@rmdes/indiekit-endpoint-syndicate 1.0.0-beta.37 → 1.0.0-beta.39

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).
+ */
+let batchRunning = false;
+
 /**
  * Syndicate a single post and update it via Micropub
  * @param {object} options - Options
@@ -34,10 +52,15 @@ const syndicatePost = async ({
 }) => {
   // Readiness gate: verify post and OG image are live before syndicating.
   // 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;
   if (!force && meUrl && postData.properties?.url) {
-    console.log(`[syndication] Readiness gate: checking ${postData.properties.url} (me=${meUrl})`);
-    const readiness = await isPostReady(postData.properties.url, meUrl);
+    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 ` +
@@ -148,87 +171,98 @@ export const syndicateController = {
       }
 
       // --- Batch mode (no source_url — process ALL pending posts) ---
-      const allPostData = await getAllPostData(postsCollection);
-
-      if (!allPostData || allPostData.length === 0) {
+      if (batchRunning) {
+        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)`,
-      );
+      batchRunning = 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 {
+        batchRunning = false;
+      }
     } catch (error) {
       next(error);
     }

package/lib/utils.js

@@ -142,8 +142,12 @@ export const syndicateToTargets = async (
           }
         })
         .map((t) => t.info.uid);
+    } else {
+      // Fall back to targets marked as checked by default
+      syndicateTo = syndicationTargets
+        .filter((t) => t?.options?.checked)
+        .map((t) => t.info.uid);
     }
-    // If no existing syndication URLs, don't default to all — leave empty
   }
 
   // BUG FIX: Was `Array.isArray` (always truthy, it's a function reference)
@@ -254,12 +258,16 @@ export function urlToOgSlug(postUrl) {
  *
  * @param {string} postUrl - Full public URL of the post
  * @param {string} me - Publication URL (e.g., "https://rmendes.net")
+ * @param {object} [options] - Options
+ * @param {boolean} [options.skipOg] - Skip OG image check (e.g., photo posts
+ *   where Eleventy uses the photo itself as og:image instead of generating /og/*.png)
  * @returns {Promise<{ready: boolean, postStatus: number, ogStatus: number}>}
  */
-export async function isPostReady(postUrl, me) {
+export async function isPostReady(postUrl, me, options = {}) {
+  const { skipOg = false } = options;
   const ogSlug = urlToOgSlug(postUrl);
   const meNorm = me?.replace(/\/$/, "");
-  const ogUrl = ogSlug && meNorm ? `${meNorm}/og/${ogSlug}.png` : null;
+  const ogUrl = !skipOg && ogSlug && meNorm ? `${meNorm}/og/${ogSlug}.png` : null;
 
   const headCheck = async (url) => {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rmdes/indiekit-endpoint-syndicate",
-  "version": "1.0.0-beta.37",
+  "version": "1.0.0-beta.39",
   "description": "Syndication endpoint for Indiekit. Fork of @indiekit/endpoint-syndicate with batch syndication support and bug fixes.",
   "keywords": [
     "indiekit",
@@ -37,5 +37,8 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "test": "node --test test/*.js"
   }
 }