feat: prepared statements, cache control, and faster sorting

store/configs.go

···
 
 func (db *DB) GetConfig(ctx context.Context, userID int64, filename string) (*Config, error) {
 	var cfg Config
-	err := db.QueryRowContext(ctx,
-		`SELECT id, user_id, filename, email, cron_expr, digest, inline_content, raw_text, last_run, next_run, created_at
-		 FROM configs WHERE user_id = ? AND filename = ?`,
-		userID, filename,
-	).Scan(&cfg.ID, &cfg.UserID, &cfg.Filename, &cfg.Email, &cfg.CronExpr, &cfg.Digest, &cfg.InlineContent, &cfg.RawText, &cfg.LastRun, &cfg.NextRun, &cfg.CreatedAt)
+	err := db.stmts.getConfig.QueryRowContext(ctx, userID, filename).Scan(&cfg.ID, &cfg.UserID, &cfg.Filename, &cfg.Email, &cfg.CronExpr, &cfg.Digest, &cfg.InlineContent, &cfg.RawText, &cfg.LastRun, &cfg.NextRun, &cfg.CreatedAt)
 	if err != nil {
 		return nil, err
 	}
···
 }
 
 func (db *DB) UpdateLastRun(ctx context.Context, configID int64, lastRun, nextRun time.Time) error {
-	_, err := db.ExecContext(ctx,
-		`UPDATE configs SET last_run = ?, next_run = ? WHERE id = ?`,
-		lastRun, nextRun, configID,
-	)
+	_, err := db.stmts.updateConfigRun.ExecContext(ctx, lastRun, nextRun, configID)
 	if err != nil {
 		return fmt.Errorf("update last run: %w", err)
 	}

store/db.go

···
 
 type DB struct {
 	*sql.DB
+	stmts *preparedStmts
+}
+
+type preparedStmts struct {
+	markItemSeen     *sql.Stmt
+	isItemSeen       *sql.Stmt
+	getSeenItems     *sql.Stmt
+	getConfig        *sql.Stmt
+	updateConfigRun  *sql.Stmt
+	updateFeedMeta   *sql.Stmt
+	cleanupSeenItems *sql.Stmt
 }
 
 func Open(path string) (*DB, error) {
···
 		return nil, fmt.Errorf("ping database: %w", err)
 	}
 
-	store := &DB{db}
+	store := &DB{DB: db}
 	if err := store.migrate(); err != nil {
 		return nil, fmt.Errorf("migrate database: %w", err)
+	}
+
+	if err := store.prepareStatements(); err != nil {
+		return nil, fmt.Errorf("prepare statements: %w", err)
 	}
 
 	return store, nil
···
 }
 
 func (db *DB) Close() error {
+	if db.stmts != nil {
+		db.stmts.markItemSeen.Close()
+		db.stmts.isItemSeen.Close()
+		db.stmts.getSeenItems.Close()
+		db.stmts.getConfig.Close()
+		db.stmts.updateConfigRun.Close()
+		db.stmts.updateFeedMeta.Close()
+		db.stmts.cleanupSeenItems.Close()
+	}
 	return db.DB.Close()
+}
+
+func (db *DB) prepareStatements() error {
+	db.stmts = &preparedStmts{}
+
+	var err error
+
+	db.stmts.markItemSeen, err = db.Prepare(
+		`INSERT INTO seen_items (feed_id, guid, title, link) VALUES (?, ?, ?, ?)
+		 ON CONFLICT(feed_id, guid) DO UPDATE SET title = excluded.title, link = excluded.link`)
+	if err != nil {
+		return fmt.Errorf("prepare markItemSeen: %w", err)
+	}
+
+	db.stmts.isItemSeen, err = db.Prepare(
+		`SELECT id FROM seen_items WHERE feed_id = ? AND guid = ?`)
+	if err != nil {
+		return fmt.Errorf("prepare isItemSeen: %w", err)
+	}
+
+	db.stmts.getSeenItems, err = db.Prepare(
+		`SELECT id, feed_id, guid, title, link, seen_at
+		 FROM seen_items WHERE feed_id = ? ORDER BY seen_at DESC LIMIT ?`)
+	if err != nil {
+		return fmt.Errorf("prepare getSeenItems: %w", err)
+	}
+
+	db.stmts.getConfig, err = db.Prepare(
+		`SELECT id, user_id, filename, email, cron_expr, digest, inline_content, raw_text, last_run, next_run, created_at
+		 FROM configs WHERE user_id = ? AND filename = ?`)
+	if err != nil {
+		return fmt.Errorf("prepare getConfig: %w", err)
+	}
+
+	db.stmts.updateConfigRun, err = db.Prepare(
+		`UPDATE configs SET last_run = ?, next_run = ? WHERE id = ?`)
+	if err != nil {
+		return fmt.Errorf("prepare updateConfigRun: %w", err)
+	}
+
+	db.stmts.updateFeedMeta, err = db.Prepare(
+		`UPDATE feeds SET last_fetched = ?, etag = ?, last_modified = ? WHERE id = ?`)
+	if err != nil {
+		return fmt.Errorf("prepare updateFeedMeta: %w", err)
+	}
+
+	db.stmts.cleanupSeenItems, err = db.Prepare(
+		`DELETE FROM seen_items WHERE seen_at < ?`)
+	if err != nil {
+		return fmt.Errorf("prepare cleanupSeenItems: %w", err)
+	}
+
+	return nil
 }
 
 func (db *DB) Migrate(ctx context.Context) error {

store/feeds.go

···
 		lmVal = sql.NullString{String: lastModified, Valid: true}
 	}
 
