@kidecms/core 0.1.0

package/package.json

@@ -0,0 +1,102 @@
+{
+  "name": "@kidecms/core",
+  "version": "0.1.0",
+  "description": "Code-first CMS framework built for Astro.",
+  "author": "Matti Hernesniemi",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./integration": {
+      "import": "./dist/integration.js"
+    },
+    "./admin/*": "./admin/*",
+    "./routes/*": "./routes/*",
+    "./middleware/*": "./middleware/*"
+  },
+  "files": [
+    "dist",
+    "admin",
+    "routes",
+    "middleware",
+    "virtual.d.ts"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  },
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "dependencies": {
+    "@base-ui/react": "^1.3.0",
+    "@dnd-kit/core": "^6.3.1",
+    "@dnd-kit/sortable": "^10.0.0",
+    "@dnd-kit/utilities": "^3.2.2",
+    "@radix-ui/react-dropdown-menu": "^2.1.16",
+    "@radix-ui/react-popover": "^1.1.15",
+    "@tanstack/react-table": "^8.21.3",
+    "@tiptap/core": "^3.22.3",
+    "@tiptap/extension-image": "^3.22.3",
+    "@tiptap/extension-link": "^3.22.3",
+    "@tiptap/markdown": "^3.22.3",
+    "@tiptap/pm": "^3.22.3",
+    "@tiptap/react": "^3.22.3",
+    "@tiptap/starter-kit": "^3.22.3",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "cmdk": "^1.1.1",
+    "drizzle-orm": "^0.45.0",
+    "lucide-react": "^0.577.0",
+    "nanoid": "^5.1.6",
+    "tailwind-merge": "^3.5.0",
+    "tw-animate-css": "^1.4.0",
+    "zod": "^4.3.6"
+  },
+  "peerDependencies": {
+    "@ai-sdk/openai": "^3.0.0",
+    "@astrojs/react": "^5.0.0",
+    "ai": "^6.0.0",
+    "astro": "^6.0.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "sharp": "^0.34.0",
+    "tailwindcss": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@ai-sdk/openai": {
+      "optional": true
+    },
+    "@astrojs/react": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    },
+    "sharp": {
+      "optional": true
+    },
+    "ai": {
+      "optional": true
+    },
+    "astro": {
+      "optional": true
+    },
+    "tailwindcss": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "typescript": "^5.9.3"
+  }
+}

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

