@kidecms/core 0.1.4 → 0.1.6

package/admin/components/DocumentActions.tsx

@@ -149,11 +149,19 @@ export default function DocumentActions({
     const form = document.createElement("form");
     form.method = "post";
     form.action = restoreEndpoint;
-    form.innerHTML = `
-      <input type="hidden" name="_action" value="restore" />
-      <input type="hidden" name="version" value="${version}" />
-      <input type="hidden" name="redirectTo" value="${redirectTo ?? window.location.pathname + window.location.search}" />
-    `;
+
+    const addInput = (name: string, value: string) => {
+      const input = document.createElement("input");
+      input.type = "hidden";
+      input.name = name;
+      input.value = value;
+      form.appendChild(input);
+    };
+
+    addInput("_action", "restore");
+    addInput("version", String(version));
+    addInput("redirectTo", redirectTo ?? window.location.pathname + window.location.search);
+
     document.body.appendChild(form);
     form.submit();
   };

package/dist/api.js

@@ -5,6 +5,7 @@ import { getCollectionMap, getTranslatableFieldNames, isStructuralField } from "
 import { getDb } from "./runtime";
 import { getSchema } from "./schema";
 import { cloneValue, createRichTextFromPlainText, slugify } from "./values";
+import { dispatchWebhooks } from "./webhooks";
 const now = () => new Date().toISOString();
 const pick = (input, keys) => Object.fromEntries(keys.filter((key) => key in input).map((key) => [key, input[key]]));
 const isJsonField = (field) => field.type === "richText" ||
@@ -405,6 +406,7 @@ export const createCms = (config) => {
                 }
                 const result = await this.findById(docId, {}, context);
                 await collection.hooks?.afterCreate?.(result, hookContext);
+                dispatchWebhooks(config, "create", slug, result, context.user);
                 return result;
             },
             async update(id, data, context = {}) {
@@ -479,6 +481,7 @@ export const createCms = (config) => {
                 }
                 const result = await this.findById(id, { status: "any" }, context);
                 await collection.hooks?.afterUpdate?.(result, hookContext);
+                dispatchWebhooks(config, "update", slug, result, context.user);
                 return result;
             },
             async delete(id, context = {}) {
@@ -499,6 +502,7 @@ export const createCms = (config) => {
                     await db.delete(tables.versions).where(eq(tables.versions._docId, id));
                 await db.delete(tables.main).where(eq(tables.main._id, id));
                 await collection.hooks?.afterDelete?.(existing, hookContext);
+                dispatchWebhooks(config, "delete", slug, existing, context.user);
             },
             async publish(id, context = {}) {
                 if (!collection.drafts)
@@ -529,6 +533,7 @@ export const createCms = (config) => {
                 await db.update(tables.main).set(updateValues).where(eq(tables.main._id, id));
                 const result = await this.findById(id, { status: "any" }, context);
                 await collection.hooks?.afterPublish?.(result, hookContext);
+                dispatchWebhooks(config, "publish", slug, result, context.user);
                 return result;
             },
             async unpublish(id, context = {}) {
@@ -559,6 +564,7 @@ export const createCms = (config) => {
                 await db.update(tables.main).set(updateValues).where(eq(tables.main._id, id));
                 const result = (await this.findById(id, { status: "any" }, context));
                 await collection.hooks?.afterUnpublish?.(result, hookContext);
+                dispatchWebhooks(config, "unpublish", slug, result, context.user);
                 return result;
             },
             async schedule(id, publishAt, unpublishAt, context = {}) {

package/dist/integration.js

@@ -175,7 +175,11 @@ export default function cmsIntegration(options) {
                     pattern: "/api/cms/locks/[...path]",
                     entrypoint: "@kidecms/core/routes/api/cms/locks/[...path].ts",
                 });
-                injectRoute({ pattern: "/api/cms/preview/render", entrypoint: "@kidecms/core/routes/api/cms/preview/render.ts" });
+                // Preview render route uses Astro Container API which depends on Vite internals.
+                // Only inject in dev mode — production builds (especially Cloudflare Workers) can't bundle it.
+                if (command === "dev") {
+                    injectRoute({ pattern: "/api/cms/preview/render", entrypoint: "@kidecms/core/routes/api/cms/preview/render.ts" });
+                }
                 injectRoute({
                     pattern: "/api/cms/references/[collection]/[id]",
                     entrypoint: "@kidecms/core/routes/api/cms/references/[collection]/[id].ts",

package/dist/webhooks.js

@@ -0,0 +1,71 @@
+const MAX_RETRIES = 3;
+const TIMEOUT_MS = 5000;
+const RETRY_DELAYS = [1000, 3000, 9000];
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function deliverOnce(webhook, body) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), TIMEOUT_MS);
+    try {
+        const response = await fetch(webhook.url, {
+            method: webhook.method ?? "POST",
+            headers: { "Content-Type": "application/json", ...webhook.headers },
+            body,
+            signal: controller.signal,
+        });
+        return { ok: response.ok, status: response.status };
+    }
+    catch (err) {
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function deliverWebhook(webhook, body) {
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+        const result = await deliverOnce(webhook, body);
+        if (result.ok) {
+            if (attempt > 0) {
+                console.log(`  [webhook] ${webhook.name} delivered after ${attempt + 1} attempts`);
+            }
+            return;
+        }
+        const detail = result.status ? `HTTP ${result.status}` : result.error;
+        if (attempt < MAX_RETRIES) {
+            console.warn(`  [webhook] ${webhook.name} failed (${detail}) — retrying in ${RETRY_DELAYS[attempt]}ms`);
+            await sleep(RETRY_DELAYS[attempt]);
+        }
+        else {
+            console.error(`  [webhook] ${webhook.name} failed permanently after ${MAX_RETRIES + 1} attempts: ${detail}`);
+        }
+    }
+}
+export async function dispatchWebhooks(config, event, collectionSlug, doc, user) {
+    const webhooks = config.admin?.webhooks;
+    if (!webhooks || webhooks.length === 0)
+        return;
+    const matching = webhooks.filter((webhook) => {
+        if (!webhook.events.includes(event))
+            return false;
+        if (webhook.collections && !webhook.collections.includes(collectionSlug))
+            return false;
+        return true;
+    });
+    if (matching.length === 0)
+        return;
+    const context = {
+        user: user ?? null,
+        event,
+        collection: collectionSlug,
+        timestamp: new Date().toISOString(),
+    };
+    // Fire all matching webhooks in parallel — don't block the operation
+    for (const webhook of matching) {
+        const payload = webhook.payload ? webhook.payload(doc, context) : { event, collection: collectionSlug, doc, user, timestamp: context.timestamp };
+        const body = JSON.stringify(payload);
+        // Fire and forget — failures are logged but don't bubble up
+        deliverWebhook(webhook, body).catch((err) => {
+            console.error(`  [webhook] ${webhook.name} dispatcher error:`, err);
+        });
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kidecms/core",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Code-first CMS framework built for Astro.",
   "author": "Matti Hernesniemi",
   "license": "MIT",