-	_, err := db.ExecContext(ctx,
-		`UPDATE feeds SET last_fetched = ?, etag = ?, last_modified = ? WHERE id = ?`,
-		time.Now(), etagVal, lmVal, feedID,
-	)
+	_, err := db.stmts.updateFeedMeta.ExecContext(ctx, time.Now(), etagVal, lmVal, feedID)
 	if err != nil {
 		return fmt.Errorf("update feed fetched: %w", err)
 	}

store/items.go

···
 		linkVal = sql.NullString{String: link, Valid: true}
 	}
 
-	_, err := db.ExecContext(ctx,
-		`INSERT INTO seen_items (feed_id, guid, title, link) VALUES (?, ?, ?, ?)
-		 ON CONFLICT(feed_id, guid) DO UPDATE SET title = excluded.title, link = excluded.link`,
-		feedID, guid, titleVal, linkVal,
-	)
+	_, err := db.stmts.markItemSeen.ExecContext(ctx, feedID, guid, titleVal, linkVal)
 	if err != nil {
 		return fmt.Errorf("mark item seen: %w", err)
 	}
···
 
 func (db *DB) IsItemSeen(ctx context.Context, feedID int64, guid string) (bool, error) {
 	var id int64
-	err := db.QueryRowContext(ctx,
-		`SELECT id FROM seen_items WHERE feed_id = ? AND guid = ?`,
-		feedID, guid,
-	).Scan(&id)
+	err := db.stmts.isItemSeen.QueryRowContext(ctx, feedID, guid).Scan(&id)
 	if err != nil {
 		if errors.Is(err, sql.ErrNoRows) {
 			return false, nil
···
 }
 
 func (db *DB) GetSeenItems(ctx context.Context, feedID int64, limit int) ([]*SeenItem, error) {
-	rows, err := db.QueryContext(ctx,
-		`SELECT id, feed_id, guid, title, link, seen_at
-		 FROM seen_items WHERE feed_id = ? ORDER BY seen_at DESC LIMIT ?`,
-		feedID, limit,
-	)
+	rows, err := db.stmts.getSeenItems.QueryContext(ctx, feedID, limit)
 	if err != nil {
 		return nil, fmt.Errorf("query seen items: %w", err)
 	}
···
 // CleanupOldSeenItems deletes seen items older than the specified duration
 func (db *DB) CleanupOldSeenItems(ctx context.Context, olderThan time.Duration) (int64, error) {
 	cutoff := time.Now().Add(-olderThan)
-	result, err := db.ExecContext(ctx,
-		`DELETE FROM seen_items WHERE seen_at < ?`,
-		cutoff,
-	)
+	result, err := db.stmts.cleanupSeenItems.ExecContext(ctx, cutoff)
 	if err != nil {
 		return 0, fmt.Errorf("cleanup old seen items: %w", err)
 	}

web/handlers.go

···
 	PubDate string `xml:"pubDate"`
 }
 
+type rssItemWithTime struct {
+	rssItem
+	parsedTime time.Time
+}
+
 type rssChannel struct {
 	Title       string    `xml:"title"`
 	Link        string    `xml:"link"`
···
 		return
 	}
 
-	var items []rssItem
+	var items []rssItemWithTime
 	feeds, err := s.store.GetFeedsByConfig(ctx, cfg.ID)
 	if err != nil {
 		s.logger.Error("get feeds", "err", err)
···
 			continue
 		}
 		for _, item := range seenItems {
-			rItem := rssItem{
-				GUID:    item.GUID,
-				PubDate: item.SeenAt.Format(time.RFC1123Z),
+			rItem := rssItemWithTime{
+				rssItem: rssItem{
+					GUID:    item.GUID,
+					PubDate: item.SeenAt.Format(time.RFC1123Z),
+				},
+				parsedTime: item.SeenAt,
 			}
 			if item.Title.Valid {
 				rItem.Title = item.Title.String
···
 	}
 
 	sort.Slice(items, func(i, j int) bool {
-		ti, _ := time.Parse(time.RFC1123Z, items[i].PubDate)
-		tj, _ := time.Parse(time.RFC1123Z, items[j].PubDate)
-		return ti.After(tj)
+		return items[i].parsedTime.After(items[j].parsedTime)
 	})
 
 	if len(items) > 100 {
 		items = items[:100]
 	}
 
+	// Convert to rssItem for XML encoding
+	rssItems := make([]rssItem, len(items))
+	for i, item := range items {
+		rssItems[i] = item.rssItem
+	}
+
 	feed := rssFeed{
 		Version: "2.0",
 		Channel: rssChannel{
 			Title:       "Herald - " + configFilename,
 			Link:        s.origin + "/" + fingerprint + "/" + configFilename,
 			Description: "Feed for " + configFilename,
-			Items:       items,
+			Items:       rssItems,
 		},
 	}
 
+	// Add caching headers
 	w.Header().Set("Content-Type", "application/rss+xml; charset=utf-8")
+	w.Header().Set("Cache-Control", "public, max-age=300")
+	if cfg.LastRun.Valid {
+		etag := fmt.Sprintf(`"%s-%d"`, fingerprint[:8], cfg.LastRun.Time.Unix())
+		w.Header().Set("ETag", etag)
+		w.Header().Set("Last-Modified", cfg.LastRun.Time.UTC().Format(http.TimeFormat))
+		
+		// Check If-None-Match
+		if match := r.Header.Get("If-None-Match"); match == etag {
+			w.WriteHeader(http.StatusNotModified)
+			return
+		}
+		
+		// Check If-Modified-Since
+		if modSince := r.Header.Get("If-Modified-Since"); modSince != "" {
+			if t, err := http.ParseTime(modSince); err == nil && !cfg.LastRun.Time.After(t) {
+				w.WriteHeader(http.StatusNotModified)
+				return
+			}
+		}
+	}
+	
 	w.Write([]byte(xml.Header))
 	enc := xml.NewEncoder(w)
 	enc.Indent("", "  ")
···
 	DatePublished string `json:"date_published"`
 }
 
+type jsonFeedItemWithTime struct {
+	jsonFeedItem
+	parsedTime time.Time
+}
+
 func (s *Server) handleFeedJSON(w http.ResponseWriter, r *http.Request, fingerprint, configFilename string) {
 	ctx := r.Context()
 
···
 		return
 	}
 
-	var items []jsonFeedItem
+	var items []jsonFeedItemWithTime
 	feeds, err := s.store.GetFeedsByConfig(ctx, cfg.ID)
 	if err != nil {
 		s.logger.Error("get feeds", "err", err)
···
 			continue
 		}
 		for _, item := range seenItems {
-			jItem := jsonFeedItem{
-				ID:            item.GUID,
-				DatePublished: item.SeenAt.Format(time.RFC3339),
+			jItem := jsonFeedItemWithTime{
+				jsonFeedItem: jsonFeedItem{
+					ID:            item.GUID,
+					DatePublished: item.SeenAt.Format(time.RFC3339),
+				},
+				parsedTime: item.SeenAt,
 			}
 			if item.Title.Valid {
 				jItem.Title = item.Title.String
···
 	}
 
 	sort.Slice(items, func(i, j int) bool {
-		ti, _ := time.Parse(time.RFC3339, items[i].DatePublished)
-		tj, _ := time.Parse(time.RFC3339, items[j].DatePublished)
-		return ti.After(tj)
+		return items[i].parsedTime.After(items[j].parsedTime)
 	})
 
 	if len(items) > 100 {
 		items = items[:100]
 	}
 
+	// Convert to jsonFeedItem for JSON encoding
+	jsonItems := make([]jsonFeedItem, len(items))
+	for i, item := range items {
+		jsonItems[i] = item.jsonFeedItem
+	}
+
 	feed := jsonFeed{
 		Version:     "https://jsonfeed.org/version/1.1",
 		Title:       "Herald - " + configFilename,
 		HomePageURL: s.origin + "/" + fingerprint + "/" + configFilename,
 		FeedURL:     s.origin + "/" + fingerprint + "/" + configFilename + ".json",
-		Items:       items,
+		Items:       jsonItems,
 	}
 
+	// Add caching headers
 	w.Header().Set("Content-Type", "application/feed+json; charset=utf-8")
+	w.Header().Set("Cache-Control", "public, max-age=300")
+	if cfg.LastRun.Valid {
+		etag := fmt.Sprintf(`"%s-%d"`, fingerprint[:8], cfg.LastRun.Time.Unix())
+		w.Header().Set("ETag", etag)
+		w.Header().Set("Last-Modified", cfg.LastRun.Time.UTC().Format(http.TimeFormat))
+		
+		// Check If-None-Match
+		if match := r.Header.Get("If-None-Match"); match == etag {
+			w.WriteHeader(http.StatusNotModified)
+			return
+		}
+		
+		// Check If-Modified-Since
+		if modSince := r.Header.Get("If-Modified-Since"); modSince != "" {
+			if t, err := http.ParseTime(modSince); err == nil && !cfg.LastRun.Time.After(t) {
+				w.WriteHeader(http.StatusNotModified)
+				return
+			}
+		}
+	}
+	
 	enc := json.NewEncoder(w)
 	enc.SetIndent("", "  ")
 	enc.Encode(feed)