qarpeo 0.0.0-alpha.10

package/dist/runtime/server/routes/cms/collections/index.post.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("nuxt/server").EventHandler<Promise<{
+    collection: import("../../../..").CMSCollection;
+}>>;
+export default _default;

package/dist/runtime/server/routes/cms/collections/index.post.mjs

@@ -0,0 +1,19 @@
+import { defineEventHandler, readBody, createError } from "nuxt/server";
+import { createCMSCollection, getCMSConfig } from "../../../utils/cms.mjs";
+import { requireAuth } from "../../../utils/context.mjs";
+export default defineEventHandler(async (event) => {
+  const config = getCMSConfig(event);
+  await requireAuth(event, { role: config.roles });
+  const body = await readBody(event);
+  if (!body?.id || !body?.name) {
+    throw createError({ statusCode: 400, message: "id and name are required" });
+  }
+  const id = body.id.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  const collection = await createCMSCollection(event, {
+    id,
+    name: body.name,
+    description: body.description,
+    fields: body.fields
+  });
+  return { collection };
+});

package/dist/runtime/server/routes/cms/components/index.get.d.ts

@@ -0,0 +1,17 @@
+/**
+ * GET /api/cms/components
+ *
+ * Returns all globally registered CMS component definitions from `nuxt.config.ts`
+ * `cms.components`. Used by the CMS Admin UI to populate component field pickers.
+ */
+declare const _default: import("nuxt/server").EventHandler<Promise<{
+    components: {
+        id: string;
+        name: string;
+        label: string;
+        icon: string | undefined;
+        description: string | undefined;
+        fields: Record<string, import("../../../..").CMSFieldDefinition>;
+    }[];
+}>>;
+export default _default;

package/dist/runtime/server/routes/cms/components/index.get.mjs

@@ -0,0 +1,16 @@
+import { defineEventHandler } from "nuxt/server";
+import { getCMSConfig } from "../../../utils/cms.mjs";
+export default defineEventHandler(async (event) => {
+  const config = getCMSConfig(event);
+  const components = config.components ?? {};
+  return {
+    components: Object.entries(components).map(([id, def]) => ({
+      id,
+      name: def.name ?? id,
+      label: def.label ?? id,
+      icon: def.icon,
+      description: def.description,
+      fields: def.fields
+    }))
+  };
+});

package/dist/runtime/server/routes/cms/deploy.post.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("nuxt/server").EventHandler<Promise<{
+    triggered: string[];
+}>>;
+export default _default;

package/dist/runtime/server/routes/cms/deploy.post.mjs

@@ -0,0 +1,46 @@
+import { defineEventHandler, createError } from "nuxt/server";
+import { getCMSConfig } from "../../utils/cms.mjs";
+import { requireAuth } from "../../utils/context.mjs";
+export default defineEventHandler(async (event) => {
+  await requireAuth(event, { role: ["admin", "super_admin"] });
+  const config = getCMSConfig(event);
+  if (!config.deploy) {
+    throw createError({ statusCode: 400, message: "No deploy trigger configured" });
+  }
+  const deploy = config.deploy;
+  const results = [];
+  if (deploy.hookUrl) {
+    try {
+      await fetch(deploy.hookUrl, { method: "POST" });
+      results.push("hookUrl");
+    } catch (e) {
+      console.warn("[qarpeo] manual deploy hook failed:", e);
+    }
+  }
+  if (deploy.github?.workflow) {
+    const gh = deploy.github;
+    const token = gh.token || process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
+    if (token) {
+      try {
+        const ref = gh.ref || "main";
+        await fetch(
+          `https://api.github.com/repos/${gh.repo}/actions/workflows/${gh.workflow}/dispatches`,
+          {
+            method: "POST",
+            headers: {
+              Authorization: `token ${token}`,
+              Accept: "application/vnd.github.v3+json",
+              "Content-Type": "application/json",
+              "User-Agent": "qarpeo-cms"
+            },
+            body: JSON.stringify({ ref })
+          }
+        );
+        results.push("github-workflow");
+      } catch (e) {
+        console.warn("[qarpeo] manual GitHub workflow dispatch failed:", e);
+      }
+    }
+  }
+  return { triggered: results };
+});

