typion 0.0.0-stage → 0.1.1

package/dist/typion-Dh2BCSRz.js

@@ -0,0 +1,1187 @@
+import { a as InternalError, c as PluginError, d as ValidationError, i as ForbiddenError, n as ConfigError, r as ConflictError, s as NotFoundError, t as BadRequestError, u as UnsupportedError } from "./errors-D-CKO-px.js";
+import { A as evaluateRule, B as pluginOptions, C as afterOperation, D as NO_TRAIT_OPTIONS, E as runOperation, F as partitionFilter, G as FALSE_FILTER, H as readStates, I as pluginFilter, J as guard, K as andFilters, L as traitFilter, M as fieldWriteCheck, N as filterToSQL, O as READING, P as forbidden, Q as operationMeta, R as kindExpression, S as afterLink, T as queueAfterCommit, U as traitOptions, V as projectCells, W as writeStates, X as CommitQueue, Y as normalizeError, Z as buildContext, _ as updateDocument, a as runEntityOperation, b as assertData, c as create, d as lockRow, f as mergedOptions, g as update, h as remove, i as operationMethods, j as fieldReadDenied, k as WRITING, l as deleteDocument, m as referenceOptionKeys, o as assertId, ot as traitOperations, p as partitionAllowance, q as isPlainObject, r as operationInput, s as assertOptions, u as deleteOptionKeys, v as writeOptionKeys, w as beforeOperation, x as assertScalars, y as writeRule, z as kindFilterSQL } from "./operations-D3rOacLX.js";
+import { t as descriptor } from "./descriptor-Cc3mGp73.js";
+import { n as structuralValidation } from "./structural-BZnjFmCs.js";
+import { PgTable, getTableConfig } from "drizzle-orm/pg-core";
+import { and, asc, eq, getTableColumns, inArray, is, sql } from "drizzle-orm";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/runtime/dialect/pg.ts
+function keyLiteral(key) {
+	return sql.raw(`'${key.replace(/'/g, "''")}'`);
+}
+const CAST_NAME = /^[a-z_][a-z0-9_ ]*(\([0-9, ]*\))?$/i;
+const SQLSTATE = /^[0-9A-Z]{5}$/;
+function findPgError(error) {
+	let current = error;
+	for (let depth = 0; depth < 8 && typeof current === "object" && current !== null; depth++) {
+		const code = current.code;
+		if (typeof code === "string" && SQLSTATE.test(code)) return current;
+		current = current.cause;
+	}
+	return null;
+}
+function isQueryError(error) {
+	return error instanceof Error && typeof error.query === "string" && Array.isArray(error.params);
+}
+function mapSqlState(pg, cause) {
+	const message = pg.message ?? "Database error";
+	const details = {
+		sqlstate: pg.code,
+		table: pg.table,
+		constraint: pg.constraint
+	};
+	switch (pg.code) {
+		case "23505": return new ConflictError(message, "unique", {
+			constraint: pg.constraint,
+			details,
+			cause
+		});
+		case "23503": return new ConflictError(message, "foreign_key", {
+			constraint: pg.constraint,
+			details,
+			cause
+		});
+		case "23514": return new ConflictError(message, "check", {
+			constraint: pg.constraint,
+			details,
+			cause
+		});
+		case "23502": return new ValidationError(message, [{
+			path: pg.column === void 0 ? [] : [pg.column],
+			message: "must not be null"
+		}], {
+			details,
+			cause
+		});
+		case "40001": return new ConflictError(message, "serialization", {
+			details,
+			cause
+		});
+		case "40P01": return new ConflictError(message, "deadlock", {
+			details,
+			cause
+		});
+		case "22P02":
+		case "22007": return new BadRequestError(message, {
+			details,
+			cause
+		});
+		default: return new InternalError("Database error", {
+			details,
+			cause
+		});
+	}
+}
+function qualifiedName(table) {
+	const config = getTableConfig(table);
+	const schema = config.schema ?? "public";
+	return {
+		schema,
+		name: config.name,
+		label: schema === "public" ? config.name : `${schema}.${config.name}`
+	};
+}
+function createPgDialect() {
+	return {
+		id: "pg",
+		jsonText(column, key) {
+			return sql`${column}->>${keyLiteral(key)}`;
+		},
+		cast(value, type) {
+			if (!CAST_NAME.test(type)) throw new InternalError(`cast: '${type}' is not a type name`);
+			return sql`(${value})::${sql.raw(type)}`;
+		},
+		jsonbMerge(column, patch) {
+			return sql`${column} || ${sql.param(patch, column)}`;
+		},
+		jsonParam(value, column) {
+			return sql`${sql.param(value, column)}`;
+		},
+		async lockSelect(tx, table, where) {
+			return await tx.select().from(table).where(where).for("update");
+		},
+		mapError(error) {
+			const pg = findPgError(error);
+			if (pg !== null) return mapSqlState(pg, error);
+			if (isQueryError(error)) return new InternalError("Database error", { cause: error });
+			return null;
+		},
+		async introspect(db, tables) {
+			const drift = {
+				missingTables: [],
+				missingColumns: []
+			};
+			if (tables.length === 0) return drift;
+			const names = tables.map(qualifiedName);
+			const matches = names.map((t) => sql`(table_schema = ${t.schema} and table_name = ${t.name})`);
+			const rows = await db.select({
+				schema: sql`table_schema`,
+				table: sql`table_name`,
+				column: sql`column_name`
+			}).from(sql`information_schema.columns`).where(sql.join(matches, sql` or `));
+			const present = /* @__PURE__ */ new Map();
+			for (const row of rows) {
+				const key = `${row.schema}.${row.table}`;
+				const columns = present.get(key) ?? /* @__PURE__ */ new Set();
+				columns.add(row.column);
+				present.set(key, columns);
+			}
+			tables.forEach((table, i) => {
+				const name = names[i];
+				const columns = present.get(`${name.schema}.${name.name}`);
+				if (columns === void 0) {
+					drift.missingTables.push(name.label);
+					return;
+				}
+				const missing = getTableConfig(table).columns.map((c) => c.name).filter((c) => !columns.has(c));
+				if (missing.length > 0) drift.missingColumns.push({
+					table: name.label,
+					columns: missing
+				});
+			});
+			return drift;
+		}
+	};
+}
+//#endregion
+//#region src/runtime/constants.ts
+const QUERY_CONFIG_KEYS = /* @__PURE__ */ new Set([
+	"columns",
+	"with",
+	"where",
+	"extras",
+	"orderBy",
+	"offset",
+	"limit",
+	"comment"
+]);
+//#endregion
+//#region src/runtime/read/virtual-table.ts
+function virtualTable(table, entity, dialect, kinds) {
+	if (entity === null) return table;
+	const rewritten = new Set(entity.kindKeys.filter((k) => entity.columns[k]?.columnKind?.expression !== void 0));
+	const hidden = new Set(Object.keys(entity.columns).filter((k) => entity.columns[k]?.read === false));
+	if (rewritten.size === 0 && hidden.size === 0) return table;
+	return new Proxy(table, { get(target, key, receiver) {
+		if (typeof key === "string") {
+			if (hidden.has(key)) return void 0;
+			if (rewritten.has(key)) {
+				const column = Reflect.get(target, key, receiver);
+				return kindExpression(entity.columns[key]?.columnKind, column, kinds, dialect, null);
+			}
+		}
+		return Reflect.get(target, key, receiver);
+	} });
+}
+//#endregion
+//#region src/runtime/read/compose.ts
+function projectedKinds(entity) {
+	const out = [];
+	for (const key of entity?.kindKeys ?? []) {
+		const kind = entity?.columns[key]?.columnKind;
+		if (kind?.project !== void 0) out.push([key, kind]);
+	}
+	return out;
+}
+function swappedSource(entity, runtime, bound, meta, options) {
+	for (const plugin of runtime.plugins) {
+		const source = plugin.traits?.source;
+		const trait = entity.traits[plugin.id];
+		if (source === void 0 || trait === void 0) continue;
+		const swapped = source({
+			entity,
+			state: trait.state,
+			operation: meta.operation,
+			options: options.get(plugin.id) ?? {},
+			ctx: bound.ctx
+		});
+		if (swapped === void 0) continue;
+		if (runtime.relations[swapped.table] === void 0) throw new InternalError(`Plugin '${plugin.id}' reads '${entity.name}' from '${swapped.table}', which is not a table of the engine`, { entity: entity.name });
+		return {
+			plugin: plugin.id,
+			key: swapped.table,
+			filter: swapped.filter,
+			rule: swapped.rule ?? "read"
+		};
+	}
+	return null;
+}
+function sourceOf(entity, runtime, swapped) {
+	if (swapped === null) return {
+		key: entity.name,
+		table: entity.table
+	};
+	return {
+		key: swapped.key,
+		table: runtime.relations[swapped.key]?.table
+	};
+}
+var Composer = class {
+	req;
+	nested = /* @__PURE__ */ new Map();
+	readOptions;
+	constructor(req) {
+		this.req = req;
+		this.readOptions = new Set(pluginOptions(req.runtime.plugins).read.keys());
+	}
+	async rootFilter(entity) {
+		const { bound, meta, traitOptions, source } = this.req;
+		const rule = source?.rule ?? "read";
+		const outcome = await evaluateRule(entity, rule, bound, meta);
+		if (outcome.kind === "deny") throw forbidden(entity.name, rule, meta, `access.${rule} denies '${meta.operation}'`);
+		return andFilters([
+			pluginFilter(entity, bound, meta.operation, traitOptions, {
+				writing: false,
+				skip: source?.plugin
+			}),
+			source?.filter,
+			outcome.kind === "filter" ? outcome.filter : void 0
+		]);
+	}
+	nestedFilter(tableName) {
+		let pending = this.nested.get(tableName);
+		if (pending === void 0) {
+			pending = this.computeNested(tableName);
+			this.nested.set(tableName, pending);
+		}
+		return pending;
+	}
+	async computeNested(tableName) {
+		const { runtime, bound, meta, traitOptions } = this.req;
+		const entity = runtime.entityOrNull(tableName);
+		if (entity === null) {
+			if (bound.$mode === "system") return void 0;
+			throw new ForbiddenError(`Table '${tableName}' is not an entity: user-mode reads cannot reach it through a relation`, {
+				operation: meta.operation,
+				rule: "entity"
+			});
+		}
+		const outcome = await evaluateRule(entity, "read", bound, meta);
+		if (outcome.kind === "deny") return FALSE_FILTER;
+		return andFilters([pluginFilter(entity, bound, meta.operation, traitOptions, READING), outcome.kind === "filter" ? outcome.filter : void 0]);
+	}
+	async compileRoot(entity, config, injected) {
+		const source = sourceOf(entity, this.req.runtime, this.req.source);
+		const parts = andFilters([await this.rootFilter(entity), injected]);
+		const level = await this.compileLevel(source.key, entity, config, parts, "root");
+		const where = level.config.where;
+		return {
+			...level,
+			source,
+			where
+		};
+	}
+	async compileWhere(entity, where, injected) {
+		const source = sourceOf(entity, this.req.runtime, this.req.source);
+		const user = where === void 0 ? void 0 : await this.rewriteWhere(where, source.key, entity);
+		return {
+			source,
+			where: andFilters([
+				await this.rootFilter(entity),
+				injected,
+				user
+			])
+		};
+	}
+	async compileLevel(tableKey, entity, raw, parts, level) {
+		const root = level === "root";
+		const cfg = raw === true ? {} : raw;
+		if (!isPlainObject(cfg)) throw new BadRequestError(`with.${level} must be true or a query config object`);
+		for (const key of Object.keys(cfg)) if (!QUERY_CONFIG_KEYS.has(key) && !(root && this.readOptions.has(key))) throw new BadRequestError(`Unknown query option '${key}'${root ? "" : ` in with.${level}`}`);
+		const { runtime, bound, meta } = this.req;
+		const out = {};
+		for (const key of [
+			"offset",
+			"limit",
+			"comment"
+		]) if (cfg[key] !== void 0) out[key] = cfg[key];
+		if (root && entity !== null) this.checkLimit(entity, cfg.limit);
+		const swappedRoot = root && this.req.source !== null;
+		const columns = this.columnsFor(entity, cfg.columns, swappedRoot);
+		if (columns !== void 0) out.columns = columns;
+		const userWhere = cfg.where === void 0 ? void 0 : await this.rewriteWhere(cfg.where, tableKey, entity);
+		const where = andFilters([parts, userWhere]);
+		if (where !== void 0) out.where = where;
+		const orderBy = cfg.orderBy ?? (root ? entity?.defaultOrder ?? void 0 : void 0);
+		if (orderBy !== void 0) out.orderBy = this.rewriteOrderBy(orderBy, tableKey, entity);
+		if (cfg.extras !== void 0) out.extras = this.wrapExtras(cfg.extras, entity);
+		const withPlan = {};
+		if (cfg.with !== void 0) {
+			if (!isPlainObject(cfg.with)) throw new BadRequestError("with must be an object");
+			const relations = runtime.relations[tableKey]?.relations ?? {};
+			const outWith = {};
+			for (const [key, value] of Object.entries(cfg.with)) {
+				if (value === void 0 || value === false) continue;
+				const relation = relations[key];
+				if (relation === void 0) throw new BadRequestError(`Unknown relation '${key}' on '${tableKey}'`);
+				const target = relation.targetTableName;
+				const compiled = await this.compileLevel(target, runtime.entityOrNull(target), value, await this.nestedFilter(target), key);
+				outWith[key] = compiled.config;
+				withPlan[key] = compiled.plan;
+			}
+			out.with = outWith;
+		}
+		return {
+			config: out,
+			plan: {
+				kinds: projectedKinds(entity),
+				nullify: entity === null ? [] : fieldReadDenied(entity, bound, meta),
+				with: withPlan
+			}
+		};
+	}
+	checkLimit(entity, limit) {
+		if (limit === void 0) return;
+		if (typeof limit !== "number" || !Number.isInteger(limit) || limit < 0) throw new BadRequestError("limit must be a non-negative integer");
+		if (limit > entity.maxLimit) throw new BadRequestError(`limit ${limit} exceeds the maximum of ${entity.maxLimit} for '${entity.name}'`, { entity: entity.name });
+	}
+	columnKeys(tableKey, entity) {
+		if (entity !== null) return new Set(Object.keys(entity.columns));
+		const table = this.req.runtime.relations[tableKey]?.table;
+		return new Set(table === void 0 ? [] : Object.keys(getTableColumns(table)));
+	}
+	hiddenKeys(entity) {
+		if (entity === null) return [];
+		return Object.keys(entity.columns).filter((k) => entity.columns[k]?.read === false);
+	}
+	columnsFor(entity, columns, swappedRoot) {
+		if (entity === null) return columns;
+		const hidden = this.hiddenKeys(entity);
+		if (columns === void 0) {
+			if (!swappedRoot && hidden.length === 0) return void 0;
+			return Object.fromEntries(entity.visibleKeys.map((k) => [k, true]));
+		}
+		if (!isPlainObject(columns)) throw new BadRequestError("columns must be an object");
+		const entries = Object.entries(columns).filter(([, v]) => v !== void 0);
+		for (const [key, value] of entries) {
+			if (!(key in entity.columns)) throw new BadRequestError(`Unknown column '${key}' on '${entity.name}'`, { entity: entity.name });
+			if (typeof value !== "boolean") throw new BadRequestError(`columns.${key} must be a boolean`);
+			if (value && hidden.includes(key)) throw new BadRequestError(`Column '${key}' of '${entity.name}' is not readable`, { entity: entity.name });
+		}
+		if (entries.some(([, v]) => v === true)) return Object.fromEntries(entries.filter(([, v]) => v));
+		const omitted = /* @__PURE__ */ new Set([...entries.map(([k]) => k), ...hidden]);
+		return Object.fromEntries(entity.visibleKeys.filter((k) => !omitted.has(k)).map((k) => [k, true]));
+	}
+	async rewriteWhere(where, tableKey, entity) {
+		if (!isPlainObject(where)) throw new BadRequestError("where must be an object");
+		const { runtime } = this.req;
+		const columns = this.columnKeys(tableKey, entity);
+		const relations = runtime.relations[tableKey]?.relations ?? {};
+		const plain = {};
+		const extra = [];
+		for (const [key, value] of Object.entries(where)) {
+			if (value === void 0) continue;
+			if (key === "AND" || key === "OR") {
+				if (!Array.isArray(value)) throw new BadRequestError(`where.${key} must be an array`);
+				plain[key] = await Promise.all(value.map((v) => this.rewriteWhere(v, tableKey, entity)));
+			} else if (key === "NOT") plain.NOT = await this.rewriteWhere(value, tableKey, entity);
+			else if (key === "RAW") plain.RAW = typeof value === "function" ? (t, ops) => value(this.virtual(t, entity), ops) : value;
+			else if (columns.has(key)) {
+				if (entity?.columns[key]?.read === false) throw new BadRequestError(`Column '${key}' of '${entity.name}' is not readable`, { entity: entity.name });
+				const kind = entity?.columns[key]?.columnKind;
+				if (kind?.expression !== void 0) {
+					const { dialect } = runtime;
+					const { kinds } = this.req;
+					extra.push({ RAW: (t) => kindFilterSQL((sample) => kindExpression(kind, t[key], kinds, dialect, sample), key, value) });
+				} else plain[key] = value;
+			} else if (relations[key] !== void 0) {
+				const target = relations[key].targetTableName;
+				const parts = await this.nestedFilter(target);
+				if (value === true) plain[key] = parts ?? true;
+				else if (value === false) {
+					if (parts === void 0) plain[key] = false;
+					else extra.push({ NOT: { [key]: parts } });
+				} else if (isPlainObject(value)) {
+					const inner = await this.rewriteWhere(value, target, runtime.entityOrNull(target));
+					plain[key] = andFilters([parts, inner]) ?? {};
+				} else throw new BadRequestError(`where.${key} must be a boolean or a filter object`);
+			} else throw new BadRequestError(`Unknown filter field '${key}' on '${tableKey}'`);
+		}
+		return extra.length === 0 ? plain : { AND: [plain, ...extra] };
+	}
+	rewriteOrderBy(orderBy, tableKey, entity) {
+		if (typeof orderBy === "function") return (t, ops) => orderBy(this.virtual(t, entity), ops);
+		if (!isPlainObject(orderBy)) throw new BadRequestError("orderBy must be an object or a callback");
+		const columns = this.columnKeys(tableKey, entity);
+		const entries = Object.entries(orderBy).filter(([, v]) => v !== void 0);
+		for (const [key, dir] of entries) {
+			if (!columns.has(key) || entity?.columns[key]?.read === false) throw new BadRequestError(`Cannot order '${tableKey}' by '${key}'`);
+			if (dir !== "asc" && dir !== "desc") throw new BadRequestError(`orderBy.${key} must be 'asc' or 'desc'`);
+		}
+		const rewritten = new Set(entries.map(([key]) => key).filter((key) => entity?.columns[key]?.columnKind?.expression !== void 0));
+		if (rewritten.size === 0) return orderBy;
+		const { dialect } = this.req.runtime;
+		const { kinds } = this.req;
+		return (t, ops) => entries.map(([key, dir]) => {
+			const column = t[key];
+			const target = rewritten.has(key) ? kindExpression(entity?.columns[key]?.columnKind, column, kinds, dialect, null) : column;
+			return dir === "asc" ? ops.asc(target) : ops.desc(target);
+		});
+	}
+	wrapExtras(extras, entity) {
+		if (!isPlainObject(extras)) throw new BadRequestError("extras must be an object");
+		const out = {};
+		for (const [key, value] of Object.entries(extras)) out[key] = typeof value === "function" ? (t, ops) => value(this.virtual(t, entity), ops) : value;
+		return out;
+	}
+	virtual(table, entity) {
+		return virtualTable(table, entity, this.req.runtime.dialect, this.req.kinds);
+	}
+};
+//#endregion
+//#region src/runtime/read/find.ts
+function parseOptions(entity, bound, operation, config) {
+	const { runtime } = bound;
+	const traits = traitOptions(entity, runtime.plugins, "read", config);
+	const kinds = readStates(runtime.plugins, bound.ctx, config);
+	const meta = operationMeta(bound.ctx, entity.name, operation, runtime.now());
+	return {
+		composer: new Composer({
+			runtime,
+			bound,
+			meta,
+			kinds,
+			traitOptions: traits,
+			source: swappedSource(entity, runtime, bound, meta, traits)
+		}),
+		kinds
+	};
+}
+function collect(rows, plan, cells, hidden) {
+	for (const row of rows) {
+		for (const [key, kind] of plan.kinds) if (key in row) cells.push({
+			row,
+			key,
+			kind
+		});
+		for (const key of plan.nullify) if (key in row) hidden.push({
+			row,
+			key
+		});
+		for (const [key, sub] of Object.entries(plan.with)) {
+			const value = row[key];
+			if (Array.isArray(value)) collect(value, sub, cells, hidden);
+			else if (isPlainObject(value)) collect([value], sub, cells, hidden);
+		}
+	}
+}
+async function project(rows, plan, kinds) {
+	const cells = [];
+	const hidden = [];
+	collect(rows, plan, cells, hidden);
+	if (cells.length > 0) await projectCells(cells, kinds);
+	for (const { row, key } of hidden) row[key] = null;
+	return rows;
+}
+function builderFor(bound, key) {
+	return bound.$executor.query[key];
+}
+function assertConfig(config) {
+	if (config === void 0) return {};
+	if (!isPlainObject(config)) throw new BadRequestError("The query config must be an object");
+	return config;
+}
+async function runMany(entity, bound, operation, config, injected) {
+	const { composer, kinds } = parseOptions(entity, bound, operation, config);
+	const compiled = await composer.compileRoot(entity, config, injected);
+	return project(await builderFor(bound, compiled.source.key).findMany(compiled.config), compiled.plan, kinds);
+}
+async function find(entity, bound, config) {
+	await bound.runtime.ready();
+	return guard(bound.runtime, () => runMany(entity, bound, "find", assertConfig(config)));
+}
+async function findOne(entity, bound, config, operation = "findOne", injected) {
+	await bound.runtime.ready();
+	return guard(bound.runtime, async () => {
+		const cfg = assertConfig(config);
+		if (cfg.limit !== void 0) throw new BadRequestError(`'${operation}' does not accept a limit`);
+		const { composer, kinds } = parseOptions(entity, bound, operation, cfg);
+		const compiled = await composer.compileRoot(entity, cfg, injected);
+		const row = await builderFor(bound, compiled.source.key).findFirst(compiled.config);
+		if (row === void 0) return null;
+		return (await project([row], compiled.plan, kinds))[0] ?? null;
+	});
+}
+async function findById(entity, bound, id, config) {
+	if (id === void 0 || id === null) throw new BadRequestError("findById needs an id");
+	const cfg = assertConfig(config);
+	if (cfg.where !== void 0 || cfg.offset !== void 0) throw new BadRequestError("findById does not accept where or offset");
+	const row = await findOne(entity, bound, cfg, "findById", { [entity.pk.key]: { eq: id } });
+	if (row === null) throw new NotFoundError(`${entity.name} '${String(id)}' not found`, { entity: entity.name });
+	return row;
+}
+async function runCount(entity, bound, operation, config) {
+	const { composer } = parseOptions(entity, bound, operation, config);
+	const { source, where } = await composer.compileWhere(entity, config.where, void 0);
+	const sqlWhere = filterToSQL(bound.runtime.relations, source.key, source.table, where);
+	return Number(await bound.$executor.$count(source.table, sqlWhere));
+}
+async function count(entity, bound, config) {
+	await bound.runtime.ready();
+	return guard(bound.runtime, async () => {
+		const cfg = assertConfig(config);
+		const known = pluginOptions(bound.runtime.plugins).read;
+		for (const key of Object.keys(cfg)) if (key !== "where" && !known.has(key)) throw new BadRequestError(`Unknown count option '${key}'`);
+		return runCount(entity, bound, "count", cfg);
+	});
+}
+async function page(entity, bound, config) {
+	await bound.runtime.ready();
+	return guard(bound.runtime, async () => {
+		const cfg = assertConfig(config);
+		const limit = cfg.limit ?? entity.maxLimit;
+		const offset = cfg.offset ?? 0;
+		if (typeof offset !== "number" || !Number.isInteger(offset) || offset < 0) throw new BadRequestError("offset must be a non-negative integer");
+		const items = await runMany(entity, bound, "page", {
+			...cfg,
+			limit,
+			offset
+		});
+		const counted = { where: cfg.where };
+		for (const key of pluginOptions(bound.runtime.plugins).read.keys()) counted[key] = cfg[key];
+		const total = await runCount(entity, bound, "page", counted);
+		return {
+			items,
+			total,
+			limit,
+			offset,
+			hasMore: offset + items.length < total
+		};
+	});
+}
+//#endregion
+//#region src/runtime/write/bulk.ts
+const DEFAULT_MAX = 1e3;
+function maxOf(options) {
+	const max = options.max ?? DEFAULT_MAX;
+	if (typeof max !== "number" || !Number.isInteger(max) || max < 1) throw new BadRequestError("max must be a positive integer");
+	return max;
+}
+async function lockMatches(scope, where, rule, values, max) {
+	const { entity, bound, meta } = scope;
+	if (!isPlainObject(where)) throw new BadRequestError("where must be an object");
+	const composer = new Composer({
+		runtime: bound.runtime,
+		bound,
+		meta,
+		kinds: readStates(bound.runtime.plugins, bound.ctx, {}),
+		traitOptions: values,
+		source: null
+	});
+	const filter = andFilters([
+		pluginFilter(entity, bound, meta.operation, values, WRITING),
+		rule,
+		await composer.rewriteWhere(where, entity.name, entity)
+	]);
+	const sqlWhere = filterToSQL(bound.runtime.relations, entity.name, entity.table, filter);
+	const pk = entity.table[entity.pk.key];
+	const rows = await scope.tx.select().from(entity.table).where(sqlWhere).orderBy(asc(pk)).limit(max + 1).for("update");
+	if (rows.length > max) throw new BadRequestError(`${meta.operation} matches more than ${max} ${entity.name} rows; narrow the filter or raise max`, { entity: entity.name });
+	return rows;
+}
+async function updateMany(entity, bound, where, input, rawOptions) {
+	const data = assertData(input);
+	assertScalars(entity, data);
+	const options = assertOptions(rawOptions, [
+		"max",
+		...writeOptionKeys(bound),
+		...referenceOptionKeys(entity, bound)
+	]);
+	const max = maxOf(options);
+	const states = writeStates(entity, bound.runtime.plugins, bound.ctx, options);
+	return runOperation(bound, entity, "updateMany", async (scope) => {
+		await beforeOperation(scope, {
+			where,
+			data,
+			options
+		});
+		const rule = await writeRule(scope, "update", { data });
+		const { allowed } = partitionAllowance(scope, data);
+		fieldWriteCheck(entity, scope.bound, scope.meta, data, allowed);
+		const rows = await lockMatches(scope, where, rule, NO_TRAIT_OPTIONS, max);
+		for (const original of rows) {
+			const { doc } = await updateDocument(scope, original, data, {
+				states,
+				op: "update",
+				options: NO_TRAIT_OPTIONS,
+				withDeleted: options.withDeleted === true
+			});
+			queueAfterCommit(scope, doc, original);
+		}
+		const result = { count: rows.length };
+		await afterOperation(scope, result);
+		return result;
+	});
+}
+async function deleteMany(entity, bound, where, rawOptions) {
+	const options = assertOptions(rawOptions, ["max", ...deleteOptionKeys(bound)]);
+	const max = maxOf(options);
+	const values = traitOptions(entity, bound.runtime.plugins, "delete", options);
+	return runOperation(bound, entity, "deleteMany", async (scope) => {
+		await beforeOperation(scope, {
+			where,
+			options
+		});
+		const rows = await lockMatches(scope, where, await writeRule(scope, "delete", { options: mergedOptions(values) }), values, max);
+		for (const original of rows) {
+			const doc = await deleteDocument(scope, original, values);
+			queueAfterCommit(scope, doc, original);
+		}
+		const result = { count: rows.length };
+		await afterOperation(scope, result);
+		return result;
+	});
+}
+//#endregion
+//#region src/runtime/write/links.ts
+function keyOf(table, column) {
+	const found = Object.entries(getTableColumns(table)).find(([, c]) => c === column);
+	if (found === void 0) throw new InternalError("A many-to-many relation names a column it has not");
+	return found[0];
+}
+function joinOf(bound, entity, relation) {
+	if (typeof relation !== "string") throw new BadRequestError("relation must be the name of a relation", { entity: entity.name });
+	if (!entity.links.has(relation)) throw new UnsupportedError(`Entity '${entity.name}' does not write the links of '${relation}' (r.many(…, { through, writable: true }))`, { entity: entity.name });
+	const rel = bound.runtime.relations[entity.name]?.relations[relation];
+	const table = rel.throughTable;
+	const [joinOwnerKey, joinTargetKey] = [rel.through?.source[0]?._.key, rel.through?.target[0]?._.key];
+	if (table === void 0 || joinOwnerKey === void 0 || joinTargetKey === void 0) throw new InternalError(`Relation '${relation}' of '${entity.name}' goes through no table`);
+	const target = bound.runtime.entity(rel.targetTableName);
+	const columns = getTableColumns(table);
+	return {
+		table,
+		ownerKey: keyOf(entity.table, rel.sourceColumns[0]),
+		target,
+		targetKey: keyOf(target.table, rel.targetColumns[0]),
+		joinOwner: columns[joinOwnerKey],
+		joinTarget: columns[joinTargetKey],
+		joinOwnerKey,
+		joinTargetKey
+	};
+}
+async function writeLinks(entity, bound, op, id, relation, ids) {
+	assertId(entity, id);
+	const join = joinOf(bound, entity, relation);
+	const list = Array.isArray(ids) ? ids : [ids];
+	if (list.some((value) => value === void 0 || value === null || typeof value === "object")) throw new BadRequestError(`${op} takes the ids of the rows to ${op}`, { entity: entity.name });
+	const targets = [...new Set(list)];
+	return runOperation(bound, entity, op, async (scope) => {
+		const rule = await writeRule(scope, "update", { data: {} });
+		const { partition } = partitionAllowance(scope, {});
+		const owner = await lockRow(scope, id, [
+			partitionFilter(partition),
+			traitFilter(entity, scope.bound, scope.meta.operation, NO_TRAIT_OPTIONS, WRITING),
+			rule
+		]);
+		if (targets.length === 0) return { count: 0 };
+		if ((await find(join.target, scope.bound, {
+			columns: { [join.targetKey]: true },
+			where: { [join.targetKey]: { in: targets } }
+		})).length !== targets.length) throw new NotFoundError(`Not every '${join.target.name}' row to ${op} was found`, { entity: join.target.name });
+		const ownerValue = owner[join.ownerKey];
+		const mine = and(eq(join.joinOwner, ownerValue), inArray(join.joinTarget, targets));
+		if (op === "unlink") {
+			const removed = await scope.tx.delete(join.table).where(mine).returning();
+			const gone = removed.map((row) => row[join.joinTargetKey]);
+			if (gone.length > 0) await afterLink(scope, {
+				op,
+				doc: owner,
+				relation,
+				ids: gone
+			});
+			return { count: removed.length };
+		}
+		const present = new Set((await scope.tx.select({ target: join.joinTarget }).from(join.table).where(mine)).map((row) => row.target));
+		const missing = targets.filter((target) => !present.has(target));
+		if (missing.length > 0) {
+			const rows = missing.map((target) => ({
+				[join.joinOwnerKey]: ownerValue,
+				[join.joinTargetKey]: target
+			}));
+			await scope.tx.insert(join.table).values(rows);
+			await afterLink(scope, {
+				op,
+				doc: owner,
+				relation,
+				ids: missing
+			});
+		}
+		return { count: missing.length };
+	});
+}
+//#endregion
+//#region src/runtime/execute.ts
+const EXTEND_KEYS = /* @__PURE__ */ new Set([
+	"where",
+	"orderBy",
+	"limit",
+	"offset"
+]);
+function inputOf(descriptor) {
+	const input = descriptor.input ?? {};
+	if (!isPlainObject(input)) throw new BadRequestError("descriptor.input must be an object");
+	return input;
+}
+function extendConfig(config, extend) {
+	if (extend === void 0) return config;
+	if (!isPlainObject(extend)) throw new BadRequestError("extend must be an object");
+	for (const key of Object.keys(extend)) if (!EXTEND_KEYS.has(key)) throw new BadRequestError(`extend.${key} is not supported`);
+	const out = { ...config };
+	const where = andFilters([config.where, extend.where]);
+	if (where !== void 0) out.where = where;
+	for (const key of [
+		"orderBy",
+		"limit",
+		"offset"
+	]) if (extend[key] !== void 0) out[key] = extend[key];
+	return out;
+}
+function entityOf(bound, descriptor) {
+	if (!isPlainObject(descriptor) || typeof descriptor.entity !== "string") throw new BadRequestError("A descriptor needs an entity name");
+	if (typeof descriptor.op !== "string") throw new BadRequestError("A descriptor needs an op");
+	return bound.runtime.entity(descriptor.entity);
+}
+async function execute(bound, descriptor, extend) {
+	const entity = entityOf(bound, descriptor);
+	const input = inputOf(descriptor);
+	if (extend !== void 0 && ![
+		"find",
+		"findOne",
+		"count",
+		"page"
+	].includes(descriptor.op)) throw new BadRequestError(`extend is only supported on read descriptors, not '${descriptor.op}'`);
+	switch (descriptor.op) {
+		case "find": return find(entity, bound, extendConfig(input, extend));
+		case "findOne": return findOne(entity, bound, extendConfig(input, extend));
+		case "findById": return findById(entity, bound, input.id, input.config);
+		case "count": return count(entity, bound, extendConfig(input, extend));
+		case "page": return page(entity, bound, extendConfig(input, extend));
+		case "create": return create(entity, bound, input.data, input.options);
+		case "update": return update(entity, bound, input.id, input.data, input.options);
+		case "updateMany": return updateMany(entity, bound, input.where, input.data, input.options);
+		case "delete": return remove(entity, bound, input.id, input.options);
+		case "deleteMany": return deleteMany(entity, bound, input.where, input.options);
+		case "link":
+		case "unlink": return writeLinks(entity, bound, descriptor.op, input.id, input.relation, input.ids);
+		default:
+			if (!traitOperations(bound.runtime.plugins).has(descriptor.op)) throw new BadRequestError(`Unknown descriptor op '${String(descriptor.op)}'`);
+			return runEntityOperation(entity, bound, descriptor.op, input);
+	}
+}
+//#endregion
+//#region src/runtime/engine.ts
+const CALLER_LOOKUP = Symbol("typion.callerLookup");
+const OWN_BIND_OPTIONS = /* @__PURE__ */ new Set([
+	"request",
+	"meta",
+	"reason",
+	"ctx"
+]);
+function pluginBindOptions(opts) {
+	const out = {};
+	for (const [key, value] of Object.entries(opts)) if (!OWN_BIND_OPTIONS.has(key) && value !== void 0) out[key] = value;
+	return out;
+}
+function defaultAfterCommitError(error, info) {
+	console.error(`[typion] afterCommit failed (${info.entity}.${info.operation}, request ${info.requestId})`, error);
+}
+var EngineRuntime = class {
+	def;
+	db;
+	options;
+	relations;
+	dialect = createPgDialect();
+	validation;
+	plugins;
+	schemas = /* @__PURE__ */ new Map();
+	boot = null;
+	initializing = false;
+	engine;
+	constructor(def, db, options) {
+		this.def = def;
+		this.db = db;
+		this.options = options;
+		this.relations = def.relations;
+		this.validation = def.validation ?? structuralValidation();
+		this.plugins = def.plugins;
+	}
+	now() {
+		return this.options.now?.() ?? /* @__PURE__ */ new Date();
+	}
+	entity(name) {
+		const entity = this.entityOrNull(name);
+		if (entity === null) throw new BadRequestError(`Unknown entity '${name}'`);
+		return entity;
+	}
+	entityOrNull(name) {
+		return Object.hasOwn(this.def.entities, name) ? this.def.entities[name] ?? null : null;
+	}
+	schema(entity, mode) {
+		const key = `${entity.name}:${mode}`;
+		let schema = this.schemas.get(key);
+		if (schema === void 0) {
+			schema = this.validation.base(entity, mode, entity.validate?.fields);
+			this.schemas.set(key, schema);
+		}
+		return schema;
+	}
+	afterCommitError(error, info) {
+		(this.options.onAfterCommitError ?? defaultAfterCommitError)(error, info);
+	}
+	ready() {
+		if (this.initializing) return Promise.resolve();
+		if (this.boot === null) this.boot = this.runBoot().catch((error) => {
+			this.boot = null;
+			throw error;
+		});
+		return this.boot;
+	}
+	async runBoot() {
+		this.options.checkAdapter?.();
+		if (this.options.checkSchema !== false) await this.checkSchema();
+		this.initializing = true;
+		try {
+			for (const plugin of this.plugins) await plugin.spec.init?.(this.engine);
+		} finally {
+			this.initializing = false;
+		}
+	}
+	async checkSchema() {
+		const tables = Object.values(this.def.schema).filter((v) => is(v, PgTable));
+		let drift;
+		try {
+			drift = await this.dialect.introspect(this.db, tables);
+		} catch (error) {
+			throw normalizeError(this, error);
+		}
+		if (drift.missingTables.length === 0 && drift.missingColumns.length === 0) return;
+		const lines = [
+			"The database schema does not match the engine definition.",
+			...drift.missingTables.length > 0 ? [`  missing tables: ${drift.missingTables.join(", ")}`] : [],
+			...drift.missingColumns.map((m) => `  missing columns on ${m.table}: ${m.columns.join(", ")}`),
+			"Run `typion db generate` and `typion db migrate` (or `typion db push` in development)."
+		];
+		throw new ConfigError(lines.join("\n"), "schema_drift", { details: { ...drift } });
+	}
+};
+function entityApi(bound, entity) {
+	const name = entity.name;
+	const schemas = {};
+	for (const mode of [
+		"insert",
+		"update",
+		"select"
+	]) Object.defineProperty(schemas, mode, {
+		enumerable: true,
+		get: () => bound.runtime.schema(entity, mode)
+	});
+	return {
+		find: (config) => find(entity, bound, config),
+		findOne: (config) => findOne(entity, bound, config),
+		findById: (id, config) => findById(entity, bound, id, config),
+		count: (config) => count(entity, bound, config),
+		page: (config) => page(entity, bound, config),
+		query: (config) => descriptor(name, "find", config ?? {}),
+		queryOne: (config) => descriptor(name, "findOne", config ?? {}),
+		run: async (d, extend) => {
+			if (d?.entity !== name) throw new BadRequestError(`A '${String(d?.entity)}' descriptor cannot run on '${name}'`);
+			return execute(bound, d, extend);
+		},
+		create: (data, options) => create(entity, bound, data, options),
+		update: (id, data, options) => update(entity, bound, id, data, options),
+		updateMany: (where, data, options) => updateMany(entity, bound, where, data, options),
+		delete: (id, options) => remove(entity, bound, id, options),
+		deleteMany: (where, options) => deleteMany(entity, bound, where, options),
+		...entity.links.size === 0 ? {} : {
+			link: (id, relation, ids) => writeLinks(entity, bound, "link", id, relation, ids),
+			unlink: (id, relation, ids) => writeLinks(entity, bound, "unlink", id, relation, ids)
+		},
+		schemas,
+		...operationMethods(entity, bound.runtime.plugins, async (op, args) => runEntityOperation(entity, bound, op.name, operationInput(op, args)))
+	};
+}
+const EMPTY_QUEUE = new CommitQueue(() => {});
+var BoundImpl = class BoundImpl {
+	$engine;
+	ctx;
+	$tx;
+	queue;
+	apis = /* @__PURE__ */ new Map();
+	plugins;
+	constructor($engine, ctx, $tx, queue) {
+		this.$engine = $engine;
+		this.ctx = ctx;
+		this.$tx = $tx;
+		this.queue = queue;
+		for (const name of Object.keys($engine.runtime.def.entities)) Object.defineProperty(this, name, {
+			enumerable: true,
+			get: () => this.entity(name)
+		});
+	}
+	get runtime() {
+		return this.$engine.runtime;
+	}
+	get $ctx() {
+		return this.ctx;
+	}
+	get $mode() {
+		return this.ctx.mode;
+	}
+	get $executor() {
+		return this.$tx ?? this.runtime.db;
+	}
+	get $afterCommit() {
+		return this.queue ?? EMPTY_QUEUE;
+	}
+	get $plugins() {
+		this.plugins ??= this.$engine.pluginApis(this);
+		return this.plugins;
+	}
+	entity(name) {
+		let api = this.apis.get(name);
+		if (api === void 0) {
+			api = entityApi(this, this.runtime.entity(name));
+			this.apis.set(name, api);
+		}
+		return api;
+	}
+	joined(tx, queue) {
+		return new BoundImpl(this.$engine, this.ctx, tx, queue);
+	}
+	systemTwin(reason) {
+		if (this.ctx.mode === "system") return this;
+		const ctx = {
+			...this.ctx,
+			mode: "system",
+			systemReason: reason
+		};
+		return new BoundImpl(this.$engine, ctx, this.$tx, this.queue);
+	}
+	$withTx(tx) {
+		return this.joined(tx, this.queue ?? this.$engine.newQueue(this.ctx));
+	}
+	$run(d, extend) {
+		return execute(this, d, extend);
+	}
+	async $transaction(fn, config) {
+		const runtime = this.runtime;
+		await runtime.ready();
+		try {
+			if (this.$tx !== null && this.queue !== null) {
+				const queue = this.queue;
+				const mark = queue.mark();
+				try {
+					return await this.$tx.transaction((tx) => fn(this.joined(tx, queue)));
+				} catch (error) {
+					queue.truncate(mark);
+					throw error;
+				}
+			}
+			const queue = this.$engine.newQueue(this.ctx);
+			let result;
+			try {
+				result = await runtime.db.transaction((tx) => fn(this.joined(tx, queue)), config);
+			} catch (error) {
+				queue.discard();
+				throw error;
+			}
+			await queue.flush();
+			return result;
+		} catch (error) {
+			throw normalizeError(runtime, error);
+		}
+	}
+};
+var EngineImpl = class {
+	options;
+	runtime;
+	$plugins = {};
+	constructor(def, options) {
+		this.options = options;
+		const db = options.db;
+		if (db?._?.relations !== def.relations) throw new ConfigError("createEngine: the db was built with other relations; create it with drizzle({ client, relations: def.relations })", "relations_mismatch");
+		this.runtime = new EngineRuntime(def, db, options);
+		this.runtime.engine = this;
+		for (const name of Object.keys(def.entities)) Object.defineProperty(this, name, {
+			enumerable: true,
+			value: {
+				query: (config) => descriptor(name, "find", config ?? {}),
+				queryOne: (config) => descriptor(name, "findOne", config ?? {})
+			}
+		});
+		Object.assign(this.$plugins, this.pluginApis());
+	}
+	pluginApis(app) {
+		const out = {};
+		for (const plugin of this.runtime.def.plugins) {
+			const errors = {};
+			for (const [code, spec] of Object.entries(plugin.errors)) errors[code] = (input = {}) => new PluginError(input.message ?? spec.message, plugin.id, code, {
+				status: spec.status,
+				details: input.details,
+				cause: input.cause
+			});
+			out[plugin.id] = {
+				...plugin.spec.api?.(this, app),
+				errors
+			};
+		}
+		return out;
+	}
+	get $def() {
+		return this.runtime.def;
+	}
+	get $db() {
+		return this.runtime.db;
+	}
+	get $dialect() {
+		return this.runtime.dialect;
+	}
+	newQueue(ctx) {
+		return new CommitQueue((error) => this.runtime.afterCommitError(error, {
+			entity: "*",
+			operation: "transaction",
+			requestId: ctx.requestId
+		}));
+	}
+	pluginContext(base, input, allowAsync) {
+		const parts = [];
+		for (const plugin of this.runtime.plugins) {
+			const build = plugin.spec.context;
+			if (build === void 0) continue;
+			const value = build(base, input);
+			if (!allowAsync && typeof value?.then === "function") throw new ConfigError(`Plugin '${plugin.id}' builds its context asynchronously: use $fromRequest() instead of $as()`);
+			parts.push(value);
+		}
+		if (!allowAsync) return Object.assign({}, ...parts);
+		return Promise.all(parts).then((values) => Object.assign({}, ...values));
+	}
+	bind(user, mode, opts, systemReason, callerLookup, pluginCtx) {
+		if (typeof user !== "object" || user === null) throw new BadRequestError("The engine context must be an object");
+		const ctx = buildContext({
+			user,
+			mode,
+			request: opts.request ?? null,
+			systemReason,
+			meta: opts.meta,
+			now: this.runtime.now()
+		});
+		const input = {
+			request: opts.request ?? void 0,
+			headers: opts.request?.headers,
+			options: pluginBindOptions(opts),
+			...callerLookup ? { callerLookup } : {}
+		};
+		const full = {
+			...pluginCtx ?? this.pluginContext(ctx, input, false),
+			...ctx
+		};
+		return new BoundImpl(this, full, null, null);
+	}
+	$as(ctx, opts = {}) {
+		return this.bind(ctx, "user", opts, null, false, null);
+	}
+	$system(opts) {
+		if (typeof opts?.reason !== "string" || opts.reason.trim() === "") throw new ConfigError("$system() needs a non-empty reason: it is recorded in versions and audit rows");
+		return this.bind(opts.ctx ?? {}, "system", opts, opts.reason, opts[CALLER_LOOKUP] === true, null);
+	}
+	$fromRequest(request, opts = {}) {
+		return this.fromInput({
+			request,
+			headers: request.headers,
+			options: pluginBindOptions(opts)
+		});
+	}
+	$fromHeaders(headers, opts = {}) {
+		return this.fromInput({
+			headers,
+			options: pluginBindOptions(opts)
+		});
+	}
+	async fromInput(input) {
+		const request = input.request ?? null;
+		const user = this.options.context === void 0 ? {} : await this.options.context(input);
+		const probe = buildContext({
+			user,
+			mode: "user",
+			request,
+			systemReason: null,
+			meta: void 0,
+			now: this.runtime.now()
+		});
+		const pluginCtx = await this.pluginContext(probe, input, true);
+		return this.bind(user, "user", { request }, null, false, pluginCtx);
+	}
+	$withTx(ctx, tx) {
+		const bound = this.$as(ctx);
+		return bound.joined(tx, this.newQueue(bound.ctx));
+	}
+	$execute(d, bound) {
+		if (!(bound instanceof BoundImpl)) return Promise.reject(new BadRequestError("$execute needs an engine bound with $as/$system"));
+		return execute(bound, d);
+	}
+};
+function createEngine(def, options) {
+	return new EngineImpl(def, options);
+}
+//#endregion
+//#region src/runtime/typion.ts
+var typion_exports = /* @__PURE__ */ __exportAll({
+	createFromConfig: () => createFromConfig,
+	getTypion: () => getTypion,
+	standIn: () => standIn
+});
+const instances = globalThis.__typion ??= /* @__PURE__ */ new Map();
+function createFromConfig(config, options) {
+	const context = options.context ?? config.context;
+	const engine = createEngine(config.definition, {
+		...options,
+		onAfterCommitError: options.onAfterCommitError ?? config.onAfterCommitError,
+		checkSchema: options.checkSchema ?? config.checkSchema,
+		db: options.db,
+		context: context === void 0 ? void 0 : (input) => context({
+			...input,
+			system: engine.$system({
+				reason: "context",
+				[CALLER_LOOKUP]: true
+			}),
+			db: options.db
+		})
+	});
+	return engine;
+}
+function standIn(config, engine) {
+	const previous = instances.get(config);
+	instances.set(config, engine);
+	return () => {
+		if (instances.get(config) !== engine) return;
+		if (previous === void 0) instances.delete(config);
+		else instances.set(config, previous);
+	};
+}
+async function getTypion(config, options = {}) {
+	const cached = options.fresh === true ? void 0 : instances.get(config);
+	if (cached !== void 0) return cached;
+	const adapter = options.db ?? config.db;
+	if (adapter === void 0) throw new ConfigError("getTypion: the config has no database adapter (`db` in defineConfig)");
+	const engine = createFromConfig(config, {
+		db: adapter.connect(config.definition.relations),
+		...adapter.check === void 0 ? {} : { checkAdapter: () => adapter.check?.() }
+	});
+	if (options.fresh !== true) instances.set(config, engine);
+	return engine;
+}
+//#endregion
+export { typion_exports as i, getTypion as n, standIn as r, createFromConfig as t };
+
+//# sourceMappingURL=typion-Dh2BCSRz.js.map