better-supabase 0.13.0 → 0.14.0

package/dist/cli/apply-DUQ-5LC6.js

@@ -0,0 +1,329 @@
+import { 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 { a as findConfig, s as loadConfig } from "./config-CjgXMZW2.js";
+import { n as applyPlan, s as planResult } from "./files-C5JfVnj5.js";
+import { h as setPresetInJson, m as setPresetInConfig, n as addBlocksToJson, t as addBlocksToConfig } from "./config-edit-D46H0UHp.js";
+import { a as withAdoptedBlock, c as hasDefaultTable, i as snapshotTables, l as proposeAdoption, n as adoptSchemas, o as adoptableBlocks, s as describeProposal } from "./adopt-B0vrj-4B.js";
+import { i as sourceArgs, n as SOURCE_ARGS } from "./source-args-DZV4RnZL.js";
+import { a as CONVENTION_ARGS, d as withConventions, i as createUrlParam, l as hasConventionFlags, n as readPresetInput, o as CONVENTION_COMPLETIONS, r as AUTHZ_NOTE, s as conventionFlags, t as writeDesign } from "./design-edit-B40ljpGZ.js";
+import { n as ident } from "./live-1eL2MIkS.js";
+import { t as syncModules } from "./sync-CjkKpI6d.js";
+import { posix, resolve } from "node:path";
+import { readFile } from "node:fs/promises";
+import { PRESET_NAMES, designConfig, diffAppTables, encodePreset, isPresetName, resolvePreset } from "better-supabase/preset";
+//#region src/cli/commands/apply.ts
+const APPLY_ARGS = {
+	preset: {
+		type: "string",
+		description: "A named preset, a code from /create, its URL or a downloaded design file; the design (&design= or the file) adds its app tables and extra columns",
+		valueHint: "name|code|url|file"
+	},
+	package: {
+		type: "string",
+		description: "Workspace package whose config to edit, relative to --cwd; a Create URL's package= sets it too",
+		valueHint: "dir"
+	},
+	only: {
+		type: "string",
+		description: "blocks: add the preset's blocks to blocks and leave the conventions; conventions: take the conventions and no blocks",
+		valueHint: "blocks|conventions"
+	},
+	adopt: {
+		type: "boolean",
+		description: "Map the preset's blocks onto tables the database already has under their default names (adopt mode)"
+	},
+	"allow-breaking": {
+		type: "boolean",
+		description: "Write a design with breaking app table changes (a rename, a retyped or required column, a tighter constraint); renames print their alter statements"
+	},
+	"dry-run": {
+		type: "boolean",
+		description: "Show the config diff and write nothing"
+	},
+	check: {
+		type: "boolean",
+		description: "Write nothing; exit 1 with the diff when the config lacks the preset"
+	}
+};
+/**
+* `text` with an adopt-mode entry for each of `blocks` that has a table under
+* one of its default names. A block the config already sets to another mode is
+* left as it is.
+*/
+function adoptBlocks(config, file, text, blocks, tables) {
+	const schemas = adoptSchemas(config);
+	const adoptable = new Set(adoptableBlocks());
+	const adopted = [];
+	const refused = [];
+	const lines = [];
+	let next = text;
+	for (const block of blocks) {
+		if (!adoptable.has(block) || !hasDefaultTable(block, tables, schemas)) continue;
+		if ((config.blocks[block]?.mode ?? "managed") !== "managed") continue;
+		const proposal = proposeAdoption(block, tables, {
+			blocks: config.blocks,
+			schemas
+		});
+		lines.push(`Adopting ${block}:`, ...describeProposal(proposal));
+		if (proposal.errors.length > 0) {
+			refused.push(proposal);
+			continue;
+		}
+		const edit = withAdoptedBlock(file, next, proposal);
+		if (!edit.ok) {
+			refused.push({
+				...proposal,
+				errors: [`blocks.${block} can't be set: ${edit.reason}.`]
+			});
+			continue;
+		}
+		next = edit.text;
+		adopted.push(proposal);
+	}
+	return {
+		text: next,
+		lines,
+		adopted,
+		refused
+	};
+}
+const describeConflicts = (preset) => {
+	const { conflicts } = resolvePreset(preset);
+	return conflicts.length === 0 ? void 0 : `The preset can't install: ${conflicts.map((conflict) => `${conflict.block ?? conflict.field ?? ""} (${conflict.reason})`).join("; ")}.`;
+};
+/**
+* The design `--preset` carries, checked against the blocks the config gets: an
+* extra column needs its block in the preset or the config.
+*/
+function designFor(config, design, preset) {
+	if (design === void 0) return;
+	const resolved = resolvePreset(preset);
+	const blocks = /* @__PURE__ */ new Set([...config.blockNames, ...resolved.blocks.map((block) => block.name)]);
+	for (const module of Object.keys(design.extraColumns ?? {})) if (!blocks.has(module)) throw new TypeError(`design.extraColumns.${module}: neither the preset nor the config installs the ${module} block`);
+	designConfig(resolved, design.appTables === void 0 ? {} : { appTables: design.appTables });
+	return design;
+}
+/** Each breaking change with its expand-and-contract steps. */
+function describeBreaking(changes) {
+	return ["Breaking changes to app tables:", ...changes.flatMap((change) => [`  ${change.summary}`, ...change.steps.map((step, index) => `    ${String(index + 1)}. ${step}`)])];
+}
+/**
+* The statements that rename the tables and columns `changes` renames, in
+* order.
+*/
+function renameStatements(changes) {
+	return changes.flatMap((change) => {
+		if (change.from === void 0) return [];
+		if (change.kind === "table.renamed") return [`alter table public.${ident(change.from)} rename to ${ident(change.table)};`];
+		if (change.kind === "column.renamed" && change.column !== void 0) return [`alter table public.${ident(change.table)} rename column ${ident(change.from)} to ${ident(change.column)};`];
+		return [];
+	});
+}
+/** How to run `renames` before `sql sync` creates the new names. */
+function describeRenames(renames, renamedTables, file) {
+	return renames.length === 0 ? [] : [
+		"Run these in a migration before `better-supabase sql sync`, so the renamed tables and columns keep their rows:",
+		...renames.map((statement) => `  ${statement}`),
+		...renamedTables.length === 0 ? [] : [`Then remove ${renamedTables.join(", ")} from appTables in ${file}: apply keeps the tables a design leaves out.`],
+		""
+	];
+}
+/** The config file edited for `--only`: the `preset` key, or the blocks. */
+function edited(file, source, name, preset, only) {
+	const json = file.endsWith(".json");
+	if (only === "blocks") {
+		const names = resolvePreset(preset).blocks.map((block) => block.name);
+		return json ? addBlocksToJson(source, names) : addBlocksToConfig(source, names);
+	}
+	const value = only === "conventions" ? encodePreset({
+		...preset,
+		blocks: []
+	}) : name ?? encodePreset(preset);
+	return json ? setPresetInJson(source, value) : setPresetInConfig(source, value);
+}
+/**
+* The config of the workspace package `pkg` names, relative to the root
+* config's directory, and its file; the root config without one.
+*/
+async function packageTarget(config, deps, pkg, reload) {
+	if (pkg === void 0) return {
+		config,
+		deps
+	};
+	const root = resolve(config.root, posix.normalize(pkg.replaceAll("\\", "/")));
+	const file = findConfig(root);
+	if (file === void 0) throw new CliError("config_not_found", `--package ${pkg} has no better-supabase config. Start one with \`better-supabase init --package ${pkg}\`.`);
+	return {
+		config: await reload(root, file),
+		deps: {
+			...deps,
+			configFile: file
+		}
+	};
+}
+/**
+* Applies a preset to an existing project: sets `preset` in the config (or,
+* with `--only blocks`, lists its blocks), shows the diff, then writes the
+* module files of every block the config now holds.
+*/
+async function runApply(rootConfig, args, rootDeps) {
+	const input = args.preset;
+	if (input === void 0) throw new CliError("usage", "Pass --preset with a named preset, a code from /create, its URL or a downloaded design file.");
+	const only = args.only;
+	if (only !== void 0 && only !== "blocks" && only !== "conventions") throw new CliError("usage", "--only must be \"blocks\" or \"conventions\"");
+	const flags = conventionFlags(args);
+	if (only === "blocks" && hasConventionFlags(flags)) throw new CliError("usage", "--only blocks leaves the conventions, so it takes no convention flags.");
+	const reload = rootDeps.reload ?? ((root, path) => loadConfig(root, path));
+	const { config, deps } = await packageTarget(rootConfig, rootDeps, args.package ?? createUrlParam(input, "package"), reload);
+	const file = deps.configFile;
+	if (file === void 0) throw new CliError("config_not_found", `No config file to apply the preset to. Start a project with \`better-supabase init --preset ${input}\`.`);
+	const read = await readPresetInput(input, rootConfig.root);
+	const preset = withConventions(read.preset, flags);
+	const name = isPresetName(input) && !hasConventionFlags(flags) ? input : void 0;
+	let design;
+	try {
+		design = only === "conventions" ? void 0 : designFor(config, read.design, preset);
+	} catch (error) {
+		throw new CliError("usage", error instanceof Error ? error.message : String(error));
+	}
+	const conflict = describeConflicts(only === "conventions" ? {
+		...preset,
+		blocks: []
+	} : preset);
+	if (conflict !== void 0) throw new CliError("usage", conflict);
+	const changes = design?.appTables === void 0 ? [] : diffAppTables(config.appTables, design.appTables);
+	const kept = changes.filter((change) => change.kind === "table.dropped").map((change) => change.table);
+	const renamedTables = changes.flatMap((change) => change.kind === "table.renamed" && change.from !== void 0 ? [change.from] : []);
+	const breaking = changes.filter((change) => change.breaking && change.kind !== "table.dropped");
+	const renames = renameStatements(breaking);
+	const shown = display(config.root, file);
+	if (breaking.length > 0 && args["allow-breaking"] !== true && args["dry-run"] !== true) return {
+		code: 1,
+		output: describeBreaking(breaking).join("\n"),
+		data: {
+			file: shown,
+			written: false,
+			breaking,
+			kept
+		},
+		error: `Nothing was written: the design has ${breaking.length === 1 ? "a breaking change" : `${String(breaking.length)} breaking changes`} to tables the app already has. Follow the steps above, or pass --allow-breaking to write it anyway.`
+	};
+	const source = await readFile(file, "utf-8");
+	const edit = edited(file, source, name, preset, only);
+	if (!edit.ok) return {
+		code: 1,
+		error: `${shown} wasn't changed: ${edit.reason}. Set preset: "${encodePreset(preset)}" in it yourself.`
+	};
+	const withDesign = design === void 0 ? edit : writeDesign(file, edit.text, design, config);
+	if (!withDesign.ok) return {
+		code: 1,
+		error: `${shown} wasn't changed: ${withDesign.reason}. Download the config from /create and copy its appTables and extraColumns yourself.`
+	};
+	const paint = deps.paint ?? plain;
+	let text = withDesign.text;
+	const lines = [
+		...breaking.length === 0 ? [] : [...describeBreaking(breaking), ""],
+		...describeRenames(renames, renamedTables, shown),
+		...kept.length === 0 ? [] : [`Kept ${kept.join(", ")}: the design doesn't name ${kept.length === 1 ? "it" : "them"}, and apply keeps the tables a design leaves out. Remove ${kept.length === 1 ? "it" : "them"} from appTables in ${shown} to drop ${kept.length === 1 ? "it" : "them"}.`, ""]
+	];
+	if (createUrlParam(input, "authz") !== void 0) lines.push(AUTHZ_NOTE, "");
+	let adopted = {};
+	if (args.adopt === true) {
+		if (only === "conventions" || deps.tables === void 0) throw new CliError("usage", only === "conventions" ? "--adopt maps blocks, and --only conventions takes none." : "--adopt needs the database or a snapshot to read the tables from.");
+		const adoption = adoptBlocks(config, file, text, resolvePreset(preset).blocks.map((block) => block.name), await deps.tables());
+		if (adoption.refused.length > 0) return {
+			code: 1,
+			output: adoption.lines.join("\n"),
+			data: {
+				file: shown,
+				written: false,
+				refused: Object.fromEntries(adoption.refused.map((proposal) => [proposal.block, proposal.errors]))
+			},
+			error: `Nothing was written: ${adoption.refused.map((proposal) => proposal.block).join(", ")} ${adoption.refused.length === 1 ? "has a table" : "have tables"} under the default names that can't be adopted as they are, and the managed block would skip them. Fix what the report lists, map them with \`better-supabase adopt <block> --tables <schema.table>\`, or leave the block out of the preset.`
+		};
+		text = adoption.text;
+		adopted = Object.fromEntries(adoption.adopted.map((proposal) => [proposal.block, proposal.entry]));
+		lines.push(...adoption.lines.length === 0 ? ["No existing tables to adopt: every block stays managed."] : adoption.lines, "");
+	}
+	const data = {
+		file: shown,
+		adopted,
+		contents: text,
+		kept,
+		...renames.length === 0 ? {} : { renames }
+	};
+	if (text === source) {
+		lines.push(`${shown} already holds the preset.`);
+		return {
+			code: 0,
+			output: lines.join("\n"),
+			data: {
+				...data,
+				written: false
+			}
+		};
+	}
+	const plan = {
+		root: config.root,
+		regenerate: "better-supabase apply",
+		files: [{
+			path: file,
+			contents: text,
+			policy: "edit"
+		}]
+	};
+	const applied = await applyPlan(plan, args, paint);
+	if (applied.mode === "check") return planResult(plan, applied, { data: {
+		...data,
+		written: false
+	} });
+	lines.push(...applied.diffs);
+	if (applied.mode === "dry-run") {
+		lines.push("", "Dry run: nothing written. Run without --dry-run to apply it.");
+		return {
+			code: 0,
+			output: lines.join("\n"),
+			data: {
+				...data,
+				written: false
+			}
+		};
+	}
+	const next = await reload(config.root, file);
+	const synced = await syncModules(next, {}, paint, deps.now);
+	lines.push("", `Updated ${shown}.`, "", synced.output ?? synced.error ?? "");
+	return {
+		code: synced.code,
+		output: lines.join("\n"),
+		data: {
+			...data,
+			written: true
+		}
+	};
+}
+const applyCommand = defineCliCommand({
+	meta: commandMeta("apply"),
+	args: {
+		...APPLY_ARGS,
+		...CONVENTION_ARGS,
+		...SOURCE_ARGS
+	},
+	completions: {
+		...CONVENTION_COMPLETIONS,
+		preset: () => PRESET_NAMES,
+		only: () => ["blocks", "conventions"]
+	},
+	run: async (args, { config, configFile, env, io, paint, signal }) => runApply(config, args, {
+		now: () => /* @__PURE__ */ new Date(),
+		paint,
+		tables: snapshotTables(config, env, {
+			...await sourceArgs(args, io),
+			...signal ? { signal } : {}
+		}),
+		...configFile === void 0 ? {} : { configFile }
+	})
+});
+//#endregion
+export { applyCommand };

package/dist/cli/bin.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { i as run } from "./run-dTu_PD4I.js";
+import { i as run } from "./run-CE2s5TDh.js";
 import { t as colorEnabled } from "./style-Bm2X5JrN.js";
 import { existsSync } from "node:fs";
 import { basename } from "node:path";

package/dist/cli/blocks-DzgYfjVv.js

@@ -0,0 +1,124 @@
+import { p as commandMeta, r as defineCliCommand } from "./command-33pu13LT.js";
+import { n as CliError } from "./errors-BTe6A15O.js";
+import { BLOCK_CATEGORIES } from "better-supabase/blocks";
+import { PRESET_CATALOG, glueCommand } from "better-supabase/preset";
+import { SQL_MODULES } from "better-supabase/sql";
+//#region src/cli/commands/blocks.ts
+const LIST_ARGS = { category: {
+	type: "string",
+	description: `One category: ${BLOCK_CATEGORIES.join(", ")}`,
+	valueHint: "name"
+} };
+const VIEW_ARGS = { block: {
+	type: "positional",
+	required: true,
+	description: "The block to show"
+} };
+const SEARCH_ARGS = { text: {
+	type: "positional",
+	required: false,
+	variadic: true,
+	description: "Words to find in block names, titles and descriptions"
+} };
+function entryOf(block) {
+	const module = SQL_MODULES[block.name];
+	const manifest = PRESET_CATALOG.manifests.find((each) => each.name === block.manifest);
+	return {
+		name: block.name,
+		title: block.title,
+		description: module?.description ?? "",
+		category: block.category,
+		requires: block.requires,
+		integrates: block.integrates,
+		modes: module?.modes ?? ["managed"],
+		client: manifest?.client?.subpath ?? null,
+		page: `https://bettersupabase.com/blocks/${block.name}`
+	};
+}
+const ENTRIES = PRESET_CATALOG.blocks.map(entryOf);
+/** Every block name, for completion. */
+const blockNames = () => ENTRIES.map((entry) => entry.name);
+function listing(entries) {
+	const width = Math.max(0, ...entries.map((entry) => entry.name.length));
+	return BLOCK_CATEGORIES.flatMap((category) => {
+		const rows = entries.filter((entry) => entry.category === category);
+		if (rows.length === 0) return [];
+		return [
+			"",
+			`${category}:`,
+			...rows.map((entry) => `  ${entry.name.padEnd(width)}  ${entry.title}`)
+		];
+	}).slice(1);
+}
+function listBlocks(category) {
+	if (category !== void 0 && !BLOCK_CATEGORIES.some((each) => each === category)) throw new CliError("usage", `Unknown category "${category}". Categories: ${BLOCK_CATEGORIES.join(", ")}`);
+	const entries = ENTRIES.filter((entry) => category === void 0 || entry.category === category);
+	return {
+		code: 0,
+		output: listing(entries).join("\n"),
+		data: { blocks: entries }
+	};
+}
+function viewBlock(name) {
+	if (name === void 0) throw new CliError("input_required", "Name a block.", {
+		missing: ["<block>"],
+		choices: { "<block>": ENTRIES.map((each) => each.name) }
+	});
+	const entry = ENTRIES.find((each) => each.name === name);
+	if (entry === void 0) throw new CliError("usage", `Unknown block "${name}". Run \`better-supabase blocks search ${name}\`.`);
+	const glue = PRESET_CATALOG.glue.filter((item) => item.preset === void 0 && item.blocks.includes(name));
+	return {
+		code: 0,
+		output: [
+			`${entry.title} (${entry.name}, ${entry.category})`,
+			"",
+			entry.description,
+			"",
+			`Requires:   ${entry.requires.join(", ") || "nothing"}`,
+			`Works with: ${entry.integrates.join(", ") || "nothing"}`,
+			`Modes:      ${entry.modes.join(", ")}`,
+			...entry.client === null ? [] : [`Client:     ${entry.client}`],
+			"",
+			`Install: better-supabase add ${entry.name}`,
+			...glue.map((item) => `Glue (${item.frameworks.join(", ")}): ${glueCommand([item])}`),
+			`More: ${entry.page}`
+		].join("\n"),
+		data: {
+			block: entry,
+			glue
+		}
+	};
+}
+function searchBlocks(text) {
+	if (text === void 0 || text.trim() === "") throw new CliError("usage", `Pass the text to search for.`);
+	const query = text.toLowerCase();
+	const found = ENTRIES.filter((entry) => [
+		entry.name,
+		entry.title,
+		entry.description
+	].some((field) => field.toLowerCase().includes(query)));
+	return {
+		code: 0,
+		output: found.length === 0 ? `No block matches "${text}". Run \`better-supabase blocks list\`.` : listing(found).join("\n"),
+		data: { blocks: found }
+	};
+}
+const blocksListCommand = defineCliCommand({
+	meta: commandMeta("blocks list"),
+	args: LIST_ARGS,
+	completions: { category: () => BLOCK_CATEGORIES },
+	run: (args) => Promise.resolve(listBlocks(args.category))
+});
+const blocksViewCommand = defineCliCommand({
+	meta: commandMeta("blocks view"),
+	args: VIEW_ARGS,
+	completions: { block: blockNames },
+	run: (args) => Promise.resolve(viewBlock(args.block))
+});
+const blocksSearchCommand = defineCliCommand({
+	meta: commandMeta("blocks search"),
+	args: SEARCH_ARGS,
+	run: (args) => Promise.resolve(searchBlocks(args._.join(" ")))
+});
+//#endregion
+export { listBlocks as a, blocksViewCommand as i, blocksListCommand as n, searchBlocks as o, blocksSearchCommand as r, viewBlock as s, blockNames as t };

package/dist/cli/blocks-gGupqvBH.js

@@ -0,0 +1 @@
+export { n as blocksListCommand, r as blocksSearchCommand, i as blocksViewCommand } from "./blocks-DzgYfjVv.js";