package/dist/runtime/server/routes/cms/export.post.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("nuxt/server").EventHandler<Promise<{
+    ok: boolean;
+    message: string;
+    exported?: undefined;
+} | {
+    ok: boolean;
+    exported: number;
+    message?: undefined;
+}>>;
+export default _default;

package/dist/runtime/server/routes/cms/export.post.mjs

@@ -0,0 +1,55 @@
+import { defineEventHandler } from "nuxt/server";
+import { getD1Binding } from "../../../db.mjs";
+import { getCMSConfig, formatFrontmatter, computeContentHash } from "../../utils/cms.mjs";
+import { requireAuth } from "../../utils/context.mjs";
+export default defineEventHandler(async (event) => {
+  const config = getCMSConfig(event);
+  await requireAuth(event, { role: config.roles });
+  let writeFile, mkdir;
+  try {
+    const fs = await import("node:fs/promises");
+    writeFile = fs.writeFile;
+    mkdir = fs.mkdir;
+  } catch {
+    return {
+      ok: false,
+      message: "Export to filesystem is only available in local development environments."
+    };
+  }
+  const db = getD1Binding("DB", event);
+  const rows = await db.prepare("SELECT * FROM _qarpeo_cms_entries ORDER BY collection_id, slug").all();
+  const entries = rows.results || [];
+  let exported = 0;
+  for (const entry of entries) {
+    const collectionId = entry.collection_id;
+    const slug = entry.slug;
+    const dir = `${config.contentDir}/${collectionId}`;
+    try {
+      await mkdir(dir, { recursive: true });
+    } catch {
+    }
+    const filePath = `${dir}/${slug}.md`;
+    let metadata = {};
+    try {
+      metadata = JSON.parse(entry.metadata_json || "{}");
+    } catch {
+    }
+    const fmData = {
+      title: entry.title,
+      slug: entry.slug,
+      ...entry.description ? { description: entry.description } : {},
+      ...entry.cover_image ? { coverImage: entry.cover_image } : {},
+      ...entry.tags ? { tags: entry.tags.split(",") } : {},
+      ...entry.order ? { order: entry.order } : {},
+      ...metadata
+    };
+    const fileContent = formatFrontmatter(fmData, entry.content_md || "");
+    await writeFile(filePath, fileContent, "utf8");
+    const newHash = await computeContentHash(fileContent);
+    await db.prepare(
+      "UPDATE _qarpeo_cms_entries SET content_hash = ?, file_path = ?, source = 'file' WHERE id = ?"
+    ).bind(newHash, filePath, entry.id).run();
+    exported++;
+  }
+  return { ok: true, exported };
+});

package/dist/runtime/server/routes/cms/navigation.get.d.ts

@@ -0,0 +1,8 @@
+/**
+ * GET /api/cms/navigation?collection=docs&levels=1&path=/docs/cms&limit=20&skip=0 Returns a
+ * navigation tree for a "page" collection. Shape is compatible with @nuxt/ui <UContentNavigation>.
+ */
+declare const _default: import("nuxt/server").EventHandler<Promise<{
+    navigation: import("../../..").CMSNavigationItem[];
+}>>;
+export default _default;

package/dist/runtime/server/routes/cms/navigation.get.mjs

@@ -0,0 +1,36 @@
+import { defineEventHandler, getQuery } from "nuxt/server";
+import { getCMSNavigationTree } from "../../utils/cms.mjs";
+export default defineEventHandler(async (event) => {
+  const query = getQuery(event);
+  const collection = query.collection;
+  if (!collection || typeof collection !== "string") {
+    return { navigation: [] };
+  }
+  const levels = query.levels != null && query.levels !== "" ? parseInt(String(query.levels), 10) : void 0;
+  const limit = query.limit != null && query.limit !== "" ? parseInt(String(query.limit), 10) : void 0;
+  const skip = query.skip != null && query.skip !== "" ? parseInt(String(query.skip), 10) : void 0;
+  const path = typeof query.path === "string" && query.path.trim() ? query.path.trim() : void 0;
+  const status = typeof query.status === "string" && ["published", "draft", "all"].includes(query.status) ? query.status : void 0;
+  const unwrap = query.unwrap === "true" || query.unwrap === "1";
+  let where;
+  if (typeof query.where === "string" && query.where.trim()) {
+    try {
+      const parsed = JSON.parse(query.where);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        where = parsed;
+      }
+    } catch {
+    }
+  }
+  const navigation = await getCMSNavigationTree(event, collection, {
+    levels: Number.isFinite(levels) ? levels : void 0,
+    path,
+    limit: Number.isFinite(limit) ? limit : void 0,
+    skip: Number.isFinite(skip) ? skip : void 0,
+    status,
+    where,
+    unwrap,
+    locale: query.locale ? String(query.locale) : void 0
+  });
+  return { navigation };
+});

