commit 74e21978e9ca4c8e15d5cab42346cdadd174c742 · edavis.dev/monarch

+1 -1

cmd/monarch/backfill.go

···

       11
       11
        
       		RelayHost:             "https://bsky.network",

     

       12
       12
        
       	}

     

       13
       13
        
       

     

       14
       14
       -
       	return backfill.NewBackfiller("backfiller", store, h.HandleUpsert, h.HandleUpsert, h.HandleDelete, opts)

     

       14
       14
       +
       	return backfill.NewBackfiller("backfiller", store, h.HandleCreate, h.HandleUpdate, h.HandleDelete, opts)

     

       15
       15
        
       }

+46 -8

cmd/monarch/handlers.go

···

       11
       11
        
       	"tangled.sh/edavis.dev/monarch/models"

     

       12
       12
        
       )

     

       13
       13
        
       

     

       14
       14
       +
       type Action int

     

       15
       15
       +
       

     

       16
       16
       +
       const (

     

       17
       17
       +
       	ActionCreate Action = iota

     

       18
       18
       +
       	ActionUpdate

     

       19
       19
       +
       )

     

       20
       20
       +
       

     

       14
       21
        
       type HandlerService struct {

     

       15
       22
        
       	store *gorm.DB

     

       16
       23
        
       }

     
···

       65
       72
        
       	}

     

       66
       73
        
       }

     

       67
       74
        
       

     

       75
       75
       +
       type helper struct {

     

       76
       76
       +
       	db *gorm.DB

     

       77
       77
       +
       	uri syntax.ATURI

     

       78
       78
       +
       	record []byte

     

       79
       79
       +
       	action Action

     

       80
       80
       +
       }

     

       81
       81
       +
       

     

       82
       82
       +
       func NewHelper(db *gorm.DB, uri syntax.ATURI, record []byte, action Action) *helper {

     

       83
       83
       +
       	return &helper{db, uri, record, action}

     

       84
       84
       +
       }

     

       85
       85
       +
       

     

       86
       86
       +
       func upsertRecord[T any](maker func(syntax.ATURI, []byte) T, opts *helper) error {

     

       87
       87
       +
       	obj := maker(opts.uri, opts.record)

     

       88
       88
       +
       	switch opts.action {

     

       89
       89
       +
       	case ActionCreate:

     

       90
       90
       +
       		if err := opts.db.Create(obj).Error; err != nil {

     

       91
       91
       +
       			return fmt.Errorf("error inserting %s record: %w", opts.uri.Collection(), err)

     

       92
       92
       +
       		}

     

       93
       93
       +
       	case ActionUpdate:

     

       94
       94
       +
       		if err := opts.db.Save(obj).Error; err != nil {

     

       95
       95
       +
       			return fmt.Errorf("error updating %s record: %w", opts.uri.Collection(), err)

     

       96
       96
       +
       		}

     

       97
       97
       +
       	}

     

       98
       98
       +
       	return nil

     

       99
       99
       +
       }

     

       100
       100
       +
       

     

       68
       101
        
       // handles both creates and updates

     

       69
       69
       -
       func (hs *HandlerService) HandleUpsert(ctx context.Context, repo string, rev string, path string, rec *[]byte, cid *cid.Cid) error {

     

       102
       102
       +
       func (hs *HandlerService) HandleUpsert(ctx context.Context, repo string, rev string, path string, rec *[]byte, cid *cid.Cid, action Action) error {

     

       70
       103
        
       	uri, err := syntax.ParseATURI(fmt.Sprintf("at://%s/%s", repo, path))

     

       71
       104
        
       	if err != nil {

     

       72
       105
        
       		return fmt.Errorf("error parsing at-uri: %w", err)

     

       73
       106
        
       	}

     

       107
       107
       +
       

     

       108
       108
       +
       	opts := NewHelper(hs.store, uri, *rec, action)

     

       74
       109
        
       

     

       75
       110
        
       	switch uri.Collection() {

     

       76
       111
        
       	case syntax.NSID("app.bsky.actor.profile"):

     
···

       116
       151
        
       			return nil

     

       117
       152
        
       		}

     

       118
       153
        
       

     

       119
       119
       -
       		db := hs.store.Session(&gorm.Session{DryRun: true})

     

       120
       120
       -
       		repost := models.NewFeedRepost(uri, *rec)

     

       121
       121
       -
       		// stmt := db.Where(models.FeedRepost{ID: string(uri)}).Assign(repost).FirstOrCreate(&models.FeedRepost{}).Statement

     

       122
       122
       -
       		stmt := db.Create(repost).Statement

     

       123
       123
       -
       

     

       124
       124
       -
       		slog.Info("repost sql statement", "sql", stmt.SQL.String(), "vars", stmt.Vars)

     

       125
       125
       -
       

     

       126
       154
        
       		// if err := hs.store.Where(models.FeedRepost{ID: string(uri)}).Assign(repost).FirstOrCreate(&models.FeedRepost{}).Error; err != nil {

     

       127
       155
        
       		// 	return fmt.Errorf("error upserting feed repost: %w", err)

     

       128
       156
        
       		// }

     

       157
       157
       +
       

     

       158
       158
       +
       		return upsertRecord(models.NewFeedRepost, opts)

     

       129
       159
        
       

     

       130
       160
        
       	case syntax.NSID("app.bsky.feed.threadgate"):

     

       131
       161
        
       		threadgate := models.NewFeedThreadgate(uri, *rec)

     
···

       189
       219
        
       	}

     

       190
       220
        
       

     

       191
       221
        
       	return nil

     

       222
       222
       +
       }

     

       223
       223
       +
       

     

       224
       224
       +
       func (hs *HandlerService) HandleCreate(ctx context.Context, repo string, rev string, path string, rec *[]byte, cid *cid.Cid) error {

     

       225
       225
       +
       	return hs.HandleUpsert(ctx, repo, rev, path, rec, cid, ActionCreate)

     

       226
       226
       +
       }

     

       227
       227
       +
       

     

       228
       228
       +
       func (hs *HandlerService) HandleUpdate(ctx context.Context, repo string, rev string, path string, rec *[]byte, cid *cid.Cid) error {

     

       229
       229
       +
       	return hs.HandleUpsert(ctx, repo, rev, path, rec, cid, ActionUpdate)

     

       192
       230
        
       }

     

       193
       231
        
       

     

       194
       232
        
       func (hs *HandlerService) HandleDelete(ctx context.Context, repo string, rev string, path string) error {