commit d9876a7982d95a88666db81d1b0f394b350f8fe6 · bretton.dev/coves

+5 -5

cmd/server/main.go

···

       46
       46
        
       	}

     

       47
       47
        
       

     

       48
       48
        
       	r := chi.NewRouter()

     

       49
       49
       -
       	

     

       49
       49
       +
       

     

       50
       50
        
       	r.Use(middleware.Logger)

     

       51
       51
        
       	r.Use(middleware.Recoverer)

     

       52
       52
        
       	r.Use(middleware.RequestID)

     
···

       56
       56
        
       		Conn: db,

     

       57
       57
        
       	}), &gorm.Config{

     

       58
       58
        
       		DisableForeignKeyConstraintWhenMigrating: true,

     

       59
       59
       -
       		PrepareStmt: false,

     

       59
       59
       +
       		PrepareStmt:                              true, // Enable prepared statements for better performance

     

       60
       60
        
       	})

     

       61
       61
        
       	if err != nil {

     

       62
       62
        
       		log.Fatal("Failed to initialize GORM:", err)

     
···

       65
       65
        
       	// Initialize repositories

     

       66
       66
        
       	userRepo := postgresRepo.NewUserRepository(db)

     

       67
       67
        
       	_ = users.NewUserService(userRepo) // TODO: Use when UserRoutes is fixed

     

       68
       68
       -
       	

     

       68
       68
       +
       

     

       69
       69
        
       	// Initialize carstore for ATProto repository storage

     

       70
       70
        
       	carDirs := []string{"./data/carstore"}

     

       71
       71
        
       	repoStore, err := carstore.NewRepoStore(gormDB, carDirs)

     

       72
       72
        
       	if err != nil {

     

       73
       73
        
       		log.Fatal("Failed to initialize repo store:", err)

     

       74
       74
        
       	}

     

       75
       75
       -
       	

     

       75
       75
       +
       

     

       76
       76
        
       	repositoryRepo := postgresRepo.NewRepositoryRepo(db)

     

       77
       77
        
       	repositoryService := repository.NewService(repositoryRepo, repoStore)

     

       78
       78
        
       

     
···

       93
       93
        
       

     

       94
       94
        
       	fmt.Printf("Server starting on port %s\n", port)

     

       95
       95
        
       	log.Fatal(http.ListenAndServe(":"+port, r))

     

       96
       96
       -
       }
     

       96
       96
       +
       }

+38 -10

internal/atproto/carstore/carstore.go

