better-supabase 0.13.0 → 0.15.0

package/dist/cli/add-DPfdDRq7.js

@@ -1,75 +0,0 @@
-import { n as CliError } from "./errors-BTe6A15O.js";
-import { D as providerLabel, _ as providerOwnsMemberships, g as layoutFor, m as MEMBERSHIP_CLAIM_MODULES } from "./module-migration-CbX-jRhV.js";
-import { n as applyPlan } from "./files-C5JfVnj5.js";
-import { n as addBlocksToJson, s as keyText, t as addBlocksToConfig } from "./config-edit-D46H0UHp.js";
-import { a as write, i as unlistedModuleFiles, n as nextStep } from "./write-DZKk5rSF.js";
-import { basename, dirname } from "node:path";
-import { readFile } from "node:fs/promises";
-import { SQL_MODULES, resolveModules } from "better-supabase/sql";
-//#region src/cli/sql/add.ts
-async function addModules(config, args, names, deps) {
-	if (names.length === 0) throw new CliError("input_required", "Name at least one module.", {
-		missing: ["<module>"],
-		choices: { "<module>": Object.keys(SQL_MODULES) }
-	});
-	const unknown = names.filter((name) => !(name in SQL_MODULES));
-	if (unknown.length > 0) throw new CliError("usage", `Unknown module ${unknown.join(", ")}. Available: ${Object.keys(SQL_MODULES).join(", ")}`);
-	const owner = config.authorization && providerOwnsMemberships(config) ? providerLabel(config.authorization) : void 0;
-	const hookModules = names.filter((name) => MEMBERSHIP_CLAIM_MODULES.has(name));
-	if (owner && hookModules.length > 0 && args["allow-hook-overlap"] !== true) return {
-		code: 1,
-		error: [
-			`The access token hook of ${owner} writes the memberships claim.`,
-			`${hookModules.join(" and ")} would add a second source for it. Use the provider's hook instead,`,
-			"or pass --allow-hook-overlap to write the modules anyway."
-		].join("\n")
-	};
-	const listed = [...config.blockNames, ...names.filter((name) => !config.blockNames.includes(name))];
-	const sqlLayout = await layoutFor(config, args, listed);
-	const added = resolveModules(names, sqlLayout).map((module) => module.name);
-	const lines = await write(config, args, listed, sqlLayout, deps.now, added);
-	const pulledIn = resolveModules(names, sqlLayout).map((module) => module.name).filter((name) => MEMBERSHIP_CLAIM_MODULES.has(name) && !names.includes(name));
-	if (owner && pulledIn.length > 0) lines.push("", `${pulledIn.join(" and ")} came along as a dependency: its memberships table backs has_organization_role() and has_entitlement().`, `The hook of ${owner} still writes the memberships claim, so don't call better_supabase.membership_claims from a hook.`, "Make better_supabase.memberships one of the provider's membership sources if both should agree.");
-	const untracked = resolveModules(names, sqlLayout).map((module) => module.name).filter((name) => !config.blockNames.includes(name));
-	if (untracked.length > 0) lines.push("", ...await listInConfig(args, untracked, deps));
-	if (args["dry-run"] !== true) lines.push(...await unlistedModuleFiles(config, names, sqlLayout));
-	return {
-		code: 0,
-		output: lines.join("\n"),
-		data: {
-			added,
-			pulledIn,
-			untracked
-		},
-		next: [await nextStep(config)]
-	};
-}
-/**
-* Lists `untracked` in `blocks` of the config file, so `sql sync --check` keeps
-* them current, or prints the snippet when the file isn't a literal object the
-* edit can follow.
-*/
-async function listInConfig(args, untracked, deps) {
-	const file = deps.configFile;
-	if (file === void 0) return ["Add them to blocks in better-supabase.config.ts so `sql sync --check` keeps them current:", ...untracked.map((name) => `  ${keyText(name)}: {},`)];
-	const source = await readFile(file, "utf-8");
-	const edit = file.endsWith(".json") ? addBlocksToJson(source, untracked) : addBlocksToConfig(source, untracked);
-	if (!edit.ok) return [
-		`${basename(file)} wasn't changed: ${edit.reason}.`,
-		"Add them to blocks so `sql sync --check` keeps them current:",
-		...untracked.map((name) => `  ${keyText(name)}: {},`)
-	];
-	await applyPlan({
-		root: dirname(file),
-		regenerate: "better-supabase sql add",
-		files: [{
-			path: file,
-			contents: edit.text,
-			policy: "edit"
-		}]
-	}, { "dry-run": args["dry-run"] });
-	if (args["dry-run"] === true) return [`Would add ${untracked.join(", ")} to blocks in ${basename(file)}.`];
-	return [`Added ${untracked.join(", ")} to blocks in ${basename(file)}.`];
-}
-//#endregion
-export { addModules as t };

