nandi/glean · fa08b45

modified internal/atproto/xrpc.go +9 -9 Viewed

@@ -29,8 +29,8 @@ func (h XRPCHandler) ListSubscriptions(w http.ResponseWriter, r http.Request)
29	29
30	30	query := `
31	31	SELECT s.id, f.feed_url, COALESCE(s.title, f.title), s.category, s.added_at
32		- FROM subscriptions s
33		- JOIN feeds f ON s.feed_url = f.feed_url
	32	+ FROM articles.subscriptions s
	33	+ JOIN articles.feeds f ON s.feed_url = f.feed_url
34	34	WHERE s.user_did = ?`
35	35	args := []any{repo}
36	36
@@ -95,7 +95,7 @@ func (h XRPCHandler) ListAnnotations(w http.ResponseWriter, r http.Request) {
95	95	query := `
96	96	SELECT a.uri, a.cid, u.did, a.feed_url, a.article_url,
97	97	a.quote, a.note, a.tags, a.rating, a.created_at
98		- FROM annotations a
	98	+ FROM articles.annotations a
99	99	JOIN users u ON a.author_did = u.did
100	100	WHERE 1=1`
101	101	args := []any{}
@@ -180,7 +180,7 @@ func (h XRPCHandler) ListLikes(w http.ResponseWriter, r http.Request) {
180	180
181	181	query := `
182	182	SELECT l.uri, l.cid, u.did, l.feed_url, l.article_url, l.created_at
183		- FROM likes l
	183	+ FROM articles.likes l
184	184	JOIN users u ON l.author_did = u.did
185	185	WHERE 1=1`
186	186	args := []any{}
@@ -250,8 +250,8 @@ func (h XRPCHandler) GetTrending(w http.ResponseWriter, r http.Request) {
250	250
251	251	query := `
252	252	SELECT l.feed_url, l.article_url, a.title, COUNT(*) as like_count
253		- FROM likes l
254		- LEFT JOIN articles a ON l.article_url = a.url
	253	+ FROM articles.likes l
	254	+ LEFT JOIN articles.articles a ON l.article_url = a.url
255	255	WHERE 1=1`
256	256	args := []any{}
257	257
@@ -372,7 +372,7 @@ func (h XRPCHandler) ListFeedLists(w http.ResponseWriter, r http.Request) {
372	372	query := `
373	373	SELECT u.did, COUNT(s.id) as subscription_count
374	374	FROM users u
375		- LEFT JOIN subscriptions s ON u.did = s.user_did
	375	+ LEFT JOIN articles.subscriptions s ON u.did = s.user_did
376	376	WHERE u.did IN (` + strings.Join(placeholders, ",") + `)`
377	377
378	378	if cursor != "" {
@@ -417,8 +417,8 @@ func (h XRPCHandler) ListFeedLists(w http.ResponseWriter, r http.Request) {
417	417	}
418	418	subRows, err := h.db.QueryContext(r.Context(), `
419	419	SELECT s.user_did, s.feed_url, COALESCE(s.title, f.title), s.category
420		- FROM subscriptions s
421		- JOIN feeds f ON s.feed_url = f.feed_url
	420	+ FROM articles.subscriptions s
	421	+ JOIN articles.feeds f ON s.feed_url = f.feed_url
422	422	WHERE s.user_did IN (`+strings.Join(ph, ",")+`)
423	423	ORDER BY s.user_did, s.added_at DESC
424	424	`, args...)

  	query := `
  		SELECT s.id, f.feed_url, COALESCE(s.title, f.title), s.category, s.added_at
--		FROM subscriptions s
++		FROM articles.subscriptions s
--		JOIN feeds f ON s.feed_url = f.feed_url
++		JOIN articles.feeds f ON s.feed_url = f.feed_url
  		WHERE s.user_did = ?`
  	args := []any{repo}
  	query := `
  		SELECT a.uri, a.cid, u.did, a.feed_url, a.article_url,
  		       a.quote, a.note, a.tags, a.rating, a.created_at
--		FROM annotations a
++		FROM articles.annotations a
  		JOIN users u ON a.author_did = u.did
  		WHERE 1=1`
  	args := []any{}
  	query := `
  		SELECT l.uri, l.cid, u.did, l.feed_url, l.article_url, l.created_at
--		FROM likes l
++		FROM articles.likes l
  		JOIN users u ON l.author_did = u.did
  		WHERE 1=1`
  	args := []any{}
  	query := `
  		SELECT l.feed_url, l.article_url, a.title, COUNT(*) as like_count
--		FROM likes l
++		FROM articles.likes l
--		LEFT JOIN articles a ON l.article_url = a.url
++		LEFT JOIN articles.articles a ON l.article_url = a.url
  		WHERE 1=1`
  	args := []any{}
  	query := `
  		SELECT u.did, COUNT(s.id) as subscription_count
  		FROM users u
--		LEFT JOIN subscriptions s ON u.did = s.user_did
++		LEFT JOIN articles.subscriptions s ON u.did = s.user_did
  		WHERE u.did IN (` + strings.Join(placeholders, ",") + `)`
  	if cursor != "" {
  		}
  		subRows, err := h.db.QueryContext(r.Context(), `
  			SELECT s.user_did, s.feed_url, COALESCE(s.title, f.title), s.category
--			FROM subscriptions s
++			FROM articles.subscriptions s
--			JOIN feeds f ON s.feed_url = f.feed_url
++			JOIN articles.feeds f ON s.feed_url = f.feed_url
  			WHERE s.user_did IN (`+strings.Join(ph, ",")+`)
  			ORDER BY s.user_did, s.added_at DESC
  		`, args...)

modified internal/db/db.go +0 -226 Viewed

@@ -57,229 +57,3 @@ func NullStrTags(tags []string) sql.NullString {
57	57	type DB struct {
58	58	*sql.DB
59	59	}
60		-
61		-func (d *DB) Close() error {
62		- return d.DB.Close()
63		-}
64		-
65		-func Open(path string) (*DB, error) {
66		- db, err := sql.Open("sqlite3_glean", path+"?cache=shared&"+DSN)
67		- if err != nil {
68		- return nil, err
69		- }
70		-
71		- db.SetMaxOpenConns(10)
72		- db.SetMaxIdleConns(5)
73		- db.SetConnMaxLifetime(30 * time.Minute)
74		-
75		- wrapped := &DB{db}
76		- if err := initSchema(wrapped); err != nil {
77		- db.Close()
78		- return nil, err
79		- }
80		-
81		- return wrapped, nil
82		-}
83		-
84		-func initSchema(db *DB) error {
85		- for _, s := range schema {
86		- if _, err := db.Exec(s); err != nil {
87		- return err
88		- }
89		- }
90		- return nil
91		-}
92		-
93		-var schema = []string{
94		- `CREATE TABLE IF NOT EXISTS users (
95		- did TEXT PRIMARY KEY,
96		- indexed_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
97		- updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
98		- )`,
99		- `CREATE TABLE IF NOT EXISTS feeds (
100		- feed_url TEXT PRIMARY KEY,
101		- title TEXT,
102		- site_url TEXT,
103		- description TEXT,
104		- feed_type TEXT CHECK(feed_type IN ('rss', 'atom', 'json')),
105		- last_fetched_at DATETIME,
106		- last_error TEXT,
107		- subscriber_count INTEGER NOT NULL DEFAULT 0,
108		- etag TEXT,
109		- last_modified TEXT,
110		- consecutive_empty_fetches INTEGER NOT NULL DEFAULT 0,
111		- error_count INTEGER NOT NULL DEFAULT 0,
112		- favicon_url TEXT
113		- )`,
114		- `CREATE TABLE IF NOT EXISTS subscriptions (
115		- id INTEGER PRIMARY KEY AUTOINCREMENT,
116		- user_did TEXT NOT NULL,
117		- feed_url TEXT NOT NULL,
118		- title TEXT,
119		- category TEXT,
120		- added_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
121		- uri TEXT,
122		- cid TEXT,
123		- UNIQUE(user_did, feed_url)
124		- )`,
125		- `CREATE TABLE IF NOT EXISTS articles (
126		- id INTEGER PRIMARY KEY AUTOINCREMENT,
127		- feed_url TEXT NOT NULL,
128		- guid TEXT NOT NULL,
129		- title TEXT NOT NULL DEFAULT '',
130		- url TEXT,
131		- author TEXT,
132		- summary TEXT,
133		- content TEXT,
134		- full_content TEXT,
135		- published DATETIME,
136		- updated DATETIME,
137		- fetched_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
138		- UNIQUE(feed_url, guid)
139		- )`,
140		- `CREATE TABLE IF NOT EXISTS read_state (
141		- user_did TEXT NOT NULL,
142		- article_id INTEGER NOT NULL,
143		- is_read BOOLEAN NOT NULL DEFAULT 0,
144		- read_at DATETIME,
145		- PRIMARY KEY (user_did, article_id)
146		- )`,
147		- `CREATE TABLE IF NOT EXISTS annotations (
148		- id INTEGER PRIMARY KEY AUTOINCREMENT,
149		- uri TEXT NOT NULL UNIQUE,
150		- author_did TEXT NOT NULL,
151		- feed_url TEXT NOT NULL,
152		- article_url TEXT NOT NULL,
153		- quote TEXT,
154		- note TEXT,
155		- tags TEXT,
156		- rating INTEGER,
157		- created_at DATETIME NOT NULL,
158		- cid TEXT
159		- )`,
160		- `CREATE TABLE IF NOT EXISTS likes (
161		- id INTEGER PRIMARY KEY AUTOINCREMENT,
162		- uri TEXT NOT NULL UNIQUE,
163		- author_did TEXT NOT NULL,
164		- feed_url TEXT NOT NULL,
165		- article_url TEXT NOT NULL,
166		- created_at DATETIME NOT NULL,
167		- cid TEXT,
168		- UNIQUE(author_did, feed_url, article_url)
169		- )`,
170		- `CREATE TABLE IF NOT EXISTS feed_similarity (
171		- feed_a TEXT NOT NULL,
172		- feed_b TEXT NOT NULL,
173		- jaccard REAL NOT NULL,
174		- computed_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
175		- PRIMARY KEY (feed_a, feed_b),
176		- CHECK(feed_a < feed_b)
177		- )`,
178		- `CREATE TABLE IF NOT EXISTS user_similarity (
179		- user_a TEXT NOT NULL,
180		- user_b TEXT NOT NULL,
181		- jaccard REAL NOT NULL,
182		- common_feeds INTEGER NOT NULL,
183		- common_likes INTEGER NOT NULL DEFAULT 0,
184		- common_tags INTEGER NOT NULL DEFAULT 0,
185		- computed_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
186		- PRIMARY KEY (user_a, user_b),
187		- CHECK(user_a < user_b)
188		- )`,
189		- `CREATE TABLE IF NOT EXISTS follows (
190		- user_did TEXT NOT NULL,
191		- target_did TEXT NOT NULL,
192		- uri TEXT,
193		- cid TEXT,
194		- followed_at DATETIME,
195		- PRIMARY KEY (user_did, target_did)
196		- )`,
197		- `CREATE TABLE IF NOT EXISTS oauth_auth_requests (
198		- state TEXT PRIMARY KEY,
199		- data TEXT NOT NULL
200		- )`,
201		- `CREATE TABLE IF NOT EXISTS oauth_sessions (
202		- account_did TEXT NOT NULL,
203		- session_id TEXT NOT NULL,
204		- data TEXT NOT NULL,
205		- PRIMARY KEY (account_did, session_id)
206		- )`,
207		- `CREATE TABLE IF NOT EXISTS dismissed_recommendations (
208		- user_did TEXT NOT NULL,
209		- target_type TEXT NOT NULL CHECK(target_type IN ('feed', 'article')),
210		- target_id TEXT NOT NULL,
211		- reason TEXT,
212		- dismissed_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
213		- PRIMARY KEY (user_did, target_type, target_id)
214		- )`,
215		- `CREATE TABLE IF NOT EXISTS recommendation_impressions (
216		- user_did TEXT NOT NULL,
217		- target_type TEXT NOT NULL CHECK(target_type IN ('feed', 'article')),
218		- target_id TEXT NOT NULL,
219		- first_shown_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
220		- last_shown_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
221		- shown_count INTEGER NOT NULL DEFAULT 1,
222		- acted BOOLEAN NOT NULL DEFAULT 0,
223		- PRIMARY KEY (user_did, target_type, target_id)
224		- )`,
225		- `CREATE TABLE IF NOT EXISTS follow_distances (
226		- user_a TEXT NOT NULL,
227		- user_b TEXT NOT NULL,
228		- distance INTEGER NOT NULL CHECK(distance IN (1, 2)),
229		- PRIMARY KEY (user_a, user_b)
230		- )`,
231		- `CREATE TABLE IF NOT EXISTS user_signal_weights (
232		- user_did TEXT PRIMARY KEY,
233		- w_sub REAL NOT NULL DEFAULT 1.0,
234		- w_like REAL NOT NULL DEFAULT 0.5,
235		- w_tag REAL NOT NULL DEFAULT 0.3,
236		- w_social REAL NOT NULL DEFAULT 0.7,
237		- w_pop REAL NOT NULL DEFAULT 0.2,
238		- w_category REAL NOT NULL DEFAULT 0.4,
239		- updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
240		- )`,
241		- `CREATE TABLE IF NOT EXISTS user_signal_profiles (
242		- user_did TEXT PRIMARY KEY,
243		- total_likes INTEGER NOT NULL DEFAULT 0,
244		- total_tags INTEGER NOT NULL DEFAULT 0,
245		- top_categories TEXT,
246		- updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
247		- )`,
248		- `CREATE INDEX IF NOT EXISTS idx_subscriptions_feed ON subscriptions(feed_url)`,
249		- `CREATE INDEX IF NOT EXISTS idx_subscriptions_feed_user ON subscriptions(feed_url, user_did)`,
250		- `CREATE INDEX IF NOT EXISTS idx_subscriptions_user ON subscriptions(user_did)`,
251		- `CREATE INDEX IF NOT EXISTS idx_subscriptions_uri ON subscriptions(uri)`,
252		- `CREATE INDEX IF NOT EXISTS idx_likes_author_feed ON likes(author_did, feed_url, created_at)`,
253		- `CREATE INDEX IF NOT EXISTS idx_articles_feed ON articles(feed_url)`,
254		- `CREATE INDEX IF NOT EXISTS idx_articles_published ON articles(published DESC)`,
255		- `CREATE INDEX IF NOT EXISTS idx_articles_url ON articles(url)`,
256		- `CREATE INDEX IF NOT EXISTS idx_read_state_unread ON read_state(user_did, is_read) WHERE is_read = 0`,
257		- `CREATE INDEX IF NOT EXISTS idx_annotations_article ON annotations(article_url)`,
258		- `CREATE INDEX IF NOT EXISTS idx_annotations_author ON annotations(author_did)`,
259		- `CREATE INDEX IF NOT EXISTS idx_annotations_created_at ON annotations(created_at DESC)`,
260		- `CREATE INDEX IF NOT EXISTS idx_likes_article ON likes(feed_url, article_url)`,
261		- `CREATE INDEX IF NOT EXISTS idx_likes_author ON likes(author_did)`,
262		- `CREATE INDEX IF NOT EXISTS idx_likes_created_at ON likes(created_at DESC)`,
263		- `CREATE INDEX IF NOT EXISTS idx_follows_user ON follows(user_did)`,
264		- `CREATE INDEX IF NOT EXISTS idx_follows_target ON follows(target_did)`,
265		- `CREATE INDEX IF NOT EXISTS idx_follows_uri ON follows(uri)`,
266		- `CREATE INDEX IF NOT EXISTS idx_user_similarity_b ON user_similarity(user_b)`,
267		- `CREATE INDEX IF NOT EXISTS idx_user_similarity_a ON user_similarity(user_a)`,
268		- `CREATE INDEX IF NOT EXISTS idx_dismissed_user_type ON dismissed_recommendations(user_did, target_type)`,
269		- `CREATE INDEX IF NOT EXISTS idx_impressions_user_unacted ON recommendation_impressions(user_did, acted, shown_count)`,
270		- `CREATE INDEX IF NOT EXISTS idx_impressions_last_shown ON recommendation_impressions(last_shown_at)`,
271		- `CREATE INDEX IF NOT EXISTS idx_follow_distances_b ON follow_distances(user_b)`,
272		- `CREATE INDEX IF NOT EXISTS idx_follow_distances_a_dist ON follow_distances(user_a, distance)`,
273		- `CREATE INDEX IF NOT EXISTS idx_follows_followed_at ON follows(followed_at)`,
274		- `CREATE VIRTUAL TABLE IF NOT EXISTS articles_fts USING fts5(title, summary, content, author, content=articles, content_rowid=id)`,
275		- `CREATE TRIGGER IF NOT EXISTS articles_ai AFTER INSERT ON articles BEGIN
276		- INSERT INTO articles_fts(rowid, title, summary, content, author) VALUES (new.id, new.title, new.summary, new.content, new.author);
277		- END`,
278		- `CREATE TRIGGER IF NOT EXISTS articles_ad AFTER DELETE ON articles BEGIN
279		- INSERT INTO articles_fts(articles_fts, rowid, title, summary, content, author) VALUES('delete', old.id, old.title, old.summary, old.content, old.author);
280		- END`,
281		- `CREATE TRIGGER IF NOT EXISTS articles_au AFTER UPDATE ON articles BEGIN
282		- INSERT INTO articles_fts(articles_fts, rowid, title, summary, content, author) VALUES('delete', old.id, old.title, old.summary, old.content, old.author);
283		- INSERT INTO articles_fts(rowid, title, summary, content, author) VALUES (new.id, new.title, new.summary, new.content, new.author);
284		- END`,
285		-}

  type DB struct {
  	*sql.DB
  }
--
--func (d *DB) Close() error {
--	return d.DB.Close()
--}
--
--func Open(path string) (*DB, error) {
--	db, err := sql.Open("sqlite3_glean", path+"?cache=shared&"+DSN)
--	if err != nil {
--		return nil, err
--	}
--
--	db.SetMaxOpenConns(10)
--	db.SetMaxIdleConns(5)
--	db.SetConnMaxLifetime(30 * time.Minute)
--
--	wrapped := &DB{db}
--	if err := initSchema(wrapped); err != nil {
--		db.Close()
--		return nil, err
--	}
--
--	return wrapped, nil
--}
--
--func initSchema(db *DB) error {
--	for _, s := range schema {
--		if _, err := db.Exec(s); err != nil {
--			return err
--		}
--	}
--	return nil
--}
--
--var schema = []string{
--	`CREATE TABLE IF NOT EXISTS users (
--		did TEXT PRIMARY KEY,
--		indexed_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
--		updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
--	)`,
--	`CREATE TABLE IF NOT EXISTS feeds (
--		feed_url TEXT PRIMARY KEY,
--		title TEXT,
--		site_url TEXT,
--		description TEXT,
--		feed_type TEXT CHECK(feed_type IN ('rss', 'atom', 'json')),
--		last_fetched_at DATETIME,
--		last_error TEXT,
--		subscriber_count INTEGER NOT NULL DEFAULT 0,
--		etag TEXT,
--		last_modified TEXT,
--		consecutive_empty_fetches INTEGER NOT NULL DEFAULT 0,
--		error_count INTEGER NOT NULL DEFAULT 0,
--		favicon_url TEXT
--	)`,
--	`CREATE TABLE IF NOT EXISTS subscriptions (
--		id INTEGER PRIMARY KEY AUTOINCREMENT,
--		user_did TEXT NOT NULL,
--		feed_url TEXT NOT NULL,
--		title TEXT,
--		category TEXT,
--		added_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
--		uri TEXT,
--		cid TEXT,
--		UNIQUE(user_did, feed_url)
--	)`,
--	`CREATE TABLE IF NOT EXISTS articles (
--		id INTEGER PRIMARY KEY AUTOINCREMENT,
--		feed_url TEXT NOT NULL,
--		guid TEXT NOT NULL,
--		title TEXT NOT NULL DEFAULT '',
--		url TEXT,
--		author TEXT,
--		summary TEXT,
--		content TEXT,
--		full_content TEXT,
--		published DATETIME,
--		updated DATETIME,
--		fetched_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
--		UNIQUE(feed_url, guid)
--	)`,
--	`CREATE TABLE IF NOT EXISTS read_state (
--		user_did TEXT NOT NULL,
--		article_id INTEGER NOT NULL,
--		is_read BOOLEAN NOT NULL DEFAULT 0,
--		read_at DATETIME,
--		PRIMARY KEY (user_did, article_id)
--	)`,
--	`CREATE TABLE IF NOT EXISTS annotations (
--		id INTEGER PRIMARY KEY AUTOINCREMENT,
--		uri TEXT NOT NULL UNIQUE,
--		author_did TEXT NOT NULL,
--		feed_url TEXT NOT NULL,
--		article_url TEXT NOT NULL,
--		quote TEXT,
--		note TEXT,
--		tags TEXT,
--		rating INTEGER,
--		created_at DATETIME NOT NULL,
--		cid TEXT
--	)`,
--	`CREATE TABLE IF NOT EXISTS likes (
--		id INTEGER PRIMARY KEY AUTOINCREMENT,
--		uri TEXT NOT NULL UNIQUE,
--		author_did TEXT NOT NULL,
--		feed_url TEXT NOT NULL,
--		article_url TEXT NOT NULL,
--		created_at DATETIME NOT NULL,
--		cid TEXT,
--		UNIQUE(author_did, feed_url, article_url)
--	)`,
--	`CREATE TABLE IF NOT EXISTS feed_similarity (
--		feed_a TEXT NOT NULL,
--		feed_b TEXT NOT NULL,
--		jaccard REAL NOT NULL,
--		computed_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
--		PRIMARY KEY (feed_a, feed_b),
--		CHECK(feed_a < feed_b)
--	)`,
--	`CREATE TABLE IF NOT EXISTS user_similarity (
--		user_a TEXT NOT NULL,
--		user_b TEXT NOT NULL,
--		jaccard REAL NOT NULL,
--		common_feeds INTEGER NOT NULL,
--		common_likes INTEGER NOT NULL DEFAULT 0,
--		common_tags INTEGER NOT NULL DEFAULT 0,
--		computed_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
--		PRIMARY KEY (user_a, user_b),
--		CHECK(user_a < user_b)
--	)`,
--	`CREATE TABLE IF NOT EXISTS follows (
--		user_did TEXT NOT NULL,
--		target_did TEXT NOT NULL,
--		uri TEXT,
--		cid TEXT,
--		followed_at DATETIME,
--		PRIMARY KEY (user_did, target_did)
--	)`,
--	`CREATE TABLE IF NOT EXISTS oauth_auth_requests (
--		state TEXT PRIMARY KEY,
--		data TEXT NOT NULL
--	)`,
--	`CREATE TABLE IF NOT EXISTS oauth_sessions (
--		account_did TEXT NOT NULL,
--		session_id TEXT NOT NULL,
--		data TEXT NOT NULL,
--		PRIMARY KEY (account_did, session_id)
--	)`,
--	`CREATE TABLE IF NOT EXISTS dismissed_recommendations (
--		user_did     TEXT NOT NULL,
--		target_type  TEXT NOT NULL CHECK(target_type IN ('feed', 'article')),
--		target_id    TEXT NOT NULL,
--		reason       TEXT,
--		dismissed_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
--		PRIMARY KEY (user_did, target_type, target_id)
--	)`,
--	`CREATE TABLE IF NOT EXISTS recommendation_impressions (
--		user_did       TEXT NOT NULL,
--		target_type    TEXT NOT NULL CHECK(target_type IN ('feed', 'article')),
--		target_id      TEXT NOT NULL,
--		first_shown_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
--		last_shown_at  DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
--		shown_count    INTEGER NOT NULL DEFAULT 1,
--		acted          BOOLEAN NOT NULL DEFAULT 0,
--		PRIMARY KEY (user_did, target_type, target_id)
--	)`,
--	`CREATE TABLE IF NOT EXISTS follow_distances (
--		user_a   TEXT NOT NULL,
--		user_b   TEXT NOT NULL,
--		distance INTEGER NOT NULL CHECK(distance IN (1, 2)),
--		PRIMARY KEY (user_a, user_b)
--	)`,
--	`CREATE TABLE IF NOT EXISTS user_signal_weights (
--		user_did   TEXT PRIMARY KEY,
--		w_sub      REAL NOT NULL DEFAULT 1.0,
--		w_like     REAL NOT NULL DEFAULT 0.5,
--		w_tag      REAL NOT NULL DEFAULT 0.3,
--		w_social   REAL NOT NULL DEFAULT 0.7,
--		w_pop      REAL NOT NULL DEFAULT 0.2,
--		w_category REAL NOT NULL DEFAULT 0.4,
--		updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
--	)`,
--	`CREATE TABLE IF NOT EXISTS user_signal_profiles (
--		user_did       TEXT PRIMARY KEY,
--		total_likes     INTEGER NOT NULL DEFAULT 0,
--		total_tags      INTEGER NOT NULL DEFAULT 0,
--		top_categories  TEXT,
--		updated_at      DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
--	)`,
--	`CREATE INDEX IF NOT EXISTS idx_subscriptions_feed ON subscriptions(feed_url)`,
--	`CREATE INDEX IF NOT EXISTS idx_subscriptions_feed_user ON subscriptions(feed_url, user_did)`,
--	`CREATE INDEX IF NOT EXISTS idx_subscriptions_user ON subscriptions(user_did)`,
--	`CREATE INDEX IF NOT EXISTS idx_subscriptions_uri ON subscriptions(uri)`,
--	`CREATE INDEX IF NOT EXISTS idx_likes_author_feed ON likes(author_did, feed_url, created_at)`,
--	`CREATE INDEX IF NOT EXISTS idx_articles_feed ON articles(feed_url)`,
--	`CREATE INDEX IF NOT EXISTS idx_articles_published ON articles(published DESC)`,
--	`CREATE INDEX IF NOT EXISTS idx_articles_url ON articles(url)`,
--	`CREATE INDEX IF NOT EXISTS idx_read_state_unread ON read_state(user_did, is_read) WHERE is_read = 0`,
--	`CREATE INDEX IF NOT EXISTS idx_annotations_article ON annotations(article_url)`,
--	`CREATE INDEX IF NOT EXISTS idx_annotations_author ON annotations(author_did)`,
--	`CREATE INDEX IF NOT EXISTS idx_annotations_created_at ON annotations(created_at DESC)`,
--	`CREATE INDEX IF NOT EXISTS idx_likes_article ON likes(feed_url, article_url)`,
--	`CREATE INDEX IF NOT EXISTS idx_likes_author ON likes(author_did)`,
--	`CREATE INDEX IF NOT EXISTS idx_likes_created_at ON likes(created_at DESC)`,
--	`CREATE INDEX IF NOT EXISTS idx_follows_user ON follows(user_did)`,
--	`CREATE INDEX IF NOT EXISTS idx_follows_target ON follows(target_did)`,
--	`CREATE INDEX IF NOT EXISTS idx_follows_uri ON follows(uri)`,
--	`CREATE INDEX IF NOT EXISTS idx_user_similarity_b ON user_similarity(user_b)`,
--	`CREATE INDEX IF NOT EXISTS idx_user_similarity_a ON user_similarity(user_a)`,
--	`CREATE INDEX IF NOT EXISTS idx_dismissed_user_type ON dismissed_recommendations(user_did, target_type)`,
--	`CREATE INDEX IF NOT EXISTS idx_impressions_user_unacted ON recommendation_impressions(user_did, acted, shown_count)`,
--	`CREATE INDEX IF NOT EXISTS idx_impressions_last_shown ON recommendation_impressions(last_shown_at)`,
--	`CREATE INDEX IF NOT EXISTS idx_follow_distances_b ON follow_distances(user_b)`,
--	`CREATE INDEX IF NOT EXISTS idx_follow_distances_a_dist ON follow_distances(user_a, distance)`,
--	`CREATE INDEX IF NOT EXISTS idx_follows_followed_at ON follows(followed_at)`,
--	`CREATE VIRTUAL TABLE IF NOT EXISTS articles_fts USING fts5(title, summary, content, author, content=articles, content_rowid=id)`,
--	`CREATE TRIGGER IF NOT EXISTS articles_ai AFTER INSERT ON articles BEGIN
--		INSERT INTO articles_fts(rowid, title, summary, content, author) VALUES (new.id, new.title, new.summary, new.content, new.author);
--	END`,
--	`CREATE TRIGGER IF NOT EXISTS articles_ad AFTER DELETE ON articles BEGIN
--		INSERT INTO articles_fts(articles_fts, rowid, title, summary, content, author) VALUES('delete', old.id, old.title, old.summary, old.content, old.author);
--	END`,
--	`CREATE TRIGGER IF NOT EXISTS articles_au AFTER UPDATE ON articles BEGIN
--		INSERT INTO articles_fts(articles_fts, rowid, title, summary, content, author) VALUES('delete', old.id, old.title, old.summary, old.content, old.author);
--		INSERT INTO articles_fts(rowid, title, summary, content, author) VALUES (new.id, new.title, new.summary, new.content, new.author);
--	END`,
--}

modified internal/db/feed.go +47 -68 Viewed

@@ -6,6 +6,8 @@ import (
6	6	"errors"
7	7	"strings"
8	8	"time"
	9	+
	10	+ "pkg.rbrt.fr/glean/internal/feed"
9	11	)
10	12
11	13	var ErrDuplicateSubscription = errors.New("already subscribed to this feed")
@@ -26,6 +28,19 @@ type Feed struct {
26	28	FaviconURL sql.NullString
27	29	}
28	30
	31	+func (f Feed) ToFeed() feed.Feed {
	32	+ return &feed.Feed{
	33	+ URL: f.FeedURL,
	34	+ Title: f.Title.String,
	35	+ SiteURL: f.SiteURL.String,
	36	+ Description: f.Description.String,
	37	+ Type: f.FeedType.String,
	38	+ FaviconURL: f.FaviconURL.String,
	39	+ ETag: f.Etag.String,
	40	+ LastModified: f.LastModified.String,
	41	+ }
	42	+}
	43	+
29	44	type Subscription struct {
30	45	ID int64
31	46	UserDID string
@@ -39,37 +54,34 @@ type Subscription struct {
39	54	FaviconURL sql.NullString
40	55	}
41	56
42		-func (s ArticleStore) UpsertFeed(ctx context.Context, feed Feed) error {
43		- return s.BatchUpsertFeeds(ctx, []*Feed{feed})
44		-}
	57	+const feedSelectCols = `feed_url, title, site_url, description, feed_type,
	58	+ last_fetched_at, last_error, subscriber_count, etag, last_modified,
	59	+ consecutive_empty_fetches, error_count, favicon_url`
45	60
46		-func (s ArticleStore) GetFeed(ctx context.Context, feedURL string) (Feed, error) {
	61	+func scanFeed(scanner interface{ Scan(...any) error }) (*Feed, error) {
47	62	f := &Feed{}
48		- err := s.db.QueryRowContext(ctx, `
49		- SELECT feed_url, title, site_url, description, feed_type,
50		- last_fetched_at, last_error, subscriber_count, etag, last_modified,
51		- consecutive_empty_fetches, error_count, favicon_url
52		- FROM articles.feeds WHERE feed_url = ?
53		- `, feedURL).Scan(&f.FeedURL, &f.Title, &f.SiteURL, &f.Description, &f.FeedType,
	63	+ if err := scanner.Scan(&f.FeedURL, &f.Title, &f.SiteURL, &f.Description, &f.FeedType,
54	64	&f.LastFetchedAt, &f.LastError, &f.SubscriberCount, &f.Etag, &f.LastModified,
55		- &f.ConsecutiveEmptyFetches, &f.ErrorCount, &f.FaviconURL)
56		- if err != nil {
	65	+ &f.ConsecutiveEmptyFetches, &f.ErrorCount, &f.FaviconURL); err != nil {
57	66	return nil, err
58	67	}
59	68	return f, nil
60	69	}
61	70
	71	+func (s ArticleStore) UpsertFeed(ctx context.Context, feed Feed) error {
	72	+ return s.BatchUpsertFeeds(ctx, []*Feed{feed})
	73	+}
	74	+
	75	+func (s ArticleStore) GetFeed(ctx context.Context, feedURL string) (Feed, error) {
	76	+ row := s.db.QueryRowContext(ctx, `SELECT `+feedSelectCols+` FROM articles.feeds WHERE feed_url = ?`, feedURL)
	77	+ return scanFeed(row)
	78	+}
	79	+
62	80	func (s ArticleStore) GetFeedsToFetch(ctx context.Context, olderThan time.Duration, limit int) ([]Feed, error) {
63	81	cutoff := time.Now().Add(-olderThan)
64		- rows, err := s.db.QueryContext(ctx, `
65		- SELECT feed_url, title, site_url, description, feed_type,
66		- last_fetched_at, last_error, subscriber_count, etag, last_modified,
67		- consecutive_empty_fetches, error_count, favicon_url
68		- FROM articles.feeds
	82	+ rows, err := s.db.QueryContext(ctx, `SELECT `+feedSelectCols+` FROM articles.feeds
69	83	WHERE subscriber_count > 0 AND error_count < 25 AND (last_fetched_at IS NULL OR last_fetched_at <= ?)
70		- ORDER BY last_fetched_at ASC NULLS FIRST
71		- LIMIT ?
72		- `, cutoff, limit)
	84	+ ORDER BY last_fetched_at ASC NULLS FIRST LIMIT ?`, cutoff, limit)
73	85	if err != nil {
74	86	return nil, err
75	87	}
@@ -77,10 +89,8 @@ func (s *ArticleStore) GetFeedsToFetch(ctx context.Context, olderThan time.Durat
77	89
78	90	var feeds []*Feed
79	91	for rows.Next() {
80		- f := &Feed{}
81		- if err := rows.Scan(&f.FeedURL, &f.Title, &f.SiteURL, &f.Description, &f.FeedType,
82		- &f.LastFetchedAt, &f.LastError, &f.SubscriberCount, &f.Etag, &f.LastModified,
83		- &f.ConsecutiveEmptyFetches, &f.ErrorCount, &f.FaviconURL); err != nil {
	92	+ f, err := scanFeed(rows)
	93	+ if err != nil {
84	94	return nil, err
85	95	}
86	96	feeds = append(feeds, f)
@@ -137,13 +147,6 @@ func (s *ArticleStore) updateSubscriptionURI(ctx context.Context, userDID, feedU
137	147	return err
138	148	}
139	149
140		-func uriOrNil(v string) any {
141		- if v == "" {
142		- return nil
143		- }
144		- return v
145		-}
146		-
147	150	func nilIfEmpty(v string) any {
148	151	if v == "" {
149	152	return nil
@@ -306,15 +309,9 @@ func (s *ArticleStore) UpdateFeedFavicon(ctx context.Context, feedURL, faviconUR
306	309	}
307	310
308	311	func (s ArticleStore) ListDeadFeeds(ctx context.Context, userDID string, threshold int) ([]Feed, error) {
309		- rows, err := s.db.QueryContext(ctx, `
310		- SELECT f.feed_url, f.title, f.site_url, f.description, f.feed_type,
311		- f.last_fetched_at, f.last_error, f.subscriber_count, f.etag, f.last_modified,
312		- f.consecutive_empty_fetches, f.error_count, f.favicon_url
313		- FROM articles.feeds f
	312	+ rows, err := s.db.QueryContext(ctx, `SELECT `+feedSelectCols+` FROM articles.feeds f
314	313	JOIN articles.subscriptions s ON s.feed_url = f.feed_url AND s.user_did = ?
315		- WHERE f.error_count >= ?
316		- ORDER BY f.error_count DESC
317		- `, userDID, threshold)
	314	+ WHERE f.error_count >= ? ORDER BY f.error_count DESC`, userDID, threshold)
318	315	if err != nil {
319	316	return nil, err
320	317	}
@@ -322,10 +319,8 @@ func (s *ArticleStore) ListDeadFeeds(ctx context.Context, userDID string, thresh
322	319
323	320	var feeds []*Feed
324	321	for rows.Next() {
325		- f := &Feed{}
326		- if err := rows.Scan(&f.FeedURL, &f.Title, &f.SiteURL, &f.Description, &f.FeedType,
327		- &f.LastFetchedAt, &f.LastError, &f.SubscriberCount, &f.Etag, &f.LastModified,
328		- &f.ConsecutiveEmptyFetches, &f.ErrorCount, &f.FaviconURL); err != nil {
	322	+ f, err := scanFeed(rows)
	323	+ if err != nil {
329	324	return nil, err
330	325	}
331	326	feeds = append(feeds, f)
@@ -334,14 +329,8 @@ func (s *ArticleStore) ListDeadFeeds(ctx context.Context, userDID string, thresh
334	329	}
335	330
336	331	func (s ArticleStore) ListAllFeeds(ctx context.Context, limit, offset int) ([]Feed, error) {
337		- rows, err := s.db.QueryContext(ctx, `
338		- SELECT feed_url, title, site_url, description, feed_type,
339		- last_fetched_at, last_error, subscriber_count, etag, last_modified,
340		- consecutive_empty_fetches, error_count, favicon_url
341		- FROM articles.feeds
342		- ORDER BY subscriber_count DESC
343		- LIMIT ? OFFSET ?
344		- `, limit, offset)
	332	+ rows, err := s.db.QueryContext(ctx, `SELECT `+feedSelectCols+` FROM articles.feeds
	333	+ ORDER BY subscriber_count DESC LIMIT ? OFFSET ?`, limit, offset)
345	334	if err != nil {
346	335	return nil, err
347	336	}
@@ -349,10 +338,8 @@ func (s ArticleStore) ListAllFeeds(ctx context.Context, limit, offset int) ([]
349	338
350	339	var feeds []*Feed
351	340	for rows.Next() {
352		- f := &Feed{}
353		- if err := rows.Scan(&f.FeedURL, &f.Title, &f.SiteURL, &f.Description, &f.FeedType,
354		- &f.LastFetchedAt, &f.LastError, &f.SubscriberCount, &f.Etag, &f.LastModified,
355		- &f.ConsecutiveEmptyFetches, &f.ErrorCount, &f.FaviconURL); err != nil {
	341	+ f, err := scanFeed(rows)
	342	+ if err != nil {
356	343	return nil, err
357	344	}
358	345	feeds = append(feeds, f)
@@ -457,7 +444,7 @@ func (s *ArticleStore) BatchReconcileSubscriptions(ctx context.Context, userDID
457	444	}
458	445	continue
459	446	}
460		- result, err := insertStmt.ExecContext(ctx, userDID, sub.FeedURL, nilIfEmpty(sub.Title), sub.Category, uriOrNil(sub.URI), uriOrNil(sub.CID))
	447	+ result, err := insertStmt.ExecContext(ctx, userDID, sub.FeedURL, nilIfEmpty(sub.Title), sub.Category, nilIfEmpty(sub.URI), nilIfEmpty(sub.CID))
461	448	if err != nil {
462	449	return err
463	450	}
@@ -472,15 +459,9 @@ func (s *ArticleStore) BatchReconcileSubscriptions(ctx context.Context, userDID
472	459	}
473	460
474	461	func (s ArticleStore) ListUnsubscribedFeeds(ctx context.Context, userDID string, limit, offset int) ([]Feed, error) {
475		- rows, err := s.db.QueryContext(ctx, `
476		- SELECT feed_url, title, site_url, description, feed_type,
477		- last_fetched_at, last_error, subscriber_count, etag, last_modified,
478		- consecutive_empty_fetches, error_count, favicon_url
479		- FROM articles.feeds
	462	+ rows, err := s.db.QueryContext(ctx, `SELECT `+feedSelectCols+` FROM articles.feeds
480	463	WHERE feed_url NOT IN (SELECT feed_url FROM articles.subscriptions WHERE user_did = ?)
481		- ORDER BY subscriber_count DESC
482		- LIMIT ? OFFSET ?
483		- `, userDID, limit, offset)
	464	+ ORDER BY subscriber_count DESC LIMIT ? OFFSET ?`, userDID, limit, offset)
484	465	if err != nil {
485	466	return nil, err
486	467	}
@@ -488,10 +469,8 @@ func (s *ArticleStore) ListUnsubscribedFeeds(ctx context.Context, userDID string
488	469
489	470	var feeds []*Feed
490	471	for rows.Next() {
491		- f := &Feed{}
492		- if err := rows.Scan(&f.FeedURL, &f.Title, &f.SiteURL, &f.Description, &f.FeedType,
493		- &f.LastFetchedAt, &f.LastError, &f.SubscriberCount, &f.Etag, &f.LastModified,
494		- &f.ConsecutiveEmptyFetches, &f.ErrorCount, &f.FaviconURL); err != nil {
	472	+ f, err := scanFeed(rows)
	473	+ if err != nil {
495	474	return nil, err
496	475	}
497	476	feeds = append(feeds, f)

  	"errors"
  	"strings"
  	"time"
++
++	"pkg.rbrt.fr/glean/internal/feed"
  )
  var ErrDuplicateSubscription = errors.New("already subscribed to this feed")
  	FaviconURL              sql.NullString
  }
++func (f *Feed) ToFeed() *feed.Feed {
++	return &feed.Feed{
++		URL:          f.FeedURL,
++		Title:        f.Title.String,
++		SiteURL:      f.SiteURL.String,
++		Description:  f.Description.String,
++		Type:         f.FeedType.String,
++		FaviconURL:   f.FaviconURL.String,
++		ETag:         f.Etag.String,
++		LastModified: f.LastModified.String,
++	}
++}
++
  type Subscription struct {
  	ID          int64
  	UserDID     string
  	FaviconURL  sql.NullString
  }
--func (s *ArticleStore) UpsertFeed(ctx context.Context, feed *Feed) error {
++const feedSelectCols = `feed_url, title, site_url, description, feed_type,
--	return s.BatchUpsertFeeds(ctx, []*Feed{feed})
++	last_fetched_at, last_error, subscriber_count, etag, last_modified,
--}
++	consecutive_empty_fetches, error_count, favicon_url`
--func (s *ArticleStore) GetFeed(ctx context.Context, feedURL string) (*Feed, error) {
++func scanFeed(scanner interface{ Scan(...any) error }) (*Feed, error) {
  	f := &Feed{}
--	err := s.db.QueryRowContext(ctx, `
++	if err := scanner.Scan(&f.FeedURL, &f.Title, &f.SiteURL, &f.Description, &f.FeedType,
--		SELECT feed_url, title, site_url, description, feed_type,
--			last_fetched_at, last_error, subscriber_count, etag, last_modified,
--			consecutive_empty_fetches, error_count, favicon_url
--		FROM articles.feeds WHERE feed_url = ?
--	`, feedURL).Scan(&f.FeedURL, &f.Title, &f.SiteURL, &f.Description, &f.FeedType,
  		&f.LastFetchedAt, &f.LastError, &f.SubscriberCount, &f.Etag, &f.LastModified,
--		&f.ConsecutiveEmptyFetches, &f.ErrorCount, &f.FaviconURL)
++		&f.ConsecutiveEmptyFetches, &f.ErrorCount, &f.FaviconURL); err != nil {
--	if err != nil {
  		return nil, err
  	}
  	return f, nil
  }
++func (s *ArticleStore) UpsertFeed(ctx context.Context, feed *Feed) error {
++	return s.BatchUpsertFeeds(ctx, []*Feed{feed})
++}
++
++func (s *ArticleStore) GetFeed(ctx context.Context, feedURL string) (*Feed, error) {
++	row := s.db.QueryRowContext(ctx, `SELECT `+feedSelectCols+` FROM articles.feeds WHERE feed_url = ?`, feedURL)
++	return scanFeed(row)
++}
++
  func (s *ArticleStore) GetFeedsToFetch(ctx context.Context, olderThan time.Duration, limit int) ([]*Feed, error) {
  	cutoff := time.Now().Add(-olderThan)
--	rows, err := s.db.QueryContext(ctx, `
++	rows, err := s.db.QueryContext(ctx, `SELECT `+feedSelectCols+` FROM articles.feeds
--		SELECT feed_url, title, site_url, description, feed_type,
--			last_fetched_at, last_error, subscriber_count, etag, last_modified,
--			consecutive_empty_fetches, error_count, favicon_url
--		FROM articles.feeds
  		WHERE subscriber_count > 0 AND error_count < 25 AND (last_fetched_at IS NULL OR last_fetched_at <= ?)
--		ORDER BY last_fetched_at ASC NULLS FIRST
++		ORDER BY last_fetched_at ASC NULLS FIRST LIMIT ?`, cutoff, limit)
--		LIMIT ?
--	`, cutoff, limit)
  	if err != nil {
  		return nil, err
  	}
  	var feeds []*Feed
  	for rows.Next() {
--		f := &Feed{}
++		f, err := scanFeed(rows)
--		if err := rows.Scan(&f.FeedURL, &f.Title, &f.SiteURL, &f.Description, &f.FeedType,
++		if err != nil {
--			&f.LastFetchedAt, &f.LastError, &f.SubscriberCount, &f.Etag, &f.LastModified,
--			&f.ConsecutiveEmptyFetches, &f.ErrorCount, &f.FaviconURL); err != nil {
  			return nil, err
  		}
  		feeds = append(feeds, f)
  	return err
  }
--func uriOrNil(v string) any {
--	if v == "" {
--		return nil
--	}
--	return v
--}
--
  func nilIfEmpty(v string) any {
  	if v == "" {
  		return nil
  }
  func (s *ArticleStore) ListDeadFeeds(ctx context.Context, userDID string, threshold int) ([]*Feed, error) {
--	rows, err := s.db.QueryContext(ctx, `
++	rows, err := s.db.QueryContext(ctx, `SELECT `+feedSelectCols+` FROM articles.feeds f
--		SELECT f.feed_url, f.title, f.site_url, f.description, f.feed_type,
--			f.last_fetched_at, f.last_error, f.subscriber_count, f.etag, f.last_modified,
--			f.consecutive_empty_fetches, f.error_count, f.favicon_url
--		FROM articles.feeds f
  		JOIN articles.subscriptions s ON s.feed_url = f.feed_url AND s.user_did = ?
--		WHERE f.error_count >= ?
++		WHERE f.error_count >= ? ORDER BY f.error_count DESC`, userDID, threshold)
--		ORDER BY f.error_count DESC
--	`, userDID, threshold)
  	if err != nil {
  		return nil, err
  	}
  	var feeds []*Feed
  	for rows.Next() {
--		f := &Feed{}
++		f, err := scanFeed(rows)
--		if err := rows.Scan(&f.FeedURL, &f.Title, &f.SiteURL, &f.Description, &f.FeedType,
++		if err != nil {
--			&f.LastFetchedAt, &f.LastError, &f.SubscriberCount, &f.Etag, &f.LastModified,
--			&f.ConsecutiveEmptyFetches, &f.ErrorCount, &f.FaviconURL); err != nil {
  			return nil, err
  		}
  		feeds = append(feeds, f)
  }
  func (s *ArticleStore) ListAllFeeds(ctx context.Context, limit, offset int) ([]*Feed, error) {
--	rows, err := s.db.QueryContext(ctx, `
++	rows, err := s.db.QueryContext(ctx, `SELECT `+feedSelectCols+` FROM articles.feeds
--		SELECT feed_url, title, site_url, description, feed_type,
++		ORDER BY subscriber_count DESC LIMIT ? OFFSET ?`, limit, offset)
--			last_fetched_at, last_error, subscriber_count, etag, last_modified,
--			consecutive_empty_fetches, error_count, favicon_url
--		FROM articles.feeds
--		ORDER BY subscriber_count DESC
--		LIMIT ? OFFSET ?
--	`, limit, offset)
  	if err != nil {
  		return nil, err
  	}
  	var feeds []*Feed
  	for rows.Next() {
--		f := &Feed{}
++		f, err := scanFeed(rows)
--		if err := rows.Scan(&f.FeedURL, &f.Title, &f.SiteURL, &f.Description, &f.FeedType,
++		if err != nil {
--			&f.LastFetchedAt, &f.LastError, &f.SubscriberCount, &f.Etag, &f.LastModified,
--			&f.ConsecutiveEmptyFetches, &f.ErrorCount, &f.FaviconURL); err != nil {
  			return nil, err
  		}
  		feeds = append(feeds, f)
  			}
  			continue
  		}
--		result, err := insertStmt.ExecContext(ctx, userDID, sub.FeedURL, nilIfEmpty(sub.Title), sub.Category, uriOrNil(sub.URI), uriOrNil(sub.CID))
++		result, err := insertStmt.ExecContext(ctx, userDID, sub.FeedURL, nilIfEmpty(sub.Title), sub.Category, nilIfEmpty(sub.URI), nilIfEmpty(sub.CID))
  		if err != nil {
  			return err
  		}
  }
  func (s *ArticleStore) ListUnsubscribedFeeds(ctx context.Context, userDID string, limit, offset int) ([]*Feed, error) {
--	rows, err := s.db.QueryContext(ctx, `
++	rows, err := s.db.QueryContext(ctx, `SELECT `+feedSelectCols+` FROM articles.feeds
--		SELECT feed_url, title, site_url, description, feed_type,
--			last_fetched_at, last_error, subscriber_count, etag, last_modified,
--			consecutive_empty_fetches, error_count, favicon_url
--		FROM articles.feeds
  		WHERE feed_url NOT IN (SELECT feed_url FROM articles.subscriptions WHERE user_did = ?)
--		ORDER BY subscriber_count DESC
++		ORDER BY subscriber_count DESC LIMIT ? OFFSET ?`, userDID, limit, offset)
--		LIMIT ? OFFSET ?
--	`, userDID, limit, offset)
  	if err != nil {
  		return nil, err
  	}
  	var feeds []*Feed
  	for rows.Next() {
--		f := &Feed{}
++		f, err := scanFeed(rows)
--		if err := rows.Scan(&f.FeedURL, &f.Title, &f.SiteURL, &f.Description, &f.FeedType,
++		if err != nil {
--			&f.LastFetchedAt, &f.LastError, &f.SubscriberCount, &f.Etag, &f.LastModified,
--			&f.ConsecutiveEmptyFetches, &f.ErrorCount, &f.FaviconURL); err != nil {
  			return nil, err
  		}
  		feeds = append(feeds, f)

modified internal/db/follow.go +1 -1 Viewed

@@ -21,7 +21,7 @@ func (s *UserStore) UpsertFollow(ctx context.Context, userDID, targetDID, uri, c
21	21	ON CONFLICT(user_did, target_did) DO UPDATE SET
22	22	uri = excluded.uri,
23	23	cid = excluded.cid
24		- `, userDID, targetDID, uriOrNil(uri), uriOrNil(cid))
	24	+ `, userDID, targetDID, nilIfEmpty(uri), nilIfEmpty(cid))
25	25	return err
26	26	}
27	27

  		ON CONFLICT(user_did, target_did) DO UPDATE SET
  			uri = excluded.uri,
  			cid = excluded.cid
--	`, userDID, targetDID, uriOrNil(uri), uriOrNil(cid))
++	`, userDID, targetDID, nilIfEmpty(uri), nilIfEmpty(cid))
  	return err
  }

modified internal/db/store.go +1 -10 Viewed

@@ -22,16 +22,7 @@ func (a *FeedStoreAdapter) GetFeedsToFetch(ctx context.Context, olderThan time.D
22	22	}
23	23	var feeds []*feed.Feed
24	24	for _, df := range dbFeeds {
25		- feeds = append(feeds, &feed.Feed{
26		- URL: df.FeedURL,
27		- Title: df.Title.String,
28		- SiteURL: df.SiteURL.String,
29		- Description: df.Description.String,
30		- Type: df.FeedType.String,
31		- FaviconURL: df.FaviconURL.String,
32		- ETag: df.Etag.String,
33		- LastModified: df.LastModified.String,
34		- })
	25	+ feeds = append(feeds, df.ToFeed())
35	26	}
36	27	return feeds, nil
37	28	}

  	}
  	var feeds []*feed.Feed
  	for _, df := range dbFeeds {
--		feeds = append(feeds, &feed.Feed{
++		feeds = append(feeds, df.ToFeed())
--			URL:          df.FeedURL,
--			Title:        df.Title.String,
--			SiteURL:      df.SiteURL.String,
--			Description:  df.Description.String,
--			Type:         df.FeedType.String,
--			FaviconURL:   df.FaviconURL.String,
--			ETag:         df.Etag.String,
--			LastModified: df.LastModified.String,
--		})
  	}
  	return feeds, nil
  }

modified internal/feed/discover.go +4 -13 Viewed

@@ -12,19 +12,10 @@ import (
12	12	"pkg.rbrt.fr/glean/internal/httpclient"
13	13	)
14	14
15		-type imageContentTypePrefixes []string
16		-
17		-func (p imageContentTypePrefixes) matches(contentType string) bool {
18		- for _, prefix := range p {
19		- if strings.HasPrefix(contentType, prefix) {
20		- return true
21		- }
22		- }
23		- return false
	15	+func isImageContentType(ct string) bool {
	16	+ return strings.HasPrefix(ct, "image/")
24	17	}
25	18
26		-var imageContentTypes = imageContentTypePrefixes{"image/"}
27		-
28	19	type DiscoveryResult struct {
29	20	FeedURLs []string
30	21	Favicon string
@@ -140,7 +131,7 @@ func findFavicon(ctx context.Context, base *url.URL, links []string) string {
140	131	return
141	132	}
142	133	resp.Body.Close()
143		- if resp.StatusCode == http.StatusOK && imageContentTypes.matches(resp.Header.Get("Content-Type")) {
	134	+ if resp.StatusCode == http.StatusOK && isImageContentType(resp.Header.Get("Content-Type")) {
144	135	select {
145	136	case found <- result{url: cleanFavicon(resolved.String()), found: true}:
146	137	default:
@@ -170,7 +161,7 @@ func checkContentType(ctx context.Context, url string) bool {
170	161	return false
171	162	}
172	163	resp.Body.Close()
173		- return resp.StatusCode == http.StatusOK && imageContentTypes.matches(resp.Header.Get("Content-Type"))
	164	+ return resp.StatusCode == http.StatusOK && isImageContentType(resp.Header.Get("Content-Type"))
174	165	}
175	166
176	167	func extractHref(link string) string {

  	"pkg.rbrt.fr/glean/internal/httpclient"
  )
--type imageContentTypePrefixes []string
++func isImageContentType(ct string) bool {
--
++	return strings.HasPrefix(ct, "image/")
--func (p imageContentTypePrefixes) matches(contentType string) bool {
--	for _, prefix := range p {
--		if strings.HasPrefix(contentType, prefix) {
--			return true
--		}
--	}
--	return false
  }
--var imageContentTypes = imageContentTypePrefixes{"image/"}
--
  type DiscoveryResult struct {
  	FeedURLs []string
  	Favicon  string
  				return
  			}
  			resp.Body.Close()
--			if resp.StatusCode == http.StatusOK && imageContentTypes.matches(resp.Header.Get("Content-Type")) {
++			if resp.StatusCode == http.StatusOK && isImageContentType(resp.Header.Get("Content-Type")) {
  				select {
  				case found <- result{url: cleanFavicon(resolved.String()), found: true}:
  				default:
  		return false
  	}
  	resp.Body.Close()
--	return resp.StatusCode == http.StatusOK && imageContentTypes.matches(resp.Header.Get("Content-Type"))
++	return resp.StatusCode == http.StatusOK && isImageContentType(resp.Header.Get("Content-Type"))
  }
  func extractHref(link string) string {

modified internal/feed/fetcher.go +4 -1 Viewed

@@ -203,7 +203,10 @@ func (s *Scheduler) fetchAll(ctx context.Context, olderThan time.Duration) {
203	203	func (s Scheduler) FetchFeed(ctx context.Context, feed Feed) {
204	204	call := &fetchCall{done: make(chan struct{})}
205	205	if actual, loaded := s.inFlight.LoadOrStore(feed.URL, call); loaded {
206		- <-actual.(*fetchCall).done
	206	+ select {
	207	+ case <-actual.(*fetchCall).done:
	208	+ case <-ctx.Done():
	209	+ }
207	210	return
208	211	}
209	212	defer func() {

  func (s *Scheduler) FetchFeed(ctx context.Context, feed *Feed) {
  	call := &fetchCall{done: make(chan struct{})}
  	if actual, loaded := s.inFlight.LoadOrStore(feed.URL, call); loaded {
--		<-actual.(*fetchCall).done
++		select {
++		case <-actual.(*fetchCall).done:
++		case <-ctx.Done():
++		}
  		return
  	}
  	defer func() {

modified internal/httpclient/httpclient.go +1 -1 Viewed

@@ -26,7 +26,7 @@ var dnsResolver = &net.Resolver{
26	26	}
27	27
28	28	var (
29		- transportOnce sync.Once
	29	+ transportOnce sync.Once
30	30	sharedTransport *http.Transport
31	31	)
32	32

  }
  var (
--	transportOnce sync.Once
++	transportOnce   sync.Once
  	sharedTransport *http.Transport
  )

modified internal/server/annotations_handler.go +0 -1 Viewed

@@ -173,7 +173,6 @@ func resolveAnnotationHandles(ctx context.Context, annotations []*db.Annotation)
173	173	g, gCtx := errgroup.WithContext(ctx)
174	174	g.SetLimit(5)
175	175	for _, a := range annotations {
176		- a := a
177	176	g.Go(func() error {
178	177	if a.AuthorDID != "" {
179	178	a.AuthorHandle = atproto.ResolveProfile(gCtx, a.AuthorDID).Handle

  	g, gCtx := errgroup.WithContext(ctx)
  	g.SetLimit(5)
  	for _, a := range annotations {
--		a := a
  		g.Go(func() error {
  			if a.AuthorDID != "" {
  				a.AuthorHandle = atproto.ResolveProfile(gCtx, a.AuthorDID).Handle

modified internal/server/auth_handler.go +1 -1 Viewed

@@ -102,7 +102,7 @@ func (s Server) handleOAuthCallback(w http.ResponseWriter, r http.Request) {
102	102	PDSURL: sessData.HostURL,
103	103	SessionID: sessData.SessionID,
104	104	}
105		- encoded, err := encodeSession(sessionData)
	105	+ encoded, err := encodeSession(s.sessionKey, sessionData)
106	106	if err != nil {
107	107	s.logger.Error("failed to encode session", "error", err)
108	108	s.renderError(w, r, http.StatusInternalServerError, "Session error", "Could not create your session. Please try again.")

  		PDSURL:    sessData.HostURL,
  		SessionID: sessData.SessionID,
  	}
--	encoded, err := encodeSession(sessionData)
++	encoded, err := encodeSession(s.sessionKey, sessionData)
  	if err != nil {
  		s.logger.Error("failed to encode session", "error", err)
  		s.renderError(w, r, http.StatusInternalServerError, "Session error", "Could not create your session. Please try again.")

modified internal/server/dashboard_handler.go +0 -1 Viewed

@@ -120,7 +120,6 @@ func resolvePeopleHandles(ctx context.Context, people []*cluster.PersonRecommend
120	120	g, gCtx := errgroup.WithContext(ctx)
121	121	g.SetLimit(5)
122	122	for _, p := range people {
123		- p := p
124	123	g.Go(func() error {
125	124	prof := atproto.ResolveProfile(gCtx, p.DID)
126	125	p.Handle = prof.Handle

  	g, gCtx := errgroup.WithContext(ctx)
  	g.SetLimit(5)
  	for _, p := range people {
--		p := p
  		g.Go(func() error {
  			prof := atproto.ResolveProfile(gCtx, p.DID)
  			p.Handle = prof.Handle

modified internal/server/feeds_handler.go +21 -25 Viewed

@@ -8,6 +8,8 @@ import (
8	8	"net/http"
9	9	"time"
10	10
	11	+ "golang.org/x/sync/errgroup"
	12	+
11	13	"pkg.rbrt.fr/glean/internal/atproto"
12	14	"pkg.rbrt.fr/glean/internal/cluster"
13	15	"pkg.rbrt.fr/glean/internal/db"
@@ -259,6 +261,8 @@ func (s Server) handleOPMLUpload(w http.ResponseWriter, r http.Request) {
259	261	feedURLs := feed.ExtractFeedURLs(opml)
260	262	var added int
261	263	client := s.pdsClientForUser(r)
	264	+
	265	+ var favGoroutines []struct{ feedURL, siteURL string }
262	266	for _, fu := range feedURLs {
263	267	f := &db.Feed{
264	268	FeedURL: fu.URL,
@@ -271,13 +275,7 @@ func (s Server) handleOPMLUpload(w http.ResponseWriter, r http.Request) {
271	275	continue
272	276	}
273	277
274		- go func(feedURL, siteURL string) {
275		- if fav := feed.ResolveFavicon(context.Background(), feedURL, siteURL); fav != "" {
276		- if err := s.dbs.Articles.UpdateFeedFavicon(context.Background(), feedURL, fav); err != nil {
277		- s.logger.Warn("failed to update favicon", "error", err, "feed", feedURL)
278		- }
279		- }
280		- }(fu.URL, fu.SiteURL)
	278	+ favGoroutines = append(favGoroutines, struct{ feedURL, siteURL string }{fu.URL, fu.SiteURL})
281	279
282	280	var subURI, subCID string
283	281	if client != nil {
@@ -305,6 +303,20 @@ func (s Server) handleOPMLUpload(w http.ResponseWriter, r http.Request) {
305	303	added++
306	304	}
307	305
	306	+ go func() {
	307	+ g, ctx := errgroup.WithContext(context.Background())
	308	+ g.SetLimit(5)
	309	+ for _, fav := range favGoroutines {
	310	+ g.Go(func() error {
	311	+ if f := feed.ResolveFavicon(ctx, fav.feedURL, fav.siteURL); f != "" {
	312	+ _ = s.dbs.Articles.UpdateFeedFavicon(ctx, fav.feedURL, f)
	313	+ }
	314	+ return nil
	315	+ })
	316	+ }
	317	+ _ = g.Wait()
	318	+ }()
	319	+
308	320	w.Header().Set("HX-Redirect", "/feeds")
309	321	w.WriteHeader(http.StatusOK)
310	322	}
@@ -385,15 +397,7 @@ func (s *Server) refreshUserFeeds(ctx context.Context, userDID string) {
385	397	s.logger.Warn("failed to get feed", "error", err, "feed", sub.FeedURL)
386	398	continue
387	399	}
388		- ff := &feed.Feed{
389		- URL: f.FeedURL,
390		- Title: f.Title.String,
391		- SiteURL: f.SiteURL.String,
392		- Description: f.Description.String,
393		- Type: f.FeedType.String,
394		- ETag: f.Etag.String,
395		- LastModified: f.LastModified.String,
396		- }
	400	+ ff := f.ToFeed()
397	401	s.scheduler.FetchFeed(ctx, ff)
398	402	}
399	403	}
@@ -411,15 +415,7 @@ func (s Server) handleRetryFeed(w http.ResponseWriter, r http.Request) {
411	415	return
412	416	}
413	417
414		- ff := &feed.Feed{
415		- URL: f.FeedURL,
416		- Title: f.Title.String,
417		- SiteURL: f.SiteURL.String,
418		- Description: f.Description.String,
419		- Type: f.FeedType.String,
420		- ETag: f.Etag.String,
421		- LastModified: f.LastModified.String,
422		- }
	418	+ ff := f.ToFeed()
423	419	s.scheduler.FetchFeed(r.Context(), ff)
424	420
425	421	user := currentUser(r)

  	"net/http"
  	"time"
++	"golang.org/x/sync/errgroup"
++
  	"pkg.rbrt.fr/glean/internal/atproto"
  	"pkg.rbrt.fr/glean/internal/cluster"
  	"pkg.rbrt.fr/glean/internal/db"
  	feedURLs := feed.ExtractFeedURLs(opml)
  	var added int
  	client := s.pdsClientForUser(r)
++
++	var favGoroutines []struct{ feedURL, siteURL string }
  	for _, fu := range feedURLs {
  		f := &db.Feed{
  			FeedURL:     fu.URL,
  			continue
  		}
--		go func(feedURL, siteURL string) {
++		favGoroutines = append(favGoroutines, struct{ feedURL, siteURL string }{fu.URL, fu.SiteURL})
--			if fav := feed.ResolveFavicon(context.Background(), feedURL, siteURL); fav != "" {
--				if err := s.dbs.Articles.UpdateFeedFavicon(context.Background(), feedURL, fav); err != nil {
--					s.logger.Warn("failed to update favicon", "error", err, "feed", feedURL)
--				}
--			}
--		}(fu.URL, fu.SiteURL)
  		var subURI, subCID string
  		if client != nil {
  		added++
  	}
++	go func() {
++		g, ctx := errgroup.WithContext(context.Background())
++		g.SetLimit(5)
++		for _, fav := range favGoroutines {
++			g.Go(func() error {
++				if f := feed.ResolveFavicon(ctx, fav.feedURL, fav.siteURL); f != "" {
++					_ = s.dbs.Articles.UpdateFeedFavicon(ctx, fav.feedURL, f)
++				}
++				return nil
++			})
++		}
++		_ = g.Wait()
++	}()
++
  	w.Header().Set("HX-Redirect", "/feeds")
  	w.WriteHeader(http.StatusOK)
  }
  			s.logger.Warn("failed to get feed", "error", err, "feed", sub.FeedURL)
  			continue
  		}
--		ff := &feed.Feed{
++		ff := f.ToFeed()
--			URL:          f.FeedURL,
--			Title:        f.Title.String,
--			SiteURL:      f.SiteURL.String,
--			Description:  f.Description.String,
--			Type:         f.FeedType.String,
--			ETag:         f.Etag.String,
--			LastModified: f.LastModified.String,
--		}
  		s.scheduler.FetchFeed(ctx, ff)
  	}
  }
  		return
  	}
--	ff := &feed.Feed{
++	ff := f.ToFeed()
--		URL:          f.FeedURL,
--		Title:        f.Title.String,
--		SiteURL:      f.SiteURL.String,
--		Description:  f.Description.String,
--		Type:         f.FeedType.String,
--		ETag:         f.Etag.String,
--		LastModified: f.LastModified.String,
--	}
  	s.scheduler.FetchFeed(r.Context(), ff)
  	user := currentUser(r)

modified internal/server/middleware.go +30 -8 Viewed

@@ -4,10 +4,9 @@ import (
4	4	"crypto/rand"
5	5	"encoding/hex"
6	6	"net/http"
	7	+ "net/url"
7	8	"strings"
8	9	"time"
9		-
10		- "github.com/go-chi/chi/v5/middleware"
11	10	)
12	11
13	12	func (s *Server) sessionMiddleware(next http.Handler) http.Handler {
@@ -33,7 +32,9 @@ func (s *Server) requireAuth(next http.Handler) http.Handler {
33	32
34	33	func csrfToken() string {
35	34	b := make([]byte, 32)
36		- rand.Read(b)
	35	+ if _, err := rand.Read(b); err != nil {
	36	+ return ""
	37	+ }
37	38	return hex.EncodeToString(b)
38	39	}
39	40
@@ -82,15 +83,19 @@ func (s *Server) csrfMiddleware(next http.Handler) http.Handler {
82	83	}
83	84
84	85	func sameOrigin(origin, host string) bool {
85		- return strings.HasPrefix(origin, "http://"+host) \|\| strings.HasPrefix(origin, "https://"+host)
	86	+ u, err := url.Parse(origin)
	87	+ if err != nil {
	88	+ return false
	89	+ }
	90	+ return u.Host == host
86	91	}
87	92
88	93	func (s *Server) realIPLogger(next http.Handler) http.Handler {
89	94	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
90	95	start := time.Now()
91		- ww := middleware.NewWrapResponseWriter(w, r.ProtoMajor)
	96	+ sw := &statusWriter{ResponseWriter: w}
92	97
93		- next.ServeHTTP(ww, r)
	98	+ next.ServeHTTP(sw, r)
94	99
95	100	ip := r.RemoteAddr
96	101	if xff := r.Header.Get("X-Forwarded-For"); xff != "" {
@@ -106,9 +111,26 @@ func (s *Server) realIPLogger(next http.Handler) http.Handler {
106	111	"method", r.Method,
107	112	"url", scheme+"://"+r.Host+r.RequestURI,
108	113	"from", ip,
109		- "status", ww.Status(),
110		- "bytes", ww.BytesWritten(),
	114	+ "status", sw.status,
	115	+ "bytes", sw.bytes,
111	116	"duration", time.Since(start).Round(time.Microsecond),
112	117	)
113	118	})
114	119	}
	120	+
	121	+type statusWriter struct {
	122	+ http.ResponseWriter
	123	+ status int
	124	+ bytes int
	125	+}
	126	+
	127	+func (w *statusWriter) WriteHeader(code int) {
	128	+ w.status = code
	129	+ w.ResponseWriter.WriteHeader(code)
	130	+}
	131	+
	132	+func (w *statusWriter) Write(b []byte) (int, error) {
	133	+ n, err := w.ResponseWriter.Write(b)
	134	+ w.bytes += n
	135	+ return n, err
	136	+}

  	"crypto/rand"
  	"encoding/hex"
  	"net/http"
++	"net/url"
  	"strings"
  	"time"
--
--	"github.com/go-chi/chi/v5/middleware"
  )
  func (s *Server) sessionMiddleware(next http.Handler) http.Handler {
  func csrfToken() string {
  	b := make([]byte, 32)
--	rand.Read(b)
++	if _, err := rand.Read(b); err != nil {
++		return ""
++	}
  	return hex.EncodeToString(b)
  }
  }
  func sameOrigin(origin, host string) bool {
--	return strings.HasPrefix(origin, "http://"+host) || strings.HasPrefix(origin, "https://"+host)
++	u, err := url.Parse(origin)
++	if err != nil {
++		return false
++	}
++	return u.Host == host
  }
  func (s *Server) realIPLogger(next http.Handler) http.Handler {
  	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  		start := time.Now()
--		ww := middleware.NewWrapResponseWriter(w, r.ProtoMajor)
++		sw := &statusWriter{ResponseWriter: w}
--		next.ServeHTTP(ww, r)
++		next.ServeHTTP(sw, r)
  		ip := r.RemoteAddr
  		if xff := r.Header.Get("X-Forwarded-For"); xff != "" {
  			"method", r.Method,
  			"url", scheme+"://"+r.Host+r.RequestURI,
  			"from", ip,
--			"status", ww.Status(),
++			"status", sw.status,
--			"bytes", ww.BytesWritten(),
++			"bytes", sw.bytes,
  			"duration", time.Since(start).Round(time.Microsecond),
  		)
  	})
  }
++
++type statusWriter struct {
++	http.ResponseWriter
++	status int
++	bytes  int
++}
++
++func (w *statusWriter) WriteHeader(code int) {
++	w.status = code
++	w.ResponseWriter.WriteHeader(code)
++}
++
++func (w *statusWriter) Write(b []byte) (int, error) {
++	n, err := w.ResponseWriter.Write(b)
++	w.bytes += n
++	return n, err
++}

modified internal/server/server.go +2 -0 Viewed

@@ -68,6 +68,7 @@ type Server struct {
68	68	scraper *scraper.Scraper
69	69	clientID string
70	70	callbackURL string
	71	+ sessionKey []byte
71	72	}
72	73
73	74	func New(dbs db.Databases, clientID, callbackURL, addr string, scheduler feed.Scheduler, engine cluster.Engine, logger slog.Logger) *Server {
@@ -98,6 +99,7 @@ func New(dbs db.Databases, clientID, callbackURL, addr string, scheduler feed.
98	99	scraper: scraper.New(logger),
99	100	clientID: clientID,
100	101	callbackURL: callbackURL,
	102	+ sessionKey: loadSessionKey(),
101	103	}
102	104
103	105	s.setupMiddleware()

  	scraper     *scraper.Scraper
  	clientID    string
  	callbackURL string
++	sessionKey  []byte
  }
  func New(dbs *db.Databases, clientID, callbackURL, addr string, scheduler *feed.Scheduler, engine *cluster.Engine, logger *slog.Logger) *Server {
  		scraper:     scraper.New(logger),
  		clientID:    clientID,
  		callbackURL: callbackURL,
++		sessionKey:  loadSessionKey(),
  	}
  	s.setupMiddleware()

modified internal/server/session.go +8 -8 Viewed

@@ -30,7 +30,7 @@ func (s Server) getUserFromSession(r http.Request) *db.User {
30	30	return nil
31	31	}
32	32
33		- data, err := decodeSession(cookie.Value)
	33	+ data, err := decodeSession(s.sessionKey, cookie.Value)
34	34	if err != nil {
35	35	return nil
36	36	}
@@ -49,7 +49,7 @@ func (s Server) getUserFromSession(r http.Request) *db.User {
49	49
50	50	func (s Server) setUserSession(w http.ResponseWriter, user db.User) {
51	51	data := sessionData{DID: user.DID}
52		- encoded, err := encodeSession(data)
	52	+ encoded, err := encodeSession(s.sessionKey, data)
53	53	if err != nil {
54	54	s.logger.Error("failed to encode session", "error", err)
55	55	return
@@ -89,14 +89,14 @@ func (s Server) getSessionData(r http.Request) *sessionData {
89	89	if err != nil {
90	90	return nil
91	91	}
92		- data, err := decodeSession(cookie.Value)
	92	+ data, err := decodeSession(s.sessionKey, cookie.Value)
93	93	if err != nil {
94	94	return nil
95	95	}
96	96	return data
97	97	}
98	98
99		-func sessionKey() []byte {
	99	+func loadSessionKey() []byte {
100	100	key := os.Getenv("GLEAN_SESSION_KEY")
101	101	if key == "" {
102	102	key = "default-dev-key-change-in-production"
@@ -104,13 +104,13 @@ func sessionKey() []byte {
104	104	return []byte(key)
105	105	}
106	106
107		-func encodeSession(data sessionData) (string, error) {
	107	+func encodeSession(key []byte, data sessionData) (string, error) {
108	108	payload, err := json.Marshal(data)
109	109	if err != nil {
110	110	return "", err
111	111	}
112	112
113		- mac := hmac.New(sha256.New, sessionKey())
	113	+ mac := hmac.New(sha256.New, key)
114	114	mac.Write(payload)
115	115	sig := mac.Sum(nil)
116	116
@@ -118,7 +118,7 @@ func encodeSession(data sessionData) (string, error) {
118	118	return base64.URLEncoding.EncodeToString(raw), nil
119	119	}
120	120
121		-func decodeSession(encoded string) (*sessionData, error) {
	121	+func decodeSession(key []byte, encoded string) (*sessionData, error) {
122	122	raw, err := base64.URLEncoding.DecodeString(encoded)
123	123	if err != nil {
124	124	return nil, errInvalidSession
@@ -131,7 +131,7 @@ func decodeSession(encoded string) (*sessionData, error) {
131	131	payload := raw[:len(raw)-sha256.Size]
132	132	sig := raw[len(raw)-sha256.Size:]
133	133
134		- mac := hmac.New(sha256.New, sessionKey())
	134	+ mac := hmac.New(sha256.New, key)
135	135	mac.Write(payload)
136	136	expectedSig := mac.Sum(nil)
137	137

  		return nil
  	}
--	data, err := decodeSession(cookie.Value)
++	data, err := decodeSession(s.sessionKey, cookie.Value)
  	if err != nil {
  		return nil
  	}
  func (s *Server) setUserSession(w http.ResponseWriter, user *db.User) {
  	data := sessionData{DID: user.DID}
--	encoded, err := encodeSession(data)
++	encoded, err := encodeSession(s.sessionKey, data)
  	if err != nil {
  		s.logger.Error("failed to encode session", "error", err)
  		return
  	if err != nil {
  		return nil
  	}
--	data, err := decodeSession(cookie.Value)
++	data, err := decodeSession(s.sessionKey, cookie.Value)
  	if err != nil {
  		return nil
  	}
  	return data
  }
--func sessionKey() []byte {
++func loadSessionKey() []byte {
  	key := os.Getenv("GLEAN_SESSION_KEY")
  	if key == "" {
  		key = "default-dev-key-change-in-production"
  	return []byte(key)
  }
--func encodeSession(data sessionData) (string, error) {
++func encodeSession(key []byte, data sessionData) (string, error) {
  	payload, err := json.Marshal(data)
  	if err != nil {
  		return "", err
  	}
--	mac := hmac.New(sha256.New, sessionKey())
++	mac := hmac.New(sha256.New, key)
  	mac.Write(payload)
  	sig := mac.Sum(nil)
  	return base64.URLEncoding.EncodeToString(raw), nil
  }
--func decodeSession(encoded string) (*sessionData, error) {
++func decodeSession(key []byte, encoded string) (*sessionData, error) {
  	raw, err := base64.URLEncoding.DecodeString(encoded)
  	if err != nil {
  		return nil, errInvalidSession
  	payload := raw[:len(raw)-sha256.Size]
  	sig := raw[len(raw)-sha256.Size:]
--	mac := hmac.New(sha256.New, sessionKey())
++	mac := hmac.New(sha256.New, key)
  	mac.Write(payload)
  	expectedSig := mac.Sum(nil)

Refactor database schema and sessions implementationUnverified