better-supabase 0.13.0 → 0.15.0

package/dist/app-tables-0YZ9IskE.js

@@ -1,831 +0,0 @@
-import { i as FIELD_FORMAT_NAMES, r as FIELD_FORMATS } from "./field-formats-C6QKA3UR.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_COLUMN_ACCESS = ["read", "server"];
-const APP_TABLE_EVENT_KINDS = [
-	"created",
-	"updated",
-	"deleted"
-];
-const APP_ROLLUP_AGGREGATES = [
-	"count",
-	"sum",
-	"min",
-	"max",
-	"avg"
-];
-//#endregion
-//#region src/config/app-access.ts
-const PLACEHOLDER$1 = /\{([^}]*)\}/gu;
-/** `appTables.<t>.columns.<c>.access` checked. */
-function accessOf(where, value) {
-	if (value === void 0) return;
-	const access = APP_COLUMN_ACCESS.find((option) => option === value);
-	if (access === void 0) throw new TypeError(`${where} must be one of ${APP_COLUMN_ACCESS.join(", ")}`);
-	return access;
-}
-/** The own columns of `table` with `access` set to `access`, in config order. */
-function columnsWithAccess(table, access) {
-	return Object.entries(table.columns ?? {}).flatMap(([name, column]) => column.access === access ? [name] : []);
-}
-/** Whether `table` restricts any column with `access`. */
-function hasColumnAccess(table) {
-	return Object.values(table.columns ?? {}).some((column) => column.access !== void 0);
-}
-function urlColumns(url) {
-	return url === void 0 ? [] : [...url.matchAll(PLACEHOLDER$1)].flatMap((match) => match[1] === void 0 ? [] : [match[1]]);
-}
-/** Every place a table's config reads a column for signed-in users. */
-function readsOf(name, table, tables) {
-	const at = `appTables.${name}`;
-	const { subject } = table;
-	const versions = subject?.versions;
-	const rank = subject?.rank;
-	const own = (where, column) => ({
-		where: `${at}.${where}`,
-		table: name,
-		column
-	});
-	const lookupTarget = (via) => {
-		const reference = table.columns?.[via]?.references;
-		return reference === void 0 || "block" in reference ? void 0 : reference.table;
-	};
-	return [
-		own("subject.title", subject?.title),
-		own("subject.search.title", subject?.search?.title),
-		...(subject?.search?.body ?? []).map((column) => own("subject.search.body", column)),
-		...urlColumns(subject?.url).map((column) => own("subject.url", column)),
-		own("subject.rank.group", rank === true ? void 0 : rank?.group),
-		...versions === true || versions?.columns === void 0 ? [] : versions.columns.map((column) => own("subject.versions.columns", column)),
-		...(table.events === true ? [] : table.events?.include ?? []).map((column) => own("events.include", column)),
-		...Object.entries(table.rollups ?? {}).flatMap(([key, rollup]) => [
-			rollup.via,
-			rollup.column,
-			rollup.where?.column
-		].map((column) => ({
-			where: `${at}.rollups.${key}`,
-			table: rollup.table,
-			column
-		}))),
-		...Object.entries(table.lookups ?? {}).flatMap(([key, lookup]) => {
-			const target = lookupTarget(lookup.via);
-			return [own(`lookups.${key}.via`, lookup.via), {
-				where: `${at}.lookups.${key}.column`,
-				table: target ?? name,
-				column: target === void 0 ? void 0 : lookup.column
-			}];
-		})
-	].filter((use) => tables[use.table] !== void 0);
-}
-/**
-* Throws when a column with `access: "server"` is read where signed-in users
-* see the value: a subject's title, search, url, rank group or versioned
-* columns, an event payload, or a rollup or lookup (ADR 0051). Versions of
-* every column (`versions: true`) would copy it into the history, so such a
-* table lists `subject.versions.columns`.
-*/
-function checkColumnAccess(tables) {
-	for (const [name, table] of Object.entries(tables)) {
-		const hidden = columnsWithAccess(table, "server");
-		const versions = table.subject?.versions;
-		if (hidden.length > 0 && (versions === true || versions !== void 0 && !versions.columns)) throw new TypeError(`appTables.${name}.subject.versions: the history would copy ${hidden.join(", ")}, which has access server; list subject.versions.columns without it`);
-		for (const use of readsOf(name, table, tables)) if ((use.column === void 0 ? void 0 : tables[use.table]?.columns?.[use.column])?.access === "server") throw new TypeError(`${use.where}: ${use.table}.${String(use.column)} has access server, so signed-in users can't read it here; drop it or set access read`);
-	}
-}
-//#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",
-	"events"
-]);
-const SUBJECT_KEYS = /* @__PURE__ */ new Set([
-	"type",
-	"title",
-	"url",
-	"search",
-	"permissions",
-	"rank",
-	"softDelete",
-	"versions"
-]);
-/** 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",
-	"access"
-]);
-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`
-	];
-}
-/**
-* Postgres truncates identifiers past 63 bytes, so longer generated names
-* collide.
-*/
-const MAX_IDENTIFIER = 63;
-/** The longest app table or column name: `<table>_view` still fits in 63 bytes. */
-const APP_NAME_MAX = 58;
-/**
-* Why `name` can't name an app table or column, or `undefined` when it can:
-* lower snake case starting with a letter, not `pg_`, and at most
-* `APP_NAME_MAX` characters.
-*/
-function appIdentifierError(name) {
-	if (name === "") return "Enter a name.";
-	if (name.length > 58) return `Use at most ${String(58)} characters.`;
-	if (!IDENT.test(name)) return "Use lower-case letters, digits and underscores, starting with a letter.";
-	if (name.startsWith("pg_")) return "Names starting with pg_ are reserved by Postgres.";
-}
-/**
-* The first constraint or index name the SQL derives for `table` that is longer
-* than 63 bytes, which Postgres would truncate into a collision, as a message;
-* `undefined` when every name fits.
-*/
-function appNameLengthError(table, config) {
-	const long = [
-		...Object.entries(config.columns ?? {}).flatMap(([column, each]) => each.references !== void 0 || each.format !== void 0 || each.options !== void 0 || each.min !== void 0 || each.max !== void 0 ? [`${table}_${column}_check`] : []),
-		...(config.unique ?? []).map((set) => `${table}_${set.join("_")}_key`),
-		...(config.indexes ?? []).map((set) => `${table}_${set.join("_")}_idx`)
-	].find((name) => name.length > MAX_IDENTIFIER);
-	return long === void 0 ? void 0 : `${long} is longer than ${String(MAX_IDENTIFIER)} characters; use shorter table or column names`;
-}
-/** The defaults `isAppDefault` accepts, per type, as a message names them. */
-const DEFAULT_EXAMPLES = {
-	text: "a 'quoted' text",
-	integer: "a whole number",
-	bigint: "a whole number",
-	numeric: "a number",
-	boolean: "true or false",
-	uuid: "gen_random_uuid(), auth.uid() or a 'quoted' value",
-	timestamptz: "now() or a 'quoted' value",
-	date: "now() or a 'quoted' value",
-	jsonb: "'{}' or '[]'",
-	"text[]": "'{}'"
-};
-/**
-* Why `value` can't be the default of `column`, or `undefined` when it can: it
-* must be on the `isAppDefault` allowlist, one of the column's `options`, and
-* inside its bounds (`min`, `max`, or those of its format).
-*/
-function appDefaultError(column, value) {
-	const { type } = column;
-	if (!isAppDefault(type, value)) return `A ${type} column takes ${DEFAULT_EXAMPLES[type]} as its default.`;
-	const literal = TEXT_LITERAL.test(value) ? value.slice(1, -1).replaceAll("''", "'") : void 0;
-	if (type === "text" && column.options !== void 0 && literal !== void 0 && !column.options.includes(literal)) return `The default must be one of the options: ${column.options.join(", ")}.`;
-	const bounds = column.format === void 0 ? void 0 : FIELD_FORMATS[column.format].bounds;
-	const min = column.min ?? bounds?.[0];
-	const max = column.max ?? bounds?.[1];
-	const size = type === "text" ? literal?.length : NUMBER.test(value) ? Number(value) : void 0;
-	if (size === void 0) return;
-	const what = type === "text" ? "length" : "value";
-	if (min !== void 0 && size < min) return `The default's ${what} is below the minimum of ${String(min)}.`;
-	if (max !== void 0 && size > max) return `The default's ${what} is above the maximum of ${String(max)}.`;
-}
-/** 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);
-	const access = accessOf(`${where}.access`, value["access"]);
-	if (access !== void 0 && nullable === false && fallback === void 0 && identity !== true) throw new TypeError(`${where}: signed-in users can't write a column with access ${access}, so a required one needs a default`);
-	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)}`);
-	const outside = typeof fallback === "string" ? appDefaultError({
-		type,
-		...options === void 0 ? {} : { options },
-		...min === void 0 ? {} : { min },
-		...max === void 0 ? {} : { max },
-		...format === void 0 ? {} : { format }
-	}, fallback) : void 0;
-	if (outside !== void 0) throw new TypeError(`${where}.default: ${outside}`);
-	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 },
-		...access === void 0 ? {} : { access }
-	};
-}
-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.versions` checked: `true`, or `columns` from the table's own columns
-* (not its id, scope or timestamps, which a restore must not write) and
-* `auto`.
-*/
-function versionsOf(where, value, editable) {
-	if (value === void 0 || value === true) return value;
-	if (!isObject(value)) throw new TypeError(`${where} must be true or { columns, auto }`);
-	checkKeys(where, value, /* @__PURE__ */ new Set(["columns", "auto"]));
-	const { columns } = value;
-	if (columns !== void 0 && (!Array.isArray(columns) || columns.length === 0)) throw new TypeError(`${where}.columns must list one or more columns`);
-	const listed = columns?.map((name, index) => namedColumn(`${where}.columns[${index}]`, name, editable));
-	const auto = optionalBoolean(`${where}.auto`, value["auto"]);
-	return {
-		...listed === void 0 ? {} : { columns: [...new Set(listed)] },
-		...auto === void 0 ? {} : { auto }
-	};
-}
-/**
-* The columns and snapshot mode `subject.versions` registers with the versions
-* block.
-*/
-function appTableVersions(table) {
-	const versions = table.subject?.versions;
-	if (versions === void 0) return;
-	const options = versions === true ? {} : versions;
-	return {
-		columns: options.columns ?? Object.keys(table.columns ?? {}),
-		auto: options.auto ?? true
-	};
-}
-/**
-* `subject` checked against the table's columns. `columns` holds every column
-* the table has, the ones `rank` and `softDelete` add included; `editable`
-* holds the table's own columns.
-*/
-function subjectOf(where, value, columns, editable) {
-	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"]);
-	const versions = versionsOf(`${where}.versions`, value["versions"], editable);
-	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 },
-		...versions === void 0 ? {} : { versions }
-	};
-}
-/** 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] : []];
-}
-/** The event kinds `events` turns on; empty without it. */
-function appTableEventKinds(table) {
-	const events = table.events;
-	if (events === void 0) return [];
-	return events === true ? APP_TABLE_EVENT_KINDS : events.on ?? APP_TABLE_EVENT_KINDS;
-}
-/** The event types an app table emits: `<subject type or table>.<kind>`. */
-function appTableEventTypes(name, table) {
-	const base = table.subject?.type ?? name;
-	return appTableEventKinds(table).map((kind) => `${base}.${kind}`);
-}
-function isEventKind(value) {
-	return APP_TABLE_EVENT_KINDS.some((kind) => kind === value);
-}
-/**
-* `events` checked: `true`, or `on` from the event kinds and `include` from the
-* table's columns.
-*/
-function eventsOf(where, value, columns) {
-	if (value === void 0 || value === true) return value;
-	if (!isObject(value)) throw new TypeError(`${where} must be true or { on, include }`);
-	checkKeys(where, value, /* @__PURE__ */ new Set(["on", "include"]));
-	const { on, include } = value;
-	if (on !== void 0 && (!Array.isArray(on) || on.length === 0 || !on.every(isEventKind))) throw new TypeError(`${where}.on must list one or more of ${APP_TABLE_EVENT_KINDS.join(", ")}`);
-	if (include !== void 0 && !Array.isArray(include)) throw new TypeError(`${where}.include must be a list of columns`);
-	const included = include?.map((name, index) => namedColumn(`${where}.include[${index}]`, name, columns));
-	return {
-		...on === void 0 ? {} : { on: [...new Set(on)] },
-		...included === void 0 ? {} : { include: [...new Set(included)] }
-	};
-}
-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}`;
-		const invalid = appIdentifierError(name);
-		if (invalid !== void 0) throw new TypeError(`${at}: "${name}" is not a column name. ${invalid}`);
-		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)
-	]), new Set(resolved.map(([name]) => name)));
-	const events = eventsOf(`${where}.events`, value["events"], /* @__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 },
-		...events === void 0 ? {} : { events }
-	};
-}
-/**
-* `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]) => {
-		const invalid = appIdentifierError(name);
-		if (invalid !== void 0) throw new TypeError(`appTables.${name}: "${name}" is not a table name. ${invalid}`);
-		const checked = tableOf(`appTables.${name}`, table, tables, reserved);
-		const long = appNameLengthError(name, checked);
-		if (long !== void 0) throw new TypeError(`appTables.${name}: ${long}`);
-		return [name, checked];
-	}));
-	const checked = 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];
-	}));
-	checkColumnAccess(checked);
-	return checked;
-}
-/**
-* `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 } : {},
-			...versionsEntry(table),
-			...subject.rank === void 0 ? {} : { rank: {
-				column: APP_RANK_COLUMN,
-				...subject.rank === true || subject.rank.group === void 0 ? {} : { group: subject.rank.group }
-			} }
-		};
-	}
-	return merged;
-}
-function versionsEntry(table) {
-	const versions = appTableVersions(table);
-	return versions === void 0 ? {} : { versions };
-}
-//#endregion
-export { APP_TABLE_EVENT_KINDS as C, APP_ROLLUP_AGGREGATES as S, hasColumnAccess as _, appDefaultError as a, APP_COLUMN_TYPES as b, appReservedColumns as c, appTableVersions as d, appTablesOf as f, columnsWithAccess as g, hasComputed as h, AUTH_USERS as i, appTableEventKinds as l, withAppTableSubjects as m, APP_NAME_MAX as n, appIdentifierError as o, isAppDefault as p, APP_RANK_COLUMN as r, appNameLengthError as s, APP_DELETED_AT_COLUMN as t, appTableEventTypes as u, APP_COLUMN_ACCESS as v, APP_ON_DELETE_ACTIONS as x, APP_COLUMN_FORMATS as y };