commit 4040f147d5e67aecde8c2bb1dd48b4fed3a4f0b8 · ptr.pet/bsky-repost-likes

+2 -5

jetstream.go

···

       3
        
       import (

     

       4
        
       	"context"

     

       5
        
       	"log/slog"

     

       6
       -
       	"time"

     

       7
        
       

     

       8
        
       	"github.com/bluesky-social/jetstream/pkg/client"

     

       9
        
       	"github.com/bluesky-social/jetstream/pkg/client/schedulers/sequential"

     
···

       33
        
       	config.Compress = true

     

       34
        
       	config.WantedCollections = opts.WantedCollections

     

       35
        
       	config.WantedDids = opts.WantedDIDs

     

       36
       -
       	config.RequireHello = len(config.WantedDids) == 0

     

       37
        
       

     

       38
        
       	scheduler := sequential.NewScheduler(name, logger, handleEvent)

     

       39
        
       

     
···

       44
        
       	}

     

       45
        
       

     

       46
        
       	startFn := func() error {

     

       47
       -
       		cursor := time.Now().UnixMicro()

     

       48
       -
       

     

       49
        
       		logger.Info("starting jetstream client", "name", name, "collections", opts.WantedCollections, "wanted_dids", len(opts.WantedDIDs))

     

       50
       -
       		if err := c.ConnectAndRead(ctx, &cursor); err != nil {

     

       51
        
       			logger.Error("jetstream client failed", "name", name, "error", err)

     

       52
        
       			return err

     

       53
        
       		}

···

       3
        
       import (

     

       4
        
       	"context"

     

       5
        
       	"log/slog"

     

       0
        
       
     

       6
        
       

     

       7
        
       	"github.com/bluesky-social/jetstream/pkg/client"

     

       8
        
       	"github.com/bluesky-social/jetstream/pkg/client/schedulers/sequential"

     
···

       32
        
       	config.Compress = true

     

       33
        
       	config.WantedCollections = opts.WantedCollections

     

       34
        
       	config.WantedDids = opts.WantedDIDs

     

       35
       +
       	config.RequireHello = false

     

       36
        
       

     

       37
        
       	scheduler := sequential.NewScheduler(name, logger, handleEvent)

     

       38
        
       

     
···

       43
        
       	}

     

       44
        
       

     

       45
        
       	startFn := func() error {

     

       0
        
       
     

       0
        
       
     

       46
        
       		logger.Info("starting jetstream client", "name", name, "collections", opts.WantedCollections, "wanted_dids", len(opts.WantedDIDs))

     

       47
       +
       		if err := c.ConnectAndRead(ctx, nil); err != nil {

     

       48
        
       			logger.Error("jetstream client failed", "name", name, "error", err)

     

       49
        
       			return err

     

       50
        
       		}

+129 -117

main.go

···

       8
        
       	"net/http"

     

       9
        
       

     

       10
        
       	"github.com/bluesky-social/indigo/api/bsky"

     

       0
        
       
     

       11
        
       	"github.com/bluesky-social/indigo/xrpc"

     

       12
        
       	"github.com/bluesky-social/jetstream/pkg/client"

     

       13
        
       	"github.com/bluesky-social/jetstream/pkg/models"

     
···

       22
        
       const ListenTypeFollows = "follows"

     

       23
        
       

     

       24
        
       type SubscriberData struct {

     

       25
       -
       	DID        string

     

       26
        
       	Conn       *websocket.Conn

     

       27
        
       	ListenType string

     

       28
       -
       	ListenTo   Set[string]

     

       29
       -
       	Reposts    Set[string]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       30
        
       }

     

       31
        
       

     

       32
        
       type NotificationMessage struct {

     

       33
       -
       	Liked     bool   `json:"liked"`

     

       34
       -
       	ByDid     string `json:"did"`

     

       35
       -
       	RepostURI string `json:"repost_uri"`

     

       36
        
       }

     

       37
        
       

     

       38
        
       type SubscriberMessage struct {

     
···

       41
        
       }

     

       42
        
       

     

       43
        
       type SubscriberUpdateListenTo struct {

     

       44
       -
       	ListenTo []string `json:"listen_to"`

     

       45
        
       }

     

       46
        
       

     

       47
        
       var (

     

       48
        
       	// storing the subscriber data in both Should Be Fine

     

       49
        
       	// we dont modify subscriber data at the same time in two places

     

       50
       -
       	subscribers = hashmap.New[string, *SubscriberData]()

     

       51
       -
       	listeningTo = hashmap.New[string, *hashmap.Map[string, *SubscriberData]]()

     

       52
        
       

     

       53
        
       	likeStream       *client.Client

     

       54
        
       	subscriberStream *client.Client

     
···

       64
        
       

     

       65
        
       func getSubscriberDids() []string {

     

       66
        
       	dids := make([]string, 0, subscribers.Len())

     

       67
       -
       	subscribers.Range(func(s string, sd *SubscriberData) bool {

     

       68
       -
       		dids = append(dids, s)

     

       69
        
       		return true

     

       70
        
       	})

     

       71
        
       	return dids

     

       72
        
       }

     

       73
        
       

     

       74
       -
       func listenTo(sd *SubscriberData, did string) {

     

       75
       -
       	targetDids, _ := listeningTo.GetOrInsert(did, hashmap.New[string, *SubscriberData]())

     

       76
       -
       	targetDids.Insert(sd.DID, sd)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       77
        
       }

     

       78
        
       

     

       79
       -
       func stopListeningTo(subscriberDid, did string) {

     

       80
       -
       	if targetDids, exists := listeningTo.Get(did); exists {

     

       81
       -
       		targetDids.Del(subscriberDid)

     

       82
        
       	}

     

       83
        
       }

     

       84
        
       

     
···

       99
        
       

     

       100
        
       func handleSubscribe(w http.ResponseWriter, r *http.Request) {

     

       101
        
       	vars := mux.Vars(r)

     

       102
       -
       	did := vars["did"]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       103
        
       

     

       104
        
       	query := r.URL.Query()

     

       105
       -
       	// "follows", everything else is considered as "none"

     

       106
        
       	listenType := query.Get("listenTo")

     

       107
        
       	if len(listenType) == 0 {

     

       108
        
       		listenType = ListenTypeFollows

     

       109
        
       	}

     

       110
        
       

     

       111
       -
       	logger = logger.With("did", did)

     

       112
        
       

     

       113
        
       	conn, err := upgrader.Upgrade(w, r, nil)

     

       114
        
       	if err != nil {

     
···

       130
        
       		Host: pdsURI,

     

       131
        
       	}

     

       132
        
       

     

       133
       -
       	var subbedTo Set[string]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       134
        
       

     

       135
        
       	switch listenType {

     

       136
        
       	case ListenTypeFollows:

     
···

       140
        
       			return

     

       141
        
       		}

     

       142
        
       		logger.Info("fetched follows")

     

       143
       -
       		subbedTo = follows

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       144
        
       	case ListenTypeNone:

     

       145
       -
       		subbedTo = make(Set[string])

     

       146
        
       	default:

     

       147
       -
       		logger.Error("invalid listen type", "requestedType", listenType)

     

       148
       -
       		return

     

       149
       -
       	}

     

       150
       -
       

     

       151
       -
       	reposts, err := fetchReposts(r.Context(), xrpcClient, did)

     

       152
       -
       	if err != nil {

     

       153
       -
       		logger.Error("error fetching reposts", "error", err)

     

       154
        
       		return

     

       155
        
       	}

     

       156
       -
       	logger.Info("fetched reposts")

     

       157
       -
       

     

       158
       -
       	sd := &SubscriberData{

     

       159
       -
       		DID:        did,

     

       160
       -
       		Conn:       conn,

     

       161
       -
       		ListenType: listenType,

     

       162
       -
       		ListenTo:   subbedTo,

     

       163
       -
       		Reposts:    reposts,

     

       164
       -
       	}

     

       165
        
       

     

       166
        
       	subscribers.Set(sd.DID, sd)

     

       167
        
       	for listenDid := range sd.ListenTo {

     

       168
       -
       		listenTo(sd, listenDid)

     

       169
        
       	}

     

       170
       -
       

     

       171
        
       	updateSubscriberStreamOpts()

     

       172
       -
       	updateLikeStreamOpts()

     

       173
        
       	// delete subscriber after we are done

     

       174
        
       	defer func() {

     

       175
        
       		for listenDid := range sd.ListenTo {

     

       176
        
       			stopListeningTo(sd.DID, listenDid)

     

       177
        
       		}

     

       178
        
       		subscribers.Del(sd.DID)

     

       179
       -
       

     

       180
        
       		updateSubscriberStreamOpts()

     

       181
       -
       		updateLikeStreamOpts()

     

       182
        
       	}()

     

       183
        
       

     

       184
        
       	logger.Info("serving subscriber")

     
···

       209
        
       			}

     

       210
        
       			for _, listenDid := range innerMsg.ListenTo {

     

       211
        
       				sd.ListenTo[listenDid] = struct{}{}

     

       212
       -
       				listenTo(sd, listenDid)

     

       213
        
       			}

     

       214
        
       		}

     

       215
        
       	}

     
