better-supabase 0.14.0 → 0.15.0

package/dist/cli/moved-CsfDQcyk.js

@@ -0,0 +1,254 @@
+import { n as CliError } from "./errors-BTe6A15O.js";
+import { s as positionalIndex } from "./parse-B9Iv_-Pf.js";
+//#region src/cli/core/moved.ts
+const API_REPLACEMENT = "defineApi includes every table and block instance, and createOrpc(betterSupabase).router(api) serves it: https://bettersupabase.com/docs/frameworks/orpc#serve-the-api";
+/** Commands removed in 0.15, with what replaces them, longest path first. */
+const REMOVED_COMMANDS = [
+	{
+		path: ["scaffold", "screens"],
+		replacement: "better-supabase writes no pages. Build them on the generated data hooks and the record-* UI recipes: https://bettersupabase.com/docs/registry/ui-recipes#app-tables"
+	},
+	{
+		path: ["scaffold", "api"],
+		replacement: API_REPLACEMENT
+	},
+	{
+		path: ["scaffold"],
+		replacement: API_REPLACEMENT
+	}
+];
+/** Commands renamed in 0.9 and folded in 0.15, longest prefix first. */
+const MOVED_COMMANDS = [
+	{
+		from: ["openapi", "emit"],
+		to: [
+			"spec",
+			"emit",
+			"openapi"
+		]
+	},
+	{
+		from: ["openapi"],
+		to: [
+			"spec",
+			"emit",
+			"openapi"
+		]
+	},
+	{
+		from: ["spec", "check"],
+		to: [
+			"spec",
+			"emit",
+			"--check"
+		]
+	},
+	{
+		from: ["sql", "list"],
+		to: [
+			"blocks",
+			"list",
+			"--installed"
+		]
+	},
+	{
+		from: ["sql", "add"],
+		to: ["add"]
+	},
+	{
+		from: ["sql", "sync"],
+		to: ["upgrade"]
+	},
+	{
+		from: ["sql", "upgrade"],
+		to: ["upgrade"]
+	},
+	{
+		from: ["sql", "data"],
+		to: ["add", "--adopt"]
+	},
+	{
+		from: ["sql", "print"],
+		to: [
+			"blocks",
+			"view",
+			"--sql"
+		]
+	},
+	{
+		from: ["preset", "decode"],
+		to: [
+			"blocks",
+			"list",
+			"--preset"
+		]
+	},
+	{
+		from: ["preset", "info"],
+		to: ["config", "--preset"]
+	},
+	{
+		from: ["apply"],
+		to: ["add"]
+	},
+	{
+		from: ["adopt"],
+		to: ["add", "--adopt"]
+	},
+	{
+		from: ["introspect"],
+		to: ["gen", "--save-snapshot"]
+	},
+	{
+		from: ["seed"],
+		to: ["db", "seed"]
+	},
+	{
+		from: ["env"],
+		to: ["dev", "env"]
+	},
+	{
+		from: ["run"],
+		to: ["dev", "run"]
+	},
+	{
+		from: ["keys"],
+		to: ["dev", "keys"]
+	},
+	{
+		from: ["stack"],
+		to: ["dev", "stack"]
+	}
+];
+/**
+* Flags renamed in 0.9, by the command path they have now. A replacement with a
+* space takes no value from argv.
+*/
+const MOVED_FLAGS = /* @__PURE__ */ new Map([
+	["init", { with: "integration" }],
+	["add", {
+		framework: "integration",
+		from: "tables"
+	}],
+	["gen", {
+		tasks: "only",
+		format: "kind"
+	}],
+	["doctor", { strict: "fail-on warning" }],
+	["dev env", {
+		print: "out -",
+		from: "status-file"
+	}],
+	["skills list", { from: "source" }],
+	["skills install", {
+		from: "source",
+		agent: "for"
+	}]
+]);
+/**
+* `argv` without the words of `prefix`, or `undefined` when it doesn't start
+* with them.
+*/
+function withoutPrefix(argv, prefix) {
+	let rest = [...argv];
+	let index = positionalIndex(rest);
+	for (const part of prefix) {
+		if (index === -1 || rest[index] !== part) return;
+		rest = rest.toSpliced(index, 1);
+		index = positionalIndex(rest, index);
+	}
+	return rest;
+}
+function same(a, b) {
+	return a.length === b.length && a.every((word, index) => word === b[index]);
+}
+/** The flag name of `arg` when it is a long flag, without `--` and any `=value`. */
+function flagName(arg) {
+	return arg.startsWith("--") ? arg.slice(2).split("=")[0] : void 0;
+}
+/** `rest` with every flag in `flags` renamed, up to a `--`. */
+function renameFlags(rest, flags) {
+	const end = rest.indexOf("--");
+	return [...(end === -1 ? rest : rest.slice(0, end)).flatMap((arg) => {
+		const name = flagName(arg);
+		if (name === void 0 || !Object.hasOwn(flags, name)) return [arg];
+		const [, value] = arg.slice(2).split(/[=](.*)/su);
+		const replacement = flags[name] ?? name;
+		if (replacement.includes(" ")) return replacement.split(" ").map((word, index) => index === 0 ? `--${word}` : word);
+		return [`--${replacement}${value === void 0 ? "" : `=${value}`}`];
+	}), ...end === -1 ? [] : rest.slice(end)];
+}
+/**
+* The current spelling of a CLI call's arguments (the words after the bin), or
+* `undefined` when nothing in it moved. Codemods use it to rewrite scripts.
+*/
+function migrateCliCall(argv) {
+	let next = [...argv];
+	for (const moved of MOVED_COMMANDS) {
+		const rest = withoutPrefix(next, moved.from);
+		if (rest) {
+			next = [...moved.to, ...rest];
+			break;
+		}
+	}
+	const paths = [...MOVED_FLAGS.keys()].toSorted((a, b) => b.split(" ").length - a.split(" ").length);
+	for (const path of paths) {
+		const parts = path.split(" ");
+		const rest = withoutPrefix(next, parts);
+		if (rest) {
+			const renamed = renameFlags(rest, MOVED_FLAGS.get(path) ?? {});
+			if (!same(renamed, rest)) next = [...parts, ...renamed];
+			break;
+		}
+	}
+	return same(next, argv) ? void 0 : next;
+}
+/** A `command_moved` error when `argv` starts with a renamed command. */
+function movedCommand(argv, bin = "better-supabase") {
+	for (const removed of REMOVED_COMMANDS) if (withoutPrefix(argv, removed.path)) return new CliError("unknown_command", `"${removed.path.join(" ")}" was removed in 0.15. ${removed.replacement}`);
+	for (const moved of MOVED_COMMANDS) {
+		const rest = withoutPrefix(argv, moved.from);
+		if (rest) {
+			const next = [
+				bin,
+				...moved.to,
+				...rest
+			].join(" ");
+			return new CliError("command_moved", `"${moved.from.join(" ")}" is now "${moved.to.join(" ")}". Run: ${next}`, { suggestion: next });
+		}
+	}
+}
+/**
+* A `flag_renamed` error when `rest` (the argv after the command path) passes a
+* renamed flag.
+*/
+function movedFlag(path, rest, bin = "better-supabase") {
+	const flags = MOVED_FLAGS.get(path.join(" "));
+	if (!flags) return;
+	const end = rest.indexOf("--");
+	const options = end === -1 ? rest : rest.slice(0, end);
+	const index = options.findIndex((arg) => {
+		const name = flagName(arg);
+		return name !== void 0 && Object.hasOwn(flags, name);
+	});
+	if (index === -1) return;
+	const [name = "", value] = (options[index] ?? "").slice(2).split(/[=](.*)/su);
+	const replacement = flags[name] ?? name;
+	const takesNoValue = replacement.includes(" ");
+	const rewritten = [
+		...rest.slice(0, index),
+		`--${replacement}${value === void 0 || takesNoValue ? "" : `=${value}`}`,
+		...rest.slice(index + 1)
+	];
+	const next = [
+		bin,
+		...path,
+		...rewritten
+	].join(" ");
+	return new CliError("flag_renamed", `--${name} is now --${replacement}. Run: ${next}`, {
+		suggestion: next,
+		flag: `--${replacement.split(" ")[0]}`
+	});
+}
+//#endregion
+export { movedCommand as n, movedFlag as r, migrateCliCall as t };

