@rmdes/indiekit-endpoint-rss 1.1.2 → 1.1.3

package/lib/controllers/feeds.js

@@ -1,8 +1,8 @@
 import { ObjectId } from "mongodb";
 import { RssClient } from "../rss-client.js";
 import { defaultContent, defaultLinkProperty } from "../jf2-builder.js";
-import { watermarkFor } from "../publisher.js";
 import { formatFeed, isValidUrl, normalizeUrl } from "../utils.js";
+import { pendingQuery, watermarkFor } from "../publisher.js";
 
 export const feedsController = {
   /**
@@ -263,7 +263,17 @@ export const feedsController = {
         { returnDocument: "after" },
       );
 
+      // Enabling publishing stamps a watermark, so a feed can be correctly
+      // configured and still have nothing to publish. Saying so beats silence.
+      let eligible;
+      if (result.publish?.enabled) {
+        eligible = await db
+          .collection("rssItems")
+          .countDocuments(pendingQuery(result));
+      }
+
       response.json({
+        eligible,
         message:
           enabled === undefined
             ? response.locals.__("rss.success.feedUpdated")
@@ -334,11 +344,10 @@ export const feedsController = {
       await feedsCollection.updateOne(
         { _id: feedId },
         {
-          $set: {
-            "publish.since": watermark,
-            // Imported history is always drafts, whatever the feed is set to.
-            "publish.status": "draft",
-          },
+          // The feed's own post status is respected: silently forcing drafts
+          // would override a deliberate choice. The guard here is the count
+          // the user asked for, and maxPostsPerCycle pacing the catch-up.
+          $set: { "publish.since": watermark },
         },
       );
 

package/lib/publisher.js

@@ -102,6 +102,35 @@ export function resolvePublishContext(application = {}, publication = {}) {
 
 const MAX_ATTEMPTS = 3;
 
+/**
+ * Query selecting a feed's items that are still waiting to be published.
+ *
+ * Exported so the dashboard can count them with exactly the same rule the
+ * publish loop applies. Two copies of this would drift, and the symptom would
+ * be a count that disagrees with what actually publishes.
+ * @param {object} feed - Feed document
+ * @returns {object} MongoDB query
+ */
+export function pendingQuery(feed) {
+  const query = {
+    feedId: feed._id,
+    postedAt: { $exists: false },
+    postSkipped: { $ne: true },
+  };
+
+  if (feed.publish?.since) {
+    // An item with no parsable date would be excluded forever by a bare
+    // `pubDate: { $gt: since }`, because null sorts below every Date in BSON.
+    // fetchedAt is always set on insert and stands in when pubDate is missing.
+    query.$or = [
+      { pubDate: { $gt: feed.publish.since } },
+      { pubDate: null, fetchedAt: { $gt: feed.publish.since } },
+    ];
+  }
+
+  return query;
+}
+
 /**
  * Publish the pending items of one feed.
  *
@@ -131,22 +160,7 @@ export async function publishPending(feed, itemsCollection, options) {
     mintImpl = mintToken,
   } = options;
 
-  const query = {
-    feedId: feed._id,
-    postedAt: { $exists: false },
-    postSkipped: { $ne: true },
-  };
-
-  if (feed.publish.since) {
-    // An item with no parsable date would be excluded forever by a bare
-    // `pubDate: { $gt: since }`, because null sorts below every Date in BSON —
-    // a silent permanent no-op. fetchedAt is always set on insert and is
-    // monotonic with cache entry, so it stands in when pubDate is missing.
-    query.$or = [
-      { pubDate: { $gt: feed.publish.since } },
-      { pubDate: null, fetchedAt: { $gt: feed.publish.since } },
-    ];
-  }
+  const query = pendingQuery(feed);
 
   const items = await itemsCollection
     .find(query)

package/locales/en.json

@@ -68,6 +68,11 @@
       "title": "Feed settings",
       "url": "Feed URL",
       "urlHint": "Correcting this keeps the cached items; removing and re-adding the feed would lose them."
+    },
+    "backfill": {
+      "label": "Publish existing items",
+      "hint": "How many of the newest cached items to publish. They are created with this feed's post status, a few per sync cycle.",
+      "submit": "Publish existing items"
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rmdes/indiekit-endpoint-rss",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "RSS feed reader endpoint for Indiekit. Aggregates multiple feeds, caches in MongoDB, displays on frontend.",
   "keywords": [
     "indiekit",

package/views/rss.njk

@@ -180,6 +180,24 @@
                   text: __("rss.publish.save")
                 }) }}
               </form>
+
+              {% if feed.publish.enabled %}
+              <form class="rss-backfill" data-backfill-feed="{{ feed.id }}">
+                {{ input({
+                  id: "backfill-last-" + feed.id,
+                  name: "last",
+                  type: "number",
+                  label: __("rss.backfill.label"),
+                  hint: __("rss.backfill.hint"),
+                  value: "10"
+                }) }}
+                {{ button({
+                  classes: "button--secondary",
+                  type: "submit",
+                  text: __("rss.backfill.submit")
+                }) }}
+              </form>
+              {% endif %}
             {% endcall %}
           </div>
           <div class="rss-feed-actions">
@@ -338,6 +356,38 @@
     }
   });
 
+  // Handle backfill
+  document.querySelectorAll('[data-backfill-feed]').forEach(form => {
+    form.addEventListener('submit', async (e) => {
+      e.preventDefault();
+      const feedId = e.target.dataset.backfillFeed;
+      const last = Number(new FormData(e.target).get('last'));
+
+      if (!last || last < 1) {
+        alert('Enter how many recent items to publish.');
+        return;
+      }
+
+      try {
+        const response = await fetch(`{{ mountPath }}/api/feeds/${feedId}/backfill`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ last })
+        });
+
+        const body = await response.json();
+        if (response.ok) {
+          alert(body.message || 'Backfill queued.');
+          location.reload();
+        } else {
+          alert(body.error || 'Failed to queue backfill');
+        }
+      } catch (err) {
+        alert('Failed to queue backfill: ' + err.message);
+      }
+    });
+  });
+
   // Handle delete feed
   document.querySelectorAll('[data-delete-feed]').forEach(btn => {
     btn.addEventListener('click', async (e) => {
@@ -386,10 +436,21 @@
           body: JSON.stringify({ url: data.get('url'), publish })
         });
 
+        const body = await response.json();
+
         if (response.ok) {
+          // A feed can be correctly configured and still have nothing to
+          // publish: the watermark only lets through items dated after the
+          // moment publishing was switched on.
+          if (body.eligible === 0) {
+            alert(
+              'Saved. No items are waiting: only items published after you ' +
+              'enabled this will post. Use "Publish existing items" to ' +
+              'include the ones already cached.'
+            );
+          }
           location.reload();
         } else {
-          const body = await response.json();
           alert(body.error || 'Failed to save publish settings');
         }
       } catch (err) {