commit 2f18acb47d2f2461fcb0448985962bd330dd6e95 · ptr.pet/bsky-repost-likes

+38 -8

main.go

···

       35
        
       // Global state

     

       36
        
       var (

     

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

     

       0
        
       
     

       38
        
       

     

       39
        
       	likeStream       *client.Client

     

       40
        
       	subscriberStream *client.Client

     
···

       122
        
       	}

     

       123
        
       	logger.Info("fetched reposts")

     

       124
        
       

     

       125
       -
       	subscriber := &SubscriberData{

     

       126
        
       		DID:  did,

     

       127
        
       		Conn: conn,

     

       128
        
       		// use user follows as default listen to

     
···

       130
        
       		Reposts:  reposts,

     

       131
        
       	}

     

       132
        
       

     

       133
       -
       	subscribers.Set(did, subscriber)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       134
        
       	updateSubscriberStreamOpts()

     

       135
        
       	updateLikeStreamOpts()

     

       136
        
       	// delete subscriber after we are done

     

       137
        
       	defer func() {

     

       138
       -
       		subscribers.Del(did)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       139
        
       		updateSubscriberStreamOpts()

     

       140
        
       		updateLikeStreamOpts()

     

       141
        
       	}()

     
···

       151
        
       	}

     

       152
        
       }

     

       153
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       154
        
       func getLikeStreamOpts() models.SubscriberOptionsUpdatePayload {

     

       155
        
       	return models.SubscriberOptionsUpdatePayload{

     

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

     

       157
       -
       		WantedDIDs:        getFollowsDids(),

     

       158
        
       	}

     

       159
        
       }

     

       160
        
       

     
···

       198
        
       		return nil

     

       199
        
       	}

     

       200
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       201
        
       	var like bsky.FeedLike

     

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

     

       203
       -
       		logger.Error("Failed to unmarshal like", "error", err)

     

       204
        
       		return nil

     

       205
        
       	}

     

       206
        
       

     

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

     

       208
        
       		for repostURI, _ := range sd.Reposts {

     

       209
        
       			// (un)liked a post the subscriber reposted

     

       210
        
       			if like.Subject.Uri == repostURI {

     
···

       215
        
       				}

     

       216
        
       

     

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

     

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

     

       219
        
       				}

     

       220
        
       			}

     

       221
        
       		}

     
···

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

     

       243
        
       		modifySubscribersWithEvent(

     

       244
        
       			event,

     

       245
       -
       			func(s *SubscriberData, r bsky.GraphFollow) { delete(s.ListenTo, r.Subject) },

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       246
        
       			func(s *SubscriberData, r bsky.GraphFollow) {

     

       247
        
       				s.ListenTo[r.Subject] = struct{}{}

     

       0
        
       
     

       248
        
       			},

     

       249
        
       		)

     

       250
        
       	}

···

       35
        
       // Global state

     

       36
        
       var (

     

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

     

       38
       +
       	listeningTo = hashmap.New[string, *hashmap.Map[string, *SubscriberData]]()

     

       39
        
       

     

       40
        
       	likeStream       *client.Client

     

       41
        
       	subscriberStream *client.Client

     
···

       123
        
       	}

     

       124
        
       	logger.Info("fetched reposts")

     

       125
        
       

     

       126
       +
       	sd := &SubscriberData{

     

       127
        
       		DID:  did,

     

       128
        
       		Conn: conn,

     

       129
        
       		// use user follows as default listen to

     
···

       131
        
       		Reposts:  reposts,

     

       132
        
       	}

     

       133
        
       

     

       134
       +
       	subscribers.Set(sd.DID, sd)

     

       135
       +
       	for listenDid := range sd.ListenTo {

     

       136
       +
       		listenTo(sd, listenDid)

     

       137
       +
       	}

     

       138
       +
       

     

       139
        
       	updateSubscriberStreamOpts()

     

       140
        
       	updateLikeStreamOpts()

     

       141
        
       	// delete subscriber after we are done

     

       142
        
       	defer func() {

     

       143
       +
       		for listenDid := range sd.ListenTo {

     

       144
       +
       			stopListeningTo(sd.DID, listenDid)

     

       145
       +
       		}

     

       146
       +
       		subscribers.Del(sd.DID)

     

       147
       +
       

     

       148
        
       		updateSubscriberStreamOpts()

     

       149
        
       		updateLikeStreamOpts()

     

       150
        
       	}()

     
···

       160
        
       	}

     

       161
        
       }

     

       162
        
       

     

       163
       +
       func listenTo(sd *SubscriberData, did string) {

     

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

     

       165
       +
       	targetDids.Insert(sd.DID, sd)

     

       166
       +
       }

     

       167
       +
       

     

       168
       +
       func stopListeningTo(subscriberDid, did string) {

     

       169
       +
       	if targetDids, exists := listeningTo.Get(did); exists {

     

       170
       +
       		targetDids.Del(subscriberDid)

     

       171
       +
       	}

     

       172
       +
       }

     

       173
       +
       

     

       174
        
       func getLikeStreamOpts() models.SubscriberOptionsUpdatePayload {

     

       175
        
       	return models.SubscriberOptionsUpdatePayload{

     

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

     

       177
       +
       		// WantedDIDs:        getFollowsDids(),

     

       178
        
       	}

     

       179
        
       }

     

       180
        
       

     
···

       218
        
       		return nil

     

       219
        
       	}

     

       220
        
       

     

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

     

       222
       +
       	targets, exists := listeningTo.Get(event.Did)

     

       223
       +
       	if !exists {

     

       224
       +
       		return nil

     

       225
       +
       	}

     

       226
       +
       

     

       227
        
       	var like bsky.FeedLike

     

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

     

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

     

       230
        
       		return nil

     

       231
        
       	}

     

       232
        
       

     

       233
       +
       	targets.Range(func(s string, sd *SubscriberData) bool {

     

       234
        
       		for repostURI, _ := range sd.Reposts {

     

       235
        
       			// (un)liked a post the subscriber reposted

     

       236
        
       			if like.Subject.Uri == repostURI {

     
···

       241
        
       				}

     

       242
        
       

     

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

     

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

     

       245
        
       				}

     

       246
        
       			}

     

       247
        
       		}

     
···

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

     

       269
        
       		modifySubscribersWithEvent(

     

       270
        
       			event,

     

       271
       +
       			func(s *SubscriberData, r bsky.GraphFollow) {

     

       272
       +
       				delete(s.ListenTo, r.Subject)

     

       273
       +
       				stopListeningTo(s.DID, r.Subject)

     

       274
       +
       			},

     

       275
        
       			func(s *SubscriberData, r bsky.GraphFollow) {

     

       276
        
       				s.ListenTo[r.Subject] = struct{}{}

     

       277
       +
       				listenTo(s, r.Subject)

     

       278
        
       			},

     

       279
        
       		)

     

       280
        
       	}