···

       21
       21
        
       	// Initialize Indigo's carstore

     

       22
       22
        
       	cs, err := carstore.NewCarStore(db, carDirs)

     

       23
       23
        
       	if err != nil {

     

       24
       24
       -
       		return nil, fmt.Errorf("failed to create carstore: %w", err)

     

       24
       24
       +
       		return nil, fmt.Errorf("initializing carstore: %w", err)

     

       25
       25
        
       	}

     

       26
       26
        
       

     

       27
       27
        
       	return &CarStore{

     
···

       32
       32
        
       // ImportSlice imports a CAR file slice for a user

     

       33
       33
        
       func (c *CarStore) ImportSlice(ctx context.Context, uid models.Uid, since *string, carData []byte) (cid.Cid, error) {

     

       34
       34
        
       	rootCid, _, err := c.cs.ImportSlice(ctx, uid, since, carData)

     

       35
       35
       -
       	return rootCid, err

     

       35
       35
       +
       	if err != nil {

     

       36
       36
       +
       		return cid.Undef, fmt.Errorf("importing CAR slice for UID %d: %w", uid, err)

     

       37
       37
       +
       	}

     

       38
       38
       +
       	return rootCid, nil

     

       36
       39
        
       }

     

       37
       40
        
       

     

       38
       41
        
       // ReadUserCar reads a user's repository CAR file

     

       39
       42
        
       func (c *CarStore) ReadUserCar(ctx context.Context, uid models.Uid, sinceRev string, incremental bool, w io.Writer) error {

     

       40
       40
       -
       	return c.cs.ReadUserCar(ctx, uid, sinceRev, incremental, w)

     

       43
       43
       +
       	if err := c.cs.ReadUserCar(ctx, uid, sinceRev, incremental, w); err != nil {

     

       44
       44
       +
       		return fmt.Errorf("reading user CAR for UID %d: %w", uid, err)

     

       45
       45
       +
       	}

     

       46
       46
       +
       	return nil

     

       41
       47
        
       }

     

       42
       48
        
       

     

       43
       49
        
       // GetUserRepoHead gets the latest repository head CID for a user

     

       44
       50
        
       func (c *CarStore) GetUserRepoHead(ctx context.Context, uid models.Uid) (cid.Cid, error) {

     

       45
       45
       -
       	return c.cs.GetUserRepoHead(ctx, uid)

     

       51
       51
       +
       	head, err := c.cs.GetUserRepoHead(ctx, uid)

     

       52
       52
       +
       	if err != nil {

     

       53
       53
       +
       		return cid.Undef, fmt.Errorf("getting repo head for UID %d: %w", uid, err)

     

       54
       54
       +
       	}

     

       55
       55
       +
       	return head, nil

     

       46
       56
        
       }

     

       47
       57
        
       

     

       48
       58
        
       // CompactUserShards performs garbage collection and compaction for a user's data

     

       49
       59
        
       func (c *CarStore) CompactUserShards(ctx context.Context, uid models.Uid, aggressive bool) error {

     

       50
       60
        
       	_, err := c.cs.CompactUserShards(ctx, uid, aggressive)

     

       51
       51
       -
       	return err

     

       61
       61
       +
       	if err != nil {

     

       62
       62
       +
       		return fmt.Errorf("compacting shards for UID %d: %w", uid, err)

     

       63
       63
       +
       	}

     

       64
       64
       +
       	return nil

     

       52
       65
        
       }

     

       53
       66
        
       

     

       54
       67
        
       // WipeUserData removes all data for a user

     

       55
       68
        
       func (c *CarStore) WipeUserData(ctx context.Context, uid models.Uid) error {

     

       56
       56
       -
       	return c.cs.WipeUserData(ctx, uid)

     

       69
       69
       +
       	if err := c.cs.WipeUserData(ctx, uid); err != nil {

     

       70
       70
       +
       		return fmt.Errorf("wiping data for UID %d: %w", uid, err)

     

       71
       71
       +
       	}

     

       72
       72
       +
       	return nil

     

       57
       73
        
       }

     

       58
       74
        
       

     

       59
       75
        
       // NewDeltaSession creates a new session for writing deltas

     

       60
       76
        
       func (c *CarStore) NewDeltaSession(ctx context.Context, uid models.Uid, since *string) (*carstore.DeltaSession, error) {

     

       61
       61
       -
       	return c.cs.NewDeltaSession(ctx, uid, since)

     

       77
       77
       +
       	session, err := c.cs.NewDeltaSession(ctx, uid, since)

     

       78
       78
       +
       	if err != nil {

     

       79
       79
       +
       		return nil, fmt.Errorf("creating delta session for UID %d: %w", uid, err)

     

       80
       80
       +
       	}

     

       81
       81
       +
       	return session, nil

     

       62
       82
        
       }

     

       63
       83
        
       

     

       64
       84
        
       // ReadOnlySession creates a read-only session for reading user data

     

       65
       85
        
       func (c *CarStore) ReadOnlySession(uid models.Uid) (*carstore.DeltaSession, error) {

     

       66
       66
       -
       	return c.cs.ReadOnlySession(uid)

     

       86
       86
       +
       	session, err := c.cs.ReadOnlySession(uid)

     

       87
       87
       +
       	if err != nil {

     

       88
       88
       +
       		return nil, fmt.Errorf("creating read-only session for UID %d: %w", uid, err)

     

       89
       89
       +
       	}

     

       90
       90
       +
       	return session, nil

     

       67
       91
        
       }

     

       68
       92
        
       

     

       69
       93
        
       // Stat returns statistics about the carstore

     

       70
       94
        
       func (c *CarStore) Stat(ctx context.Context, uid models.Uid) ([]carstore.UserStat, error) {

     

       71
       71
       -
       	return c.cs.Stat(ctx, uid)

     

       72
       72
       -
       }
     

       95
       95
       +
       	stats, err := c.cs.Stat(ctx, uid)

     

       96
       96
       +
       	if err != nil {

     

       97
       97
       +
       		return nil, fmt.Errorf("getting stats for UID %d: %w", uid, err)

     

       98
       98
       +
       	}

     

       99
       99
       +
       	return stats, nil

     

       100
       100
       +
       }

+11 -11

internal/atproto/carstore/repo_store.go

