better-supabase 0.9.0 → 0.10.0

package/dist/preset-BBrL6_Ln.js

@@ -0,0 +1,648 @@
+import { c as PRESET_CATALOG, h as encodePreset, r as presetConfig } from "./config-C4RQDF6t.js";
+import { r as FIELD_FORMATS } from "./field-formats-Cif5gr7c.js";
+import { f as appTablesOf } from "./app-tables-BRjMcWhW.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). Format 4 adds table `events` (ADR 0048) and
+* subject `versions`. Format 5 adds column `access` (ADR 0051).
+*/
+const DESIGN_FORMAT = 5;
+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) => Object.values(table.columns ?? {}).some((column) => column.access !== void 0))) return 5;
+	if (tables.some((table) => table.events !== void 0 || table.subject?.versions !== void 0)) return 4;
+	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 > 5) throw new TypeError(`design: the code needs format ${String(version)}, and this better-supabase reads up to ${String(5)}; 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 breakingChange = (kind, table, summary, steps, column) => ({
+	kind,
+	table,
+	...column === void 0 ? {} : { column },
+	breaking: true,
+	summary,
+	steps
+});
+/** The steps that make a new check or constraint safe on rows that may not pass it. */
+const checkSteps = (target, rule) => [
+	`Find the rows where ${target} doesn't ${rule}, and fix them in a migration.`,
+	`Make the app write only values that ${rule}, then deploy.`,
+	`Add the constraint.`
+];
+const targetOf = (reference) => reference === void 0 ? "" : "block" in reference ? `${reference.block}.${reference.table}` : reference.table;
+/** How closed a column's access is: none, then `read`, then `server`. */
+const ACCESS_RANK = {
+	read: 1,
+	server: 2
+};
+const accessRank = (column) => column.access === void 0 ? 0 : ACCESS_RANK[column.access];
+/**
+* The changes to one column whose name and type stay: each new or tighter
+* constraint is breaking, because rows already in the table may not pass
+* it; anything else (a comment, a default, `onDelete`, a looser rule) is safe.
+*/
+function constraintChanges(table, name, before, after) {
+	const at = `${table}.${name}`;
+	const changes = [];
+	if (before.unique !== true && after.unique === true) changes.push(breakingChange("column.unique", table, `Makes ${at} unique, which fails while two rows share a value.`, checkSteps(at, "repeat a value"), name));
+	const removed = after.options === void 0 ? [] : before.options === void 0 ? after.options : before.options.filter((option) => !after.options?.includes(option));
+	if (after.options !== void 0 && removed.length > 0) changes.push(breakingChange("column.options", table, before.options === void 0 ? `Limits ${at} to ${after.options.join(", ")}.` : `Removes ${removed.join(", ")} from the options of ${at}.`, checkSteps(at, `hold one of ${after.options.join(", ")}`), name));
+	const raised = after.min !== void 0 && (before.min === void 0 || after.min > before.min);
+	const lowered = after.max !== void 0 && (before.max === void 0 || after.max < before.max);
+	if (raised || lowered) changes.push(breakingChange("column.bounds", table, `Narrows the bounds of ${at}${after.min === void 0 ? "" : ` to at least ${String(after.min)}`}${after.max === void 0 ? "" : `${after.min === void 0 ? " to" : " and"} at most ${String(after.max)}`}.`, checkSteps(at, "fit the new bounds"), name));
+	const checks = (format) => {
+		const rule = format === void 0 ? void 0 : FIELD_FORMATS[format];
+		return rule?.pattern !== void 0 || rule?.bounds !== void 0;
+	};
+	if (after.format !== void 0 && after.format !== before.format && checks(after.format)) changes.push(breakingChange("column.format", table, `Checks ${at} as ${after.format}.`, checkSteps(at, `hold a valid ${after.format}`), name));
+	if (after.references !== void 0 && targetOf(before.references) !== targetOf(after.references)) changes.push(breakingChange("column.reference", table, `Points ${at} at ${targetOf(after.references)}, which fails for values that row doesn't have.`, checkSteps(at, `match a row of ${targetOf(after.references)}`), name));
+	if (accessRank(after) > accessRank(before)) changes.push(breakingChange("column.access", table, after.access === "server" ? `Hides ${at} from signed-in users, so client reads and writes of it fail.` : `Makes ${at} read-only for signed-in users, so client writes of it fail.`, [`Move every client ${after.access === "server" ? "read and write" : "write"} of ${at} to server code that uses the service role, then deploy.`, `Change the access of ${at}.`], name));
+	if (changes.length === 0 && !same(before, after)) changes.push(safe("column.changed", table, `Changes ${at}.`, name));
+	return changes;
+}
+/**
+* The changes to a table's own keys: a new scope, unique set, or a removed
+* `timestamps`, `rank` or `softDelete` breaks what exists; the rest (indexes,
+* the comment, other subject keys) is safe.
+*/
+function tableChanges(name, before, after) {
+	const changes = [];
+	if ((before.scope ?? "inherit") !== (after.scope ?? "inherit")) changes.push(breakingChange("table.scope", name, `Changes the scope of ${name} from ${before.scope ?? "inherit"} to ${after.scope ?? "inherit"}, which changes its scope column and policies.`, [
+		`Add the new scope column as nullable and fill it for every row in a migration.`,
+		`Move the app to the new scope, then deploy.`,
+		`Change the scope and drop the old column in a later migration.`
+	]));
+	const sets = (table) => new Set((table.unique ?? []).map((set) => set.join(",")));
+	const oldSets = sets(before);
+	const added = [...sets(after)].filter((set) => !oldSets.has(set));
+	if (added.length > 0) changes.push(breakingChange("table.unique", name, `Adds unique (${added.join("), (")}) to ${name}, which fails while two rows share those values.`, checkSteps(`(${added.join("), (")})`, "repeat across rows")));
+	const dropped = [
+		before.timestamps !== false && after.timestamps === false ? "timestamps" : void 0,
+		before.subject?.rank !== void 0 && after.subject?.rank === void 0 ? "rank" : void 0,
+		before.subject?.softDelete === true && after.subject?.softDelete !== true ? "softDelete" : void 0
+	].filter((each) => each !== void 0);
+	if (dropped.length > 0) changes.push(breakingChange("table.columns", name, `Removes ${dropped.join(", ")} from ${name}, which drops the columns ${dropped.length === 1 ? "it adds" : "they add"} and their values.`, [
+		`Stop reading ${dropped.join(", ")} in the app, then deploy.`,
+		`Export the values first if you need them.`,
+		`Remove the key and generate the migration that drops the columns.`
+	]));
+	const rest = (config) => ({
+		...config,
+		columns: void 0,
+		id: void 0,
+		rollups: void 0,
+		lookups: void 0,
+		events: void 0,
+		subject: config.subject === void 0 ? void 0 : {
+			...config.subject,
+			versions: void 0
+		}
+	});
+	if (!same(before.events, after.events)) changes.push(safe("table.events", name, `Changes the outbox events ${name} emits, which replaces its events trigger.`));
+	if (!same(before.subject?.versions, after.subject?.versions)) changes.push(safe("table.versions", name, `Changes the versions ${name} keeps, which replaces its snapshot trigger; existing versions stay.`));
+	if (changes.every((change) => change.kind === "table.events" || change.kind === "table.versions") && !same(rest(before), rest(after))) changes.push(safe("table.changed", name, `Changes table ${name}.`));
+	return changes;
+}
+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 changes.push(...constraintChanges(table, name, column, now));
+	}
+	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(...tableChanges(name, table, now), ...columnChanges(name, table, now));
+			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 { presetApplyCommand as _, MAX_DESIGN_CODE_LENGTH as a, presetGlue as b, designConfig as c, designInstallCommand as d, designOf as f, glueCommand as g, PROVIDER_COMMENT as h, DesignTooLongError as i, designConfigSource as l, isDesignCode as m, diffDesigns as n, decodeDesign as o, encodeDesign as p, DESIGN_FORMAT as r, designApplyCommand as s, diffAppTables as t, designFormat as u, presetBlocksSource as v, presetInstallCommand as x, presetConfigSource as y };

