feat: distribute new local posts to followers via websocket

internal/database/sql/blog.go

@@ -85,10 +85,16 @@ func (s *BlogStore) LocalCount(ctx context.Context) (count int64, err error) {
 	return count, nil
 }
 
-func (s *BlogStore) Followers(ctx context.Context, id ulid.ULID) ([]ulid.ULID, error) {
-	q := sqlf.Sprintf("SELECT account_id FROM account_follows WHERE blog_id = %s", id)
+type BlogFollower struct {
+	AccountID ulid.ULID
+	IsLocal   bool
+}
 
-	follows, err := Select[ulid.ULID](ctx, s.q, q)
+func (s *BlogStore) Followers(ctx context.Context, id ulid.ULID) ([]BlogFollower, error) {
+	q := sqlf.Sprintf(`SELECT f.account_id, a.domain IS NOT NULL AS is_local
+	FROM account_follows f JOIN accounts a ON a.id = f.account_id WHERE f.blog_id = %s`, id)
+
+	follows, err := Select[BlogFollower](ctx, s.q, q)
 	if err != nil {
 		return nil, errors.Wrap(err, "executing query")
 	}

internal/processor/processor.go

@@ -1,9 +1,14 @@
 package processor
 
 import (
+	"context"
+	"time"
+
 	"git.sleepycat.moe/sam/mercury/internal/database"
 	"git.sleepycat.moe/sam/mercury/internal/database/sql"
 	"git.sleepycat.moe/sam/mercury/internal/streaming"
+	"git.sleepycat.moe/sam/mercury/web/api"
+	"github.com/rs/zerolog/log"
 )
 
 type Processor struct {
@@ -14,7 +19,7 @@ type Processor struct {
 
 func New(db *sql.Base) *Processor {
 	p := &Processor{
-		SocketHolder: &streaming.SocketHolder{},
+		SocketHolder: streaming.NewSocketHolder(),
 
 		db: db,
 	}
@@ -23,5 +28,54 @@ func New(db *sql.Base) *Processor {
 }
 
 func (p *Processor) HandlePost(post database.Post) {
+	// this function is spun off in a separate goroutine, so we shouldn't use the same context as the parent request
+	// TODO: make timeout configurable?
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
 
+	conn, err := p.db.Acquire(ctx)
+	if err != nil {
+		log.Err(err).Msg("acquiring database")
+		return
+	}
+	defer conn.Release()
+
+	// get the blog and their followers
+	blog, err := sql.NewBlogStore(conn).ByID(ctx, post.BlogID)
+	if err != nil {
+		log.Err(err).Msg("getting blog")
+		return
+	}
+	acct, err := sql.NewAccountStore(conn).ByID(ctx, blog.AccountID)
+	if err != nil {
+		log.Err(err).Msg("getting account")
+		return
+	}
+	followers, err := sql.NewBlogStore(conn).Followers(ctx, blog.ID)
+	if err != nil {
+		log.Err(err).Msg("getting followers")
+		return
+	}
+
+	p.handlePostLocal(ctx, post, blog, acct, followers)
+}
+
+// handlePostLocal handles a post on the local side--mostly sending notifications to websockets.
+// All posts go through this function.
+func (p *Processor) handlePostLocal(
+	ctx context.Context, post database.Post,
+	blog database.Blog, acct database.Account,
+	followers []sql.BlogFollower,
+) {
+	// send to self
+	apiPost := api.DBPostToPost(post, blog, acct)
+	p.SocketHolder.Send(acct.ID, streaming.EventTypePost, apiPost)
+
+	for _, follower := range followers {
+		if !follower.IsLocal {
+			continue
+		}
+
+		p.SocketHolder.Send(follower.AccountID, streaming.EventTypePost, apiPost)
+	}
 }

internal/streaming/event.go

@@ -5,10 +5,20 @@ import "encoding/json"
 type EventType int8
 
 const (
+	// Sent when an error occurs
+	// Payload: {code:int, message:string}
 	EventTypeError EventType = 1
-	EventTypePost  EventType = 2
+	// Sent when echoing back received messages
+	// Payload: <received message>
+	EventTypeEcho EventType = 2
+	// Sent on a new post being created
+	// Payload: <post object>
+	EventTypePost EventType = 3
 
-	EventTypeSubscribe   EventType = 126
+	// Receive events
+	// Subscribe to a new event
+	EventTypeSubscribe EventType = 126
+	// Unsubscribe from an event
 	EventTypeUnsubscribe EventType = 127
 )
 
@@ -16,6 +26,8 @@ func (et EventType) Valid() bool {
 	switch et {
 	case EventTypeError:
 		return true
+	case EventTypeEcho:
+		return true
 	case EventTypePost:
 		return true
 	case EventTypeSubscribe:

internal/streaming/sockets.go

@@ -13,6 +13,12 @@ type SocketHolder struct {
 	mu      sync.Mutex
 }
 
+func NewSocketHolder() *SocketHolder {
+	return &SocketHolder{
+		sockets: make(map[ulid.ULID]*userSockets),
+	}
+}
+
 func (sh *SocketHolder) Send(acctID ulid.ULID, et EventType, data any) {
 	userSockets := sh.SocketsFor(acctID)
 
@@ -22,7 +28,7 @@ func (sh *SocketHolder) Send(acctID ulid.ULID, et EventType, data any) {
 	userSockets.mu.Unlock()
 
 	for _, s := range sockets {
-		if s.willAcceptEvent(et) {
+		if s.WillAcceptEvent(et) {
 			// the socket might block for a bit, so spin this off into a separate goroutine
 			go func(s *Socket) {
 				s.ch <- Event{Type: et, Data: data}
@@ -71,7 +77,7 @@ type Socket struct {
 	mu sync.RWMutex
 }
 
-func (s *Socket) willAcceptEvent(mt EventType) bool {
+func (s *Socket) WillAcceptEvent(mt EventType) bool {
 	if mt == EventTypeError {
 		return true
 	}
@@ -109,6 +115,8 @@ func NewSocket(ctx context.Context, cancel context.CancelFunc) *Socket {
 		ctx:    ctx,
 		cancel: cancel,
 		ch:     make(chan Event),
-		types:  make(map[EventType]struct{}),
+		types: map[EventType]struct{}{
+			EventTypeEcho: {},
+		},
 	}
 }