···

       22
       22
        
       	// Create carstore

     

       23
       23
        
       	cs, err := NewCarStore(db, carDirs)

     

       24
       24
        
       	if err != nil {

     

       25
       25
       -
       		return nil, fmt.Errorf("failed to create carstore: %w", err)

     

       25
       25
       +
       		return nil, fmt.Errorf("creating carstore: %w", err)

     

       26
       26
        
       	}

     

       27
       27
        
       

     

       28
       28
        
       	// Create user mapping

     

       29
       29
        
       	mapping, err := NewUserMapping(db)

     

       30
       30
        
       	if err != nil {

     

       31
       31
       -
       		return nil, fmt.Errorf("failed to create user mapping: %w", err)

     

       31
       31
       +
       		return nil, fmt.Errorf("creating user mapping: %w", err)

     

       32
       32
        
       	}

     

       33
       33
        
       

     

       34
       34
        
       	return &RepoStore{

     
···

       41
       41
        
       func (rs *RepoStore) ImportRepo(ctx context.Context, did string, carData io.Reader) (cid.Cid, error) {

     

       42
       42
        
       	uid, err := rs.mapping.GetOrCreateUID(ctx, did)

     

       43
       43
        
       	if err != nil {

     

       44
       44
       -
       		return cid.Undef, fmt.Errorf("failed to get UID for DID %s: %w", did, err)

     

       44
       44
       +
       		return cid.Undef, fmt.Errorf("getting UID for DID %s: %w", did, err)

     

       45
       45
        
       	}

     

       46
       46
        
       

     

       47
       47
        
       	// Read all data from the reader

     

       48
       48
        
       	data, err := io.ReadAll(carData)

     

       49
       49
        
       	if err != nil {

     

       50
       50
       -
       		return cid.Undef, fmt.Errorf("failed to read CAR data: %w", err)

     

       50
       50
       +
       		return cid.Undef, fmt.Errorf("reading CAR data: %w", err)

     

       51
       51
        
       	}

     

       52
       52
       -
       	

     

       52
       52
       +
       

     

       53
       53
        
       	return rs.cs.ImportSlice(ctx, uid, nil, data)

     

       54
       54
        
       }

     

       55
       55
        
       

     
···

       57
       57
        
       func (rs *RepoStore) ReadRepo(ctx context.Context, did string, sinceRev string) ([]byte, error) {

     

       58
       58
        
       	uid, err := rs.mapping.GetUID(did)

     

       59
       59
        
       	if err != nil {

     

       60
       60
       -
       		return nil, fmt.Errorf("failed to get UID for DID %s: %w", did, err)

     

       60
       60
       +
       		return nil, fmt.Errorf("getting UID for DID %s: %w", did, err)

     

       61
       61
        
       	}

     

       62
       62
        
       

     

       63
       63
        
       	var buf bytes.Buffer

     

       64
       64
        
       	err = rs.cs.ReadUserCar(ctx, uid, sinceRev, false, &buf)

     

       65
       65
        
       	if err != nil {

     

       66
       66
       -
       		return nil, fmt.Errorf("failed to read repo for DID %s: %w", did, err)

     

       66
       66
       +
       		return nil, fmt.Errorf("reading repo for DID %s: %w", did, err)

     

       67
       67
        
       	}

     

       68
       68
        
       

     

       69
       69
        
       	return buf.Bytes(), nil

     
···

       73
       73
        
       func (rs *RepoStore) GetRepoHead(ctx context.Context, did string) (cid.Cid, error) {

     

       74
       74
        
       	uid, err := rs.mapping.GetUID(did)

     

       75
       75
        
       	if err != nil {

     

       76
       76
       -
       		return cid.Undef, fmt.Errorf("failed to get UID for DID %s: %w", did, err)

     

       76
       76
       +
       		return cid.Undef, fmt.Errorf("getting UID for DID %s: %w", did, err)

     

       77
       77
        
       	}

     

       78
       78
        
       

     

       79
       79
        
       	return rs.cs.GetUserRepoHead(ctx, uid)

     
···

       83
       83
        
       func (rs *RepoStore) CompactRepo(ctx context.Context, did string) error {

     

       84
       84
        
       	uid, err := rs.mapping.GetUID(did)

     

       85
       85
        
       	if err != nil {

     

       86
       86
       -
       		return fmt.Errorf("failed to get UID for DID %s: %w", did, err)

     

       86
       86
       +
       		return fmt.Errorf("getting UID for DID %s: %w", did, err)

     

       87
       87
        
       	}

     

       88
       88
        
       

     

       89
       89
        
       	return rs.cs.CompactUserShards(ctx, uid, false)

     
···

       93
       93
        
       func (rs *RepoStore) DeleteRepo(ctx context.Context, did string) error {

     

       94
       94
        
       	uid, err := rs.mapping.GetUID(did)

     

       95
       95
        
       	if err != nil {

     

       96
       96
       -
       		return fmt.Errorf("failed to get UID for DID %s: %w", did, err)

     

       96
       96
       +
       		return fmt.Errorf("getting UID for DID %s: %w", did, err)

     

       97
       97
        
       	}

     

       98
       98
        
       

     

       99
       99
        
       	return rs.cs.WipeUserData(ctx, uid)

     
···

       119
       119
        
       // GetOrCreateUID gets or creates a UID for a DID

     

       120
       120
        
       func (rs *RepoStore) GetOrCreateUID(ctx context.Context, did string) (models.Uid, error) {

     

       121
       121
        
       	return rs.mapping.GetOrCreateUID(ctx, did)

     

       122
       122
       -
       }
     

       122
       122
       +
       }

+11 -11

internal/atproto/carstore/user_mapping.go

···

       11
       11
        
       

     

       12
       12
        
       // UserMapping manages the mapping between DIDs and numeric UIDs required by Indigo's carstore

     

       13
       13
        
       type UserMapping struct {

     

       14
       14
       -
       	db        *gorm.DB

     

       15
       15
       -
       	mu        sync.RWMutex

     

       16
       16
       -
       	didToUID  map[string]models.Uid

     

       17
       17
       -
       	uidToDID  map[models.Uid]string

     

       18
       18
       -
       	nextUID   models.Uid

     

       14
       14
       +
       	db       *gorm.DB

     

       15
       15
       +
       	mu       sync.RWMutex

     

       16
       16
       +
       	didToUID map[string]models.Uid

     

       17
       17
       +
       	uidToDID map[models.Uid]string

     

       18
       18
       +
       	nextUID  models.Uid

     

       19
       19
        
       }

     

       20
       20
        
       

     

       21
       21
        
       // UserMap represents the database model for DID to UID mapping

     

       22
       22
        
       type UserMap struct {

     

       23
       23
        
       	UID       models.Uid `gorm:"primaryKey;autoIncrement"`

     

       24
       24
       -
       	DID       string     `gorm:"uniqueIndex;not null"`

     

       24
       24
       +
       	DID       string     `gorm:"column:did;uniqueIndex;not null"`

     

       25
       25
        
       	CreatedAt int64

     

       26
       26
        
       	UpdatedAt int64

     

       27
       27
        
       }

     
···

       30
       30
        
       func NewUserMapping(db *gorm.DB) (*UserMapping, error) {

     

       31
       31
        
       	// Auto-migrate the user mapping table

     

       32
       32
        
       	if err := db.AutoMigrate(&UserMap{}); err != nil {

     

       33
       33
       -
       		return nil, fmt.Errorf("failed to migrate user mapping table: %w", err)

     

       33
       33
       +
       		return nil, fmt.Errorf("migrating user mapping table: %w", err)

     

       34
       34
        
       	}

     

       35
       35
        
       

     

       36
       36
        
       	um := &UserMapping{

     
···

       42
       42
        
       

     

       43
       43
        
       	// Load existing mappings

     

       44
       44
        
       	if err := um.loadMappings(); err != nil {

     

       45
       45
       -
       		return nil, fmt.Errorf("failed to load user mappings: %w", err)

     

       45
       45
       +
       		return nil, fmt.Errorf("loading user mappings: %w", err)

     

       46
       46
        
       	}

     

       47
       47
        
       

     

       48
       48
        
       	return um, nil

     
···

       52
       52
        
       func (um *UserMapping) loadMappings() error {

     

       53
       53
        
       	var mappings []UserMap

     

       54
       54
        
       	if err := um.db.Find(&mappings).Error; err != nil {

     

       55
       55
       -
       		return err

     

       55
       55
       +
       		return fmt.Errorf("querying user mappings: %w", err)

     

       56
       56
        
       	}

     

       57
       57
        
       

     

       58
       58
        
       	um.mu.Lock()

     
···

       93
       93
        
       	}

     

       94
       94
        
       

     

       95
       95
        
       	if err := um.db.Create(userMap).Error; err != nil {

     

       96
       96
       -
       		return 0, fmt.Errorf("failed to create user mapping: %w", err)

     

       96
       96
       +
       		return 0, fmt.Errorf("creating user mapping for DID %s: %w", did, err)

     

       97
       97
        
       	}

     

       98
       98
        
       

     

       99
       99
        
       	um.didToUID[did] = userMap.UID

     
···

       124
       124
        
       		return "", fmt.Errorf("DID not found for UID: %d", uid)

     

       125
       125
        
       	}

     

       126
       126
        
       	return did, nil

     

       127
       127
       -
       }
     

       127
       127
       +
       }

+20

internal/core/repository/constants.go

···

       1
       1
       +
       package repository

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"github.com/ipfs/go-cid"

     

       5
       5
       +
       	"github.com/multiformats/go-multihash"

     

       6
       6
       +
       )

     

       7
       7
       +
       

     

       8
       8
       +
       var (

     

       9
       9
       +
       	// PlaceholderCID is used for empty repositories that have no content yet

     

       10
       10
       +
       	// This allows us to maintain consistency in the repository record

     

       11
       11
       +
       	// while the actual CAR data is created when records are added

     

       12
       12
       +
       	PlaceholderCID cid.Cid

     

       13
       13
       +
       )

     

       14
       14
       +
       

     

       15
       15
       +
       func init() {

     

       16
       16
       +
       	// Initialize the placeholder CID once at startup

     

       17
       17
       +
       	emptyData := []byte("empty")

     

       18
       18
       +
       	mh, _ := multihash.Sum(emptyData, multihash.SHA2_256, -1)

     

       19
       19
       +
       	PlaceholderCID = cid.NewCidV1(cid.Raw, mh)

     

       20
       20
       +
       }

+28 -35

internal/core/repository/service.go

···

       9
       9
        
       

     

       10
       10
        
       	"Coves/internal/atproto/carstore"

     

       11
       11
        
       	"github.com/ipfs/go-cid"

     

       12
       12
       -
       	"github.com/multiformats/go-multihash"

     

       13
       12
        
       )

     

       14
       13
        
       

     

       15
       14
        
       // Service implements the RepositoryService interface using Indigo's carstore

     

       16
       15
        
       type Service struct {

     

       17
       17
       -
       	repo         RepositoryRepository

     

       18
       18
       -
       	repoStore    *carstore.RepoStore

     

       19
       19
       -
       	signingKeys  map[string]interface{} // DID -> signing key

     

       16
       16
       +
       	repo        RepositoryRepository

     

       17
       17
       +
       	repoStore   *carstore.RepoStore

     

       18
       18
       +
       	signingKeys map[string]interface{} // DID -> signing key

     

       20
       19
        
       }

     

       21
       20
        
       

     

       22
       21
        
       // NewService creates a new repository service using carstore

     
···

       38
       37
        
       	// Check if repository already exists

     

       39
       38
        
       	existing, err := s.repo.GetByDID(did)

     

       40
       39
        
       	if err != nil {

     

       41
       41
       -
       		return nil, fmt.Errorf("failed to check existing repository: %w", err)

     

       40
       40
       +
       		return nil, fmt.Errorf("checking existing repository: %w", err)

     

       42
       41
        
       	}

     

       43
       42
        
       	if existing != nil {

     

       44
       43
        
       		return nil, fmt.Errorf("repository already exists for DID: %s", did)

     
···

       47
       46
        
       	// For now, just create the user mapping without importing CAR data

     

       48
       47
        
       	// The actual repository data will be created when records are added

     

       49
       48
        
       	ctx := context.Background()

     

       50
       50
       -
       	

     

       49
       49
       +
       

     

       51
       50
        
       	// Ensure user mapping exists

     

       52
       51
        
       	_, err = s.repoStore.GetOrCreateUID(ctx, did)

     

       53
       52
        
       	if err != nil {

     

       54
       54
       -
       		return nil, fmt.Errorf("failed to create user mapping: %w", err)

     

       53
       53
       +
       		return nil, fmt.Errorf("creating user mapping: %w", err)

     

       55
       54
        
       	}

     

       56
       56
       -
       	

     

       57
       55
        
       

     

       58
       58
       -
       	// Create a placeholder CID for the empty repository

     

       59
       59
       -
       	emptyData := []byte("empty")

     

       60
       60
       -
       	mh, _ := multihash.Sum(emptyData, multihash.SHA2_256, -1)

     

       61
       61
       -
       	placeholderCID := cid.NewCidV1(cid.Raw, mh)

     

       56
       56
       +
       	// Use placeholder CID for the empty repository

     

       62
       57
        
       

     

       63
       58
        
       	// Create repository record

     

       64
       59
        
       	repository := &Repository{

     

       65
       60
        
       		DID:         did,

     

       66
       66
       -
       		HeadCID:     placeholderCID,

     

       61
       61
       +
       		HeadCID:     PlaceholderCID,

     

       67
       62
        
       		Revision:    "rev-0",

     

       68
       63
        
       		RecordCount: 0,

     

       69
       64
        
       		StorageSize: 0,

     
···

       73
       68
        
       

     

       74
       69
        
       	// Save to database

     

       75
       70
        
       	if err := s.repo.Create(repository); err != nil {

     

       76
       76
       -
       		return nil, fmt.Errorf("failed to save repository: %w", err)

     

       71
       71
       +
       		return nil, fmt.Errorf("saving repository: %w", err)

     

       77
       72
        
       	}

     

       78
       73
        
       

     

       79
       74
        
       	return repository, nil

     
···

       83
       78
        
       func (s *Service) GetRepository(did string) (*Repository, error) {

     

       84
       79
        
       	repo, err := s.repo.GetByDID(did)

     

       85
       80
        
       	if err != nil {

     

       86
       86
       -
       		return nil, fmt.Errorf("failed to get repository: %w", err)

     

       81
       81
       +
       		return nil, fmt.Errorf("getting repository: %w", err)

     

       87
       82
        
       	}

     

       88
       83
        
       	if repo == nil {

     

       89
       84
        
       		return nil, fmt.Errorf("repository not found for DID: %s", did)

     
···

       102
       97
        
       func (s *Service) DeleteRepository(did string) error {

     

       103
       98
        
       	// Delete from carstore

     

       104
       99
        
       	if err := s.repoStore.DeleteRepo(context.Background(), did); err != nil {

     

       105
       105
       -
       		return fmt.Errorf("failed to delete repo from carstore: %w", err)

     

       100
       100
       +
       		return fmt.Errorf("deleting repo from carstore: %w", err)

     

       106
       101
        
       	}

     

       107
       102
        
       

     

       108
       103
        
       	// Delete from database

     

       109
       104
        
       	if err := s.repo.Delete(did); err != nil {

     

       110
       110
       -
       		return fmt.Errorf("failed to delete repository: %w", err)

     

       105
       105
       +
       		return fmt.Errorf("deleting repository from database: %w", err)

     

       111
       106
        
       	}

     

       112
       107
        
       

     

       113
       108
        
       	return nil

     
···

       118
       113
        
       	// First check if repository exists in our database

     

       119
       114
        
       	repo, err := s.repo.GetByDID(did)

     

       120
       115
        
       	if err != nil {

     

       121
       121
       -
       		return nil, fmt.Errorf("failed to get repository: %w", err)

     

       116
       116
       +
       		return nil, fmt.Errorf("getting repository: %w", err)

     

       122
       117
        
       	}

     

       123
       118
        
       	if repo == nil {

     

       124
       119
        
       		return nil, fmt.Errorf("repository not found for DID: %s", did)

     
···

       132
       127
        
       		// Check for the specific error pattern from Indigo's carstore

     

       133
       128
        
       		errMsg := err.Error()

     

       134
       129
        
       		if strings.Contains(errMsg, "no data found for user") ||

     

       135
       135
       -
       		   strings.Contains(errMsg, "user not found") {

     

       130
       130
       +
       			strings.Contains(errMsg, "user not found") {

     

       136
       131
        
       			return []byte{}, nil

     

       137
       132
        
       		}

     

       138
       138
       -
       		return nil, fmt.Errorf("failed to export repository: %w", err)

     

       133
       133
       +
       		return nil, fmt.Errorf("exporting repository: %w", err)

     

       139
       134
        
       	}

     

       140
       135
        
       

     

       141
       136
        
       	return carData, nil

     
···

       144
       139
        
       // ImportRepository imports a repository from a CAR file

     

       145
       140
        
       func (s *Service) ImportRepository(did string, carData []byte) error {

     

       146
       141
        
       	ctx := context.Background()

     

       147
       147
       -
       	

     

       142
       142
       +
       

     

       148
       143
        
       	// If empty CAR data, just create user mapping

     

       149
       144
        
       	if len(carData) == 0 {

     

       150
       145
        
       		_, err := s.repoStore.GetOrCreateUID(ctx, did)

     

       151
       146
        
       		if err != nil {

     

       152
       152
       -
       			return fmt.Errorf("failed to create user mapping: %w", err)

     

       147
       147
       +
       			return fmt.Errorf("creating user mapping: %w", err)

     

       153
       148
        
       		}

     

       154
       154
       -
       		

     

       155
       155
       -
       		// Create placeholder CID

     

       156
       156
       -
       		emptyData := []byte("empty")

     

       157
       157
       -
       		mh, _ := multihash.Sum(emptyData, multihash.SHA2_256, -1)

     

       158
       158
       -
       		headCID := cid.NewCidV1(cid.Raw, mh)

     

       159
       159
       -
       		

     

       149
       149
       +
       

     

       150
       150
       +
       		// Use placeholder CID for empty repository

     

       151
       151
       +
       		headCID := PlaceholderCID

     

       152
       152
       +
       

     

       160
       153
        
       		// Create repository record

     

       161
       154
        
       		repo := &Repository{

     

       162
       155
        
       			DID:         did,

     
···

       168
       161
        
       			UpdatedAt:   time.Now(),

     

       169
       162
        
       		}

     

       170
       163
        
       		if err := s.repo.Create(repo); err != nil {

     

       171
       171
       -
       			return fmt.Errorf("failed to create repository: %w", err)

     

       164
       164
       +
       			return fmt.Errorf("creating repository: %w", err)

     

       172
       165
        
       		}

     

       173
       166
        
       		return nil

     

       174
       167
        
       	}

     

       175
       175
       -
       	

     

       168
       168
       +
       

     

       176
       169
        
       	// Import non-empty CAR into carstore

     

       177
       170
        
       	headCID, err := s.repoStore.ImportRepo(ctx, did, bytes.NewReader(carData))

     

       178
       171
        
       	if err != nil {

     

       179
       179
       -
       		return fmt.Errorf("failed to import repository: %w", err)

     

       172
       172
       +
       		return fmt.Errorf("importing repository: %w", err)

     

       180
       173
        
       	}

     

       181
       174
        
       

     

       182
       175
        
       	// Create or update repository record

     

       183
       176
        
       	repo, err := s.repo.GetByDID(did)

     

       184
       177
        
       	if err != nil {

     

       185
       185
       -
       		return fmt.Errorf("failed to get repository: %w", err)

     

       178
       178
       +
       		return fmt.Errorf("getting repository: %w", err)

     

       186
       179
        
       	}

     

       187
       180
        
       

     

       188
       181
        
       	if repo == nil {

     
···

       197
       190
        
       			UpdatedAt:   time.Now(),

     

       198
       191
        
       		}

     

       199
       192
        
       		if err := s.repo.Create(repo); err != nil {

     

       200
       200
       -
       			return fmt.Errorf("failed to create repository: %w", err)

     

       193
       193
       +
       			return fmt.Errorf("creating repository: %w", err)

     

       201
       194
        
       		}

     

       202
       195
        
       	} else {

     

       203
       196
        
       		// Update existing repository

     

       204
       197
        
       		repo.HeadCID = headCID

     

       205
       198
        
       		repo.UpdatedAt = time.Now()

     

       206
       199
        
       		if err := s.repo.Update(repo); err != nil {

     

       207
       207
       -
       			return fmt.Errorf("failed to update repository: %w", err)

     

       200
       200
       +
       			return fmt.Errorf("updating repository: %w", err)

     

       208
       201
        
       		}

     

       209
       202
        
       	}

     

       210
       203
        
       

     
···

       247
       240
        
       

     

       248
       241
        
       func (s *Service) ListCommits(did string, limit int, cursor string) ([]*Commit, string, error) {

     

       249
       242
        
       	return nil, "", fmt.Errorf("commit operations not yet implemented for carstore")

     

       250
       250
       -
       }
     

       243
       243
       +
       }

+17 -9

internal/core/repository/service_test.go

···

       10
       10
        
       	"Coves/internal/atproto/carstore"

     

       11
       11
        
       	"Coves/internal/core/repository"

     

       12
       12
        
       	"Coves/internal/db/postgres"

     

       13
       13
       -
       	

     

       13
       13
       +
       

     

       14
       14
        
       	"github.com/ipfs/go-cid"

     

       15
       15
        
       	_ "github.com/lib/pq"

     

       16
       16
        
       	"github.com/pressly/goose/v3"

     
···

       44
       44
        
       	// Connect with GORM using a fresh connection

     

       45
       45
        
       	gormDB, err := gorm.Open(postgresDriver.Open(dbURL), &gorm.Config{

     

       46
       46
        
       		DisableForeignKeyConstraintWhenMigrating: true,

     

       47
       47
       -
       		PrepareStmt: false,

     

       47
       47
       +
       		PrepareStmt:                              false,

     

       48
       48
        
       	})

     

       49
       49
        
       	if err != nil {

     

       50
       50
        
       		t.Fatalf("Failed to create GORM connection: %v", err)

     
···

       58
       58
        
       		gormDB.Exec("DELETE FROM records")

     

       59
       59
        
       		gormDB.Exec("DELETE FROM user_maps")

     

       60
       60
        
       		gormDB.Exec("DELETE FROM car_shards")

     

       61
       61
       +
       		gormDB.Exec("DELETE FROM block_refs")

     

       62
       62
       +
       

     

       63
       63
       +
       		// Close GORM connection

     

       64
       64
       +
       		if sqlGormDB, err := gormDB.DB(); err == nil {

     

       65
       65
       +
       			sqlGormDB.Close()

     

       66
       66
       +
       		}

     

       67
       67
       +
       

     

       68
       68
       +
       		// Close original SQL connection

     

       61
       69
        
       		sqlDB.Close()

     

       62
       70
        
       	}

     

       63
       71
        
       

     
···

       88
       96
        
       

     

       89
       97
        
       	// Test DID

     

       90
       98
        
       	testDID := "did:plc:testuser123"

     

       91
       91
       -
       	

     

       99
       99
       +
       

     

       92
       100
        
       	// Set signing key

     

       93
       101
        
       	service.SetSigningKey(testDID, &mockSigningKey{})

     

       94
       102
        
       

     
···

       135
       143
        
       		t.Fatalf("Failed to create temp dir: %v", err)

     

       136
       144
        
       	}

     

       137
       145
        
       	defer os.RemoveAll(tempDir)

     

       138
       138
       -
       	

     

       146
       146
       +
       

     

       139
       147
        
       	// Log the temp directory for debugging

     

       140
       148
        
       	t.Logf("Using carstore directory: %s", tempDir)

     

       141
       149
        
       

     
···

       158
       166
        
       		t.Fatalf("Failed to create repository 1: %v", err)

     

       159
       167
        
       	}

     

       160
       168
        
       	t.Logf("Created repository with HeadCID: %s", repo1.HeadCID)

     

       161
       161
       -
       	

     

       169
       169
       +
       

     

       162
       170
        
       	// Check what's in the database

     

       163
       171
        
       	var userMapCount int

     

       164
       172
        
       	gormDB.Raw("SELECT COUNT(*) FROM user_maps").Scan(&userMapCount)

     

       165
       173
        
       	t.Logf("User maps count: %d", userMapCount)

     

       166
       166
       -
       	

     

       174
       174
       +
       

     

       167
       175
        
       	var carShardCount int

     

       168
       176
        
       	gormDB.Raw("SELECT COUNT(*) FROM car_shards").Scan(&carShardCount)

     

       169
       177
        
       	t.Logf("Car shards count: %d", carShardCount)

     

       170
       170
       -
       	

     

       178
       178
       +
       

     

       171
       179
        
       	// Check block_refs too

     

       172
       180
        
       	var blockRefCount int

     

       173
       181
        
       	gormDB.Raw("SELECT COUNT(*) FROM block_refs").Scan(&blockRefCount)

     
···

       333
       341
        
       func TestRepositoryService_MockedComponents(t *testing.T) {

     

       334
       342
        
       	// Use the existing mock repository from the old test file

     

       335
       343
        
       	_ = NewMockRepositoryRepository()

     

       336
       336
       -
       	

     

       344
       344
       +
       

     

       337
       345
        
       	// For unit testing without real carstore, we would need to mock RepoStore

     

       338
       346
        
       	// For now, this demonstrates the structure

     

       339
       347
        
       	t.Skip("Mocked carstore tests would require creating mock RepoStore interface")

     
···

       502
       510
        
       	}

     

       503
       511
        
       

     

       504
       512
        
       	return records[start:end], nil

     

       505
       505
       -
       }
     

       513
       513
       +
       }

internal/db/migrations/003_update_for_carstore.sql

···

       1
       1
        
       -- +goose Up

     

       2
       2
        
       -- +goose StatementBegin

     

       3
       3
        
       

     

       4
       4
       +
       -- WARNING: This migration removes blob storage tables. 

     

       5
       5
       +
       -- Ensure all blob data has been migrated to carstore before running this migration.

     

       6
       6
       +
       -- This migration is NOT reversible if blob data exists!

     

       7
       7
       +
       

     

       4
       8
        
       -- Remove the value column from records table since blocks are now stored in filesystem

     

       5
       9
        
       ALTER TABLE records DROP COLUMN IF EXISTS value;

     

       6
       10
        
       

     

       7
       11
        
       -- Drop blob-related tables since FileCarStore handles block storage

     

       12
       12
       +
       -- WARNING: This will permanently delete all blob data!

     

       8
       13
        
       DROP TABLE IF EXISTS blob_refs;

     

       9
       14
        
       DROP TABLE IF EXISTS blobs;

     

       10
       15

+32

internal/db/migrations/005_add_user_maps_indices.sql

···

       1
       1
       +
       -- +goose Up

     

       2
       2
       +
       -- +goose StatementBegin

     

       3
       3
       +
       

     

       4
       4
       +
       -- Note: The user_maps table is created by GORM's AutoMigrate in the carstore package

     

       5
       5
       +
       -- Only add indices if the table exists

     

       6
       6
       +
       DO $$

     

       7
       7
       +
       BEGIN

     

       8
       8
       +
           -- Check if user_maps table exists

     

       9
       9
       +
           IF EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'user_maps') THEN

     

       10
       10
       +
               -- Check if column exists before creating index

     

       11
       11
       +
               IF EXISTS (SELECT 1 FROM information_schema.columns WHERE table_name = 'user_maps' AND column_name = 'did') THEN

     

       12
       12
       +
                   -- Explicit column name specified in GORM tag

     

       13
       13
       +
                   CREATE INDEX IF NOT EXISTS idx_user_maps_did ON user_maps(did);

     

       14
       14
       +
               END IF;

     

       15
       15
       +
               

     

       16
       16
       +
               -- Add index on created_at if column exists

     

       17
       17
       +
               IF EXISTS (SELECT 1 FROM information_schema.columns WHERE table_name = 'user_maps' AND column_name = 'created_at') THEN

     

       18
       18
       +
                   CREATE INDEX IF NOT EXISTS idx_user_maps_created_at ON user_maps(created_at);

     

       19
       19
       +
               END IF;

     

       20
       20
       +
           END IF;

     

       21
       21
       +
       END $$;

     

       22
       22
       +
       

     

       23
       23
       +
       -- +goose StatementEnd

     

       24
       24
       +
       

     

       25
       25
       +
       -- +goose Down

     

       26
       26
       +
       -- +goose StatementBegin

     

       27
       27
       +
       

     

       28
       28
       +
       -- Remove indices if they exist

     

       29
       29
       +
       DROP INDEX IF EXISTS idx_user_maps_did;

     

       30
       30
       +
       DROP INDEX IF EXISTS idx_user_maps_created_at;

     

       31
       31
       +
       

     

       32
       32
       +
       -- +goose StatementEnd