@contentrain/query 7.0.15 → 7.1.0

package/README.md

@@ -398,6 +398,55 @@ Behavior:
 | Caching | In-memory (embedded) | ETag-based HTTP cache + optional bundle preload |
 | Use case | SSG, build-time | SSR, client-side, serverless |
 
+## 🚀 Astro Content Layer
+
+`contentrain generate` gives application code a typed client. Astro would
+rather own the content itself, so pages can use `getCollection()`, `getEntry()`,
+`reference()` and render documents with `<Content />`. `@contentrain/query/astro`
+reads the same `.contentrain` files the generator reads — one project, one
+answer about what its content is.
+
+```ts
+// src/content.config.ts
+import { defineCollection, z } from 'astro:content'
+import { contentrainLoader } from '@contentrain/query/astro'
+
+export const collections = {
+  posts: defineCollection({
+    loader: contentrainLoader({ model: 'blog-post', locale: 'en' }),
+    schema: z.object({ title: z.string(), publishedAt: z.string() }).passthrough(),
+  }),
+  articles: defineCollection({ loader: contentrainLoader({ model: 'blog-article' }) }),
+}
+```
+
+```astro
+---
+import { getCollection, getEntry, render } from 'astro:content'
+const posts = await getCollection('posts')
+const article = await getEntry('articles', 'en/welcome-post')
+const { Content } = await render(article)
+---
+<ul>{posts.map((p) => <li>{p.data.title}</li>)}</ul>
+<Content />
+```
+
+| Model kind | Becomes |
+|---|---|
+| `collection` | One entry per record; `data.id` is the entry id |
+| `document` | One entry per file — frontmatter in `data`, markdown in `body`, rendered so `<Content />` works |
+| `dictionary` | One entry per key (`{ key, value }`) — a key is a semantic address, and a single blob would make `getEntry()` useless on it |
+| `singleton` | One entry, id `<model>` (or the locale) |
+
+`locale` picks one language; omit it on an i18n model and every supported locale
+loads with ids prefixed (`en/my-post`) — Astro ids are unique per collection, so
+without the prefix one language would overwrite the other. `root` points at the
+project holding `.contentrain` (default: `process.cwd()`).
+
+Astro is not a dependency, not even a peer: the loader is structurally what
+`defineCollection` accepts, so any Astro 5 version works and non-Astro consumers
+of this package carry nothing extra.
+
 ## CommonJS Usage
 
 Generated clients support CommonJS through `init()`:
@@ -450,6 +499,10 @@ CDN transport:
 
 - `@contentrain/query/cdn` — CDN client with `HttpTransport`, async query classes, `MediaAccessor`, `FormsClient`, `ConversationClient`
 
+Astro content layer:
+
+- `@contentrain/query/astro` — `contentrainLoader()` for `defineCollection({ loader })`
+
 ## 🧠 Design Constraints
 
 This package intentionally:

package/dist/astro/index.cjs

