@rmdes/indiekit-endpoint-rss 1.0.15 → 1.0.17

package/README.md

@@ -36,7 +36,8 @@ export default {
       maxItemsPerFeed: 50,           // Max items per feed to cache
       fetchTimeout: 10_000,          // 10 second timeout per feed
       maxConcurrentFetches: 3,       // Parallel feed fetches
-      retentionDays: 30              // Days to keep items
+      retentionDays: 30,             // Days to keep items
+      minItemsPerFeed: 10            // Newest items always kept, whatever their age
     })
   ],
   // MongoDB database is REQUIRED

package/index.js

@@ -6,14 +6,11 @@ import { dashboardController } from "./lib/controllers/dashboard.js";
 import { feedsController } from "./lib/controllers/feeds.js";
 import { itemsController } from "./lib/controllers/items.js";
 import { statusController } from "./lib/controllers/status.js";
-import { startSync } from "./lib/sync.js";
+import { startSync, stopSync } from "./lib/sync.js";
 import { waitForReady } from "@rmdes/indiekit-startup-gate";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
-const protectedRouter = express.Router();
-const publicRouter = express.Router();
-
 const defaults = {
   mountPath: "/rssapi",
   syncInterval: 900_000, // 15 minutes
@@ -21,6 +18,7 @@ const defaults = {
   fetchTimeout: 10_000,
   maxConcurrentFetches: 3,
   retentionDays: 30,
+  minItemsPerFeed: 10,
 };
 
 export default class RssEndpoint {
@@ -55,44 +53,60 @@ export default class RssEndpoint {
   /**
    * Protected routes (require authentication)
    * Admin dashboard and feed management (write operations)
+   *
+   * Built once per instance. Indiekit reads this getter twice while mounting
+   * (once to test it, once to pass it to router.use), so a router built on
+   * every read registers every handler twice.
+   * @returns {express.Router}
    */
   get routes() {
+    if (this._routes) return this._routes;
+
+    const router = express.Router();
+
     // Dashboard
-    protectedRouter.get("/", dashboardController.get);
+    router.get("/", dashboardController.get);
 
     // Manual sync trigger
-    protectedRouter.post("/sync", dashboardController.sync);
+    router.post("/sync", dashboardController.sync);
 
     // Clear items and re-sync
-    protectedRouter.post("/clear-resync", dashboardController.clearResync);
+    router.post("/clear-resync", dashboardController.clearResync);
 
     // Feed management (protected - requires auth)
-    protectedRouter.post("/api/feeds", express.json(), feedsController.add);
-    protectedRouter.delete("/api/feeds/:id", feedsController.remove);
-    protectedRouter.patch("/api/feeds/:id", express.json(), feedsController.toggle);
+    router.post("/api/feeds", express.json(), feedsController.add);
+    router.delete("/api/feeds/:id", feedsController.remove);
+    router.patch("/api/feeds/:id", express.json(), feedsController.toggle);
 
     // Manual refresh (protected)
-    protectedRouter.post("/api/refresh", statusController.refresh);
+    router.post("/api/refresh", statusController.refresh);
 
-    return protectedRouter;
+    this._routes = router;
+    return router;
   }
 
   /**
    * Public routes (no authentication required)
    * Read-only JSON API endpoints for frontend
+   * @returns {express.Router}
    */
   get routesPublic() {
+    if (this._routesPublic) return this._routesPublic;
+
+    const router = express.Router();
+
     // Feeds API (read-only)
-    publicRouter.get("/api/feeds", feedsController.list);
+    router.get("/api/feeds", feedsController.list);
 
     // Items API (read-only)
-    publicRouter.get("/api/items", itemsController.list);
-    publicRouter.get("/api/items/:id", itemsController.get);
+    router.get("/api/items", itemsController.list);
+    router.get("/api/items/:id", itemsController.get);
 
     // Status API (read-only)
-    publicRouter.get("/api/status", statusController.status);
+    router.get("/api/status", statusController.status);
 
-    return publicRouter;
+    this._routesPublic = router;
+    return router;
   }
 
   init(Indiekit) {
@@ -120,5 +134,6 @@ export default class RssEndpoint {
 
   destroy() {
     this._stopGate?.();
+    stopSync();
   }
 }

package/lib/controllers/feeds.js

@@ -85,7 +85,7 @@ export const feedsController = {
         description: feedMeta.description,
         imageUrl: feedMeta.imageUrl,
         enabled: true,
-        addedAt: new Date(),
+        addedAt: new Date().toISOString(),
         lastFetchedAt: null,
         lastError: null,
         itemCount: 0,

package/lib/sync.js

@@ -1,6 +1,7 @@
 import { RssClient } from "./rss-client.js";
 
 let syncInterval = null;
+let initialSyncTimeout = null;
 let syncState = {
   lastSync: null,
   syncing: false,
@@ -25,12 +26,16 @@ export function getSyncState() {
 export function startSync(Indiekit, options) {
   const intervalMs = options.syncInterval || 900_000; // 15 minutes default
 
+  // Starting twice would orphan the previous timers with no handle to clear.
+  stopSync();
+
   console.log(
     `[RSS] Starting background sync with ${intervalMs / 60_000}min interval`
   );
 
   // Initial sync after delay
-  setTimeout(() => {
+  initialSyncTimeout = setTimeout(() => {
+    initialSyncTimeout = null;
     runSync(Indiekit, options).catch((err) => {
       console.error("[RSS] Initial sync error:", err.message);
     });
@@ -48,9 +53,16 @@ export function startSync(Indiekit, options) {
  * Stop background sync
  */
 export function stopSync() {
-  if (syncInterval) {
-    clearInterval(syncInterval);
-    syncInterval = null;
+  const wasRunning = Boolean(syncInterval || initialSyncTimeout);
+
+  // Both timers matter: destroy() within the first 10 seconds would otherwise
+  // still fire an initial sync against a torn-down plugin.
+  clearTimeout(initialSyncTimeout);
+  initialSyncTimeout = null;
+  clearInterval(syncInterval);
+  syncInterval = null;
+
+  if (wasRunning) {
     console.log("[RSS] Background sync stopped");
   }
 }
@@ -88,6 +100,7 @@ export async function runSync(dbOrIndiekit, options) {
 
     // Create indexes if they don't exist
     await createIndexes(feedsCollection, itemsCollection);
+    await normalizeLegacyFeedDates(feedsCollection);
 
     // Get all enabled feeds
     const feeds = await feedsCollection.find({ enabled: true }).toArray();
@@ -122,6 +135,7 @@ export async function runSync(dbOrIndiekit, options) {
       itemsCollection,
       feedsCollection,
       retentionDays,
+      options.minItemsPerFeed ?? 10,
     );
 
     syncState.lastSync = new Date().toISOString();
@@ -258,40 +272,96 @@ async function createIndexes(feedsCollection, itemsCollection) {
 }
 
 /**
- * Prune items older than retention period and update feed item counts
+ * Rewrite legacy BSON Date values of `addedAt` as ISO 8601 strings.
+ *
+ * Indiekit stores dates as ISO strings. Feeds added before that was fixed hold
+ * a BSON Date, and in BSON a Date sorts after every string — so a mixed
+ * collection buries newly added feeds at the bottom of { addedAt: -1 }.
+ * No-op once every row has been converted.
+ * @param {Collection} feedsCollection - Feeds collection
+ * @returns {Promise<number>} Number of feeds normalized
+ */
+export async function normalizeLegacyFeedDates(feedsCollection) {
+  const legacy = await feedsCollection
+    .find({ addedAt: { $type: "date" } })
+    .toArray();
+
+  for (const feed of legacy) {
+    await feedsCollection.updateOne(
+      { _id: feed._id },
+      { $set: { addedAt: feed.addedAt.toISOString() } },
+    );
+  }
+
+  if (legacy.length > 0) {
+    console.log(`[RSS] Normalized addedAt on ${legacy.length} feed(s)`);
+  }
+
+  return legacy.length;
+}
+
+/**
+ * Prune items older than the retention period.
+ *
+ * The newest `minItemsPerFeed` items of every feed are kept whatever their
+ * age. Without that floor a low-traffic feed whose whole backlog predates the
+ * cutoff is emptied and refetched on every single sync, so it churns forever
+ * and always reads as empty.
  * @param {Collection} itemsCollection - Items collection
  * @param {Collection} feedsCollection - Feeds collection
  * @param {number} retentionDays - Days to keep items
+ * @param {number} minItemsPerFeed - Newest items always kept per feed
  * @returns {Promise<number>} Number of items pruned
  */
-async function pruneOldItems(itemsCollection, feedsCollection, retentionDays) {
+export async function pruneOldItems(
+  itemsCollection,
+  feedsCollection,
+  retentionDays,
+  minItemsPerFeed = 10,
+) {
   const cutoff = new Date();
   cutoff.setDate(cutoff.getDate() - retentionDays);
 
   try {
-    const result = await itemsCollection.deleteMany({
-      pubDate: { $lt: cutoff },
-    });
-
-    if (result.deletedCount > 0) {
-      console.log(
-        `[RSS] Pruned ${result.deletedCount} items older than ${retentionDays} days`,
-      );
-
-      // Update item counts for all feeds
-      const feeds = await feedsCollection.find({}).toArray();
-      for (const feed of feeds) {
-        const count = await itemsCollection.countDocuments({
+    const feeds = await feedsCollection.find({}).toArray();
+    let deletedCount = 0;
+
+    for (const feed of feeds) {
+      const keep = await itemsCollection
+        .find({ feedId: feed._id })
+        .sort({ pubDate: -1 })
+        .limit(minItemsPerFeed)
+        .project({ _id: 1 })
+        .toArray();
+
+      const result = await itemsCollection.deleteMany({
+        feedId: feed._id,
+        // $ne: null also excludes missing dates: in BSON null sorts before
+        // Date, so a bare $lt would delete every undated item as "too old".
+        pubDate: { $lt: cutoff, $ne: null },
+        _id: { $nin: keep.map((item) => item._id) },
+      });
+
+      if (result.deletedCount > 0) {
+        deletedCount += result.deletedCount;
+
+        const itemCount = await itemsCollection.countDocuments({
           feedId: feed._id,
         });
         await feedsCollection.updateOne(
           { _id: feed._id },
-          { $set: { itemCount: count } },
+          { $set: { itemCount } },
         );
       }
     }
 
-    return result.deletedCount;
+    if (deletedCount > 0) {
+      console.log(
+        `[RSS] Pruned ${deletedCount} items older than ${retentionDays} days`,
+      );
+    }
+
+    return deletedCount;
   } catch (err) {
     console.error("[RSS] Prune error:", err.message);
     return 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rmdes/indiekit-endpoint-rss",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "description": "RSS feed reader endpoint for Indiekit. Aggregates multiple feeds, caches in MongoDB, displays on frontend.",
   "keywords": [
     "indiekit",
@@ -30,6 +30,9 @@
   },
   "type": "module",
   "main": "index.js",
+  "scripts": {
+    "test": "node --test \"test/*.test.js\""
+  },
   "exports": {
     ".": "./index.js"
   },