package/dist/runtime/server/routes/cms/preview/disable.get.d.ts

@@ -0,0 +1,9 @@
+/**
+ * GET /api/cms/preview/disable
+ * Disables CMS preview mode by clearing the `qarpeo_preview` cookie and redirecting.
+ *
+ * Query params:
+ *   - redirect: string (optional page to redirect back to, default: "/")
+ */
+declare const _default: import("nuxt/server").EventHandler<string>;
+export default _default;

package/dist/runtime/server/routes/cms/preview/disable.get.mjs

@@ -0,0 +1,9 @@
+import { defineEventHandler, getQuery, deleteCookie, sendRedirect } from "nuxt/server";
+export default defineEventHandler((event) => {
+  const query = getQuery(event);
+  const redirect = String(query.redirect || "/");
+  deleteCookie(event, "qarpeo_preview", {
+    path: "/"
+  });
+  return sendRedirect(event, redirect, 302);
+});

package/dist/runtime/server/routes/cms/preview/enable.get.d.ts

@@ -0,0 +1,14 @@
+/**
+ * GET /api/cms/preview/enable
+ * Activates preview mode by verifying an HMAC preview token and setting a `qarpeo_preview` cookie.
+ * Redirects the user to the target document page.
+ *
+ * Query params:
+ *   - collection: string (collection ID)
+ *   - slug: string (entry slug or ID)
+ *   - token: string (HMAC-SHA256 signature)
+ *   - expires: string (expiration timestamp)
+ *   - redirect: string (target page URL)
+ */
+declare const _default: import("nuxt/server").EventHandler<Promise<string>>;
+export default _default;

package/dist/runtime/server/routes/cms/preview/enable.get.mjs

@@ -0,0 +1,42 @@
+import { defineEventHandler, getQuery, setCookie, sendRedirect, createError } from "nuxt/server";
+import { verifyPreviewToken } from "../../../utils/cms.mjs";
+export default defineEventHandler(async (event) => {
+  const query = getQuery(event);
+  const collection = String(query.collection || "");
+  const slug = String(query.slug || query.id || "");
+  const token = String(query.token || query.preview_token || "");
+  const expires = String(query.expires || "");
+  const redirect = String(query.redirect || (slug ? `/${collection}/${slug}` : "/"));
+  if (!collection || !slug || !token || !expires) {
+    throw createError({
+      statusCode: 400,
+      message: "Missing preview credentials (collection, slug, token, and expires are required)."
+    });
+  }
+  const isValid = await verifyPreviewToken(event, collection, slug, token, expires);
+  if (!isValid) {
+    throw createError({
+      statusCode: 403,
+      message: "Invalid or expired CMS preview token."
+    });
+  }
+  const maxAgeSeconds = Math.max(60, Math.floor((Number(expires) - Date.now()) / 1e3));
+  setCookie(
+    event,
+    "qarpeo_preview",
+    JSON.stringify({
+      collection,
+      slug,
+      token,
+      expires: Number(expires)
+    }),
+    {
+      path: "/",
+      httpOnly: false,
+      secure: true,
+      sameSite: "lax",
+      maxAge: maxAgeSeconds
+    }
+  );
+  return sendRedirect(event, redirect, 302);
+});

package/dist/runtime/server/routes/cms/publish-scheduled.post.d.ts

@@ -0,0 +1,11 @@
+declare const _default: import("nuxt/server").EventHandler<Promise<{
+    ok: boolean;
+    publishedCount: number;
+    published: {
+        id: string;
+        slug: string;
+        collection: string;
+        publishedAt: number | null | undefined;
+    }[];
+}>>;
+export default _default;

package/dist/runtime/server/routes/cms/publish-scheduled.post.mjs

