typion 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,1324 @@
+import { n as getTypion } from "./typion-TJWDkHGh.js";
+import { a as InternalError, c as PluginError, d as ValidationError, f as attempt, i as ForbiddenError, l as TypionError, n as ConfigError, o as InvalidStateError, p as isTypionError, r as ConflictError, s as NotFoundError, t as BadRequestError, u as UnsupportedError } from "./errors-D-CKO-px.js";
+import { i as timestamps, n as cloneColumn, r as defaultIdColumn, t as typion } from "./schema-Rzzq97cK.js";
+import { $ as allowAll, at as resolvePlugins, et as buildEntityMeta, it as definePlugin, nt as checkDependencies, rt as defineFeaturePlugin, tt as defineEntity } from "./operations-D3rOacLX.js";
+import { n as defineColumnKind, r as readColumnKind } from "./column-kinds-Bkm4NJI2.js";
+import { n as structuralValidation } from "./structural-BZnjFmCs.js";
+import { PgTable, boolean, foreignKey, getTableConfig, index, integer, isPgEnum, jsonb, pgSchema, pgTable, text, timestamp, unique, uniqueIndex, uuid } from "drizzle-orm/pg-core";
+import { and, buildRelations, createRelationsHelper, desc, eq, getTableColumns, getTableName, inArray, is, sql } from "drizzle-orm";
+//#region src/define/collection.ts
+const relationHelpers = {
+	one: (target, config) => ({
+		kind: "one",
+		target,
+		from: config.from,
+		to: config.to,
+		optional: config.optional ?? true
+	}),
+	many: (target, config) => ({
+		kind: "many",
+		target,
+		from: config.from,
+		to: config.to,
+		through: config.through,
+		writable: config.writable ?? false
+	})
+};
+function collection(name, structure) {
+	const relations = structure.relations?.(relationHelpers) ?? {};
+	const state = { table: void 0 };
+	const make = (behaviour) => ({
+		name,
+		"~structure": structure,
+		"~runtime": {
+			structure,
+			relations,
+			behaviour,
+			state
+		},
+		get table() {
+			if (state.table === void 0) throw new ConfigError(`Collection '${name}' has no table until a config includes it`);
+			return state.table;
+		}
+	});
+	return Object.assign(make({}), { define: (behaviour) => make(behaviour) });
+}
+function buildCollectionTable(plugins, entry) {
+	const { state } = entry["~runtime"];
+	if (state.table !== void 0) return state.table;
+	const options = entry["~runtime"].structure;
+	const structure = options;
+	const columns = {};
+	if (!("id" in structure.columns) && structure.idColumn === void 0) columns.id = defaultIdColumn();
+	Object.assign(columns, structure.columns);
+	if (structure.timestamps !== false) Object.assign(columns, timestamps());
+	for (const plugin of plugins) for (const [key, column] of Object.entries(plugin.collection?.columns?.(options) ?? {})) {
+		if (key in columns) throw new ConfigError(`Collection '${entry.name}': plugin '${plugin.id}' adds column '${key}', which the collection already declares`);
+		columns[key] = column;
+	}
+	const indexes = entry["~runtime"].behaviour.indexes;
+	state.table = pgTable(structure.dbName ?? entry.name, columns, indexes);
+	return state.table;
+}
+function collectionEntityOptions(plugins, entry) {
+	const { structure, behaviour } = entry["~runtime"];
+	const consumed = /* @__PURE__ */ new Set([
+		"columns",
+		"relations",
+		"dbName",
+		"timestamps",
+		"public"
+	]);
+	for (const plugin of plugins) for (const key of plugin.collection?.consumes ?? []) consumed.add(key);
+	const { indexes: _table, ...entityBehaviour } = behaviour;
+	const access = { ...behaviour.access };
+	const out = {
+		...entityBehaviour,
+		access: structure.public === true ? {
+			...access,
+			read: true
+		} : access
+	};
+	for (const [key, value] of Object.entries(structure)) if (!consumed.has(key)) out[key] = value;
+	const links = Object.entries(entry["~runtime"].relations).filter(([, spec]) => spec.kind === "many" && spec.writable === true).map(([key]) => key);
+	if (links.length > 0) out.links = links;
+	for (const plugin of plugins) Object.assign(out, plugin.collection?.entity?.(structure));
+	return out;
+}
+//#endregion
+//#region src/features/localization.ts
+const localizedKind = defineColumnKind("localized");
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+function sameValue(a, b) {
+	if (a === b) return true;
+	if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((item, i) => sameValue(item, b[i]));
+	if (isPlainObject(a) && isPlainObject(b)) {
+		const keys = Object.keys(a);
+		return keys.length === Object.keys(b).length && keys.every((k) => sameValue(a[k], b[k]));
+	}
+	return false;
+}
+function castFor(sample) {
+	if (typeof sample === "number" || typeof sample === "bigint") return "numeric";
+	if (typeof sample === "boolean") return "boolean";
+	if (sample instanceof Date) return "timestamptz";
+	return null;
+}
+function localeExpr(dialect, column, chain, cast) {
+	const parts = chain.map((locale) => dialect.jsonText(column, locale));
+	const expr = parts.length === 1 ? parts[0] : sql`coalesce(${sql.join(parts, sql`, `)})`;
+	return cast === null ? expr : dialect.cast(expr, cast);
+}
+function assertLocales(locales, defaultLocale) {
+	if (locales.length === 0) throw new ConfigError("localization: locales must not be empty");
+	if (new Set(locales).size !== locales.length) throw new ConfigError("localization: locales must be unique");
+	if (!locales.includes(defaultLocale)) throw new ConfigError(`localization: defaultLocale '${defaultLocale}' is not in locales`);
+}
+function localization(options) {
+	const { locales, defaultLocale } = options;
+	assertLocales(locales, defaultLocale);
+	const fallback = options.fallback ?? true;
+	const resolve = (locale) => {
+		if (locale === void 0) return defaultLocale;
+		if (typeof locale !== "string" || !locales.includes(locale)) throw new BadRequestError(`Unknown locale '${String(locale)}' (expected one of ${locales.join(", ")})`);
+		return locale;
+	};
+	const stateOf = (ctxLocale, locale, strict) => {
+		const all = locale === "all";
+		const effective = all || locale === void 0 ? ctxLocale : resolve(locale);
+		const withFallback = strict !== false && fallback;
+		const chain = withFallback ? [.../* @__PURE__ */ new Set([effective, defaultLocale])] : [effective];
+		return {
+			mode: all ? "all" : withFallback ? "resolved" : "strict",
+			chain
+		};
+	};
+	const project = (value, state) => {
+		if (state.mode === "all" || !isPlainObject(value)) return value;
+		for (const locale of state.chain) {
+			const item = value[locale];
+			if (item !== void 0 && item !== null) return item;
+		}
+		return null;
+	};
+	const plugin = defineFeaturePlugin({
+		id: "localization",
+		columnKinds: {
+			$types: {},
+			readOptions: {
+				locale: "string",
+				fallback: "boolean"
+			},
+			writeOptions: { locale: "string" },
+			read: ({ options: given, ctx }) => stateOf(ctx.locale, given.locale, given.fallback),
+			write: ({ options: given, ctx }) => given.locale === "all" ? "all" : { locale: resolve(given.locale ?? ctx.locale) },
+			kinds: { localized: {
+				project: (values, state) => values.map((value) => project(value, state)),
+				expression: ({ column, state, sample, dialect }) => localeExpr(dialect, column, state.chain, castFor(sample)),
+				write: ({ value, stored, state }) => {
+					if (state === "all") return value;
+					const next = {
+						...isPlainObject(stored) ? stored : {},
+						[state.locale]: value
+					};
+					return value === null && Object.values(next).every((item) => item === null) ? null : next;
+				},
+				validation: (column, mode) => ({
+					type: "keyed",
+					keyName: "locale",
+					keys: locales,
+					required: column.notNull && mode !== "update" ? [defaultLocale] : [],
+					nonNull: column.notNull ? [defaultLocale] : [],
+					value: localizedKind.metaOf(column.column)?.value
+				}),
+				diff: (before, after) => {
+					if (!isPlainObject(before) || !isPlainObject(after)) return {
+						before,
+						after
+					};
+					const b = {};
+					const a = {};
+					for (const locale of /* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])) {
+						if (sameValue(before[locale], after[locale])) continue;
+						b[locale] = before[locale] ?? null;
+						a[locale] = after[locale] ?? null;
+					}
+					return {
+						before: b,
+						after: a
+					};
+				}
+			} }
+		},
+		contextOptions: { $type: {} },
+		requestHeaders: ["x-locale"],
+		context: (_base, input) => ({ locale: resolve(input.options?.locale ?? options.locale?.(input) ?? input.headers?.get("x-locale") ?? void 0) }),
+		seed: { columns: (entity, input) => {
+			const columns = {};
+			for (const key of entity.kindKeys) {
+				if (entity.columns[key]?.kind !== localizedKind.id) continue;
+				const values = Array.from({ length: input.count }, (_, i) => ({ [defaultLocale]: `${entity.name} ${key} ${i + 1}` }));
+				columns[key] = input.generators.valuesFromArray({
+					values: [{
+						weight: 1,
+						values
+					}],
+					isUnique: true
+				});
+			}
+			return columns;
+		} }
+	});
+	return Object.assign(plugin, {
+		locales,
+		defaultLocale
+	});
+}
+function isJsonSafe(dataType) {
+	return dataType.startsWith("string") || dataType.startsWith("number") || dataType === "boolean" || dataType === "object json";
+}
+function localized(builder) {
+	const name = builder.config.name;
+	const value = pgTable("localized", { value: builder }).value;
+	if (!isJsonSafe(value.dataType)) throw new ConfigError(`localized(): a ${value.dataType} value would not survive JSON; use text, numbers, booleans, enums or json`);
+	const column = name === "" ? jsonb() : jsonb(name);
+	return localizedKind.mark(column.$type(), { value });
+}
+function localizedValue(column, locale) {
+	return sql`(${column}->>${sql.raw(`'${locale.replace(/'/g, "''")}'`)})`;
+}
+function localizedIndex(name, column, locale) {
+	return index(name).on(localizedValue(column, locale));
+}
+function localizedUnique(name, column, locale) {
+	return uniqueIndex(name).on(localizedValue(column, locale));
+}
+//#endregion
+//#region src/define/kit.ts
+function buildKitSchema(input) {
+	const out = {};
+	const owners = /* @__PURE__ */ new Map();
+	const add = (group, entries) => {
+		for (const [key, value] of Object.entries(entries)) {
+			const owner = owners.get(key);
+			if (owner !== void 0) throw new ConfigError(`Schema key '${key}' is used by both ${owner} and ${group}`);
+			owners.set(key, group);
+			out[key] = value;
+		}
+	};
+	add("tables", input.tables);
+	add("generated", input.generated);
+	add("plugins", input.pluginTables);
+	const schemas = /* @__PURE__ */ new Map();
+	schemas.set(input.pgSchema.schemaName, input.pgSchema);
+	for (const value of Object.values(out)) {
+		const name = is(value, PgTable) ? getTableConfig(value).schema : isPgEnum(value) ? value.schema : void 0;
+		if (name !== void 0 && name !== "public" && !schemas.has(name)) schemas.set(name, pgSchema(name));
+	}
+	for (const [name, schema] of schemas) {
+		if (owners.has(name)) throw new ConfigError(`Schema key '${name}' collides with the pg schema of the same name`);
+		out[name] = schema;
+	}
+	return out;
+}
+function buildGenerated(derived, pluginTables) {
+	return {
+		...pluginTables,
+		...derived,
+		$names: Object.keys(derived)
+	};
+}
+//#endregion
+//#region src/define/relations.ts
+function mergeRelationConfigs(fragments) {
+	const merged = {};
+	const owners = /* @__PURE__ */ new Map();
+	for (const { owner, config } of fragments) for (const [table, record] of Object.entries(config)) {
+		if (record === void 0) continue;
+		const target = merged[table] ?? {};
+		merged[table] = target;
+		for (const [key, relation] of Object.entries(record)) {
+			const id = `${table}.${key}`;
+			const previous = owners.get(id);
+			if (previous !== void 0) throw new ConfigError(`Relation '${id}' is declared twice (by ${previous} and by ${owner})`);
+			owners.set(id, owner);
+			target[key] = relation;
+		}
+	}
+	return merged;
+}
+function wrapDrizzleError(error) {
+	if (error instanceof ConfigError) throw error;
+	const message = error instanceof Error ? error.message : String(error);
+	throw new ConfigError(message, "config", { cause: error });
+}
+function resolveRelations(tables, build) {
+	const helper = createRelationsHelper(tables);
+	try {
+		return buildRelations(tables, mergeRelationConfigs(build(helper)));
+	} catch (error) {
+		wrapDrizzleError(error);
+	}
+}
+function tablesOnly(schema) {
+	const out = {};
+	for (const [key, value] of Object.entries(schema)) if (is(value, PgTable)) out[key] = value;
+	return out;
+}
+function columnKey(table, column, context) {
+	for (const [key, candidate] of Object.entries(getTableColumns(table))) if (candidate === column) return key;
+	throw new ConfigError(`${context}: relation column does not belong to its table`);
+}
+function single(items) {
+	return items.length === 1 ? items[0] : items;
+}
+function mirrorRelations(r, resolved, source, mirror) {
+	const config = resolved[source];
+	if (config === void 0) throw new ConfigError(`No relations entry for '${source}'`);
+	const out = {};
+	const mirrorTable = r[mirror];
+	if (mirrorTable === void 0) throw new ConfigError(`No table '${mirror}' in the merged schema`);
+	for (const [key, rel] of Object.entries(config.relations)) {
+		const context = `relations -> ${mirror}.${key}`;
+		const target = rel.targetTableName;
+		const targetTable = r[target];
+		if (targetTable === void 0) throw new ConfigError(`${context}: unknown target '${target}'`);
+		const sourceTable = rel.sourceTable;
+		const targetPg = rel.targetTable;
+		let from = rel.sourceColumns.map((c) => {
+			const column = mirrorTable[columnKey(sourceTable, c, context)];
+			if (column === void 0) throw new ConfigError(`${context}: the derived table lacks a column`);
+			return column;
+		});
+		let to = rel.targetColumns.map((c) => {
+			const column = targetTable[columnKey(targetPg, c, context)];
+			if (column === void 0) throw new ConfigError(`${context}: target lacks a column`);
+			return column;
+		});
+		const through = rel.through;
+		if (through !== void 0) {
+			const junction = (cfg) => {
+				const column = r[cfg.tableName]?.[cfg.key];
+				if (column === void 0) throw new ConfigError(`${context}: junction column '${cfg.tableName}.${cfg.key}' not found`);
+				return column;
+			};
+			from = from.map((c, i) => {
+				const via = through.source[i];
+				if (via === void 0) throw new ConfigError(`${context}: junction columns mismatch`);
+				return c.through(junction(via._));
+			});
+			to = to.map((c, i) => {
+				const via = through.target[i];
+				if (via === void 0) throw new ConfigError(`${context}: junction columns mismatch`);
+				return c.through(junction(via._));
+			});
+		}
+		const cfg = {
+			from: single(from),
+			to: single(to)
+		};
+		if (rel.alias !== void 0) cfg.alias = rel.alias;
+		if (rel.where !== void 0) cfg.where = rel.where;
+		if (rel.relationType === "one") {
+			cfg.optional = rel.optional ?? true;
+			const one = r.one[target];
+			if (one === void 0) throw new ConfigError(`${context}: unknown target '${target}'`);
+			out[key] = one(cfg);
+		} else {
+			const many = r.many[target];
+			if (many === void 0) throw new ConfigError(`${context}: unknown target '${target}'`);
+			out[key] = many(cfg);
+		}
+	}
+	return out;
+}
+//#endregion
+//#region src/define/engine.ts
+const RESERVED_ENTITY_NAMES = /* @__PURE__ */ new Set([
+	"_rpc",
+	"_plugins",
+	"entity"
+]);
+const DEFAULT_MAX_LIMIT = 100;
+function pluginTablesOf(plugins) {
+	const out = {};
+	for (const plugin of plugins) Object.assign(out, plugin.tables);
+	return out;
+}
+function fragmentsOf(r, userRelations, plugins) {
+	const fragments = [];
+	for (const plugin of plugins) {
+		const build = plugin.spec.relations;
+		if (build !== void 0) fragments.push({
+			owner: `plugin '${plugin.id}'`,
+			config: build(r)
+		});
+	}
+	fragments.push({
+		owner: "the engine relations",
+		config: userRelations(r)
+	});
+	return fragments;
+}
+function assertEntityName(name, def, relations, plugins) {
+	if (def.name !== name) throw new ConfigError(`Entity registered as '${name}' is defined as '${def.name}'`, "config", { entity: name });
+	if (RESERVED_ENTITY_NAMES.has(name) || name.startsWith("$")) throw new ConfigError(`Entity name '${name}' is reserved`, "config", { entity: name });
+	if (plugins.some((p) => p.id === name)) throw new ConfigError(`Entity name '${name}' collides with the plugin of the same id`, "config", { entity: name });
+	if (!(name in relations)) throw new ConfigError(`Entity '${name}' does not name a table of the engine`, "config", { entity: name });
+}
+function deriveTables(state, entities, taken) {
+	const out = {
+		tables: {},
+		mirrors: /* @__PURE__ */ new Map(),
+		byEntity: /* @__PURE__ */ new Map()
+	};
+	const names = new Set(entities.map(({ def }) => def.name));
+	for (const { def } of entities) {
+		const options = typeof def.options === "object" && def.options !== null ? def.options : {};
+		const table = state.resolved[def.name]?.table;
+		for (const plugin of state.plugins) {
+			const derive = plugin.traits?.derive;
+			if (derive === void 0) continue;
+			const tables = derive({
+				entity: def.name,
+				table,
+				options,
+				schema: state.pgSchema
+			});
+			if (tables === null) continue;
+			const own = {};
+			for (const [key, entry] of Object.entries(tables)) {
+				if (!is(entry.table, PgTable)) throw new ConfigError(`Plugin '${plugin.id}' derives '${key}' for entity '${def.name}', which is not a pg table`, "config", { entity: def.name });
+				if (key in taken || key in out.tables || names.has(key)) throw new ConfigError(`Plugin '${plugin.id}' derives a table '${key}' for entity '${def.name}', and the key is taken`, "config", { entity: def.name });
+				out.tables[key] = entry.table;
+				own[key] = entry.table;
+				if (entry.mirror === true) out.mirrors.set(key, {
+					entity: def.name,
+					plugin: plugin.id
+				});
+			}
+			let byPlugin = out.byEntity.get(def.name);
+			if (byPlugin === void 0) {
+				byPlugin = /* @__PURE__ */ new Map();
+				out.byEntity.set(def.name, byPlugin);
+			}
+			byPlugin.set(plugin.id, own);
+		}
+	}
+	return out;
+}
+function buildDefinition(state, userEntities) {
+	const entities = [];
+	const names = /* @__PURE__ */ new Set();
+	for (const [name, def] of Object.entries(userEntities)) {
+		assertEntityName(name, def, state.resolved, state.plugins);
+		names.add(name);
+		entities.push({
+			def,
+			owner: "user"
+		});
+	}
+	for (const plugin of state.plugins) for (const [name, def] of Object.entries(plugin.entities)) {
+		if (names.has(name)) throw new ConfigError(`Entity '${name}' is defined both by the engine and by plugin '${plugin.id}'`, "config", { entity: name });
+		assertEntityName(name, def, state.resolved, state.plugins);
+		names.add(name);
+		entities.push({
+			def,
+			owner: { plugin: plugin.id }
+		});
+	}
+	const pluginTables = pluginTablesOf(state.plugins);
+	const userTables = tablesOnly(state.tables);
+	const derived = deriveTables(state, entities, {
+		...userTables,
+		...pluginTables
+	});
+	const relations = resolveRelations({
+		...userTables,
+		...pluginTables,
+		...derived.tables
+	}, (r) => {
+		const fragments = fragmentsOf(r, state.userRelations, state.plugins);
+		for (const [key, { entity, plugin }] of derived.mirrors) fragments.push({
+			owner: `plugin '${plugin}'`,
+			config: { [key]: mirrorRelations(r, state.resolved, entity, key) }
+		});
+		return fragments;
+	});
+	const meta = {};
+	for (const { def, owner } of entities) meta[def.name] = buildEntityMeta({
+		name: def.name,
+		options: def.options,
+		table: relations[def.name]?.table,
+		relations,
+		plugins: state.plugins,
+		derived: derived.byEntity.get(def.name) ?? /* @__PURE__ */ new Map(),
+		maxLimit: state.maxLimit,
+		owner
+	});
+	return {
+		$types: void 0,
+		relations,
+		schema: buildKitSchema({
+			tables: state.tables,
+			pgSchema: state.pgSchema,
+			generated: derived.tables,
+			pluginTables
+		}),
+		generated: buildGenerated(derived.tables, pluginTables),
+		entities: meta,
+		plugins: state.plugins,
+		pgSchema: state.pgSchema,
+		maxLimit: state.maxLimit,
+		validation: state.validation
+	};
+}
+function blueprintOf(state) {
+	return {
+		$types: void 0,
+		entity: defineEntity,
+		entities: (userEntities) => buildDefinition(state, userEntities)
+	};
+}
+function pluginsStepOf(settings, tables, pluginDefs) {
+	const plugins = resolvePlugins(pluginDefs, tables);
+	return {
+		plugins: (next) => pluginsStepOf(settings, tables, next),
+		relations: (userRelations) => {
+			const resolved = resolveRelations({
+				...tablesOnly(tables),
+				...pluginTablesOf(plugins)
+			}, (r) => fragmentsOf(r, userRelations, plugins));
+			return blueprintOf({
+				...settings,
+				tables,
+				plugins,
+				userRelations,
+				resolved
+			});
+		}
+	};
+}
+function tablesStepOf(settings) {
+	return { tables: (tables) => {
+		for (const [key, value] of Object.entries(tables)) if (!is(value, PgTable) && !isPgEnum(value)) throw new ConfigError(`tables.${key} is neither a pg table nor a pg enum`);
+		return pluginsStepOf(settings, tables, []);
+	} };
+}
+function defineEngine(options = {}) {
+	const maxLimit = options.maxLimit ?? DEFAULT_MAX_LIMIT;
+	if (!Number.isInteger(maxLimit) || maxLimit < 1) throw new ConfigError("defineEngine: maxLimit must be a positive integer");
+	return tablesStepOf({
+		pgSchema: options.schema ?? typion,
+		validation: options.validation ?? null,
+		maxLimit
+	});
+}
+//#endregion
+//#region src/features/multi-tenant.ts
+const COLUMN$1 = "tenantId";
+function columnOf$1(state) {
+	return state.column;
+}
+function fail$2(entity, message) {
+	throw new ConfigError(`Entity '${entity}': ${message}`, "config", { entity });
+}
+function tenantColumn(entity) {
+	const trait = entity.traits.multiTenant;
+	return trait === void 0 ? null : columnOf$1(trait.state);
+}
+function multiTenant(options) {
+	return defineFeaturePlugin({
+		id: "multiTenant",
+		needsContext: { $type: {} },
+		systemOptions: { $type: {} },
+		context: (base, input) => {
+			const unscoped = input.options?.unscoped;
+			if (unscoped !== void 0 && typeof unscoped !== "boolean") throw new BadRequestError("unscoped must be a boolean");
+			if (unscoped === true && base.mode !== "system") throw new BadRequestError("unscoped is an option of $system(): a caller always has a tenant");
+			return { unscoped: base.mode === "system" && (unscoped === true || input.callerLookup === true) };
+		},
+		traits: {
+			$types: {},
+			resolve: ({ entity, options: given, columns }) => {
+				const option = given.tenant;
+				if (option === void 0 || option === false) return null;
+				if (option !== true) fail$2(entity, "tenant must be true");
+				if (columns[COLUMN$1] === void 0) fail$2(entity, `tenant needs a column '${COLUMN$1}'`);
+				return {
+					state: { column: COLUMN$1 },
+					managed: [COLUMN$1]
+				};
+			},
+			partition: ({ entity, state, ctx }) => {
+				if (ctx.mode === "system" && ctx.unscoped === true) return void 0;
+				const tenant = ctx.tenantId;
+				if (tenant === null || tenant === void 0) {
+					const hint = ctx.mode === "system" ? " (pass it through $system({ ctx }) or cross tenants with $system({ unscoped: true }))" : "";
+					throw new ForbiddenError(`Entity '${entity.name}' belongs to a tenant, and the context has none${hint}`, {
+						entity: entity.name,
+						rule: "tenant"
+					});
+				}
+				return { [columnOf$1(state)]: tenant };
+			}
+		},
+		seed: { columns: (entity, { generators, values }) => {
+			const column = tenantColumn(entity);
+			if (column === null) return {};
+			const tenant = values.tenant ?? options.seedTenant;
+			if (tenant === void 0 && entity.columns[column]?.notNull === true) throw new Error(`Collection '${entity.name}' belongs to a tenant: give one with multiTenant({ seedTenant }) or defineConfig({ seed: { values: { tenant } } })`);
+			return { [column]: generators.default({ defaultValue: tenant ?? null }) };
+		} },
+		collection: {
+			$options: {},
+			$kinds: {},
+			consumes: ["tenant"],
+			columns: (collection) => collection.tenant === true ? { [COLUMN$1]: options.column() } : {},
+			entity: (collection) => collection.tenant === true ? { tenant: true } : {}
+		}
+	});
+}
+//#endregion
+//#region src/features/soft-delete.ts
+function softDeleteColumns() {
+	return { deletedAt: timestamp("deleted_at", { withTimezone: true }) };
+}
+function softUnique(name, deletedAt) {
+	return { on: (...cols) => uniqueIndex(name).on(...cols).where(sql`${deletedAt} is null`) };
+}
+const COLUMN = "deletedAt";
+function columnOf(state) {
+	return state.column;
+}
+function fail$1(entity, message) {
+	throw new ConfigError(`Entity '${entity}': ${message}`, "config", { entity });
+}
+function softDeleteColumn(entity) {
+	const trait = entity.traits.softDelete;
+	return trait === void 0 ? null : columnOf(trait.state);
+}
+function softDelete() {
+	return defineFeaturePlugin({
+		id: "softDelete",
+		traits: {
+			$types: {},
+			options: {
+				read: { withDeleted: "boolean" },
+				delete: { hard: "boolean" }
+			},
+			resolve: ({ entity, options, columns }) => {
+				const option = options.softDelete;
+				if (option === void 0 || option === false) return null;
+				if (option !== true) fail$1(entity, "softDelete must be true");
+				const column = columns[COLUMN];
+				if (column === void 0 || column.dataType !== "object date" || column.notNull) fail$1(entity, `softDelete needs a nullable timestamp column '${COLUMN}'`);
+				return {
+					state: { column: COLUMN },
+					managed: [COLUMN]
+				};
+			},
+			filter: ({ state, operation, options }) => {
+				const column = columnOf(state);
+				if (operation === "restore") return { [column]: { isNotNull: true } };
+				if (options.withDeleted === true || options.hard === true) return void 0;
+				return { [column]: { isNull: true } };
+			},
+			remove: ({ state, options, now, update }) => options.hard === true ? void 0 : update({ [columnOf(state)]: now }),
+			operations: { restore: {
+				args: ["id"],
+				route: {
+					method: "POST",
+					path: ":id/restore"
+				},
+				run: ({ state, input, kit }) => kit.update(input.id, { [columnOf(state)]: null })
+			} }
+		},
+		seed: { columns: (entity, { generators }) => {
+			const column = softDeleteColumn(entity);
+			return column === null ? {} : { [column]: generators.default({ defaultValue: null }) };
+		} },
+		collection: {
+			$options: {},
+			$kinds: {},
+			consumes: ["softDelete"],
+			columns: (options) => options.softDelete === true ? softDeleteColumns() : {},
+			entity: (options) => options.softDelete === true ? { softDelete: true } : {}
+		}
+	});
+}
+//#endregion
+//#region src/features/versions/history.ts
+const STATUS = "status";
+const PUBLISHED_AT = "publishedAt";
+function col(table, key) {
+	return table[key];
+}
+function stateOf(state, doc) {
+	if (!state.drafts) return "published";
+	return doc["status"] === "published" ? "published" : "draft";
+}
+function entityData(entity, row) {
+	const out = {};
+	for (const key of Object.keys(entity.columns)) out[key] = row[key];
+	return out;
+}
+function generatedAlways(entity, key) {
+	const column = entity.columns[key]?.column;
+	return column?.generated?.type === "always" || column?.generatedIdentity?.type === "always";
+}
+function contentPatch(entity, from, to) {
+	const skip = /* @__PURE__ */ new Set([entity.pk.key, ...entity.managedKeys]);
+	const patch = {};
+	for (const key of Object.keys(entity.columns)) {
+		if (skip.has(key) || generatedAlways(entity, key)) continue;
+		if (entity.columns[key]?.column.onUpdateFn !== void 0) continue;
+		if (!equal(from[key], to[key])) patch[key] = to[key];
+	}
+	return patch;
+}
+function equal(a, b) {
+	if (Object.is(a, b)) return true;
+	if (a instanceof Date || b instanceof Date) return a instanceof Date && b instanceof Date && a.getTime() === b.getTime();
+	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+	if (Array.isArray(a) !== Array.isArray(b)) return false;
+	if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((item, i) => equal(item, b[i]));
+	const left = a;
+	const right = b;
+	const keys = /* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)]);
+	for (const key of keys) if (!equal(left[key], right[key])) return false;
+	return true;
+}
+async function latestVersion(tx, entity, state, id) {
+	const { table } = state;
+	return (await tx.select().from(table).where(and(eq(col(table, entity.pk.key), id), eq(col(table, "versionIsLatest"), true))).limit(1))[0] ?? null;
+}
+async function pendingDraft(tx, entity, state, row) {
+	if (!state.drafts || row["status"] !== "published") return null;
+	const latest = await latestVersion(tx, entity, state, row[entity.pk.key]);
+	return latest !== null && latest.versionState === "draft" ? entityData(entity, latest) : null;
+}
+async function recordVersion(tx, entity, state, doc, versionState, operation, ctx) {
+	const { table } = state;
+	const idColumn = col(table, entity.pk.key);
+	const id = doc[entity.pk.key];
+	const [next] = await tx.select({ value: sql`coalesce(max(${col(table, "versionNumber")}), 0) + 1`.mapWith(Number) }).from(table).where(eq(idColumn, id));
+	await tx.update(table).set({ versionIsLatest: false }).where(and(eq(idColumn, id), eq(col(table, "versionIsLatest"), true)));
+	const [row] = await tx.insert(table).values({
+		...entityData(entity, doc),
+		versionNumber: next?.value ?? 1,
+		versionIsLatest: true,
+		versionState,
+		versionOperation: operation,
+		versionCreatedBy: ctx.actorId,
+		versionMode: ctx.mode,
+		versionSystemReason: ctx.systemReason,
+		versionRequestId: ctx.requestId
+	}).returning();
+	await prune(tx, entity, state, id);
+	return {
+		versionId: row?.versionId,
+		versionNumber: row?.versionNumber,
+		state: versionState
+	};
+}
+async function prune(tx, entity, state, id) {
+	if (state.max === null) return;
+	const { table } = state;
+	const rows = await tx.select({
+		id: col(table, "versionId"),
+		state: col(table, "versionState"),
+		latest: col(table, "versionIsLatest")
+	}).from(table).where(eq(col(table, entity.pk.key), id)).orderBy(desc(col(table, "versionNumber")));
+	if (rows.length <= state.max) return;
+	const keep = new Set(rows.slice(0, state.max).map((r) => r.id));
+	const lastPublished = rows.find((r) => r.state === "published");
+	if (lastPublished !== void 0) keep.add(lastPublished.id);
+	const latest = rows.find((r) => r.latest);
+	if (latest !== void 0) keep.add(latest.id);
+	const drop = rows.filter((r) => !keep.has(r.id)).map((r) => r.id);
+	if (drop.length > 0) await tx.delete(table).where(inArray(col(table, "versionId"), drop));
+}
+function toVersion(entity, row) {
+	const data = {};
+	for (const key of entity.visibleKeys) data[key] = row[key];
+	return {
+		versionId: row.versionId,
+		versionNumber: row.versionNumber,
+		state: row.versionState,
+		operation: row.versionOperation,
+		isLatest: row.versionIsLatest,
+		createdAt: row.versionCreatedAt,
+		createdBy: row.versionCreatedBy,
+		mode: row.versionMode,
+		systemReason: row.versionSystemReason,
+		requestId: row.versionRequestId,
+		data
+	};
+}
+//#endregion
+//#region src/features/versions/table.ts
+function draftColumns() {
+	return {
+		status: text("status", { enum: ["draft", "published"] }).notNull().default("draft"),
+		publishedAt: timestamp("published_at", { withTimezone: true })
+	};
+}
+const VERSION_STATES = ["draft", "published"];
+const VERSION_MODES = ["user", "system"];
+const VERSION_COLUMNS = () => ({
+	versionId: uuid("version_id").primaryKey().defaultRandom(),
+	versionNumber: integer("version_number").notNull(),
+	versionIsLatest: boolean("version_is_latest").notNull().default(false),
+	versionState: text("version_state", { enum: VERSION_STATES }).notNull(),
+	versionOperation: text("version_operation").notNull(),
+	versionCreatedAt: timestamp("version_created_at", { withTimezone: true }).notNull().defaultNow(),
+	versionCreatedBy: text("version_created_by"),
+	versionMode: text("version_mode", { enum: VERSION_MODES }).notNull(),
+	versionSystemReason: text("version_system_reason"),
+	versionRequestId: text("version_request_id")
+});
+function singlePrimaryKey(source) {
+	const tableName = getTableName(source);
+	if (getTableConfig(source).primaryKeys.length > 0) throw new ConfigError(`Versioned table '${tableName}' has a composite primary key; versions need a single-column pk`);
+	const pks = Object.entries(getTableColumns(source)).filter(([, c]) => c.primary);
+	const first = pks[0];
+	if (first === void 0 || pks.length !== 1) throw new ConfigError(`Versioned table '${tableName}' must have exactly one primary-key column (found ${pks.length})`);
+	return {
+		key: first[0],
+		column: first[1]
+	};
+}
+function buildVersionsTable(source, opts) {
+	const sourceName = getTableName(source);
+	const name = opts.name ?? `${sourceName}_versions`;
+	const pk = singlePrimaryKey(source);
+	const bookkeeping = VERSION_COLUMNS();
+	const cloned = {};
+	for (const [key, column] of Object.entries(getTableColumns(source))) {
+		if (key in bookkeeping || column.name.startsWith("version_")) throw new ConfigError(`Versioned table '${sourceName}': column '${key}' ('${column.name}') collides with the version_* bookkeeping columns`);
+		cloned[key] = cloneColumn(column, { keepDefault: key !== pk.key });
+	}
+	const columns = {
+		...bookkeeping,
+		...cloned
+	};
+	return opts.schema.table(name, columns, (t) => {
+		const id = t[pk.key];
+		const number = t.versionNumber;
+		const latest = t.versionIsLatest;
+		const createdAt = t.versionCreatedAt;
+		return [
+			foreignKey({
+				name: `${name}_doc_fk`,
+				columns: [id],
+				foreignColumns: [pk.column]
+			}).onDelete("cascade"),
+			unique(`${name}_doc_number`).on(id, number),
+			uniqueIndex(`${name}_latest`).on(id).where(sql`${latest}`),
+			index(`${name}_created`).on(id, createdAt.desc())
+		];
+	});
+}
+//#endregion
+//#region src/features/versions/index.ts
+function fail(entity, message) {
+	throw new ConfigError(`Entity '${entity}': ${message}`, "config", { entity });
+}
+function parse(entity, option) {
+	if (option === void 0 || option === false) return null;
+	if (option !== true && (typeof option !== "object" || option === null)) fail(entity, "versions must be true or an object");
+	const opts = option === true ? {} : option;
+	for (const key of Object.keys(opts)) if (![
+		"drafts",
+		"max",
+		"onPendingDraft",
+		"table"
+	].includes(key)) fail(entity, `versions.${key} is not an option`);
+	const { drafts, max, onPendingDraft, table } = opts;
+	if (drafts !== void 0 && typeof drafts !== "boolean") fail(entity, "versions.drafts must be a boolean");
+	if (max !== void 0 && (!Number.isInteger(max) || max < 1)) fail(entity, "versions.max must be a positive integer");
+	if (onPendingDraft !== void 0 && onPendingDraft !== "supersede" && onPendingDraft !== "reject") fail(entity, `versions.onPendingDraft must be 'supersede' or 'reject'`);
+	if (table !== void 0 && !is(table, PgTable)) fail(entity, "versions.table is not a pg table");
+	return {
+		drafts: drafts === true,
+		max: max ?? null,
+		onPendingDraft: onPendingDraft ?? "supersede",
+		table
+	};
+}
+function keyOf(entity) {
+	return `${entity}Versions`;
+}
+function versionsState(state) {
+	return state;
+}
+function versionsTable(entity) {
+	const trait = entity.traits.versions;
+	return trait === void 0 ? null : versionsState(trait.state).table;
+}
+function recordedAs(operation, draft) {
+	if (operation === "update") return draft ? "draft" : "update";
+	if (operation === "versions.restore") return "restoreVersion";
+	if (operation === "discardDraft") return "discard";
+	return operation;
+}
+function assertId(entity, id) {
+	if (id === void 0 || id === null) throw new BadRequestError(`${entity.name}: an id is required`, { entity: entity.name });
+}
+function history(entity, state, { executor, partition }, id) {
+	const { table } = state;
+	return {
+		executor,
+		table,
+		conditions: [eq(col(table, entity.pk.key), id), ...Object.entries(partition).map(([key, value]) => eq(col(table, key), value))]
+	};
+}
+async function loadVersion(entity, state, input, id, versionId) {
+	if (typeof versionId !== "string") throw new BadRequestError("versionId must be a string");
+	const { executor, table, conditions } = history(entity, state, input, id);
+	const row = (await executor.select().from(table).where(and(...conditions, eq(col(table, "versionId"), versionId))).limit(1))[0];
+	if (row === void 0) throw new NotFoundError(`Version '${versionId}' of ${entity.name} '${String(id)}' not found`, { entity: entity.name });
+	return row;
+}
+function readVersions(kit, fn) {
+	return kit.read(fn, { rule: "readVersions" });
+}
+function versions() {
+	return defineFeaturePlugin({
+		id: "versions",
+		traits: {
+			$types: {},
+			options: {
+				read: { draft: "boolean" },
+				create: {
+					draft: "boolean",
+					publish: "boolean"
+				},
+				update: { draft: "boolean" }
+			},
+			rules: {
+				readDrafts: "filter",
+				readVersions: "boolean",
+				publish: "filter"
+			},
+			hookArgs: {
+				change: { draft: false },
+				afterChange: {
+					previousDraft: null,
+					version: null
+				},
+				afterDelete: { version: null }
+			},
+			derive: ({ entity, table, options, schema }) => {
+				const parsed = parse(entity, options.versions);
+				if (parsed === null) return null;
+				return { [keyOf(entity)]: {
+					table: parsed.table ?? buildVersionsTable(table, { schema }),
+					mirror: true
+				} };
+			},
+			resolve: ({ entity, options, columns, derived }) => {
+				const parsed = parse(entity, options.versions);
+				if (parsed === null) return null;
+				if (parsed.drafts) {
+					for (const key of [STATUS, PUBLISHED_AT]) if (!(key in columns)) fail(entity, `versions.drafts needs a column '${key}' (add draftColumns() to the table)`);
+					const values = columns[STATUS]?.enumValues;
+					if (values !== void 0 && !(values.includes("draft") && values.includes("published"))) fail(entity, `versions.drafts needs status to allow 'draft' and 'published'`);
+				}
+				const key = keyOf(entity);
+				const state = {
+					key,
+					table: derived[key],
+					drafts: parsed.drafts,
+					max: parsed.max,
+					onPendingDraft: parsed.onPendingDraft
+				};
+				return parsed.drafts ? {
+					state,
+					managed: [STATUS, PUBLISHED_AT],
+					options: [
+						"read",
+						"create",
+						"update"
+					]
+				} : {
+					state,
+					options: [],
+					rules: ["readVersions"]
+				};
+			},
+			filter: ({ state, writing }) => versionsState(state).drafts && !writing ? { [STATUS]: { eq: "published" } } : void 0,
+			source: ({ state, options }) => options.draft === true ? {
+				table: versionsState(state).key,
+				filter: { versionIsLatest: { eq: true } },
+				rule: "readDrafts"
+			} : void 0,
+			create: ({ state, options, row, now }) => {
+				if (!versionsState(state).drafts) return void 0;
+				const publish = options.publish === true;
+				return {
+					set: publish ? {
+						[STATUS]: "published",
+						[PUBLISHED_AT]: row["publishedAt"] ?? now
+					} : {},
+					rules: publish ? ["publish"] : [],
+					args: { change: { draft: options.draft === true } }
+				};
+			},
+			update: async ({ entity, state: raw, operation, options, row, tx }) => {
+				const state = versionsState(raw);
+				if (!state.drafts) return void 0;
+				const pending = await pendingDraft(tx, entity, state, row);
+				const after = { afterChange: { previousDraft: pending } };
+				if (operation === "publish" || operation === "unpublish") return { args: after };
+				if (operation === "discardDraft") return {
+					base: pending ?? row,
+					keep: true,
+					args: after
+				};
+				if ((options.draft ?? operation === "versions.restore") === true && row["status"] === "published") return {
+					base: pending ?? row,
+					keep: true,
+					args: {
+						...after,
+						change: { draft: true }
+					}
+				};
+				if (pending !== null && state.onPendingDraft === "reject") throw new InvalidStateError(`${entity.name} '${String(row[entity.pk.key])}' has a pending draft: publish or discard it first`, { entity: entity.name });
+				return { args: after };
+			},
+			record: async ({ entity, state: raw, operation, step, row, written, tx, ctx }) => {
+				const state = versionsState(raw);
+				if (step === "delete" && written) return void 0;
+				const draft = step === "update" && !written && state.drafts;
+				return { version: await recordVersion(tx, entity, state, row, operation === "discardDraft" ? "published" : draft ? "draft" : stateOf(state, row), step === "update" ? recordedAs(operation, draft) : operation, ctx) };
+			},
+			operations: {
+				publish: {
+					args: ["id"],
+					route: {
+						method: "POST",
+						path: ":id/publish"
+					},
+					run: ({ entity, state, input, kit }) => kit.update(input.id, async ({ row, tx, now }) => {
+						const pending = await pendingDraft(tx, entity, versionsState(state), row);
+						if (row["status"] === "published" && pending === null) return void 0;
+						return {
+							...pending === null ? {} : contentPatch(entity, row, pending),
+							[STATUS]: "published",
+							[PUBLISHED_AT]: now
+						};
+					}, { rule: "publish" })
+				},
+				unpublish: {
+					args: ["id"],
+					route: {
+						method: "POST",
+						path: ":id/unpublish"
+					},
+					run: ({ entity, input, kit }) => kit.update(input.id, ({ row }) => {
+						if (row["status"] !== "published") throw new InvalidStateError(`${entity.name} '${String(input.id)}' is not published`, { entity: entity.name });
+						return { [STATUS]: "draft" };
+					}, { rule: "publish" })
+				},
+				discardDraft: {
+					args: ["id"],
+					route: {
+						method: "POST",
+						path: ":id/discard-draft"
+					},
+					run: ({ entity, state, input, kit }) => kit.update(input.id, async ({ row, tx }) => {
+						const pending = await pendingDraft(tx, entity, versionsState(state), row);
+						return pending === null ? void 0 : contentPatch(entity, pending, row);
+					})
+				},
+				"versions.list": {
+					args: ["id"],
+					options: {
+						limit: "number",
+						offset: "number",
+						state: "string"
+					},
+					route: {
+						method: "GET",
+						path: ":id/versions"
+					},
+					run: ({ entity, state, input, kit }) => {
+						assertId(entity, input.id);
+						const limit = input.limit ?? entity.maxLimit;
+						const offset = input.offset ?? 0;
+						for (const [name, value] of [["limit", limit], ["offset", offset]]) if (typeof value !== "number" || !Number.isInteger(value) || value < 0) throw new BadRequestError(`${name} must be a non-negative integer`);
+						if (limit > entity.maxLimit) throw new BadRequestError(`limit exceeds the maximum of ${entity.maxLimit}`);
+						if (input.state !== void 0 && input.state !== "draft" && input.state !== "published") throw new BadRequestError(`state must be 'draft' or 'published'`);
+						return readVersions(kit, async (read) => {
+							const { executor, table, conditions } = history(entity, versionsState(state), read, input.id);
+							return (await executor.select().from(table).where(and(...conditions, input.state === void 0 ? void 0 : eq(col(table, "versionState"), input.state))).orderBy(desc(col(table, "versionNumber"))).limit(limit).offset(offset)).map((row) => toVersion(entity, row));
+						});
+					}
+				},
+				"versions.get": {
+					args: ["id", "versionId"],
+					route: {
+						method: "GET",
+						path: ":id/versions/:versionId"
+					},
+					run: ({ entity, state, input, kit }) => {
+						assertId(entity, input.id);
+						return readVersions(kit, async (read) => toVersion(entity, await loadVersion(entity, versionsState(state), read, input.id, input.versionId)));
+					}
+				},
+				"versions.diff": {
+					args: [
+						"id",
+						"from",
+						"to"
+					],
+					route: {
+						method: "GET",
+						path: ":id/diff"
+					},
+					run: ({ entity, state, input, kit }) => {
+						assertId(entity, input.id);
+						return readVersions(kit, async (read) => {
+							const before = await loadVersion(entity, versionsState(state), read, input.id, input.from);
+							const after = await loadVersion(entity, versionsState(state), read, input.id, input.to);
+							const out = [];
+							for (const key of entity.visibleKeys) if (!equal(before[key], after[key])) out.push({
+								field: key,
+								before: before[key],
+								after: after[key]
+							});
+							return out;
+						});
+					}
+				},
+				"versions.restore": {
+					args: ["id", "versionId"],
+					options: { draft: "boolean" },
+					route: {
+						method: "POST",
+						path: ":id/versions/:versionId/restore"
+					},
+					run: ({ entity, state: raw, input, kit }) => {
+						const state = versionsState(raw);
+						if (typeof input.versionId !== "string") throw new BadRequestError("versionId must be a string");
+						if (input.draft === true && !state.drafts) throw new UnsupportedError(`Entity '${entity.name}' has no drafts`, { entity: entity.name });
+						return kit.update(input.id, async ({ row, tx }) => {
+							const { table } = state;
+							const version = (await tx.select().from(table).where(and(eq(col(table, entity.pk.key), input.id), eq(col(table, "versionId"), input.versionId))).limit(1))[0];
+							if (version === void 0) throw new NotFoundError(`Version '${input.versionId}' of ${entity.name} '${String(input.id)}' not found`, { entity: entity.name });
+							return contentPatch(entity, row, entityData(entity, version));
+						}, { options: { draft: input.draft } });
+					}
+				}
+			}
+		},
+		seed: { columns: (entity, { generators }) => {
+			const trait = entity.traits.versions;
+			return trait !== void 0 && versionsState(trait.state).drafts ? {
+				[STATUS]: generators.default({ defaultValue: "published" }),
+				[PUBLISHED_AT]: generators.default({ defaultValue: /* @__PURE__ */ new Date() })
+			} : {};
+		} },
+		collection: {
+			$options: {},
+			$kinds: {},
+			consumes: ["versions"],
+			columns: (options) => typeof options.versions === "object" && options.versions !== null && options.versions.drafts === true ? draftColumns() : {},
+			entity: (options) => options.versions === void 0 ? {} : { versions: options.versions }
+		}
+	});
+}
+//#endregion
+//#region src/features/index.ts
+const FEATURE_IDS = /* @__PURE__ */ new Set([
+	"localization",
+	"versions",
+	"softDelete",
+	"multiTenant"
+]);
+function featurePlugins(options) {
+	const plugins = [];
+	if (options.localization !== void 0) plugins.push(localization(options.localization));
+	plugins.push(versions(), softDelete());
+	if (options.multiTenant !== void 0) plugins.push(multiTenant(options.multiTenant));
+	return plugins;
+}
+//#endregion
+//#region src/define/setup.ts
+function defineSetup(options) {
+	const plugins = featurePlugins(options);
+	const ids = new Set(plugins.map((plugin) => plugin.id));
+	for (const plugin of options.plugins ?? []) {
+		if (FEATURE_IDS.has(plugin.id)) throw new ConfigError(`Plugin '${plugin.id}' has the name of a feature of the core`);
+		if (ids.has(plugin.id)) throw new ConfigError(`Plugin '${plugin.id}' is installed twice`);
+		ids.add(plugin.id);
+		plugins.push(plugin);
+	}
+	checkDependencies(plugins);
+	const out = { "~plugins": Object.freeze(plugins) };
+	const localization = plugins.find((plugin) => plugin.id === "localization");
+	if (localization !== void 0) out.localization = Object.freeze({
+		locales: localization.locales,
+		defaultLocale: localization.defaultLocale
+	});
+	return Object.freeze(out);
+}
+function defaultSetup() {
+	return { "~plugins": featurePlugins({}) };
+}
+//#endregion
+//#region src/define/config.ts
+function enumsOf(tables) {
+	const out = /* @__PURE__ */ new Map();
+	for (const table of tables) for (const column of Object.values(getTableColumns(table))) {
+		const candidate = column.enum;
+		if (isPgEnum(candidate)) out.set(candidate, candidate.enumName);
+	}
+	return out;
+}
+function relationConfig(r, name, field, spec, collections, plainTables) {
+	const where = `Relation '${name}.${field}'`;
+	if (!collections.has(spec.target)) throw new ConfigError(`${where} targets '${spec.target}', which is not a collection of this config`);
+	const source = r[name];
+	const target = r[spec.target];
+	const from = source[spec.from];
+	const to = target[spec.to];
+	if (from === void 0) throw new ConfigError(`${where}: collection '${name}' has no column '${spec.from}'`);
+	if (to === void 0) throw new ConfigError(`${where}: collection '${spec.target}' has no column '${spec.to}'`);
+	if (spec.kind === "one") return r.one[spec.target]({
+		from,
+		to,
+		optional: spec.optional
+	});
+	const through = spec.through;
+	if (through === void 0) return r.many[spec.target]({
+		from,
+		to
+	});
+	if (!plainTables.has(through.table)) throw new ConfigError(`${where} goes through '${through.table}', which is not in the config's tables (a collection cannot be the join: its rules would be bypassed)`);
+	const join = r[through.table];
+	const joinFrom = join[through.from];
+	const joinTo = join[through.to];
+	if (joinFrom === void 0 || joinTo === void 0) throw new ConfigError(`${where}: table '${through.table}' has no column '${joinFrom === void 0 ? through.from : through.to}'`);
+	return r.many[spec.target]({
+		from: from.through(joinFrom),
+		to: to.through(joinTo)
+	});
+}
+function defineConfig(options) {
+	const plugins = (options.setup ?? defaultSetup())["~plugins"];
+	const ids = new Set(plugins.map((plugin) => plugin.id));
+	const collections = {};
+	const tables = {};
+	for (const entry of options.collections) {
+		if (entry.name in collections) throw new ConfigError(`Collection '${entry.name}' is listed twice`);
+		collections[entry.name] = entry;
+		const table = buildCollectionTable(plugins, entry);
+		tables[entry.name] = table;
+		const tenant = entry["~runtime"].structure.tenant;
+		if (tenant !== void 0 && tenant !== false && !ids.has("multiTenant")) throw new ConfigError(`Collection '${entry.name}' belongs to a tenant, and the setup configures no multi-tenancy (defineSetup({ multiTenant }))`);
+		if (!ids.has("localization")) {
+			for (const [key, column] of Object.entries(getTableColumns(table))) if (readColumnKind(column) === localizedKind.id) throw new ConfigError(`Collection '${entry.name}': column '${key}' is localized, and the setup configures no localization (defineSetup({ localization }))`);
+		}
+	}
+	const plainTables = /* @__PURE__ */ new Set();
+	for (const [key, value] of Object.entries(options.tables ?? {})) {
+		if (key in collections) throw new ConfigError(`tables.${key} has the name of a collection`);
+		tables[key] = value;
+		if (is(value, PgTable)) plainTables.add(key);
+	}
+	const listed = new Set(Object.values(tables));
+	for (const [found, enumName] of enumsOf(Object.values(tables).filter((value) => is(value, PgTable)))) {
+		if (listed.has(found)) continue;
+		if (enumName in tables) throw new ConfigError(`Enum '${enumName}' is used by a column, and the config already has a table or an enum under that key`);
+		tables[enumName] = found;
+	}
+	const names = new Set(Object.keys(collections));
+	const blueprint = defineEngine({
+		maxLimit: options.maxLimit,
+		validation: options.validation
+	}).tables(tables).plugins(plugins).relations((r) => {
+		const config = {};
+		for (const [name, entry] of Object.entries(collections)) {
+			const record = {};
+			for (const [field, spec] of Object.entries(entry["~runtime"].relations)) record[field] = relationConfig(r, name, field, spec, names, plainTables);
+			config[name] = record;
+		}
+		return config;
+	});
+	const entities = {};
+	for (const [name, entry] of Object.entries(collections)) entities[name] = blueprint.entity(name, collectionEntityOptions(plugins, entry));
+	const definition = blueprint.entities(entities);
+	return {
+		definition,
+		schema: definition.schema,
+		db: options.db,
+		context: options.context,
+		migrations: options.migrations,
+		seed: options.seed,
+		onAfterCommitError: options.onAfterCommitError,
+		checkSchema: options.checkSchema
+	};
+}
+//#endregion
+//#region src/db/adapter.ts
+function dbAdapter(connect, options = {}) {
+	return {
+		connect,
+		check: () => {
+			if ("url" in options && (options.url === void 0 || options.url === "")) throw new ConfigError("The config's database url is empty: set the variable it reads (DATABASE_URL?) in the environment or in .env");
+		},
+		...options.close === void 0 ? {} : { close: options.close },
+		...options.url === void 0 ? {} : { credentials: () => ({ url: options.url }) }
+	};
+}
+//#endregion
+export { BadRequestError, ConfigError, ConflictError, ForbiddenError, InternalError, InvalidStateError, NotFoundError, PluginError, TypionError, UnsupportedError, ValidationError, allowAll, attempt, collection, dbAdapter, defineConfig, definePlugin, defineSetup, getTypion, isTypionError, localized, localizedIndex, localizedUnique, localizedValue, softDeleteColumn, softUnique, structuralValidation, tenantColumn, versionsTable };
+
+//# sourceMappingURL=index.js.map