@backmatter/core 0.0.6

package/src/node/cli.ts

@@ -0,0 +1,505 @@
+#!/usr/bin/env bun
+// packages/core/src/node/cli.ts
+import { existsSync } from "node:fs";
+import { appendFile, mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import {
+  frontmatterJsonSchema,
+  serializeModel,
+  serializeBlock,
+  validateContentTree,
+  type ContentFileResult,
+  type ModelDef,
+  type ModelSnapshot,
+} from "../index";
+import { resolveConfig, type BackmatterConfig, type ResolvedConfig } from "../config";
+import { discoverModels, discoverBlocks } from "./discover";
+import { walkContentFiles } from "./fs-loader";
+import { detectSdk, findConfigFile, generate, type GenerateResult } from "./generate";
+
+export type CliArgs = {
+  command?: string;
+  root: string;
+  /** Optional barrel module exporting `models`; default is folder discovery. */
+  models?: string;
+  out: string;
+  json: boolean;
+};
+
+const USAGE = `Usage:
+  backmatter init                          scaffold backmatter.config.ts, the catch-all route and .backmatter/
+  backmatter generate  [--root <dir>]      write .backmatter/index.ts (typed cms), blocks.ts, mdx.ts and layouts.ts
+  backmatter validate  [--root <dir>] [--models <file>] [--json]
+  backmatter schema    [--root <dir>] [--models <file>] [--out <dir>]
+
+Defaults: --root .  --out .backmatter/schemas
+Models are discovered from models/*.ts (one \`export default defineModel(...)\` per
+file, file name = model type). Pass --models <file> to use a module that exports
+\`models\` instead. Importing your code sets BACKMATTER_CLI=1 so createBackmatter never
+syncs the schema from the CLI.`;
+
+export function parseArgs(argv: string[]): CliArgs {
+  const args: CliArgs = {
+    command: undefined,
+    root: ".",
+    models: undefined,
+    out: ".backmatter/schemas",
+    json: false,
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]!;
+    if (arg === "--root") {
+      const value = argv[++i];
+      if (value === undefined || value.startsWith("--")) {
+        throw new Error("usage: missing value for --root");
+      }
+      args.root = value;
+    } else if (arg === "--models") {
+      const value = argv[++i];
+      if (value === undefined || value.startsWith("--")) {
+        throw new Error("usage: missing value for --models");
+      }
+      args.models = value;
+    } else if (arg === "--out") {
+      const value = argv[++i];
+      if (value === undefined || value.startsWith("--")) {
+        throw new Error("usage: missing value for --out");
+      }
+      args.out = value;
+    } else if (arg === "--json") {
+      args.json = true;
+    } else if (arg.startsWith("--")) {
+      throw new Error(`usage: unknown flag ${arg}`);
+    } else if (args.command === undefined) {
+      args.command = arg;
+    } else {
+      throw new Error("usage: unexpected positional argument");
+    }
+  }
+  return args;
+}
+
+/** Run `fn` with BACKMATTER_CLI=1 so imported host code never syncs the schema. */
+async function withCliFlag<T>(fn: () => Promise<T>): Promise<T> {
+  const prevCli = process.env.BACKMATTER_CLI;
+  process.env.BACKMATTER_CLI = "1";
+  try {
+    return await fn();
+  } finally {
+    if (prevCli === undefined) delete process.env.BACKMATTER_CLI;
+    else process.env.BACKMATTER_CLI = prevCli;
+  }
+}
+
+/** Import `backmatter.config.ts` (default export) when present; `{}` otherwise. */
+export async function loadConfig(root: string): Promise<ResolvedConfig> {
+  const file = findConfigFile(root);
+  if (!file) return resolveConfig({});
+  const mod = await withCliFlag(
+    () =>
+      import(/* webpackIgnore: true */ /* turbopackIgnore: true */ pathToFileURL(file).href) as Promise<{ default?: unknown; config?: unknown }>,
+  );
+  const candidate = mod.default ?? mod.config;
+  if (candidate !== undefined && (typeof candidate !== "object" || candidate === null)) {
+    throw new Error(`${path.basename(file)} must \`export default defineConfig({ ... })\``);
+  }
+  return resolveConfig((candidate ?? {}) as BackmatterConfig);
+}
+
+/**
+ * Models from the `models/` folder (default) or from an explicit barrel module
+ * that exports `models` / a default array.
+ */
+export async function loadModels(root: string, modelsPath?: string): Promise<ModelDef[]> {
+  if (modelsPath === undefined) {
+    const config = await loadConfig(root);
+    return withCliFlag(() => discoverModels(root, config.dirs.models));
+  }
+  const full = path.resolve(root, modelsPath);
+  const mod = await withCliFlag(
+    () =>
+      import(/* webpackIgnore: true */ /* turbopackIgnore: true */ pathToFileURL(full).href) as Promise<{ models?: unknown; default?: unknown }>,
+  );
+  const candidate = mod.models ?? mod.default;
+  if (!Array.isArray(candidate)) {
+    throw new Error(
+      `${modelsPath} must export \`models\` (array of defineModel results) or a default array`,
+    );
+  }
+  return candidate as ModelDef[];
+}
+
+/**
+ * Static directory roots the models' path templates live under, e.g.
+ * `content/{locale}/blog/{slug}.mdx` → `content`. Roots that are sub-paths of
+ * another root are dropped; a template with no static leading segment yields ".".
+ */
+export function contentRoots(models: ModelSnapshot[]): string[] {
+  const candidates = new Set<string>();
+  for (const model of models) {
+    const segments = model.path.split("/").slice(0, -1); // drop the filename segment
+    const leading: string[] = [];
+    for (const segment of segments) {
+      if (segment.includes("{")) break;
+      leading.push(segment);
+    }
+    candidates.add(leading.length > 0 ? leading.join("/") : ".");
+  }
+  const list = [...candidates];
+  return list
+    .filter(
+      (root) =>
+        !list.some(
+          (other) =>
+            other !== root && (other === "." || root.startsWith(`${other}/`)),
+        ),
+    )
+    .sort();
+}
+
+export async function runValidate(
+  args: CliArgs,
+): Promise<{ results: ContentFileResult[]; roots: string[]; exitCode: 0 | 1 }> {
+  const root = path.resolve(args.root);
+  const models = (await loadModels(root, args.models)).map(serializeModel);
+  const config = await loadConfig(root);
+  let catalog: ReturnType<typeof serializeBlock>[] = [];
+  try {
+    const defs = await discoverBlocks(root, config.dirs.blocks);
+    catalog = defs.map((d) => serializeBlock(d as never));
+  } catch {
+    catalog = [];
+  }
+  const roots = contentRoots(models);
+  const files: string[] = [];
+  for (const contentRoot of roots) {
+    const dir = path.join(root, contentRoot);
+    const info = await stat(dir).catch(() => null);
+    if (!info?.isDirectory()) continue; // missing roots are simply skipped
+    files.push(...(await walkContentFiles(dir)));
+  }
+  files.sort();
+  const inputs = await Promise.all(
+    files.map(async (full) => ({
+      path: path.relative(root, full).split(path.sep).join("/"),
+      raw: await readFile(full, "utf-8"),
+    })),
+  );
+  const results = validateContentTree({ models, files: inputs, catalog });
+  return { results, roots, exitCode: results.some((r) => !r.ok) ? 1 : 0 };
+}
+
+export function formatResults(results: ContentFileResult[]): string[] {
+  const lines: string[] = [];
+  for (const r of results) {
+    if (!r.ok) {
+      for (const err of r.errors) lines.push(`${r.path}: ${err}`);
+    } else if ("skipped" in r) {
+      lines.push(`${r.path}: no matching model (skipped)`);
+    }
+  }
+  return lines;
+}
+
+export async function runSchema(args: CliArgs): Promise<string[]> {
+  const root = path.resolve(args.root);
+  const models = (await loadModels(root, args.models)).map(serializeModel);
+  const outDir = path.resolve(root, args.out);
+  await mkdir(outDir, { recursive: true });
+  const written: string[] = [];
+  for (const model of models) {
+    const file = path.join(outDir, `${model.type}.json`);
+    await writeFile(file, `${JSON.stringify(frontmatterJsonSchema(model), null, 2)}\n`);
+    written.push(path.relative(root, file).split(path.sep).join("/"));
+  }
+  return written;
+}
+
+export async function runGenerate(args: CliArgs): Promise<GenerateResult> {
+  const root = path.resolve(args.root);
+  // Codegen must not depend on the host's dependencies being installed yet
+  // (e.g. right after `init`); fall back to default folders if the config
+  // cannot be imported.
+  let config: ResolvedConfig;
+  try {
+    config = await loadConfig(root);
+  } catch (err) {
+    console.error(
+      `backmatter: could not load backmatter.config (${err instanceof Error ? err.message : String(err)}); using default folders`,
+    );
+    config = resolveConfig({});
+  }
+  return generate({
+    root,
+    modelsDir: config.dirs.models,
+    blocksDir: config.dirs.blocks,
+    mdxDir: config.dirs.mdx,
+    layoutsDir: config.dirs.layouts,
+  });
+}
+
+const CATCH_ALL_DIR = "[[...backmatter]]";
+
+function renderConfigFile(sdk: string): string {
+  const from = sdk === "@backmatter/next" ? "@backmatter/next" : "@backmatter/core";
+  return `// backmatter.config.ts
+import { defineConfig } from "${from}";
+
+// General settings only. Models live in models/*.ts, composer blocks in
+// blocks/*.tsx, MDX tags in mdx/*.tsx, and content in
+// content/{locale}/{type}/{slug}.{mdx,json} — all discovered automatically.
+// workspaceId / apiUrl / tokens fall back to BACKMATTER_* env vars when omitted.
+export default defineConfig({
+  defaultLocale: "en",
+});
+`;
+}
+
+function renderCatchAllPage(registryImport: string): string {
+  return `// ${CATCH_ALL_DIR}/page.tsx — mounts every model at its route, including / via indexSlug.
+import { createCatchAll } from "@backmatter/next/routes";
+import { cms } from "${registryImport}";
+import { components } from "${registryImport}/mdx";
+import { blockLoaders } from "${registryImport}/blocks";
+import { blockFallbacks } from "${registryImport}/block-fallbacks";
+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;
+`;
+}
+
+function renderInstrumentation(syncImport: string): string {
+  return `// instrumentation.ts — schema sync on Node. Next also runs register() on Edge;
+// do not import .backmatter/sync there (it pulls Node APIs).
+export async function register() {
+  if (process.env.NEXT_RUNTIME === "nodejs") {
+    await import("${syncImport}");
+  }
+}
+`;
+}
+
+export function warnMissingInstrumentation(root: string): void {
+  if (detectSdk(root) !== "@backmatter/next") return;
+  const hasRoot = existsSync(path.join(root, "instrumentation.ts"));
+  const hasSrc = existsSync(path.join(root, "src", "instrumentation.ts"));
+  if (!hasRoot && !hasSrc) {
+    console.warn(
+      "backmatter: add instrumentation.ts that imports .backmatter/sync — block schema sync will not run without it",
+    );
+  }
+}
+
+function renderPreviewRoute(registryImport: string): string {
+  return `// api/backmatter/preview/route.ts — preview session enable / disable / stream / session.
+import { createPreviewRoute } from "@backmatter/next/preview-route";
+import { cms } from "${registryImport}";
+
+export const { GET, POST } = createPreviewRoute(cms);
+`;
+}
+
+function renderProxy(): string {
+  return `// proxy.ts — preview session (draft cookie, noindex, ticket entry).
+// Next 16: \`config\` must be declared in this file, not re-exported.
+export { proxy } from "@backmatter/next/proxy";
+
+export const config = {
+  matcher: [
+    "/((?!_next/static|_next/image|favicon.ico|.*\\\\.(?:svg|png|jpg|jpeg|gif|webp|ico|css|js)$).*)",
+  ],
+};
+`;
+}
+
+function renderRevalidateRoute(registryImport: string): string {
+  return `// api/backmatter/revalidate/route.ts — content.committed from the BACKMATTER server.
+import { createRevalidateRoute } from "@backmatter/next/revalidate";
+import { cms } from "${registryImport}";
+
+export const POST = createRevalidateRoute(cms);
+`;
+}
+
+export async function runInit(args: CliArgs): Promise<string[]> {
+  const root = path.resolve(args.root);
+  const sdk = detectSdk(root);
+  const notes: string[] = [];
+
+  if (!findConfigFile(root)) {
+    await writeFile(path.join(root, "backmatter.config.ts"), renderConfigFile(sdk));
+    notes.push("wrote backmatter.config.ts");
+  } else {
+    notes.push("kept existing backmatter.config.*");
+  }
+
+  const gitignore = path.join(root, ".gitignore");
+  const current = existsSync(gitignore) ? await readFile(gitignore, "utf-8") : "";
+  if (!current.split("\n").some((line) => line.trim() === ".backmatter/" || line.trim() === ".backmatter")) {
+    const prefix = current.length && !current.endsWith("\n") ? "\n" : "";
+    await appendFile(gitignore, `${prefix}# backmatter generated registry\n.backmatter/\n`);
+    notes.push("added .backmatter/ to .gitignore");
+  }
+
+  if (sdk === "@backmatter/next") {
+    const appDir = existsSync(path.join(root, "src", "app")) ? path.join("src", "app") : "app";
+    const pageDir = path.join(root, appDir, CATCH_ALL_DIR);
+    const page = path.join(pageDir, "page.tsx");
+    const requiredCatchAll = path.join(root, appDir, "[...backmatter]", "page.tsx");
+    if (existsSync(page)) {
+      notes.push(`kept existing ${path.join(appDir, CATCH_ALL_DIR, "page.tsx")}`);
+    } else if (existsSync(requiredCatchAll)) {
+      notes.push(`kept existing ${path.join(appDir, "[...backmatter]", "page.tsx")}`);
+    } else {
+      const registry = path.relative(pageDir, path.join(root, ".backmatter")).split(path.sep).join("/");
+      await mkdir(pageDir, { recursive: true });
+      await writeFile(page, renderCatchAllPage(registry.startsWith(".") ? registry : `./${registry}`));
+      notes.push(`wrote ${path.join(appDir, CATCH_ALL_DIR, "page.tsx")}`);
+    }
+
+    const revalidateDir = path.join(root, appDir, "api", "backmatter", "revalidate");
+    const revalidateFile = path.join(revalidateDir, "route.ts");
+    if (!existsSync(revalidateFile)) {
+      const registry = path.relative(revalidateDir, path.join(root, ".backmatter")).split(path.sep).join("/");
+      await mkdir(revalidateDir, { recursive: true });
+      await writeFile(
+        revalidateFile,
+        renderRevalidateRoute(registry.startsWith(".") ? registry : `./${registry}`),
+      );
+      notes.push(`wrote ${path.join(appDir, "api/backmatter/revalidate/route.ts")}`);
+    } else {
+      notes.push(`kept existing ${path.join(appDir, "api/backmatter/revalidate/route.ts")}`);
+    }
+
+    const previewDir = path.join(root, appDir, "api", "backmatter", "preview");
+    const previewFile = path.join(previewDir, "route.ts");
+    if (!existsSync(previewFile)) {
+      const registry = path.relative(previewDir, path.join(root, ".backmatter")).split(path.sep).join("/");
+      await mkdir(previewDir, { recursive: true });
+      await writeFile(
+        previewFile,
+        renderPreviewRoute(registry.startsWith(".") ? registry : `./${registry}`),
+      );
+      notes.push(`wrote ${path.join(appDir, "api/backmatter/preview/route.ts")}`);
+    } else {
+      notes.push(`kept existing ${path.join(appDir, "api/backmatter/preview/route.ts")}`);
+    }
+
+    const proxyFile = path.join(root, "proxy.ts");
+    const srcProxy = path.join(root, "src", "proxy.ts");
+    const middlewareFile = path.join(root, "middleware.ts");
+    const srcMiddleware = path.join(root, "src", "middleware.ts");
+    const existingProxy = existsSync(proxyFile)
+      ? proxyFile
+      : existsSync(srcProxy)
+        ? srcProxy
+        : existsSync(middlewareFile)
+          ? middlewareFile
+          : existsSync(srcMiddleware)
+            ? srcMiddleware
+            : null;
+    if (!existingProxy) {
+      const dest = existsSync(path.join(root, "src", "app")) ? srcProxy : proxyFile;
+      await writeFile(dest, renderProxy());
+      notes.push(`wrote ${path.relative(root, dest)}`);
+    } else {
+      notes.push(`kept existing ${path.relative(root, existingProxy)}`);
+    }
+
+    const rootInstrumentation = path.join(root, "instrumentation.ts");
+    const srcInstrumentation = path.join(root, "src", "instrumentation.ts");
+    const usesSrcApp = existsSync(path.join(root, "src", "app"));
+    if (existsSync(rootInstrumentation) || existsSync(srcInstrumentation)) {
+      notes.push("kept existing instrumentation.ts");
+    } else {
+      const dest = usesSrcApp ? srcInstrumentation : rootInstrumentation;
+      const syncImport = usesSrcApp ? "../.backmatter/sync" : "./.backmatter/sync";
+      await writeFile(dest, renderInstrumentation(syncImport));
+      notes.push(`wrote ${path.relative(root, dest)}`);
+    }
+  } else {
+    notes.push("no @backmatter/next dependency: skipped the catch-all route");
+  }
+
+  for (const dir of ["models", "content", "blocks", "mdx", "layouts"]) {
+    await mkdir(path.join(root, dir), { recursive: true });
+  }
+
+  const result = await runGenerate(args);
+  notes.push(...result.files.map((f) => `wrote ${f}`));
+  return notes;
+}
+
+async function main(argv: string[]): Promise<number> {
+  let args: CliArgs;
+  try {
+    args = parseArgs(argv);
+  } catch (err) {
+    if (err instanceof Error && err.message.startsWith("usage:")) {
+      console.error(err.message);
+      console.error(USAGE);
+      return 2;
+    }
+    console.error(`backmatter: ${err instanceof Error ? err.message : String(err)}`);
+    return 2;
+  }
+  try {
+    if (args.command === "validate") {
+      const { results, roots, exitCode } = await runValidate(args);
+      if (results.length === 0) {
+        console.error(
+          `backmatter: no .mdx or .json files found under ${roots.join(", ")} (check --root)`,
+        );
+      }
+      if (args.json) {
+        console.log(JSON.stringify(results, null, 2));
+      } else {
+        for (const line of formatResults(results)) console.log(line);
+        const checked = results.filter((r) => !("skipped" in r)).length;
+        console.log(
+          exitCode === 0
+            ? `backmatter: ${checked} document(s) valid`
+            : `backmatter: validation failed`,
+        );
+      }
+      return exitCode;
+    }
+    if (args.command === "schema") {
+      const written = await runSchema(args);
+      for (const file of written) console.log(`wrote ${file}`);
+      return 0;
+    }
+    if (args.command === "generate") {
+      const result = await runGenerate(args);
+      for (const file of result.files) {
+        console.log(`${result.changed.includes(file) ? "wrote" : "unchanged"} ${file}`);
+      }
+      for (const skipped of result.skippedBlocks) {
+        console.error(`backmatter: skipped ${skipped} (block file names must be PascalCase)`);
+      }
+      for (const skipped of result.skippedMdx) {
+        console.error(`backmatter: skipped ${skipped} (MDX file names must be PascalCase)`);
+      }
+      warnMissingInstrumentation(path.resolve(args.root));
+      return 0;
+    }
+    if (args.command === "init") {
+      for (const note of await runInit(args)) console.log(note);
+      return 0;
+    }
+    console.error(USAGE);
+    return 2;
+  } catch (err) {
+    console.error(`backmatter: ${err instanceof Error ? err.message : String(err)}`);
+    return 2;
+  }
+}
+
+if (import.meta.main) {
+  main(process.argv.slice(2)).then((code) => process.exit(code));
+}