@@ -0,0 +1,35 @@
+import { defineEventHandler, getRequestHeader, getQuery, createError } from "nuxt/server";
+import { publishDueScheduledEntries, getCMSConfig } from "../../utils/cms.mjs";
+import { getAuthContext } from "../../utils/context.mjs";
+export default defineEventHandler(async (event) => {
+  const config = getCMSConfig(event);
+  const cronSecret = process.env.CRON_SECRET || process.env.QARPEO_CRON_SECRET;
+  const authHeader = getRequestHeader(event, "authorization") || getRequestHeader(event, "x-cron-secret");
+  const querySecret = getQuery(event)?.secret;
+  let authorized = false;
+  if (cronSecret && (authHeader === `Bearer ${cronSecret}` || authHeader === cronSecret || querySecret === cronSecret)) {
+    authorized = true;
+  } else {
+    const auth = await getAuthContext(event);
+    if (auth?.isAdmin || auth?.role && config.roles?.includes(auth.role)) {
+      authorized = true;
+    }
+  }
+  if (!authorized && (cronSecret || !config.scheduledPublish)) {
+    throw createError({
+      statusCode: 401,
+      message: "Unauthorized: Invalid cron secret or insufficient permissions"
+    });
+  }
+  const published = await publishDueScheduledEntries(event);
+  return {
+    ok: true,
+    publishedCount: published.length,
+    published: published.map((e) => ({
+      id: e.id,
+      slug: e.slug,
+      collection: e.collectionId,
+      publishedAt: e.publishedAt
+    }))
+  };
+});

package/dist/runtime/server/routes/cms/search.get.d.ts

@@ -0,0 +1,13 @@
+import type { CMSEntry } from "../../../../types";
+declare const _default: import("nuxt/server").EventHandler<Promise<{
+    results: never[];
+    total: number;
+    limit?: undefined;
+    offset?: undefined;
+} | {
+    results: CMSEntry[];
+    total: number;
+    limit: number;
+    offset: number;
+}>>;
+export default _default;

package/dist/runtime/server/routes/cms/search.get.mjs

