better-supabase 0.12.0 → 0.14.0

package/dist/cli/emit-56LAG_Px.js

@@ -1,1067 +0,0 @@
-import { n as CliError } from "./errors-Caiz_0so.js";
-import { t as byCodePoint } from "./compare-BmIWVEui.js";
-import { s as restrictSchemas, u as tsTypeOf } from "./typegen--TfvOPLh.js";
-import { t as isRecord } from "./guards-CUlDNYZs.js";
-import { t as toCatalog } from "./catalog-Cm6BtquM.js";
-import { resolveProviderSql } from "better-supabase/sql";
-import { DEFAULT_CLAIMS, tenantClaimPaths } from "better-supabase/config";
-import { toCamel } from "better-supabase";
-//#region src/cli/gen/comment.ts
-/**
-* The metadata a `COMMENT ON` adds to a table or column: its description,
-* without the `@example` lines the validator generators read, and
-* `deprecated` when a line starts with `@deprecated`. The library's
-* `parseComment` (`src/generators/shared.ts`) reads comments the same way.
-*/
-function commentMeta(comment) {
-	if (!comment) return {};
-	const deprecated = /^\s*@deprecated\b/m.test(comment);
-	const description = comment.replaceAll(/^\s*@example\s+(.+?)\s*$/gm, "").replaceAll(/^\s*@deprecated\b.*$/gm, "").trim();
-	return {
-		...description ? { description } : {},
-		...deprecated ? { deprecated: true } : {}
-	};
-}
-//#endregion
-//#region src/cli/gen/model-types.ts
-const applyCasing = (name, casing) => casing === "camel" ? toCamel(name) : name;
-const CODEC_TYPE = {
-	instant: "Temporal.Instant",
-	plainDateTime: "Temporal.PlainDateTime",
-	bigint: "bigint",
-	string: "string"
-};
-function codecFor(udt, config) {
-	const { codecs } = config;
-	if (codecs.timestamptz === "instant") {
-		if (udt === "timestamptz") return "instant";
-		if (udt === "timestamp") return "plainDateTime";
-	}
-	if (udt === "int8" && codecs.int8 !== "number") return codecs.int8;
-	if (udt === "numeric" && codecs.numeric === "string") return "string";
-}
-function enumType(values) {
-	return values.map((value) => JSON.stringify(value)).join(" | ");
-}
-//#endregion
-//#region src/cli/gen/shared.ts
-const q = (value) => JSON.stringify(value);
-/** A property key: bare when it is a valid identifier, quoted otherwise. */
-function prop(name) {
-	return /^[A-Za-z_$][\w$]*$/.test(name) ? name : q(name);
-}
-function nullable(type, isNullable) {
-	return isNullable ? `${type} | null` : type;
-}
-/** `T[]`, parenthesized when `T` is a union or other compound type. */
-function arrayOf(type) {
-	return /^[\w.$]+$/.test(type) ? `${type}[]` : `(${type})[]`;
-}
-function indent(lines, depth) {
-	const pad = "  ".repeat(depth);
-	return lines.flatMap((line) => line.split("\n")).map((line) => line === "" ? line : pad + line);
-}
-/** `name: {` + indented children + `};`, or an inline empty type. */
-function block(name, children, empty = "{ [_ in never]: never }") {
-	if (children.length === 0) return [`${name}: ${empty};`];
-	return [
-		`${name}: {`,
-		...indent(children, 1),
-		"};"
-	];
-}
-function sameColumns(left, right) {
-	return left.length === right.length && left.every((column) => right.includes(column));
-}
-function singular(name) {
-	if (name.endsWith("ies")) return `${name.slice(0, -3)}y`;
-	if (name.endsWith("sses")) return name.slice(0, -2);
-	if (name.endsWith("s") && !name.endsWith("ss")) return name.slice(0, -1);
-	return name;
-}
-function pascal(name) {
-	return name.replaceAll(/(^|[_-]+)([a-z0-9])/g, (_, __, char) => char.toUpperCase()).replace(/^[a-z]/, (char) => char.toUpperCase());
-}
-/** A valid TypeScript identifier: other characters become `_`, a leading digit gets one. */
-function identifier(name) {
-	const safe = name.replaceAll(/[^\w$]/g, "_");
-	return /^\d/.test(safe) ? `_${safe}` : safe;
-}
-/**
-* The config entry for a database object, keyed `schema.name` or `name`.
-* The qualified key wins.
-*/
-function configFor(entries, schema, name) {
-	return entries[`${schema}.${name}`] ?? entries[name];
-}
-function isJsonUdt(udt) {
-	return udt === "json" || udt === "jsonb";
-}
-const CHECK_ANY = /^CHECK \(\(\(?"?(\w+)"?\)?(?:::\w+)? = ANY \(\(?ARRAY\[(.+)\]\)?(?:::\w+\[\])?\)\)\)$/;
-const CHECK_OR = /^CHECK \(\((.+)\)\)$/;
-const OR_TERM = /^\(?"?(\w+)"?\)?(?:::\w+)? = '((?:[^']|'')*)'(?:::\w+)?\)?$/;
-const LITERAL = /'((?:[^']|'')*)'(?:::[\w ]+)?/g;
-/**
-* Extracts `column in ('a', 'b')` CHECK constraints, which Postgres stores as
-* `CHECK ((col = ANY (ARRAY['a'::text, 'b'::text])))` or an OR chain.
-*/
-function parseCheckUnion(definition) {
-	const any = CHECK_ANY.exec(definition);
-	if (any?.[1] && any[2]) {
-		const values = [...any[2].matchAll(LITERAL)].map((match) => (match[1] ?? "").replaceAll("''", "'"));
-		return values.length > 0 ? {
-			column: any[1],
-			values
-		} : void 0;
-	}
-	const chain = CHECK_OR.exec(definition);
-	if (chain?.[1]) {
-		const terms = chain[1].split(/\) OR \(|\s+OR\s+/);
-		let column;
-		const values = [];
-		for (const term of terms) {
-			const match = OR_TERM.exec(term.trim());
-			if (!match?.[1]) return;
-			if (column && column !== match[1]) return;
-			column = match[1];
-			values.push((match[2] ?? "").replaceAll("''", "'"));
-		}
-		return column && values.length > 1 ? {
-			column,
-			values
-		} : void 0;
-	}
-}
-/** The text inside one pair of parentheses that wraps all of `text`, if any. */
-function unwrap(text) {
-	let current = text.trim();
-	while (current.startsWith("(") && current.endsWith(")")) {
-		let depth = 0;
-		let wraps = true;
-		for (let index = 0; index < current.length; index++) {
-			const char = current[index];
-			if (char === "(") depth++;
-			else if (char === ")") depth--;
-			if (depth === 0 && index < current.length - 1) {
-				wraps = false;
-				break;
-			}
-		}
-		if (!wraps) break;
-		current = current.slice(1, -1).trim();
-	}
-	return current;
-}
-/** Splits `text` on a keyword outside parentheses and quotes. */
-function splitTopLevel(text, keyword) {
-	const parts = [];
-	let depth = 0;
-	let quote;
-	let start = 0;
-	const separator = ` ${keyword} `;
-	for (let index = 0; index < text.length; index++) {
-		const char = text[index];
-		if (quote) {
-			if (char === quote) quote = void 0;
-			continue;
-		}
-		if (char === "'" || char === "\"") quote = char;
-		else if (char === "(") depth++;
-		else if (char === ")") depth--;
-		else if (depth === 0 && text.slice(index, index + separator.length).toUpperCase() === separator) {
-			parts.push(text.slice(start, index));
-			start = index + separator.length;
-			index += separator.length - 1;
-		}
-	}
-	parts.push(text.slice(start));
-	return parts.map((part) => part.trim());
-}
-const IS_NOT_NULL = /^(?:"((?:[^"]|"")+)"|([\w$]+)) IS NOT NULL$/i;
-/**
-* Columns a CHECK constraint makes not null: `CHECK ((slug IS NOT NULL))` and
-* the `IS NOT NULL` terms of a top-level `AND`. A term under `OR`, `NOT` or
-* any other expression narrows nothing, and neither does a `NOT VALID` one.
-*/
-function parseCheckNotNull(definition) {
-	const text = definition.trim();
-	if (/\bNOT VALID$/i.test(text)) return [];
-	const body = /^CHECK\s*(.*)$/is.exec(text)?.[1];
-	if (!body) return [];
-	const expression = unwrap(body);
-	if (splitTopLevel(expression, "OR").length > 1) return [];
-	return splitTopLevel(expression, "AND").flatMap((term) => {
-		const match = IS_NOT_NULL.exec(unwrap(term));
-		if (!match) return [];
-		return [match[1]?.replaceAll("\"\"", "\"") ?? match[2] ?? ""];
-	});
-}
-//#endregion
-//#region src/cli/gen/model-functions.ts
-const NOT_NULL_TAG = /@notNull(?:\(([^)]*)\))?/u;
-/**
-* The `@notNull` tag in a function's comment: `true` for every result, or the
-* columns `@notNull(a, b)` names. `undefined` without a tag.
-*/
-function notNullTag(comment) {
-	const match = comment === void 0 ? null : NOT_NULL_TAG.exec(comment);
-	if (!match) return;
-	const list = match[1];
-	return list === void 0 ? true : list.split(",").map((name) => name.trim()).filter((name) => name !== "");
-}
-/** The callable functions; warns about functions another schema shadows. */
-function buildFunctions(ctx, tableModels) {
-	const { config, catalog, enumsByName, tsType, warnings } = ctx;
-	const tablesByName = new Map(tableModels.map((table) => [`${table.snapshot.schema}.${table.snapshot.name}`, table]));
-	const callable = catalog.functions.filter((fn) => config.schemas.includes(fn.schema)).filter((fn) => fn.returns !== "trigger" && fn.returns !== "event_trigger").filter((fn) => !fn.args.some((arg) => arg.udt === "internal"));
-	const ownerSchema = /* @__PURE__ */ new Map();
-	for (const schema of config.schemas) for (const fn of callable) if (fn.schema === schema && !ownerSchema.has(fn.name)) ownerSchema.set(fn.name, schema);
-	const shadowed = /* @__PURE__ */ new Set();
-	const functions = callable.filter((fn) => {
-		if (ownerSchema.get(fn.name) === fn.schema) return true;
-		shadowed.add(`${fn.schema}.${fn.name}`);
-		return false;
-	}).map((fn) => {
-		const typeOf = (format, typeSchema) => {
-			const isArray = format.startsWith("_");
-			const values = enumsByName.get(`${typeSchema ?? fn.schema}.${isArray ? format.slice(1) : format}`);
-			if (values) return isArray ? arrayOf(enumType(values)) : enumType(values);
-			return tsType(fn.schema, format, typeSchema);
-		};
-		const configured = configFor(config.functions, fn.schema, fn.name)?.notNull;
-		const notNull = configured ?? notNullTag(fn.comment);
-		const source = configured === void 0 ? `the @notNull tag on ${fn.schema}.${fn.name}` : `functions.${fn.name}.notNull`;
-		const notNullColumns = new Set(Array.isArray(notNull) ? notNull : []);
-		if (Array.isArray(notNull)) {
-			for (const name of notNullColumns) if (!fn.returnsTable?.some((column) => column.name === name)) throw new TypeError(`${source}: "${name}" is not a column the function returns`);
-		}
-		const orNull = (type, column) => notNull === true || column !== void 0 && notNullColumns.has(column) || type === "undefined" || type === "Json" || type === "unknown" ? type : `${type} | null`;
-		let returns;
-		let result;
-		const rowTable = fn.returnsRelation ? tablesByName.get(fn.returnsRelation) : void 0;
-		if (fn.returnsTable) {
-			const columns = fn.returnsTable.map((column) => {
-				const codec = codecFor(column.udt, config);
-				return {
-					db: column.name,
-					app: applyCasing(column.name, config.casing),
-					codec,
-					tsType: codec ? CODEC_TYPE[codec] : typeOf(column.udt, column.typeSchema)
-				};
-			});
-			returns = `{ ${columns.map((column) => `${JSON.stringify(column.app)}: ${orNull(column.tsType, column.db)}`).join("; ")} }[]`;
-			if (columns.some((column) => column.codec !== void 0 || column.app !== column.db)) result = { columns: columns.map(({ db, app, codec }) => ({
-				db,
-				...app === db ? {} : { name: app },
-				...codec ? { codec } : {}
-			})) };
-		} else if (rowTable) {
-			returns = `Models[${JSON.stringify(rowTable.key)}]['Row']`;
-			returns = fn.returnsSet ? arrayOf(returns) : orNull(returns);
-			if (rowTable.columns.some((column) => column.codec !== void 0 || column.app !== column.db)) result = { table: rowTable.key };
-		} else {
-			returns = orNull(typeOf(fn.returns, fn.returnsSchema));
-			if (fn.returnsSet) returns = arrayOf(returns);
-		}
-		return {
-			key: fn.name,
-			meta: {
-				name: fn.name,
-				schema: fn.schema,
-				args: fn.args.map((arg) => ({
-					name: arg.name,
-					type: arg.udt
-				})),
-				returns: fn.returns,
-				returnsSet: fn.returnsSet,
-				volatility: fn.volatility,
-				...result ? { result } : {}
-			},
-			args: fn.args.map((arg) => ({
-				name: arg.name,
-				tsType: typeOf(arg.isArray ? `_${arg.udt}` : arg.udt, arg.typeSchema),
-				optional: arg.hasDefault
-			})),
-			returns
-		};
-	});
-	for (const name of Object.keys(config.functions)) if (!functions.some((fn) => fn.key === name || `${fn.meta.schema}.${fn.key}` === name)) throw new TypeError(`functions.${name}: no function "${name}" in ${config.schemas.join(", ")}`);
-	for (const id of shadowed) {
-		const name = id.slice(id.indexOf(".") + 1);
-		warnings.push(`${id}: ${ownerSchema.get(name) ?? ""}.${name} has the same name and comes first in \`schemas\`, so ${id} gets no \`$rpc\` types.`);
-	}
-	return functions;
-}
-//#endregion
-//#region src/cli/gen/model-relations.ts
-function buildRelations(ctx, tables) {
-	const { config, keyOf } = ctx;
-	const byKey = /* @__PURE__ */ new Map();
-	for (const entry of tables) byKey.set(`${entry.table.schema}.${entry.table.name}`, entry);
-	const appName = (schema, table, column) => {
-		return byKey.get(`${schema}.${table}`)?.byDb.get(column)?.app ?? column;
-	};
-	const relations = /* @__PURE__ */ new Map();
-	const push = (tableId, relation) => {
-		const list = relations.get(tableId);
-		if (list) list.push(relation);
-		else relations.set(tableId, [relation]);
-	};
-	for (const { table, casing, byDb: own } of tables) {
-		const sourceId = `${table.schema}.${table.name}`;
-		for (const fk of table.foreignKeys) {
-			const targetId = `${fk.refSchema}.${fk.refTable}`;
-			const target = byKey.get(targetId);
-			if (!target) continue;
-			const targetKey = keyOf.get(targetId) ?? fk.refTable;
-			const sourceColumns = fk.columns.map((column) => appName(table.schema, table.name, column));
-			const targetColumns = fk.refColumns.map((column) => appName(fk.refSchema, fk.refTable, column));
-			const nullable = config.relations.nullableUnderRls && target.table.rls || fk.columns.some((column) => own.get(column)?.nullable ?? true);
-			const onDelete = fk.onDelete === "cascade" || fk.onDelete === "set null" || fk.onDelete === "set default" ? { onDelete: fk.onDelete } : {};
-			const naming = namingColumns(fk.columns, fk.refColumns);
-			const [only] = naming;
-			const forwardBase = naming.length === 1 && only?.endsWith("_id") ? only.slice(0, -3) : singular(fk.refTable);
-			push(sourceId, {
-				name: applyCasing(forwardBase, casing),
-				base: forwardBase,
-				fkColumns: fk.columns,
-				refColumns: fk.refColumns,
-				meta: {
-					table: targetKey,
-					kind: "one",
-					nullable,
-					foreignKey: fk.name,
-					columns: sourceColumns,
-					references: targetColumns,
-					direction: "forward",
-					...onDelete
-				}
-			});
-			const unique = fk.oneToOne || sameColumns(table.primaryKey, fk.columns) || table.uniques.some((key) => sameColumns(key.columns, fk.columns));
-			const reverseBase = unique ? singular(table.name) : table.name;
-			push(targetId, {
-				name: applyCasing(reverseBase, target.casing),
-				base: reverseBase,
-				fkColumns: fk.columns,
-				refColumns: fk.refColumns,
-				meta: {
-					table: keyOf.get(sourceId) ?? table.name,
-					kind: unique ? "one" : "many",
-					nullable: true,
-					foreignKey: fk.name,
-					columns: targetColumns,
-					references: sourceColumns,
-					direction: "reverse",
-					...onDelete
-				}
-			});
-		}
-	}
-	return relations;
-}
-/**
-* The columns that name a relation. A composite key that repeats a column on
-* both sides, such as `(customer_id, organization_id)` referencing
-* `(id, organization_id)` to keep rows in one tenant, is named by the rest.
-*/
-function namingColumns(columns, references) {
-	const own = columns.filter((column, index) => column !== references[index]);
-	return own.length > 0 ? own : columns;
-}
-//#endregion
-//#region src/cli/gen/model.ts
-const SOFT_DELETE_UDTS = /* @__PURE__ */ new Set(["timestamptz", "timestamp"]);
-/** The overloads of each function name, in model order. */
-function functionGroups(functions) {
-	const groups = /* @__PURE__ */ new Map();
-	for (const fn of functions) {
-		const group = groups.get(fn.key);
-		if (group) group.push(fn);
-		else groups.set(fn.key, [fn]);
-	}
-	return groups;
-}
-function signatureOf(fn) {
-	const { name: _name, schema: _schema, ...signature } = fn.meta;
-	return {
-		...signature,
-		args: signature.args.map((arg, index) => fn.args[index]?.optional ? {
-			...arg,
-			optional: true
-		} : arg)
-	};
-}
-function tableKey(table, casing, schemas) {
-	const base = applyCasing(table.name, casing);
-	if (schemas.length === 1 || table.schema === "public") return base;
-	return applyCasing(`${table.schema}_${table.name}`, casing);
-}
-const TEXT_UDTS = /* @__PURE__ */ new Set([
-	"text",
-	"varchar",
-	"bpchar"
-]);
-/** `config.storagePaths` resolved to bucket ids, with a check that every key is used. */
-function numberedColumnsOf(config) {
-	const columns = /* @__PURE__ */ new Map();
-	const block = config.blocks["number-sequences"];
-	if (!config.blockNames.includes("number-sequences") || block?.mode === "custom" || !isRecord(block?.options?.["entities"])) return columns;
-	for (const entry of Object.values(block.options["entities"])) {
-		if (!isRecord(entry) || typeof entry["table"] !== "string" || typeof entry["column"] !== "string") continue;
-		const key = entry["table"].includes(".") ? entry["table"] : `public.${entry["table"]}`;
-		const set = columns.get(key) ?? /* @__PURE__ */ new Set();
-		set.add(entry["column"]);
-		if (typeof entry["sequenceColumn"] === "string") set.add(entry["sequenceColumn"]);
-		columns.set(key, set);
-	}
-	return columns;
-}
-function storagePathsOf(config) {
-	const bucketId = (name) => {
-		const bucket = config.buckets[name];
-		if (!bucket) return name;
-		return bucket.id ?? name.replaceAll(/[A-Z]/g, (char) => `-${char.toLowerCase()}`);
-	};
-	const unused = new Set(Object.keys(config.storagePaths));
-	return {
-		lookup(schema, table, column, udt) {
-			const key = [`${schema}.${table}.${column}`, `${table}.${column}`].find((candidate) => candidate in config.storagePaths);
-			if (key === void 0) return;
-			unused.delete(key);
-			if (!TEXT_UDTS.has(udt)) throw new TypeError(`storagePaths["${key}"]: ${schema}.${table}.${column} is ${udt}, not a text column`);
-			return bucketId(config.storagePaths[key]);
-		},
-		assertUsed() {
-			const [first] = unused;
-			if (first !== void 0) throw new TypeError(`storagePaths["${first}"]: no such column. Use \`table.column\` or \`schema.table.column\` (database names) in \`schemas\`.`);
-		}
-	};
-}
-function prepareCatalog(snapshot, config) {
-	const catalog = toCatalog(snapshot);
-	const introspection = restrictSchemas(snapshot.generator, config.schemas);
-	const tsType = (schema, format, typeSchema) => tsTypeOf(introspection, schema, format, typeSchema).replaceAll(/\(([\w.$]+)\)\[\]/g, "$1[]");
-	const enumsByName = /* @__PURE__ */ new Map();
-	for (const entry of catalog.enums) enumsByName.set(`${entry.schema}.${entry.name}`, entry.values);
-	const jsonImports = /* @__PURE__ */ new Map();
-	const unusedJson = new Set(Object.keys(config.json));
-	const jsonTypeFor = (schema, table, column) => {
-		const key = [`${schema}.${table}.${column}`, `${table}.${column}`].find((candidate) => candidate in config.json);
-		const override = key === void 0 ? void 0 : config.json[key];
-		if (key === void 0 || !override) return;
-		unusedJson.delete(key);
-		if ("type" in override) return override.type;
-		const [from, name] = override.import.split("#");
-		if (!from || !name) throw new TypeError(`json["${key}"].import must look like "./path.ts#TypeName"`);
-		jsonImports.set(name, {
-			name,
-			from
-		});
-		return name;
-	};
-	const optionsOf = (table) => configFor(config.tables, table.schema, table.name);
-	const included = catalog.tables.filter((table) => config.schemas.includes(table.schema) && !optionsOf(table)?.exclude);
-	const keyOf = /* @__PURE__ */ new Map();
-	const ownerOf = /* @__PURE__ */ new Map();
-	for (const table of included) {
-		const id = `${table.schema}.${table.name}`;
-		const key = tableKey(table, config.casing, config.schemas);
-		const other = ownerOf.get(key);
-		if (other !== void 0) throw new TypeError(`${other} and ${id} both generate the model key "${key}". Exclude one with \`tables["${id}"].exclude\`, or rename one of the tables.`);
-		ownerOf.set(key, id);
-		keyOf.set(id, key);
-	}
-	return {
-		config,
-		catalog,
-		introspection,
-		enumsByName,
-		jsonImports,
-		unusedJson,
-		included,
-		keyOf,
-		warnings: [],
-		tsType,
-		jsonTypeFor,
-		optionsOf
-	};
-}
-function draftTables(ctx) {
-	const { config, included, enumsByName, tsType, jsonTypeFor, optionsOf } = ctx;
-	const storagePaths = storagePathsOf(config);
-	const numbered = numberedColumnsOf(config);
-	const tables = included.map((table) => {
-		const casing = optionsOf(table)?.casing ?? config.casing;
-		const checks = /* @__PURE__ */ new Map();
-		const checkedNotNull = /* @__PURE__ */ new Set();
-		for (const check of table.checks) {
-			const union = parseCheckUnion(check.definition);
-			if (union) checks.set(union.column, union.values);
-			for (const column of parseCheckNotNull(check.definition)) checkedNotNull.add(column);
-		}
-		const beforeInsert = table.triggers.some((trigger) => trigger.timing === "before" && trigger.level === "row" && trigger.events.includes("insert"));
-		const insertOptional = new Set(optionsOf(table)?.insertOptional);
-		const numberedColumns = numbered.get(`${table.schema}.${table.name}`);
-		for (const name of insertOptional) if (!table.columns.some((column) => column.name === name)) throw new TypeError(`tables.${table.name}.insertOptional: "${name}" is not a column of ${table.schema}.${table.name}`);
-		const columns = table.columns.map((column) => {
-			const values = (column.isEnum ? enumsByName.get(`${column.typeSchema}.${column.udt}`) : void 0) ?? checks.get(column.name);
-			const json = isJsonUdt(column.udt);
-			const override = json ? jsonTypeFor(table.schema, table.name, column.name) : void 0;
-			const storage = storagePaths.lookup(table.schema, table.name, column.name, column.udt);
-			const codec = override || values || storage ? void 0 : codecFor(column.udt, config);
-			const base = override ?? (values ? enumType(values) : storage ? `StoragePath<${JSON.stringify(storage)}>` : codec ? CODEC_TYPE[codec] : void 0);
-			const columnType = base === void 0 ? tsType(table.schema, column.format, column.typeSchema) : column.isArray ? arrayOf(base) : base;
-			const readonly = column.generated || column.identity === "always";
-			const narrowed = column.nullable && checkedNotNull.has(column.name);
-			const nullable = column.nullable && !narrowed;
-			const filled = column.hasDefault || insertOptional.has(column.name) || (numberedColumns?.has(column.name) ?? false) || narrowed && beforeInsert;
-			const insertable = !readonly && table.insertable && (table.kind !== "view" || column.updatable);
-			const updatable = !readonly && table.updatable && column.updatable;
-			return {
-				...table.schema === "public" && config.appTables[table.name]?.columns?.[column.name]?.access === "server" ? { selectable: false } : {},
-				app: applyCasing(column.name, casing),
-				db: column.name,
-				snapshot: column,
-				tsType: columnType,
-				nullable,
-				filled,
-				optional: nullable || filled || readonly,
-				readonly,
-				values,
-				json,
-				codec,
-				storage,
-				insertable,
-				updatable
-			};
-		});
-		const byApp = /* @__PURE__ */ new Map();
-		for (const column of columns) {
-			const other = byApp.get(column.app);
-			if (other !== void 0) throw new TypeError(`${table.schema}.${table.name}: columns "${other}" and "${column.db}" both become "${column.app}". Rename one, or set \`tables["${table.schema}.${table.name}"].casing: "snake"\`.`);
-			byApp.set(column.app, column.db);
-		}
-		return {
-			table,
-			casing,
-			columns,
-			byDb: new Map(columns.map((column) => [column.db, column]))
-		};
-	});
-	storagePaths.assertUsed();
-	return tables;
-}
-/** Config entries that match no table or column. */
-function configWarnings(ctx) {
-	const { config, catalog, unusedJson } = ctx;
-	const schemasOf = /* @__PURE__ */ new Map();
-	for (const table of catalog.tables) {
-		if (!config.schemas.includes(table.schema)) continue;
-		schemasOf.set(table.name, [...schemasOf.get(table.name) ?? [], table.schema]);
-	}
-	const known = (key) => {
-		const dot = key.indexOf(".");
-		if (dot === -1) return schemasOf.has(key);
-		return schemasOf.get(key.slice(dot + 1))?.includes(key.slice(0, dot)) ?? false;
-	};
-	return [
-		...Object.keys(config.tables).filter((name) => !known(name)).map((name) => `tables["${name}"]: no table by that name in ${config.schemas.join(", ")}, so the entry does nothing.`),
-		...Object.keys(config.tables).flatMap((name) => {
-			const shared = (schemasOf.get(name) ?? []).filter((schema) => !(`${schema}.${name}` in config.tables)).map((schema) => `${schema}.${name}`);
-			return shared.length > 1 ? [`tables["${name}"]: ${shared.join(" and ")} share the name, so the entry applies to each. Key it \`schema.table\` to pick one.`] : [];
-		}),
-		...[...unusedJson].map((key) => `json["${key}"]: no json or jsonb column by that name, so the type is not used. Keys are \`table.column\` or \`schema.table.column\` with database names.`)
-	];
-}
-function toTableModels(ctx, tables, relations) {
-	const { config, keyOf, optionsOf } = ctx;
-	const flagsConfig = config.plugins;
-	const subjectDeletedAt = /* @__PURE__ */ new Map();
-	for (const [type, subject] of Object.entries(config.subjects)) if (subject.deletedAt !== void 0) {
-		const table = subject.table.includes(".") ? subject.table : `public.${subject.table}`;
-		subjectDeletedAt.set(table, {
-			db: subject.deletedAt,
-			source: `subjects.${type}.deletedAt`
-		});
-	}
-	return tables.map(({ table, casing, columns, byDb }) => {
-		const id = `${table.schema}.${table.name}`;
-		const renames = optionsOf(table)?.relations ?? {};
-		const columnNames = new Set(columns.map((column) => column.app));
-		const list = dedupeRelations(relations.get(id) ?? [], columnNames, casing).map((relation) => ({
-			...relation,
-			name: renames[relation.name] ?? relation.name
-		}));
-		const has = (db) => byDb.get(db)?.app;
-		const flags = {};
-		const subjectColumn = subjectDeletedAt.get(id);
-		const softDelete = subjectColumn !== void 0 && byDb.has(subjectColumn.db) ? subjectColumn : flagsConfig.softDelete ? {
-			db: flagsConfig.softDelete.column,
-			source: "plugins.softDelete.column"
-		} : void 0;
-		const softDeleteColumn = softDelete && byDb.get(softDelete.db);
-		if (softDelete && softDeleteColumn) {
-			const udt = softDeleteColumn.snapshot.udt;
-			if (softDeleteColumn.snapshot.isArray || !SOFT_DELETE_UDTS.has(udt)) throw new TypeError(`${softDelete.source}: ${id}.${softDelete.db} is ${udt}, but softDelete() writes a timestamp. Use timestamptz or timestamp.`);
-			flags.softDelete = softDeleteColumn.app;
-		}
-		if (flagsConfig.timestamps) {
-			const createdAt = has(flagsConfig.timestamps.createdAt);
-			const updatedAt = has(flagsConfig.timestamps.updatedAt);
-			if (createdAt || updatedAt) flags.timestamps = {
-				...createdAt ? { createdAt } : {},
-				...updatedAt ? { updatedAt } : {}
-			};
-		}
-		if (flagsConfig.tenant) {
-			const column = has(flagsConfig.tenant.column);
-			if (column) flags.tenant = column;
-		}
-		if (flagsConfig.actor) {
-			const createdBy = has(flagsConfig.actor.createdBy);
-			const updatedBy = has(flagsConfig.actor.updatedBy);
-			const impersonatedBy = has(flagsConfig.actor.impersonatedBy);
-			if (createdBy || updatedBy || impersonatedBy) flags.actor = {
-				...createdBy ? { createdBy } : {},
-				...updatedBy ? { updatedBy } : {},
-				...impersonatedBy ? { impersonatedBy } : {}
-			};
-		}
-		const key = keyOf.get(id) ?? table.name;
-		const columnMeta = {};
-		for (const column of columns) {
-			const meta = {
-				db: column.db,
-				type: column.snapshot.udt,
-				nullable: column.nullable,
-				hasDefault: column.filled
-			};
-			if (column.readonly) meta.generated = true;
-			if (column.snapshot.identity) meta.identity = column.snapshot.identity;
-			if (!column.readonly && !column.insertable) meta.insertable = false;
-			if (!column.readonly && !column.updatable) meta.updatable = false;
-			if (column.selectable === false) meta.selectable = false;
-			if (column.snapshot.isArray) meta.array = true;
-			if (column.json) meta.json = true;
-			if (column.values) meta.enum = column.values;
-			if (column.codec) meta.codec = column.codec;
-			if (column.storage) meta.storage = column.storage;
-			if (config.sensitive.includes(`${table.name}.${column.db}`) || config.sensitive.includes(`${table.schema}.${table.name}.${column.db}`)) meta.sensitive = true;
-			Object.assign(meta, commentMeta(column.snapshot.comment));
-			columnMeta[column.app] = meta;
-		}
-		const app = (db) => byDb.get(db)?.app ?? db;
-		const uniqueKeys = {};
-		for (const unique of table.uniques) uniqueKeys[unique.name] = unique.columns.map(app);
-		const relationMeta = {};
-		for (const relation of list) relationMeta[relation.name] = relation.meta;
-		return {
-			key,
-			snapshot: table,
-			casing,
-			columns,
-			relations: list,
-			meta: {
-				key,
-				name: table.name,
-				schema: table.schema,
-				kind: table.kind,
-				columns: columnMeta,
-				primaryKey: table.primaryKey.map(app),
-				uniqueKeys,
-				relations: relationMeta,
-				flags,
-				...commentMeta(table.comment)
-			}
-		};
-	});
-}
-function buildEnums(ctx) {
-	const { config, catalog } = ctx;
-	const includedEnums = catalog.enums.filter((entry) => config.schemas.includes(entry.schema));
-	const enumNameCount = /* @__PURE__ */ new Map();
-	for (const entry of includedEnums) enumNameCount.set(entry.name, (enumNameCount.get(entry.name) ?? 0) + 1);
-	return includedEnums.map((entry) => {
-		const key = entry.schema !== "public" && (enumNameCount.get(entry.name) ?? 0) > 1 ? `${entry.schema}_${entry.name}` : entry.name;
-		return {
-			schema: entry.schema,
-			name: entry.name,
-			key,
-			constant: identifier(`${toCamel(key)}Values`),
-			typeName: identifier(pascal(key)),
-			values: entry.values
-		};
-	});
-}
-function assembleMeta(config, tableModels, enums, functions) {
-	const tablesMeta = {};
-	for (const table of tableModels) tablesMeta[table.key] = table.meta;
-	const enumsMeta = {};
-	for (const entry of enums) enumsMeta[entry.key] = entry.values;
-	const functionsMeta = {};
-	for (const [key, group] of functionGroups(functions)) {
-		const [first] = group;
-		if (!first) continue;
-		functionsMeta[key] = group.length === 1 ? first.meta : {
-			...first.meta,
-			overloads: group.map(signatureOf)
-		};
-	}
-	const claimOverrides = {};
-	for (const key of Object.keys(DEFAULT_CLAIMS)) if (config.claims[key] !== DEFAULT_CLAIMS[key]) claimOverrides[key] = config.claims[key];
-	const tenantClaim = config.claims.tenant === DEFAULT_CLAIMS.tenant ? void 0 : tenantClaimPaths(config.claims.tenant);
-	return {
-		version: 1,
-		casing: config.casing,
-		tables: tablesMeta,
-		enums: enumsMeta,
-		functions: functionsMeta,
-		...Object.keys(config.buckets).length > 0 ? { buckets: Object.fromEntries(Object.entries(config.buckets).map(([name, bucket]) => [name, {
-			id: bucket.id ?? name.replaceAll(/[A-Z]/g, (char) => `-${char.toLowerCase()}`),
-			public: bucket.public ?? false,
-			path: bucket.path,
-			...bucket.policy ? { policy: typeof bucket.policy === "string" ? bucket.policy : resolveProviderSql(`buckets.${name}`, bucket.policy, config.authorization?.functions) } : {},
-			...bucket.policy === "tenant" && tenantClaim ? { tenant: { claim: tenantClaim } } : {},
-			...bucket.fileSizeLimit ? { fileSizeLimit: bucket.fileSizeLimit } : {},
-			...bucket.allowedMimeTypes ? { allowedMimeTypes: bucket.allowedMimeTypes } : {},
-			...bucket.versioning ? { versioning: true } : {},
-			...bucket.lifecycle ? { lifecycle: bucket.lifecycle } : {}
-		}])) } : {},
-		...Object.keys(config.topics).length > 0 ? { topics: config.topics } : {},
-		...config.realtime.tables.length > 0 ? { realtime: realtimeMeta(config.realtime.tables, config.realtime.users, tableModels) } : {},
-		...Object.keys(claimOverrides).length > 0 ? { claims: claimOverrides } : {}
-	};
-}
-/** Builds the codegen model from a snapshot and config. */
-function buildModel(snapshot, config) {
-	const ctx = prepareCatalog(snapshot, config);
-	const tables = draftTables(ctx);
-	ctx.warnings.push(...configWarnings(ctx));
-	const tableModels = toTableModels(ctx, tables, buildRelations(ctx, tables));
-	const enums = buildEnums(ctx);
-	const functions = buildFunctions(ctx, tableModels);
-	return {
-		tables: tableModels,
-		enums,
-		functions,
-		jsonImports: [...ctx.jsonImports.values()],
-		meta: assembleMeta(config, tableModels, enums, functions),
-		config,
-		catalog: ctx.catalog,
-		introspection: ctx.introspection,
-		warnings: ctx.warnings
-	};
-}
-function deepFreeze(value) {
-	if (typeof value === "object" && value !== null && !Object.isFrozen(value)) {
-		Object.freeze(value);
-		for (const entry of Object.values(value)) deepFreeze(entry);
-	}
-	return value;
-}
-/** The public, frozen view of the model that generators receive. */
-function generatorModel(model) {
-	return deepFreeze({
-		tables: model.tables.map((table) => ({
-			key: table.key,
-			schema: table.snapshot.schema,
-			name: table.snapshot.name,
-			casing: table.casing,
-			columns: table.columns.map((column) => ({
-				app: column.app,
-				db: column.db,
-				tsType: column.tsType,
-				nullable: column.nullable,
-				optional: column.optional,
-				readonly: column.readonly,
-				values: column.values === void 0 ? void 0 : [...column.values],
-				json: column.json
-			}))
-		})),
-		enums: model.enums.map((entry) => ({
-			schema: entry.schema,
-			name: entry.name,
-			values: [...entry.values]
-		}))
-	});
-}
-/**
-* Makes relation names unique per table and distinct from column names:
-* two FKs to the same table become `customersByPrimaryContact`-style names.
-* When those still collide, the names use every column of the key
-* (`locationsByCustomerOrganization`), then the constraint name, and only
-* then a trailing `_`.
-*/
-function dedupeRelations(list, columns, casing) {
-	const suffixed = (relation, suffix) => applyCasing(`${relation.base}_by_${suffix}`, casing);
-	const keyColumns = (relation, all) => (all ? relation.fkColumns : namingColumns(relation.fkColumns, relation.refColumns)).map((column) => column.replace(/_?[iI]d$/, "")).join("_");
-	const repeated = (names) => {
-		const seen = /* @__PURE__ */ new Set();
-		const twice = /* @__PURE__ */ new Set();
-		for (const name of names) (seen.has(name) ? twice : seen).add(name);
-		return twice;
-	};
-	const plain = repeated(list.map((relation) => relation.name));
-	const names = [(relation) => suffixed(relation, keyColumns(relation, true)), (relation) => suffixed(relation, relation.meta.foreignKey)].reduce((current, step) => {
-		const clash = repeated(current);
-		return list.map((relation, index) => {
-			const name = current[index] ?? relation.name;
-			return clash.has(name) || columns.has(name) ? step(relation) : name;
-		});
-	}, list.map((relation) => plain.has(relation.name) || columns.has(relation.name) ? suffixed(relation, keyColumns(relation, false)) : relation.name));
-	const used = /* @__PURE__ */ new Set();
-	return list.map((relation, index) => {
-		let name = names[index] ?? relation.name;
-		while (used.has(name) || columns.has(name)) name = `${name}_`;
-		used.add(name);
-		return {
-			...relation,
-			name
-		};
-	});
-}
-function realtimeMeta(names, users, tables) {
-	const out = {};
-	for (const name of names) {
-		const table = tables.find((candidate) => candidate.meta.name === name || `${candidate.meta.schema}.${candidate.meta.name}` === name);
-		if (!table) throw new CliError("config_invalid", `realtime.tables: unknown table "${name}". Check the name and \`schemas\`.`);
-		const owner = users[name];
-		if (owner !== void 0) {
-			const user = Object.entries(table.meta.columns).find(([, column]) => column.db === owner)?.[0];
-			if (user === void 0) throw new CliError("config_invalid", `realtime.users: "${name}" has no column "${owner}".`);
-			out[table.key] = { user };
-			continue;
-		}
-		const tenant = table.meta.flags.tenant;
-		out[table.key] = tenant ? { tenant } : {};
-	}
-	return out;
-}
-//#endregion
-//#region src/cli/gen/emit.ts
-const GENERATED_HEADER = "// @generated by better-supabase gen. Do not edit; run `better-supabase gen` instead.";
-function rowEntries(columns, name) {
-	return columns.map((column) => `${prop(column[name])}${column.selectable === false ? "?" : ""}: ${nullable(column.tsType, column.nullable)};`);
-}
-function insertEntries(columns, name) {
-	return columns.map((column) => {
-		if (!column.insertable) return `${prop(column[name])}?: never;`;
-		const optional = column.optional ? "?" : "";
-		return `${prop(column[name])}${optional}: ${nullable(column.tsType, column.nullable)};`;
-	});
-}
-function updateEntries(columns, name) {
-	return columns.map((column) => {
-		if (!column.updatable) return `${prop(column[name])}?: never;`;
-		return `${prop(column[name])}?: ${nullable(column.tsType, column.nullable)};`;
-	});
-}
-/**
-* Postgres passes `null` to any argument, so every argument accepts it. An
-* optional argument also accepts `undefined`, which `rpc()` leaves out, so
-* `exactOptionalPropertyTypes` apps can pass a maybe-missing value.
-*/
-function argEntries(fn) {
-	return fn.args.map((arg) => `${prop(arg.name)}${arg.optional ? "?" : ""}: ${nullable(arg.tsType, true)}${arg.optional ? " | undefined" : ""};`);
-}
-function enrichedDatabase(model) {
-	const schemas = model.config.schemas.flatMap((schema) => {
-		const tables = model.tables.filter((t) => t.snapshot.schema === schema).flatMap((table) => {
-			const overrides = table.columns.filter((column) => column.values !== void 0 && !column.snapshot.isEnum || column.json && column.tsType !== "Json" || column.storage !== void 0).map((column) => `${prop(column.db)}: ${column.tsType};`);
-			return overrides.length > 0 ? block(prop(table.snapshot.name), overrides) : [];
-		});
-		return tables.length > 0 ? block(prop(schema), tables) : [];
-	});
-	if (schemas.length === 0) return ["export type Database = SupabaseDatabase;"];
-	return [
-		"export type Database = EnrichDatabase<",
-		"  SupabaseDatabase,",
-		"  {",
-		...indent(schemas, 2),
-		"  }",
-		">;"
-	];
-}
-function modelsType(model) {
-	return [
-		"export type Models = {",
-		...indent(model.tables.flatMap((table) => {
-			const relations = table.relations.map((relation) => `${prop(relation.name)}: { table: ${q(relation.meta.table)}; kind: ${q(relation.meta.kind)}; nullable: ${String(relation.meta.nullable)} };`);
-			const pk = table.meta.primaryKey;
-			const uniques = Object.entries(table.meta.uniqueKeys).map(([name, columns]) => `${prop(name)}: readonly [${columns.map(q).join(", ")}];`);
-			const flags = [];
-			const tableFlags = table.meta.flags;
-			if (tableFlags.softDelete) flags.push(`softDelete: ${q(tableFlags.softDelete)};`);
-			if (tableFlags.timestamps) flags.push("timestamps: true;");
-			if (tableFlags.tenant) flags.push(`tenant: ${q(tableFlags.tenant)};`);
-			if (tableFlags.actor) flags.push("actor: true;");
-			const none = "Record<never, never>";
-			const union = (names) => names.length === 0 ? "never" : names.map(q).join(" | ");
-			return block(prop(table.key), [
-				...block("Row", rowEntries(table.columns, "app"), none),
-				...table.snapshot.insertable ? block("Insert", insertEntries(table.columns, "app"), none) : ["Insert: never;"],
-				...table.snapshot.updatable ? block("Update", updateEntries(table.columns, "app"), none) : ["Update: never;"],
-				...block("Relations", relations, none),
-				`PrimaryKey: ${union(pk)};`,
-				...block("UniqueKeys", uniques, none),
-				`Checks: ${union(table.snapshot.checks.map((check) => check.name))};`,
-				`ForeignKeys: ${union(table.snapshot.foreignKeys.map((fk) => fk.name))};`,
-				...block("Flags", flags, none)
-			]);
-		}), 1),
-		"};"
-	];
-}
-function functionsType(model) {
-	if (model.functions.length === 0) return ["export type Functions = Record<never, never>;"];
-	return [
-		"export type Functions = {",
-		...indent([...functionGroups(model.functions)].flatMap(([key, group]) => {
-			const [first] = group;
-			if (group.length === 1 && first) return block(prop(key), [...block("Args", argEntries(first), "Record<never, never>"), `Returns: ${first.returns};`]);
-			return [`${prop(key)}:`, ...indent(group.flatMap((fn, index) => {
-				const lines = [...block("Args", argEntries(fn), "Record<PropertyKey, never>"), `Returns: ${fn.returns};`];
-				const end = index === group.length - 1 ? "};" : "}";
-				return [
-					"| {",
-					...indent(lines, 1),
-					end
-				];
-			}), 1)];
-		}), 1),
-		"};"
-	];
-}
-/** The metadata module next to `generated.ts`: `generated.meta.js` and its `.d.ts`. */
-function metaPaths(output) {
-	const base = output.replace(/\.[cm]?[jt]sx?$/, "");
-	return {
-		js: `${base}.meta.js`,
-		dts: `${base}.meta.d.ts`
-	};
-}
-/**
-* JSON with one line per table, function and other named entry, so the
-* module stays small to load and a schema change still diffs per entry.
-*/
-function compactJson(meta) {
-	return `{\n${Object.entries(meta).map(([key, value]) => {
-		const name = JSON.stringify(key);
-		if (typeof value !== "object" || value === null || Array.isArray(value)) return `  ${name}: ${JSON.stringify(value)}`;
-		const inner = Object.entries(value).map(([entry, item]) => `    ${JSON.stringify(entry)}: ${JSON.stringify(item)}`);
-		return inner.length === 0 ? `  ${name}: {}` : `  ${name}: {\n${inner.join(",\n")}\n  }`;
-	}).join(",\n")}\n}`;
-}
-/**
-* The schema metadata as plain JavaScript plus a one-line declaration, so
-* TypeScript reads `SchemaMeta` instead of checking thousands of lines of
-* object literal in every program that imports the generated module.
-*/
-function emitMeta(model, options = {}) {
-	const runtime = options.runtimeImport ?? "better-supabase";
-	return {
-		js: [
-			GENERATED_HEADER,
-			`// @ts-self-types="${options.types ?? "./generated.meta.d.ts"}"`,
-			"/* oxlint-disable */",
-			"/* eslint-disable */",
-			"",
-			`export default ${compactJson({ ...model.meta })};`,
-			""
-		].join("\n"),
-		dts: [
-			GENERATED_HEADER,
-			"/* oxlint-disable */",
-			"/* eslint-disable */",
-			"",
-			`import type { SchemaMeta } from ${q(runtime)};`,
-			"",
-			"declare const meta: SchemaMeta;",
-			"export default meta;",
-			""
-		].join("\n")
-	};
-}
-/** Names the generated module declares or imports itself. */
-const RESERVED_EXPORTS = [
-	"defineSchema",
-	"Schema",
-	"SchemaMeta",
-	"EnrichDatabase",
-	"MutableWhere",
-	"OrderByArg",
-	"OrderByInput",
-	"StoragePath",
-	"SupabaseDatabase",
-	"meta",
-	"Json",
-	"Database",
-	"Models",
-	"Functions",
-	"TableName",
-	"UniqueConstraint",
-	"CheckConstraint",
-	"ForeignKeyConstraint",
-	"RowOf",
-	"InsertOf",
-	"UpdateOf",
-	"WhereOf",
-	"OrderByOf",
-	"OrderTermOf",
-	"WritableColumnOf",
-	"GeneratedColumnOf",
-	"buckets",
-	"topics",
-	"subjectTypes",
-	"SubjectType",
-	"SubjectRef",
-	"schema"
-];
-/** Renders the generated module. */
-function emitModule(model, options) {
-	const runtime = options.runtimeImport ?? "better-supabase";
-	const lines = [
-		GENERATED_HEADER,
-		"/* oxlint-disable */",
-		"/* eslint-disable */",
-		"",
-		`import { defineSchema, type Schema${options.inlineMeta ? ", type SchemaMeta" : ""} } from ${q(runtime)};`
-	];
-	const storagePaths = model.tables.some((table) => table.columns.some((column) => column.storage !== void 0));
-	lines.push(`import type { EnrichDatabase, GeneratedColumns, MutableWhere, OrderByArg, OrderByInput${storagePaths ? ", StoragePath" : ""}, WritableColumns } from ${q(runtime)};`, `import type { Database as SupabaseDatabase } from ${q(options.databaseTypesImport ?? "./database.types.ts")};`);
-	const byFile = /* @__PURE__ */ new Map();
-	for (const entry of model.jsonImports) {
-		const list = byFile.get(entry.from) ?? [];
-		list.push(entry.name);
-		byFile.set(entry.from, list);
-	}
-	for (const [from, names] of [...byFile.entries()].sort(([a], [b]) => byCodePoint(a, b))) lines.push(`import type { ${names.sort().join(", ")} } from ${q(options.importPathFor(from))};`);
-	lines.push(options.inlineMeta ? `\nconst meta: SchemaMeta = ${compactJson({ ...model.meta })};` : `import meta from ${q(options.metaImport ?? "./generated.meta.js")};`, "", "export type Json = string | number | boolean | null | { [key: string]: Json | undefined } | Json[];", "", ...enrichedDatabase(model), "");
-	const exported = new Map([...RESERVED_EXPORTS, ...model.jsonImports.map((entry) => entry.name)].map((name) => [name, "the generated module"]));
-	const claim = (name, source) => {
-		const other = exported.get(name);
-		if (other !== void 0) throw new TypeError(`${source} and ${other} both export "${name}" from the generated module. Rename one of them in the database.`);
-		exported.set(name, source);
-		return name;
-	};
-	for (const entry of model.enums) {
-		const source = `enum ${entry.schema}.${entry.name}`;
-		lines.push(`export const ${claim(entry.constant, source)} = [${entry.values.map(q).join(", ")}] as const;`, `export type ${claim(entry.typeName, source)} = (typeof ${entry.constant})[number];`);
-	}
-	for (const table of model.tables) for (const column of table.columns) if (column.values && !column.snapshot.isEnum) {
-		const source = `the CHECK on ${table.snapshot.schema}.${table.snapshot.name}.${column.db}`;
-		const constant = identifier(`${table.key}${pascal(column.app)}Values`.replace(/^[A-Z]/, (c) => c.toLowerCase()));
-		const typeName = identifier(`${pascal(table.key)}${pascal(column.app)}`);
-		lines.push(`export const ${claim(constant, source)} = [${column.values.map(q).join(", ")}] as const;`, `export type ${claim(typeName, source)} = (typeof ${constant})[number];`);
-	}
-	if (model.enums.length > 0) lines.push("");
-	lines.push(...modelsType(model), "", ...functionsType(model), "", "export type TableName = keyof Models;", "/** Constraint names for `isConflict`, `isCheck` and `isForeignKey`. */", "export type UniqueConstraint = { [T in TableName]: Extract<keyof Models[T]['UniqueKeys'], string> }[TableName];", "export type CheckConstraint = Models[TableName]['Checks'];", "export type ForeignKeyConstraint = Models[TableName]['ForeignKeys'];", "export type RowOf<T extends TableName> = Models[T]['Row'];", "export type InsertOf<T extends TableName> = Models[T]['Insert'];", "export type UpdateOf<T extends TableName> = Models[T]['Update'];", "/** A `where` for `T` you can assign to one key at a time. */", "export type WhereOf<T extends TableName> = MutableWhere<Models, T>;", "/** An `orderBy` for `T`: one sort or a list, by column or to-one relation. */", "export type OrderByOf<T extends TableName> = OrderByArg<Models, T>;", "/** One sort term of `T`'s `orderBy`, by column or to-one relation. */", "export type OrderTermOf<T extends TableName> = OrderByInput<Models, T>;", "/** Columns of `T` that `Insert` and `Update` accept. */", "export type WritableColumnOf<T extends TableName> = WritableColumns<Models, T>;", "/** Columns of `T` the database fills (generated columns): in `Row`, never writable. */", "export type GeneratedColumnOf<T extends TableName> = GeneratedColumns<Models, T>;", "");
-	if (model.meta.buckets) lines.push("/** Bucket configs for `defineBucket` from `better-supabase/storage`. */", `export const buckets = ${JSON.stringify(model.meta.buckets, null, 2)} as const;`, "");
-	if (model.meta.topics) lines.push("/** Topic templates for `defineTopic` from `better-supabase/realtime`. */", `export const topics = ${JSON.stringify(model.meta.topics, null, 2)} as const;`, "");
-	const subjects = Object.keys(model.config.subjects);
-	if (subjects.length > 0) lines.push("/** The app's subject types, from `config.subjects`. */", `export const subjectTypes = [${subjects.map(q).join(", ")}] as const;`, "export type SubjectType = (typeof subjectTypes)[number];", "/** One subject: its type and its id as text. */", "export type SubjectRef<T extends SubjectType = SubjectType> = { readonly type: T; readonly id: string };", "", "export const schema: Schema<Models, Database, Functions, SubjectType> = defineSchema(meta);", "");
-	else lines.push("export const schema: Schema<Models, Database, Functions> = defineSchema(meta);", "");
-	return lines.join("\n");
-}
-//#endregion
-export { buildModel as a, configFor as c, applyCasing as d, metaPaths as i, prop as l, emitMeta as n, generatorModel as o, emitModule as r, notNullTag as s, GENERATED_HEADER as t, q as u };