@@ -0,0 +1,142 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_frontmatter = require("../frontmatter-DSFLOTwS.cjs");
+let node_path = require("node:path");
+let node_url = require("node:url");
+//#region src/astro/loader.ts
+/**
+* A loader for one Contentrain model.
+*
+* ```ts
+* // src/content.config.ts
+* import { defineCollection } from 'astro:content'
+* import { contentrainLoader } from '@contentrain/query/astro'
+*
+* export const collections = {
+*   posts: defineCollection({ loader: contentrainLoader({ model: 'blog-post', locale: 'en' }) }),
+*   articles: defineCollection({ loader: contentrainLoader({ model: 'blog-article' }) }),
+* }
+* ```
+*
+* Each model kind maps to the shape Astro can actually use:
+* collection → one entry per record · document → one entry per file, markdown
+* in `body` (and rendered, so `<Content />` works) · dictionary → one entry per
+* key, because a single blob would make `getEntry()` useless · singleton → one
+* entry, id `<model>` or the locale.
+*/
+function contentrainLoader(options) {
+	const root = options.root ?? process.cwd();
+	let watching = false;
+	return {
+		name: `contentrain:${options.model}`,
+		async load(context) {
+			const manifest = await require_frontmatter.readProjectManifest(root);
+			const model = manifest.models.find((m) => m.id === options.model);
+			if (!model) {
+				const known = manifest.models.map((m) => m.id).join(", ") || "none";
+				throw new Error(`contentrainLoader: model "${options.model}" not found in ${(0, node_path.join)(root, ".contentrain", "models")}. Models here: ${known}.`);
+			}
+			const refs = manifest.contentFiles.filter((ref) => ref.modelId === model.id && (options.locale === void 0 || ref.locale === options.locale));
+			if (options.locale !== void 0 && refs.length === 0 && model.i18n) context.logger?.warn(`contentrainLoader: model "${model.id}" has no content for locale "${options.locale}" — collection is empty.`);
+			const prefixLocale = model.i18n === true && options.locale === void 0;
+			const entries = (await Promise.all(refs.map((ref) => entriesOf(ref, model, prefixLocale)))).flat();
+			const siteRoot = toPath(context.config?.root);
+			context.store.clear();
+			for (const entry of entries) {
+				const data = context.parseData ? await context.parseData({
+					id: entry.id,
+					data: entry.data,
+					filePath: entry.filePath
+				}) : entry.data;
+				const filePath = siteRoot === void 0 ? void 0 : (0, node_path.relative)(siteRoot, entry.filePath);
+				context.store.set({
+					id: entry.id,
+					data,
+					...filePath === void 0 || filePath.startsWith("..") || (0, node_path.isAbsolute)(filePath) ? {} : { filePath },
+					...entry.body === void 0 ? {} : { body: entry.body },
+					...context.generateDigest ? { digest: context.generateDigest(entry.data) } : {},
+					...entry.body !== void 0 && context.renderMarkdown ? { rendered: await context.renderMarkdown(entry.body) } : {}
+				});
+			}
+			context.logger?.info(`Loaded ${entries.length} ${model.kind} ${entries.length === 1 ? "entry" : "entries"} from ${model.id}`);
+			if (context.watcher && !watching) {
+				watching = true;
+				const paths = new Set(refs.map((ref) => ref.filePath));
+				for (const path of paths) context.watcher.add(path);
+				context.watcher.add((0, node_path.join)(root, ".contentrain", "models", `${model.id}.json`));
+				const reload = (path) => {
+					if (!paths.has(path) && !path.endsWith(`${model.id}.json`)) return;
+					this.load(context);
+				};
+				context.watcher.on("change", reload);
+				context.watcher.on("add", reload);
+				context.watcher.on("unlink", reload);
+			}
+		}
+	};
+}
+/** Astro hands `config.root` as a file URL; tests and other hosts may use a path. */
+function toPath(root) {
+	if (root === void 0) return void 0;
+	if (typeof root !== "string") return (0, node_url.fileURLToPath)(root);
+	return root.startsWith("file:") ? (0, node_url.fileURLToPath)(root) : root;
+}
+async function entriesOf(ref, model, prefixLocale) {
+	const prefix = prefixLocale && ref.locale ? `${ref.locale}/` : "";
+	const withLocale = (data) => ref.locale === null ? data : {
+		...data,
+		locale: ref.locale
+	};
+	switch (ref.kind) {
+		case "collection": {
+			const raw = await require_frontmatter.readJson(ref.filePath);
+			if (!raw) return [];
+			return Object.entries(raw).toSorted(([a], [b]) => a.localeCompare(b, "en")).map(([id, fields]) => ({
+				id: `${prefix}${id}`,
+				data: withLocale({
+					id,
+					...fields
+				}),
+				filePath: ref.filePath
+			}));
+		}
+		case "singleton": {
+			const raw = await require_frontmatter.readJson(ref.filePath);
+			if (!raw) return [];
+			return [{
+				id: prefix ? `${ref.locale}` : model.id,
+				data: withLocale(raw),
+				filePath: ref.filePath
+			}];
+		}
+		case "dictionary": {
+			const raw = await require_frontmatter.readJson(ref.filePath);
+			if (!raw) return [];
+			return Object.entries(raw).toSorted(([a], [b]) => a.localeCompare(b, "en")).map(([key, value]) => ({
+				id: `${prefix}${key}`,
+				data: withLocale({
+					key,
+					value
+				}),
+				filePath: ref.filePath
+			}));
+		}
+		case "document": {
+			const text = await require_frontmatter.readText(ref.filePath);
+			if (text === null) return [];
+			const { frontmatter, body } = require_frontmatter.parseFrontmatter(text, require_frontmatter.stringLikeFieldKeys(model));
+			const slug = ref.slug ?? model.id;
+			return [{
+				id: `${prefix}${slug}`,
+				data: withLocale({
+					slug,
+					...frontmatter
+				}),
+				body,
+				filePath: ref.filePath
+			}];
+		}
+		default: return [];
+	}
+}
+//#endregion
+exports.contentrainLoader = contentrainLoader;

package/dist/astro/index.d.cts

