better-supabase 0.11.0 → 0.13.0

package/dist/build-C-D_vn0U.js

@@ -1,694 +0,0 @@
-import { r as isPlainObject } from "./clone-dN9XOL1K.js";
-import { t as DbException } from "./db-exception-CnWcYPxL.js";
-import { n as dbError } from "./errors-BV1SKTVs.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-BCJxCtHS.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",
-	"ieq",
-	"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;
-				case "ieq":
-					items.push(at("ilike", escapeLike(String(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 "ieq": 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.entries(table.columns).flatMap(([alias, meta]) => meta.selectable === false ? [] : [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 };