feat(backend): favorite + latest-chapter fields, conditional updated_at

Adds favorite, latest_chapter and latest_chapter_num to the bookmark record, with an idempotent ALTER TABLE migration so the already-deployed database picks them up. updated_at now moves only when a bookmark is new or last_chapter_num changes. Clients order their list by updated_at, so favoriting a series or recording a newly published chapter must not disturb that order. Upsert consequently returns the row as stored and the handler echoes that rather than the request payload, since the candidate timestamp it sends is often discarded. Scanning also tolerates NULL in the optional columns, which a database created before this code can legitimately contain. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-07-25 12:06:44 +07:00
parent 053355d0c6
commit 01301805fb
3 changed files with 422 additions and 43 deletions
@@ -9,33 +9,54 @@ import (
 )

 // Bookmark is one tracked series, keyed "<site>:<series_id>" across both sites.
+//
+// LastChapter* is the user's read progress; LatestChapter* is the newest
+// chapter the site has published, captured opportunistically by the userscript.
 type Bookmark struct {
-	Key            string  `json:"key"`
-	Site           string  `json:"site"`
-	SeriesID       string  `json:"series_id"`
-	Title          string  `json:"title"`
-	SeriesURL      string  `json:"series_url"`
-	Cover          string  `json:"cover"`
-	LastChapter    string  `json:"last_chapter"`
-	LastChapterNum float64 `json:"last_chapter_num"`
-	LastChapterURL string  `json:"last_chapter_url"`
-	UpdatedAt      int64   `json:"updated_at"` // unix ms, server-assigned
+	Key              string   `json:"key"`
+	Site             string   `json:"site"`
+	SeriesID         string   `json:"series_id"`
+	Title            string   `json:"title"`
+	SeriesURL        string   `json:"series_url"`
+	Cover            string   `json:"cover"`
+	LastChapter      string   `json:"last_chapter"`
+	LastChapterNum   float64  `json:"last_chapter_num"`
+	LastChapterURL   string   `json:"last_chapter_url"`
+	Favorite         bool     `json:"favorite"`
+	LatestChapter    string   `json:"latest_chapter"`
+	LatestChapterNum *float64 `json:"latest_chapter_num"` // nil until first captured
+	UpdatedAt        int64    `json:"updated_at"`         // unix ms; see Upsert
 }

 const schema = `
 CREATE TABLE IF NOT EXISTS bookmarks (
-  key              TEXT PRIMARY KEY,
-  site             TEXT NOT NULL,
-  series_id        TEXT NOT NULL,
-  title            TEXT,
-  series_url       TEXT,
-  cover            TEXT,
-  last_chapter     TEXT,
-  last_chapter_num REAL,
-  last_chapter_url TEXT,
-  updated_at       INTEGER NOT NULL
+  key                TEXT PRIMARY KEY,
+  site               TEXT NOT NULL,
+  series_id          TEXT NOT NULL,
+  title              TEXT,
+  series_url         TEXT,
+  cover              TEXT,
+  last_chapter       TEXT,
+  last_chapter_num   REAL,
+  last_chapter_url   TEXT,
+  favorite           INTEGER NOT NULL DEFAULT 0,
+  latest_chapter     TEXT NOT NULL DEFAULT '',
+  latest_chapter_num REAL,
+  updated_at         INTEGER NOT NULL
 );`

+// The columns above that databases created before them will be missing.
+// SQLite has no ADD COLUMN IF NOT EXISTS, so each is added only when absent.
+var addedColumns = []struct{ name, ddl string }{
+	{"favorite", `ALTER TABLE bookmarks ADD COLUMN favorite INTEGER NOT NULL DEFAULT 0`},
+	{"latest_chapter", `ALTER TABLE bookmarks ADD COLUMN latest_chapter TEXT NOT NULL DEFAULT ''`},
+	{"latest_chapter_num", `ALTER TABLE bookmarks ADD COLUMN latest_chapter_num REAL`},
+}
+
+const bookmarkColumns = `key, site, series_id, title, series_url, cover,
+	last_chapter, last_chapter_num, last_chapter_url,
+	favorite, latest_chapter, latest_chapter_num, updated_at`
+
 // Store is the SQLite-backed bookmark store.
 type Store struct {
 	db *sql.DB
@@ -58,17 +79,91 @@ func OpenStore(path string) (*Store, error) {
 		db.Close()
 		return nil, fmt.Errorf("apply schema: %w", err)
 	}
+	if err := migrateColumns(db); err != nil {
+		db.Close()
+		return nil, fmt.Errorf("migrate schema: %w", err)
+	}
 	return &Store{db: db}, nil
 }