@@ -0,0 +1,81 @@
+//#region src/astro/loader.d.ts
+/** The slice of Astro's `LoaderContext` this loader uses. */
+interface ContentrainLoaderContext {
+  store: {
+    clear: () => void;
+    set: (entry: {
+      id: string;
+      data: Record<string, unknown>;
+      body?: string;
+      digest?: string;
+      rendered?: {
+        html: string;
+        metadata?: Record<string, unknown>;
+      };
+      filePath?: string;
+    }) => void;
+  };
+  logger?: {
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+  };
+  /** Astro's resolved config; only `root` is read, to make file paths relative. */
+  config?: {
+    root?: URL | string;
+  };
+  generateDigest?: (data: unknown) => string;
+  parseData?: (entry: {
+    id: string;
+    data: Record<string, unknown>;
+    filePath?: string;
+  }) => Promise<Record<string, unknown>>;
+  renderMarkdown?: (content: string) => Promise<{
+    html: string;
+    metadata?: Record<string, unknown>;
+  }>;
+  watcher?: {
+    add: (path: string) => void;
+    on: (event: string, cb: (path: string) => void) => void;
+  };
+}
+/** Structurally Astro's `Loader`. */
+interface ContentrainLoader {
+  name: string;
+  load: (context: ContentrainLoaderContext) => Promise<void>;
+}
+interface ContentrainLoaderOptions {
+  /** Model id — the `id` in `.contentrain/models/<id>.json`. */
+  model: string;
+  /** Project root holding `.contentrain`. Default: `process.cwd()`. */
+  root?: string;
+  /**
+   * Load only this locale. Omitted on an i18n model, every supported locale is
+   * loaded and entry ids are prefixed (`en/my-post`) so the two languages of one
+   * post do not collide — Astro ids are unique per collection.
+   */
+  locale?: string;
+}
+/**
+ * A loader for one Contentrain model.
+ *
+ * ```ts
+ * // src/content.config.ts
+ * import { defineCollection } from 'astro:content'
+ * import { contentrainLoader } from '@contentrain/query/astro'
+ *
+ * export const collections = {
+ *   posts: defineCollection({ loader: contentrainLoader({ model: 'blog-post', locale: 'en' }) }),
+ *   articles: defineCollection({ loader: contentrainLoader({ model: 'blog-article' }) }),
+ * }
+ * ```
+ *
+ * Each model kind maps to the shape Astro can actually use:
+ * collection → one entry per record · document → one entry per file, markdown
+ * in `body` (and rendered, so `<Content />` works) · dictionary → one entry per
+ * key, because a single blob would make `getEntry()` useless · singleton → one
+ * entry, id `<model>` or the locale.
+ */
+declare function contentrainLoader(options: ContentrainLoaderOptions): ContentrainLoader;
+//#endregion
+export { type ContentrainLoader, type ContentrainLoaderContext, type ContentrainLoaderOptions, contentrainLoader };
+//# sourceMappingURL=index.d.cts.map

package/dist/astro/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/astro/loader.ts"],"mappings":";;UAsBiB,wBAAA;EACf,KAAA;IACE,KAAA;IACA,GAAA,GAAM,KAAA;MACJ,EAAA;MACA,IAAA,EAAM,MAAA;MACN,IAAA;MACA,MAAA;MACA,QAAA;QAAa,IAAA;QAAc,QAAA,GAAW,MAAA;MAAA;MACtC,QAAA;IAAA;EAAA;EAGJ,MAAA;IAAW,IAAA,GAAO,GAAA;IAAsB,IAAA,GAAO,GAAA;EAAA;EAN3C;EAQJ,MAAA;IAAW,IAAA,GAAO,GAAA;EAAA;EAClB,cAAA,IAAkB,IAAA;EAClB,SAAA,IAAa,KAAA;IAAS,EAAA;IAAY,IAAA,EAAM,MAAA;IAAyB,QAAA;EAAA,MAAwB,OAAA,CAAQ,MAAA;EACjG,cAAA,IAAkB,OAAA,aAAoB,OAAA;IAAU,IAAA;IAAc,QAAA,GAAW,MAAA;EAAA;EACzE,OAAA;IAAY,GAAA,GAAM,IAAA;IAAuB,EAAA,GAAK,KAAA,UAAe,EAAA,GAAK,IAAA;EAAA;AAAA;;UAInD,iBAAA;EACf,IAAA;EACA,IAAA,GAAO,OAAA,EAAS,wBAAA,KAA6B,OAAA;AAAA;AAAA,UAG9B,wBAAA;EAXkF;EAajG,KAAA;EAZkB;EAclB,IAAA;EAdgD;;;;;EAoBhD,MAAA;AAAA;;;;;;AAfF;;;;;;;;;;;AAKA;;;;iBAwCgB,iBAAA,CAAkB,OAAA,EAAS,wBAAA,GAA2B,iBAAA"}

package/dist/astro/index.d.mts

