@bettercms-ai/next 0.5.2

package/dist/index.js

@@ -0,0 +1,583 @@
+// src/types.ts
+var BetterCMSError = class extends Error {
+  status;
+  code;
+  constructor(message, status, code) {
+    super(message);
+    this.name = "BetterCMSError";
+    this.status = status;
+    this.code = code;
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.bettercms.ai/api/v1/delivery";
+var DEFAULT_REVALIDATE = 60;
+function statusToCode(status) {
+  if (status === 404) return "CONTENT_NOT_FOUND";
+  if (status === 401) return "UNAUTHORIZED";
+  if (status === 403) return "FORBIDDEN";
+  if (status === 429) return "RATE_LIMITED";
+  if (status === 422) return "VALIDATION_ERROR";
+  return "INTERNAL_ERROR";
+}
+function mapEntry(raw) {
+  return {
+    slug: raw.slug,
+    status: raw.status,
+    fields: raw.data,
+    publishedAt: raw.publishedAt ?? null,
+    updatedAt: raw.updatedAt ?? null
+  };
+}
+function createBetterCMS(config) {
+  const baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const previewBaseUrl = (config.previewBaseUrl ?? baseUrl.replace(/\/delivery$/, "/preview")).replace(/\/+$/, "");
+  const defaultRevalidate = config.revalidate ?? DEFAULT_REVALIDATE;
+  function headers() {
+    const h = { Accept: "application/json" };
+    if (config.apiKey) h["Authorization"] = `Bearer ${config.apiKey}`;
+    return h;
+  }
+  function cacheInit(revalidate, tags, forceNoStore = false) {
+    const rv = revalidate ?? defaultRevalidate;
+    if (forceNoStore) return { headers: headers(), cache: "no-store" };
+    if (rv === false) {
+      return tags?.length ? { headers: headers(), next: { revalidate: false, tags } } : { headers: headers(), cache: "no-store" };
+    }
+    return { headers: headers(), next: { revalidate: rv, tags } };
+  }
+  async function requestJSON(url, init, { nullOn404 = false } = {}) {
+    let res;
+    try {
+      res = await fetch(url, init);
+    } catch (err) {
+      throw new BetterCMSError(
+        `Network error: ${err instanceof Error ? err.message : String(err)}`,
+        0,
+        "NETWORK_ERROR"
+      );
+    }
+    if (res.status === 404 && nullOn404) return null;
+    if (!res.ok) {
+      let message = res.statusText || "Request failed";
+      try {
+        const body = await res.json();
+        message = body.error ?? body.message ?? message;
+      } catch {
+      }
+      throw new BetterCMSError(message, res.status, statusToCode(res.status));
+    }
+    return await res.json();
+  }
+  function entryQuery(opts) {
+    const params = new URLSearchParams();
+    if (opts?.depth != null) params.set("depth", String(opts.depth));
+    if (opts?.select?.length) params.set("select", opts.select.join(","));
+    const qs = params.toString();
+    return qs ? `?${qs}` : "";
+  }
+  const client = {
+    async getEntry(slug, opts) {
+      const encoded = encodeURIComponent(slug);
+      const query = entryQuery(opts);
+      if (opts?.preview) {
+        if (!opts.previewToken) {
+          throw new BetterCMSError(
+            "preview: true requires a previewToken",
+            400,
+            "VALIDATION_ERROR"
+          );
+        }
+        const tokenParam = `token=${encodeURIComponent(opts.previewToken)}`;
+        const sep = query ? "&" : "?";
+        const url2 = `${previewBaseUrl}/${encoded}${query}${sep}${tokenParam}`;
+        const body = await requestJSON(
+          url2,
+          cacheInit(void 0, void 0, true),
+          { nullOn404: true }
+        );
+        return body ? mapEntry(body.data) : null;
+      }
+      const url = `${baseUrl}/${config.workspace}/content-entries/${encoded}${query}`;
+      const raw = await requestJSON(
+        url,
+        cacheInit(opts?.revalidate, opts?.tags),
+        { nullOn404: true }
+      );
+      return raw ? mapEntry(raw) : null;
+    },
+    async listEntries(model, opts) {
+      const params = new URLSearchParams();
+      if (model) params.set("model", model);
+      if (opts?.page != null) params.set("page", String(opts.page));
+      if (opts?.perPage != null) params.set("perPage", String(opts.perPage));
+      if (opts?.depth != null) params.set("depth", String(opts.depth));
+      if (opts?.select?.length) params.set("select", opts.select.join(","));
+      const url = `${baseUrl}/${config.workspace}/content-entries?${params}`;
+      const body = await requestJSON(
+        url,
+        cacheInit(opts?.revalidate, opts?.tags)
+      );
+      const data = body?.data;
+      if (!data) {
+        return {
+          items: [],
+          page: opts?.page ?? 1,
+          perPage: opts?.perPage ?? 20,
+          totalItems: 0,
+          totalPages: 1,
+          hasNextPage: false,
+          hasPreviousPage: false
+        };
+      }
+      return {
+        items: data.items.map((r) => mapEntry(r)),
+        page: data.page,
+        perPage: data.perPage,
+        totalItems: data.totalItems,
+        totalPages: data.totalPages,
+        hasNextPage: data.hasNextPage,
+        hasPreviousPage: data.hasPreviousPage
+      };
+    },
+    async getPage(slug, opts) {
+      const url = `${baseUrl}/${config.workspace}/content/${encodeURIComponent(slug)}`;
+      const body = await requestJSON(
+        url,
+        cacheInit(opts?.revalidate, opts?.tags),
+        { nullOn404: true }
+      );
+      if (!body) return null;
+      const { entry, publishedAt } = body.data;
+      return {
+        slug: entry.slug,
+        title: entry.title,
+        metaTitle: entry.metaTitle ?? null,
+        metaDescription: entry.metaDescription ?? null,
+        metaJson: entry.metaJson ?? null,
+        blocks: entry.blocks ?? [],
+        publishedAt: publishedAt ?? null,
+        updatedAt: entry.updatedAt ?? null
+      };
+    }
+  };
+  return client;
+}
+
+// src/metadata.ts
+import { resolveSeo } from "@bettercms-ai/sdk";
+function buildMetadata(page, siteDefaults = {}) {
+  const seo = resolveSeo(page, siteDefaults);
+  return {
+    title: seo.title || void 0,
+    description: seo.description || void 0,
+    alternates: seo.canonical ? { canonical: seo.canonical } : void 0,
+    openGraph: {
+      title: seo.og.title || void 0,
+      description: seo.og.description || void 0,
+      type: seo.og.type || "website",
+      url: seo.og.url || void 0,
+      images: seo.og.image ? [{ url: seo.og.image }] : void 0
+    },
+    twitter: {
+      card: seo.twitter.card || "summary",
+      title: seo.twitter.title || void 0,
+      description: seo.twitter.description || void 0,
+      images: seo.twitter.image ? [seo.twitter.image] : void 0,
+      site: seo.twitter.site || void 0
+    }
+  };
+}
+
+// src/index.ts
+import { resolveSeo as resolveSeo2 } from "@bettercms-ai/sdk";
+
+// src/snapshot.ts
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
+import { dirname, resolve } from "path";
+var SNAPSHOT_VERSION = 1;
+var DEFAULT_SNAPSHOT_FILE = "bcms-content.json";
+function serializeSnapshot(snapshot) {
+  return JSON.stringify(snapshot, null, 2);
+}
+function parseSnapshot(json) {
+  const parsed = JSON.parse(json);
+  if (parsed.version !== SNAPSHOT_VERSION) {
+    throw new BetterCMSError(
+      `Unsupported bcms-content.json version ${parsed.version} (expected ${SNAPSHOT_VERSION}). Regenerate it with "bettercms-snapshot".`,
+      0,
+      "SNAPSHOT_VERSION_MISMATCH"
+    );
+  }
+  return parsed;
+}
+function writeSnapshot(path, snapshot) {
+  const out = resolve(process.cwd(), path);
+  mkdirSync(dirname(out), { recursive: true });
+  writeFileSync(out, serializeSnapshot(snapshot), "utf8");
+}
+function readSnapshot(path) {
+  const out = resolve(process.cwd(), path);
+  let json;
+  try {
+    json = readFileSync(out, "utf8");
+  } catch (err) {
+    if (err?.code === "ENOENT") return null;
+    throw err;
+  }
+  return parseSnapshot(json);
+}
+async function buildSnapshot(opts) {
+  const client = opts.client ?? createBetterCMS(opts.config);
+  const models = {};
+  for (const slug of opts.modelSlugs) {
+    const all = [];
+    let page = 1;
+    for (; ; ) {
+      const res = await client.listEntries(slug, { page, perPage: 100, revalidate: false });
+      all.push(...res.items);
+      if (!res.hasNextPage) break;
+      page += 1;
+    }
+    models[slug] = all;
+  }
+  return {
+    version: SNAPSHOT_VERSION,
+    workspace: opts.config.workspace,
+    generatedAt: opts.now ?? (/* @__PURE__ */ new Date()).toISOString(),
+    models
+  };
+}
+function isPreview() {
+  const v = globalThis.process?.env?.BETTERCMS_PREVIEW;
+  return v != null && v !== "" && v !== "0" && v !== "false";
+}
+var snapshotCache = /* @__PURE__ */ new Map();
+function emptyPage(items) {
+  return {
+    items,
+    page: 1,
+    perPage: items.length,
+    totalItems: items.length,
+    totalPages: 1,
+    hasNextPage: false,
+    hasPreviousPage: false
+  };
+}
+function getContent(config, opts = {}) {
+  const path = opts.snapshotPath ?? DEFAULT_SNAPSHOT_FILE;
+  if (isPreview()) {
+    const live = createBetterCMS(config);
+    return {
+      getEntry: (slug) => live.getEntry(slug, { revalidate: false }),
+      listEntries: (model) => live.listEntries(model, { revalidate: false })
+    };
+  }
+  const resolved = resolve(process.cwd(), path);
+  function load() {
+    const cached = snapshotCache.get(resolved);
+    if (cached) return cached;
+    const snap = readSnapshot(path);
+    if (!snap) {
+      throw new BetterCMSError(
+        `BetterCMS content snapshot "${path}" not found. A static (output: "export") build reads content from this snapshot; without it pages fall back to a live no-store fetch, become dynamic routes, and output: "export" silently drops them (empty out/). Run "bettercms-snapshot" before "next build" (make it your build:preview prestep), or set BETTERCMS_PREVIEW=1 to read live in a preview build.`,
+        0,
+        "SNAPSHOT_MISSING"
+      );
+    }
+    snapshotCache.set(resolved, snap);
+    return snap;
+  }
+  return {
+    async getEntry(slug) {
+      const snap = load();
+      for (const entries of Object.values(snap.models)) {
+        const found = entries.find((e) => e.slug === slug);
+        if (found) return found;
+      }
+      return null;
+    },
+    async listEntries(model) {
+      const snap = load();
+      const items = model ? snap.models[model] ?? [] : Object.values(snap.models).flat();
+      return emptyPage(items);
+    }
+  };
+}
+
+// src/llms-txt.ts
+function oneLine(text) {
+  return text.replace(/[\r\n]+/g, " ").trim();
+}
+function inlineText(text) {
+  return oneLine(text).replace(/^([#>\-*+=|])/, "\\$1");
+}
+function codeSpan(text) {
+  return oneLine(text).replace(/`/g, "");
+}
+function fieldLine(f) {
+  const req = f.required ? ", required" : "";
+  const label = f.label && f.label !== f.key ? ` \u2014 ${inlineText(f.label)}` : "";
+  return `  - \`${codeSpan(f.key)}\` (${codeSpan(f.type)}${req})${label}`;
+}
+function generateLlmsTxt(models, opts = {}) {
+  const title = opts.title ?? "BetterCMS content";
+  const sorted = [...models].sort(
+    (a, b) => a.slug < b.slug ? -1 : a.slug > b.slug ? 1 : 0
+  );
+  const lines = [`# ${inlineText(title)}`, ""];
+  if (opts.description) {
+    lines.push(`> ${inlineText(opts.description)}`, "");
+  }
+  const base = opts.baseUrl && opts.workspace ? `${opts.baseUrl.replace(/\/+$/, "")}/${opts.workspace}/content-entries` : void 0;
+  lines.push("## Content models", "");
+  if (sorted.length === 0) {
+    lines.push("_No content models are defined yet._", "");
+  }
+  for (const model of sorted) {
+    const name = model.name ?? model.slug;
+    lines.push(`### ${inlineText(name)} (\`${codeSpan(model.slug)}\`)`);
+    if (model.description) lines.push("", inlineText(model.description));
+    if (base) {
+      lines.push("", `- List: \`GET ${base}?model=${codeSpan(model.slug)}\``);
+      lines.push(`- Entry: \`GET ${base}/{slug}\``);
+    }
+    if (model.fields.length) {
+      lines.push("", "Fields:");
+      for (const f of model.fields) lines.push(fieldLine(f));
+    }
+    lines.push("");
+  }
+  if (opts.notes?.length) {
+    lines.push("## Notes", "");
+    for (const note of opts.notes) lines.push(`- ${inlineText(note)}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function llmsTxtRoute(config) {
+  const { models, getModels, cacheControl, ...opts } = config;
+  return async () => {
+    const resolved = getModels ? await getModels() : models ?? [];
+    const body = generateLlmsTxt(resolved, opts);
+    return new Response(body, {
+      status: 200,
+      headers: {
+        "Content-Type": "text/plain; charset=utf-8",
+        "Cache-Control": cacheControl ?? "public, max-age=3600"
+      }
+    });
+  };
+}
+async function fetchModels(opts) {
+  const doFetch = opts.fetchImpl ?? fetch;
+  const base = opts.apiUrl.replace(/\/+$/, "");
+  const res = await doFetch(`${base}/management/content/models`, {
+    headers: { Authorization: `Bearer ${opts.apiKey}`, Accept: "application/json" }
+  });
+  if (!res.ok) {
+    throw new Error(`Management API returned ${res.status} ${res.statusText}`);
+  }
+  const body = await res.json();
+  return (body.data ?? []).map((m) => ({
+    slug: m.slug,
+    name: m.name,
+    description: m.description ?? null,
+    fields: m.fields ?? []
+  }));
+}
+
+// src/preview.ts
+async function isDraftEnabled() {
+  const { draftMode } = await import("next/headers");
+  const dm = await draftMode();
+  return dm.isEnabled;
+}
+async function getPreviewToken() {
+  const { cookies } = await import("next/headers");
+  const jar = await cookies();
+  return jar.get("bcms-preview-token")?.value ?? null;
+}
+
+// src/draft-route.ts
+var PREVIEW_TOKEN_COOKIE = "bcms-preview-token";
+function safeRedirectPath(to) {
+  return to.startsWith("/") && !to.startsWith("//") ? to : "/";
+}
+function decodeTokenSlug(token) {
+  try {
+    const part = token.split(".")[1];
+    if (!part) return null;
+    const json = JSON.parse(
+      Buffer.from(part, "base64url").toString("utf8")
+    );
+    return json.entrySlug ?? null;
+  } catch {
+    return null;
+  }
+}
+function createDraftModeRoute(config) {
+  const apiUrl = config.apiUrl.replace(/\/+$/, "");
+  async function GET(request) {
+    const url = new URL(request.url);
+    const token = url.searchParams.get("token");
+    const redirectTo = url.searchParams.get("redirect") ?? "/";
+    if (!token) return new Response("Missing token", { status: 400 });
+    const slug = decodeTokenSlug(token);
+    if (!slug) return new Response("Malformed token", { status: 400 });
+    const res = await fetch(
+      `${apiUrl}/api/v1/preview/${encodeURIComponent(slug)}?token=${encodeURIComponent(token)}`
+    );
+    if (!res.ok) return new Response("Invalid or expired token", { status: 401 });
+    const { draftMode, cookies } = await import("next/headers");
+    (await draftMode()).enable();
+    (await cookies()).set(PREVIEW_TOKEN_COOKIE, token, {
+      httpOnly: true,
+      sameSite: "lax",
+      secure: url.protocol === "https:",
+      path: "/",
+      maxAge: 60 * 60 * 24
+    });
+    return Response.redirect(new URL(safeRedirectPath(redirectTo), url.origin), 302);
+  }
+  return { GET };
+}
+function createDisableDraftRoute() {
+  async function GET(request) {
+    const url = new URL(request.url);
+    const redirectTo = url.searchParams.get("redirect") ?? "/";
+    const { draftMode, cookies } = await import("next/headers");
+    (await draftMode()).disable();
+    (await cookies()).delete(PREVIEW_TOKEN_COOKIE);
+    return Response.redirect(new URL(safeRedirectPath(redirectTo), url.origin), 302);
+  }
+  return { GET };
+}
+
+// src/index.ts
+import { default as default2, imageUrl } from "@bettercms-ai/image-url";
+
+// src/forms-read.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+function readForms(path = "bcms-content.json") {
+  let raw;
+  try {
+    raw = readFileSync2(resolve2(process.cwd(), path), "utf8");
+  } catch {
+    return { forms: [], turnstileSiteKey: null };
+  }
+  const snap = JSON.parse(raw);
+  return { forms: snap.forms ?? [], turnstileSiteKey: snap.turnstileSiteKey ?? null };
+}
+function getForm(idOrName, path) {
+  return readForms(path).forms.find((f) => f.id === idOrName || f.name === idOrName);
+}
+
+// src/pages-read.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve3 } from "path";
+function readPages(path = "bcms-content.json") {
+  let raw;
+  try {
+    raw = readFileSync3(resolve3(process.cwd(), path), "utf8");
+  } catch {
+    return [];
+  }
+  const snap = JSON.parse(raw);
+  return snap.pages ?? [];
+}
+function getPage(slug, path) {
+  return readPages(path).find((p) => p.slug === slug);
+}
+
+// src/components-read.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { resolve as resolve4 } from "path";
+function readComponents(path = "bcms-content.json") {
+  let raw;
+  try {
+    raw = readFileSync4(resolve4(process.cwd(), path), "utf8");
+  } catch {
+    return [];
+  }
+  const snap = JSON.parse(raw);
+  return snap.components ?? [];
+}
+function getComponent(idOrSlug, path) {
+  return readComponents(path).find(
+    (c) => c.id === idOrSlug || c.slug === idOrSlug || c.name === idOrSlug
+  );
+}
+
+// src/live-config.ts
+function defineBetterCMSLive(config) {
+  const base = config.apiUrl.replace(/\/+$/, "");
+  const liveSrc = `${base}/api/v1/delivery/${config.workspace}/live?key=${encodeURIComponent(config.apiKey)}`;
+  return { liveSrc };
+}
+
+// src/revalidate-route.ts
+import { createHmac, timingSafeEqual } from "crypto";
+function safeEqual(a, b) {
+  const ab = Buffer.from(a);
+  const bb = Buffer.from(b);
+  return ab.length === bb.length && timingSafeEqual(ab, bb);
+}
+function createRevalidateRoute(config = {}) {
+  async function POST(request) {
+    const body = await request.text();
+    if (config.secret) {
+      const provided = request.headers.get("x-bettercms-signature") ?? "";
+      const expected = `sha256=${createHmac("sha256", config.secret).update(body).digest("hex")}`;
+      if (!safeEqual(provided, expected)) {
+        return new Response("Invalid signature", { status: 401 });
+      }
+    }
+    let payload;
+    try {
+      payload = JSON.parse(body);
+    } catch {
+      return new Response("Invalid JSON", { status: 400 });
+    }
+    const tags = payload.data?.tags ?? [];
+    const { revalidateTag } = await import("next/cache");
+    for (const tag of tags) revalidateTag(tag);
+    return Response.json({ revalidated: true, tags });
+  }
+  return { POST };
+}
+export {
+  BetterCMSError,
+  DEFAULT_SNAPSHOT_FILE,
+  PREVIEW_TOKEN_COOKIE,
+  SNAPSHOT_VERSION,
+  buildMetadata,
+  buildSnapshot,
+  createBetterCMS,
+  createDisableDraftRoute,
+  createDraftModeRoute,
+  createRevalidateRoute,
+  defineBetterCMSLive,
+  fetchModels,
+  generateLlmsTxt,
+  getComponent,
+  getContent,
+  getForm,
+  getPage,
+  getPreviewToken,
+  imageUrl,
+  default2 as imageUrlBuilder,
+  isDraftEnabled,
+  llmsTxtRoute,
+  parseSnapshot,
+  readComponents,
+  readForms,
+  readPages,
+  readSnapshot,
+  resolveSeo2 as resolveSeo,
+  serializeSnapshot,
+  writeSnapshot
+};
+//# sourceMappingURL=index.js.map