package/dist/cli/orphans-BAboqyVM.js

@@ -0,0 +1,28 @@
+import { resolve } from "node:path";
+import { readFile, readdir } from "node:fs/promises";
+import { CONFIG_DEFAULTS } from "better-supabase/config";
+import { isModuleDataFile, moduleDataDir, moduleFileVersion } from "better-supabase/sql";
+//#region src/cli/sql/orphans.ts
+/**
+* Block schema and data files in `sql.dir` and the data folder that no
+* installed block renders any more: files of a removed or renamed block, or
+* from an earlier position. Only files with a `@bsb-block` or `@bsb-block-data`
+* line count, so the app's own files are never listed.
+*/
+async function orphanedBlockFiles(config, sqlLayout, rendered) {
+	const prefix = sqlLayout.prefix ?? CONFIG_DEFAULTS.sql.prefix;
+	const dirs = [(sqlLayout.dir ?? CONFIG_DEFAULTS.sql.dir).replace(/\/$/, ""), moduleDataDir(sqlLayout)];
+	const orphans = [];
+	for (const dir of new Set(dirs)) {
+		const entries = await readdir(resolve(config.root, dir)).catch(() => []);
+		for (const name of entries.toSorted()) {
+			const path = `${dir}/${name}`;
+			if (!name.startsWith(`${prefix}_`) || !name.endsWith(".sql") || rendered.has(path)) continue;
+			const text = await readFile(resolve(config.root, path), "utf-8").catch(() => "");
+			if (moduleFileVersion(text) !== void 0 || isModuleDataFile(text)) orphans.push(path);
+		}
+	}
+	return orphans;
+}
+//#endregion
+export { orphanedBlockFiles as t };

