better-supabase 0.8.0 → 0.9.0

package/dist/build-Cx08LOT7.js

@@ -0,0 +1,689 @@
+import { r as isPlainObject } from "./clone-dN9XOL1K.js";
+import { t as DbException } from "./db-exception-CnWcYPxL.js";
+import { n as dbError } from "./errors-8i6tSICm.js";
+import { t as lookupOf } from "./lookup-BaP5bI27.js";
+import { t as escapeLike } from "./escape-like-DHfx6jRr.js";
+import { i as or, r as not, t as and } from "./types-R6syp1el.js";
+import { i as encodeValue } from "./wire-DEY0ajW9.js";
+//#region src/schema/define.ts
+/**
+* Binds generated model types to runtime metadata. Called from the generated
+* module; apps import the returned `schema`, never call this themselves.
+*/
+function defineSchema(meta) {
+	return { meta: validateMeta(meta) };
+}
+function validateMeta(meta) {
+	if (meta.version !== 1) throw new TypeError(`better-supabase: unsupported schema metadata version ${String(meta.version)}. Run \`better-supabase gen\` again.`);
+	return meta;
+}
+function tableMeta(meta, table) {
+	const found = meta.tables[table];
+	if (!found) throw new TypeError(`better-supabase: unknown table "${table}"`);
+	return found;
+}
+function relationMeta(meta, table, relation) {
+	const found = table.relations[relation];
+	if (!found) throw new TypeError(`better-supabase: unknown relation "${relation}" on "${table.key}"`);
+	return {
+		relation: found,
+		target: tableMeta(meta, found.table)
+	};
+}
+//#endregion
+//#region src/ir/build.ts
+const AGGREGATE_KEYS = {
+	_sum: "sum",
+	_avg: "avg",
+	_min: "min",
+	_max: "max"
+};
+const NUMERIC_TYPES = /* @__PURE__ */ new Set([
+	"int2",
+	"int4",
+	"int8",
+	"float4",
+	"float8",
+	"numeric",
+	"smallint",
+	"integer",
+	"bigint",
+	"real",
+	"double precision"
+]);
+/** Thrown while building IR; surfaces as an `invalid_request` Result. */
+function invalidRequest(message, table) {
+	throw new DbException(dbError("invalid_request", message, table ? { table } : {}));
+}
+/** A regconfig name, optionally schema-qualified; PostgREST puts it in the operator unquoted. */
+const TEXT_SEARCH_CONFIG = /^[A-Za-z_]\w*(\.[A-Za-z_]\w*)?$/;
+const FIELD_OPS = /* @__PURE__ */ new Set([
+	"eq",
+	"neq",
+	"in",
+	"notIn",
+	"isNull",
+	"not",
+	"gt",
+	"gte",
+	"lt",
+	"lte",
+	"like",
+	"ilike",
+	"match",
+	"imatch",
+	"contains",
+	"startsWith",
+	"endsWith",
+	"search",
+	"hasEvery",
+	"hasSome",
+	"has",
+	"containedBy"
+]);
+function isOpsObject(value) {
+	if (!isPlainObject(value)) return false;
+	const keys = Object.keys(value);
+	return keys.length > 0 && keys.every((key) => FIELD_OPS.has(key));
+}
+function writable(meta, mode) {
+	if (meta.generated || meta.identity === "always") return false;
+	return mode === "insert" ? meta.insertable !== false : meta.updatable !== false;
+}
+/** A json key PostgREST accepts in an arrow path, or an array index. */
+const JSON_KEY = /^[\w$]+$/;
+/** Path filters compare text (`->>`), so numbers and booleans become strings. */
+function text(value) {
+	return typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" ? String(value) : value;
+}
+/**
+* `in` over a list: `null` never equals anything in SQL, so a list with
+* `null` also matches the rows where the column is null.
+*/
+function inList(values, make) {
+	const present = values.filter((value) => value !== null);
+	if (present.length === values.length) return make("in", values);
+	const isNull = make("is", null);
+	return present.length === 0 ? isNull : or(make("in", present), isNull);
+}
+/** A primary key value; `null` and `undefined` match no row, so they are a caller error. */
+function keyValue(table, name, value) {
+	if (value === null || value === void 0) invalidRequest(`"${name}" of a ${table.key} key is ${String(value)}; pass the row's key`, table.key);
+	return value;
+}
+const builders = /* @__PURE__ */ new WeakMap();
+/** Column lists remembered per table; reads with generated lists stay bounded. */
+const SELECTION_CACHE_SIZE = 256;
+/** The shared builder for a schema; a builder holds no per-call state. */
+function builderFor(meta) {
+	let builder = builders.get(meta);
+	if (!builder) {
+		builder = new IrBuilder(meta);
+		builders.set(meta, builder);
+	}
+	return builder;
+}
+var IrBuilder = class {
+	meta;
+	/** Every column of a table, the selection of reads without `select`. */
+	#allColumns = /* @__PURE__ */ new WeakMap();
+	#selections = /* @__PURE__ */ new WeakMap();
+	constructor(meta) {
+		this.meta = meta;
+	}
+	table(key) {
+		const table = this.meta.tables[key];
+		if (!table) invalidRequest(`Unknown table "${key}"`);
+		return table;
+	}
+	column(table, name) {
+		const column = table.columns[name];
+		if (!column) invalidRequest(`Unknown column "${name}" on "${table.key}"`, table.key);
+		return column.db;
+	}
+	where(table, input) {
+		if (input === void 0) return;
+		if (!isPlainObject(input)) invalidRequest(`"where" on "${table.key}" must be an object`, table.key);
+		const items = [];
+		for (const [key, value] of Object.entries(input)) {
+			if (value === void 0) continue;
+			if (key === "AND") {
+				const list = Array.isArray(value) ? value : [value];
+				items.push(and(...list.map((item) => this.where(table, item))));
+			} else if (key === "OR") {
+				if (!Array.isArray(value)) invalidRequest(`"OR" on "${table.key}" must be an array`, table.key);
+				const branches = value.map((item) => this.where(table, item)).filter((item) => item !== void 0);
+				items.push(branches.length === 0 ? not({
+					kind: "and",
+					items: []
+				}) : or(...branches));
+			} else if (key === "NOT") {
+				const inner = this.where(table, value);
+				if (inner) items.push(not(inner));
+			} else if (key in table.relations) items.push(this.relationFilter(table, key, value));
+			else items.push(this.fieldFilter(table, key, value));
+		}
+		return and(...items);
+	}
+	relationFilter(table, name, value) {
+		const { relation, target } = relationMeta(this.meta, table, name);
+		const make = (quantifier, where) => ({
+			kind: "relation",
+			name,
+			relation,
+			target,
+			quantifier,
+			where: where === null ? void 0 : this.where(target, where)
+		});
+		if (relation.kind === "many") {
+			if (!isPlainObject(value)) invalidRequest(`Filter on to-many relation "${name}" needs some, none or every`, table.key);
+			const items = [];
+			for (const [quantifier, where] of Object.entries(value)) {
+				if (where === void 0) continue;
+				if (quantifier !== "some" && quantifier !== "none" && quantifier !== "every") invalidRequest(`Unknown quantifier "${quantifier}" on relation "${name}"`, table.key);
+				items.push(make(quantifier, where));
+			}
+			return and(...items) ?? make("some", {});
+		}
+		if (value === null) return make("none", null);
+		if (isPlainObject(value)) {
+			const keys = Object.keys(value);
+			if (keys.length > 0 && keys.every((key) => key === "is" || key === "isNot")) {
+				const items = [];
+				if (value["is"] !== void 0) items.push(value["is"] === null ? make("none", null) : make("some", value["is"]));
+				if (value["isNot"] !== void 0) items.push(value["isNot"] === null ? make("some", null) : not(make("some", value["isNot"])));
+				return and(...items) ?? make("some", null);
+			}
+		}
+		return make("some", value);
+	}
+	fieldFilter(table, name, value) {
+		const column = this.column(table, name);
+		if (value === null) return {
+			kind: "column",
+			column,
+			op: "is",
+			value: null
+		};
+		if (isPlainObject(value) && Array.isArray(value["path"])) return this.pathFilter(table, name, column, value);
+		if (!isOpsObject(value)) return {
+			kind: "column",
+			column,
+			op: "eq",
+			value: encodeValue(value)
+		};
+		const items = [];
+		for (const [op, operand] of Object.entries(value)) {
+			if (operand === void 0) continue;
+			items.push(this.fieldOp(table, name, column, op, operand));
+		}
+		return and(...items) ?? {
+			kind: "and",
+			items: []
+		};
+	}
+	/** `{ path: ["a", "b"], eq: "x" }` on a json column: compares the text at the path. */
+	pathFilter(table, name, column, input) {
+		if (!table.columns[name]?.json) invalidRequest(`"path" needs a json column; "${name}" on "${table.key}" is not one`, table.key);
+		const path = input["path"];
+		if (!Array.isArray(path) || path.length === 0 || !path.every((key) => typeof key === "string" && JSON_KEY.test(key))) invalidRequest(`"path" on "${name}" must be a non-empty list of keys made of letters, digits and _`, table.key);
+		const keys = path;
+		const at = (op, value) => ({
+			kind: "column",
+			column,
+			op,
+			value,
+			path: keys
+		});
+		const items = [];
+		for (const [op, operand] of Object.entries(input)) {
+			if (op === "path" || operand === void 0) continue;
+			switch (op) {
+				case "eq":
+					items.push(operand === null ? at("is", null) : at("eq", text(operand)));
+					break;
+				case "neq":
+					items.push(operand === null ? not(at("is", null)) : at("neq", text(operand)));
+					break;
+				case "in":
+				case "notIn": {
+					if (!Array.isArray(operand)) invalidRequest(`"${op}" on "${name}" needs an array`, table.key);
+					const condition = inList(operand.map(text), at);
+					items.push(op === "in" ? condition : not(condition));
+					break;
+				}
+				case "isNull":
+					items.push(operand ? at("is", null) : not(at("is", null)));
+					break;
+				case "gt":
+				case "gte":
+				case "lt":
+				case "lte":
+				case "like":
+				case "ilike":
+				case "match":
+				case "imatch":
+					items.push(at(op, text(operand)));
+					break;
+				default: invalidRequest(`Unknown operator "${op}" on a path of "${name}"`, table.key);
+			}
+		}
+		const condition = and(...items);
+		if (!condition) invalidRequest(`"path" on "${name}" needs an operator`, table.key);
+		return condition;
+	}
+	fieldOp(table, name, column, op, operand) {
+		const col = (kind, value) => ({
+			kind: "column",
+			column,
+			op: kind,
+			value: encodeValue(value)
+		});
+		const meta = table.columns[name];
+		const containment = (kind, value) => meta?.json ? {
+			kind: "column",
+			column,
+			op: kind,
+			value: encodeValue(value),
+			json: true
+		} : col(kind, value);
+		switch (op) {
+			case "eq": return operand === null ? col("is", null) : col("eq", operand);
+			case "neq": return operand === null ? not(col("is", null)) : col("neq", operand);
+			case "in":
+			case "notIn": {
+				if (!Array.isArray(operand)) invalidRequest(`"${op}" on "${name}" needs an array`, table.key);
+				const condition = inList(operand, col);
+				return op === "in" ? condition : not(condition);
+			}
+			case "isNull": return operand ? col("is", null) : not(col("is", null));
+			case "not": {
+				const inner = this.fieldFilter(table, name, operand);
+				return not(inner);
+			}
+			case "gt":
+			case "gte":
+			case "lt":
+			case "lte":
+			case "like":
+			case "ilike":
+			case "match":
+			case "imatch": return col(op, operand);
+			case "contains":
+				if (meta?.json || meta?.array) return containment("contains", operand);
+				return col("ilike", `%${escapeLike(String(operand))}%`);
+			case "startsWith": return col("like", `${escapeLike(String(operand))}%`);
+			case "endsWith": return col("like", `%${escapeLike(String(operand))}`);
+			case "search": {
+				if (typeof operand === "string") return col("fts", operand);
+				const { query, config } = operand;
+				if (config && !TEXT_SEARCH_CONFIG.test(config)) invalidRequest(`"search" on "${name}" needs a text search configuration name, such as "english"`, table.key);
+				return config ? {
+					kind: "column",
+					column,
+					op: "fts",
+					value: query,
+					config
+				} : col("fts", query);
+			}
+			case "hasEvery": return containment("contains", operand);
+			case "has": return containment("contains", [operand]);
+			case "hasSome":
+				if (meta?.json) invalidRequest(`"hasSome" on json column "${name}" has no PostgREST operator; use OR with "has"`, table.key);
+				return col("overlaps", operand);
+			case "containedBy": return containment("containedBy", operand);
+			default: return invalidRequest(`Unknown operator "${op}" on "${name}"`, table.key);
+		}
+	}
+	selection(table, select, include) {
+		if (include === void 0) return this.#columnsOnly(table, select);
+		const columns = select?.map((alias) => this.selectColumn(table, alias)) ?? this.allColumns(table);
+		const includes = [];
+		if (!isPlainObject(include)) invalidRequest(`"include" on "${table.key}" must be an object`, table.key);
+		for (const [name, value] of Object.entries(include)) {
+			if (value === void 0 || value === false) continue;
+			const fn = AGGREGATE_KEYS[name];
+			if (name === "_count") includes.push(...this.counts(table, value));
+			else if (fn) includes.push(...this.relationAggregates(table, fn, value));
+			else includes.push(this.include(table, name, value));
+		}
+		return {
+			columns,
+			includes
+		};
+	}
+	/**
+	* A selection without includes, shared per table and column list so the
+	* caches keyed on a selection (decoding, rules) hit across calls.
+	*/
+	#columnsOnly(table, select) {
+		let byList = this.#selections.get(table);
+		if (!byList) {
+			byList = /* @__PURE__ */ new Map();
+			this.#selections.set(table, byList);
+		}
+		const key = select === void 0 ? "*" : `:${select.join(",")}`;
+		let selection = byList.get(key);
+		if (!selection) {
+			selection = {
+				columns: select?.map((alias) => this.selectColumn(table, alias)) ?? this.allColumns(table),
+				includes: []
+			};
+			if (byList.size >= SELECTION_CACHE_SIZE) byList.clear();
+			byList.set(key, selection);
+		}
+		return selection;
+	}
+	/**
+	* `db.x.aggregate(args)`: the grouping columns, `_count` and the measures
+	* of each group.
+	*/
+	aggregation(table, args) {
+		const groupBy = args["groupBy"] ?? [];
+		if (!Array.isArray(groupBy)) invalidRequest(`"groupBy" on "${table.key}" must be an array`, table.key);
+		const columns = groupBy.map((name) => this.selectColumn(table, String(name)));
+		const measures = [];
+		for (const [key, fn] of Object.entries(AGGREGATE_KEYS)) {
+			const value = args[key];
+			if (value === void 0) continue;
+			for (const alias of this.measured(table, key, value)) measures.push(this.measure(table, fn, alias, `${key}_${alias}`));
+		}
+		const count = args["_count"] === true;
+		if (!count && measures.length === 0) invalidRequest(`aggregate on "${table.key}" needs _count, _sum, _avg, _min or _max`, table.key);
+		return {
+			columns,
+			includes: [],
+			aggregate: {
+				count,
+				measures
+			}
+		};
+	}
+	relationAggregates(table, fn, value) {
+		const key = `_${fn}`;
+		if (!isPlainObject(value)) invalidRequest(`"${key}" on "${table.key}" must map relations to columns`, table.key);
+		const includes = [];
+		for (const [name, entry] of Object.entries(value)) {
+			if (entry === void 0 || entry === false) continue;
+			const { relation, target } = relationMeta(this.meta, table, name);
+			if (relation.kind !== "many") invalidRequest(`"${key}.${name}" on "${table.key}" needs a to-many relation`, table.key);
+			const measures = this.measured(target, `${key}.${name}`, entry).map((alias) => this.measure(target, fn, alias, alias));
+			if (measures.length === 0) continue;
+			includes.push({
+				alias: `${key}_${name}`,
+				relation,
+				target,
+				selection: {
+					columns: [],
+					includes: [],
+					aggregate: {
+						count: false,
+						measures
+					}
+				},
+				where: void 0,
+				orderBy: [],
+				limit: void 0,
+				required: false,
+				aggregate: {
+					fn,
+					name
+				}
+			});
+		}
+		return includes;
+	}
+	/** The columns switched on in `{ amount: true, tax: true }`. */
+	measured(table, path, value) {
+		if (!isPlainObject(value)) invalidRequest(`"${path}" on "${table.key}" must map columns to true`, table.key);
+		return Object.entries(value).filter(([, on]) => on === true).map(([alias]) => alias);
+	}
+	measure(table, fn, alias, key) {
+		const column = this.column(table, alias);
+		const meta = table.columns[alias];
+		if ((fn === "sum" || fn === "avg") && !NUMERIC_TYPES.has(meta?.type ?? "")) invalidRequest(`_${fn} needs a numeric column; "${alias}" on "${table.key}" is ${meta?.type}`, table.key);
+		const codec = fn === "avg" ? void 0 : meta?.codec;
+		if (!codec) return {
+			fn,
+			key,
+			alias,
+			column
+		};
+		return {
+			fn,
+			key,
+			alias,
+			column,
+			cast: "text",
+			codec
+		};
+	}
+	allColumns(table) {
+		let columns = this.#allColumns.get(table);
+		if (!columns) {
+			columns = Object.keys(table.columns).map((alias) => this.selectColumn(table, alias));
+			this.#allColumns.set(table, columns);
+		}
+		return columns;
+	}
+	/** A selected column, with the cast and codec its metadata asks for. */
+	selectColumn(table, alias) {
+		const column = this.column(table, alias);
+		const codec = table.columns[alias]?.codec;
+		if (!codec) return {
+			alias,
+			column
+		};
+		return {
+			alias,
+			column,
+			cast: "text",
+			codec
+		};
+	}
+	counts(table, value) {
+		if (!isPlainObject(value)) invalidRequest(`"_count" on "${table.key}" must map relations to true or { where }`, table.key);
+		const counts = [];
+		for (const [name, entry] of Object.entries(value)) {
+			if (entry === void 0 || entry === false) continue;
+			const { relation, target } = relationMeta(this.meta, table, name);
+			if (relation.kind !== "many") invalidRequest(`"_count.${name}" on "${table.key}" needs a to-many relation`, table.key);
+			const args = isPlainObject(entry) ? entry : {};
+			counts.push({
+				alias: `_count_${name}`,
+				relation,
+				target,
+				selection: {
+					columns: [],
+					includes: []
+				},
+				where: this.where(target, args["where"]),
+				orderBy: [],
+				limit: void 0,
+				required: false,
+				count: name
+			});
+		}
+		return counts;
+	}
+	include(table, name, value) {
+		const { relation, target } = relationMeta(this.meta, table, name);
+		const args = value === true ? {} : isPlainObject(value) ? value : {};
+		return {
+			alias: name,
+			relation,
+			target,
+			selection: this.selection(target, args["select"], args["include"]),
+			where: this.where(target, args["where"]),
+			orderBy: this.orderBy(target, args["orderBy"], "include"),
+			limit: typeof args["limit"] === "number" ? args["limit"] : void 0,
+			required: args["required"] === true
+		};
+	}
+	/**
+	* Sort terms. On the root table, a to-one relation key sorts by the related
+	* row's columns: `{ organization: { name: "asc" } }`.
+	*/
+	orderBy(table, input, scope = "root") {
+		if (input === void 0) return [];
+		const list = Array.isArray(input) ? input : [input];
+		const terms = [];
+		for (const item of list) {
+			if (!isPlainObject(item)) invalidRequest(`"orderBy" on "${table.key}" must be an object`, table.key);
+			for (const [name, spec] of Object.entries(item)) {
+				if (spec === void 0) continue;
+				if (!(name in table.columns) && name in table.relations) {
+					terms.push(...this.relationOrder(table, name, spec, scope));
+					continue;
+				}
+				terms.push(this.sortTerm(table, name, this.column(table, name), spec));
+			}
+		}
+		return terms;
+	}
+	/**
+	* Sort terms for `db.x.aggregate(args)`: `groupBy` columns of `grouped`,
+	* `{ _count: "desc" }` and measures such as `{ _sum: { amount: "desc" } }`.
+	*/
+	aggregateOrderBy(table, input, grouped) {
+		if (input === void 0) return [];
+		const list = Array.isArray(input) ? input : [input];
+		const columns = new Set(grouped.columns.map((entry) => entry.column));
+		const terms = [];
+		for (const item of list) {
+			if (!isPlainObject(item)) invalidRequest(`"orderBy" on "${table.key}" must be an object`, table.key);
+			for (const [name, spec] of Object.entries(item)) {
+				if (spec === void 0) continue;
+				if (Object.hasOwn(table.columns, name) || Object.hasOwn(table.relations, name)) terms.push(...this.groupOrder(table, name, spec, columns));
+				else if (name === "_count") terms.push({
+					...this.sortTerm(table, name, "*", spec),
+					aggregate: "count"
+				});
+				else terms.push(...this.measureOrder(table, name, spec));
+			}
+		}
+		return terms;
+	}
+	/** A sort on a column, which an aggregate allows only for `groupBy` columns. */
+	groupOrder(table, name, spec, grouped) {
+		const terms = this.orderBy(table, { [name]: spec });
+		const loose = terms.find((term) => term.relation !== void 0 || !grouped.has(term.column));
+		if (loose) invalidRequest(`aggregate on "${table.key}" can only sort by groupBy columns, _count and measures, not "${loose.column}"`, table.key);
+		return terms;
+	}
+	/** `_sum: { amount: "desc" }` in an aggregate's `orderBy`. */
+	measureOrder(table, key, spec) {
+		const fn = Object.hasOwn(AGGREGATE_KEYS, key) ? AGGREGATE_KEYS[key] : void 0;
+		if (fn === void 0) invalidRequest(`Unknown column "${key}" on "${table.key}"`, table.key);
+		if (!isPlainObject(spec)) invalidRequest(`"orderBy.${key}" on "${table.key}" must map columns to a direction`, table.key);
+		const terms = [];
+		for (const [alias, direction] of Object.entries(spec)) {
+			if (direction === void 0) continue;
+			const { column } = this.measure(table, fn, alias, alias);
+			terms.push({
+				...this.sortTerm(table, `${key}.${alias}`, column, direction),
+				aggregate: fn
+			});
+		}
+		return terms;
+	}
+	/** One sort term from `"asc"`, `"desc"` or `{ direction, nulls }`. */
+	sortTerm(table, name, column, spec) {
+		if (spec === "asc" || spec === "desc") return {
+			column,
+			direction: spec
+		};
+		if (!isPlainObject(spec)) invalidRequest(`Invalid sort for "${name}" on "${table.key}"`, table.key);
+		const direction = spec["direction"] === "desc" ? "desc" : "asc";
+		const nulls = spec["nulls"];
+		return nulls === "first" || nulls === "last" ? {
+			column,
+			direction,
+			nulls
+		} : {
+			column,
+			direction
+		};
+	}
+	relationOrder(table, name, spec, scope) {
+		if (scope !== "root") invalidRequest(scope === "include" ? `"orderBy" inside an include can't sort by the relation "${name}"` : `"orderBy" sorts by one level of relations; "${name}" on "${table.key}" is a second`, table.key);
+		const { relation, target } = relationMeta(this.meta, table, name);
+		if (relation.kind !== "one") invalidRequest(`"orderBy" on "${name}" needs a to-one relation; "${name}" on "${table.key}" is to-many`, table.key);
+		if (!isPlainObject(spec)) invalidRequest(`"orderBy.${name}" on "${table.key}" must map columns of "${target.key}" to a direction`, table.key);
+		return this.orderBy(target, spec, "relation").map((term) => ({
+			...term,
+			relation: {
+				name,
+				relation,
+				target
+			}
+		}));
+	}
+	/**
+	* Maps an app-cased row to database column names. Rejects columns the
+	* database won't accept for `mode`: generated columns, `identity always`
+	* columns and read-only view columns.
+	*/
+	row(table, input, mode = "insert") {
+		if (!isPlainObject(input)) invalidRequest(`Row for "${table.key}" must be an object`, table.key);
+		const out = {};
+		for (const [name, value] of Object.entries(input)) {
+			if (value === void 0) continue;
+			const column = this.column(table, name);
+			const meta = table.columns[name];
+			if (meta && !writable(meta, mode)) invalidRequest(`"${name}" on "${table.key}" is read-only${meta.generated ? " (generated)" : meta.identity === "always" ? " (identity always)" : ""} and can't be set in an ${mode}`, table.key);
+			out[column] = encodeValue(value);
+		}
+		return out;
+	}
+	/**
+	* Condition matching exactly one row by the primary key or by the columns
+	* of a named unique key. The given columns must be one complete key.
+	*/
+	uniqueKey(table, input) {
+		if (!isPlainObject(input)) invalidRequest(`"where" on "${table.key}" must be an object`, table.key);
+		const given = Object.keys(input).filter((key) => input[key] !== void 0);
+		const { keys } = lookupOf(table);
+		const match = keys.find((key) => key.length > 0 && key.length === given.length && key.every((column) => given.includes(column)));
+		if (!match) {
+			const names = keys.filter((key) => key.length > 0).map((key) => `{ ${key.join(", ")} }`).join(", ");
+			invalidRequest(`findUnique on "${table.key}" needs one complete unique key: ${names}`, table.key);
+		}
+		return {
+			kind: "and",
+			items: match.map((name) => ({
+				kind: "column",
+				column: this.column(table, name),
+				op: input[name] === null ? "is" : "eq",
+				value: encodeValue(input[name])
+			}))
+		};
+	}
+	/** Condition matching one primary key value. */
+	primaryKey(table, id) {
+		const pk = table.primaryKey;
+		if (pk.length === 0) invalidRequest(`Table "${table.key}" has no primary key`, table.key);
+		if (pk.length === 1) {
+			const [name] = pk;
+			const value = isPlainObject(id) && name in id ? id[name] : id;
+			return {
+				kind: "column",
+				column: this.column(table, name),
+				op: "eq",
+				value: encodeValue(keyValue(table, name, value))
+			};
+		}
+		if (!isPlainObject(id)) invalidRequest(`Table "${table.key}" has a composite key; pass { ${pk.join(", ")} }`, table.key);
+		return {
+			kind: "and",
+			items: pk.map((name) => ({
+				kind: "column",
+				column: this.column(table, name),
+				op: "eq",
+				value: encodeValue(keyValue(table, name, id[name]))
+			}))
+		};
+	}
+};
+//#endregion
+export { tableMeta as i, invalidRequest as n, defineSchema as r, builderFor as t };