···

       218
        
       func getLikeStreamOpts() models.SubscriberOptionsUpdatePayload {

     

       219
        
       	return models.SubscriberOptionsUpdatePayload{

     

       220
        
       		WantedCollections: []string{"app.bsky.feed.like"},

     

       221
       -
       		// WantedDIDs:        getFollowsDids(),

     

       222
        
       	}

     

       223
        
       }

     

       224
        
       

     
···

       229
        
       	}

     

       230
        
       }

     

       231
        
       

     

       232
       -
       func updateLikeStreamOpts() {

     

       233
       -
       	opts := getLikeStreamOpts()

     

       234
       -
       	err := likeStream.SendOptionsUpdate(opts)

     

       235
       -
       	if err != nil {

     

       236
       -
       		logger.Error("couldnt update like stream opts", "error", err)

     

       237
       -
       		return

     

       238
       -
       	}

     

       239
       -
       	logger.Info("updated like stream opts", "requestedDids", len(opts.WantedDIDs))

     

       240
       -
       }

     

       241
       -
       

     

       242
        
       func updateSubscriberStreamOpts() {

     

       243
        
       	opts := getSubscriberStreamOpts()

     

       244
        
       	err := subscriberStream.SendOptionsUpdate(opts)

     
···

       250
        
       }

     

       251
        
       

     

       252
        
       func HandleLikeEvent(ctx context.Context, event *models.Event) error {

     

       253
       -
       	if event == nil || event.Commit == nil || len(event.Commit.Record) == 0 {

     

       254
        
       		return nil

     

       255
        
       	}

     

       256
        
       

     

       0
        
       
     

       257
        
       	// skip handling event if its not from a source we are listening to

     

       258
       -
       	targets, exists := listeningTo.Get(event.Did)

     

       259
        
       	if !exists {

     

       260
        
       		return nil

     

       261
        
       	}

     

       262
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       263
        
       	var like bsky.FeedLike

     

       264
       -
       	if err := json.Unmarshal(event.Commit.Record, &like); err != nil {

     

       265
       -
       		logger.Error("failed to unmarshal like", "error", err)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       266
        
       		return nil

     

       267
        
       	}

     

       268
        
       

     

       269
       -
       	targets.Range(func(s string, sd *SubscriberData) bool {

     

       270
       -
       		for repostURI, _ := range sd.Reposts {

     

       271
       -
       			// (un)liked a post the subscriber reposted

     

       272
       -
       			if like.Subject.Uri == repostURI {

     

       273
       -
       				notification := NotificationMessage{

     

       274
       -
       					Liked:     event.Commit.Operation != models.CommitOperationDelete,

     

       275
       -
       					ByDid:     event.Did,

     

       276
       -
       					RepostURI: repostURI,

     

       277
       -
       				}

     

       278
        
       

     

       279
       -
       				if err := sd.Conn.WriteJSON(notification); err != nil {

     

       280
       -
       					logger.Error("failed to send notification", "subscriber", sd.DID, "error", err)

     

       281
       -
       				}

     

       282
       -
       			}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       283
        
       		}

     

       284
       -
       		return true

     

       285
       -
       	})

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       286
        
       

     

       287
        
       	return nil

     

       288
        
       }

     