package/dist/cli/adopt-B28iUeGg.js

@@ -1 +0,0 @@
-export { t as adoptCommand } from "./adopt-C0VugVMu.js";

package/dist/cli/adopt-C0VugVMu.js

@@ -1,421 +0,0 @@
-import { a as list, p as commandMeta, r as defineCliCommand } from "./command-33pu13LT.js";
-import { i as plain } from "./style-Bm2X5JrN.js";
-import { n as CliError } from "./errors-BTe6A15O.js";
-import { t as display } from "./io-DH1kcmmP.js";
-import { t as toCatalog } from "./catalog-DwTUdJaQ.js";
-import { t as loadSnapshot } from "./snapshot-GfdB9Cjl.js";
-import { n as applyPlan, s as planResult } from "./files-C5JfVnj5.js";
-import { d as setBlockInJson, f as setPathInConfig, p as setPathInJson, u as setBlockInConfig } from "./config-edit-D46H0UHp.js";
-import { t as blockNames } from "./blocks-D3tsq-mR.js";
-import { n as latestMigrationVersion } from "./migration-safety-Dg1lxomi.js";
-import { i as sourceArgs, n as SOURCE_ARGS } from "./source-args-Dy3j1-H-.js";
-import { readFile } from "node:fs/promises";
-import { SQL_MODULES, adoptedColumnProblems, adoptedTables, migrationOptionUses, moduleIdType } from "better-supabase/sql";
-import { toSnake } from "better-supabase";
-//#region src/cli/sql/adopt.ts
-/**
-* Other names apps give a logical column. They are tried after the module's
-* default name and the logical name in snake case.
-*/
-const ALIASES = {
-	tenant: [
-		"organization_id",
-		"org_id",
-		"tenant_id",
-		"workspace_id",
-		"account_id",
-		"company_id"
-	],
-	user: [
-		"user_id",
-		"profile_id",
-		"owner_id",
-		"member_id"
-	],
-	createdBy: [
-		"created_by",
-		"author_id",
-		"creator_id",
-		"owner_id"
-	],
-	rank: [
-		"position",
-		"sort_order",
-		"sort_key",
-		"order_index"
-	],
-	key: ["id", "user_id"],
-	note: ["notes", "note"]
-};
-/** The blocks with an adopt mode, in registry order. */
-function adoptableBlocks() {
-	return Object.values(SQL_MODULES).filter((module) => module.modes?.includes("adopt") === true).map((module) => module.name);
-}
-/**
-* `schema.table` from `table` or `schema.table`; an unqualified name is in
-* `public`.
-*/
-function qualifiedName(name) {
-	return name.includes(".") ? name : `public.${name}`;
-}
-/** The introspected tables in the shape a proposal reads. */
-function existingTables(tables) {
-	return tables.filter((table) => table.kind === "table");
-}
-function candidates(logical, physical) {
-	const snake = toSnake(logical);
-	const singular = physical.endsWith("s") ? physical.slice(0, -1) : void 0;
-	return [
-		physical,
-		snake,
-		`${snake}_id`,
-		`${physical}s`,
-		...singular === void 0 ? [] : [singular],
-		...ALIASES[logical] ?? []
-	];
-}
-/** The logical columns of `logical` matched to the columns of `table`. */
-function matchColumns(spec, table) {
-	const names = new Set(table.columns.map((column) => column.name));
-	const used = /* @__PURE__ */ new Set();
-	const matches = [];
-	for (const physical of Object.values(spec.columns)) if (names.has(physical)) used.add(physical);
-	for (const [logical, physical] of Object.entries(spec.columns)) {
-		if (names.has(physical)) {
-			matches.push({
-				logical,
-				column: physical,
-				by: "name"
-			});
-			continue;
-		}
-		const found = candidates(logical, physical).find((name) => names.has(name) && !used.has(name)) ?? unique(table.columns.map((column) => column.name).filter((name) => name.endsWith(`_${physical}`) && !used.has(name)));
-		if (found === void 0) matches.push({
-			logical,
-			column: null,
-			by: "missing"
-		});
-		else {
-			used.add(found);
-			matches.push({
-				logical,
-				column: found,
-				by: "alias"
-			});
-		}
-	}
-	return matches;
-}
-const unique = (names) => names.length === 1 ? names[0] : void 0;
-/**
-* The share of logical columns a table matches, so a wide table doesn't win on
-* size.
-*/
-const score = (matches) => matches.length === 0 ? 0 : matches.filter((match) => match.column !== null).length / matches.length;
-/**
-* The table each logical table of `block` maps to: the tables in `from` go to
-* the logical tables whose columns they match best, and the rest are looked up
-* by the module's default names in `schemas`.
-*/
-function matchTables(block, tables, from, schemas, errors) {
-	const spec = SQL_MODULES[block]?.names?.tables ?? {};
-	const byName = new Map(tables.map((table) => [`${table.schema}.${table.name}`, table]));
-	const chosen = /* @__PURE__ */ new Map();
-	for (const name of from) {
-		const table = byName.get(qualifiedName(name));
-		if (table === void 0) {
-			errors.push(`${qualifiedName(name)} is not a table in the database.`);
-			continue;
-		}
-		const best = Object.entries(spec).filter(([logical]) => !chosen.has(logical)).map(([logical, names]) => ({
-			logical,
-			score: score(matchColumns(names, table)) + (table.name === names.name ? 1 : 0)
-		})).toSorted((left, right) => right.score - left.score)[0];
-		if (best === void 0 || best.score === 0) {
-			errors.push(`${qualifiedName(name)} matches none of the ${block} tables (${Object.keys(spec).join(", ")}).`);
-			continue;
-		}
-		chosen.set(best.logical, table);
-	}
-	for (const [logical, table] of Object.entries(spec)) {
-		if (chosen.has(logical)) continue;
-		const found = schemas.map((schema) => byName.get(`${schema}.${table.name}`)).find((match) => match !== void 0);
-		if (found !== void 0) chosen.set(logical, found);
-		else if (table.optionalTable === true) chosen.set(logical, null);
-		else errors.push(`blocks.${block} needs a table for ${logical} (${table.name} by default) and none was found. Pass it with --tables.`);
-	}
-	return chosen;
-}
-const enumType = (column) => `"${column.typeSchema ?? "public"}"."${column.udt}"`;
-/**
-* A `create table` per adopted table, with its enum types, for
-* `adoptedColumnProblems`.
-*/
-const declaration = (table) => [...table.columns.filter((column) => column.isEnum === true).map((column) => `create type ${enumType(column)} as enum ();`), `create table ${table.schema}.${table.name} (\n${table.columns.map((column) => `  "${column.name}" ${column.isEnum === true ? enumType(column) : column.udt}`).join(",\n")}\n);`].join("\n");
-/** The adopt-mode entry for `block` over `tables`, and what can't map. */
-function proposeAdoption(block, tables, options = {}) {
-	const module = SQL_MODULES[block];
-	if (module?.modes?.includes("adopt") !== true) return {
-		block,
-		entry: {},
-		tables: [],
-		errors: [module === void 0 ? `${block} is not a block. See \`better-supabase blocks list\`.` : `${block} has no adopt mode. Blocks you can adopt: ${adoptableBlocks().join(", ")}.`],
-		warnings: []
-	};
-	const errors = [];
-	const spec = module.names?.tables ?? {};
-	const chosen = matchTables(block, tables, options.from ?? [], options.schemas ?? ["public"], errors);
-	const matched = [];
-	const entryTables = {};
-	const entryColumns = {};
-	let idType;
-	for (const [logical, table] of Object.entries(spec)) {
-		if (!chosen.has(logical)) continue;
-		const existing = chosen.get(logical) ?? null;
-		if (existing === null) {
-			entryTables[logical] = null;
-			matched.push({
-				logical,
-				table: null,
-				columns: []
-			});
-			continue;
-		}
-		const name = `${existing.schema}.${existing.name}`;
-		entryTables[logical] = name;
-		const columns = matchColumns(table, existing);
-		matched.push({
-			logical,
-			table: name,
-			columns
-		});
-		const mapped = {};
-		for (const match of columns) {
-			if (match.column === null) {
-				if (table.optional?.includes(match.logical) === true) mapped[match.logical] = null;
-				else errors.push(`${name} has no column for ${logical}.${match.logical} (${table.columns[match.logical]} by default). Add the column, or map blocks.${block}.columns.${logical}.${match.logical} to the one that holds it.`);
-				continue;
-			}
-			if (match.column !== table.columns[match.logical]) mapped[match.logical] = match.column;
-			if (match.logical === "tenant" && idType === void 0) {
-				const udt = existing.columns.find((column) => column.name === match.column)?.udt;
-				const type = udt === void 0 ? void 0 : moduleIdType(udt);
-				if (type !== void 0 && type !== "uuid") idType = type;
-			}
-		}
-		if (Object.keys(mapped).length > 0) entryColumns[logical] = mapped;
-	}
-	const current = options.blocks?.[block];
-	const entry = {
-		...current,
-		mode: "adopt",
-		tables: entryTables,
-		...Object.keys(entryColumns).length > 0 ? { columns: entryColumns } : {},
-		...idType === void 0 || current?.idType !== void 0 ? {} : { idType }
-	};
-	const warnings = [];
-	if (errors.length === 0) {
-		const blocks = {
-			...options.blocks,
-			[block]: entry
-		};
-		try {
-			adoptedTables(blocks);
-			const adopted = [...chosen.values()].filter((table) => table !== null);
-			errors.push(...adoptedColumnProblems(blocks, adopted.map((table) => ({ text: declaration(table) })), [...new Set(adopted.map((table) => table.schema))]));
-		} catch (error) {
-			errors.push(error instanceof Error ? error.message : String(error));
-		}
-		warnings.push(...migrationOptionUses({ [block]: entry }).map((use) => use.message));
-	}
-	return {
-		block,
-		entry,
-		tables: matched,
-		errors,
-		warnings
-	};
-}
-/**
-* Whether one of `block`'s logical tables has an existing table under its
-* default name, so `apply --adopt` proposes adopting the block.
-*/
-function hasDefaultTable(block, tables, schemas = ["public"]) {
-	const names = new Set(Object.values(SQL_MODULES[block]?.names?.tables ?? {}).map((table) => table.name));
-	return tables.some((table) => names.has(table.name) && schemas.includes(table.schema));
-}
-/** The proposal as lines: each table and column, then the errors and warnings. */
-function describeProposal(proposal) {
-	const lines = [];
-	for (const table of proposal.tables) {
-		lines.push(`  ${table.logical}: ${table.table ?? "null (not in the app)"}`);
-		const width = Math.max(0, ...table.columns.map((c) => c.logical.length));
-		for (const column of table.columns) {
-			const target = column.column === null ? "null (not in the table)" : column.by === "alias" ? `${column.column} (guessed)` : column.column;
-			lines.push(`    ${column.logical.padEnd(width)}  ${target}`);
-		}
-	}
-	for (const error of proposal.errors) lines.push(`  error  ${error}`);
-	for (const warning of proposal.warnings) lines.push(`  warn   ${warning}`);
-	return lines;
-}
-//#endregion
-//#region src/cli/commands/adopt.ts
-const ADOPT_ARGS = {
-	block: {
-		type: "positional",
-		required: false,
-		description: "The block to adopt existing tables for"
-	},
-	tables: {
-		type: "string",
-		description: "The existing tables, as table or schema.table; the block's other tables are looked up by their default names",
-		valueHint: "schema.table,..."
-	},
-	"dry-run": {
-		type: "boolean",
-		description: "Show the proposed mapping and the config diff, and write nothing"
-	},
-	check: {
-		type: "boolean",
-		description: "Write nothing; exit 1 with the diff when the config lacks this mapping"
-	}
-};
-/** The schemas searched for a block's default table names. */
-const adoptSchemas = (config) => [.../* @__PURE__ */ new Set(["public", ...config.schemas])];
-/** `source` with `blocks.<block>` set to the proposal's entry. */
-function withAdoptedBlock(file, source, proposal) {
-	return file.endsWith(".json") ? setBlockInJson(source, proposal.block, proposal.entry) : setBlockInConfig(source, proposal.block, proposal.entry);
-}
-/**
-* `edit` with `doctor.migrationSafety.since` set to the newest migration when
-* the config has none, so doctor's lock checks skip the migrations that ran
-* before the tables were adopted.
-*/
-async function withMigrationSince(config, file, edit) {
-	if (!edit.ok || config.doctor.migrationSafety?.since !== void 0) return edit;
-	const since = await latestMigrationVersion(config.root);
-	if (since === void 0) return edit;
-	const path = [
-		"doctor",
-		"migrationSafety",
-		"since"
-	];
-	const next = file.endsWith(".json") ? setPathInJson(edit.text, path, since) : setPathInConfig(edit.text, path, since);
-	return next.ok ? next : edit;
-}
-/** The tables `loadSnapshot` reads, for the adopt commands. */
-function snapshotTables(config, env, source) {
-	return async () => existingTables(toCatalog(await loadSnapshot(config, env, source)).tables);
-}
-/**
-* Proposes `blocks.<block>` in adopt mode over existing tables, reports what
-* can't map, and writes the entry to the config when everything maps.
-*/
-async function runAdopt(config, args, deps) {
-	const block = args.block;
-	if (block === void 0) throw new CliError("usage", "Name the block to adopt, e.g. `better-supabase adopt teams --tables public.teams`.");
-	const proposal = proposeAdoption(block, await deps.tables(), {
-		from: list(args.tables),
-		blocks: config.blocks,
-		schemas: adoptSchemas(config)
-	});
-	const lines = [`Adopting ${block}:`, ...describeProposal(proposal)];
-	const data = {
-		block,
-		entry: proposal.entry,
-		tables: proposal.tables,
-		errors: proposal.errors,
-		warnings: proposal.warnings
-	};
-	if (proposal.errors.length > 0) return {
-		code: 1,
-		output: lines.join("\n"),
-		error: `blocks.${block} wasn't written: fix what the report lists, then run adopt again.`,
-		data: {
-			...data,
-			written: false
-		}
-	};
-	const file = deps.configFile;
-	if (file === void 0) {
-		lines.push("", `No config file: add this to blocks yourself.`, `${block}: ${JSON.stringify(proposal.entry, null, 2)}`);
-		return {
-			code: 0,
-			output: lines.join("\n"),
-			data: {
-				...data,
-				written: false
-			}
-		};
-	}
-	const edit = await withMigrationSince(config, file, withAdoptedBlock(file, await readFile(file, "utf-8"), proposal));
-	const shown = display(config.root, file);
-	if (!edit.ok) return {
-		code: 1,
-		output: lines.join("\n"),
-		error: `${shown} wasn't changed: ${edit.reason}. Set blocks.${block} in it yourself.`,
-		data: {
-			...data,
-			written: false
-		}
-	};
-	const paint = deps.paint ?? plain;
-	const plan = {
-		root: config.root,
-		regenerate: "better-supabase adopt",
-		files: [{
-			path: file,
-			contents: edit.text,
-			policy: "edit"
-		}]
-	};
-	const applied = await applyPlan(plan, args, paint);
-	if (applied.mode === "check") return planResult(plan, applied, { data: {
-		...data,
-		written: false
-	} });
-	if (applied.drift) lines.push("", ...applied.diffs);
-	if (applied.mode === "dry-run" || !applied.drift) {
-		lines.push("", applied.drift ? "Dry run: nothing written. Run without --dry-run to write it." : `${shown} already holds this mapping.`);
-		return {
-			code: 0,
-			output: lines.join("\n"),
-			data: {
-				...data,
-				written: false
-			}
-		};
-	}
-	lines.push("", `Updated ${shown}. Run \`better-supabase sql sync\` to write the block's module over these tables.`);
-	return {
-		code: 0,
-		output: lines.join("\n"),
-		data: {
-			...data,
-			written: true
-		}
-	};
-}
-const adoptCommand = defineCliCommand({
-	meta: commandMeta("adopt"),
-	args: {
-		...ADOPT_ARGS,
-		...SOURCE_ARGS
-	},
-	lists: ["tables"],
-	completions: { block: blockNames },
-	run: async (args, { config, configFile, env, io, log, paint, signal }) => {
-		const tables = snapshotTables(config, env, {
-			...await sourceArgs(args, io),
-			...signal ? { signal } : {}
-		});
-		return runAdopt(config, args, {
-			paint,
-			tables: () => log.progress("Reading the schema", tables),
-			...configFile === void 0 ? {} : { configFile }
-		});
-	}
-});
-//#endregion
-export { withAdoptedBlock as a, hasDefaultTable as c, snapshotTables as i, proposeAdoption as l, adoptSchemas as n, adoptableBlocks as o, runAdopt as r, describeProposal as s, adoptCommand as t };