+7 -3

.env-example

··· 1 1 - FEED_DID_BASE="test" 2 2 - FEED_HOST_NAME="test" 3 3 - FEED_NAME="test-feed" 1 1 + BSKY_HANDLE="your-handle" 2 2 + BSKY_PASS="app password" 3 3 + FEED_HOST_NAME="demo-feed.com" 4 4 + FEED_NAME="demo-feed" 5 5 + FEED_DISPLAY_NAME="My demo feed" 6 6 + FEED_DESCRIPTION="This is a demo feed" 7 7 + FEED_DID="did:web:demo-feed.com"

+2

.gitignore

··· 1 1 .env 2 2 + database.db 3 3 + demo-feed-generator

+8 -2

consumer.go

··· 1 1 - package main 1 1 + package feed 2 2 3 3 import ( 4 4 "context" ··· 22 22 logger *slog.Logger 23 23 } 24 24 25 25 - func newJetstreamConsumer(jsAddr string, logger *slog.Logger, handler *Handler) *JetstreamConsumer { 25 25 + // NewJetstreamConsumer configures a new jetstream consumer. To run or start you should call the Consume function 26 26 + func NewJetstreamConsumer(jsAddr string, logger *slog.Logger, handler *Handler) *JetstreamConsumer { 26 27 cfg := client.DefaultClientConfig() 27 28 if jsAddr != "" { 28 29 cfg.WebsocketURL = jsAddr ··· 62 63 // Handler is responsible for handling a message consumed from Jetstream 63 64 type Handler struct { 64 65 store PostStore 66 66 + } 67 67 + 68 68 + // NewFeedHandler returns a new handler 69 69 + func NewFeedHandler(store PostStore) *Handler { 70 70 + return &Handler{store: store} 65 71 } 66 72 67 73 // HandleEvent will handle an event based on the event's commit operation

database.db

This is a binary file and will not be displayed.

+12 -5

database.go

··· 1 1 - package main 1 1 + package feed 2 2 3 3 import ( 4 4 "database/sql" ··· 15 15 db *sql.DB 16 16 } 17 17 18 18 - func newDatabase(dbPath string) (*Database, error) { 18 18 + // NewDatabase will open a new database. It will ping the database to ensure it is available and error if not 19 19 + func NewDatabase(dbPath string) (*Database, error) { 19 20 if dbPath != ":memory:" { 20 21 err := createDbFile(dbPath) 21 22 if err != nil { ··· 41 42 return &Database{db: db}, nil 42 43 } 43 44 44 44 - func (d *Database) close() { 45 45 + // Close will cleanly stop the database connection 46 46 + func (d *Database) Close() { 45 47 err := d.db.Close() 46 48 if err != nil { 47 49 slog.Error("failed to close db", "error", err) ··· 57 59 if err != nil { 58 60 return fmt.Errorf("create db file : %w", err) 59 61 } 60 60 - f.Close() 62 62 + err = f.Close() 63 63 + if err != nil { 64 64 + return fmt.Errorf("failed to close DB file: %w", err) 65 65 + } 61 66 return nil 62 67 } 63 68 ··· 103 108 if err != nil { 104 109 return nil, fmt.Errorf("run query to get feed posts: %w", err) 105 110 } 106 106 - defer rows.Close() 111 111 + defer func() { 112 112 + _ = rows.Close() 113 113 + }() 107 114 108 115 posts := make([]Post, 0) 109 116 for rows.Next() {

-72

feedgenerator.go

··· 1 1 - package main 2 2 - 3 3 - import ( 4 4 - "context" 5 5 - "fmt" 6 6 - "log/slog" 7 7 - "strconv" 8 8 - ) 9 9 - 10 10 - // Post describes a Bluesky post 11 11 - type Post struct { 12 12 - ID int 13 13 - RKey string 14 14 - PostURI string 15 15 - UserDID string 16 16 - CreatedAt int64 17 17 - } 18 18 - 19 19 - // PostStore defines the interactions with a store 20 20 - type PostStore interface { 21 21 - GetFeedPosts(cursor, limit int) ([]Post, error) 22 22 - CreatePost(post Post) error 23 23 - } 24 24 - 25 25 - // FeedGenerator is responsible for generating a feed 26 26 - type FeedGenerator struct { 27 27 - store PostStore 28 28 - } 29 29 - 30 30 - func newFeedGenerator(store PostStore) *FeedGenerator { 31 31 - return &FeedGenerator{ 32 32 - store: store, 33 33 - } 34 34 - } 35 35 - 36 36 - // GetFeed will fetch a feed and build up a response that can be returned 37 37 - func (f *FeedGenerator) GetFeed(ctx context.Context, feed, cursor string, limit int) (FeedSkeletonReponse, error) { 38 38 - resp := FeedSkeletonReponse{ 39 39 - Feed: make([]FeedSkeletonPost, 0), 40 40 - } 41 41 - 42 42 - cursorInt, err := strconv.Atoi(cursor) 43 43 - if err != nil && cursor != "" { 44 44 - slog.Error("convert cursor to int", "error", err, "cursor value", cursor) 45 45 - } 46 46 - if cursorInt == 0 { 47 47 - // if no cursor provided use a date waaaaay in the future to start the less than query 48 48 - cursorInt = 9999999999999 49 49 - } 50 50 - 51 51 - posts, err := f.store.GetFeedPosts(cursorInt, limit) 52 52 - if err != nil { 53 53 - return resp, fmt.Errorf("get feed from DB: %w", err) 54 54 - } 55 55 - 56 56 - usersFeed := make([]FeedSkeletonPost, 0, len(posts)) 57 57 - for _, post := range posts { 58 58 - usersFeed = append(usersFeed, FeedSkeletonPost{ 59 59 - Post: post.PostURI, 60 60 - }) 61 61 - } 62 62 - 63 63 - resp.Feed = usersFeed 64 64 - 65 65 - // only set the return cursor if there was at least 1 record returned and that the len of records 66 66 - // being returned is the same as the limit 67 67 - if len(posts) > 0 && len(posts) == limit { 68 68 - lastPost := posts[len(posts)-1] 69 69 - resp.Cursor = fmt.Sprintf("%d", lastPost.CreatedAt) 70 70 - } 71 71 - return resp, nil 72 72 - }

+41 -11

handlers.go

··· 1 1 - package main 1 1 + package feed 2 2 3 3 import ( 4 4 + "context" 4 5 "encoding/json" 5 6 "fmt" 6 7 "log/slog" ··· 66 67 67 68 cursor := params.Get("cursor") 68 69 69 69 - resp, err := s.feeder.GetFeed(r.Context(), feed, cursor, limit) 70 70 + resp, err := s.getFeed(r.Context(), feed, cursor, limit) 70 71 if err != nil { 71 72 slog.Error("get feed", "error", err, "feed", feed) 72 73 http.Error(w, "error getting feed", http.StatusInternalServerError) ··· 103 104 DID: fmt.Sprintf("did:web:%s", s.feedHost), 104 105 Feeds: []Feed{ 105 106 { 106 106 - URI: fmt.Sprintf("at://%s/app.bsky.feed.generator/%s", s.feedDidBase, s.feedName), 107 107 + URI: fmt.Sprintf("at://%s/app.bsky.feed.generator/%s", s.feedHost, s.feedName), 107 108 }, 108 109 }, 109 110 } ··· 167 168 return limit, nil 168 169 } 169 170 170 170 - func checkUserAuth(r *http.Request) (string, error) { 171 171 - usersDID, err := getRequestUserDID(r) 172 172 - if err != nil { 173 173 - return "", fmt.Errorf("getting users did from request: %w", err) 174 174 - } 175 175 - return usersDID, nil 176 176 - } 177 177 - 178 171 func getRequestUserDID(r *http.Request) (string, error) { 179 172 headerValues := r.Header["Authorization"] 180 173 ··· 215 208 216 209 return string(syntax.DID(issVal)), nil 217 210 } 211 211 + 212 212 + func (s *Server) getFeed(ctx context.Context, feed, cursor string, limit int) (FeedSkeletonReponse, error) { 213 213 + resp := FeedSkeletonReponse{ 214 214 + Feed: make([]FeedSkeletonPost, 0), 215 215 + } 216 216 + 217 217 + cursorInt, err := strconv.Atoi(cursor) 218 218 + if err != nil && cursor != "" { 219 219 + slog.Error("convert cursor to int", "error", err, "cursor value", cursor) 220 220 + } 221 221 + if cursorInt == 0 { 222 222 + // if no cursor provided use a date waaaaay in the future to start the less than query 223 223 + cursorInt = 9999999999999 224 224 + } 225 225 + 226 226 + posts, err := s.postStore.GetFeedPosts(cursorInt, limit) 227 227 + if err != nil { 228 228 + return resp, fmt.Errorf("get feed from DB: %w", err) 229 229 + } 230 230 + 231 231 + usersFeed := make([]FeedSkeletonPost, 0, len(posts)) 232 232 + for _, post := range posts { 233 233 + usersFeed = append(usersFeed, FeedSkeletonPost{ 234 234 + Post: post.PostURI, 235 235 + }) 236 236 + } 237 237 + 238 238 + resp.Feed = usersFeed 239 239 + 240 240 + // only set the return cursor if there was at least 1 record returned and that the len of records 241 241 + // being returned is the same as the limit 242 242 + if len(posts) > 0 && len(posts) == limit { 243 243 + lastPost := posts[len(posts)-1] 244 244 + resp.Cursor = fmt.Sprintf("%d", lastPost.CreatedAt) 245 245 + } 246 246 + return resp, nil 247 247 + }

-111

main.go

··· 1 1 - package main 2 2 - 3 3 - import ( 4 4 - "context" 5 5 - "errors" 6 6 - "fmt" 7 7 - "log" 8 8 - "log/slog" 9 9 - "os" 10 10 - "os/signal" 11 11 - "path" 12 12 - "syscall" 13 13 - 14 14 - "github.com/avast/retry-go/v4" 15 15 - "github.com/joho/godotenv" 16 16 - ) 17 17 - 18 18 - const ( 19 19 - defaultJetstreamAddr = "wss://jetstream.atproto.tools/subscribe" 20 20 - serverPort = 443 // this must be the port value used. See https://docs.bsky.app/docs/starter-templates/custom-feeds#deploying-your-feed 21 21 - ) 22 22 - 23 23 - func main() { 24 24 - err := run() 25 25 - if err != nil { 26 26 - log.Fatal(err) 27 27 - } 28 28 - } 29 29 - 30 30 - func run() error { 31 31 - err := godotenv.Load() 32 32 - if err != nil && !os.IsNotExist(err) { 33 33 - return fmt.Errorf("Error loading .env file") 34 34 - } 35 35 - 36 36 - signals := make(chan os.Signal, 1) 37 37 - signal.Notify(signals, syscall.SIGTERM, syscall.SIGINT) 38 38 - 39 39 - feedDidBase := os.Getenv("FEED_DID_BASE") 40 40 - if feedDidBase == "" { 41 41 - return fmt.Errorf("FEED_DID_BASE not set") 42 42 - } 43 43 - feedHost := os.Getenv("FEED_HOST_NAME") 44 44 - if feedHost == "" { 45 45 - return fmt.Errorf("FEED_HOST_NAME not set") 46 46 - } 47 47 - feedName := os.Getenv("FEED_NAME") 48 48 - if feedHost == "" { 49 49 - return fmt.Errorf("FEED_NAME not set") 50 50 - } 51 51 - 52 52 - dbPath := os.Getenv("DATABASE_PATH") 53 53 - if dbPath == "" { 54 54 - dbPath = "./" 55 55 - } 56 56 - 57 57 - dbFilename := path.Join(dbPath, "database.db") 58 58 - database, err := newDatabase(dbFilename) 59 59 - if err != nil { 60 60 - return fmt.Errorf("create new store: %w", err) 61 61 - } 62 62 - defer database.close() 63 63 - 64 64 - feeder := newFeedGenerator(database) 65 65 - 66 66 - ctx, cancel := context.WithCancel(context.Background()) 67 67 - defer cancel() 68 68 - 69 69 - go consumeLoop(ctx, database) 70 70 - 71 71 - server, err := NewServer(serverPort, feedHost, feedDidBase, feedName, feeder) 72 72 - if err != nil { 73 73 - return fmt.Errorf("create new server: %w", err) 74 74 - } 75 75 - go func() { 76 76 - <-signals 77 77 - cancel() 78 78 - _ = server.Stop(context.Background()) 79 79 - }() 80 80 - 81 81 - server.Run() 82 82 - return nil 83 83 - } 84 84 - 85 85 - func consumeLoop(ctx context.Context, database *Database) { 86 86 - handler := Handler{ 87 87 - store: database, 88 88 - } 89 89 - 90 90 - jsServerAddr := os.Getenv("JS_SERVER_ADDR") 91 91 - if jsServerAddr == "" { 92 92 - jsServerAddr = defaultJetstreamAddr 93 93 - } 94 94 - 95 95 - consumer := newJetstreamConsumer(jsServerAddr, slog.Default(), &handler) 96 96 - 97 97 - _ = retry.Do(func() error { 98 98 - err := consumer.Consume(ctx) 99 99 - if err != nil { 100 100 - // if the context has been cancelled then it's time to exit 101 101 - if errors.Is(err, context.Canceled) { 102 102 - return nil 103 103 - } 104 104 - slog.Error("consume loop", "error", err) 105 105 - return err 106 106 - } 107 107 - return nil 108 108 - }, retry.Attempts(0)) // retry indefinitly until context canceled 109 109 - 110 110 - slog.Warn("exiting consume loop") 111 111 - }

+22 -14

server.go

··· 1 1 - package main 1 1 + package feed 2 2 3 3 import ( 4 4 "context" ··· 8 8 "net/http" 9 9 ) 10 10 11 11 - // Feeder describes building up a feed 12 12 - type Feeder interface { 13 13 - GetFeed(ctx context.Context, feed, cursor string, limit int) (FeedSkeletonReponse, error) 11 11 + // Post describes a Bluesky post 12 12 + type Post struct { 13 13 + ID int 14 14 + RKey string 15 15 + PostURI string 16 16 + UserDID string 17 17 + CreatedAt int64 18 18 + } 19 19 + 20 20 + // PostStore defines the interactions with a store 21 21 + type PostStore interface { 22 22 + GetFeedPosts(cursor, limit int) ([]Post, error) 23 23 + CreatePost(post Post) error 14 24 } 15 25 16 26 // Server is the feed server that will be called when a user requests to view a feed 17 27 type Server struct { 18 18 - httpsrv *http.Server 19 19 - feeder Feeder 20 20 - feedHost string 21 21 - feedDidBase string 22 22 - feedName string 28 28 + httpsrv *http.Server 29 29 + postStore PostStore 30 30 + feedHost string 31 31 + feedName string 23 32 } 24 33 25 34 // NewServer builds a server - call the Run function to start the server 26 26 - func NewServer(port int, feedHost, feedDidBase, feedName string, feeder Feeder) (*Server, error) { 35 35 + func NewServer(port int, feedHost, feedName string, postStore PostStore) (*Server, error) { 27 36 srv := &Server{ 28 28 - feedHost: feedHost, 29 29 - feedDidBase: feedDidBase, 30 30 - feedName: feedName, 31 31 - feeder: feeder, 37 37 + feedHost: feedHost, 38 38 + feedName: feedName, 39 39 + postStore: postStore, 32 40 } 33 41 34 42 mux := http.NewServeMux()