···

       292
        
       		return nil

     

       293
        
       	}

     

       294
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       295
        
       	switch event.Commit.Collection {

     

       296
       -
       	case "app.bsky.feed.repost":

     

       297
       -
       		modifySubscribersWithEvent(

     

       298
       -
       			event,

     

       299
       -
       			func(s *SubscriberData, r bsky.FeedRepost, deleted bool) {

     

       300
       -
       				if deleted {

     

       301
       -
       					delete(s.Reposts, r.Subject.Uri)

     

       302
       -
       				} else {

     

       303
       -
       					s.Reposts[r.Subject.Uri] = struct{}{}

     

       304
       -
       				}

     

       305
       -
       			},

     

       306
       -
       		)

     

       307
        
       	case "app.bsky.graph.follow":

     

       308
       -
       		modifySubscribersWithEvent(

     

       309
       -
       			event,

     

       310
       -
       			func(s *SubscriberData, r bsky.GraphFollow, deleted bool) {

     

       311
       -
       				// if we arent managing then we dont need to update anything

     

       312
       -
       				if s.ListenType != ListenTypeFollows {

     

       313
       -
       					return

     

       314
       -
       				}

     

       315
       -
       				if deleted {

     

       316
       -
       					stopListeningTo(s.DID, r.Subject)

     

       317
       -
       					delete(s.ListenTo, r.Subject)

     

       318
       -
       				} else {

     

       319
       -
       					s.ListenTo[r.Subject] = struct{}{}

     

       320
       -
       					listenTo(s, r.Subject)

     

       321
       -
       				}

     

       322
       -
       			},

     

       323
       -
       		)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       324
        
       	}

     

       325
        
       

     

       326
        
       	return nil

     

       327
        
       }

     

       328
        
       

     

       329
       -
       type ModifyFunc[v any] func(*SubscriberData, v, bool)

     

       330
       -
       

     

       331
       -
       func modifySubscribersWithEvent[v any](event *models.Event, handle ModifyFunc[v]) error {

     

       332
       -
       	if len(event.Commit.Record) == 0 {

     

       333
        
       		return nil

     

       334
        
       	}

     

       335
       -
       

     

       336
       -
       	var data v

     

       337
       -
       	if err := json.Unmarshal(event.Commit.Record, &data); err != nil {

     

       338
       -
       		logger.Error("failed to unmarshal repost", "error", err, "raw", event.Commit.Record)

     

       339
       -
       		return nil

     

       340
       -
       	}

     

       341
       -
       

     

       342
       -
       	if subscriber, exists := subscribers.Get(event.Did); exists {

     

       343
       -
       		handle(subscriber, data, event.Commit.Operation == models.CommitOperationDelete)

     

       344
       -
       	}

     

       345
       -
       

     

       346
        
       	return nil

     

       347
        
       }

