@rmdes/indiekit-endpoint-rss 1.1.1 → 1.1.3

package/assets/styles.css

@@ -83,19 +83,28 @@
 }
 
 .rss-feed-item {
-  align-items: center;
+  align-items: flex-start;
   border-block-end: 1px solid var(--color-border);
   display: flex;
-  flex-wrap: wrap;
   gap: var(--space-s);
   padding: var(--space-s) 0;
 }
 
-/* The publish disclosure gets a row of its own. As a plain flex sibling of the
-   icon, info and actions it was squeezed into the same line and overlapped the
-   feed metadata. */
+/* The publish disclosure lives inside the feed's own column. As a full-width
+   flex row it turned every feed into three rows and put a bar wider than the
+   feed between each entry, which made the list unscannable. Its summary stays
+   quiet so the feed title remains what the eye lands on. */
 .rss-publish {
-  flex-basis: 100%;
+  margin-block-start: var(--space-2xs);
+}
+
+.rss-publish .details__summary {
+  color: var(--color-text-secondary);
+  font-size: var(--step--1);
+}
+
+.rss-publish .details__main {
+  padding-block-start: var(--space-2xs);
 }
 
 .rss-feed-item:last-child {

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 = {
   /**
@@ -156,13 +156,13 @@ export const feedsController = {
   async toggle(request, response) {
     try {
       const { id } = request.params;
-      const { enabled, publish } = request.body;
+      const { enabled, publish, url } = request.body;
 
       if (!ObjectId.isValid(id)) {
         return response.status(400).json({ error: "Invalid feed ID" });
       }
 
-      if (enabled === undefined && publish === undefined) {
+      if (enabled === undefined && publish === undefined && url === undefined) {
         return response.status(400).json({ error: "Nothing to update" });
       }
 
@@ -191,6 +191,31 @@ export const feedsController = {
         update.enabled = enabled;
       }
 
+      if (url !== undefined) {
+        if (!isValidUrl(url)) {
+          return response.status(400).json({
+            error: response.locals.__("rss.error.invalidUrl"),
+          });
+        }
+
+        const normalizedUrl = normalizeUrl(url);
+        const clash = await feedsCollection.findOne({
+          url: normalizedUrl,
+          _id: { $ne: feedId },
+        });
+
+        if (clash) {
+          return response.status(409).json({
+            error: response.locals.__("rss.error.feedExists"),
+          });
+        }
+
+        update.url = normalizedUrl;
+        // Items key on feedId, so they survive the change. Any error from the
+        // old URL is stale the moment it is corrected.
+        update.lastError = null;
+      }
+
       if (publish !== undefined) {
         const { postTypes } = request.app.locals.publication || {};
 
@@ -238,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")
@@ -309,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/lib/sync.js

@@ -173,7 +173,7 @@ export async function runSync(dbOrIndiekit, options, publishContext) {
       itemsCollection,
       feedsCollection,
       retentionDays,
-      options.minItemsPerFeed ?? 10,
+      retentionFloor(options),
     );
 
     syncState.lastSync = new Date().toISOString();
@@ -310,6 +310,21 @@ async function createIndexes(feedsCollection, itemsCollection) {
   await itemsCollection.createIndex({ fetchedAt: -1 });
 }
 
+/**
+ * Number of newest items per feed that pruning must never touch.
+ *
+ * Pruning an item the feed still serves is a no-op by construction — the next
+ * sync re-inserts it. A sync stores at most `maxItemsPerFeed` items per feed,
+ * so age-based retention below that threshold can only churn: insert, delete,
+ * refetch, forever. The floor is therefore derived from what a sync can store,
+ * not set as an independent constant.
+ * @param {object} options - Plugin options
+ * @returns {number} Items to keep per feed regardless of age
+ */
+export function retentionFloor(options = {}) {
+  return Math.max(options.minItemsPerFeed ?? 10, options.maxItemsPerFeed ?? 50);
+}
+
 /**
  * Rewrite legacy BSON Date values of `addedAt` as ISO 8601 strings.
  *

package/locales/en.json

@@ -56,13 +56,23 @@
       "enabled": "Create posts from this feed",
       "postType": "Post type",
       "content": "Content template",
-      "contentHint": "Placeholders: {{title}} {{link}} {{description}} {{content}} {{author}} {{sourceTitle}}",
+      "contentHint": "Available: title, link, description, content, author, sourceTitle. Write each one in double braces, as shown below.",
       "linkProperty": "Link property",
       "linkPropertyHint": "Discovery property carrying the item URL, e.g. bookmark-of. Leave empty for a plain note or article.",
       "status": "Post status",
       "draft": "Draft",
       "published": "Published",
-      "save": "Save publish settings"
+      "save": "Save settings"
+    },
+    "settings": {
+      "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.1",
+  "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

@@ -100,79 +100,106 @@
             {% if feed.lastError %}
             <div class="rss-feed-error">{{ feed.lastError }}</div>
             {% endif %}
+            {% set typeItems = [] %}
+            {% for type in postTypes %}
+            {% set typeItems = (typeItems.push({
+              text: type,
+              value: type,
+              selected: feed.publish.postType == type
+            }), typeItems) %}
+            {% endfor %}
+            {% set publishSummary %}{{ __("rss.settings.title") }}{% if feed.publish.enabled %} &bull; {{ feed.publish.postType }}{% endif %}{% endset %}
+            {% call details({
+              classes: "rss-publish",
+              summary: publishSummary
+            }) %}
+              <form data-publish-feed="{{ feed.id }}">
+                {{ input({
+                  id: "feed-url-" + feed.id,
+                  name: "url",
+                  type: "url",
+                  label: __("rss.settings.url"),
+                  hint: __("rss.settings.urlHint"),
+                  value: feed.url
+                }) }}
+
+                {{ checkboxes({
+                  idPrefix: "publish-enabled-" + feed.id,
+                  name: "enabled",
+                  items: [{
+                    value: "true",
+                    label: __("rss.publish.enabled"),
+                    checked: feed.publish.enabled
+                  }]
+                }) }}
+
+                {{ select({
+                  id: "publish-post-type-" + feed.id,
+                  name: "postType",
+                  label: __("rss.publish.postType"),
+                  items: typeItems
+                }) }}
+
+                {{ input({
+                  id: "publish-content-" + feed.id,
+                  name: "content",
+                  label: __("rss.publish.content"),
+                  hint: __("rss.publish.contentHint"),
+                  value: feed.publish.content or "{{description}}"
+                }) }}
+
+                {{ input({
+                  id: "publish-link-property-" + feed.id,
+                  name: "linkProperty",
+                  label: __("rss.publish.linkProperty"),
+                  hint: __("rss.publish.linkPropertyHint"),
+                  optional: true,
+                  value: feed.publish.linkProperty
+                }) }}
+
+                {{ select({
+                  id: "publish-status-" + feed.id,
+                  name: "status",
+                  label: __("rss.publish.status"),
+                  items: [
+                    {
+                      text: __("rss.publish.draft"),
+                      value: "draft",
+                      selected: feed.publish.status != "published"
+                    },
+                    {
+                      text: __("rss.publish.published"),
+                      value: "published",
+                      selected: feed.publish.status == "published"
+                    }
+                  ]
+                }) }}
+
+                {{ button({
+                  type: "submit",
+                  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>
-          {% set typeItems = [] %}
-          {% for type in postTypes %}
-          {% set typeItems = (typeItems.push({
-            text: type,
-            value: type,
-            selected: feed.publish.postType == type
-          }), typeItems) %}
-          {% endfor %}
-          {% set publishSummary %}{{ __("rss.publish.title") }}{% if feed.publish.enabled %} &bull; {{ feed.publish.postType }}{% endif %}{% endset %}
-          {% call details({
-            classes: "rss-publish",
-            summary: publishSummary
-          }) %}
-            <form data-publish-feed="{{ feed.id }}">
-              {{ checkboxes({
-                idPrefix: "publish-enabled-" + feed.id,
-                name: "enabled",
-                items: [{
-                  value: "true",
-                  text: __("rss.publish.enabled"),
-                  checked: feed.publish.enabled
-                }]
-              }) }}
-
-              {{ select({
-                id: "publish-post-type-" + feed.id,
-                name: "postType",
-                label: __("rss.publish.postType"),
-                items: typeItems
-              }) }}
-
-              {{ input({
-                id: "publish-content-" + feed.id,
-                name: "content",
-                label: __("rss.publish.content"),
-                hint: __("rss.publish.contentHint"),
-                value: feed.publish.content or "{{description}}"
-              }) }}
-
-              {{ input({
-                id: "publish-link-property-" + feed.id,
-                name: "linkProperty",
-                label: __("rss.publish.linkProperty"),
-                hint: __("rss.publish.linkPropertyHint"),
-                optional: true,
-                value: feed.publish.linkProperty
-              }) }}
-
-              {{ select({
-                id: "publish-status-" + feed.id,
-                name: "status",
-                label: __("rss.publish.status"),
-                items: [
-                  {
-                    text: __("rss.publish.draft"),
-                    value: "draft",
-                    selected: feed.publish.status != "published"
-                  },
-                  {
-                    text: __("rss.publish.published"),
-                    value: "published",
-                    selected: feed.publish.status == "published"
-                  }
-                ]
-              }) }}
-
-              {{ button({
-                type: "submit",
-                text: __("rss.publish.save")
-              }) }}
-            </form>
-          {% endcall %}
           <div class="rss-feed-actions">
             <label class="rss-toggle">
               <input
@@ -329,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) => {
@@ -374,13 +433,24 @@
         const response = await fetch(`{{ mountPath }}/api/feeds/${feedId}`, {
           method: 'PATCH',
           headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ publish })
+          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) {