@@ -0,0 +1,366 @@
+import type { APIRoute } from "astro";
+
+import config from "virtual:kide/config";
+import { cms } from "virtual:kide/api";
+
+export const prerender = false;
+
+const cmsRuntime = cms as Record<string, any> & { meta: typeof cms.meta };
+
+const getSegments = (path: string | undefined) => (path ?? "").split("/").filter(Boolean);
+
+const isFormRequest = (request: Request) => {
+  const contentType = request.headers.get("content-type") ?? "";
+  return contentType.includes("application/x-www-form-urlencoded") || contentType.includes("multipart/form-data");
+};
+
+// Append _toast and _msg params so the layout can render a server-side toast
+const redirect = (location: string, toast?: { status: "success" | "error"; msg: string }) => {
+  let target = location;
+  if (toast) {
+    const sep = target.includes("?") ? "&" : "?";
+    target += `${sep}_toast=${toast.status}&_msg=${encodeURIComponent(toast.msg)}`;
+  }
+  return new Response(null, { status: 303, headers: { Location: target } });
+};
+
+const stripToastParams = (url: string) => {
+  const [path, query] = url.split("?");
+  if (!query) return url;
+  const params = new URLSearchParams(query);
+  params.delete("_toast");
+  params.delete("_msg");
+  return params.size ? `${path}?${params}` : path;
+};
+
+const parseJsonQuery = (value: string | null) => {
+  if (!value) {
+    return undefined;
+  }
+
+  try {
+    return JSON.parse(value);
+  } catch {
+    return undefined;
+  }
+};
+
+const getCollection = (slug: string) => {
+  const collection = config.collections.find((entry) => entry.slug === slug);
+  if (!collection) {
+    throw new Error(`Unknown collection "${slug}".`);
+  }
+
+  return collection;
+};
+
+const extractDataFromForm = async (request: Request) => {
+  const formData = await request.formData();
+  const entries = [...formData.entries()];
+
+  return {
+    action: String(formData.get("_action") ?? "create"),
+    intent: String(formData.get("_intent") ?? "save"),
+    // Strip stale toast params from redirectTo (they persist in the hidden input
+    // because the server renders the form before the client-side URL cleanup runs)
+    redirectTo: stripToastParams(String(formData.get("redirectTo") ?? "/admin")),
+    locale: formData.get("locale") ? String(formData.get("locale")) : undefined,
+    version: formData.get("version") ? Number(formData.get("version")) : undefined,
+    data: Object.fromEntries(
+      entries.filter(
+        ([key]) =>
+          (!key.startsWith("_") || key === "_publishAt" || key === "_unpublishAt") &&
+          key !== "redirectTo" &&
+          key !== "locale" &&
+          key !== "version",
+      ),
+    ),
+  };
+};
+
+const handleHtmlMutation = async (
+  collectionSlug: string,
+  documentId: string | undefined,
+  request: Request,
+  locals: App.Locals,
+  cache?: { invalidate: (opts: { tags: string[] }) => void | Promise<void> },
+) => {
+  const { action, data, intent, redirectTo, locale, version } = await extractDataFromForm(request);
+  const collectionApi = cmsRuntime[collectionSlug];
+  const collection = getCollection(collectionSlug);
+  const ctx = getRuntimeContext(locals, cache);
+
+  const name = collection.labels.singular;
+
+  try {
+    if (action === "create") {
+      const created = await collectionApi.create(data, ctx);
+      if (collection.drafts && intent === "publish") {
+        await collectionApi.publish(created._id, ctx);
+      } else if (collection.drafts && intent === "schedule" && data._publishAt) {
+        await collectionApi.schedule(
+          created._id,
+          String(data._publishAt),
+          data._unpublishAt ? String(data._unpublishAt) : null,
+          ctx,
+        );
+      }
+      const msg =
+        intent === "publish"
+          ? `${name} created and published`
+          : intent === "schedule"
+            ? `${name} scheduled`
+            : `${name} created`;
+      return redirect(`/admin/${collectionSlug}/${created._id}`, { status: "success", msg });
+    }
+
+    if (!documentId) {
+      throw new Error("A document id is required for this action.");
+    }
+
+    if (action === "update") {
+      await collectionApi.update(documentId, data, ctx);
+      if (collection.drafts && intent === "publish") {
+        await collectionApi.publish(documentId, ctx);
+      } else if (collection.drafts && intent === "unpublish") {
+        await collectionApi.unpublish(documentId, ctx);
+      } else if (collection.drafts && intent === "schedule" && data._publishAt) {
+        await collectionApi.schedule(
+          documentId,
+          String(data._publishAt),
+          data._unpublishAt ? String(data._unpublishAt) : null,
+          ctx,
+        );
+      }
+      const msg =
+        intent === "publish"
+          ? `${name} published`
+          : intent === "unpublish"
+            ? `${name} unpublished`
+            : intent === "schedule"
+              ? `${name} scheduled`
+              : collection.drafts
+                ? `${name} saved as draft`
+                : `${name} saved`;
+      return redirect(redirectTo, { status: "success", msg });
+    }
+
+    if (action === "delete") {
+      await collectionApi.delete(documentId, ctx);
+      return redirect(`/admin/${collectionSlug}`, { status: "success", msg: `${name} deleted` });
+    }
+
+    if (action === "publish") {
+      await collectionApi.publish(documentId, ctx);
+      return redirect(redirectTo, { status: "success", msg: `${name} published` });
+    }
+
+    if (action === "unpublish") {
+      await collectionApi.unpublish(documentId, ctx);
+      return redirect(redirectTo, { status: "success", msg: `${name} unpublished` });
+    }
+
+    if (action === "discard-draft") {
+      await collectionApi.discardDraft(documentId, ctx);
+      return redirect(redirectTo, { status: "success", msg: `Changes discarded` });
+    }
+
+    if (action === "restore" && version) {
+      await collectionApi.restore(documentId, version, ctx);
+      return redirect(redirectTo, { status: "success", msg: `Version ${version} restored` });
+    }
+
+    if (action === "save-translation" && locale) {
+      await collectionApi.upsertTranslation(documentId, locale, data, ctx);
+      return redirect(redirectTo, { status: "success", msg: `${locale} translation saved` });
+    }
+
+    return redirect(redirectTo);
+  } catch (error) {
+    let msg = error instanceof Error ? error.message : `Failed to ${action}`;
+    if (msg.toLowerCase().includes("unique constraint failed")) {
+      const match = msg.match(/unique constraint failed:\s*\S+\.(\w+)/i);
+      const field = match ? match[1] : "field";
+      msg = `A document with this ${field} already exists`;
+    } else if (msg.startsWith("Failed query:")) {
+      msg = `Failed to ${action} ${collection.labels.singular.toLowerCase()}`;
+    }
+    const fallback = documentId ? redirectTo : redirectTo || `/admin/${collectionSlug}/new`;
+    return redirect(fallback, { status: "error", msg });
+  }
+};
+
+const getRuntimeContext = (
+  locals: App.Locals,
+  cache?: { invalidate: (opts: { tags: string[] }) => void | Promise<void> },
+) => {
+  const user = locals.user;
+  return {
+    ...(user ? { user: { id: user.id, role: user.role, email: user.email } } : {}),
+    ...(cache ? { cache } : {}),
+  };
+};
+
+export const GET: APIRoute = async ({ params, url, locals }) => {
+  const collectionSlug = params.collection;
+  if (!collectionSlug) {
+    return Response.json({ error: "Collection is required." }, { status: 400 });
+  }
+
+  const ctx = getRuntimeContext(locals);
+  const pathSegments = getSegments(params.path);
+  const documentId = pathSegments[0];
+  const locale = url.searchParams.get("locale") ?? undefined;
+  const status = (url.searchParams.get("status") as "draft" | "published" | "any" | null) ?? undefined;
+
+  if (documentId) {
+    const doc = await cmsRuntime[collectionSlug].findById(documentId, { locale, status }, ctx);
+    if (!doc) {
+      return Response.json({ error: "Not found." }, { status: 404 });
+    }
+
+    return Response.json(doc);
+  }
+
+  const limit = url.searchParams.get("limit") ? Number(url.searchParams.get("limit")) : 20;
+  const offset = url.searchParams.get("offset") ? Number(url.searchParams.get("offset")) : 0;
+  const search = url.searchParams.get("search") ?? undefined;
+
+  const findOptions = {
+    where: parseJsonQuery(url.searchParams.get("where")),
+    sort: parseJsonQuery(url.searchParams.get("sort")),
+    limit,
+    offset,
+    locale,
+    status,
+    search,
+  };
+
+  const [docs, totalDocs] = await Promise.all([
+    cmsRuntime[collectionSlug].find(findOptions, ctx),
+    cmsRuntime[collectionSlug].count({ where: findOptions.where, status: findOptions.status, locale, search }, ctx),
+  ]);
+
+  const page = Math.floor(offset / limit) + 1;
+  const totalPages = Math.ceil(totalDocs / limit);
+
+  return Response.json({ docs, totalDocs, limit, offset, page, totalPages });
+};
+
+export const POST: APIRoute = async ({ params, request, locals, cache }) => {
+  const collectionSlug = params.collection;
+  if (!collectionSlug) {
+    return Response.json({ error: "Collection is required." }, { status: 400 });
+  }
+
+  const ctx = getRuntimeContext(locals, cache);
+  const pathSegments = getSegments(params.path);
+  const documentId = pathSegments[0];
+  const pathAction = pathSegments[1];
+
+  if (isFormRequest(request)) {
+    return handleHtmlMutation(collectionSlug, documentId, request, locals, cache);
+  }
+
+  const collectionApi = cmsRuntime[collectionSlug];
+
+  if (pathAction === "publish" && documentId) {
+    return Response.json(await collectionApi.publish(documentId, ctx));
+  }
+
+  if (pathAction === "unpublish" && documentId) {
+    return Response.json(await collectionApi.unpublish(documentId, ctx));
+  }
+
+  if (pathAction === "schedule" && documentId) {
+    const body = await request.json();
+    return Response.json(await collectionApi.schedule(documentId, body.publishAt, body.unpublishAt ?? null, ctx));
+  }
+
+  if (pathAction === "duplicate" && documentId) {
+    const original = await collectionApi.findById(documentId, { status: "any" }, ctx);
+    if (!original) {
+      return Response.json({ error: "Not found." }, { status: 404 });
+    }
+    const collection = getCollection(collectionSlug);
+
+    // Strip system fields and unique values that would conflict
+    const stripFields = (source: Record<string, any>) => {
+      const out: Record<string, any> = {};
+      for (const [key, value] of Object.entries(source)) {
+        if (key.startsWith("_")) continue;
+        const fieldDef = collection.fields[key];
+        if (!fieldDef) continue;
+        if ("unique" in fieldDef && fieldDef.unique) continue;
+        if (fieldDef.type === "slug") continue;
+        out[key] = value;
+      }
+      return out;
+    };
+
+    const data = stripFields(original);
+    if (typeof data.title === "string") data.title = `Copy of ${data.title}`;
+    else if (typeof data.name === "string") data.name = `Copy of ${data.name}`;
+
+    const created = await collectionApi.create(data, ctx);
+
+    // Copy translations if the collection supports them
+    if (collectionApi.getTranslations && collectionApi.upsertTranslation) {
+      try {
+        const translations = await collectionApi.getTranslations(documentId);
+        if (translations && typeof translations === "object") {
+          for (const [locale, translationData] of Object.entries(translations)) {
+            if (!translationData || typeof translationData !== "object") continue;
+            const translatedData = stripFields(translationData as Record<string, any>);
+            if (typeof translatedData.title === "string") translatedData.title = `Copy of ${translatedData.title}`;
+            else if (typeof translatedData.name === "string") translatedData.name = `Copy of ${translatedData.name}`;
+            await collectionApi.upsertTranslation(created._id, locale, translatedData, ctx);
+          }
+        }
+      } catch {
+        // Translations are optional — ignore errors
+      }
+    }
+
+    return Response.json(created, { status: 201 });
+  }
+
+  const body = await request.json();
+  const created = await collectionApi.create(body, ctx);
+  return Response.json(created, { status: 201 });
+};
+
+export const PATCH: APIRoute = async ({ params, request, locals, cache }) => {
+  const collectionSlug = params.collection;
+  if (!collectionSlug) {
+    return Response.json({ error: "Collection is required." }, { status: 400 });
+  }
+
+  const ctx = getRuntimeContext(locals, cache);
+  const pathSegments = getSegments(params.path);
+  const documentId = pathSegments[0];
+  if (!documentId) {
+    return Response.json({ error: "Document id is required." }, { status: 400 });
+  }
+
+  const body = await request.json();
+  const updated = await cmsRuntime[collectionSlug].update(documentId, body, ctx);
+  return Response.json(updated);
+};
+
+export const DELETE: APIRoute = async ({ params, locals, cache }) => {
+  const collectionSlug = params.collection;
+  if (!collectionSlug) {
+    return new Response(null, { status: 400 });
+  }
+
+  const ctx = getRuntimeContext(locals, cache);
+  const pathSegments = getSegments(params.path);
+  const documentId = pathSegments[0];
+  if (!documentId) {
+    return new Response(null, { status: 400 });
+  }
+
+  await cmsRuntime[collectionSlug].delete(documentId, ctx);
+  return new Response(null, { status: 204 });
+};

