content-query 0.3.0 → 0.5.0

package/dist/next.mjs

@@ -1,10 +1,12 @@
-import { c as contentDeclarations, i as resolveConfigPath, t as buildAtRoot } from "./build-CI4s0oFP.mjs";
-import { n as serializeContentError } from "./diagnostics-Cu94mZhl.mjs";
+import { I as collectionNames } from "./operators-D-w1-gDg.mjs";
+import { c as collectionDeclarations, i as resolveConfigPath, t as buildAtRoot } from "./build-DWpB69_c.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";
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, rmdirSync, writeFileSync } from "node:fs";
 import { PHASE_DEVELOPMENT_SERVER, PHASE_PRODUCTION_BUILD } from "next/constants.js";
 //#region src/integrations/next/publication.ts
+const developmentEntry = /^next-dev-[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}\.js$/;
 /** Switches a development entry synchronously so error delivery cannot race a later publication. */
 function writeEntry(filename, source) {
 	try {
@@ -19,25 +21,75 @@ function writeEntry(filename, source) {
 		rmSync(temporary, { force: true });
 	}
 }
-/** Publishes fresh runtime imports and optionally prunes previous runs after a successful build. */
+/** Lists one directory's entries, treating a missing directory as empty. */
+function entriesOf(directory) {
+	try {
+		return readdirSync(directory);
+	} catch (cause) {
+		const code = cause && typeof cause === "object" && "code" in cause ? cause.code : void 0;
+		if (code === "ENOENT" || code === "ENOTDIR") return [];
+		throw cause;
+	}
+}
+/** Lists the directories of collection entries that exist from an earlier publication. */
+function publishedCollections(outDir) {
+	const collections = path.join(outDir, "collections");
+	return entriesOf(collections).map((name) => path.join(collections, name)).filter((directory) => existsSync(path.join(directory, "server.js")));
+}
+/** Points one entry at a fresh copy of its runtime, so Next reloads it even for identical bytes. */
+function redirectEntry(directory, exportName, filename) {
+	const entry = path.join(directory, "server.js");
+	const runtime = path.join(directory, filename);
+	writeEntry(runtime, readFileSync(entry, "utf8"));
+	writeEntry(entry, `export { ${exportName} } from ${JSON.stringify(`./${filename}`)};\n`);
+	return runtime;
+}
+/**
+* Publishes fresh runtime imports and optionally prunes previous runs after a successful build.
+*
+* Each collection entry, `collections/<export name>/server.js`, is pointed at a fresh copy of its
+* runtime. A preparation error replaces every entry, so each route that imports one reports it.
+*
+* @param outDir - Generated output directory.
+* @param config - Absolute path of content-query.config.
+* @param state - The session's current revision or error.
+* @param options - `prune` removes development entries from previous runs.
+* @returns The new runtime modules, or `undefined` when nothing valid was published.
+*/
 function publishDevelopment(outDir, config, state, { prune = false } = {}) {
 	if (!state.error) {
 		if (!state.revision) return;
-		const entry = path.join(outDir, "server.js");
 		const filename = `next-dev-${randomUUID()}.js`;
-		const runtime = path.join(outDir, filename);
-		writeEntry(runtime, readFileSync(entry, "utf8"));
-		writeEntry(entry, `export { content } from ${JSON.stringify(`./${filename}`)};\n`);
+		const runtimes = [...collectionNames(state.revision.registry).values()].map(({ exportName }) => redirectEntry(path.join(outDir, "collections", exportName), exportName, filename));
 		if (prune) pruneDevelopmentEntries(outDir, filename);
-		return runtime;
+		return runtimes;
+	}
+	const failure = `import { restoreContentError } from "content-query/internal";\nthrow restoreContentError(${JSON.stringify(serializeContentError(state.error))});\n`;
+	const directories = new Map(publishedCollections(outDir).map((directory) => [directory, path.basename(directory)]));
+	for (const [name, generated] of collectionNames(state.registry ?? {})) {
+		const directory = path.join(outDir, "collections", generated.exportName);
+		directories.set(directory, generated.exportName);
+		writeEntry(path.join(directory, "server.d.ts"), collectionDeclarations(directory, config, name, generated));
 	}
 	writeEntry(path.join(outDir, "package.json"), "{\"type\":\"module\",\"private\":true}\n");
-	writeEntry(path.join(outDir, "server.d.ts"), contentDeclarations(outDir, config));
-	writeEntry(path.join(outDir, "server.js"), `import { restoreContentError } from "content-query/internal";\nthrow restoreContentError(${JSON.stringify(serializeContentError(state.error))});\nexport const content = undefined;\n`);
+	for (const [directory, exportName] of directories) writeEntry(path.join(directory, "server.js"), `${failure}export const ${exportName} = undefined;\n`);
 }
-/** Removes owned runtime entries from previous runs, preserving the current facade's target. */
+/**
+* Removes owned runtime entries from previous runs, preserving the current entries' target.
+*
+* @param outDir - Generated output directory.
+* @param keep - The current publication's runtime filename, shared by every entry.
+*/
 function pruneDevelopmentEntries(outDir, keep) {
-	for (const filename of readdirSync(outDir)) if (filename !== keep && /^next-dev-[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}\.js$/.test(filename)) rmSync(path.join(outDir, filename), { force: true });
+	const collections = path.join(outDir, "collections");
+	const directories = [outDir, ...entriesOf(collections).map((name) => path.join(collections, name))];
+	for (const directory of directories) {
+		const entries = entriesOf(directory);
+		for (const filename of entries) if (filename !== keep && developmentEntry.test(filename)) rmSync(path.join(directory, filename), { force: true });
+		if (directory !== outDir && entries.every((filename) => developmentEntry.test(filename))) try {
+			rmdirSync(directory);
+		} catch {}
+	}
 }
 //#endregion
 //#region src/integrations/next/plugin.ts
@@ -114,7 +166,8 @@ async function startDevelopment(root, options) {
 }
 /**
 * Builds content before Next compiles, retaining one managed watcher during `next dev`.
-* Import the generated server entry from Server Components; Next's HMR observes its updates.
+* Import each collection's generated entry, such as `#content-query/posts`, from Server
+* Components; Next's HMR observes their updates, and each route traces only what it imports.
 * Next's detached telemetry helper evaluates configuration without starting content sessions.
 * @param nextConfig Existing object, promise, or phase-aware Next.js configuration.
 * @param options Optional content configuration file and generated output directory.

package/dist/operators-D-w1-gDg.mjs

@@ -0,0 +1,391 @@
+import { a as invalidQuery } from "./errors-Bfd0R4_P.mjs";
+import { c as isScalar, i as detach } from "./values-BbTV4QT-.mjs";
+//#region src/collection/names.ts
+/** Words that cannot name a `const` binding in an ES module, or that read as module syntax. */
+const reservedWords = new Set("arguments await break case catch class const continue debugger default delete do else enum eval export extends false finally for function if implements import in instanceof interface let new null package private protected public return static super switch this throw true try typeof var void while with yield".split(" "));
+/** Names Windows reserves for devices, in any letter case, which cannot name a directory. */
+const deviceName = /^(?:con|prn|aux|nul|com[0-9]|lpt[0-9])$/i;
+const identifier = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+/** Uppercases the first character, keeping the rest of a camelCase name. */
+function capitalize(value) {
+	return value.charAt(0).toUpperCase() + value.slice(1);
+}
+/**
+* Converts a collection name into the identifier its entry exports and its import path uses.
+* Characters that cannot appear in an identifier separate camelCase words, a leading digit gets
+* an `_` prefix, and reserved words and Windows device names get a `Collection` suffix.
+*
+* @param name - The collection's key in the `collections` registry.
+* @returns The export name, such as `blogPosts` for `blog-posts`.
+*/
+function exportNameOf(name) {
+	let converted = name.split(/[^A-Za-z0-9_$]+/).filter(Boolean).map((word, index) => index === 0 ? word : capitalize(word)).join("");
+	if (!converted) converted = "collection";
+	else if (/^[0-9]/.test(converted)) converted = `_${converted}`;
+	return reservedWords.has(converted) || deviceName.test(converted) ? `${converted}Collection` : converted;
+}
+/**
+* Derives the singular word for generated type names by dropping one trailing `s`. Names ending
+* in `ss`, such as `address`, keep it. Irregular plurals use the collection's `typeName`.
+*
+* @param exportName - The collection's export name.
+* @returns The singular form, such as `blogPost` for `blogPosts`.
+*/
+function singularOf(exportName) {
+	return exportName.length > 1 && exportName.endsWith("s") && !exportName.endsWith("ss") ? exportName.slice(0, -1) : exportName;
+}
+/**
+* Computes every collection's generated names and rejects names that would collide.
+*
+* @param registry - Collection keys with each collection's optional `typeName` override.
+* @returns The names of each collection's entry, keyed by collection name.
+* @throws An `Error` naming the conflict when two collections share an export or type name, or
+* when a `typeName` is not an identifier.
+*/
+function collectionNames(registry) {
+	const names = /* @__PURE__ */ new Map();
+	const exports = /* @__PURE__ */ new Map();
+	const types = /* @__PURE__ */ new Map();
+	for (const [name, definition] of Object.entries(registry)) {
+		const declared = definition?.typeName;
+		if (declared !== void 0 && (typeof declared !== "string" || !identifier.test(declared))) throw new Error(`Collection "${name}" typeName must be an identifier such as "Category"; received ${JSON.stringify(declared)}.`);
+		const exportName = exportNameOf(name);
+		const typeName = `Content${capitalize(declared ?? singularOf(exportName))}`;
+		const exported = exports.get(exportName.toLowerCase());
+		if (exported !== void 0) throw new Error(`Collections "${exported}" and "${name}" both export "${exportName}" (ignoring letter case), which their #content-query entries cannot share. Rename one of them.`);
+		const payloadTypeName = `${typeName}Payload`;
+		for (const generated of [typeName, payloadTypeName]) {
+			const typed = types.get(generated);
+			if (typed !== void 0) throw new Error(`Collections "${typed}" and "${name}" both generate the type "${generated}". Set typeName on one of them.`);
+			types.set(generated, name);
+		}
+		exports.set(exportName.toLowerCase(), name);
+		names.set(name, {
+			exportName,
+			typeName,
+			payloadTypeName
+		});
+	}
+	return names;
+}
+//#endregion
+//#region src/query/plan.ts
+/**
+* Rejects a declared relationship whose target collection this query scope has not loaded,
+* naming the collection to pass to `using()`.
+*
+* @param registry - The query scope's registry.
+* @param collection - The collection that declares the relationship.
+* @param name - The relationship, field, or filter name a query used.
+*/
+function assertAvailable(registry, collection, name) {
+	const unavailable = registry[collection]?.unavailable;
+	if (!unavailable || !Object.hasOwn(unavailable, name)) return;
+	const target = exportNameOf(unavailable[name]);
+	invalidQuery(`Relationship "${name}" targets the ${target} collection, which this query has not loaded. Pass it to using(), such as ${exportNameOf(collection)}.using(${target}).`);
+}
+/** Starts a fresh query without binding a content revision until execution. */
+function emptyPlan(collection) {
+	return {
+		collection,
+		filters: [],
+		order: [],
+		with: {}
+	};
+}
+/** Explains the explicit-selection rule wherever a scope returns rows without selecting data. */
+const NO_SELECTION_MESSAGE = "Select fields, relationships, payloads, or adjacent entries before running this query.";
+/** Explains why `paginate()` is unavailable once a query sets its own limit or offset. */
+const PAGINATE_AFTER_LIMIT_MESSAGE = "paginate() sets the limit and offset itself; remove limit and offset from this query.";
+/**
+* Returns the order a scope's entries follow: explicit clauses, then ascending ID as the final
+* tie-breaker unless ID is already sorted. Scopes without clauses sort by ascending ID, except
+* relationship scopes that preserve an authored ID array's order.
+*
+* @param plan - The scope whose order to resolve.
+* @param preserveOrder - Keeps authored order when the scope has no explicit clauses.
+* @returns The sort clauses to apply, in priority order.
+*/
+function effectiveOrder(plan, preserveOrder = false) {
+	if (!plan.order.length) return preserveOrder ? [] : [{
+		field: "id",
+		direction: "asc"
+	}];
+	const order = [...plan.order];
+	if (!order.some((sort) => sort.field === "id")) order.push({
+		field: "id",
+		direction: "asc"
+	});
+	return order;
+}
+/**
+* Checks whether a row-returning scope explicitly requests data. Nothing is implicit, not even
+* `id`: a scope must select fields, include a relationship, request a payload, or select adjacency.
+*
+* @param plan - The scope to check; `undefined` when a callback returned no builder.
+* @returns `true` when the scope requests at least one kind of data.
+*/
+function hasSelection(plan) {
+	return !!plan && (!!plan.select?.length || !!plan.adjacent || Object.keys(plan.with).length > 0 || Object.keys(plan.payloads ?? {}).length > 0);
+}
+//#endregion
+//#region src/query/operators.ts
+/** Builds a checked, backend-independent predicate instead of a per-entry callback. */
+function predicate(operator, field, value) {
+	if (!field || typeof field.name !== "string" || !field.name) invalidQuery("A filter must reference a query field.");
+	if ([
+		"in-array",
+		"not-in-array",
+		"array-contains-any",
+		"array-contains-all",
+		"array-contained"
+	].includes(operator)) {
+		if (!Array.isArray(value) || !value.every(isScalar)) invalidQuery("Choice arguments must be arrays of scalar values.");
+	} else if ([
+		"contains",
+		"starts-with",
+		"ends-with",
+		"like",
+		"ilike"
+	].includes(operator)) {
+		if (typeof value !== "string") invalidQuery("String predicates require a string argument.");
+	} else if (!operator.startsWith("is-") && !isScalar(value)) invalidQuery("This predicate requires a scalar argument.");
+	if ([
+		"gt",
+		"gte",
+		"lt",
+		"lte"
+	].includes(operator) && (value == null || typeof value === "boolean")) invalidQuery("Range predicates require a string, number, bigint, or date.");
+	return {
+		kind: "predicate",
+		operator,
+		field: field.name,
+		value: detach(value)
+	};
+}
+/** Matches a scalar using strict value/date equality. */
+function eq(field, value) {
+	return predicate("eq", field, value);
+}
+/** Negates scalar equality. */
+function ne(field, value) {
+	return predicate("ne", field, value);
+}
+/** Matches values greater than the supplied scalar. */
+function gt(field, value) {
+	return predicate("gt", field, value);
+}
+/** Matches values greater than or equal to the supplied scalar. */
+function gte(field, value) {
+	return predicate("gte", field, value);
+}
+/** Matches values less than the supplied scalar. */
+function lt(field, value) {
+	return predicate("lt", field, value);
+}
+/** Matches values less than or equal to the supplied scalar. */
+function lte(field, value) {
+	return predicate("lte", field, value);
+}
+/** Matches one of a list of scalar choices. */
+function inArray(field, values) {
+	return predicate("in-array", field, values);
+}
+/** Matches none of a list of scalar choices. */
+function notInArray(field, values) {
+	return predicate("not-in-array", field, values);
+}
+/** Matches a literal substring, without SQL wildcard interpretation. */
+function contains(field, value) {
+	return predicate("contains", field, value);
+}
+/** Matches a literal string prefix. */
+function startsWith(field, value) {
+	return predicate("starts-with", field, value);
+}
+/** Matches a literal string suffix. */
+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) {
+				assertAvailable(registry, collection, expression.field);
+				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);
+}
+/** Tests whether any candidate belongs to an existing scalar array. */
+function arrayContainsAny(field, values) {
+	return predicate("array-contains-any", field, values);
+}
+/** Tests whether every candidate belongs to an existing scalar array. */
+function arrayContainsAll(field, values) {
+	return predicate("array-contains-all", field, values);
+}
+/** Checks explicit null independently from undefined and absence. */
+function isNull(field) {
+	return predicate("is-null", field);
+}
+/** Checks undefined, including a missing property. */
+function isUndefined(field) {
+	return predicate("is-undefined", field);
+}
+/** Checks own-property absence before projection. */
+function isMissing(field) {
+	return predicate("is-missing", field);
+}
+/** Requires all child predicates; an empty conjunction is true. */
+function and(...expressions) {
+	expressions.forEach(validateExpression);
+	return {
+		kind: "and",
+		expressions
+	};
+}
+/** Requires any child predicate; an empty disjunction is false. */
+function or(...expressions) {
+	expressions.forEach(validateExpression);
+	return {
+		kind: "or",
+		expressions
+	};
+}
+/** Negates a predicate's boolean result. */
+function not(expression) {
+	validateExpression(expression);
+	return {
+		kind: "not",
+		expressions: [expression]
+	};
+}
+/** Checks the shape of expression trees even when TypeScript was bypassed. */
+function validateExpression(expression) {
+	if (!expression || typeof expression !== "object") invalidQuery("where() must return a structured expression.");
+	if (expression.kind === "predicate") {
+		if (![
+			"eq",
+			"ne",
+			"gt",
+			"gte",
+			"lt",
+			"lte",
+			"in-array",
+			"not-in-array",
+			"contains",
+			"starts-with",
+			"ends-with",
+			"like",
+			"ilike",
+			"array-contains",
+			"array-contains-any",
+			"array-contains-all",
+			"array-contained",
+			"is-null",
+			"is-undefined",
+			"is-missing"
+		].includes(expression.operator)) invalidQuery("Unknown filter operator.");
+		predicate(expression.operator, { name: expression.field }, expression.value);
+	} else if (expression.kind === "relation") {
+		if ([
+			expression.collection,
+			expression.field,
+			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",
+		"not"
+	].includes(expression.kind) && Array.isArray(expression.expressions)) {
+		if (expression.kind === "not" && expression.expressions.length !== 1) invalidQuery("not() requires one expression.");
+		expression.expressions.forEach(validateExpression);
+	} else invalidQuery("Invalid expression structure.");
+}
+//#endregion
+export { NO_SELECTION_MESSAGE as A, notIlike as C, resolveRelations as D, or as E, hasSelection as F, collectionNames as I, assertAvailable as M, effectiveOrder as N, startsWith as O, emptyPlan as P, 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, PAGINATE_AFTER_LIMIT_MESSAGE as j, 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-C2FcT1f9.d.mts

@@ -0,0 +1,23 @@
+//#region src/runtime/query-style.d.ts
+/** Query APIs an application can allow through `queryStyle` in content-query.config. */
+type QueryStyle = "fluent" | "relational";
+/**
+ * Collection members that start each query style. Every other query API hangs off these members,
+ * so gating them gates payloads, relationships, and adjacency as well. `count()` without options
+ * belongs to both styles; `count(options)` takes relational options.
+ */
+declare const queryStyleMembers: {
+  readonly fluent: readonly ["select", "where", "orderBy", "limit", "offset", "with", "withPayload", "selectAdjacent"];
+  readonly relational: readonly ["findMany", "findFirst", "paginate", "count(options)"];
+};
+/** A collection member that belongs to exactly one query style. */
+type QueryStyleMember = (typeof queryStyleMembers)[QueryStyle][number];
+/** Collection members that start a query in the given style. */
+type MembersOf<Style extends QueryStyle> = (typeof queryStyleMembers)[Style][number];
+/**
+ * Describes a disabled collection member in the type error itself, for example:
+ * `posts.select is unavailable because content-query.config sets queryStyle to "relational".`
+ */
+type QueryStyleDisabled<Collection extends string, Member extends QueryStyleMember, Style extends QueryStyle> = `${Collection}.${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-B45zM34W.mjs";
+import { C as Selection, E as Expression, S as ScalarField, T as Where, _ as PaginateResult, a as RelationalQueryOptions, b as RelationField, c as Adjacent, d as Field, f as Fields, g as PaginateOptions, h as PageOptions, i as RelationalQueries, l as CursorOptions, m as Ordered, n as RelationalCountOptions, o as RelationalQueryResult, p as NumberedPage, r as RelationalPaginateOptions, s as RelationalWhere, u as CursorPage, w as SelectionResult, x as Scalar, y as QueryFields } from "./relational-types-CTcalUNW.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, CursorOptions, CursorPage, Expression, Field, Fields, NumberedPage, PageOptions, PaginateOptions, PaginateResult, QueryFields, RelationalQueryOptions as QueryOptions, RelationalQueryOptions, RelationField, RelationalPaginateOptions, 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-D-w1-gDg.mjs";