@rmdes/indiekit-endpoint-syndicate 1.0.0-beta.27

package/index.js

@@ -0,0 +1,29 @@
+import express from "express";
+
+import { syndicateController } from "./lib/controllers/syndicate.js";
+
+const defaults = { mountPath: "/syndicate" };
+const router = express.Router();
+
+export default class SyndicateEndpoint {
+  name = "Syndication endpoint";
+
+  constructor(options = {}) {
+    this.options = { ...defaults, ...options };
+    this.mountPath = this.options.mountPath;
+  }
+
+  get routesPublic() {
+    router.post("/", syndicateController.post);
+
+    return router;
+  }
+
+  init(Indiekit) {
+    Indiekit.addEndpoint(this);
+
+    // Use private value to register syndication endpoint path
+    Indiekit.config.application._syndicationEndpointPath =
+      this.options.mountPath;
+  }
+}

package/lib/controllers/syndicate.js

@@ -0,0 +1,203 @@
+import { IndiekitError } from "@indiekit/error";
+
+import { findBearerToken } from "../token.js";
+import {
+  getAllPostData,
+  getPostData,
+  syndicateToTargets,
+} from "../utils.js";
+
+/**
+ * Delay helper for rate limiting between posts
+ * @param {number} ms - Milliseconds to wait
+ * @returns {Promise<void>}
+ */
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+/**
+ * Syndicate a single post and update it via Micropub
+ * @param {object} options - Options
+ * @param {object} options.application - Application config
+ * @param {object} options.publication - Publication config
+ * @param {object} options.postData - Post data from database
+ * @param {string} options.bearerToken - Bearer token for Micropub
+ * @returns {Promise<object>} Result object
+ */
+const syndicatePost = async ({
+  application,
+  publication,
+  postData,
+  bearerToken,
+}) => {
+  const { failedTargets, syndicatedUrls } = await syndicateToTargets(
+    publication,
+    postData.properties,
+  );
+
+  // Update post with syndicated URL(s) and remaining syndication target(s)
+  const micropubResponse = await fetch(application.micropubEndpoint, {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      authorization: `Bearer ${bearerToken}`,
+      "content-type": "application/json",
+    },
+    body: JSON.stringify({
+      action: "update",
+      url: postData.properties.url,
+      ...(!failedTargets && { delete: ["mp-syndicate-to"] }),
+      replace: {
+        ...(failedTargets && { "mp-syndicate-to": failedTargets }),
+        ...(syndicatedUrls && { syndication: syndicatedUrls }),
+      },
+    }),
+  });
+
+  if (!micropubResponse.ok) {
+    throw await IndiekitError.fromFetch(micropubResponse);
+  }
+
+  /** @type {object} */
+  const body = await micropubResponse.json();
+
+  return {
+    url: postData.properties.url,
+    body,
+    failedTargets,
+    syndicatedUrls,
+  };
+};
+
+export const syndicateController = {
+  async post(request, response, next) {
+    try {
+      const { application, publication } = request.app.locals;
+      const bearerToken = findBearerToken(request);
+      const sourceUrl =
+        request.query.source_url || request.body?.syndication?.source_url;
+      const redirectUri =
+        request.query.redirect_uri || request.body?.syndication?.redirect_uri;
+
+      const postsCollection = application?.collections?.get("posts");
+      if (!postsCollection) {
+        throw IndiekitError.notImplemented(
+          response.locals.__("NotImplementedError.database"),
+        );
+      }
+
+      // Get syndication targets
+      const { syndicationTargets } = publication;
+      if (syndicationTargets.length === 0) {
+        return response.json({
+          success: "OK",
+          success_description: "No syndication targets have been configured",
+        });
+      }
+
+      // --- Single post mode (when source_url is provided) ---
+      if (sourceUrl) {
+        const postData = await getPostData(postsCollection, sourceUrl);
+
+        if (!postData) {
+          return response.json({
+            success: "OK",
+            success_description: `No post record available for ${sourceUrl}`,
+          });
+        }
+
+        const result = await syndicatePost({
+          application,
+          publication,
+          postData,
+          bearerToken,
+        });
+
+        // Include failed syndication targets in response
+        if (result.failedTargets) {
+          result.body.success_description +=
+            ". The following target(s) did not return a URL: " +
+            result.failedTargets.join(" ");
+        }
+
+        if (redirectUri && redirectUri.startsWith("/")) {
+          const message = encodeURIComponent(result.body.success_description);
+          return response.redirect(`${redirectUri}?success=${message}`);
+        }
+
+        return response.json(result.body);
+      }
+
+      // --- Batch mode (no source_url — process ALL pending posts) ---
+      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 = [];
+      let successCount = 0;
+      let failCount = 0;
+
+      for (const postData of allPostData) {
+        try {
+          const result = await syndicatePost({
+            application,
+            publication,
+            postData,
+            bearerToken,
+          });
+
+          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,
+          });
+
+          failCount++;
+          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);
+        }
+      }
+
+      const description =
+        `Processed ${allPostData.length} post(s): ${successCount} succeeded, ${failCount} failed`;
+
+      console.log(`[syndication] ${description}`);
+
+      return response.json({
+        success: "OK",
+        success_description: description,
+        results,
+      });
+    } catch (error) {
+      next(error);
+    }
+  },
+};