···

       8
        
       	"net/http"

     

       9
        
       

     

       10
        
       	"github.com/bluesky-social/indigo/api/bsky"

     

       11
       +
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       12
        
       	"github.com/bluesky-social/indigo/xrpc"

     

       13
        
       	"github.com/bluesky-social/jetstream/pkg/client"

     

       14
        
       	"github.com/bluesky-social/jetstream/pkg/models"

     
···

       23
        
       const ListenTypeFollows = "follows"

     

       24
        
       

     

       25
        
       type SubscriberData struct {

     

       26
       +
       	DID        syntax.DID

     

       27
        
       	Conn       *websocket.Conn

     

       28
        
       	ListenType string

     

       29
       +
       	ListenTo   Set[syntax.DID]

     

       30
       +
       	follows    map[syntax.RecordKey]bsky.GraphFollow

     

       31
       +
       }

     

       32
       +
       

     

       33
       +
       type ListeneeData struct {

     

       34
       +
       	targets *hashmap.Map[syntax.DID, *SubscriberData]

     

       35
       +
       	likes   map[syntax.RecordKey]bsky.FeedLike

     

       36
        
       }

     

       37
        
       

     

       38
        
       type NotificationMessage struct {

     

       39
       +
       	Liked     bool         `json:"liked"`

     

       40
       +
       	ByDid     syntax.DID   `json:"did"`

     

       41
       +
       	RepostURI syntax.ATURI `json:"repost_uri"`

     

       42
        
       }

     

       43
        
       

     

       44
        
       type SubscriberMessage struct {

     
···

       47
        
       }

     

       48
        
       

     

       49
        
       type SubscriberUpdateListenTo struct {

     

       50
       +
       	ListenTo []syntax.DID `json:"listen_to"`

     

       51
        
       }

     

       52
        
       

     

       53
        
       var (

     

       54
        
       	// storing the subscriber data in both Should Be Fine

     

       55
        
       	// we dont modify subscriber data at the same time in two places

     

       56
       +
       	subscribers = hashmap.New[syntax.DID, *SubscriberData]()

     

       57
       +
       	listeningTo = hashmap.New[syntax.DID, *ListeneeData]()

     

       58
        
       

     

       59
        
       	likeStream       *client.Client

     

       60
        
       	subscriberStream *client.Client

     
···

       70
        
       

     

       71
        
       func getSubscriberDids() []string {

     

       72
        
       	dids := make([]string, 0, subscribers.Len())

     

       73
       +
       	subscribers.Range(func(s syntax.DID, sd *SubscriberData) bool {

     

       74
       +
       		dids = append(dids, string(s))

     

       75
        
       		return true

     

       76
        
       	})

     

       77
        
       	return dids

     

       78
        
       }

     

       79
        
       

     

       80
       +
       func startListeningTo(sd *SubscriberData, did syntax.DID) {

     

       81
       +
       	ld, _ := listeningTo.GetOrInsert(did, &ListeneeData{

     

       82
       +
       		targets: hashmap.New[syntax.DID, *SubscriberData](),

     

       83
       +
       		likes:   make(map[syntax.RecordKey]bsky.FeedLike),

     

       84
       +
       	})

     

       85
       +
       	ld.targets.Insert(sd.DID, sd)

     

       86
        
       }

     

       87
        
       

     

       88
       +
       func stopListeningTo(subscriberDid, did syntax.DID) {

     

       89
       +
       	if ld, exists := listeningTo.Get(did); exists {

     

       90
       +
       		ld.targets.Del(subscriberDid)

     

       91
        
       	}

     

       92
        
       }

     

       93
        
       

     
···

       108
        
       

     

       109
        
       func handleSubscribe(w http.ResponseWriter, r *http.Request) {

     

       110
        
       	vars := mux.Vars(r)

     

       111
       +
       	did, err := syntax.ParseDID(vars["did"])

     

       112
       +
       	if err != nil {

     

       113
       +
       		http.Error(w, "not a valid did", http.StatusBadRequest)

     

       114
       +
       		return

     

       115
       +
       	}

     

       116
        
       

     

       117
        
       	query := r.URL.Query()

     

       0
        
       
     

       118
        
       	listenType := query.Get("listenTo")

     

       119
        
       	if len(listenType) == 0 {

     

       120
        
       		listenType = ListenTypeFollows

     

       121
        
       	}

     

       122
        
       

     

       123
       +
       	logger := logger.With("did", did)

     

       124
        
       

     

       125
        
       	conn, err := upgrader.Upgrade(w, r, nil)

     

       126
        
       	if err != nil {

     
···

       142
        
       		Host: pdsURI,

     

       143
        
       	}

     

       144
        
       

     

       145
       +
       	sd := &SubscriberData{

     

       146
       +
       		DID:        did,

     

       147
       +
       		Conn:       conn,

     

       148
       +
       		ListenType: listenType,

     

       149
       +
       	}

     

       150
        
       

     

       151
        
       	switch listenType {

     

       152
        
       	case ListenTypeFollows:

     
···

       156
        
       			return

     

       157
        
       		}

     

       158
        
       		logger.Info("fetched follows")

     

       159
       +
       		sd.follows = follows

     

       160
       +
       		sd.ListenTo = make(Set[syntax.DID])

     

       161
       +
       		for _, follow := range follows {

     

       162
       +
       			sd.ListenTo[syntax.DID(follow.Subject)] = struct{}{}

     

       163
       +
       		}

     

       164
        
       	case ListenTypeNone:

     

       165
       +
       		sd.ListenTo = make(Set[syntax.DID])

     

       166
        
       	default:

     

       167
       +
       		http.Error(w, "invalid listen type", http.StatusBadRequest)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       168
        
       		return

     

       169
        
       	}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       170
        
       

     

       171
        
       	subscribers.Set(sd.DID, sd)

     

       172
        
       	for listenDid := range sd.ListenTo {

     

       173
       +
       		startListeningTo(sd, listenDid)

     

       174
        
       	}

     

       0
        
       
     

       175
        
       	updateSubscriberStreamOpts()

     

       0
        
       
     

       176
        
       	// delete subscriber after we are done

     

       177
        
       	defer func() {

     

       178
        
       		for listenDid := range sd.ListenTo {

     

       179
        
       			stopListeningTo(sd.DID, listenDid)

     

       180
        
       		}

     

       181
        
       		subscribers.Del(sd.DID)

     

       0
        
       
     

       182
        
       		updateSubscriberStreamOpts()

     

       0
        
       
     

       183
        
       	}()

     

       184
        
       

     

       185
        
       	logger.Info("serving subscriber")

     
···

       210
        
       			}

     

       211
        
       			for _, listenDid := range innerMsg.ListenTo {

     

       212
        
       				sd.ListenTo[listenDid] = struct{}{}

     

       213
       +
       				startListeningTo(sd, listenDid)

     

       214
        
       			}

     

       215
        
       		}

     

       216
        
       	}

     