package/src/node/create-backmatter.ts

@@ -0,0 +1,130 @@
+// packages/core/src/node/create-backmatter.ts
+import type { ModelDef, ModelSnapshot } from "../model";
+import type { BlockDef } from "../block";
+import { getDocFromApi, listDocsFromApi } from "../api-loader";
+import { getDocFromFs, listDocsFromFs } from "./fs-loader";
+import { createQuery, type DocLoader, type Query } from "../query";
+import { syncSchema } from "../sync-schema";
+import type { BackmatterDoc, BackmatterDocSummary } from "../doc";
+import { resolveConfig, type BackmatterConfig, type ResolvedConfig } from "../config";
+import { contentCacheTags, listCacheTags } from "../content-committed";
+
+/**
+ * `BackmatterConfig` (usually spread from `backmatter.config.ts`) plus the discovered
+ * models. Unset fields fall back to `BACKMATTER_*` env vars.
+ */
+export type CreateBackmatterOptions<Models extends readonly ModelDef[] = readonly ModelDef[]> =
+  BackmatterConfig & {
+    models: Models;
+    blocks?: readonly BlockDef[];
+    /**
+     * When true, API fetches use Next cache tags instead of `cache: "no-store"`.
+     * `@backmatter/next` turns this on.
+     */
+    taggedApiFetch?: boolean;
+  };
+
+export type BackmatterClient<Models extends readonly ModelDef[] = readonly ModelDef[]> = {
+  listDocs: (filter?: {
+    type?: string;
+    locale?: string;
+  }) => Promise<BackmatterDocSummary[]>;
+  getDoc: (
+    locale: string,
+    type: string,
+    slug: string,
+  ) => Promise<BackmatterDoc | null>;
+  /** Typed access keyed by model.type: cms.query.blog.get / findMany */
+  query: Query<Models>;
+  /** The registered models, e.g. for route matching. */
+  models: Models;
+  /** Effective config after env fallbacks. */
+  config: ResolvedConfig;
+};
+
+function toSnapshots(models: readonly ModelDef[]): ModelSnapshot[] {
+  return models.map((m) => {
+    const snapshot: ModelSnapshot = {
+      type: m.type,
+      path: m.path,
+      fields: m.fields as ModelSnapshot["fields"],
+    };
+    if (m.route !== undefined) snapshot.route = m.route;
+    if (m.format === "page") snapshot.format = "page";
+    if (m.indexSlug !== undefined) snapshot.indexSlug = m.indexSlug;
+    return snapshot;
+  });
+}
+
+export function createBackmatter<const Models extends readonly ModelDef[]>(
+  options: CreateBackmatterOptions<Models>,
+): BackmatterClient<Models> {
+  const { models: modelDefs, blocks: blockDefs, taggedApiFetch, ...rest } = options;
+  const config = resolveConfig(rest);
+  const models = toSnapshots(modelDefs);
+  const siteRoot = config.siteRoot ?? process.cwd();
+  const useApi = Boolean(config.apiUrl && config.workspaceId);
+  const { workspaceId, apiUrl, contentToken, hostToken, branch, siteUrl } = config;
+
+  if (apiUrl && !workspaceId) {
+    throw new Error(
+      "backmatter: workspaceId is required when apiUrl is set (backmatter.config.ts or BACKMATTER_WORKSPACE_ID)",
+    );
+  }
+
+  // backmatter CLI imports the config to read models; never sync from there.
+  if (apiUrl && hostToken && workspaceId) {
+    if (process.env.BACKMATTER_CLI === "1") {
+      console.warn("backmatter: schema sync skipped (BACKMATTER_CLI=1)");
+    } else {
+      void syncSchema({
+        apiUrl,
+        workspaceId,
+        hostToken,
+        models: [...modelDefs],
+        blocks: blockDefs ? [...blockDefs] : undefined,
+        branch: config.branch,
+        siteUrl,
+      }).catch((err) => {
+        console.error("backmatter schema sync failed", err);
+      });
+    }
+  }
+
+  const loader: DocLoader = {
+    async listDocs(filter) {
+      const docs = useApi
+        ? await listDocsFromApi(apiUrl!, workspaceId!, contentToken, {
+            branch,
+            type: filter?.type,
+            locale: filter?.locale,
+            tags: taggedApiFetch ? listCacheTags(filter?.type) : undefined,
+          })
+        : await listDocsFromFs(siteRoot, models);
+
+      return docs.filter((d) => {
+        if (filter?.type && d.type !== filter.type) return false;
+        if (filter?.locale && d.locale !== filter.locale) return false;
+        return true;
+      });
+    },
+
+    async getDoc(locale, type, slug) {
+      if (useApi) {
+        return getDocFromApi(apiUrl!, workspaceId!, contentToken, locale, type, slug, {
+          branch,
+          tags: taggedApiFetch ? contentCacheTags(locale, type, slug) : undefined,
+        });
+      }
+      return getDocFromFs(siteRoot, models, locale, type, slug);
+    },
+  };
+
+  return {
+    listDocs: loader.listDocs,
+    getDoc: loader.getDoc,
+    query: createQuery(modelDefs, loader),
+    models: modelDefs,
+    config,
+  };
+}