@backmatter/core 0.0.9 → 0.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@backmatter/core",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "Experimental Backmatter SDK. APIs will break. Not ready for production.",
   "type": "module",
   "publishConfig": {

package/src/doc.ts

@@ -4,6 +4,8 @@ export type BackmatterDocSummary = {
   locale: string;
   type: string;
   slug: string;
+  /** Card-level fields when the loader already parsed the file. */
+  frontmatter?: Record<string, unknown>;
 };
 
 export type BackmatterDoc = {

package/src/node/cli.ts

@@ -260,6 +260,7 @@ export default defineConfig({
 
 function renderCatchAllPage(registryImport: string): string {
   return `// ${CATCH_ALL_DIR}/page.tsx — mounts every model at its route, including / via indexSlug.
+import { cacheLife } from "next/cache";
 import { createCatchAll } from "@backmatter/next/routes";
 import { cms } from "${registryImport}";
 import { components } from "${registryImport}/mdx";
@@ -270,8 +271,30 @@ import { layouts } from "${registryImport}/layouts";
 const route = createCatchAll(cms, { components, blocks: blockLoaders, fallbacks: blockFallbacks, layouts });
 
 export const generateStaticParams = route.generateStaticParams;
-export const generateMetadata = route.generateMetadata;
-export default route.Page;
+
+async function cachedParams<T extends { backmatter?: string[] }>(
+  params: Promise<T> | T,
+): Promise<T> {
+  "use cache";
+  cacheLife("hours");
+  return params;
+}
+
+export async function generateMetadata(props: {
+  params: Promise<{ backmatter?: string[] }>;
+}) {
+  return route.generateMetadata({ params: cachedParams(props.params) });
+}
+
+export default async function Page(props: {
+  params: Promise<{ backmatter?: string[] }>;
+  searchParams?: Promise<Record<string, string | string[] | undefined>>;
+}) {
+  return route.Page({
+    params: cachedParams(props.params),
+    searchParams: props.searchParams,
+  });
+}
 `;
 }
 

package/src/node/fs-loader.ts

@@ -53,10 +53,20 @@ export async function listDocsFromFs(
     const rel = path.relative(siteRoot, full).split(path.sep).join("/");
     const hit = matchAnyModelPath(models, rel);
     if (!hit) continue;
+    const model = models.find((m) => m.type === hit.type);
+    let frontmatter: Record<string, unknown> | undefined;
+    if (model) {
+      try {
+        frontmatter = parseDoc(await readFile(full, "utf-8"), modelFormat(model)).frontmatter;
+      } catch {
+        frontmatter = undefined;
+      }
+    }
     docs.push({
       locale: hit.locale,
       type: hit.type,
       slug: hit.slug,
+      frontmatter,
     });
   }
   return docs.sort((a, b) => {

package/src/node/generate.ts

@@ -93,13 +93,46 @@ export function detectSdk(root: string): string {
   return "@backmatter/core/node";
 }
 
+function renderCachedCmsClient(): string[] {
+  return [
+    "const raw = createBackmatter({ ...config, models });",
+    "",
+    "async function getDoc(locale: string, type: string, slug: string) {",
+    '  "use cache";',
+    '  cacheLife("hours");',
+    "  cacheTag(...contentCacheTags(locale, type, slug));",
+    "  return raw.getDoc(locale, type, slug);",
+    "}",
+    "",
+    "async function listDocs(filter?: { type?: string; locale?: string }) {",
+    '  "use cache";',
+    '  cacheLife("hours");',
+    "  cacheTag(...listCacheTags(filter?.type));",
+    "  return raw.listDocs(filter);",
+    "}",
+    "",
+    "/** Typed content client: cms.query.{type}, cms.getDoc, cms.listDocs. */",
+    "export const cms = {",
+    "  ...raw,",
+    "  getDoc,",
+    "  listDocs,",
+    `  query: createQuery(models, { getDoc, listDocs }),`,
+    "};",
+  ];
+}
+
 export function renderModelsBarrel(input: {
   outDir: string;
   models: ModelFile[];
   configFile: string | null;
   sdk: string;
 }): string {
+  const nextHost = input.sdk === "@backmatter/next";
   const lines = [GENERATED_HEADER, `import { createBackmatter } from "${input.sdk}";`];
+  if (nextHost) {
+    lines.push('import { contentCacheTags, createQuery, listCacheTags } from "@backmatter/core";');
+    lines.push('import { cacheLife, cacheTag } from "next/cache";');
+  }
   if (input.configFile) {
     lines.push(`import config from "${importSpecifier(input.outDir, input.configFile)}";`);
   } else {
@@ -112,8 +145,12 @@ export function renderModelsBarrel(input: {
   lines.push(`export const models = [${input.models.map((m) => m.importName).join(", ")}] as const;`);
   lines.push("export type Models = typeof models;");
   lines.push("");
-  lines.push("/** Typed content client: cms.query.{type}, cms.getDoc, cms.listDocs. */");
-  lines.push("export const cms = createBackmatter({ ...config, models });");
+  if (nextHost) {
+    lines.push(...renderCachedCmsClient());
+  } else {
+    lines.push("/** Typed content client: cms.query.{type}, cms.getDoc, cms.listDocs. */");
+    lines.push("export const cms = createBackmatter({ ...config, models });");
+  }
   return `${lines.join("\n")}\n`;
 }
 

package/src/query.ts

@@ -103,8 +103,21 @@ export function createQuery<const Models extends readonly ModelDef[]>(
       docs = doc ? [doc] : [];
     } else {
       const summaries = await loader.listDocs({ type, locale: opts?.locale });
-      const loaded = await Promise.all(summaries.map((s) => get(type, s.locale, s.slug)));
-      docs = loaded.filter((d): d is BackmatterDoc => d !== null);
+      const fromList = summaries.filter((s) => s.frontmatter != null);
+      const missing = summaries.filter((s) => s.frontmatter == null);
+      const loaded = await Promise.all(missing.map((s) => get(type, s.locale, s.slug)));
+      docs = [
+        ...fromList.map((s) => ({
+          locale: s.locale,
+          type: s.type,
+          slug: s.slug,
+          source: "head" as const,
+          frontmatter: normalizeFrontmatter(s.frontmatter ?? {}),
+          body: "",
+          raw: "",
+        })),
+        ...loaded.filter((d): d is BackmatterDoc => d !== null),
+      ];
     }
 
     const filtered = opts?.where ? docs.filter((d) => matchesWhere(d, opts.where!)) : docs;