commit fcc6236396f4406c1d2b037497a10f057e00f873 · edavis.dev/monarch

+2 -1

cmd/monarch/census.go

···

       36
       36
        
       		return

     

       37
       37
        
       	}

     

       38
       38
        
       

     

       39
       39
       +
       	jmstore.GetOrCreateJob(ctx, "did:plc:4nsduwlpivpuur4mqkbfvm6a", backfill.StateEnqueued)

     

       40
       40
       +
       

     

       39
       41
        
       	curs, _ := cs.cursor.Get("repos")

     

       40
       42
        
       	for {

     

       41
       43
        
       		select {

     

       42
       44
        
       		case <-ctx.Done():

     

       43
       45
        
       			slog.Info("stopping repo census")

     

       44
       46
        
       			return

     

       45
       45
       -
       		default:

     

       46
       47
        
       		}

     

       47
       48
        
       

     

       48
       49
        
       		res, err := atproto.SyncListRepos(ctx, xrpcc, curs, 1000)

+16 -3

cmd/monarch/handlers.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"context"

     

       5
       5
        
       	"fmt"

     

       6
       6
       +
       	"log/slog"

     

       6
       7
        
       

     

       7
       8
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       8
       9
        
       	"github.com/ipfs/go-cid"

     
···

       109
       110
        
       		}

     

       110
       111
        
       

     

       111
       112
        
       	case syntax.NSID("app.bsky.feed.repost"):

     

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

     

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

     

       114
       114
       -
       			return fmt.Errorf("error upserting feed repost: %w", err)

     

       113
       113
       +
       		if uri.RecordKey() == "3lvhrfzuzb32k" || uri.RecordKey() == "3lvcmas2cw32k" {

     

       114
       114
       +
       			slog.Info("got repost", "uri", uri)

     

       115
       115
       +
       		} else {

     

       116
       116
       +
       			return nil

     

       115
       117
        
       		}

     

       118
       118
       +
       

     

       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
       126
       +
       		// if err := hs.store.Where(models.FeedRepost{ID: string(uri)}).Assign(repost).FirstOrCreate(&models.FeedRepost{}).Error; err != nil {

     

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

     

       128
       128
       +
       		// }

     

       116
       129
        
       

     

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

     

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

+2 -1

cmd/monarch/main.go

···

       61
       61
        
       	rsc := events.RepoStreamCallbacks{

     

       62
       62
        
       		RepoCommit: func(evt *comatproto.SyncSubscribeRepos_Commit) error {

     

       63
       63
        
       			app.cursor.SetFirehoseCursor(evt.Seq)

     

       64
       64
       -
       			return app.backfill.HandleEvent(ctx, evt)

     

       64
       64
       +
       			//return app.backfill.HandleEvent(ctx, evt)

     

       65
       65
       +
       			return nil

     

       65
       66
        
       		},

     

       66
       67
        
       		// TODO account

     

       67
       68
        
       		// TODO identity

+18 -2

models/feed_repost.go

···

       13
       13
        
       	ID string `gorm:"primaryKey"`

     

       14
       14
        
       

     

       15
       15
        
       	CreatedAt string

     

       16
       16
       -
       	Subject   *StrongRef `gorm:"embedded;embeddedPrefix:subject_"`

     

       17
       17
       -
       	Via       *StrongRef `gorm:"embedded;embeddedPrefix:via_"`

     

       16
       16
       +
       

     

       17
       17
       +
       	Subject *StrongRef `gorm:"embedded;embeddedPrefix:subject_"`

     

       18
       18
       +
       	Via     *StrongRef `gorm:"embedded;embeddedPrefix:via_"`

     

       19
       19
       +
       

     

       20
       20
       +
       	// SubjectUri string

     

       21
       21
       +
       	// ViaUri     string

     

       18
       22
        
       

     

       19
       23
        
       	AutoCreatedAt time.Time `gorm:"autoCreateTime"`

     

       20
       24
        
       	AutoUpdatedAt time.Time `gorm:"autoUpdateTime"`

     
···

       26
       30
        
       		slog.Error("could not unmarshal feed repost CBOR", "err", err)

     

       27
       31
        
       		return nil

     

       28
       32
        
       	}

     

       33
       33
       +
       

     

       34
       34
       +
       	slog.Info("repost debug", "out", out)

     

       29
       35
        
       

     

       30
       36
        
       	repost := FeedRepost{

     

       31
       37
        
       		ID:        string(uri),

     
···

       33
       39
        
       	}

     

       34
       40
        
       

     

       35
       41
        
       	if out.Subject != nil {

     

       42
       42
       +
       		slog.Info("out.Subject is not nil")

     

       36
       43
        
       		repost.Subject = &StrongRef{

     

       37
       44
        
       			Uri: out.Subject.Uri,

     

       38
       45
        
       			Cid: out.Subject.Cid,

     

       39
       46
        
       		}

     

       47
       47
       +
       		// repost.SubjectUri = out.Subject.Uri

     

       48
       48
       +
       	} else {

     

       49
       49
       +
       		slog.Info("out.Subject is nil")

     

       40
       50
        
       	}

     

       41
       51
        
       

     

       42
       52
        
       	if out.Via != nil {

     

       53
       53
       +
       		slog.Info("out.Via is not nil")

     

       43
       54
        
       		repost.Via = &StrongRef{

     

       44
       55
        
       			Uri: out.Via.Uri,

     

       45
       56
        
       			Cid: out.Via.Cid,

     

       46
       57
        
       		}

     

       58
       58
       +
       		// repost.ViaUri = out.Via.Uri

     

       59
       59
       +
       	} else {

     

       60
       60
       +
       		slog.Info("out.Via is nil")

     

       47
       61
        
       	}

     

       62
       62
       +
       

     

       63
       63
       +
       	slog.Info("final repost", "repost", repost)

     

       48
       64
        
       

     

       49
       65
        
       	return &repost

     

       50
       66
        
       }