···

       219
        
       func getLikeStreamOpts() models.SubscriberOptionsUpdatePayload {

     

       220
        
       	return models.SubscriberOptionsUpdatePayload{

     

       221
        
       		WantedCollections: []string{"app.bsky.feed.like"},

     

       0
        
       
     

       222
        
       	}

     

       223
        
       }

     

       224
        
       

     
···

       229
        
       	}

     

       230
        
       }

     

       231
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       232
        
       func updateSubscriberStreamOpts() {

     

       233
        
       	opts := getSubscriberStreamOpts()

     

       234
        
       	err := subscriberStream.SendOptionsUpdate(opts)

     
···

       240
        
       }

     

       241
        
       

     

       242
        
       func HandleLikeEvent(ctx context.Context, event *models.Event) error {

     

       243
       +
       	if event == nil || event.Commit == nil {

     

       244
        
       		return nil

     

       245
        
       	}

     

       246
        
       

     

       247
       +
       	byDid := syntax.DID(event.Did)

     

       248
        
       	// skip handling event if its not from a source we are listening to

     

       249
       +
       	ld, exists := listeningTo.Get(byDid)

     

       250
        
       	if !exists {

     

       251
        
       		return nil

     

       252
        
       	}

     

       253
        
       

     

       254
       +
       	deleted := event.Commit.Operation == models.CommitOperationDelete

     

       255
       +
       	rkey := syntax.RecordKey(event.Commit.RKey)

     

       256
       +
       

     

       257
        
       	var like bsky.FeedLike

     

       258
       +
       	if deleted {

     

       259
       +
       		if l, exists := ld.likes[rkey]; exists {

     

       260
       +
       			like = l

     

       261
       +
       			defer delete(ld.likes, rkey)

     

       262
       +
       		} else {

     

       263
       +
       			logger.Error("like record not found", "rkey", rkey)

     

       264
       +
       			return nil

     

       265
       +
       		}

     

       266
       +
       	} else {

     

       267
       +
       		if err := json.Unmarshal(event.Commit.Record, &like); err != nil {

     

       268
       +
       			logger.Error("failed to unmarshal like", "error", err)

     

       269
       +
       			return nil

     

       270
       +
       		}

     

       271
       +
       	}

     

       272
       +
       

     

       273
       +
       	// if there is no via it means its not a repost anyway

     

       274
       +
       	if like.Via == nil {

     

       275
        
       		return nil

     

       276
        
       	}

     

       277
        
       

     

       278
       +
       	// store for later when it gets deleted so we can fetch the record

     

       279
       +
       	if !deleted {

     

       280
       +
       		ld.likes[rkey] = like

     

       281
       +
       	}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       282
        
       

     

       283
       +
       	repostURI := syntax.ATURI(like.Via.Uri)

     

       284
       +
       	// if not a repost we dont care

     

       285
       +
       	if repostURI.Collection() != "app.bsky.feed.repost" {

     

       286
       +
       		return nil

     

       287
       +
       	}

     

       288
       +
       	reposterDID, err := repostURI.Authority().AsDID()

     

       289
       +
       	if err != nil {

     

       290
       +
       		return err

     

       291
       +
       	}

     

       292
       +
       	if sd, exists := ld.targets.Get(reposterDID); exists {

     

       293
       +
       		notification := NotificationMessage{

     

       294
       +
       			Liked:     !deleted,

     

       295
       +
       			ByDid:     byDid,

     

       296
       +
       			RepostURI: repostURI,

     

       297
        
       		}

     

       298
       +
       

     

       299
       +
       		if err := sd.Conn.WriteJSON(notification); err != nil {

     

       300
       +
       			logger.Error("failed to send notification", "subscriber", sd.DID, "error", err)

     

       301
       +
       		}

     

       302
       +
       	}

     

       303
        
       

     

       304
        
       	return nil

     

       305
        
       }

     
