@isomoes/iread 0.2.1 → 0.2.2

package/README.md

@@ -4,6 +4,8 @@ A concise, local, single-user RSS/Atom reader inspired by newsboat. Keyboard-fir
 
 There is no auth, no multi-user, no cloud sync, and no background scheduler. Refresh is always user-initiated. All data lives in a single local SQLite file — by default `~/.config/iread/iread.db` — which is the trust boundary.
 
+![iread UI](https://github.com/user-attachments/assets/ca9489c9-630f-4a67-9cd5-60c18ce3544e)
+
 ## Quick start
 
 ```sh

package/dist/server/cli.js

@@ -91,4 +91,3 @@ for (let i = 0; i < args.length; i++) {
 // Serve the prebuilt web bundle unless the caller explicitly set NODE_ENV.
 process.env.NODE_ENV ??= 'production';
 await import('./index.js');
-//# sourceMappingURL=cli.js.map

package/dist/server/db.js

@@ -155,4 +155,3 @@ export function totalChanges() {
     const row = db.prepare('SELECT total_changes() AS n').get();
     return row.n;
 }
-//# sourceMappingURL=db.js.map

package/dist/server/feed-service.js

@@ -212,7 +212,12 @@ const UPDATE_FEED_ON_SUCCESS = `
     last_fetched_at = ?, fetch_error = NULL
   WHERE id = ?
 `;
-async function refreshFeedRow(row) {
+// Phase 1 (async, no DB, runs concurrently across feeds): fetch + parse + sanitize.
+// Never throws — a failed fetch/parse becomes an 'error' plan so the caller's loop
+// always completes. CRITICAL (review fix #13): the new etag/last_modified are
+// carried in the plan and persisted only by applyRefresh, after a fully
+// successful parse+upsert.
+async function planRefresh(row) {
     const now = Date.now();
     try {
         const result = await fetchFeed({
@@ -220,30 +225,56 @@ async function refreshFeedRow(row) {
             etag: row.etag,
             lastModified: row.last_modified,
         });
-        if (result.kind === 'notModified') {
+        if (result.kind === 'notModified')
+            return { kind: 'notModified', now };
+        const { feedMeta, commit } = await parseAndPrepare(row.feed_url, result.xml);
+        return {
+            kind: 'ok',
+            now,
+            feedMeta,
+            commit,
+            etag: result.etag,
+            lastModified: result.lastModified,
+        };
+    }
+    catch (err) {
+        return { kind: 'error', now, message: err instanceof Error ? err.message : String(err) };
+    }
+}
+// Record a failed refresh on the feed row. Shared by the error-plan branch and the
+// catch fallback so the UPDATE + error outcome live in exactly one place.
+function recordFeedError(row, now, message) {
+    db.prepare(`UPDATE feeds SET last_fetched_at = ?, fetch_error = ? WHERE id = ?`).run(now, message, row.id);
+    return { feed: getFeedWithCounts(row.id), newItems: 0, ok: false };
+}
+// Phase 2 (synchronous DB writes): apply one plan. Fully synchronous — it never
+// awaits — so even when called from concurrent fetch workers its writes can't
+// overlap and node:sqlite never awaits mid-transaction. Only the commit + feed-row
+// update run inside the transaction.
+function applyRefresh(row, plan) {
+    try {
+        if (plan.kind === 'notModified') {
             // 304: nothing changed. Update last_fetched_at and clear any prior error.
-            db.prepare(`UPDATE feeds SET last_fetched_at = ?, fetch_error = NULL WHERE id = ?`).run(now, row.id);
+            db.prepare(`UPDATE feeds SET last_fetched_at = ?, fetch_error = NULL WHERE id = ?`).run(plan.now, row.id);
             return { feed: getFeedWithCounts(row.id), newItems: 0, ok: true };
         }
-        // Parse + sanitize OUTSIDE the transaction (async, CPU work, no DB). Only the
-        // synchronous DB writes (commit) run inside the transaction so node:sqlite
-        // never awaits mid-transaction. CRITICAL (review fix #13): the new
-        // etag/last_modified are persisted only here, after a fully successful
-        // parse+upsert.
-        const { feedMeta, commit } = await parseAndPrepare(row.feed_url, result.xml);
-        const newItems = transaction(() => {
-            const inserted = commit(row.id);
-            db.prepare(UPDATE_FEED_ON_SUCCESS).run(feedMeta.title, feedMeta.siteUrl, feedMeta.description, result.etag, result.lastModified, now, row.id);
-            return inserted;
-        });
-        return { feed: getFeedWithCounts(row.id), newItems, ok: true };
+        if (plan.kind === 'ok') {
+            const newItems = transaction(() => {
+                const inserted = plan.commit(row.id);
+                db.prepare(UPDATE_FEED_ON_SUCCESS).run(plan.feedMeta.title, plan.feedMeta.siteUrl, plan.feedMeta.description, plan.etag, plan.lastModified, plan.now, row.id);
+                return inserted;
+            });
+            return { feed: getFeedWithCounts(row.id), newItems, ok: true };
+        }
+        return recordFeedError(row, plan.now, plan.message);
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        db.prepare(`UPDATE feeds SET last_fetched_at = ?, fetch_error = ? WHERE id = ?`).run(now, message, row.id);
-        return { feed: getFeedWithCounts(row.id), newItems: 0, ok: false };
+        return recordFeedError(row, plan.now, err instanceof Error ? err.message : String(err));
     }
 }
+async function refreshFeedRow(row) {
+    return applyRefresh(row, await planRefresh(row));
+}
 function getFeedRow(id) {
     return queryGet(`SELECT * FROM feeds WHERE id = ?`, id);
 }
@@ -257,29 +288,54 @@ export async function refreshFeed(id) {
     syncOpmlMirror();
     return { feed: outcome.feed, newItems: outcome.newItems };
 }
-/** Refresh every feed sequentially. Never fails because one feed errored;
- *  tallies refreshed/failed/newItems and returns the full updated feed list. */
+// Max feeds fetched+parsed at once in refreshAll. Bounded so we never open
+// hundreds of sockets or buffer hundreds of 10 MB bodies simultaneously.
+const REFRESH_CONCURRENCY = 8;
+// Map items through an async worker with at most `limit` in flight, preserving
+// input order in the result. Used to overlap the per-feed fetch/parse/apply work.
+async function mapWithConcurrency(items, limit, worker) {
+    const results = new Array(items.length);
+    let next = 0;
+    const runners = Array.from({ length: Math.min(limit, items.length) }, () => (async () => {
+        for (;;) {
+            const i = next++;
+            if (i >= items.length)
+                return;
+            results[i] = await worker(items[i], i);
+        }
+    })());
+    await Promise.all(runners);
+    return results;
+}
+/** Refresh every feed. Each feed's fetch + parse runs concurrently (bounded by
+ *  REFRESH_CONCURRENCY) and its synchronous apply runs in the same worker, so the
+ *  DB writes serialize naturally and only ~concurrency feeds' parsed content is held
+ *  at once. Never fails because one feed errored; tallies refreshed/failed/newItems
+ *  and returns the full updated list. */
 export async function refreshAll() {
     const rows = queryAll(`SELECT * FROM feeds ORDER BY id ASC`);
     let refreshed = 0;
     let failed = 0;
     let newItems = 0;
-    // Sequential, one transaction per feed (commit per feed keeps each transaction
-    // short on the synchronous DB; one failure never aborts the loop).
-    for (const row of rows) {
+    // Each worker fetches+parses (concurrent) then applies its own plan (synchronous,
+    // so applies never overlap and node:sqlite stays happy). The try/catch guarantees
+    // the batch always completes: even if applyRefresh's own error path throws (a
+    // DB-level fault), that feed is tallied as failed rather than aborting the request.
+    const outcomes = await mapWithConcurrency(rows, REFRESH_CONCURRENCY, async (row) => {
         try {
-            const outcome = await refreshFeedRow(row);
-            if (outcome.ok)
-                refreshed += 1;
-            else
-                failed += 1;
-            newItems += outcome.newItems;
+            const outcome = applyRefresh(row, await planRefresh(row));
+            return { ok: outcome.ok, newItems: outcome.newItems };
         }
         catch {
-            // refreshFeedRow already records its own errors; this guards against any
-            // unexpected throw so the loop always completes.
-            failed += 1;
+            return { ok: false, newItems: 0 };
         }
+    });
+    for (const outcome of outcomes) {
+        if (outcome.ok)
+            refreshed += 1;
+        else
+            failed += 1;
+        newItems += outcome.newItems;
     }
     syncOpmlMirror();
     return { feeds: listFeeds().feeds, refreshed, failed, newItems };
@@ -529,4 +585,3 @@ export function listFeedsForExport() {
 export function syncOpmlMirror() {
     writeOpmlSnapshot(listFeedsForExport());
 }
-//# sourceMappingURL=feed-service.js.map

package/dist/server/fetch-feed.js

@@ -80,4 +80,3 @@ export async function fetchFeed(input) {
         clearTimeout(timer);
     }
 }
-//# sourceMappingURL=fetch-feed.js.map

package/dist/server/index.js

@@ -61,4 +61,3 @@ serve({ fetch: app.fetch, port: PORT }, (info) => {
     console.log(`[iread] listening on ${url}`);
 });
 export { app };
-//# sourceMappingURL=index.js.map

package/dist/server/opml-sync.js

@@ -1,4 +1,4 @@
-import { mkdirSync, writeFileSync, renameSync } from 'node:fs';
+import { mkdirSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { dbPath } from './db.js';
 import { exportOpml } from './opml.js';
@@ -11,11 +11,24 @@ function resolveMirrorPath() {
     return join(dirname(dbPath), 'feeds.opml');
 }
 export const opmlMirrorPath = resolveMirrorPath();
+function withoutDateCreated(xml) {
+    return xml.replace(/[ \t]*<dateCreated>.*?<\/dateCreated>\r?\n?/, '');
+}
 export function writeOpmlSnapshot(feeds) {
     if (!opmlMirrorPath)
         return;
     try {
         const xml = exportOpml(feeds);
+        let existing = null;
+        try {
+            existing = readFileSync(opmlMirrorPath, 'utf-8');
+        }
+        catch {
+            existing = null;
+        }
+        if (existing !== null && withoutDateCreated(existing) === withoutDateCreated(xml)) {
+            return;
+        }
         mkdirSync(dirname(opmlMirrorPath), { recursive: true });
         const tmp = `${opmlMirrorPath}.tmp`;
         writeFileSync(tmp, xml, 'utf-8');
@@ -26,4 +39,3 @@ export function writeOpmlSnapshot(feeds) {
         console.warn(`[iread] could not write OPML mirror at ${opmlMirrorPath}: ${message}`);
     }
 }
-//# sourceMappingURL=opml-sync.js.map

package/dist/server/opml.js

@@ -135,4 +135,3 @@ export function exportOpml(feeds) {
     lines.push('');
     return lines.join('\n');
 }
-//# sourceMappingURL=opml.js.map

package/dist/server/routes/feeds.js

@@ -65,4 +65,3 @@ feeds.delete('/:id', (c) => {
         return serviceErrorToResponse(c, err);
     }
 });
-//# sourceMappingURL=feeds.js.map

package/dist/server/routes/helpers.js

@@ -41,4 +41,3 @@ export function parseOptionalInt(raw) {
     const n = Number(raw);
     return Number.isFinite(n) ? Math.trunc(n) : undefined;
 }
-//# sourceMappingURL=helpers.js.map

package/dist/server/routes/items.js

@@ -92,4 +92,3 @@ items.patch('/:id', async (c) => {
         return serviceErrorToResponse(c, err);
     }
 });
-//# sourceMappingURL=items.js.map

package/dist/server/routes/opml.js

@@ -47,4 +47,3 @@ opml.post('/', async (c) => {
     const body = result;
     return c.json(body, 200);
 });
-//# sourceMappingURL=opml.js.map

package/dist/server/sanitize.js

@@ -72,4 +72,3 @@ export function sanitizeArticleHtml(raw) {
 export function toPlainText(raw) {
     return sanitizeHtml(raw, { allowedTags: [], allowedAttributes: {} });
 }
-//# sourceMappingURL=sanitize.js.map

package/dist/server/ssrf.js

@@ -272,4 +272,3 @@ export async function fetchWithGuardedRedirects(initialUrl, init) {
     }
     throw new SsrfError(`Too many redirects (> ${MAX_REDIRECTS}).`);
 }
-//# sourceMappingURL=ssrf.js.map

package/dist/shared/types.js

@@ -2,4 +2,3 @@
 // Shared between the Hono server and the React client. Type-only (no runtime code).
 // Timestamps are Unix epoch milliseconds. Import everywhere with `import type`.
 export {};
-//# sourceMappingURL=types.js.map