@@ -0,0 +1,81 @@
+//#region src/astro/loader.d.ts
+/** The slice of Astro's `LoaderContext` this loader uses. */
+interface ContentrainLoaderContext {
+  store: {
+    clear: () => void;
+    set: (entry: {
+      id: string;
+      data: Record<string, unknown>;
+      body?: string;
+      digest?: string;
+      rendered?: {
+        html: string;
+        metadata?: Record<string, unknown>;
+      };
+      filePath?: string;
+    }) => void;
+  };
+  logger?: {
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+  };
+  /** Astro's resolved config; only `root` is read, to make file paths relative. */
+  config?: {
+    root?: URL | string;
+  };
+  generateDigest?: (data: unknown) => string;
+  parseData?: (entry: {
+    id: string;
+    data: Record<string, unknown>;
+    filePath?: string;
+  }) => Promise<Record<string, unknown>>;
+  renderMarkdown?: (content: string) => Promise<{
+    html: string;
+    metadata?: Record<string, unknown>;
+  }>;
+  watcher?: {
+    add: (path: string) => void;
+    on: (event: string, cb: (path: string) => void) => void;
+  };
+}
+/** Structurally Astro's `Loader`. */
+interface ContentrainLoader {
+  name: string;
+  load: (context: ContentrainLoaderContext) => Promise<void>;
+}
+interface ContentrainLoaderOptions {
+  /** Model id — the `id` in `.contentrain/models/<id>.json`. */
+  model: string;
+  /** Project root holding `.contentrain`. Default: `process.cwd()`. */
+  root?: string;
+  /**
+   * Load only this locale. Omitted on an i18n model, every supported locale is
+   * loaded and entry ids are prefixed (`en/my-post`) so the two languages of one
+   * post do not collide — Astro ids are unique per collection.
+   */
+  locale?: string;
+}
+/**
+ * A loader for one Contentrain model.
+ *
+ * ```ts
+ * // src/content.config.ts
+ * import { defineCollection } from 'astro:content'
+ * import { contentrainLoader } from '@contentrain/query/astro'
+ *
+ * export const collections = {
+ *   posts: defineCollection({ loader: contentrainLoader({ model: 'blog-post', locale: 'en' }) }),
+ *   articles: defineCollection({ loader: contentrainLoader({ model: 'blog-article' }) }),
+ * }
+ * ```
+ *
+ * Each model kind maps to the shape Astro can actually use:
+ * collection → one entry per record · document → one entry per file, markdown
+ * in `body` (and rendered, so `<Content />` works) · dictionary → one entry per
+ * key, because a single blob would make `getEntry()` useless · singleton → one
+ * entry, id `<model>` or the locale.
+ */
+declare function contentrainLoader(options: ContentrainLoaderOptions): ContentrainLoader;
+//#endregion
+export { type ContentrainLoader, type ContentrainLoaderContext, type ContentrainLoaderOptions, contentrainLoader };
+//# sourceMappingURL=index.d.mts.map

package/dist/astro/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/astro/loader.ts"],"mappings":";;UAsBiB,wBAAA;EACf,KAAA;IACE,KAAA;IACA,GAAA,GAAM,KAAA;MACJ,EAAA;MACA,IAAA,EAAM,MAAA;MACN,IAAA;MACA,MAAA;MACA,QAAA;QAAa,IAAA;QAAc,QAAA,GAAW,MAAA;MAAA;MACtC,QAAA;IAAA;EAAA;EAGJ,MAAA;IAAW,IAAA,GAAO,GAAA;IAAsB,IAAA,GAAO,GAAA;EAAA;EAN3C;EAQJ,MAAA;IAAW,IAAA,GAAO,GAAA;EAAA;EAClB,cAAA,IAAkB,IAAA;EAClB,SAAA,IAAa,KAAA;IAAS,EAAA;IAAY,IAAA,EAAM,MAAA;IAAyB,QAAA;EAAA,MAAwB,OAAA,CAAQ,MAAA;EACjG,cAAA,IAAkB,OAAA,aAAoB,OAAA;IAAU,IAAA;IAAc,QAAA,GAAW,MAAA;EAAA;EACzE,OAAA;IAAY,GAAA,GAAM,IAAA;IAAuB,EAAA,GAAK,KAAA,UAAe,EAAA,GAAK,IAAA;EAAA;AAAA;;UAInD,iBAAA;EACf,IAAA;EACA,IAAA,GAAO,OAAA,EAAS,wBAAA,KAA6B,OAAA;AAAA;AAAA,UAG9B,wBAAA;EAXkF;EAajG,KAAA;EAZkB;EAclB,IAAA;EAdgD;;;;;EAoBhD,MAAA;AAAA;;;;;;AAfF;;;;;;;;;;;AAKA;;;;iBAwCgB,iBAAA,CAAkB,OAAA,EAAS,wBAAA,GAA2B,iBAAA"}