···

       309
        
       		return nil

     

       310
        
       	}

     

       311
        
       

     

       312
       +
       	byDid := syntax.DID(event.Did)

     

       313
       +
       	sd, exists := subscribers.Get(byDid)

     

       314
       +
       	if !exists {

     

       315
       +
       		return nil

     

       316
       +
       	}

     

       317
       +
       

     

       318
       +
       	deleted := event.Commit.Operation == models.CommitOperationDelete

     

       319
       +
       	rkey := syntax.RecordKey(event.Commit.RKey)

     

       320
       +
       

     

       321
        
       	switch event.Commit.Collection {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       322
        
       	case "app.bsky.graph.follow":

     

       323
       +
       		// if we arent managing then we dont need to update anything

     

       324
       +
       		if sd.ListenType != ListenTypeFollows {

     

       325
       +
       			return nil

     

       326
       +
       		}

     

       327
       +
       		var r bsky.GraphFollow

     

       328
       +
       		if deleted {

     

       329
       +
       			if f, exists := sd.follows[rkey]; exists {

     

       330
       +
       				r = f

     

       331
       +
       			} else {

     

       332
       +
       				logger.Error("follow record not found", "rkey", rkey)

     

       333
       +
       				return nil

     

       334
       +
       			}

     

       335
       +
       			subjectDid := syntax.DID(r.Subject)

     

       336
       +
       			stopListeningTo(sd.DID, subjectDid)

     

       337
       +
       			delete(sd.ListenTo, subjectDid)

     

       338
       +
       			delete(sd.follows, rkey)

     

       339
       +
       		} else {

     

       340
       +
       			if err := unmarshalEvent(event, &r); err != nil {

     

       341
       +
       				return err

     

       342
       +
       			}

     

       343
       +
       			subjectDid := syntax.DID(r.Subject)

     

       344
       +
       			sd.ListenTo[subjectDid] = struct{}{}

     

       345
       +
       			sd.follows[rkey] = r

     

       346
       +
       			startListeningTo(sd, subjectDid)

     

       347
       +
       		}

     

       348
        
       	}

     

       349
        
       

     

       350
        
       	return nil

     

       351
        
       }

     

       352
        
       

     

       353
       +
       func unmarshalEvent[v any](event *models.Event, val *v) error {

     

       354
       +
       	if err := json.Unmarshal(event.Commit.Record, val); err != nil {

     

       355
       +
       		logger.Error("failed to unmarshal", "error", err, "raw", event.Commit.Record)

     

       0
        
       
     

       356
        
       		return nil

     

       357
        
       	}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       358
        
       	return nil

     

       359
        
       }

