strapi-bulk-publish 1.0.0

package/dist/server/index.js

@@ -0,0 +1,432 @@
+"use strict";
+const register = (_args) => {
+};
+const bootstrap = async ({ strapi }) => {
+  strapi.log.debug("Bulk Publish plugin bootstrapped");
+  await strapi.service("admin::permission").actionProvider.registerMany([
+    {
+      section: "plugins",
+      displayName: "Publish",
+      uid: "publish",
+      pluginName: "bulk-publish"
+    },
+    {
+      section: "plugins",
+      displayName: "Settings",
+      uid: "settings",
+      pluginName: "bulk-publish"
+    }
+  ]);
+  const store = strapi.store({ type: "plugin", name: "bulk-publish" });
+  const existingUrl = await store.get({ key: "webhookUrl" });
+  if (existingUrl === null || existingUrl === void 0) {
+    const configUrl = strapi.plugin("bulk-publish").config("webhookUrl") || "";
+    await store.set({ key: "webhookUrl", value: configUrl });
+  }
+};
+const config = {
+  default: {
+    contentType: "",
+    titleField: "title",
+    webhookUrl: ""
+  },
+  validator: (config2) => {
+    if (!config2.contentType || typeof config2.contentType !== "string") {
+      throw new Error(
+        'bulk-publish: contentType is required (e.g. "api::blog-post.blog-post")'
+      );
+    }
+    if (config2.titleField && typeof config2.titleField !== "string") {
+      throw new Error("bulk-publish: titleField must be a string");
+    }
+    if (config2.webhookUrl && typeof config2.webhookUrl !== "string") {
+      throw new Error("bulk-publish: webhookUrl must be a string");
+    }
+  }
+};
+const admin = {
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/posts",
+      handler: "bulk-publish.getPosts",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
+            config: { actions: ["plugin::bulk-publish.publish"] }
+          }
+        ],
+        description: "List blog posts with unpublished locales"
+      }
+    },
+    {
+      method: "POST",
+      path: "/publish",
+      handler: "bulk-publish.publish",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
+            config: { actions: ["plugin::bulk-publish.publish"] }
+          }
+        ],
+        description: "Publish selected posts across all locales"
+      }
+    },
+    {
+      method: "GET",
+      path: "/settings",
+      handler: "bulk-publish.getSettings",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
+            config: { actions: ["plugin::bulk-publish.settings"] }
+          }
+        ],
+        description: "Get webhook settings"
+      }
+    },
+    {
+      method: "PUT",
+      path: "/settings",
+      handler: "bulk-publish.updateSettings",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
+            config: { actions: ["plugin::bulk-publish.settings"] }
+          }
+        ],
+        description: "Update webhook settings"
+      }
+    }
+  ]
+};
+const routes = {
+  admin
+};
+const WEBHOOK_TIMEOUT_MS = 1e4;
+const MAX_LOG_BODY_LENGTH = 500;
+const BLOCKED_HOSTNAMES = /* @__PURE__ */ new Set([
+  "localhost",
+  "127.0.0.1",
+  "::1",
+  "0.0.0.0",
+  "169.254.169.254"
+]);
+function isPrivateIP(hostname) {
+  const normalized = hostname.replace(/^\[|\]$/g, "");
+  if (BLOCKED_HOSTNAMES.has(normalized)) return true;
+  if (normalized.endsWith(".local") || normalized.endsWith(".internal")) return true;
+  const parts = hostname.split(".").map(Number);
+  if (parts.length !== 4 || parts.some(isNaN)) return false;
+  if (parts[0] === 10) return true;
+  if (parts[0] === 172 && parts[1] >= 16 && parts[1] <= 31) return true;
+  if (parts[0] === 192 && parts[1] === 168) return true;
+  if (parts[0] === 169 && parts[1] === 254) return true;
+  if (parts[0] === 127) return true;
+  return false;
+}
+function isAllowedWebhookUrl(urlStr) {
+  if (!urlStr) return true;
+  try {
+    const url = new URL(urlStr);
+    if (url.protocol !== "https:" && url.protocol !== "http:") return false;
+    return !isPrivateIP(url.hostname.toLowerCase());
+  } catch {
+    return false;
+  }
+}
+const webhook = ({ strapi }) => {
+  const getStore = () => strapi.store({ type: "plugin", name: "bulk-publish" });
+  return {
+    async getWebhookUrl() {
+      const url = await getStore().get({ key: "webhookUrl" });
+      return url || "";
+    },
+    async setWebhookUrl(url) {
+      await getStore().set({ key: "webhookUrl", value: url });
+    },
+    async trigger(documentIds) {
+      const webhookUrl = await this.getWebhookUrl();
+      if (!webhookUrl) {
+        return { triggered: false, error: "No webhook URL configured" };
+      }
+      if (!isAllowedWebhookUrl(webhookUrl)) {
+        strapi.log.warn("bulk-publish: webhook URL blocked by SSRF protection");
+        return { triggered: false, error: "Webhook URL is not allowed" };
+      }
+      try {
+        const response = await fetch(webhookUrl, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            event: "bulk-publish",
+            posts: documentIds,
+            publishedAt: (/* @__PURE__ */ new Date()).toISOString()
+          }),
+          signal: AbortSignal.timeout(WEBHOOK_TIMEOUT_MS)
+        });
+        if (!response.ok) {
+          const text = await response.text();
+          const truncated = text.length > MAX_LOG_BODY_LENGTH ? text.slice(0, MAX_LOG_BODY_LENGTH) + "..." : text;
+          strapi.log.warn(`bulk-publish webhook returned ${response.status}: ${truncated}`);
+          return { triggered: true, error: `Webhook returned ${response.status}` };
+        }
+        return { triggered: true };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Webhook call failed";
+        strapi.log.error(`bulk-publish: webhook call failed: ${message}`);
+        return { triggered: false, error: message };
+      }
+    }
+  };
+};
+const MAX_BATCH_SIZE = 100;
+const bulkPublish = ({ strapi }) => {
+  const publishService = () => strapi.plugin("bulk-publish").service("publish");
+  const webhookService = () => strapi.plugin("bulk-publish").service("webhook");
+  return {
+    async getPosts(ctx) {
+      const posts = await publishService().getDraftPosts();
+      ctx.body = { data: posts };
+    },
+    async publish(ctx) {
+      const { documentIds } = ctx.request.body;
+      if (!Array.isArray(documentIds) || documentIds.length === 0) {
+        return ctx.badRequest("documentIds must be a non-empty array");
+      }
+      if (documentIds.length > MAX_BATCH_SIZE) {
+        return ctx.badRequest(`Cannot publish more than ${MAX_BATCH_SIZE} documents at once`);
+      }
+      if (!documentIds.every((id) => typeof id === "string" && id.length > 0)) {
+        return ctx.badRequest("Each documentId must be a non-empty string");
+      }
+      const { published, errors } = await publishService().publishMany(documentIds);
+      let webhookResult = { triggered: false, error: "No posts published" };
+      if (published.length > 0) {
+        webhookResult = await webhookService().trigger(
+          published.map((p) => p.documentId)
+        );
+      }
+      ctx.body = {
+        data: {
+          published,
+          errors,
+          webhookTriggered: webhookResult.triggered,
+          webhookError: webhookResult.error || null
+        }
+      };
+    },
+    async getSettings(ctx) {
+      const webhookUrl = await webhookService().getWebhookUrl();
+      ctx.body = { data: { webhookUrl } };
+    },
+    async updateSettings(ctx) {
+      const { webhookUrl } = ctx.request.body;
+      if (typeof webhookUrl !== "string") {
+        return ctx.badRequest("webhookUrl must be a string");
+      }
+      if (webhookUrl && !isAllowedWebhookUrl(webhookUrl)) {
+        return ctx.badRequest("webhookUrl must be a valid public HTTP(S) URL");
+      }
+      await webhookService().setWebhookUrl(webhookUrl);
+      ctx.body = { data: { webhookUrl } };
+    }
+  };
+};
+const controllers = {
+  "bulk-publish": bulkPublish
+};
+const publish = ({ strapi }) => {
+  const getContentType = () => strapi.plugin("bulk-publish").config("contentType");
+  const getTitleField = () => strapi.plugin("bulk-publish").config("titleField") || "title";
+  return {
+    async getAvailableLocales() {
+      const localeService = strapi.plugin("i18n")?.service("locales");
+      if (!localeService) {
+        return ["en"];
+      }
+      const locales = await localeService.find();
+      return locales.map((l) => l.code);
+    },
+    async getDefaultLocale() {
+      const localeService = strapi.plugin("i18n")?.service("locales");
+      if (!localeService) {
+        return "en";
+      }
+      const defaultLocale = await localeService.getDefaultLocale();
+      return defaultLocale || "en";
+    },
+    async getDraftPosts() {
+      const allLocales = await this.getAvailableLocales();
+      const defaultLocale = await this.getDefaultLocale();
+      const contentType = getContentType();
+      const titleField = getTitleField();
+      const draftsByLocale = /* @__PURE__ */ new Map();
+      const publishedByLocale = /* @__PURE__ */ new Map();
+      await Promise.all(
+        allLocales.map(async (locale) => {
+          const [drafts, published] = await Promise.all([
+            strapi.documents(contentType).findMany({
+              locale,
+              status: "draft",
+              fields: [titleField, "updatedAt"],
+              limit: 1e3
+            }),
+            strapi.documents(contentType).findMany({
+              locale,
+              status: "published",
+              fields: ["updatedAt"],
+              limit: 1e3
+            })
+          ]);
+          const localeMap = /* @__PURE__ */ new Map();
+          for (const doc of drafts) {
+            localeMap.set(doc.documentId, {
+              title: String(doc[titleField] ?? ""),
+              updatedAt: doc.updatedAt
+            });
+          }
+          draftsByLocale.set(locale, localeMap);
+          const pubMap = /* @__PURE__ */ new Map();
+          for (const doc of published) {
+            pubMap.set(doc.documentId, { updatedAt: doc.updatedAt });
+          }
+          publishedByLocale.set(locale, pubMap);
+        })
+      );
+      const allDocIds = /* @__PURE__ */ new Set();
+      for (const localeMap of draftsByLocale.values()) {
+        for (const docId of localeMap.keys()) {
+          allDocIds.add(docId);
+        }
+      }
+      const posts = [];
+      for (const docId of allDocIds) {
+        let hasUnpublishedLocale = false;
+        let latestUpdatedAt = 0;
+        let primaryTitle = "";
+        const locales = [];
+        for (const locale of allLocales) {
+          const draft = draftsByLocale.get(locale)?.get(docId);
+          const pub = publishedByLocale.get(locale)?.get(docId);
+          if (!draft) {
+            locales.push({ locale, status: "missing" });
+            continue;
+          }
+          if (locale === defaultLocale) {
+            primaryTitle = draft.title;
+          }
+          const draftTime = new Date(draft.updatedAt).getTime();
+          if (draftTime > latestUpdatedAt) {
+            latestUpdatedAt = draftTime;
+          }
+          const needsPublishing = !pub || new Date(draft.updatedAt) > new Date(pub.updatedAt);
+          if (needsPublishing) {
+            hasUnpublishedLocale = true;
+            locales.push({ locale, status: "draft" });
+          } else {
+            locales.push({ locale, status: "published" });
+          }
+        }
+        if (!hasUnpublishedLocale) continue;
+        posts.push({
+          documentId: docId,
+          title: primaryTitle || "(untitled)",
+          updatedAt: new Date(latestUpdatedAt).toISOString(),
+          locales
+        });
+      }
+      posts.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+      return posts;
+    },
+    async publishDocument(documentId, locales) {
+      const allLocales = locales ?? await this.getAvailableLocales();
+      const defaultLocale = await this.getDefaultLocale();
+      const contentType = getContentType();
+      const titleField = getTitleField();
+      const localesPublished = [];
+      const localeErrors = [];
+      let title = "";
+      for (const locale of allLocales) {
+        try {
+          const draft = await strapi.documents(contentType).findOne({
+            documentId,
+            locale,
+            status: "draft",
+            fields: [titleField, "updatedAt"]
+          });
+          if (!draft) continue;
+          const draftDoc = draft;
+          if (locale === defaultLocale && draftDoc[titleField]) {
+            title = String(draftDoc[titleField]);
+          }
+          const published = await strapi.documents(contentType).findOne({
+            documentId,
+            locale,
+            status: "published",
+            fields: ["updatedAt"]
+          });
+          if (published && new Date(draftDoc.updatedAt) <= new Date(published.updatedAt)) {
+            continue;
+          }
+          await strapi.documents(contentType).publish({
+            documentId,
+            locale
+          });
+          localesPublished.push(locale);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Unknown error";
+          strapi.log.error(
+            `bulk-publish: failed to publish ${documentId} locale ${locale}: ${message}`
+          );
+          localeErrors.push({ locale, error: message });
+        }
+      }
+      if (!title) {
+        title = `Document ${documentId}`;
+      }
+      return { documentId, title, localesPublished, localeErrors };
+    },
+    async publishMany(documentIds) {
+      const allLocales = await this.getAvailableLocales();
+      const published = [];
+      const errors = [];
+      for (const documentId of documentIds) {
+        try {
+          const result = await this.publishDocument(documentId, allLocales);
+          if (result.localesPublished.length > 0) {
+            published.push(result);
+          } else {
+            errors.push({ documentId, error: "No draft locales found to publish" });
+          }
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Unknown error";
+          errors.push({ documentId, error: message });
+        }
+      }
+      return { published, errors };
+    }
+  };
+};
+const services = {
+  publish,
+  webhook
+};
+const index = {
+  register,
+  bootstrap,
+  config,
+  routes,
+  controllers,
+  services
+};
+module.exports = index;