+// migrateColumns brings a pre-existing bookmarks table up to the current
+// schema. Safe to run on every start: columns already present are skipped.
+func migrateColumns(db *sql.DB) error {
+	have, err := existingColumns(db, "bookmarks")
+	if err != nil {
+		return err
+	}
+	for _, c := range addedColumns {
+		if _, ok := have[c.name]; ok {
+			continue
+		}
+		if _, err := db.Exec(c.ddl); err != nil {
+			return fmt.Errorf("add column %q: %w", c.name, err)
+		}
+	}
+	return nil
+}
+
+func existingColumns(db *sql.DB, table string) (map[string]struct{}, error) {
+	rows, err := db.Query(`SELECT name FROM pragma_table_info(?)`, table)
+	if err != nil {
+		return nil, fmt.Errorf("read %s columns: %w", table, err)
+	}
+	defer rows.Close()
+
+	out := map[string]struct{}{}
+	for rows.Next() {
+		var name string
+		if err := rows.Scan(&name); err != nil {
+			return nil, fmt.Errorf("scan column name: %w", err)
+		}
+		out[name] = struct{}{}
+	}
+	return out, rows.Err()
+}
+
+// scanBookmark reads one row in bookmarkColumns order, translating SQLite's
+// integer bool and nullable latest_chapter_num into Go types.
+//
+// The optional columns are read through Null* types because rows predating
+// this code (or written by hand) may hold NULL where the app only ever writes
+// zero values. Only latest_chapter_num distinguishes the two: everywhere else
+// NULL and the zero value mean the same thing to clients.
+func scanBookmark(scan func(...any) error) (Bookmark, error) {
+	var (
+		b                                          Bookmark
+		title, seriesURL, cover                    sql.NullString
+		lastChapter, lastChapterURL, latestChapter sql.NullString
+		lastChapterNum, latestChapterNum           sql.NullFloat64
+		favorite                                   sql.NullInt64
+	)
+	if err := scan(
+		&b.Key, &b.Site, &b.SeriesID, &title, &seriesURL, &cover,
+		&lastChapter, &lastChapterNum, &lastChapterURL,
+		&favorite, &latestChapter, &latestChapterNum, &b.UpdatedAt,
+	); err != nil {
+		return Bookmark{}, err
+	}
+	b.Title = title.String
+	b.SeriesURL = seriesURL.String
+	b.Cover = cover.String
+	b.LastChapter = lastChapter.String
+	b.LastChapterNum = lastChapterNum.Float64
+	b.LastChapterURL = lastChapterURL.String
+	b.Favorite = favorite.Int64 != 0
+	b.LatestChapter = latestChapter.String
+	if latestChapterNum.Valid {
+		b.LatestChapterNum = &latestChapterNum.Float64
+	}
+	return b, nil
+}
+
 // Close releases the underlying database handle.
 func (s *Store) Close() error { return s.db.Close() }

 // List returns every bookmark, newest activity first.
 func (s *Store) List() ([]Bookmark, error) {
-	rows, err := s.db.Query(`
-		SELECT key, site, series_id, title, series_url, cover,
-		       last_chapter, last_chapter_num, last_chapter_url, updated_at
+	rows, err := s.db.Query(`SELECT ` + bookmarkColumns + `
 		FROM bookmarks
 		ORDER BY updated_at DESC`)
 	if err != nil {
@@ -78,11 +173,8 @@ func (s *Store) List() ([]Bookmark, error) {

 	out := []Bookmark{}
 	for rows.Next() {
-		var b Bookmark
-		if err := rows.Scan(
-			&b.Key, &b.Site, &b.SeriesID, &b.Title, &b.SeriesURL, &b.Cover,
-			&b.LastChapter, &b.LastChapterNum, &b.LastChapterURL, &b.UpdatedAt,
-		); err != nil {
+		b, err := scanBookmark(rows.Scan)
+		if err != nil {
 			return nil, fmt.Errorf("scan bookmark: %w", err)
 		}
 		out = append(out, b)
@@ -90,24 +182,60 @@ func (s *Store) List() ([]Bookmark, error) {
 	return out, rows.Err()
 }

-// Upsert inserts or replaces a bookmark by key (last-write-wins).
-func (s *Store) Upsert(b Bookmark) error {
-	_, err := s.db.Exec(`
-		INSERT INTO bookmarks
-		  (key, site, series_id, title, series_url, cover,
-		   last_chapter, last_chapter_num, last_chapter_url, updated_at)
-		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+// Upsert inserts or replaces a bookmark by key (last-write-wins) and returns
+// the row as actually stored.
+//
+// b.UpdatedAt is only a candidate: it is applied when the row is new or when
+// last_chapter_num changes, and otherwise the stored value is kept. Clients
+// order their list by updated_at, so favoriting a series or recording a newly
+// published chapter must not disturb that order — only real reading progress
+// does. Callers must therefore use the returned bookmark, not the argument.
+func (s *Store) Upsert(b Bookmark) (Bookmark, error) {
+	tx, err := s.db.Begin()
+	if err != nil {
+		return Bookmark{}, fmt.Errorf("begin %q: %w", b.Key, err)
+	}
+	defer tx.Rollback()
+
+	var latestNum any
+	if b.LatestChapterNum != nil {
+		latestNum = *b.LatestChapterNum
+	}
+
+	// IS NOT is SQLite's null-safe comparison. Within DO UPDATE, a bare column
+	// is the stored row and excluded.* is the incoming one; a brand-new key
+	// never reaches this clause, so it keeps the fresh timestamp from VALUES.
+	if _, err := tx.Exec(`
+		INSERT INTO bookmarks (`+bookmarkColumns+`)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
 		ON CONFLICT(key) DO UPDATE SET
 		  site=excluded.site, series_id=excluded.series_id, title=excluded.title,
 		  series_url=excluded.series_url, cover=excluded.cover,
 		  last_chapter=excluded.last_chapter, last_chapter_num=excluded.last_chapter_num,
-		  last_chapter_url=excluded.last_chapter_url, updated_at=excluded.updated_at`,
+		  last_chapter_url=excluded.last_chapter_url,
+		  favorite=excluded.favorite,
+		  latest_chapter=excluded.latest_chapter,
+		  latest_chapter_num=excluded.latest_chapter_num,
+		  updated_at=CASE
+		    WHEN bookmarks.last_chapter_num IS NOT excluded.last_chapter_num
+		    THEN excluded.updated_at
+		    ELSE bookmarks.updated_at
+		  END`,
 		b.Key, b.Site, b.SeriesID, b.Title, b.SeriesURL, b.Cover,
-		b.LastChapter, b.LastChapterNum, b.LastChapterURL, b.UpdatedAt)
-	if err != nil {
-		return fmt.Errorf("upsert %q: %w", b.Key, err)
+		b.LastChapter, b.LastChapterNum, b.LastChapterURL,
+		b.Favorite, b.LatestChapter, latestNum, b.UpdatedAt); err != nil {
+		return Bookmark{}, fmt.Errorf("upsert %q: %w", b.Key, err)
 	}
-	return nil
+
+	stored, err := scanBookmark(tx.QueryRow(
+		`SELECT `+bookmarkColumns+` FROM bookmarks WHERE key = ?`, b.Key).Scan)
+	if err != nil {
+		return Bookmark{}, fmt.Errorf("read back %q: %w", b.Key, err)
+	}
+	if err := tx.Commit(); err != nil {
+		return Bookmark{}, fmt.Errorf("commit %q: %w", b.Key, err)
+	}
+	return stored, nil
 }

 // Delete removes a bookmark by key. Deleting a missing key is not an error.