package/lib/token.js

@@ -0,0 +1,56 @@
+import process from "node:process";
+
+import { IndiekitError } from "@indiekit/error";
+import jwt from "jsonwebtoken";
+
+export const findBearerToken = (request) => {
+  if (request.headers?.["x-webhook-signature"] && request.body?.url) {
+    const signature = request.headers["x-webhook-signature"];
+    const verifiedToken = verifyToken(signature);
+    const bearerToken = signToken(verifiedToken, request.body.url);
+    return bearerToken;
+  }
+
+  if (request.body?.access_token) {
+    const bearerToken = request.body.access_token;
+    delete request.body.access_token;
+    return bearerToken;
+  }
+
+  if (request.query?.token) {
+    const bearerToken = request.query.token;
+    return bearerToken;
+  }
+
+  throw IndiekitError.invalidRequest("No bearer token provided by request");
+};
+
+/**
+ * Generate short-lived bearer token with update scope
+ * @param {object} verifiedToken - JSON Web Token
+ * @param {string} url - Publication URL
+ * @returns {string} Signed JSON Web Token
+ */
+export const signToken = (verifiedToken, url) =>
+  jwt.sign(
+    {
+      me: url,
+      scope: "update",
+    },
+    process.env.SECRET,
+    {
+      expiresIn: "10m",
+    },
+  );
+
+/**
+ * Verify that token provided by signature was issued by Netlify
+ * @param {string} signature - JSON Web Signature
+ * @returns {object} JSON Web Token
+ * @see {@link https://docs.netlify.com/site-deploys/notifications/#payload-signature}
+ */
+export const verifyToken = (signature) =>
+  jwt.verify(signature, process.env.WEBHOOK_SECRET, {
+    algorithms: ["HS256"],
+    issuer: ["netlify"],
+  });

package/lib/utils.js

