@rmdes/indiekit-endpoint-syndicate 1.0.0-beta.38 → 1.0.0-beta.40

package/lib/controllers/syndicate.js

@@ -15,6 +15,24 @@ import {
  */
 const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
+/**
+ * Guards batch mode against overlapping runs.
+ *
+ * A post stays selectable until its Micropub update lands at the end of a
+ * batch, so a second trigger arriving mid-batch sees `mp-syndicate-to` still
+ * set and syndicates it again. Both triggers — the poller and the Eleventy
+ * post-build hook — reach the same process, so a module-level flag is enough.
+ * Anything skipped is picked up by the next poll.
+ *
+ * Batch mode only: the single-post force path (source_url) is deliberately
+ * unguarded so manual re-syndication always runs.
+ *
+ * ponytail: single-process guard. If Indiekit is ever run multi-process or
+ * multi-container, replace with an atomic per-post claim (findOneAndUpdate
+ * setting a claim timestamp, with a stale-claim timeout).
+ */
+const batch = { isRunning: false };
+
 /**
  * Syndicate a single post and update it via Micropub
  * @param {object} options - Options
@@ -36,17 +54,24 @@ const syndicatePost = async ({
   // Skip check in force mode (manual re-syndication from UI/backlog script).
   // Photo posts skip OG check — Eleventy deliberately skips OG generation
   // for posts with photos (the photo itself serves as og:image in HTML).
-  const meUrl = typeof publication.me === "string" ? publication.me : publication.me?.href || publication.me?.toString?.() || "";
-  const hasPhotos = Array.isArray(postData.properties?.photo) && postData.properties.photo.length > 0;
+  const meUrl =
+    typeof publication.me === "string"
+      ? publication.me
+      : publication.me?.href || publication.me?.toString?.() || "";
+  const hasPhotos =
+    Array.isArray(postData.properties?.photo) &&
+    postData.properties.photo.length > 0;
   if (!force && meUrl && postData.properties?.url) {
-    console.log(`[syndication] Readiness gate: checking ${postData.properties.url} (me=${meUrl}, hasPhotos=${hasPhotos})`);
+    console.log(
+      `[syndication] Readiness gate: checking ${postData.properties.url} (me=${meUrl}, hasPhotos=${hasPhotos})`,
+    );
     const readiness = hasPhotos
       ? await isPostReady(postData.properties.url, meUrl, { skipOg: true })
       : await isPostReady(postData.properties.url, meUrl);
     if (!readiness.ready) {
       console.log(
         `[syndication] Skipping ${postData.properties.url} — not yet built ` +
-        `(post: ${readiness.postStatus}, og: ${readiness.ogStatus})`
+          `(post: ${readiness.postStatus}, og: ${readiness.ogStatus})`,
       );
       return { skipped: true, url: postData.properties.url, readiness };
     }
@@ -81,7 +106,9 @@ const syndicatePost = async ({
     throw await IndiekitError.fromFetch(micropubResponse);
   }
 
-  /** @type {object} */
+  /**
+  @type {object}
+   */
   const body = await micropubResponse.json();
 
   return {
@@ -153,87 +180,97 @@ export const syndicateController = {
       }
 
       // --- Batch mode (no source_url — process ALL pending posts) ---
-      const allPostData = await getAllPostData(postsCollection);
-
-      if (!allPostData || allPostData.length === 0) {
+      if (batch.isRunning) {
+        console.log("[syndication] Batch already in progress, skipping");
         return response.json({
           success: "OK",
-          success_description: "No posts awaiting syndication",
+          success_description: "Batch already in progress",
         });
       }
 
-      console.log(
-        `[syndication] Batch processing ${allPostData.length} post(s)`,
-      );
+      batch.isRunning = true;
 
-      const results = [];
-      let successCount = 0;
-      let failCount = 0;
-      let skippedCount = 0;
-
-      for (const postData of allPostData) {
-        try {
-          const result = await syndicatePost({
-            application,
-            publication,
-            postData,
-            bearerToken,
+      try {
+        const allPostData = await getAllPostData(postsCollection);
+
+        if (!allPostData || allPostData.length === 0) {
+          return response.json({
+            success: "OK",
+            success_description: "No posts awaiting syndication",
           });
+        }
+
+        console.log(
+          `[syndication] Batch processing ${allPostData.length} post(s)`,
+        );
+
+        const results = [];
+
+        for (const [index, postData] of allPostData.entries()) {
+          try {
+            const result = await syndicatePost({
+              application,
+              publication,
+              postData,
+              bearerToken,
+            });
+
+            // Post was skipped (not yet built)
+            if (result.skipped) {
+              results.push({
+                url: result.url,
+                success: true,
+                skipped: true,
+                reason: `Not yet built (post: ${result.readiness.postStatus}, og: ${result.readiness.ogStatus})`,
+              });
+              continue;
+            }
 
-          // Post was skipped (not yet built)
-          if (result.skipped) {
             results.push({
               url: result.url,
               success: true,
-              skipped: true,
-              reason: `Not yet built (post: ${result.readiness.postStatus}, og: ${result.readiness.ogStatus})`,
+              syndicatedUrls: result.syndicatedUrls,
+              ...(result.failedTargets && {
+                failedTargets: result.failedTargets,
+              }),
             });
-            skippedCount++;
-            continue;
-          }
-
-          results.push({
-            url: result.url,
-            success: true,
-            syndicatedUrls: result.syndicatedUrls,
-            ...(result.failedTargets && {
-              failedTargets: result.failedTargets,
-            }),
-          });
 
-          successCount++;
-          console.log(
-            `[syndication] Syndicated: ${result.url} (${result.syndicatedUrls.length} target(s))`,
-          );
-        } catch (error) {
-          results.push({
-            url: postData.properties?.url,
-            success: false,
-            error: error.message,
-          });
+            console.log(
+              `[syndication] Syndicated: ${result.url} (${result.syndicatedUrls.length} target(s))`,
+            );
+          } catch (error) {
+            results.push({
+              url: postData.properties?.url,
+              success: false,
+              error: error.message,
+            });
 
-          failCount++;
-          console.error(
-            `[syndication] Failed: ${postData.properties?.url} - ${error.message}`,
-          );
-        }
+            console.error(
+              `[syndication] Failed: ${postData.properties?.url} - ${error.message}`,
+            );
+          }
 
-        // Rate limit delay between posts (2 seconds)
-        if (allPostData.indexOf(postData) < allPostData.length - 1) {
-          await delay(2000);
+          // Rate limit delay between posts (2 seconds)
+          if (index < allPostData.length - 1) {
+            await delay(2000);
+          }
         }
-      }
 
-      const description =
-        `Processed ${allPostData.length} post(s): ${successCount} succeeded, ${failCount} failed, ${skippedCount} not yet built`;
+        const failed = results.filter((result) => !result.success).length;
+        const skipped = results.filter((result) => result.skipped).length;
+        const succeeded = results.length - failed - skipped;
+        const description = `Processed ${allPostData.length} post(s): ${succeeded} succeeded, ${failed} failed, ${skipped} not yet built`;
 
-      console.log(`[syndication] ${description}`);
+        console.log(`[syndication] ${description}`);
 
-      return response.json({
-        success: "OK",
-        success_description: description,
-        results,
-      });
+        return response.json({
+          success: "OK",
+          success_description: description,
+          results,
+        });
+      } finally {
+        batch.isRunning = false;
+      }
     } catch (error) {
       next(error);
     }

package/lib/utils.js

@@ -5,36 +5,31 @@
  * @returns {Promise<object>} Post data for given URL else most recent pending post
  */
 export const getPostData = async (postsCollection, url) => {
-  let postData = {};
-
   if (url) {
-    // Get item in database with matching URL
-    postData = await postsCollection.findOne({
+    return postsCollection.findOne({
       "properties.url": url,
     });
-  } else {
-    // Get most recent published post awaiting syndication
-    const items = await postsCollection
-      .find({
-        "properties.mp-syndicate-to": {
-          $exists: true,
-        },
-        // BUG FIX: Removed "properties.syndication": { $exists: false }
-        // That filter skipped partially syndicated posts (e.g., posted to
-        // Mastodon but not yet to Bluesky). syndicateToTargets() already
-        // calls hasSyndicationUrl() to skip completed targets.
-        "properties.post-status": {
-          $ne: "draft",
-        },
-      })
-      // eslint-disable-next-line unicorn/no-array-sort
-      .sort({ "properties.published": -1 })
-      .limit(1)
-      .toArray();
-    postData = items[0];
   }
 
-  return postData;
+  // A post is awaiting syndication while `mp-syndicate-to` remains: it is
+  // deleted once every target has returned a URL, and replaced with the
+  // targets that failed otherwise. Posts already syndicated to some of their
+  // targets are therefore still awaiting the rest, and `syndicateToTargets`
+  // skips the ones already done.
+  const items = await postsCollection
+    .find({
+      "properties.mp-syndicate-to": {
+        $exists: true,
+      },
+      "properties.post-status": {
+        $ne: "draft",
+      },
+    })
+    .sort({ "properties.published": -1 })
+    .limit(1)
+    .toArray();
+
+  return items[0];
 };
 
 /**
@@ -53,7 +48,7 @@ export const getAllPostData = async (postsCollection) => {
         $ne: "draft",
       },
     })
-    // eslint-disable-next-line unicorn/no-array-sort
+
     .sort({ "properties.published": -1 })
     .toArray();
 
@@ -136,7 +131,9 @@ export const syndicateToTargets = async (
       syndicateTo = syndicationTargets
         .filter((t) => {
           try {
-            return t?.info?.uid && existingOrigins.has(new URL(t.info.uid).origin);
+            return (
+              t?.info?.uid && existingOrigins.has(new URL(t.info.uid).origin)
+            );
           } catch {
             return false;
           }
@@ -228,7 +225,6 @@ export const syndicateToTargets = async (
  *
  * Date-based: /type/YYYY/MM/DD/slug → YYYY-MM-DD-slug
  * Non-date:   /about/ → about
- *
  * @param {string} postUrl - Full post URL
  * @returns {string|null} OG slug or null
  */
@@ -240,22 +236,46 @@ export function urlToOgSlug(postUrl) {
     // Date-based URL: /type/yyyy/MM/dd/slug → 5 segments
     if (segments.length === 5) {
       const [, year, month, day, slug] = segments;
-      if (/^\d{4}$/.test(year) && /^\d{2}$/.test(month) && /^\d{2}$/.test(day)) {
+      if (
+        /^\d{4}$/.test(year) &&
+        /^\d{2}$/.test(month) &&
+        /^\d{2}$/.test(day)
+      ) {
         return `${year}-${month}-${day}-${slug}`;
       }
     }
 
     // Fallback: last segment
-    return segments[segments.length - 1] || null;
+    return segments.at(-1);
   } catch {
-    return null;
+    return;
   }
 }
 
+/**
+ * HEAD a URL and report its status, 0 on network error or timeout
+ * @param {string} url - URL to check
+ * @returns {Promise<number>} HTTP status
+ */
+const headCheck = async (url) => {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5000);
+    const response = await fetch(url, {
+      method: "HEAD",
+      redirect: "follow",
+      signal: controller.signal,
+    });
+    clearTimeout(timeoutId);
+    return response.status;
+  } catch {
+    return 0;
+  }
+};
+
 /**
  * Check if a post and its OG image are live on the public site.
  * Uses HTTP HEAD requests with a 5-second timeout.
- *
  * @param {string} postUrl - Full public URL of the post
  * @param {string} me - Publication URL (e.g., "https://rmendes.net")
  * @param {object} [options] - Options
@@ -267,23 +287,8 @@ export async function isPostReady(postUrl, me, options = {}) {
   const { skipOg = false } = options;
   const ogSlug = urlToOgSlug(postUrl);
   const meNorm = me?.replace(/\/$/, "");
-  const ogUrl = !skipOg && ogSlug && meNorm ? `${meNorm}/og/${ogSlug}.png` : null;
-
-  const headCheck = async (url) => {
-    try {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), 5000);
-      const response = await fetch(url, {
-        method: "HEAD",
-        redirect: "follow",
-        signal: controller.signal,
-      });
-      clearTimeout(timeoutId);
-      return response.status;
-    } catch {
-      return 0;
-    }
-  };
+  const ogUrl =
+    !skipOg && ogSlug && meNorm ? `${meNorm}/og/${ogSlug}.png` : undefined;
 
   const [postStatus, ogStatus] = await Promise.all([
     headCheck(postUrl),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rmdes/indiekit-endpoint-syndicate",
-  "version": "1.0.0-beta.38",
+  "version": "1.0.0-beta.40",
   "description": "Syndication endpoint for Indiekit. Fork of @indiekit/endpoint-syndicate with batch syndication support and bug fixes.",
   "keywords": [
     "indiekit",
@@ -15,7 +15,7 @@
   },
   "license": "MIT",
   "engines": {
-    "node": ">=20"
+    "node": ">=24.17"
   },
   "type": "module",
   "main": "index.js",
@@ -28,14 +28,17 @@
     "url": "https://github.com/rmdes/indiekit-endpoint-syndicate.git"
   },
   "dependencies": {
-    "@indiekit/error": "^1.0.0-beta.27",
-    "express": "^5.0.0",
-    "jsonwebtoken": "^9.0.0"
+    "@indiekit/error": "^1.0.0-beta.28",
+    "express": "^5.2.1",
+    "jsonwebtoken": "^9.0.3"
   },
   "peerDependencies": {
     "@indiekit/indiekit": ">=1.0.0-beta.25"
   },
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "test": "node --test test/*.js"
   }
 }