package/routes/api/cms/ai/alt-text.ts

@@ -0,0 +1,25 @@
+import type { APIRoute } from "astro";
+import { isAiEnabled, streamAltText } from "virtual:kide/runtime";
+
+export const prerender = false;
+
+export const POST: APIRoute = async ({ request }) => {
+  if (!isAiEnabled()) {
+    return Response.json({ error: "AI features are not enabled." }, { status: 403 });
+  }
+
+  const body = await request.json();
+  const { imageUrl, filename } = body;
+
+  if (!imageUrl || !filename) {
+    return Response.json({ error: "imageUrl and filename are required." }, { status: 400 });
+  }
+
+  try {
+    const result = await streamAltText(imageUrl, filename);
+    return result.toTextStreamResponse();
+  } catch (e) {
+    const message = e instanceof Error ? e.message : "Generation failed";
+    return Response.json({ error: message }, { status: 500 });
+  }
+};

package/routes/api/cms/ai/seo.ts

@@ -0,0 +1,25 @@
+import type { APIRoute } from "astro";
+import { isAiEnabled, streamSeoDescription } from "virtual:kide/runtime";
+
+export const prerender = false;
+
+export const POST: APIRoute = async ({ request }) => {
+  if (!isAiEnabled()) {
+    return Response.json({ error: "AI features are not enabled." }, { status: 403 });
+  }
+
+  const body = await request.json();
+  const { title, excerpt, body: pageBody } = body;
+
+  if (!title) {
+    return Response.json({ error: "title is required." }, { status: 400 });
+  }
+
+  try {
+    const result = await streamSeoDescription({ title, excerpt, body: pageBody });
+    return result.toTextStreamResponse();
+  } catch (e) {
+    const message = e instanceof Error ? e.message : "Generation failed";
+    return Response.json({ error: message }, { status: 500 });
+  }
+};