+45 -16

xrpc.go

···

       10
        
       	"github.com/bluesky-social/indigo/atproto/identity"

     

       11
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       12
        
       	"github.com/bluesky-social/indigo/xrpc"

     

       0
        
       
     

       13
        
       )

     

       14
        
       

     

       15
       -
       func findUserPDS(ctx context.Context, did string) (string, error) {

     

       16
       -
       	id, err := identity.DefaultDirectory().LookupDID(ctx, syntax.DID(did))

     

       17
        
       	if err != nil {

     

       18
        
       		return "", err

     

       19
        
       	}

     
···

       25
        
       	return pdsURI, nil

     

       26
        
       }

     

       27
        
       

     

       28
       -
       func fetchRecords[v any](ctx context.Context, xrpcClient *xrpc.Client, collection, did string, extractFn func(v) string) (Set[string], error) {

     

       29
       -
       	all := make(Set[string])

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       30
        
       	cursor := ""

     

       31
        
       

     

       32
        
       	for {

     

       33
        
       		// todo: ratelimits?? idk what this does for those

     

       34
       -
       		out, err := atproto.RepoListRecords(ctx, xrpcClient, collection, cursor, 100, did, false)

     

       35
        
       		if err != nil {

     

       36
       -
       			return nil, err

     

       37
        
       		}

     

       38
        
       

     

       39
        
       		for _, record := range out.Records {

     

       40
        
       			raw, _ := record.Value.MarshalJSON()

     

       41
        
       			var val v

     

       42
        
       			if err := json.Unmarshal(raw, &val); err != nil {

     

       43
       -
       				return nil, err

     

       44
        
       			}

     

       45
       -
       			s := extractFn(val)

     

       46
       -
       			if len(s) > 0 {

     

       47
       -
       				all[s] = struct{}{}

     

       48
       -
       			}

     

       49
        
       		}

     

       50
        
       

     

       51
        
       		if out.Cursor == nil || *out.Cursor == "" {

     

       52
        
       			break

     

       53
        
       		}

     

       54
        
       		cursor = *out.Cursor

     

       0
        
       
     

       0
        
       
     

       55
        
       	}

     

       56
        
       

     

       57
       -
       	return all, nil

     

       58
        
       }

     

       59
        
       

     

       60
       -
       func fetchReposts(ctx context.Context, xrpcClient *xrpc.Client, did string) (Set[string], error) {

     

       61
       -
       	return fetchRecords(ctx, xrpcClient, "app.bsky.feed.repost", did, func(v bsky.FeedRepost) string { return v.Subject.Uri })

     

       0
        
       
     

       0
        
       
     

       62
        
       }

     

       63
        
       

     

       64
       -
       func fetchFollows(ctx context.Context, xrpcClient *xrpc.Client, did string) (Set[string], error) {

     

       65
       -
       	return fetchRecords(ctx, xrpcClient, "app.bsky.graph.follow", did, func(v bsky.GraphFollow) string { return v.Subject })

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       66
        
       }

