content-query 0.2.0 → 0.4.0

package/dist/internal.mjs

@@ -1,13 +1,35 @@
-import { t as ContentError } from "./errors-C2iuBM0G.mjs";
+import { t as ContentError } from "./errors-Bfd0R4_P.mjs";
 import { r as decode } from "./values-BbTV4QT-.mjs";
-import { i as prepareRelationships, n as createRuntime, t as createLiveRuntime } from "./content-N1gYshjg.mjs";
-import { t as restoreContentError } from "./diagnostics-Cu94mZhl.mjs";
+import { n as createRuntime, o as prepareRelationships, r as isQueryStyle, t as createLiveRuntime } from "./content-BXrgP7nL.mjs";
+import { t as restoreContentError } from "./diagnostics-DmUZtrJ6.mjs";
 import { gunzipSync } from "fflate/browser";
 //#region src/artifacts/runtime.ts
+/** Checks that a value is a plain record before reading generated payload tables from it. */
+function isTable(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+/**
+* Restores lazy custom payload loaders from a generated payload table.
+*
+* @param collection - The collection name, for error messages.
+* @param payloads - Encoded loaders by payload name, entry ID, and canonical variant key.
+* @returns Decoding loaders with the same keys.
+*/
+function customPayloadTable(collection, payloads) {
+	if (!isTable(payloads)) throw new Error(`Invalid payload table for collection "${collection}".`);
+	return new Map(Object.entries(payloads).map(([payload, entries]) => {
+		if (!isTable(entries)) throw new Error(`Invalid payload table for collection "${collection}".`);
+		return [payload, new Map(Object.entries(entries).map(([id, variants]) => {
+			if (!isTable(variants) || Object.values(variants).some((load) => typeof load !== "function")) throw new Error(`Invalid payload table for collection "${collection}".`);
+			return [id, new Map(Object.entries(variants).map(([variant, load]) => [variant, async () => decode((await load()).default)]))];
+		}))];
+	}));
+}
 /** Initializes generated/embedded prepared content. This versioned wiring is internal. */
 function createArtifactRevision(manifest, collections, renderMarkdown) {
 	try {
 		if (manifest.version !== 2 || manifest.codec !== "devalue-6.0.2") throw new Error("Incompatible content artifact or codec version; regenerate content.");
+		if (manifest.queryStyle !== void 0 && !isQueryStyle(manifest.queryStyle)) throw new Error("Invalid query style in content artifact; regenerate content.");
 		const revision = {
 			registry: manifest.collections,
 			collections: Object.create(null),
@@ -15,7 +37,8 @@ function createArtifactRevision(manifest, collections, renderMarkdown) {
 			active: 0,
 			payloadCache: /* @__PURE__ */ new Map(),
 			renderCache: /* @__PURE__ */ new Map(),
-			renderMarkdown
+			renderMarkdown,
+			...manifest.queryStyle ? { queryStyle: manifest.queryStyle } : {}
 		};
 		for (const [name, descriptor] of Object.entries(manifest.collections)) {
 			const encoded = collections[name];
@@ -25,7 +48,8 @@ function createArtifactRevision(manifest, collections, renderMarkdown) {
 			revision.collections[name] = {
 				records,
 				relationships: descriptor.relationships,
-				builtins: new Map(Object.entries(encoded.builtins ?? {}).map(([id, load]) => [id, async () => decode((await load()).default)]))
+				builtins: new Map(Object.entries(encoded.builtins ?? {}).map(([id, load]) => [id, async () => decode((await load()).default)])),
+				...encoded.payloads ? { payloads: customPayloadTable(name, encoded.payloads) } : {}
 			};
 		}
 		const errors = prepareRelationships(revision);

package/dist/loaders.d.mts

@@ -1,5 +1,4 @@
-import { a as Loader, c as LoaderLogger, d as MetaStore, f as RecordLoader, i as FileSource, l as LoaderSource, n as DataStore, o as LoaderConfig, r as FileEntrySource, s as LoaderContext, t as DataEntry, u as LoaderWatcher } from "./types-ChaNhj42.mjs";
-import { n as GlobOptions, t as FileOptions } from "./descriptor-D9Th5hzk.mjs";
+import { a as DataStore, c as Loader, d as LoaderLogger, f as LoaderSource, h as RecordLoader, i as DataEntry, l as LoaderConfig, m as MetaStore, n as GlobOptions, o as FileEntrySource, p as LoaderWatcher, r as BodyLoader, s as FileSource, t as FileOptions, u as LoaderContext } from "./descriptor-bcPa6XLk.mjs";
 //#region src/loaders/file.d.ts
 /** Declares a multi-entry data file with typed source paths and record keys, plus an optional parser. */
 export declare function file(filename: string, options?: FileOptions): RecordLoader<FileEntrySource>;
@@ -8,4 +7,4 @@ export declare function file(filename: string, options?: FileOptions): RecordLoa
 /** Declares local files with Astro-style IDs and typed, project-relative source paths. */
 export declare function glob(options: GlobOptions): Loader<FileSource>;
 //#endregion
-export type { DataEntry, DataStore, FileEntrySource, FileOptions, FileSource, GlobOptions, Loader, LoaderConfig, LoaderContext, LoaderLogger, LoaderSource, LoaderWatcher, MetaStore, RecordLoader };
+export type { BodyLoader, DataEntry, DataStore, FileEntrySource, FileOptions, FileSource, GlobOptions, Loader, LoaderConfig, LoaderContext, LoaderLogger, LoaderSource, LoaderWatcher, MetaStore, RecordLoader };

package/dist/loaders.mjs

@@ -1,85 +1,6 @@
-import { o as builtinPath, s as builtinSymbol } from "./validation-D_XdE1pF.mjs";
-import { i as groupDiagnostics, n as contentError, r as describeCause, t as ContentError } from "./errors-C2iuBM0G.mjs";
-import { a as populateStore, i as recordData, n as coerceIdentity, r as parseData, t as glob } from "./glob-Bv0dpvCQ.mjs";
+import { t as glob } from "./glob-BXJuwy_p.mjs";
 import { t as assertServerOnly } from "./server-only-CIJUlyL-.mjs";
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-//#region src/loaders/file.ts
-/** Declares a multi-entry data file with typed source paths and record keys, plus an optional parser. */
-function file(filename, options = {}) {
-	if (typeof filename !== "string" || !filename) throw new TypeError("file() requires a filename.");
-	const descriptor = {
-		kind: "file",
-		filename,
-		options
-	};
-	return {
-		[builtinSymbol]: descriptor,
-		name: "content-query/file",
-		async load(context) {
-			const entries = await loadFile(descriptor, fileURLToPath(context.config.root), context.signal ?? new AbortController().signal);
-			await populateStore(context, entries);
-		}
-	};
-}
-/** Captures a complete multi-entry data source without applying collection validation. */
-async function loadFile(descriptor, root, signal) {
-	const resolved = builtinPath(descriptor, root);
-	let parsed;
-	try {
-		const text = await readFile(resolved, {
-			encoding: "utf8",
-			signal
-		});
-		parsed = descriptor.options.parser ? await descriptor.options.parser(text) : parseData(text, resolved);
-	} catch (cause) {
-		signal.throwIfAborted();
-		throw contentError(cause, {
-			code: "source-error",
-			source: resolved,
-			message: `Could not load "${descriptor.filename}": ${describeCause(cause)}`,
-			cause
-		});
-	}
-	const array = Array.isArray(parsed);
-	if (!array && (!parsed || typeof parsed !== "object")) throw new ContentError({
-		code: "source-error",
-		source: resolved,
-		message: `"${descriptor.filename}" must parse to an array or keyed record.`
-	});
-	const diagnostics = [];
-	const entries = Object.entries(parsed).flatMap(([key, value]) => {
-		if (!array && key === "$schema" && typeof value === "string") return [];
-		const source = `${resolved}#${key}`;
-		try {
-			const data = recordData(value);
-			const identity = array ? data.id ?? data.slug : key;
-			if (identity == null || coerceIdentity(identity) === "") throw new Error("Array entries require a nonempty id or slug.");
-			const { id: _transportId, ...metadata } = data;
-			return [{
-				id: coerceIdentity(identity),
-				data: metadata,
-				source: array ? source : `${resolved}#${coerceIdentity(identity)}`,
-				sourceData: {
-					filePath: path.relative(root, resolved).split(path.sep).join("/"),
-					key
-				}
-			}];
-		} catch (cause) {
-			diagnostics.push({
-				code: "source-error",
-				source,
-				message: `Invalid entry "${key}" in "${descriptor.filename}": ${describeCause(cause)}`,
-				cause
-			});
-			return [];
-		}
-	});
-	if (diagnostics.length) throw groupDiagnostics(diagnostics);
-	return entries;
-}
-//#endregion
+import { t as file } from "./file-DSOcdFj0.mjs";
 //#region src/loaders.ts
 assertServerOnly();
 //#endregion

package/dist/next.d.mts

@@ -1,4 +1,4 @@
-import { t as BuildContentOptions } from "./build-DfKd2bpf.mjs";
+import { t as BuildContentOptions } from "./build-DL1GzmRy.mjs";
 import { NextConfig } from "next";
 //#region src/integrations/next/plugin.d.ts
 /** Content locations for Next.js; the adapter chooses generated storage and the watch lifecycle. */

package/dist/next.mjs

@@ -1,5 +1,5 @@
-import { c as contentDeclarations, i as resolveConfigPath, t as buildAtRoot } from "./build-Dxz7P1ur.mjs";
-import { n as serializeContentError } from "./diagnostics-Cu94mZhl.mjs";
+import { c as contentDeclarations, i as resolveConfigPath, t as buildAtRoot } from "./build-CcqIpkes.mjs";
+import { n as serializeContentError } from "./diagnostics-DmUZtrJ6.mjs";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";

package/dist/{operators-UqWUhKQJ.mjs → operators-Cwy8Kx4o.mjs}

@@ -1,4 +1,4 @@
-import { a as invalidQuery } from "./errors-C2iuBM0G.mjs";
+import { a as invalidQuery } from "./errors-Bfd0R4_P.mjs";
 import { c as isScalar, i as detach } from "./values-BbTV4QT-.mjs";
 //#region src/query/operators.ts
 /** Builds a checked, backend-independent predicate instead of a per-entry callback. */
@@ -78,6 +78,89 @@ function startsWith(field, value) {
 function endsWith(field, value) {
 	return predicate("ends-with", field, value);
 }
+/**
+* Matches a SQL-style pattern: `%` matches any run of characters and `_` matches one character.
+* A backslash escapes a wildcard. Matching is case-sensitive.
+*/
+function like(field, pattern) {
+	return predicate("like", field, pattern);
+}
+/** Matches a SQL-style pattern like {@link like}, ignoring case. */
+function ilike(field, pattern) {
+	return predicate("ilike", field, pattern);
+}
+/** Negates {@link like}; entries without a matching string, including absent values, match. */
+function notLike(field, pattern) {
+	return not(like(field, pattern));
+}
+/** Negates {@link ilike}; entries without a matching string, including absent values, match. */
+function notIlike(field, pattern) {
+	return not(ilike(field, pattern));
+}
+/** Tests whether every item of an existing scalar array belongs to the candidates. */
+function arrayContained(field, values) {
+	return predicate("array-contained", field, values);
+}
+/**
+* Matches entries with at least one related entry. With a filter, a related entry must also match
+* it, for example `has(fields.author, (author) => eq(author.name, "Ada"))`. Wrap the result in
+* {@link not} to match entries without such a related entry.
+*
+* @param relation - A relationship from the `where()` callback's fields.
+* @param filter - Optional filter over the related entry's fields and relationships.
+* @returns An expression that the query resolves against the relationship's target collection.
+*/
+function has(relation, filter) {
+	if (!relation || typeof relation.name !== "string" || !relation.name) invalidQuery("has() requires a relationship from the where() fields.");
+	if (filter !== void 0 && typeof filter !== "function") invalidQuery("has() filters must be callbacks over the related entry's fields.");
+	const expression = filter === void 0 ? and() : filter(fieldProxy());
+	validateExpression(expression);
+	return {
+		kind: "has",
+		field: relation.name,
+		expression
+	};
+}
+/** Creates the field and relationship accessors passed to filter callbacks. */
+function fieldProxy() {
+	return new Proxy(Object.create(null), { get: (_target, name) => ({ name }) });
+}
+/**
+* Resolves fluent `has()` filters against a scope's declared relationships, producing portable
+* `relation` expressions that both runtime backends evaluate.
+*
+* @param registry - The query registry with each collection's relationships.
+* @param collection - The collection the expression filters.
+* @param expression - A validated expression that may contain `has()` filters.
+* @returns The expression with every `has()` filter resolved.
+*/
+function resolveRelations(registry, collection, expression) {
+	switch (expression.kind) {
+		case "has": {
+			const relationships = registry[collection]?.relationships ?? {};
+			const relation = Object.hasOwn(relationships, expression.field) ? relationships[expression.field] : void 0;
+			if (!relation) invalidQuery(`Unknown relationship "${expression.field}" in has().`);
+			return {
+				kind: "relation",
+				collection,
+				field: expression.field,
+				target: relation.collection,
+				expression: resolveRelations(registry, relation.collection, expression.expression)
+			};
+		}
+		case "relation": return {
+			...expression,
+			expression: resolveRelations(registry, expression.target, expression.expression)
+		};
+		case "and":
+		case "or":
+		case "not": return {
+			...expression,
+			expressions: expression.expressions.map((child) => resolveRelations(registry, collection, child))
+		};
+		default: return expression;
+	}
+}
 /** Tests scalar membership in an array, ignoring holes. */
 function arrayContains(field, value) {
 	return predicate("array-contains", field, value);
@@ -160,6 +243,9 @@ function validateExpression(expression) {
 			expression.target
 		].some((name) => typeof name !== "string" || !name)) invalidQuery("Relationship filters require registered collection and relationship names.");
 		validateExpression(expression.expression);
+	} else if (expression.kind === "has") {
+		if (typeof expression.field !== "string" || !expression.field) invalidQuery("has() requires a relationship from the where() fields.");
+		validateExpression(expression.expression);
 	} else if ([
 		"and",
 		"or",
@@ -170,4 +256,4 @@ function validateExpression(expression) {
 	} else invalidQuery("Invalid expression structure.");
 }
 //#endregion
-export { not as _, contains as a, startsWith as b, gt as c, isMissing as d, isNull as f, ne as g, lte as h, arrayContainsAny as i, gte as l, lt as m, arrayContains as n, endsWith as o, isUndefined as p, arrayContainsAll as r, eq as s, and as t, inArray as u, notInArray as v, validateExpression as x, or as y };
+export { notIlike as C, resolveRelations as D, or as E, startsWith as O, not as S, notLike as T, isUndefined as _, arrayContainsAny as a, lte as b, eq as c, gte as d, has as f, isNull as g, isMissing as h, arrayContainsAll as i, validateExpression as k, fieldProxy as l, inArray as m, arrayContained as n, contains as o, ilike as p, arrayContains as r, endsWith as s, and as t, gt as u, like as v, notInArray as w, ne as x, lt as y };

package/dist/query-style-eXENQJ0O.d.mts

@@ -0,0 +1,22 @@
+//#region src/runtime/query-style.d.ts
+/** Query APIs an application can allow through `queryStyle` in content-query.config. */
+type QueryStyle = "fluent" | "relational";
+/**
+ * Root `content` members that start each query style. Every other query API hangs off these
+ * members, so gating them gates payloads, relationships, and adjacency as well.
+ */
+declare const queryStyleMembers: {
+  readonly fluent: readonly ["from"];
+  readonly relational: readonly ["query", "count"];
+};
+/** A root `content` member that belongs to exactly one query style. */
+type QueryStyleMember = (typeof queryStyleMembers)[QueryStyle][number];
+/** Root members that start a query in the given style. */
+type MembersOf<Style extends QueryStyle> = (typeof queryStyleMembers)[Style][number];
+/**
+ * Describes a disabled root member in the type error itself, for example:
+ * `content.from is unavailable because content-query.config sets queryStyle to "relational".`
+ */
+type QueryStyleDisabled<Member extends QueryStyleMember, Style extends QueryStyle> = `content.${Member} is unavailable because content-query.config sets queryStyle to "${Style}".`;
+//#endregion
+export { QueryStyleMember as i, QueryStyle as n, QueryStyleDisabled as r, MembersOf as t };

package/dist/query.d.mts

@@ -1,4 +1,4 @@
-import { a as RelationalWhere, c as Fields, d as Scalar, f as ScalarField, g as Expression, h as Where, i as RelationalQueryResult, l as Ordered, m as SelectionResult, n as RelationalQueries, o as Adjacent, p as Selection, r as RelationalQueryOptions, s as Field, t as RelationalCountOptions } from "./relational-types-DgK3rLuw.mjs";
+import { _ as Where, a as RelationalWhere, c as Fields, d as QueryFields, f as RelationField, g as SelectionResult, h as Selection, i as RelationalQueryResult, l as Ordered, m as ScalarField, n as RelationalQueries, o as Adjacent, p as Scalar, r as RelationalQueryOptions, s as Field, t as RelationalCountOptions, v as Expression } from "./relational-types-C8xJtLG5.mjs";
 //#region src/query/operators.d.ts
 /** Matches a scalar using strict value/date equality. */
 export declare function eq<Value>(field: ScalarField<Value>, value: NoInfer<Value>): Expression;
@@ -22,6 +22,29 @@ export declare function contains<Value>(field: Field<Value> & (NonNullable<Value
 export declare function startsWith<Value>(field: Field<Value> & (NonNullable<Value> extends string ? unknown : never), value: string): Expression;
 /** Matches a literal string suffix. */
 export declare function endsWith<Value>(field: Field<Value> & (NonNullable<Value> extends string ? unknown : never), value: string): Expression;
+/**
+ * Matches a SQL-style pattern: `%` matches any run of characters and `_` matches one character.
+ * A backslash escapes a wildcard. Matching is case-sensitive.
+ */
+export declare function like<Value>(field: Field<Value> & (NonNullable<Value> extends string ? unknown : never), pattern: string): Expression;
+/** Matches a SQL-style pattern like {@link like}, ignoring case. */
+export declare function ilike<Value>(field: Field<Value> & (NonNullable<Value> extends string ? unknown : never), pattern: string): Expression;
+/** Negates {@link like}; entries without a matching string, including absent values, match. */
+export declare function notLike<Value>(field: Field<Value> & (NonNullable<Value> extends string ? unknown : never), pattern: string): Expression;
+/** Negates {@link ilike}; entries without a matching string, including absent values, match. */
+export declare function notIlike<Value>(field: Field<Value> & (NonNullable<Value> extends string ? unknown : never), pattern: string): Expression;
+/** Tests whether every item of an existing scalar array belongs to the candidates. */
+export declare function arrayContained<Value extends Scalar>(field: Field<readonly Value[] | null | undefined>, values: readonly NoInfer<Value>[]): Expression;
+/**
+ * Matches entries with at least one related entry. With a filter, a related entry must also match
+ * it, for example `has(fields.author, (author) => eq(author.name, "Ada"))`. Wrap the result in
+ * {@link not} to match entries without such a related entry.
+ *
+ * @param relation - A relationship from the `where()` callback's fields.
+ * @param filter - Optional filter over the related entry's fields and relationships.
+ * @returns An expression that the query resolves against the relationship's target collection.
+ */
+export declare function has<TargetFields>(relation: RelationField<TargetFields>, filter?: (fields: TargetFields) => Expression): Expression;
 /** Tests scalar membership in an array, ignoring holes. */
 export declare function arrayContains<Value extends Scalar>(field: Field<readonly Value[] | null | undefined>, value: NoInfer<Value>): Expression;
 /** Tests whether any candidate belongs to an existing scalar array. */
@@ -41,4 +64,4 @@ export declare function or(...expressions: Expression[]): Expression;
 /** Negates a predicate's boolean result. */
 export declare function not(expression: Expression): Expression;
 //#endregion
-export type { Adjacent, RelationalCountOptions as CountOptions, Expression, Field, Fields, RelationalQueryOptions as QueryOptions, RelationalQueryOptions, RelationalQueries, RelationalQueryResult, RelationalWhere, Selection, SelectionResult, Where };
+export type { Adjacent, RelationalCountOptions as CountOptions, Expression, Field, Fields, QueryFields, RelationalQueryOptions as QueryOptions, RelationalQueryOptions, RelationField, RelationalQueries, RelationalQueryResult, RelationalWhere, Selection, SelectionResult, Where };

package/dist/query.mjs

@@ -1 +1 @@
-export { t as and, n as arrayContains, r as arrayContainsAll, i as arrayContainsAny, a as contains, o as endsWith, s as eq, c as gt, l as gte, u as inArray, d as isMissing, f as isNull, p as isUndefined, m as lt, h as lte, g as ne, _ as not, v as notInArray, y as or, b as startsWith } from "./operators-UqWUhKQJ.mjs";
+export { t as and, n as arrayContained, r as arrayContains, i as arrayContainsAll, a as arrayContainsAny, o as contains, s as endsWith, c as eq, u as gt, d as gte, f as has, p as ilike, m as inArray, h as isMissing, g as isNull, _ as isUndefined, v as like, y as lt, b as lte, x as ne, S as not, C as notIlike, w as notInArray, T as notLike, E as or, O as startsWith } from "./operators-Cwy8Kx4o.mjs";