better-supabase 0.7.1 → 0.9.0

package/dist/app-tables-BGl5_U2x.js

@@ -0,0 +1,584 @@
+import { i as FIELD_FORMAT_NAMES, r as FIELD_FORMATS } from "./field-formats-Cif5gr7c.js";
+//#region src/config/types/app-tables.ts
+/**
+* The column types an app table may use. Money is a `bigint` of minor units
+* next to a `text` currency column (ADR 0024 and 0037), never `numeric`.
+*/
+const APP_COLUMN_TYPES = [
+	"text",
+	"uuid",
+	"integer",
+	"bigint",
+	"numeric",
+	"boolean",
+	"timestamptz",
+	"date",
+	"jsonb",
+	"text[]"
+];
+/** What a reference does when the row it points at is deleted (`references.onDelete`). */
+const APP_ON_DELETE_ACTIONS = [
+	"cascade",
+	"restrict",
+	"set null",
+	"no action"
+];
+/**
+* What a column holds, beyond its Postgres type. `email`, `url`, `rating`
+* and `percent` add a check; the others tell the UI and `gen` how to show
+* the value. `FIELD_FORMATS` lists the types each fits and its input.
+*/
+const APP_COLUMN_FORMATS = FIELD_FORMAT_NAMES;
+const APP_ROLLUP_AGGREGATES = [
+	"count",
+	"sum",
+	"min",
+	"max",
+	"avg"
+];
+//#endregion
+//#region src/config/app-computed.ts
+const IDENT$1 = /^[a-z][a-z0-9_]{0,62}$/;
+/** Rollups and lookups together, per table. */
+const MAX_COMPUTED = 50;
+const ROLLUP_KEYS = /* @__PURE__ */ new Set([
+	"table",
+	"via",
+	"aggregate",
+	"column",
+	"where"
+]);
+const WHERE_KEYS = /* @__PURE__ */ new Set(["column", "equals"]);
+const LOOKUP_KEYS = /* @__PURE__ */ new Set(["via", "column"]);
+const AGGREGATES = new Set(APP_ROLLUP_AGGREGATES);
+const NUMBERS = /* @__PURE__ */ new Set([
+	"integer",
+	"bigint",
+	"numeric"
+]);
+const ORDERED = /* @__PURE__ */ new Set([
+	...NUMBERS,
+	"date",
+	"timestamptz",
+	"text"
+]);
+function isObject$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isAggregate(value) {
+	return typeof value === "string" && AGGREGATES.has(value);
+}
+function checkKeys$1(where, value, allowed) {
+	for (const key of Object.keys(value)) if (!allowed.has(key)) throw new TypeError(`${where}: unknown key "${key}" (use ${[...allowed].join(", ")})`);
+}
+/** The columns of `table` a rollup or lookup may read, with their types. */
+function readable(table) {
+	return new Map([...Object.entries(table.columns ?? {}).map(([name, column]) => [name, column.type]), ...table.timestamps === false ? [] : [["created_at", "timestamptz"], ["updated_at", "timestamptz"]]]);
+}
+function listOf(names) {
+	const list = [...names].join(", ");
+	return list === "" ? "none" : list;
+}
+/** The columns of `child` that reference the app table `parent`. */
+function referencesTo(child, parent) {
+	return Object.entries(child.columns ?? {}).filter(([, column]) => column.references !== void 0 && !("block" in column.references) && column.references.table === parent).map(([name]) => name);
+}
+function whereOf(where, value, child, table) {
+	if (value === void 0) return;
+	if (!isObject$1(value)) throw new TypeError(`${where} must be { column, equals }`);
+	checkKeys$1(where, value, WHERE_KEYS);
+	const { column, equals } = value;
+	const selects = Object.entries(table.columns ?? {}).filter(([, each]) => each.type === "text" && each.options !== void 0);
+	const found = selects.find(([name]) => name === column)?.[1];
+	if (typeof column !== "string" || found?.options === void 0) throw new TypeError(`${where}.column must name a select column of ${child} (${listOf(selects.map(([name]) => name))})`);
+	if (typeof equals !== "string" || !found.options.includes(equals)) throw new TypeError(`${where}.equals must be an option of ${child}.${column} (${listOf(found.options)})`);
+	return {
+		column,
+		equals
+	};
+}
+function rollupOf(where, value, parent, tables) {
+	if (!isObject$1(value)) throw new TypeError(`${where} must be an object`);
+	checkKeys$1(where, value, ROLLUP_KEYS);
+	const { table, via, aggregate, column } = value;
+	const child = typeof table === "string" ? tables[table] : void 0;
+	if (typeof table !== "string" || child === void 0) throw new TypeError(`${where}.table must name an app table (${listOf(Object.keys(tables))})`);
+	const vias = referencesTo(child, parent);
+	if (typeof via !== "string" || !vias.includes(via)) throw new TypeError(`${where}.via must name a column of ${table} that references ${parent} (${listOf(vias)})`);
+	if (!isAggregate(aggregate)) throw new TypeError(`${where}.aggregate must be one of ${APP_ROLLUP_AGGREGATES.join(", ")}`);
+	const filter = whereOf(`${where}.where`, value["where"], table, child);
+	const base = {
+		table,
+		via,
+		aggregate,
+		...filter ? { where: filter } : {}
+	};
+	if (aggregate === "count") {
+		if (column !== void 0) throw new TypeError(`${where}.column: count counts rows; drop column`);
+		return base;
+	}
+	const fits = aggregate === "sum" || aggregate === "avg" ? NUMBERS : ORDERED;
+	const candidates = [...readable(child)].filter(([, type]) => fits.has(type)).map(([name]) => name);
+	if (typeof column !== "string" || !candidates.includes(column)) throw new TypeError(`${where}.column: ${aggregate} needs a ${fits === NUMBERS ? "number" : "number, date, time or text"} column of ${table} (${listOf(candidates)})`);
+	return {
+		...base,
+		column
+	};
+}
+function lookupOf(where, value, name, tables) {
+	if (!isObject$1(value)) throw new TypeError(`${where} must be an object`);
+	checkKeys$1(where, value, LOOKUP_KEYS);
+	const { via, column } = value;
+	const own = tables[name]?.columns ?? {};
+	const vias = Object.entries(own).filter(([, each]) => each.references !== void 0 && !("block" in each.references) && Object.hasOwn(tables, each.references.table));
+	const reference = vias.find(([each]) => each === via)?.[1].references;
+	if (typeof via !== "string" || reference === void 0 || "block" in reference) throw new TypeError(`${where}.via must name a column of ${name} that references another app table (${listOf(vias.map(([each]) => each))})`);
+	const target = tables[reference.table];
+	const columns = target === void 0 ? /* @__PURE__ */ new Map() : readable(target);
+	if (typeof column !== "string" || !columns.has(column)) throw new TypeError(`${where}.column must name a column of ${reference.table} (${listOf(columns.keys())})`);
+	return {
+		via,
+		column
+	};
+}
+function entriesOf(where, value) {
+	if (value === void 0) return [];
+	if (!isObject$1(value)) throw new TypeError(`${where} must be an object keyed by column name`);
+	return Object.entries(value);
+}
+/**
+* The `rollups` and `lookups` of the app table `name`, checked against
+* every resolved app table. `taken` holds the columns the table already
+* has, which a computed column may not reuse.
+*/
+function computedOf(where, value, name, tables, taken) {
+	if (!isObject$1(value)) return {};
+	const rollups = entriesOf(`${where}.rollups`, value["rollups"]);
+	const lookups = entriesOf(`${where}.lookups`, value["lookups"]);
+	if (rollups.length + lookups.length > MAX_COMPUTED) throw new TypeError(`${where}: at most ${String(MAX_COMPUTED)} rollups and lookups together`);
+	const used = new Set(taken);
+	const named = (key, column) => {
+		const at = `${where}.${key}.${column}`;
+		if (!IDENT$1.test(column)) throw new TypeError(`${at}: "${column}" is not a lower snake identifier (a-z, 0-9 and _, starting with a letter)`);
+		if (used.has(column)) throw new TypeError(`${at}: "${column}" is already a column of ${name}; choose another name`);
+		used.add(column);
+		return at;
+	};
+	const resolvedRollups = rollups.map(([column, rollup]) => [column, rollupOf(named("rollups", column), rollup, name, tables)]);
+	const resolvedLookups = lookups.map(([column, lookup]) => [column, lookupOf(named("lookups", column), lookup, name, tables)]);
+	return {
+		...value["rollups"] === void 0 ? {} : { rollups: Object.fromEntries(resolvedRollups) },
+		...value["lookups"] === void 0 ? {} : { lookups: Object.fromEntries(resolvedLookups) }
+	};
+}
+/** Whether a table has a rollup or a lookup, and so a `<table>_view`. */
+function hasComputed(table) {
+	return Object.keys(table.rollups ?? {}).length > 0 || Object.keys(table.lookups ?? {}).length > 0;
+}
+//#endregion
+//#region src/config/app-tables.ts
+const IDENT = /^[a-z][a-z0-9_]{0,62}$/;
+const BLOCK_NAME = /^[a-z][a-z0-9-]{0,62}$/;
+const TEXT_LITERAL = /^'(?:[^'\\]|'')*'$/;
+const INTEGER = /^-?\d{1,18}$/;
+const NUMBER = /^-?\d{1,30}(?:\.\d{1,30})?$/;
+const MAX_LITERAL = 200;
+const MAX_OPTIONS = 100;
+const MAX_OPTION = 100;
+const MAX_COMMENT = 1e3;
+const MAX_KEY_SETS = 20;
+/** Postgres keeps at most 32 columns in an index. */
+const MAX_KEY_COLUMNS = 32;
+const CONTROL = /\p{Cc}/u;
+const TABLE_KEYS = /* @__PURE__ */ new Set([
+	"columns",
+	"scope",
+	"timestamps",
+	"id",
+	"unique",
+	"indexes",
+	"comment",
+	"subject",
+	"rollups",
+	"lookups"
+]);
+const SUBJECT_KEYS = /* @__PURE__ */ new Set([
+	"type",
+	"title",
+	"url",
+	"search",
+	"permissions",
+	"rank",
+	"softDelete"
+]);
+/** The columns `subject.rank` and `subject.softDelete` add. */
+const APP_RANK_COLUMN = "rank";
+const APP_DELETED_AT_COLUMN = "deleted_at";
+const PLACEHOLDER = /\{([^}]*)\}/gu;
+const COLUMN_KEYS = /* @__PURE__ */ new Set([
+	"type",
+	"nullable",
+	"default",
+	"unique",
+	"references",
+	"format",
+	"options",
+	"min",
+	"max",
+	"comment",
+	"identity"
+]);
+const NUMBER_TYPES = /* @__PURE__ */ new Set([
+	"integer",
+	"bigint",
+	"numeric"
+]);
+const FORMATS = new Set(APP_COLUMN_FORMATS);
+const REFERENCE_KEYS = /* @__PURE__ */ new Set([
+	"table",
+	"block",
+	"onDelete"
+]);
+const SCOPES = /* @__PURE__ */ new Set([
+	"inherit",
+	"user",
+	"none"
+]);
+const ON_DELETE = new Set(APP_ON_DELETE_ACTIONS);
+const COLUMN_TYPES = new Set(APP_COLUMN_TYPES);
+/** The table every `auth.users` reference points at. */
+const AUTH_USERS = "auth.users";
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isOnDelete(value) {
+	return typeof value === "string" && ON_DELETE.has(value);
+}
+function isScope(value) {
+	return typeof value === "string" && SCOPES.has(value);
+}
+function isColumnType(value) {
+	return typeof value === "string" && COLUMN_TYPES.has(value);
+}
+function isFormat(value) {
+	return typeof value === "string" && FORMATS.has(value);
+}
+function commentOf(where, value) {
+	if (value === void 0) return;
+	if (typeof value !== "string" || value.length === 0 || value.length > MAX_COMMENT || value.includes("\0")) throw new TypeError(`${where} must be text of 1 to ${String(MAX_COMMENT)} characters`);
+	return value;
+}
+function formatOf(where, value, type) {
+	if (value === void 0) return;
+	if (!isFormat(value)) throw new TypeError(`${where} must be one of ${APP_COLUMN_FORMATS.join(", ")}`);
+	const types = FIELD_FORMATS[value].types;
+	if (!types.includes(type)) throw new TypeError(`${where}: ${value} fits a ${types.join(" or ")} column, not ${type}`);
+	return value;
+}
+function optionsOf(where, value, type) {
+	if (value === void 0) return;
+	if (type !== "text" && type !== "text[]") throw new TypeError(`${where}: options fit a text (single select) or text[] (multi-select) column, not ${type}`);
+	if (!Array.isArray(value) || value.length === 0 || value.length > MAX_OPTIONS) throw new TypeError(`${where} must list 1 to ${String(MAX_OPTIONS)} values`);
+	const seen = /* @__PURE__ */ new Set();
+	for (const option of value) {
+		if (typeof option !== "string" || option.length === 0 || option.length > MAX_OPTION || CONTROL.test(option)) throw new TypeError(`${where}: each option is text of 1 to ${String(MAX_OPTION)} characters without control characters`);
+		if (seen.has(option)) throw new TypeError(`${where}: "${option}" is listed twice`);
+		seen.add(option);
+	}
+	return [...seen];
+}
+function boundOf(where, value, type) {
+	if (value === void 0) return;
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new TypeError(`${where} must be a number`);
+	if (type === "text") {
+		if (!Number.isSafeInteger(value) || value < 0) throw new TypeError(`${where}: a text length is a whole number of 0 or more`);
+		return value;
+	}
+	if (!NUMBER_TYPES.has(type)) throw new TypeError(`${where}: min and max fit a number or text column, not ${type}`);
+	if (type !== "numeric" && !Number.isSafeInteger(value)) throw new TypeError(`${where}: an ${type} bound is a whole number`);
+	return value;
+}
+function identityOf(where, value, column, type) {
+	const identity = optionalBoolean(where, value);
+	if (identity !== true) return identity;
+	if (type !== "integer" && type !== "bigint") throw new TypeError(`${where}: an identity is an integer or bigint, not ${type}`);
+	for (const key of [
+		"default",
+		"references",
+		"options"
+	]) if (column[key] !== void 0) throw new TypeError(`${where}: an identity takes no ${key}`);
+	if (column["nullable"] === true) throw new TypeError(`${where}: an identity is never null`);
+	return identity;
+}
+/**
+* The sets of columns of a composite `unique` or `indexes` key. Whether each
+* name is a column of the table is checked when the SQL renders, where the
+* scope column is known.
+*/
+function keySetsOf(where, value) {
+	if (value === void 0) return;
+	if (!Array.isArray(value) || value.length > MAX_KEY_SETS) throw new TypeError(`${where} must list at most ${String(MAX_KEY_SETS)} sets of columns`);
+	return value.map((set, index) => {
+		const at = `${where}[${String(index)}]`;
+		if (!Array.isArray(set) || set.length === 0 || set.length > MAX_KEY_COLUMNS) throw new TypeError(`${at} must list 1 to ${String(MAX_KEY_COLUMNS)} column names`);
+		const columns = set.map((column) => {
+			if (typeof column !== "string" || !IDENT.test(column)) throw new TypeError(`${at}: ${JSON.stringify(column)} is not a column name`);
+			return column;
+		});
+		if (new Set(columns).size !== columns.length) throw new TypeError(`${at} names a column twice`);
+		return columns;
+	});
+}
+function checkKeys(where, value, allowed) {
+	for (const key of Object.keys(value)) if (!allowed.has(key)) throw new TypeError(`${where}: unknown key "${key}" (use ${[...allowed].join(", ")})`);
+}
+function optionalBoolean(where, value) {
+	if (value !== void 0 && typeof value !== "boolean") throw new TypeError(`${where} must be true or false`);
+	return value;
+}
+/**
+* The columns every app table gets, which `columns` may not name:
+* `id`, `created_at`, `updated_at`, `user_id` and the tenant column
+* (`organization_id`, or `<sql.naming.tenant>_id`), whatever the table's
+* scope, so changing the scope never collides with a column.
+*/
+function appReservedColumns(tenant = "organization") {
+	return [
+		"id",
+		"created_at",
+		"updated_at",
+		"user_id",
+		`${tenant}_id`
+	];
+}
+/** Whether `value` is a default `type` accepts; see `AppColumnConfig.default`. */
+function isAppDefault(type, value) {
+	switch (value) {
+		case "now()": return type === "timestamptz" || type === "date";
+		case "gen_random_uuid()":
+		case "auth.uid()": return type === "uuid";
+		case "true":
+		case "false": return type === "boolean";
+		case "'{}'": return type === "jsonb" || type === "text[]" || type === "text";
+		case "'[]'": return type === "jsonb" || type === "text";
+	}
+	if (INTEGER.test(value)) return type === "integer" || type === "bigint" || type === "numeric";
+	if (NUMBER.test(value)) return type === "numeric";
+	return value.length <= MAX_LITERAL && TEXT_LITERAL.test(value) && (type === "text" || type === "uuid" || type === "date" || type === "timestamptz");
+}
+function referenceOf(where, value, type, nullable, tables) {
+	if (!isObject(value)) throw new TypeError(`${where} must be an object`);
+	checkKeys(where, value, REFERENCE_KEYS);
+	const { table, block, onDelete } = value;
+	if (typeof table !== "string") throw new TypeError(`${where}.table must be a string`);
+	if (onDelete !== void 0 && !isOnDelete(onDelete)) throw new TypeError(`${where}.onDelete must be one of ${[...ON_DELETE].join(", ")}`);
+	if (onDelete === "set null" && !nullable) throw new TypeError(`${where}.onDelete: "set null" needs a nullable column`);
+	const deletes = onDelete === void 0 ? {} : { onDelete };
+	if (block !== void 0) {
+		if (typeof block !== "string" || !BLOCK_NAME.test(block)) throw new TypeError(`${where}.block must be a block name`);
+		if (!IDENT.test(table)) throw new TypeError(`${where}.table: "${table}" is not a logical table name of the ${block} block`);
+		return {
+			block,
+			table,
+			...deletes
+		};
+	}
+	const id = table === "auth.users" ? "uuid" : tables.get(table);
+	if (id === void 0) throw new TypeError(`${where}.table: "${table}" is neither an app table nor ${AUTH_USERS}; reference a block table with { block, table }`);
+	if (type !== id) throw new TypeError(`${where}: a reference to ${table} needs a ${id} column, not ${type}`);
+	return {
+		table,
+		...deletes
+	};
+}
+function columnOf(where, value, tables) {
+	if (!isObject(value)) throw new TypeError(`${where} must be an object`);
+	checkKeys(where, value, COLUMN_KEYS);
+	const { type } = value;
+	if (!isColumnType(type)) throw new TypeError(`${where}.type must be one of ${APP_COLUMN_TYPES.join(", ")}${type === "money" ? " (store money as bigint minor units next to a text currency column)" : ""}`);
+	const nullable = optionalBoolean(`${where}.nullable`, value["nullable"]);
+	const unique = optionalBoolean(`${where}.unique`, value["unique"]);
+	const fallback = value["default"];
+	if (fallback !== void 0 && (typeof fallback !== "string" || !isAppDefault(type, fallback))) throw new TypeError(`${where}.default: ${JSON.stringify(fallback)} is not an allowed ${type} default (now(), gen_random_uuid(), auth.uid(), true, false, a number, a 'quoted' literal, '{}' or '[]')`);
+	const references = value["references"] === void 0 ? void 0 : referenceOf(`${where}.references`, value["references"], type, nullable !== false, tables);
+	const format = formatOf(`${where}.format`, value["format"], type);
+	const options = optionsOf(`${where}.options`, value["options"], type);
+	const min = boundOf(`${where}.min`, value["min"], type);
+	const max = boundOf(`${where}.max`, value["max"], type);
+	const comment = commentOf(`${where}.comment`, value["comment"]);
+	const identity = identityOf(`${where}.identity`, value["identity"], value, type);
+	if (options !== void 0 && format !== void 0) throw new TypeError(`${where}: options make a select; drop the format ${format}`);
+	if (min !== void 0 && max !== void 0 && min > max) throw new TypeError(`${where}: min ${String(min)} is above max ${String(max)}`);
+	return {
+		type,
+		...nullable === void 0 ? {} : { nullable },
+		...fallback === void 0 ? {} : { default: fallback },
+		...unique === void 0 ? {} : { unique },
+		...references === void 0 ? {} : { references },
+		...format === void 0 ? {} : { format },
+		...options === void 0 ? {} : { options },
+		...min === void 0 ? {} : { min },
+		...max === void 0 ? {} : { max },
+		...comment === void 0 ? {} : { comment },
+		...identity === void 0 ? {} : { identity }
+	};
+}
+function namedColumn(where, value, columns) {
+	if (typeof value !== "string" || !columns.has(value)) throw new TypeError(`${where} must name a column of the table (${[...columns].join(", ")})`);
+	return value;
+}
+function searchOf(where, value, columns) {
+	if (value === void 0) return;
+	if (!isObject(value)) throw new TypeError(`${where} must be an object`);
+	checkKeys(where, value, /* @__PURE__ */ new Set(["title", "body"]));
+	const { title, body } = value;
+	if (body !== void 0 && !Array.isArray(body)) throw new TypeError(`${where}.body must be a list of columns`);
+	return {
+		...title === void 0 ? {} : { title: namedColumn(`${where}.title`, title, columns) },
+		...body === void 0 ? {} : { body: body.map((each) => namedColumn(`${where}.body`, each, columns)) }
+	};
+}
+function permissionsOf(where, value) {
+	if (value === void 0) return;
+	if (!isObject(value) || Object.values(value).some((key) => typeof key !== "string" || key === "")) throw new TypeError(`${where} must map each action to a permission key`);
+	return Object.fromEntries(Object.entries(value).map(([action, key]) => [action, String(key)]));
+}
+function rankOf(where, value, columns) {
+	if (value === void 0 || value === true) return value;
+	if (!isObject(value)) throw new TypeError(`${where} must be true or { group }`);
+	checkKeys(where, value, /* @__PURE__ */ new Set(["group"]));
+	return value["group"] === void 0 ? {} : { group: namedColumn(`${where}.group`, value["group"], columns) };
+}
+/**
+* `subject` checked against the table's columns. `columns` holds every
+* column the table has, the ones `rank` and `softDelete` add included.
+*/
+function subjectOf(where, value, columns) {
+	if (value === void 0) return;
+	if (!isObject(value)) throw new TypeError(`${where} must be an object`);
+	checkKeys(where, value, SUBJECT_KEYS);
+	const { type, title, url } = value;
+	if (typeof type !== "string" || !IDENT.test(type)) throw new TypeError(`${where}.type must be lowercase letters, digits and underscores, starting with a letter`);
+	if (url !== void 0) {
+		if (typeof url !== "string" || !url.startsWith("/")) throw new TypeError(`${where}.url must be a path starting with /`);
+		for (const [, name] of url.matchAll(PLACEHOLDER)) namedColumn(`${where}.url {${name ?? ""}}`, name, columns);
+	}
+	const search = searchOf(`${where}.search`, value["search"], columns);
+	const permissions = permissionsOf(`${where}.permissions`, value["permissions"]);
+	const rank = rankOf(`${where}.rank`, value["rank"], columns);
+	const softDelete = optionalBoolean(`${where}.softDelete`, value["softDelete"]);
+	return {
+		type,
+		...title === void 0 ? {} : { title: namedColumn(`${where}.title`, title, columns) },
+		...url === void 0 ? {} : { url },
+		...search === void 0 ? {} : { search },
+		...permissions === void 0 ? {} : { permissions },
+		...rank === void 0 ? {} : { rank },
+		...softDelete === void 0 ? {} : { softDelete }
+	};
+}
+/** The columns the subject adds, which `columns` may not name. */
+function subjectColumnsOf(value) {
+	if (!isObject(value)) return [];
+	return [...value["rank"] === void 0 ? [] : [APP_RANK_COLUMN], ...value["softDelete"] === true ? [APP_DELETED_AT_COLUMN] : []];
+}
+function tableOf(where, value, tables, reserved) {
+	if (!isObject(value)) throw new TypeError(`${where} must be an object`);
+	checkKeys(where, value, TABLE_KEYS);
+	const { scope, columns, id } = value;
+	if (scope !== void 0 && !isScope(scope)) throw new TypeError(`${where}.scope must be inherit, user or none`);
+	if (id !== void 0 && id !== "uuid" && id !== "bigint") throw new TypeError(`${where}.id must be uuid or bigint`);
+	const unique = keySetsOf(`${where}.unique`, value["unique"]);
+	const indexes = keySetsOf(`${where}.indexes`, value["indexes"]);
+	const comment = commentOf(`${where}.comment`, value["comment"]);
+	const timestamps = optionalBoolean(`${where}.timestamps`, value["timestamps"]);
+	if (columns !== void 0 && !isObject(columns)) throw new TypeError(`${where}.columns must be an object keyed by column`);
+	const added = subjectColumnsOf(value["subject"]);
+	const resolved = Object.entries(columns ?? {}).map(([name, column]) => {
+		const at = `${where}.columns.${name}`;
+		if (!IDENT.test(name)) throw new TypeError(`${at}: "${name}" is not a lower snake identifier (a-z, 0-9 and _, starting with a letter)`);
+		if (reserved.has(name)) throw new TypeError(`${at}: "${name}" is a column every app table gets (${[...reserved].join(", ")})`);
+		if (added.includes(name)) throw new TypeError(`${at}: "${name}" is the column ${where}.subject adds; remove it from columns`);
+		return [name, columnOf(at, column, tables)];
+	});
+	const subject = subjectOf(`${where}.subject`, value["subject"], /* @__PURE__ */ new Set([
+		...reserved,
+		...added,
+		...resolved.map(([name]) => name)
+	]));
+	return {
+		...columns === void 0 ? {} : { columns: Object.fromEntries(resolved) },
+		...scope === void 0 ? {} : { scope },
+		...timestamps === void 0 ? {} : { timestamps },
+		...id === void 0 ? {} : { id },
+		...unique === void 0 ? {} : { unique },
+		...indexes === void 0 ? {} : { indexes },
+		...comment === void 0 ? {} : { comment },
+		...subject === void 0 ? {} : { subject }
+	};
+}
+/**
+* `appTables` checked: lower snake table and column names, column types
+* from `APP_COLUMN_TYPES`, defaults from the allowlist, no reserved
+* columns, and references to another app table, `auth.users` or a block's
+* logical table. Whether a referenced block is installed, and whether a
+* name clashes with a block table, is checked when the SQL renders, where
+* the block registry is known. Throws a `TypeError` naming the key.
+*/
+function appTablesOf(value, tenant) {
+	if (value === void 0) return {};
+	if (!isObject(value)) throw new TypeError("appTables must be an object keyed by table name");
+	const tables = new Map(Object.entries(value).map(([name, table]) => [name, isObject(table) && table["id"] === "bigint" ? "bigint" : "uuid"]));
+	const reserved = new Set(appReservedColumns(tenant));
+	const resolved = Object.fromEntries(Object.entries(value).map(([name, table]) => {
+		if (!IDENT.test(name) || name.startsWith("pg_")) throw new TypeError(`appTables.${name}: "${name}" is not a lower snake identifier (a-z, 0-9 and _, starting with a letter)`);
+		return [name, tableOf(`appTables.${name}`, table, tables, reserved)];
+	}));
+	return Object.fromEntries(Object.entries(resolved).map(([name, table]) => {
+		const where = `appTables.${name}`;
+		const computed = computedOf(where, value[name], name, resolved, /* @__PURE__ */ new Set([
+			...reserved,
+			...Object.keys(table.columns ?? {}),
+			...subjectColumnsOf(table.subject)
+		]));
+		const withComputed = {
+			...table,
+			...computed
+		};
+		if (hasComputed(withComputed) && Object.hasOwn(resolved, `${name}_view`)) throw new TypeError(`${where}: its rollups and lookups go in the view ${name}_view, which is also an app table; rename one`);
+		return [name, withComputed];
+	}));
+}
+/**
+* `subjects` with the subject of every app table that sets one (ADR 0043):
+* the table in `public`, its id type, and its tenant column, or `false`
+* for a table kept per user or shared. `scope` is `sql.scope` and `tenant`
+* is `sql.naming.tenant`. Throws when a type is taken twice.
+*/
+function withAppTableSubjects(subjects, appTables, scope, tenant = "organization") {
+	const merged = { ...subjects };
+	for (const [name, table] of Object.entries(appTables)) {
+		const subject = table.subject;
+		if (subject === void 0) continue;
+		const where = `appTables.${name}.subject`;
+		if (Object.hasOwn(merged, subject.type)) throw new TypeError(`${where}.type: "${subject.type}" is already a subject type; choose another type or remove subjects.${subject.type}`);
+		const kept = table.scope === void 0 || table.scope === "inherit" ? scope ?? "tenant" : table.scope;
+		merged[subject.type] = {
+			table: `public.${name}`,
+			idType: table.id ?? "uuid",
+			tenant: kept === "tenant" ? `${tenant}_id` : false,
+			...subject.title === void 0 ? {} : { title: subject.title },
+			...subject.url === void 0 ? {} : { url: subject.url },
+			...subject.search === void 0 ? {} : { search: subject.search },
+			...subject.permissions === void 0 ? {} : { permissions: subject.permissions },
+			...subject.softDelete === true ? { deletedAt: APP_DELETED_AT_COLUMN } : {},
+			...subject.rank === void 0 ? {} : { rank: {
+				column: APP_RANK_COLUMN,
+				...subject.rank === true || subject.rank.group === void 0 ? {} : { group: subject.rank.group }
+			} }
+		};
+	}
+	return merged;
+}
+//#endregion
+export { appTablesOf as a, hasComputed as c, APP_ON_DELETE_ACTIONS as d, APP_ROLLUP_AGGREGATES as f, appReservedColumns as i, APP_COLUMN_FORMATS as l, APP_RANK_COLUMN as n, isAppDefault as o, AUTH_USERS as r, withAppTableSubjects as s, APP_DELETED_AT_COLUMN as t, APP_COLUMN_TYPES as u };