better-supabase 0.8.0 → 0.9.0

package/dist/preset/index.js

@@ -0,0 +1,564 @@
+import { C as integrationsForFramework, E as PRESET_BLOCKS, S as PRESET_VERSION, T as presetValueLabel, _ as withPresetField, a as listNames, b as PRESET_FRAMEWORKS, c as PRESET_CATALOG, d as PRESET_NAMES, f as isPresetName, g as isPresetCode, h as encodePreset, i as presetOf, l as PRESETS, m as decodePreset, n as expandPreset, o as presetBlockConflict, p as namedPreset, r as presetConfig, s as resolvePreset, t as conventionConfig, u as PRESET_GROUPS, v as DEFAULT_CONVENTIONS, w as presetField, x as PRESET_TENANT_NAMES, y as PRESET_FIELDS } from "../config-C4MozTD7.js";
+import { a as appTablesOf, i as appReservedColumns, l as APP_COLUMN_FORMATS, o as isAppDefault } from "../app-tables-BGl5_U2x.js";
+//#region src/preset/render.ts
+const CREATE_URL = "https://bettersupabase.com/create";
+/** The comment a config with the provider access model gets above `blocks`. */
+const PROVIDER_COMMENT = ["  // The provider access model reads roles from your authorization", "  // library: set `authorization` to its adapter."];
+const key = (name) => /^[a-z_$][a-z0-9_$]*$/i.test(name) ? name : JSON.stringify(name);
+const camel = (name) => name.replaceAll(/-([a-z0-9])/g, (_, letter) => letter.toUpperCase());
+/** A JSON value as a TypeScript literal, one line. */
+function literal(value) {
+	if (Array.isArray(value)) return `[${value.map(literal).join(", ")}]`;
+	if (typeof value === "object" && value !== null) {
+		const entries = Object.entries(value);
+		if (entries.length === 0) return "{}";
+		return `{ ${entries.map(([name, each]) => `${key(name)}: ${literal(each)}`).join(", ")} }`;
+	}
+	return JSON.stringify(value);
+}
+/** The `/create` URL of a preset, with `&design=` when `designCode` isn't empty. */
+function createUrl(resolved, designCode = "") {
+	const preset = `${CREATE_URL}?preset=${encodePreset(resolved.preset)}`;
+	return designCode === "" ? preset : `${preset}&design=${designCode}`;
+}
+/**
+* `better-supabase.config.ts` with these keys: every block with its reason,
+* the conventions, and the app tables, under a comment with the `/create` URL.
+*/
+function configSource(resolved, config, url) {
+	const lines = [
+		"import { defineConfig } from \"better-supabase/config\";",
+		"",
+		`// ${url}`,
+		"export default defineConfig({"
+	];
+	if (config.casing !== void 0) lines.push(`  casing: ${literal(config.casing)},`);
+	if (config.sql !== void 0) lines.push(`  sql: ${literal(config.sql)},`);
+	if (config.integrations !== void 0) lines.push(`  integrations: ${literal(config.integrations)},`);
+	if (resolved.preset.access === "provider") lines.push(...PROVIDER_COMMENT);
+	lines.push("  blocks: {");
+	const entries = Object.entries(config.blocks);
+	for (const block of resolved.blocks) {
+		const entry = entries.find(([name]) => name === block.name)?.[1] ?? {};
+		const note = block.selected ? "" : ` // ${block.reason}`;
+		lines.push(`    ${key(block.name)}: ${literal(entry)},${note}`);
+	}
+	lines.push("  },");
+	if (config.appTables !== void 0) {
+		lines.push("  appTables: {");
+		for (const [name, table] of Object.entries(config.appTables)) lines.push(`    ${key(name)}: ${literal(table)},`);
+		lines.push("  },");
+	}
+	lines.push("});", "");
+	return lines.join("\n");
+}
+/**
+* `better-supabase.config.ts` for a resolved preset: every block with its
+* reason, and the conventions that differ from the defaults.
+*/
+function presetConfigSource(resolved) {
+	return configSource(resolved, presetConfig(resolved), createUrl(resolved));
+}
+/**
+* `lib/blocks.ts`: the blocks with a TypeScript client, wired with
+* `defineBlocks` over the Data API as the caller. Each block's schema (the
+* API schema when `sql.api` is set) and shared options come from
+* `blockConfig`, which `better-supabase gen` writes to
+* `blocks.generated.ts`; `blockConfigImport` is its import path.
+*/
+function presetBlocksSource(resolved, blockConfigImport = "./supabase/blocks.generated") {
+	const clients = resolved.manifests.flatMap((manifest) => manifest.client === null ? [] : [{
+		name: manifest.name,
+		...manifest.client
+	}]);
+	return [
+		"import {",
+		"  type RpcClient,",
+		"  defineBlocks,",
+		"  rpcTransport,",
+		"} from \"better-supabase/blocks\";",
+		...clients.map((client) => `import { ${client.export} } from "${client.subpath}";`),
+		"",
+		`import { blockConfig } from ${JSON.stringify(blockConfigImport)};`,
+		"",
+		"/** The installed blocks, with the settings `better-supabase gen` writes from the config. */",
+		"export const blockSet = defineBlocks(blockConfig, {",
+		...clients.map((client) => `  ${camel(client.name)}: ${client.export},`),
+		"});",
+		"",
+		"/**",
+		" * The blocks as typed clients, acting as the caller of `supabase`: its",
+		" * token, so RLS and each function's checks apply.",
+		" */",
+		"export function blocks(supabase: RpcClient) {",
+		"  return blockSet.create({ transport: rpcTransport(supabase) });",
+		"}",
+		""
+	].join("\n");
+}
+/** Where `presetBlocksSource` goes, as a shadcn target. */
+const WIRING_TARGET = "@lib/blocks.ts";
+/**
+* The registry glue for the preset's framework and platforms: each item
+* whose blocks are all installed, except bundles and items that write
+* `lib/blocks.ts`, which the preset writes itself.
+*/
+function presetGlue(resolved, catalog = PRESET_CATALOG) {
+	const { preset } = resolved;
+	const platforms = preset.platforms === "both" ? ["web", "native"] : [preset.platforms];
+	const installed = new Set(resolved.blocks.map((block) => block.name));
+	return catalog.glue.filter((item) => item.preset === void 0 && !item.targets.includes(WIRING_TARGET) && item.frameworks.includes(preset.framework) && item.platforms.some((platform) => platforms.includes(platform)) && item.blocks.every((block) => installed.has(block)));
+}
+/** The shadcn command that copies glue items into the app. */
+function glueCommand(items) {
+	return `npx shadcn@latest add ${items.map((item) => `@better-supabase/${item.name}`).join(" ")}`;
+}
+/** The command that starts a project from the preset. */
+function presetInstallCommand(resolved) {
+	return `npx better-supabase init --preset ${encodePreset(resolved.preset)}`;
+}
+/** The command that applies the preset to an existing project. */
+function presetApplyCommand(resolved) {
+	return `npx better-supabase apply --preset ${encodePreset(resolved.preset)}`;
+}
+//#endregion
+//#region src/preset/design.ts
+/**
+* The first character of a design code: how it is encoded. `0` is
+* deflate-raw compressed JSON in base64url. Preset codes never start with
+* `0` (their first character is the preset version, from 1), and preset
+* names never start with a digit. The JSON's own format is `DESIGN_FORMAT`.
+*/
+const DESIGN_VERSION = "0";
+/**
+* The newest format of the design JSON, in its `version` key (ADR 0042).
+* A code carries the lowest format that reads it, and none for format 0,
+* so a design without format 1 keys still opens in an older release.
+* Format 1 adds column `format`, `options`, `min`, `max`, `comment` and
+* `identity`, and table `id`, `unique`, `indexes` and `comment`. Format 2
+* adds table `subject` (ADR 0043). Format 3 adds table `rollups` and
+* `lookups` (ADR 0044).
+*/
+const DESIGN_FORMAT = 3;
+const FORMAT_1_TABLE_KEYS = [
+	"id",
+	"unique",
+	"indexes",
+	"comment"
+];
+const FORMAT_1_COLUMN_KEYS = [
+	"format",
+	"options",
+	"min",
+	"max",
+	"comment",
+	"identity"
+];
+/** The lowest design format that reads `design`. */
+function designFormat(design) {
+	const tables = Object.values(design.appTables ?? {});
+	if (tables.some((table) => table.rollups !== void 0 || table.lookups !== void 0)) return 3;
+	if (tables.some((table) => table.subject !== void 0)) return 2;
+	return tables.some((table) => FORMAT_1_TABLE_KEYS.some((key) => table[key] !== void 0) || Object.values(table.columns ?? {}).some((column) => FORMAT_1_COLUMN_KEYS.some((key) => column[key] !== void 0))) ? 1 : 0;
+}
+/** The longest design code, so a `/create` URL stays under common limits. */
+const MAX_DESIGN_CODE_LENGTH = 6e3;
+/**
+* What `encodeDesign` throws when a valid design is too long for a URL, so
+* a caller can offer the config download instead of a fix.
+*/
+var DesignTooLongError = class extends TypeError {
+	/** The length the code would have. */
+	length;
+	constructor(length) {
+		super(`design: the code is ${String(length)} characters; the most a URL carries is ${String(MAX_DESIGN_CODE_LENGTH)}. Download the config instead, save it as better-supabase.config.ts, then run \`better-supabase init\` and \`better-supabase sql sync\`.`);
+		this.name = "DesignTooLongError";
+		this.length = length;
+	}
+};
+/** The most bytes a design code inflates to; a longer one is rejected. */
+const MAX_DESIGN_BYTES = 262144;
+const MAX_TABLES = 100;
+const MAX_EXTRA_COLUMNS = 64;
+const MAX_POSITIONS = 1e3;
+const MAX_COORDINATE = 1e6;
+const DESIGN_CODE = /^0[A-Za-z0-9_-]+$/;
+const COLUMN = /^[a-z_][a-z0-9_]{0,62}$/;
+const SQL_TYPE = /^[a-z][a-z0-9_ (),.'[\]-]*$/i;
+const QUALIFIED = /^[a-z_][a-z0-9_]{0,62}\.[a-z_][a-z0-9_]{0,62}$/;
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** Whether `value` has the shape of a design code. It may still fail to decode. */
+function isDesignCode(value) {
+	return value.length <= 6e3 && DESIGN_CODE.test(value);
+}
+function extraColumnsOf(value, catalog) {
+	if (!isRecord(value)) throw new TypeError("design.extraColumns must be an object");
+	return Object.fromEntries(Object.entries(value).map(([module, columns]) => {
+		const at = `design.extraColumns.${module}`;
+		const block = catalog.blocks.find((each) => each.name === module);
+		if (block === void 0) throw new TypeError(`${at}: "${module}" is not a block`);
+		if (block.extraColumns === void 0) throw new TypeError(`${at}: the ${module} block takes no extra columns`);
+		if (!isRecord(columns)) throw new TypeError(`${at} must be an object of column name to SQL type`);
+		const entries = Object.entries(columns);
+		if (entries.length > MAX_EXTRA_COLUMNS) throw new TypeError(`${at} has ${String(entries.length)} columns; the most is ${String(MAX_EXTRA_COLUMNS)}`);
+		const checked = {};
+		for (const [name, type] of entries) {
+			if (!COLUMN.test(name)) throw new TypeError(`${at}: "${name}" is not a valid column name`);
+			if (typeof type !== "string" || !SQL_TYPE.test(type) || type.includes("--")) throw new TypeError(`${at}.${name} must be a SQL type such as "text not null default ''"`);
+			checked[name] = type;
+		}
+		return [module, checked];
+	}));
+}
+function coordinate(value) {
+	return typeof value === "number" && Number.isFinite(value) && Math.abs(value) <= MAX_COORDINATE;
+}
+function pairOf(value) {
+	if (!Array.isArray(value) || value.length !== 2) return;
+	const x = value[0];
+	const y = value[1];
+	return coordinate(x) && coordinate(y) ? [x, y] : void 0;
+}
+function positionsOf(value) {
+	if (!isRecord(value)) throw new TypeError("design.positions must be an object");
+	const entries = Object.entries(value);
+	if (entries.length > MAX_POSITIONS) throw new TypeError(`design.positions has ${String(entries.length)} entries; the most is ${String(MAX_POSITIONS)}`);
+	return Object.fromEntries(entries.map(([table, position]) => {
+		if (!QUALIFIED.test(table)) throw new TypeError(`design.positions: "${table}" is not a schema.table name`);
+		const pair = pairOf(position);
+		if (pair === void 0) throw new TypeError(`design.positions.${table} must be [x, y], two finite numbers`);
+		return [table, pair];
+	}));
+}
+/**
+* Checks a design and drops its empty parts. Throws a TypeError naming the
+* first problem.
+*/
+function designOfValue(value, catalog = PRESET_CATALOG) {
+	if (!isRecord(value)) throw new TypeError("design must be an object");
+	const unknownKey = Object.keys(value).find((name) => name !== "appTables" && name !== "extraColumns" && name !== "positions" && name !== "version");
+	if (unknownKey !== void 0) throw new TypeError(`design: unknown key "${unknownKey}"; a design has appTables, extraColumns and positions`);
+	const version = value["version"] ?? 0;
+	if (typeof version !== "number" || !Number.isSafeInteger(version) || version < 0) throw new TypeError("design.version must be a whole number");
+	if (version > 3) throw new TypeError(`design: the code needs format ${String(version)}, and this better-supabase reads up to ${String(3)}; update better-supabase`);
+	const appTables = value["appTables"] === void 0 ? {} : appTablesOf(value["appTables"]);
+	if (Object.keys(appTables).length > MAX_TABLES) throw new TypeError(`design.appTables has ${String(Object.keys(appTables).length)} tables; the most is ${String(MAX_TABLES)}`);
+	const extraColumns = value["extraColumns"] === void 0 ? {} : extraColumnsOf(value["extraColumns"], catalog) ?? {};
+	const positions = value["positions"] === void 0 ? {} : positionsOf(value["positions"]) ?? {};
+	const filled = Object.fromEntries(Object.entries(extraColumns).filter(([, columns]) => Object.keys(columns).length > 0));
+	return {
+		...Object.keys(appTables).length === 0 ? {} : { appTables },
+		...Object.keys(filled).length === 0 ? {} : { extraColumns: filled },
+		...Object.keys(positions).length === 0 ? {} : { positions }
+	};
+}
+async function pipe(bytes, transform, limit) {
+	const reader = new Blob([bytes]).stream().pipeThrough(transform).getReader();
+	const chunks = [];
+	let length = 0;
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		length += value.byteLength;
+		if (length > limit) {
+			await reader.cancel();
+			throw new TypeError(`design: the code inflates past ${String(limit)} bytes`);
+		}
+		chunks.push(value);
+	}
+	const out = new Uint8Array(length);
+	let offset = 0;
+	for (const chunk of chunks) {
+		out.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return out;
+}
+function toBase64Url(bytes) {
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCodePoint(byte);
+	return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+function fromBase64Url(text) {
+	const binary = atob(text.replaceAll("-", "+").replaceAll("_", "/"));
+	return Uint8Array.from(binary, (char) => char.codePointAt(0) ?? 0);
+}
+/**
+* The design as a code for the `&design=` parameter: `0`, then its JSON
+* (with `version` set to `designFormat` when it is above 0) compressed with
+* deflate-raw, in base64url. An empty design is `""`.
+* Throws a TypeError when the design is invalid, and a `DesignTooLongError`
+* when the code would be longer than `MAX_DESIGN_CODE_LENGTH`.
+*/
+async function encodeDesign(design) {
+	const checked = designOfValue(design);
+	if (Object.keys(checked).length === 0) return "";
+	const format = designFormat(checked);
+	const json = new TextEncoder().encode(JSON.stringify(format === 0 ? checked : {
+		version: format,
+		...checked
+	}));
+	const code = `${DESIGN_VERSION}${toBase64Url(await pipe(json, new CompressionStream("deflate-raw"), MAX_DESIGN_BYTES))}`;
+	if (code.length > 6e3) throw new DesignTooLongError(code.length);
+	return code;
+}
+/** Reads a design code. Throws a TypeError when it isn't a valid one. */
+async function decodeDesign(code) {
+	if (code === "") return {};
+	if (!isDesignCode(code)) throw new TypeError(code.length > 6e3 ? `design: the code is longer than ${String(MAX_DESIGN_CODE_LENGTH)} characters` : `design: "${code.slice(0, 40)}" is not a design code`);
+	let json;
+	try {
+		const bytes = await pipe(fromBase64Url(code.slice(1)), new DecompressionStream("deflate-raw"), MAX_DESIGN_BYTES);
+		json = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+	} catch (error) {
+		if (error instanceof TypeError && error.message.startsWith("design:")) throw error;
+		throw new TypeError("design: the code is damaged; copy it again from /create", { cause: error });
+	}
+	return designOfValue(json);
+}
+/**
+* The design in a `/create` URL's `&design=` parameter, or in a bare design
+* code; `undefined` when `input` has neither.
+*/
+async function designOf(input) {
+	const parameter = /[?&]design=([^&#]*)/.exec(input)?.[1];
+	if (parameter !== void 0) return decodeDesign(decodeURIComponent(parameter));
+	return isDesignCode(input) ? decodeDesign(input) : void 0;
+}
+/**
+* The config keys a preset with a design sets: `presetConfig`, with each
+* block's `options.extraColumns` and `appTables`. Throws a TypeError when the
+* design adds columns to a block the preset doesn't install.
+*/
+function designConfig(resolved, design) {
+	const base = presetConfig(resolved);
+	const blocks = { ...base.blocks };
+	for (const [module, columns] of Object.entries(design.extraColumns ?? {})) {
+		const entry = blocks[module];
+		if (entry === void 0) throw new TypeError(`design.extraColumns.${module}: the preset doesn't install the ${module} block`);
+		blocks[module] = {
+			...entry,
+			options: {
+				...entry.options,
+				extraColumns: columns
+			}
+		};
+	}
+	const appTables = design.appTables === void 0 ? {} : appTablesOf(design.appTables, resolved.preset.tenantName);
+	return {
+		...base,
+		blocks,
+		...Object.keys(appTables).length === 0 ? {} : { appTables }
+	};
+}
+/**
+* `better-supabase.config.ts` for a preset with a design. `designCode`, the
+* design's `encodeDesign`, goes into the `/create` URL in the comment, so the
+* canvas reopens with its positions.
+*/
+function designConfigSource(resolved, design, designCode = "") {
+	return configSource(resolved, designConfig(resolved, design), createUrl(resolved, designCode));
+}
+/**
+* The command that starts a project from the preset and design: `init` with
+* the quoted `/create` URL, or `presetInstallCommand` when `designCode` is
+* empty.
+*/
+function designInstallCommand(resolved, designCode) {
+	return designCode === "" ? presetInstallCommand(resolved) : `npx better-supabase init --preset "${createUrl(resolved, designCode)}"`;
+}
+/** The command that applies the preset and design to an existing project. */
+function designApplyCommand(resolved, designCode) {
+	return designCode === "" ? presetApplyCommand(resolved) : `npx better-supabase apply --preset "${createUrl(resolved, designCode)}"`;
+}
+//#endregion
+//#region src/preset/design-diff.ts
+/** `value` as JSON with sorted keys, so two configs compare by content. */
+function canonical(value) {
+	if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+	if (value !== null && typeof value === "object") return `{${Object.entries(value).filter(([, each]) => each !== void 0).toSorted(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, each]) => `${JSON.stringify(key)}:${canonical(each)}`).join(",")}}`;
+	return JSON.stringify(value);
+}
+const same = (a, b) => canonical(a) === canonical(b);
+const isRequired = (column) => column.nullable === false;
+const lacksDefault = (column) => column.default === void 0 && column.identity !== true;
+const safe = (kind, table, summary, column) => ({
+	kind,
+	table,
+	...column === void 0 ? {} : { column },
+	breaking: false,
+	summary,
+	steps: []
+});
+const columnsOf = (table) => table.columns ?? {};
+/**
+* Pairs each name only in `before` with a name only in `after` whose value
+* is the same: a rename, as far as a config can tell.
+*/
+function renames(before, after) {
+	const added = Object.keys(after).filter((name) => !(name in before));
+	const paired = /* @__PURE__ */ new Map();
+	for (const [name, value] of Object.entries(before)) {
+		if (name in after) continue;
+		const match = added.find((candidate) => ![...paired.values()].includes(candidate) && same(value, after[candidate]));
+		if (match !== void 0) paired.set(name, match);
+	}
+	return paired;
+}
+function columnChanges(table, before, after) {
+	const old = columnsOf(before);
+	const next = columnsOf(after);
+	const renamed = renames(old, next);
+	const renamedTo = new Set(renamed.values());
+	const changes = [];
+	for (const [name, column] of Object.entries(old)) {
+		const to = renamed.get(name);
+		const now = next[name];
+		if (to !== void 0) changes.push({
+			kind: "column.renamed",
+			table,
+			column: to,
+			from: name,
+			breaking: true,
+			summary: `Renames ${table}.${name} to ${to}.`,
+			steps: [
+				`Add ${to} as a nullable column and copy ${name} into it in a migration.`,
+				`Write both columns and move reads to ${to}, then deploy.`,
+				`Drop ${name} in a later migration${isRequired(column) ? `, then make ${to} required` : ""}.`
+			]
+		});
+		else if (now === void 0) changes.push({
+			kind: "column.dropped",
+			table,
+			column: name,
+			breaking: true,
+			summary: `Drops ${table}.${name} and its values.`,
+			steps: [
+				`Stop reading and writing ${table}.${name} in the app, then deploy.`,
+				`Export the values first if you need them.`,
+				`Remove the column and generate the migration that drops it.`
+			]
+		});
+		else if (now.type !== column.type) changes.push({
+			kind: "column.type",
+			table,
+			column: name,
+			from: column.type,
+			to: now.type,
+			breaking: true,
+			summary: `Changes ${table}.${name} from ${column.type} to ${now.type}.`,
+			steps: [
+				`Add a ${now.type} column next to ${name}.`,
+				`Fill it from ${name} with a cast in a migration, and write both columns.`,
+				`Move reads to the new column, drop ${name} in a later migration and rename the new one if you need the name.`
+			]
+		});
+		else if (!isRequired(column) && isRequired(now) && lacksDefault(now)) changes.push({
+			kind: "column.required",
+			table,
+			column: name,
+			breaking: true,
+			summary: `Makes ${table}.${name} required without a default.`,
+			steps: [
+				`Fill ${table}.${name} in every row where it is null, in a migration.`,
+				`Make the app always write it, or give it a default, then deploy.`,
+				`Make the column required.`
+			]
+		});
+		else if (!same(column, now)) changes.push(safe("column.changed", table, `Changes ${table}.${name}.`, name));
+	}
+	for (const [name, column] of Object.entries(next)) {
+		if (name in old || renamedTo.has(name)) continue;
+		changes.push(isRequired(column) && lacksDefault(column) ? {
+			kind: "column.added",
+			table,
+			column: name,
+			breaking: true,
+			summary: `Adds ${table}.${name} as required without a default, which rows already in the table don't have.`,
+			steps: [
+				`Add ${name} as a nullable column.`,
+				`Fill it in every existing row, and make the app always write it, then deploy.`,
+				`Make the column required.`
+			]
+		} : safe("column.added", table, `Adds ${table}.${name}.`, name));
+	}
+	return changes;
+}
+/**
+* What changes from `before` to `after`: each added, dropped, renamed or
+* changed table and column, with the breaking ones marked and their
+* expand-and-contract steps. A rename is a dropped name and an added one
+* with the same definition.
+*/
+function diffAppTables(before, after, options = {}) {
+	const old = options.keepMissing === true ? Object.fromEntries(Object.entries(before).filter(([name]) => name in after)) : before;
+	const renamed = renames(old, after);
+	const renamedTo = new Set(renamed.values());
+	const changes = [];
+	for (const [name, table] of Object.entries(old)) {
+		const to = renamed.get(name);
+		const now = after[name];
+		if (to !== void 0) changes.push({
+			kind: "table.renamed",
+			table: to,
+			from: name,
+			breaking: true,
+			summary: `Renames table ${name} to ${to}.`,
+			steps: [
+				`Add ${to} next to ${name} and copy the rows in a migration.`,
+				`Write to both tables and move reads to ${to}, then deploy.`,
+				`Stop using ${name}, then drop it in a later migration.`
+			]
+		});
+		else if (now === void 0) changes.push({
+			kind: "table.dropped",
+			table: name,
+			breaking: true,
+			summary: `Drops table ${name} and its rows.`,
+			steps: [
+				`Stop reading and writing ${name} in the app, then deploy.`,
+				`Export the rows first if you need them.`,
+				`Remove the table and generate the migration that drops it.`
+			]
+		});
+		else {
+			const from = table.id ?? "uuid";
+			const toId = now.id ?? "uuid";
+			if (from !== toId) changes.push({
+				kind: "table.id",
+				table: name,
+				from,
+				to: toId,
+				breaking: true,
+				summary: `Changes the id of ${name} from ${from} to ${toId}.`,
+				steps: [
+					`Add a table with the ${toId} id and copy the rows, keeping a map from old ids to new ones.`,
+					`Point the columns that reference ${name} at the new ids, then move the app to the new table.`,
+					`Drop the old table in a later migration.`
+				]
+			});
+			changes.push(...columnChanges(name, table, now));
+			const rest = (config) => ({
+				...config,
+				columns: void 0,
+				id: void 0,
+				rollups: void 0,
+				lookups: void 0
+			});
+			if (!same(rest(table), rest(now))) changes.push(safe("table.changed", name, `Changes table ${name}.`));
+			const computed = (config) => ({
+				rollups: config.rollups,
+				lookups: config.lookups
+			});
+			if (!same(computed(table), computed(now))) changes.push(safe("table.computed", name, `Changes the rollups and lookups of ${name}, read through ${name}_view.`));
+		}
+	}
+	for (const name of Object.keys(after)) if (!(name in old) && !renamedTo.has(name)) changes.push(safe("table.added", name, `Adds table ${name}.`));
+	return changes;
+}
+/** `diffAppTables` over the app tables of two `/create` designs. */
+function diffDesigns(before, after) {
+	return diffAppTables(before.appTables ?? {}, after.appTables ?? {});
+}
+//#endregion
+export { APP_COLUMN_FORMATS, DEFAULT_CONVENTIONS, DESIGN_FORMAT, DesignTooLongError, MAX_DESIGN_CODE_LENGTH, PRESETS, PRESET_BLOCKS, PRESET_CATALOG, PRESET_FIELDS, PRESET_FRAMEWORKS, PRESET_GROUPS, PRESET_NAMES, PRESET_TENANT_NAMES, PRESET_VERSION, PROVIDER_COMMENT, appReservedColumns, conventionConfig, decodeDesign, decodePreset, designApplyCommand, designConfig, designConfigSource, designFormat, designInstallCommand, designOf, diffAppTables, diffDesigns, encodeDesign, encodePreset, expandPreset, glueCommand, integrationsForFramework, isAppDefault, isDesignCode, isPresetCode, isPresetName, listNames, namedPreset, presetApplyCommand, presetBlockConflict, presetBlocksSource, presetConfig, presetConfigSource, presetField, presetGlue, presetInstallCommand, presetOf, presetValueLabel, resolvePreset, withPresetField };

package/dist/problem-CEjyhV5T.d.ts

@@ -0,0 +1,76 @@
+import { E as ValidationIssue, b as DbError, x as DbErrorKind } from "./result-Cj3yWhjH.js";
+//#region src/core/problem.d.ts
+/** RFC 9457 Problem Details, with the `DbError` fields as extension members. */
+interface ProblemDetails {
+  readonly type: string;
+  readonly title: string;
+  readonly status: number;
+  readonly detail?: string;
+  readonly instance?: string;
+  /** The `DbError` kind. */
+  readonly kind: DbErrorKind;
+  readonly code?: string;
+  readonly hint?: string;
+  readonly constraint?: string;
+  readonly columns?: readonly string[];
+  readonly column?: string;
+  readonly issues?: readonly ValidationIssue[];
+  /** The assurance level a `forbidden` answer needs (`aal2`). */
+  readonly required?: "aal1" | "aal2";
+  /** The OAuth scopes a `forbidden` answer needs. */
+  readonly scopes?: readonly string[];
+  /** The permission key an authorizer denied. */
+  readonly permission?: string;
+  /** The permission keys a `forbidden` caller lacks. */
+  readonly permissions?: readonly string[];
+  /** The pending approval of an `APPROVAL_REQUIRED` answer. */
+  readonly approval?: {
+    readonly id: string;
+  };
+  /** Seconds until a `rate_limited` or `quota_exceeded` caller may retry. */
+  readonly retryAfter?: number;
+  /** The meter a `quota_exceeded` answer ran out of, and its limit. */
+  readonly meter?: string;
+  readonly limit?: number;
+  /** The row limit a `max_affected` write exceeded. */
+  readonly maxAffected?: number;
+}
+/** The `type` prefix of kinds that mean more than their HTTP status. */
+declare const PROBLEM_TYPE_BASE = "https://bettersupabase.com/problems/";
+declare const PROBLEM_CONTENT_TYPE = "application/problem+json";
+interface ProblemOptions {
+  /** URI reference for this occurrence, e.g. the request path. */
+  readonly instance?: string;
+  /** Include messages of internal errors. Defaults to false. */
+  readonly expose?: boolean;
+}
+/**
+ * Rewrites the Problem Details a block answers with into the app's own error
+ * body, such as its `type` URIs and error codes. The status, `Retry-After`
+ * and `WWW-Authenticate` headers stay as they are.
+ */
+type ProblemFormat = (problem: ProblemDetails, error: DbError) => Readonly<Record<string, unknown>>;
+/** The `problem` option of the blocks that answer HTTP requests. */
+interface BlockProblemOptions {
+  /** The app's error body for the block's error responses. Defaults to RFC 9457 Problem Details. */
+  readonly problem?: ProblemFormat;
+}
+interface ProblemResponseOptions extends ProblemOptions {
+  readonly headers?: ConstructorParameters<typeof Headers>[0];
+  /** `realm` of the RFC 6750 challenge on 401. */
+  readonly realm?: string;
+  /** Rewrites the body; see `ProblemFormat`. */
+  readonly format?: ProblemFormat | undefined;
+}
+/** Converts a `DbError` to Problem Details. */
+declare function toProblem(error: DbError, options?: ProblemOptions): ProblemDetails;
+/**
+ * An `application/problem+json` response. A 401, and a 403 for a missing
+ * OAuth scope, carry an RFC 6750 `WWW-Authenticate: Bearer` challenge.
+ */
+declare function problemResponse(error: DbError, options?: ProblemResponseOptions): Response;
+declare function isProblem(value: unknown): value is ProblemDetails;
+/** Turns a Problem Details body back into a `DbError` (client side). */
+declare function fromProblem(problem: ProblemDetails): DbError;
+//#endregion
+export { ProblemFormat as a, fromProblem as c, toProblem as d, ProblemDetails as i, isProblem as l, PROBLEM_CONTENT_TYPE as n, ProblemOptions as o, PROBLEM_TYPE_BASE as r, ProblemResponseOptions as s, BlockProblemOptions as t, problemResponse as u };