package/dist/{provider-9gBq9W6k.d.ts → provider-CQ1SrhLa.d.ts}

@@ -1,6 +1,6 @@
 /// <reference lib="esnext.temporal" />
 import { b as DbError, t as AsyncResult } from "./result-Cj3yWhjH.js";
-import { r as AuthState } from "./resolve-w9EpHzuM.js";
+import { r as AuthState } from "./resolve-7atr-wWr.js";
 //#region src/credentials/provider.d.ts
 /**
  * Names a credential without holding it. Tables store this as a

package/dist/{push-token-asrmi7-6.d.ts → push-token-CDMgWT13.d.ts}

@@ -1,4 +1,4 @@
-import { s as PushTokenPort } from "./ports-DAdQyjZz.js";
+import { s as PushTokenPort } from "./ports-Dcnuo3HT.js";
 //#region src/client/native/push-token.d.ts
 /** The part of `expo-notifications` the push token port uses. */
 interface ExpoNotificationsLike {

package/dist/query/index.d.ts

@@ -1,4 +1,4 @@
 import { t as escapeLike } from "../escape-like-AUEPn-C5.js";
 import { n as invalidateTables, t as BetterQueryMeta } from "../invalidate-BBqhpxyB.js";
-import { _ as invalidateOnMutation, a as UserChangeSource, c as InfiniteExtras, d as QueriesOptions, f as QueryHelpers, g as createQueries, h as TableQueries, i as optimistic, l as InfiniteOptionsOf, m as QueryOptionsOf, n as OptimisticSnapshot, o as clearOnUserChange, p as QueryKeyOf, r as OptimisticTarget, s as BetterQueries, t as OptimisticHandlers, u as MutationOptionsOf, v as queryCache } from "../index-DygICr8c.js";
+import { _ as invalidateOnMutation, a as UserChangeSource, c as InfiniteExtras, d as QueriesOptions, f as QueryHelpers, g as createQueries, h as TableQueries, i as optimistic, l as InfiniteOptionsOf, m as QueryOptionsOf, n as OptimisticSnapshot, o as clearOnUserChange, p as QueryKeyOf, r as OptimisticTarget, s as BetterQueries, t as OptimisticHandlers, u as MutationOptionsOf, v as queryCache } from "../index-Cckxs8IE.js";
 export { type BetterQueries, type BetterQueryMeta, type InfiniteExtras, type InfiniteOptionsOf, type MutationOptionsOf, type OptimisticHandlers, type OptimisticSnapshot, type OptimisticTarget, type QueriesOptions, type QueryHelpers, type QueryKeyOf, type QueryOptionsOf, type TableQueries, type UserChangeSource, clearOnUserChange, createQueries, escapeLike, invalidateOnMutation, invalidateTables, optimistic, queryCache };