@@ -0,0 +1,138 @@
+/**
+ * Get post data for a single post
+ * @param {object} postsCollection - Posts database collection
+ * @param {string} url - URL of existing post (optional)
+ * @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({
+      "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;
+};
+
+/**
+ * Get ALL posts awaiting syndication (batch mode)
+ * @param {object} postsCollection - Posts database collection
+ * @returns {Promise<Array>} Array of post data objects
+ */
+export const getAllPostData = async (postsCollection) => {
+  const items = await postsCollection
+    .find({
+      "properties.mp-syndicate-to": {
+        $exists: true,
+      },
+      // No syndication filter — let syndicateToTargets() handle dedup
+      "properties.post-status": {
+        $ne: "draft",
+      },
+    })
+    // eslint-disable-next-line unicorn/no-array-sort
+    .sort({ "properties.published": -1 })
+    .toArray();
+
+  return items;
+};
+
+/**
+ * Check if target already returned a syndication URL
+ * @param {Array} syndicatedUrls - Syndication URLs
+ * @param {string} syndicateTo - Syndication target
+ * @returns {boolean} Target returned a syndication URL
+ */
+export const hasSyndicationUrl = (syndicatedUrls, syndicateTo) => {
+  return syndicatedUrls.some((url) => {
+    const { origin } = new URL(url);
+    return syndicateTo.includes(origin);
+  });
+};
+
+/**
+ * Get syndication target for syndication URL
+ * @param {Array} syndicationTargets - Publication syndication targets
+ * @param {string} syndicateTo - Syndication URL
+ * @returns {object|undefined} Publication syndication target
+ */
+export const getSyndicationTarget = (syndicationTargets, syndicateTo) => {
+  return syndicationTargets.find((target) => {
+    if (!target?.info?.uid) {
+      return;
+    }
+
+    const targetOrigin = new URL(target.info.uid).origin;
+    const syndicateToOrigin = new URL(syndicateTo).origin;
+    return targetOrigin === syndicateToOrigin;
+  });
+};
+
+/**
+ * Syndicate URLs to configured syndication targets
+ * @param {object} publication - Publication configuration
+ * @param {object} properties - JF2 properties
+ * @returns {Promise<object>} Syndication target
+ */
+export const syndicateToTargets = async (publication, properties) => {
+  const { syndicationTargets } = publication;
+  const syndicateTo = properties["mp-syndicate-to"];
+  // BUG FIX: Was `Array.isArray` (always truthy, it's a function reference)
+  // Now correctly passes syndicateTo as the argument
+  const syndicateToUrls = Array.isArray(syndicateTo)
+    ? syndicateTo
+    : [syndicateTo];
+  const syndicatedUrls = properties.syndication || [];
+  const failedTargets = [];
+
+  for (const url of syndicateToUrls) {
+    const target = getSyndicationTarget(syndicationTargets, url);
+    const alreadySyndicated = hasSyndicationUrl(syndicatedUrls, url);
+
+    if (target && !alreadySyndicated) {
+      try {
+        const syndicatedUrl = await target.syndicate(properties, publication);
+
+        if (syndicatedUrl) {
+          // Add syndicated URL to list of syndicated URLs
+          syndicatedUrls.push(syndicatedUrl);
+        } else {
+          // Add failed syndication target to list of failed targets
+          failedTargets.push(target.info.uid);
+        }
+      } catch (error) {
+        // Add failed syndication target to list of failed targets
+        failedTargets.push(target.info.uid);
+        console.error(error.message);
+      }
+    }
+  }
+
+  return {
+    ...(failedTargets.length > 0 && { failedTargets }),
+    syndicatedUrls,
+  };
+};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@rmdes/indiekit-endpoint-syndicate",
+  "version": "1.0.0-beta.27",
+  "description": "Syndication endpoint for Indiekit. Fork of @indiekit/endpoint-syndicate with batch syndication support and bug fixes.",
+  "keywords": [
+    "indiekit",
+    "indiekit-plugin",
+    "indieweb",
+    "syndication"
+  ],
+  "homepage": "https://github.com/rmdes/indiekit-endpoint-syndicate",
+  "author": {
+    "name": "Ricardo Mendes",
+    "url": "https://rmendes.net"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
+  "type": "module",
+  "main": "index.js",
+  "files": [
+    "lib",
+    "index.js"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rmdes/indiekit-endpoint-syndicate.git"
+  },
+  "dependencies": {
+    "@indiekit/error": "^1.0.0-beta.25",
+    "express": "^5.0.0",
+    "jsonwebtoken": "^9.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}