@@ -0,0 +1,137 @@
+import { defineEventHandler, getQuery } from "nuxt/server";
+import { getD1Binding } from "../../../db.mjs";
+import { getCloudflareEnv } from "../../../bindings.mjs";
+import { similaritySearch } from "../../utils/ai.mjs";
+import { getCMSConfig, buildFtsQuery } from "../../utils/cms.mjs";
+import { getAuthContext } from "../../utils/context.mjs";
+export default defineEventHandler(async (event) => {
+  const query = getQuery(event);
+  const q = (query.q || "").trim();
+  const collection = query.collection;
+  const isSemantic = query.mode === "semantic" || query.semantic === "true";
+  const limit = Math.min(50, Math.max(1, query.limit ? Number(query.limit) : 10));
+  const offset = Math.max(0, query.offset ? Number(query.offset) : 0);
+  const locale = query.locale ? String(query.locale) : void 0;
+  if (!q) {
+    return { results: [], total: 0 };
+  }
+  const auth = await getAuthContext(event);
+  const config = getCMSConfig(event);
+  const isEditor = auth?.user && (config.roles.some((r) => r === auth.role) || auth.isAdmin);
+  const db = getD1Binding("DB", event);
+  const conditions = [];
+  const binds = [];
+  if (!isEditor) {
+    conditions.push("status = 'published'");
+  } else if (query.status) {
+    conditions.push("status = ?");
+    binds.push(query.status);
+  }
+  if (collection) {
+    conditions.push("collection_id = ?");
+    binds.push(collection);
+  }
+  if (locale) {
+    conditions.push("(locale = ? OR locale = 'en')");
+    binds.push(locale);
+  }
+  let matchedIdsFromVectorize = null;
+  if (isSemantic) {
+    try {
+      const env = getCloudflareEnv(event);
+      if (env?.VECTORIZE && env?.AI) {
+        const matches = await similaritySearch("VECTORIZE", q, { topK: limit * 2, event });
+        if (Array.isArray(matches) && matches.length > 0) {
+          matchedIdsFromVectorize = matches.map((m) => m.id).filter(Boolean);
+        }
+      }
+    } catch {
+    }
+  }
+  if (matchedIdsFromVectorize && matchedIdsFromVectorize.length > 0) {
+    const placeholders = matchedIdsFromVectorize.map(() => "?").join(", ");
+    conditions.push(`id IN (${placeholders})`);
+    binds.push(...matchedIdsFromVectorize);
+  } else {
+    let ftsMatchedIds = null;
+    try {
+      const ftsQuery = buildFtsQuery(q, "AND");
+      if (ftsQuery) {
+        const ftsRes = await db.prepare(
+          "SELECT id FROM _qarpeo_cms_entries_fts WHERE _qarpeo_cms_entries_fts MATCH ? ORDER BY rank LIMIT 100"
+        ).bind(ftsQuery).all();
+        const ids = (ftsRes.results || []).map((r) => r.id).filter(Boolean);
+        if (ids.length > 0) {
+          ftsMatchedIds = ids;
+        } else {
+          const ftsOrQuery = buildFtsQuery(q, "OR");
+          if (ftsOrQuery && ftsOrQuery !== ftsQuery) {
+            const orRes = await db.prepare(
+              "SELECT id FROM _qarpeo_cms_entries_fts WHERE _qarpeo_cms_entries_fts MATCH ? ORDER BY rank LIMIT 100"
+            ).bind(ftsOrQuery).all();
+            const orIds = (orRes.results || []).map((r) => r.id).filter(Boolean);
+            if (orIds.length > 0) {
+              ftsMatchedIds = orIds;
+            }
+          }
+        }
+      }
+    } catch {
+    }
+    if (ftsMatchedIds && ftsMatchedIds.length > 0) {
+      const placeholders = ftsMatchedIds.map(() => "?").join(", ");
+      conditions.push(`id IN (${placeholders})`);
+      binds.push(...ftsMatchedIds);
+    } else {
+      const searchPattern = `%${q.toLowerCase()}%`;
+      conditions.push(
+        "(LOWER(title) LIKE ? OR LOWER(description) LIKE ? OR LOWER(tags) LIKE ? OR LOWER(content_md) LIKE ?)"
+      );
+      binds.push(searchPattern, searchPattern, searchPattern, searchPattern);
+    }
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const [countRes, dataRes] = await Promise.all([
+    db.prepare(`SELECT COUNT(*) as total FROM _qarpeo_cms_entries ${where}`).bind(...binds).first(),
+    db.prepare(
+      `SELECT id, collection_id, slug, title, description, cover_image, tags, "order",
+                content_md, content_html, metadata_json, status, source, file_path,
+                locale, published_at, created_at, updated_at
+         FROM _qarpeo_cms_entries ${where}
+         ORDER BY published_at DESC LIMIT ? OFFSET ?`
+    ).bind(...binds, limit, offset).all()
+  ]);
+  const total = countRes?.total ?? 0;
+  const results = (dataRes.results || []).map(
+    (row) => {
+      let metadata = {};
+      try {
+        metadata = JSON.parse(row.metadata_json || "{}");
+      } catch {
+      }
+      return {
+        id: row.id,
+        collectionId: row.collection_id,
+        slug: row.slug,
+        title: row.title,
+        description: row.description,
+        coverImage: row.cover_image,
+        tags: row.tags,
+        order: row.order,
+        contentMd: row.content_md,
+        contentHtml: row.content_html,
+        metadata,
+        metadataJson: row.metadata_json,
+        status: row.status,
+        source: row.source,
+        filePath: row.file_path,
+        locale: row.locale || "en",
+        authorId: row.author_id,
+        publishedAt: row.published_at,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at
+      };
+    }
+  );
+  return { results, total, limit, offset };
+});

package/dist/runtime/server/routes/cms/sync.post.d.ts

@@ -0,0 +1,7 @@
+declare const _default: import("nuxt/server").EventHandler<Promise<{
+    synced: number;
+    skipped: number;
+    inserted: number;
+    ok: boolean;
+}>>;
+export default _default;

package/dist/runtime/server/routes/cms/sync.post.mjs

@@ -0,0 +1,18 @@
+import { defineEventHandler } from "nuxt/server";
+import { getCMSConfig, seedCollectionsFromConfig, syncLocalContentFiles } from "../../utils/cms.mjs";
+import { requireAuth } from "../../utils/context.mjs";
+export default defineEventHandler(async (event) => {
+  const config = getCMSConfig(event);
+  await requireAuth(event, { role: config.roles });
+  await seedCollectionsFromConfig(event, config.collections);
+  const syncResult = await syncLocalContentFiles(
+    event,
+    config.contentDir,
+    config.collections,
+    config.sources
+  );
+  return {
+    ok: true,
+    ...syncResult
+  };
+});