package/dist/cli/parse-B9Iv_-Pf.js

@@ -0,0 +1,182 @@
+import { r as __toESM } from "./rolldown-runtime-kJ_i4yPo.js";
+import { t as GLOBAL_ARGS } from "./command-CQ61x6gN.js";
+import { n as CliError } from "./errors-BTe6A15O.js";
+//#region src/cli/core/parse.ts
+/**
+* Global options that take a value, so a command name is never the token after
+* them.
+*/
+const GLOBAL_VALUE_FLAGS = new Set(Object.entries(GLOBAL_ARGS).flatMap(([name, definition]) => definition.type === "string" ? [`--${name}`] : []));
+/**
+* The tree of `specs`, with each leaf's loader from `loaders` (keyed by its
+* space-separated path).
+*/
+function commandTree(specs, loaders, parent = []) {
+	return new Map(specs.map((spec) => {
+		const path = [...parent, spec.name];
+		const load = loaders.get(path.join(" "));
+		return [spec.name, {
+			spec,
+			path,
+			...load ? { load } : {},
+			children: commandTree(spec.subcommands ?? [], loaders, path)
+		}];
+	}));
+}
+/**
+* The index of the next token that is not an option or a global option's value,
+* from `start`.
+*/
+function positionalIndex(argv, start = 0) {
+	for (let index = start; index < argv.length; index += 1) {
+		const token = argv[index];
+		if (token === "--") return -1;
+		if (!token.startsWith("-") || token === "-") return index;
+		if (GLOBAL_VALUE_FLAGS.has(token)) index += 1;
+	}
+	return -1;
+}
+/** Walks `argv` down the tree to the deepest command it names. */
+function resolveCommand(tree, argv) {
+	let rest = [...argv];
+	let index = positionalIndex(rest);
+	if (index === -1) return {
+		kind: "root",
+		rest
+	};
+	let level = tree;
+	let node;
+	while (index !== -1) {
+		const name = rest[index];
+		const next = level.get(name);
+		if (!next) {
+			if (node?.load) break;
+			return {
+				kind: "unknown",
+				parent: node?.path ?? [],
+				name,
+				candidates: [...level.keys()],
+				rest: rest.toSpliced(index, 1)
+			};
+		}
+		node = next;
+		rest = rest.toSpliced(index, 1);
+		if (node.children.size === 0) break;
+		level = node.children;
+		index = positionalIndex(rest, index);
+	}
+	return {
+		kind: "command",
+		node,
+		rest
+	};
+}
+/** The flags `run()` reads before it loads a command, before `--`. */
+function globalFlags(argv) {
+	const end = argv.indexOf("--");
+	const options = end === -1 ? argv : argv.slice(0, end);
+	const flags = new Set(options);
+	const at = options.findLastIndex((arg) => arg === "--agent" || arg.startsWith("--agent="));
+	const agentArg = options[at];
+	return {
+		help: flags.has("--help") || flags.has("-h"),
+		json: flags.has("--json") || flags.has("--json=true"),
+		noJson: flags.has("--no-json") || flags.has("--json=false"),
+		color: !flags.has("--no-color") && !flags.has("--color=false"),
+		debug: flags.has("--debug"),
+		agent: agentArg === void 0 ? void 0 : agentArg === "--agent" ? options[at + 1] ?? "" : agentArg.slice(8)
+	};
+}
+/** A command's static `args`, or none. */
+async function commandArgs(command) {
+	const declared = command.args;
+	return await (typeof declared === "function" ? declared() : declared) ?? {};
+}
+/** A positional that takes the rest of the arguments (`add <block...>`). */
+function isVariadic(definition) {
+	return definition.type === "positional" && "variadic" in definition && definition.variadic === true;
+}
+const kebab = (name) => name.replaceAll(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+/**
+* The registered name closest to a mistyped one, if it is close enough to be a
+* typo.
+*/
+async function closestName(name, names) {
+	if (names.length === 0) return;
+	const { closest, distance } = await import("./fastest-levenshtein-dhRRvrM2.js").then((m) => /* @__PURE__ */ __toESM(m.default, 1));
+	const candidate = closest(name, [...names]);
+	return distance(name, candidate) <= Math.max(2, Math.floor(name.length / 3)) ? candidate : void 0;
+}
+/**
+* Rejects what citty would ignore: unknown options, values outside an enum, and
+* positionals the command doesn't declare.
+*/
+async function checkArgs(args, argv, usage) {
+	const definitions = {
+		...args,
+		...GLOBAL_ARGS
+	};
+	const long = /* @__PURE__ */ new Map();
+	const short = /* @__PURE__ */ new Map();
+	const positionals = [];
+	for (const [name, definition] of Object.entries(definitions)) {
+		if (definition.type === "positional") {
+			positionals.push(definition);
+			continue;
+		}
+		long.set(kebab(name), [name, definition]);
+		const aliases = "alias" in definition ? [definition.alias].flat() : [];
+		for (const alias of aliases) (alias.length === 1 ? short : long).set(alias, [name, definition]);
+	}
+	const takesValue = (definition) => definition.type === "string" || definition.type === "enum";
+	const unknownOption = async (option) => {
+		const suggestion = await closestName(option, [...long.keys()]);
+		throw new CliError("unknown_flag", `Unknown option --${option} for ${usage}.${suggestion ? ` Did you mean --${suggestion}?` : ""}`, {
+			flag: `--${option}`,
+			...suggestion ? { suggestion: `--${suggestion}` } : {}
+		});
+	};
+	const checkValue = (name, definition, value) => {
+		if (definition.type !== "enum" || value === void 0 || !definition.options || definition.options.includes(value)) return;
+		throw new CliError("invalid_value", `--${name} takes ${definition.options.join(", ")}, not "${value}".`, { flag: `--${name}` });
+	};
+	let count = 0;
+	for (let index = 0; index < argv.length; index += 1) {
+		const token = argv[index];
+		if (token === "--") break;
+		if (token.startsWith("--")) {
+			const [raw = "", inline] = token.slice(2).split(/[=](.*)/s, 2);
+			const option = kebab(raw);
+			const found = long.get(option) ?? (option.startsWith("no-") ? long.get(option.slice(3)) : void 0);
+			if (!found || found !== long.get(option) && takesValue(found[1])) await unknownOption(option);
+			const [name, definition] = found;
+			if (takesValue(definition) && inline === void 0) {
+				const value = argv[index + 1];
+				if (value !== void 0 && (value === "-" || !value.startsWith("-"))) {
+					checkValue(name, definition, value);
+					index += 1;
+				}
+			} else checkValue(name, definition, inline);
+			continue;
+		}
+		if (token.startsWith("-") && token !== "-") {
+			for (const letter of token.slice(1)) {
+				const found = short.get(letter);
+				if (!found) throw new CliError("unknown_flag", `Unknown option -${letter} for ${usage}.`, { flag: `-${letter}` });
+				if (takesValue(found[1])) {
+					index += 1;
+					break;
+				}
+			}
+			continue;
+		}
+		count += 1;
+		const last = positionals.at(-1);
+		if (count > positionals.length && !(last && isVariadic(last))) {
+			const takes = positionals.length === 0 ? "takes no arguments" : `takes ${positionals.length} argument${positionals.length === 1 ? "" : "s"}`;
+			throw new CliError("usage", `${usage} ${takes}, and got "${token}".${token === "help" ? ` Run ${usage} --help.` : ""}`, token === "help" ? { suggestion: `${usage} --help` } : {});
+		}
+	}
+}
+//#endregion
+export { globalFlags as a, resolveCommand as c, commandTree as i, closestName as n, isVariadic as o, commandArgs as r, positionalIndex as s, checkArgs as t };

package/dist/cli/preset-BwmIfFnh.js

@@ -0,0 +1,101 @@
+import { n as CliError } from "./errors-BTe6A15O.js";
+import { CONVENTION_FIELDS, presetAndDesignOf, presetConfig, presetOf, presetSpec, resolvePreset } from "better-supabase/preset";
+//#region src/cli/commands/preset.ts
+const messageOf = (error) => error instanceof Error ? error.message : String(error);
+/** The value of a convention field, for printing. */
+function fieldValue(preset, key) {
+	const value = preset[key];
+	if (typeof value === "string") return value;
+	return value.length === 0 ? "none" : value.join(", ");
+}
+/** A preset and what it resolves to, as lines. */
+function describe(resolved) {
+	const { preset } = resolved;
+	const width = Math.max(...CONVENTION_FIELDS.map((field) => field.key.length));
+	const spec = presetSpec(preset);
+	const lines = [
+		`Preset: ${typeof spec === "string" ? spec : "custom"}`,
+		"",
+		...CONVENTION_FIELDS.map((field) => `  ${field.key.padEnd(width)}  ${fieldValue(preset, field.key)}`),
+		"",
+		`Blocks (${String(resolved.blocks.length)}):`,
+		...resolved.blocks.map((block) => `  ${block.name}${block.selected ? "" : ` (${block.reason})`}`)
+	];
+	if (resolved.conflicts.length > 0) lines.push("", "Can't install:", ...resolved.conflicts.map((conflict) => `  ${conflict.block ?? conflict.field ?? ""}: ${conflict.reason}`));
+	return lines;
+}
+function presetData(resolved) {
+	return {
+		spec: presetSpec(resolved.preset),
+		preset: resolved.preset,
+		blocks: resolved.blocks,
+		integrations: resolved.integrations,
+		conflicts: resolved.conflicts
+	};
+}
+async function decodePresetInput(value) {
+	if (value === void 0) throw new CliError("input_required", "Name a preset, a design code or a /create URL.", { missing: ["<preset>"] });
+	let preset;
+	try {
+		({preset} = await presetAndDesignOf(value));
+	} catch (error) {
+		throw new CliError("usage", messageOf(error));
+	}
+	const resolved = resolvePreset(preset);
+	return {
+		code: resolved.conflicts.length > 0 ? 1 : 0,
+		output: describe(resolved).join("\n"),
+		data: presetData(resolved)
+	};
+}
+/** How the config differs from the preset it names. */
+function drift(config, resolved) {
+	const base = presetConfig(resolved);
+	const baseBlocks = base.blocks;
+	const fromPreset = new Set(Object.keys(baseBlocks));
+	const added = config.blockNames.filter((name) => !fromPreset.has(name));
+	const changed = [];
+	if ((base.casing ?? "snake") !== config.casing) changed.push(`casing is ${config.casing}, the preset sets ${base.casing ?? "snake"}`);
+	for (const name of fromPreset) {
+		const own = config.blocks[name];
+		const preset = baseBlocks[name] ?? {};
+		const keys = Object.keys(own ?? {}).filter((key) => key !== "schema" && key !== "api" && !(key in preset));
+		if (keys.length > 0) changed.push(`${name} sets ${keys.join(", ")}`);
+	}
+	return {
+		added,
+		changed
+	};
+}
+function presetInfo(config) {
+	if (config.preset === void 0) return {
+		code: 0,
+		output: "The config names no preset. Start one with `better-supabase add --preset <name>`.",
+		data: { preset: null }
+	};
+	let preset;
+	try {
+		preset = presetOf(config.preset);
+	} catch (error) {
+		throw new CliError("usage", messageOf(error));
+	}
+	const resolved = resolvePreset(preset);
+	const { added, changed } = drift(config, resolved);
+	return {
+		code: 0,
+		output: [
+			...describe(resolved),
+			"",
+			added.length === 0 && changed.length === 0 ? "The config adds nothing to the preset." : "The config differs from the preset:",
+			...added.map((name) => `  + ${name}`),
+			...changed.map((line) => `  ~ ${line}`)
+		].join("\n"),
+		data: {
+			...presetData(resolved),
+			added,
+			changed
+		}
+	};
+}
+//#endregion
+export { presetInfo as n, decodePresetInput as t };

package/dist/cli/print-BeWO7OJY.js

@@ -0,0 +1,67 @@
+import { n as CliError } from "./errors-BTe6A15O.js";
+import { g as layout, o as migrationModules, r as latestMigration, u as writesMigrations } from "./module-migration-aPCckev6.js";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { SQL_MODULES, contractSignature, customContracts, moduleBody, moduleFilePaths } from "better-supabase/sql";
+//#region src/cli/sql/list.ts
+async function listModules(config, args) {
+	const sqlLayout = await layout(config, args);
+	const files = moduleFilePaths(Object.keys(SQL_MODULES), sqlLayout);
+	const migrated = await writesMigrations(config) ? migrationModules((await latestMigration(config, "_better_supabase_modules.sql"))?.text ?? "") : void 0;
+	const modules = [];
+	const lines = Object.values(SQL_MODULES).map((module) => {
+		const path = files.get(module.name);
+		const installed = path !== void 0 && (migrated === void 0 ? existsSync(resolve(config.root, path)) : migrated.has(module.name));
+		const tracked = config.blockNames.includes(module.name);
+		const mark = path === void 0 ? "◇" : installed ? tracked ? "●" : "○" : " ";
+		const requires = sqlLayout.entitlementsProvider && module.providerRequires ? module.providerRequires : module.requires;
+		modules.push({
+			name: module.name,
+			description: module.description,
+			installed,
+			tracked,
+			custom: path === void 0,
+			requires
+		});
+		const needs = requires.length > 0 ? ` (needs ${requires.join(", ")})` : "";
+		const integrates = module.integrates ?? [];
+		const works = integrates.includes("*") ? " (works with every installed module)" : integrates.length > 0 ? ` (works with ${integrates.join(", ")})` : "";
+		return `${mark} ${module.name.padEnd(15)} ${module.description}${needs}${works}`;
+	});
+	return {
+		code: 0,
+		data: { modules },
+		output: `${lines.join("\n")}\n\n● installed and in blocks   ○ installed, not in blocks   ◇ custom mode (the app implements it)`
+	};
+}
+//#endregion
+//#region src/cli/sql/print.ts
+async function printModule(config, args, names) {
+	const [name] = names;
+	if (name === void 0) throw new CliError("input_required", "Name one module.", {
+		missing: ["<module>"],
+		choices: { "<module>": Object.keys(SQL_MODULES) }
+	});
+	const module = SQL_MODULES[name];
+	if (!module) throw new CliError("usage", `Name one module: ${Object.keys(SQL_MODULES).join(", ")}`);
+	const body = moduleBody(module.name, await layout(config, args, [module.name]));
+	if (body === void 0) return {
+		code: 0,
+		data: {
+			module: module.name,
+			custom: true
+		},
+		output: `-- blocks.${module.name} is in custom mode: the app writes these functions.\n${customContracts([module.name], await layout(config, args, [module.name])).flatMap((contract) => contract.functions.map((fn) => `-- ${contract.schema}.${fn.name}(${contractSignature(fn, contract.idType)}) returns ${fn.returns.replaceAll("{id}", contract.idType)}`)).join("\n")}`
+	};
+	return {
+		code: 0,
+		output: body,
+		data: {
+			module: module.name,
+			custom: false,
+			sql: body
+		}
+	};
+}
+//#endregion
+export { listModules as n, printModule as t };