@kidecms/core 0.1.0

package/routes/api/cms/locks/[...path].ts

@@ -0,0 +1,37 @@
+import type { APIRoute } from "astro";
+
+import { acquireLock, releaseLock } from "virtual:kide/runtime";
+
+export const prerender = false;
+
+const getSegments = (path: string | undefined) => (path ?? "").split("/").filter(Boolean);
+
+// POST /api/cms/locks/:collection/:documentId — acquire/heartbeat or release (via ?_method=DELETE for sendBeacon)
+export const POST: APIRoute = async ({ params, locals, url }) => {
+  const [collection, documentId] = getSegments(params.path);
+  const user = locals.user;
+
+  if (!collection || !documentId || !user) {
+    return Response.json({ error: "Missing parameters" }, { status: 400 });
+  }
+
+  if (url.searchParams.get("_method") === "DELETE") {
+    await releaseLock(collection, documentId, user.id);
+    return new Response(null, { status: 204 });
+  }
+
+  return Response.json(await acquireLock(collection, documentId, user.id, user.email));
+};
+
+// DELETE /api/cms/locks/:collection/:documentId — release lock
+export const DELETE: APIRoute = async ({ params, locals }) => {
+  const [collection, documentId] = getSegments(params.path);
+  const user = locals.user;
+
+  if (!collection || !documentId || !user) {
+    return new Response(null, { status: 400 });
+  }
+
+  await releaseLock(collection, documentId, user.id);
+  return new Response(null, { status: 204 });
+};

package/routes/api/cms/preview/render.ts

@@ -0,0 +1,36 @@
+import type { APIRoute } from "astro";
+import { experimental_AstroContainer as AstroContainer } from "astro/container";
+import { loadRenderers } from "astro:container";
+import { getContainerRenderer } from "@astrojs/react";
+
+import BlockRenderer from "virtual:kide/block-renderer";
+import { renderRichText, parseBlocks } from "@kidecms/core";
+
+export const prerender = false;
+
+let containerPromise: Promise<AstroContainer> | null = null;
+const getContainer = () => {
+  if (!containerPromise) {
+    containerPromise = (async () => {
+      const renderers = await loadRenderers([getContainerRenderer()]);
+      return AstroContainer.create({ renderers });
+    })();
+  }
+  return containerPromise;
+};
+
+export const POST: APIRoute = async ({ request }) => {
+  const { type, data } = await request.json();
+
+  let html = "";
+  if (type === "blocks") {
+    const blocks = parseBlocks(data);
+    const container = await getContainer();
+    html = await container.renderToString(BlockRenderer, { props: { blocks } });
+  } else if (type === "richText") {
+    const parsed = typeof data === "string" ? JSON.parse(data) : data;
+    html = renderRichText(parsed) ?? "";
+  }
+
+  return new Response(html, { headers: { "Content-Type": "text/html" } });
+};

package/routes/api/cms/references/[collection]/[id].ts

@@ -0,0 +1,60 @@
+import type { APIRoute } from "astro";
+import config from "virtual:kide/config";
+import { cms } from "virtual:kide/api";
+import { getLabelField } from "@kidecms/core";
+
+export const prerender = false;
+
+const cmsRuntime = cms as Record<string, any>;
+
+export const GET: APIRoute = async ({ params }) => {
+  const { collection: collectionSlug, id: documentId } = params;
+  if (!collectionSlug || !documentId) {
+    return Response.json({ refs: [] });
+  }
+
+  const collection = config.collections.find((c) => c.slug === collectionSlug);
+  if (!collection) return Response.json({ refs: [] });
+
+  const refs: Array<{ collection: string; label: string; count: number }> = [];
+
+  for (const otherCollection of config.collections) {
+    if (otherCollection.slug === collectionSlug) continue;
+    const relationFields = Object.entries(otherCollection.fields).filter(
+      ([, f]) => f.type === "relation" && (f as any).collection === collectionSlug,
+    );
+    if (relationFields.length === 0) continue;
+
+    const otherApi = cmsRuntime[otherCollection.slug];
+    if (!otherApi) continue;
+
+    for (const [fieldName, field] of relationFields) {
+      try {
+        const isMany = (field as any).hasMany;
+        let count = 0;
+
+        if (isMany) {
+          const allDocs = await otherApi.find({ status: "any", limit: 200 });
+          count = allDocs.filter((r: Record<string, unknown>) => {
+            const val = r[fieldName];
+            if (Array.isArray(val)) return val.includes(documentId);
+            if (typeof val === "string") return val.includes(documentId);
+            return false;
+          }).length;
+        } else {
+          count = await otherApi.count({ status: "any", where: { [fieldName]: documentId } });
+        }
+
+        if (count > 0) {
+          refs.push({
+            collection: otherCollection.labels.plural,
+            label: getLabelField(otherCollection),
+            count,
+          });
+        }
+      } catch {}
+    }
+  }
+
+  return Response.json({ refs, total: refs.reduce((sum, r) => sum + r.count, 0) });
+};