package/dist/astro/index.mjs

@@ -0,0 +1,143 @@
+import { a as readJson, n as stringLikeFieldKeys, o as readText, r as readProjectManifest, t as parseFrontmatter } from "../frontmatter-CVjPyhOq.mjs";
+import { isAbsolute, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/astro/loader.ts
+/**
+* A loader for one Contentrain model.
+*
+* ```ts
+* // src/content.config.ts
+* import { defineCollection } from 'astro:content'
+* import { contentrainLoader } from '@contentrain/query/astro'
+*
+* export const collections = {
+*   posts: defineCollection({ loader: contentrainLoader({ model: 'blog-post', locale: 'en' }) }),
+*   articles: defineCollection({ loader: contentrainLoader({ model: 'blog-article' }) }),
+* }
+* ```
+*
+* Each model kind maps to the shape Astro can actually use:
+* collection → one entry per record · document → one entry per file, markdown
+* in `body` (and rendered, so `<Content />` works) · dictionary → one entry per
+* key, because a single blob would make `getEntry()` useless · singleton → one
+* entry, id `<model>` or the locale.
+*/
+function contentrainLoader(options) {
+	const root = options.root ?? process.cwd();
+	let watching = false;
+	return {
+		name: `contentrain:${options.model}`,
+		async load(context) {
+			const manifest = await readProjectManifest(root);
+			const model = manifest.models.find((m) => m.id === options.model);
+			if (!model) {
+				const known = manifest.models.map((m) => m.id).join(", ") || "none";
+				throw new Error(`contentrainLoader: model "${options.model}" not found in ${join(root, ".contentrain", "models")}. Models here: ${known}.`);
+			}
+			const refs = manifest.contentFiles.filter((ref) => ref.modelId === model.id && (options.locale === void 0 || ref.locale === options.locale));
+			if (options.locale !== void 0 && refs.length === 0 && model.i18n) context.logger?.warn(`contentrainLoader: model "${model.id}" has no content for locale "${options.locale}" — collection is empty.`);
+			const prefixLocale = model.i18n === true && options.locale === void 0;
+			const entries = (await Promise.all(refs.map((ref) => entriesOf(ref, model, prefixLocale)))).flat();
+			const siteRoot = toPath(context.config?.root);
+			context.store.clear();
+			for (const entry of entries) {
+				const data = context.parseData ? await context.parseData({
+					id: entry.id,
+					data: entry.data,
+					filePath: entry.filePath
+				}) : entry.data;
+				const filePath = siteRoot === void 0 ? void 0 : relative(siteRoot, entry.filePath);
+				context.store.set({
+					id: entry.id,
+					data,
+					...filePath === void 0 || filePath.startsWith("..") || isAbsolute(filePath) ? {} : { filePath },
+					...entry.body === void 0 ? {} : { body: entry.body },
+					...context.generateDigest ? { digest: context.generateDigest(entry.data) } : {},
+					...entry.body !== void 0 && context.renderMarkdown ? { rendered: await context.renderMarkdown(entry.body) } : {}
+				});
+			}
+			context.logger?.info(`Loaded ${entries.length} ${model.kind} ${entries.length === 1 ? "entry" : "entries"} from ${model.id}`);
+			if (context.watcher && !watching) {
+				watching = true;
+				const paths = new Set(refs.map((ref) => ref.filePath));
+				for (const path of paths) context.watcher.add(path);
+				context.watcher.add(join(root, ".contentrain", "models", `${model.id}.json`));
+				const reload = (path) => {
+					if (!paths.has(path) && !path.endsWith(`${model.id}.json`)) return;
+					this.load(context);
+				};
+				context.watcher.on("change", reload);
+				context.watcher.on("add", reload);
+				context.watcher.on("unlink", reload);
+			}
+		}
+	};
+}
+/** Astro hands `config.root` as a file URL; tests and other hosts may use a path. */
+function toPath(root) {
+	if (root === void 0) return void 0;
+	if (typeof root !== "string") return fileURLToPath(root);
+	return root.startsWith("file:") ? fileURLToPath(root) : root;
+}
+async function entriesOf(ref, model, prefixLocale) {
+	const prefix = prefixLocale && ref.locale ? `${ref.locale}/` : "";
+	const withLocale = (data) => ref.locale === null ? data : {
+		...data,
+		locale: ref.locale
+	};
+	switch (ref.kind) {
+		case "collection": {
+			const raw = await readJson(ref.filePath);
+			if (!raw) return [];
+			return Object.entries(raw).toSorted(([a], [b]) => a.localeCompare(b, "en")).map(([id, fields]) => ({
+				id: `${prefix}${id}`,
+				data: withLocale({
+					id,
+					...fields
+				}),
+				filePath: ref.filePath
+			}));
+		}
+		case "singleton": {
+			const raw = await readJson(ref.filePath);
+			if (!raw) return [];
+			return [{
+				id: prefix ? `${ref.locale}` : model.id,
+				data: withLocale(raw),
+				filePath: ref.filePath
+			}];
+		}
+		case "dictionary": {
+			const raw = await readJson(ref.filePath);
+			if (!raw) return [];
+			return Object.entries(raw).toSorted(([a], [b]) => a.localeCompare(b, "en")).map(([key, value]) => ({
+				id: `${prefix}${key}`,
+				data: withLocale({
+					key,
+					value
+				}),
+				filePath: ref.filePath
+			}));
+		}
+		case "document": {
+			const text = await readText(ref.filePath);
+			if (text === null) return [];
+			const { frontmatter, body } = parseFrontmatter(text, stringLikeFieldKeys(model));
+			const slug = ref.slug ?? model.id;
+			return [{
+				id: `${prefix}${slug}`,
+				data: withLocale({
+					slug,
+					...frontmatter
+				}),
+				body,
+				filePath: ref.filePath
+			}];
+		}
+		default: return [];
+	}
+}
+//#endregion
+export { contentrainLoader };
+
+//# sourceMappingURL=index.mjs.map

package/dist/astro/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/astro/loader.ts"],"sourcesContent":["// Astro content-layer loader for a `.contentrain` project.\n//\n// `contentrain generate` produces a typed client for application code; Astro\n// wants its content in the content layer instead, so pages can query it with\n// `getCollection()` and render documents with `<Content />`. This loader reads\n// the same `.contentrain` files the generator reads — through the same manifest\n// — so a project never has two answers about what its content is.\n//\n// Astro is NOT a dependency here, not even a peer: the returned object is\n// structurally what `defineCollection({ loader })` accepts, and the context is\n// typed by the small surface this loader actually uses. That keeps\n// @contentrain/query dependency-free and usable from any Astro 5 version.\n\nimport type { ModelDefinition } from '@contentrain/types'\nimport { isAbsolute, join, relative } from 'node:path'\nimport { fileURLToPath } from 'node:url'\nimport type { ContentFileRef } from '../generator/config-reader.js'\nimport { readProjectManifest } from '../generator/config-reader.js'\nimport { readJson, readText } from '../generator/utils.js'\nimport { parseFrontmatter, stringLikeFieldKeys } from '../shared/frontmatter.js'\n\n/** The slice of Astro's `LoaderContext` this loader uses. */\nexport interface ContentrainLoaderContext {\n  store: {\n    clear: () => void\n    set: (entry: {\n      id: string\n      data: Record<string, unknown>\n      body?: string\n      digest?: string\n      rendered?: { html: string, metadata?: Record<string, unknown> }\n      filePath?: string\n    }) => void\n  }\n  logger?: { info: (msg: string) => void, warn: (msg: string) => void }\n  /** Astro's resolved config; only `root` is read, to make file paths relative. */\n  config?: { root?: URL | string }\n  generateDigest?: (data: unknown) => string\n  parseData?: (entry: { id: string, data: Record<string, unknown>, filePath?: string }) => Promise<Record<string, unknown>>\n  renderMarkdown?: (content: string) => Promise<{ html: string, metadata?: Record<string, unknown> }>\n  watcher?: { add: (path: string) => void, on: (event: string, cb: (path: string) => void) => void }\n}\n\n/** Structurally Astro's `Loader`. */\nexport interface ContentrainLoader {\n  name: string\n  load: (context: ContentrainLoaderContext) => Promise<void>\n}\n\nexport interface ContentrainLoaderOptions {\n  /** Model id — the `id` in `.contentrain/models/<id>.json`. */\n  model: string\n  /** Project root holding `.contentrain`. Default: `process.cwd()`. */\n  root?: string\n  /**\n   * Load only this locale. Omitted on an i18n model, every supported locale is\n   * loaded and entry ids are prefixed (`en/my-post`) so the two languages of one\n   * post do not collide — Astro ids are unique per collection.\n   */\n  locale?: string\n}\n\ninterface Entry {\n  id: string\n  data: Record<string, unknown>\n  body?: string\n  filePath: string\n}\n\n/**\n * A loader for one Contentrain model.\n *\n * ```ts\n * // src/content.config.ts\n * import { defineCollection } from 'astro:content'\n * import { contentrainLoader } from '@contentrain/query/astro'\n *\n * export const collections = {\n *   posts: defineCollection({ loader: contentrainLoader({ model: 'blog-post', locale: 'en' }) }),\n *   articles: defineCollection({ loader: contentrainLoader({ model: 'blog-article' }) }),\n * }\n * ```\n *\n * Each model kind maps to the shape Astro can actually use:\n * collection → one entry per record · document → one entry per file, markdown\n * in `body` (and rendered, so `<Content />` works) · dictionary → one entry per\n * key, because a single blob would make `getEntry()` useless · singleton → one\n * entry, id `<model>` or the locale.\n */\nexport function contentrainLoader(options: ContentrainLoaderOptions): ContentrainLoader {\n  const root = options.root ?? process.cwd()\n  let watching = false\n\n  return {\n    name: `contentrain:${options.model}`,\n    async load(context) {\n      const manifest = await readProjectManifest(root)\n      const model = manifest.models.find(m => m.id === options.model)\n      if (!model) {\n        const known = manifest.models.map(m => m.id).join(', ') || 'none'\n        throw new Error(\n          `contentrainLoader: model \"${options.model}\" not found in ${join(root, '.contentrain', 'models')}. Models here: ${known}.`,\n        )\n      }\n\n      const refs = manifest.contentFiles.filter(ref =>\n        ref.modelId === model.id && (options.locale === undefined || ref.locale === options.locale),\n      )\n      if (options.locale !== undefined && refs.length === 0 && model.i18n) {\n        context.logger?.warn(\n          `contentrainLoader: model \"${model.id}\" has no content for locale \"${options.locale}\" — collection is empty.`,\n        )\n      }\n      // Prefix ids only when one collection really holds several languages;\n      // a single-locale load keeps the natural id so routes stay clean.\n      const prefixLocale = model.i18n === true && options.locale === undefined\n\n      const perFile = await Promise.all(refs.map(ref => entriesOf(ref, model, prefixLocale)))\n      const entries = perFile.flat()\n      // Astro rejects an absolute filePath (\"must be relative to the site\n      // root\"), and a `.contentrain` outside the Astro root has no relative\n      // form it accepts — there we send none rather than a path it refuses.\n      const siteRoot = toPath(context.config?.root)\n\n      context.store.clear()\n      for (const entry of entries) {\n        const data = context.parseData\n          ? await context.parseData({ id: entry.id, data: entry.data, filePath: entry.filePath })\n          : entry.data\n        const filePath = siteRoot === undefined ? undefined : relative(siteRoot, entry.filePath)\n        context.store.set({\n          id: entry.id,\n          data,\n          ...(filePath === undefined || filePath.startsWith('..') || isAbsolute(filePath) ? {} : { filePath }),\n          ...(entry.body === undefined ? {} : { body: entry.body }),\n          ...(context.generateDigest ? { digest: context.generateDigest(entry.data) } : {}),\n          ...(entry.body !== undefined && context.renderMarkdown\n            ? { rendered: await context.renderMarkdown(entry.body) }\n            : {}),\n        })\n      }\n      context.logger?.info(`Loaded ${entries.length} ${model.kind} ${entries.length === 1 ? 'entry' : 'entries'} from ${model.id}`)\n\n      // Dev server: reload when the files behind this collection change. The\n      // listener is registered once — `load` runs again on every change, and a\n      // listener per run would multiply the work on every save.\n      if (context.watcher && !watching) {\n        watching = true\n        const paths = new Set(refs.map(ref => ref.filePath))\n        for (const path of paths) context.watcher.add(path)\n        context.watcher.add(join(root, '.contentrain', 'models', `${model.id}.json`))\n        const reload = (path: string) => {\n          if (!paths.has(path) && !path.endsWith(`${model.id}.json`)) return\n          void this.load(context)\n        }\n        context.watcher.on('change', reload)\n        context.watcher.on('add', reload)\n        context.watcher.on('unlink', reload)\n      }\n    },\n  }\n}\n\n/** Astro hands `config.root` as a file URL; tests and other hosts may use a path. */\nfunction toPath(root: URL | string | undefined): string | undefined {\n  if (root === undefined) return undefined\n  if (typeof root !== 'string') return fileURLToPath(root)\n  return root.startsWith('file:') ? fileURLToPath(root) : root\n}\n\nasync function entriesOf(ref: ContentFileRef, model: ModelDefinition, prefixLocale: boolean): Promise<Entry[]> {\n  const prefix = prefixLocale && ref.locale ? `${ref.locale}/` : ''\n  const withLocale = (data: Record<string, unknown>): Record<string, unknown> =>\n    ref.locale === null ? data : { ...data, locale: ref.locale }\n\n  switch (ref.kind) {\n    case 'collection': {\n      const raw = await readJson<Record<string, Record<string, unknown>>>(ref.filePath)\n      if (!raw) return []\n      return Object.entries(raw)\n        .toSorted(([a], [b]) => a.localeCompare(b, 'en'))\n        .map(([id, fields]) => ({\n          id: `${prefix}${id}`,\n          data: withLocale({ id, ...fields }),\n          filePath: ref.filePath,\n        }))\n    }\n\n    case 'singleton': {\n      const raw = await readJson<Record<string, unknown>>(ref.filePath)\n      if (!raw) return []\n      return [{\n        id: prefix ? `${ref.locale}` : model.id,\n        data: withLocale(raw),\n        filePath: ref.filePath,\n      }]\n    }\n\n    case 'dictionary': {\n      // One entry per key: a dictionary key is a semantic address, and a single\n      // blob entry would make getEntry() and reference() useless on it.\n      const raw = await readJson<Record<string, string>>(ref.filePath)\n      if (!raw) return []\n      return Object.entries(raw)\n        .toSorted(([a], [b]) => a.localeCompare(b, 'en'))\n        .map(([key, value]) => ({\n          id: `${prefix}${key}`,\n          data: withLocale({ key, value }),\n          filePath: ref.filePath,\n        }))\n    }\n\n    case 'document': {\n      const text = await readText(ref.filePath)\n      if (text === null) return []\n      const { frontmatter, body } = parseFrontmatter(text, stringLikeFieldKeys(model))\n      const slug = ref.slug ?? model.id\n      return [{\n        id: `${prefix}${slug}`,\n        data: withLocale({ slug, ...frontmatter }),\n        body,\n        filePath: ref.filePath,\n      }]\n    }\n\n    default:\n      return []\n  }\n}\n"],"mappings":"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"}

package/dist/cdn/index.d.mts

@@ -1,2 +1,2 @@
-import { C as CdnDocumentQuery, E as CdnCollectionQuery, F as DocumentDataSource, I as DocumentIndexEntry, L as SingletonDataSource, M as TransportConfig, N as CollectionDataSource, P as DictionaryDataSource, S as MediaManifest, T as CdnSingletonAccessor, _ as FormsClient, a as ConversationClient, b as MediaAsset, c as ConversationHistory, d as ConversationSendOptions, f as ConversationToolResult, g as FormSubmitResult, h as FormFieldConfig, i as ContentrainError, j as HttpTransport, l as ConversationMessage, m as FormConfig, n as ContentrainCDNConfig, o as ConversationClientConfig, p as ConversationUsage, r as createContentrain, s as ConversationContext, t as ContentrainCDNClient, u as ConversationResponse, v as FormsClientConfig, w as CdnDictionaryAccessor, x as MediaAssetMeta, y as MediaAccessor } from "../index-TgljULTn.mjs";
+import { C as CdnDocumentQuery, E as CdnCollectionQuery, F as DocumentDataSource, I as DocumentIndexEntry, L as SingletonDataSource, M as TransportConfig, N as CollectionDataSource, P as DictionaryDataSource, S as MediaManifest, T as CdnSingletonAccessor, _ as FormsClient, a as ConversationClient, b as MediaAsset, c as ConversationHistory, d as ConversationSendOptions, f as ConversationToolResult, g as FormSubmitResult, h as FormFieldConfig, i as ContentrainError, j as HttpTransport, l as ConversationMessage, m as FormConfig, n as ContentrainCDNConfig, o as ConversationClientConfig, p as ConversationUsage, r as createContentrain, s as ConversationContext, t as ContentrainCDNClient, u as ConversationResponse, v as FormsClientConfig, w as CdnDictionaryAccessor, x as MediaAssetMeta, y as MediaAccessor } from "../index-DYWwX7xL.mjs";
 export { CdnCollectionQuery, CdnDictionaryAccessor, CdnDocumentQuery, CdnSingletonAccessor, CollectionDataSource, ContentrainCDNClient, ContentrainCDNConfig, ContentrainError, ConversationClient, ConversationClientConfig, ConversationContext, ConversationHistory, ConversationMessage, ConversationResponse, ConversationSendOptions, ConversationToolResult, ConversationUsage, DictionaryDataSource, DocumentDataSource, DocumentIndexEntry, FormConfig, FormFieldConfig, FormSubmitResult, FormsClient, FormsClientConfig, HttpTransport, MediaAccessor, MediaAsset, MediaAssetMeta, MediaManifest, SingletonDataSource, TransportConfig, createContentrain };

package/dist/cli.cjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const require_generate = require("./generate-DN3mAbvC.cjs");
+const require_generate = require("./generate-D3C6itur.cjs");
 let node_path = require("node:path");
 let node_fs = require("node:fs");
 //#region src/cli.ts

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as generate } from "./generate-mpKW9Y8v.mjs";
+import { t as generate } from "./generate-B7jooE0f.mjs";
 import { join, resolve } from "node:path";
 import { watch } from "node:fs";
 //#region src/cli.ts