···

       10
        
       	"github.com/bluesky-social/indigo/atproto/identity"

     

       11
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       12
        
       	"github.com/bluesky-social/indigo/xrpc"

     

       13
       +
       	"github.com/bluesky-social/jetstream/pkg/models"

     

       14
        
       )

     

       15
        
       

     

       16
       +
       func findUserPDS(ctx context.Context, did syntax.DID) (string, error) {

     

       17
       +
       	id, err := identity.DefaultDirectory().LookupDID(ctx, did)

     

       18
        
       	if err != nil {

     

       19
        
       		return "", err

     

       20
        
       	}

     
···

       26
        
       	return pdsURI, nil

     

       27
        
       }

     

       28
        
       

     

       29
       +
       func fetchRecord[v any](ctx context.Context, xrpcClient *xrpc.Client, val *v, event *models.Event) error {

     

       30
       +
       	out, err := atproto.RepoGetRecord(ctx, xrpcClient, "", event.Commit.Collection, event.Did, event.Commit.RKey)

     

       31
       +
       	if err != nil {

     

       32
       +
       		return err

     

       33
       +
       	}

     

       34
       +
       	raw, _ := out.Value.MarshalJSON()

     

       35
       +
       	if err := json.Unmarshal(raw, val); err != nil {

     

       36
       +
       		return err

     

       37
       +
       	}

     

       38
       +
       	return nil

     

       39
       +
       }

     

       40
       +
       

     

       41
       +
       func fetchRecords[v any](ctx context.Context, xrpcClient *xrpc.Client, cb func(syntax.ATURI, v), collection string, did syntax.DID) error {

     

       42
       +
       	if xrpcClient == nil {

     

       43
       +
       		pdsURI, err := findUserPDS(ctx, did)

     

       44
       +
       		if err != nil {

     

       45
       +
       			return err

     

       46
       +
       		}

     

       47
       +
       		xrpcClient = &xrpc.Client{

     

       48
       +
       			Host: pdsURI,

     

       49
       +
       		}

     

       50
       +
       	}

     

       51
       +
       

     

       52
        
       	cursor := ""

     

       53
        
       

     

       54
        
       	for {

     

       55
        
       		// todo: ratelimits?? idk what this does for those

     

       56
       +
       		out, err := atproto.RepoListRecords(ctx, xrpcClient, collection, cursor, 100, string(did), false)

     

       57
        
       		if err != nil {

     

       58
       +
       			return err

     

       59
        
       		}

     

       60
        
       

     

       61
        
       		for _, record := range out.Records {

     

       62
        
       			raw, _ := record.Value.MarshalJSON()

     

       63
        
       			var val v

     

       64
        
       			if err := json.Unmarshal(raw, &val); err != nil {

     

       65
       +
       				return err

     

       66
        
       			}

     

       67
       +
       			cb(syntax.ATURI(record.Uri), val)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       68
        
       		}

     

       69
        
       

     

       70
        
       		if out.Cursor == nil || *out.Cursor == "" {

     

       71
        
       			break

     

       72
        
       		}

     

       73
        
       		cursor = *out.Cursor

     

       74
       +
       

     

       75
       +
       		break

     

       76
        
       	}

     

       77
        
       

     

       78
       +
       	return nil

     

       79
        
       }

     

       80
        
       

     

       81
       +
       func fetchFollows(ctx context.Context, xrpcClient *xrpc.Client, did syntax.DID) (map[syntax.RecordKey]bsky.GraphFollow, error) {

     

       82
       +
       	out := make(map[syntax.RecordKey]bsky.GraphFollow)

     

       83
       +
       	fetchRecords(ctx, xrpcClient, func(uri syntax.ATURI, f bsky.GraphFollow) { out[uri.RecordKey()] = f }, "app.bsky.graph.follow", did)

     

       84
       +
       	return out, nil

     

       85
        
       }

     

       86
        
       

     

       87
       +
       func fetchRepostLikes(ctx context.Context, xrpcClient *xrpc.Client, did syntax.DID) (map[syntax.RecordKey]bsky.FeedLike, error) {

     

       88
       +
       	out := make(map[syntax.RecordKey]bsky.FeedLike)

     

       89
       +
       	fetchRecords(ctx, xrpcClient, func(uri syntax.ATURI, f bsky.FeedLike) {

     

       90
       +
       		if f.Via != nil && syntax.ATURI(f.Via.Uri).Collection() == "app.bsky.feed.repost" {

     

       91
       +
       			out[uri.RecordKey()] = f

     

       92
       +
       		}

     

       93
       +
       	}, "app.bsky.feed.like", did)

     

       94
       +
       	return out, nil

     

       95
        
       }