better-supabase 0.8.0 → 0.9.0

package/dist/cli/emit-ZAYeh4Yn.js

@@ -0,0 +1,1042 @@
+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 toCatalog } from "./catalog-Di15TkM2.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 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 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);
+		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) || narrowed && beforeInsert;
+			const insertable = !readonly && table.insertable && (table.kind !== "view" || column.updatable);
+			const updatable = !readonly && table.updatable && column.updatable;
+			return {
+				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.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])}: ${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. */
+function argEntries(fn) {
+	return fn.args.map((arg) => `${prop(arg.name)}${arg.optional ? "?" : ""}: ${nullable(arg.tsType, true)};`);
+}
+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",
+	"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, MutableWhere, OrderByArg, OrderByInput${storagePaths ? ", StoragePath" : ""} } 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>;", "");
+	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 };