package/routes/api/cms/ai/translate.ts

@@ -0,0 +1,31 @@
+import type { APIRoute } from "astro";
+import { isAiEnabled, streamTranslation } from "virtual:kide/runtime";
+
+export const prerender = false;
+
+export const POST: APIRoute = async ({ request }) => {
+  if (!isAiEnabled()) {
+    return Response.json({ error: "AI features are not enabled." }, { status: 403 });
+  }
+
+  const body = await request.json();
+  const { text, sourceLocale, targetLocale, fieldName, fieldType } = body;
+
+  if (!text || !sourceLocale || !targetLocale || !fieldName) {
+    return Response.json({ error: "text, sourceLocale, targetLocale, and fieldName are required." }, { status: 400 });
+  }
+
+  try {
+    const result = await streamTranslation({
+      text,
+      sourceLocale,
+      targetLocale,
+      fieldName,
+      fieldType: fieldType || "text",
+    });
+    return result.toTextStreamResponse();
+  } catch (e) {
+    const message = e instanceof Error ? e.message : "Generation failed";
+    return Response.json({ error: message }, { status: 500 });
+  }
+};

package/routes/api/cms/assets/[id].ts

@@ -0,0 +1,82 @@
+import type { APIRoute } from "astro";
+import { assets } from "virtual:kide/runtime";
+
+export const prerender = false;
+
+export const GET: APIRoute = async ({ params }) => {
+  const id = params.id;
+  if (!id) return Response.json({ error: "Asset ID is required." }, { status: 400 });
+
+  const asset = await assets.findById(id);
+  if (!asset) return Response.json({ error: "Not found." }, { status: 404 });
+
+  return Response.json(asset);
+};
+
+export const PATCH: APIRoute = async ({ params, request }) => {
+  const id = params.id;
+  if (!id) return Response.json({ error: "Asset ID is required." }, { status: 400 });
+
+  const body = await request.json();
+  const data: {
+    alt?: string;
+    filename?: string;
+    folder?: string | null;
+    focalX?: number | null;
+    focalY?: number | null;
+  } = {};
+  if (typeof body.alt === "string") data.alt = body.alt;
+  if (typeof body.filename === "string") data.filename = body.filename;
+  if (body.folder === null || typeof body.folder === "string") data.folder = body.folder;
+  if (body.focalX === null || typeof body.focalX === "number") data.focalX = body.focalX;
+  if (body.focalY === null || typeof body.focalY === "number") data.focalY = body.focalY;
+
+  const result = await assets.update(id, data);
+  if (!result) return Response.json({ error: "Not found." }, { status: 404 });
+
+  return Response.json(result);
+};
+
+export const DELETE: APIRoute = async ({ params }) => {
+  const id = params.id;
+  if (!id) return new Response(null, { status: 400 });
+
+  await assets.delete(id);
+  return new Response(null, { status: 204 });
+};
+
+export const POST: APIRoute = async ({ params, request }) => {
+  const id = params.id;
+  if (!id) return new Response(null, { status: 400 });
+
+  const formData = new URLSearchParams(await request.text());
+  const method = formData.get("_method");
+
+  if (method === "DELETE") {
+    await assets.delete(id);
+    return new Response(null, {
+      status: 303,
+      headers: { Location: "/admin/assets?_toast=success&_msg=Asset+deleted" },
+    });
+  }
+
+  const action = formData.get("_action");
+  if (action === "update") {
+    const alt = formData.get("alt");
+    const folder = formData.get("folder");
+    const focalX = formData.get("focalX");
+    const focalY = formData.get("focalY");
+    await assets.update(id, {
+      alt: alt !== null ? alt : undefined,
+      folder: folder !== null ? (folder === "" ? null : folder) : undefined,
+      focalX: focalX !== null ? (focalX === "" ? null : Number(focalX)) : undefined,
+      focalY: focalY !== null ? (focalY === "" ? null : Number(focalY)) : undefined,
+    });
+    return new Response(null, {
+      status: 303,
+      headers: { Location: `/admin/assets/${id}?_toast=success&_msg=Asset+updated` },
+    });
+  }
+
+  return new Response(null, { status: 400 });
+};