better-supabase 0.7.0 → 0.8.0

package/dist/cli/{openapi-BlRJ18s3.js → openapi-DWa4Ir1q.js}

@@ -1,9 +1,8 @@
-import { r as defineCliCommand } from "./command-CK14fP91.js";
-import { i as writeIfChanged, t as display } from "./io-DI1mTdSA.js";
-import { i as importExport } from "./config-NiPxAmUF.js";
+import { r as defineCliCommand } from "./command-DV-StG1x.js";
+import { t as display } from "./io-CFzJVJ68.js";
+import { a as importExport } from "./config-M-WzL9O2.js";
+import { n as staleResult, r as writeLine, t as fileState } from "./files-BVupXPIC.js";
 import { resolve } from "node:path";
-import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
 //#region src/cli/commands/openapi.ts
 const ARGS = {
 	action: {
@@ -41,17 +40,12 @@ async function runOpenApi(config, args) {
 		error: `${display(config.root, entry)} must export an OpenAPI document (createOpenApi(...)) as \`openapi\` or default.`
 	};
 	const contents = `${JSON.stringify(document, null, 2)}\n`;
-	const path = resolve(config.root, out);
-	if (args.check === true) return (existsSync(path) ? await readFile(path, "utf8") : void 0) === contents ? {
-		code: 0,
-		output: `${display(config.root, out)} is up to date.`
-	} : {
-		code: 1,
-		error: `${display(config.root, out)} is out of date. Run \`better-supabase openapi emit\`.`
-	};
+	const state = await fileState(config.root, out, contents);
+	if (args.check === true) return staleResult(state, "better-supabase openapi emit");
+	const { line } = await writeLine(state.path, contents, state.file);
 	return {
 		code: 0,
-		output: `${await writeIfChanged(path, contents) ? "Wrote" : "Unchanged"} ${display(config.root, out)}`
+		output: line
 	};
 }
 const openapiCommand = defineCliCommand({

package/dist/cli/prompts-BdeVmVpg.js

@@ -0,0 +1,2 @@
+import { t as createClackPrompter } from "./prompts-DZJB1nTw.js";
+export { createClackPrompter };

package/dist/cli/{prompts-BNcNfAve.js → prompts-DZJB1nTw.js}

@@ -1,4 +1,4 @@
-import { t as __commonJSMin } from "./rolldown-runtime-BPOCksWG.js";
+import { t as __commonJSMin } from "./rolldown-runtime-CMFfr-1z.js";
 import { styleText } from "node:util";
 import "node:path";
 import "node:fs";
@@ -1093,8 +1093,8 @@ const options = (choices) => choices.map((choice) => ({
 	label: choice.label,
 	...choice.hint ? { hint: choice.hint } : {}
 }));
-/** The @clack/prompts implementation; spinners write to stderr so stdout stays pipeable. */
-const clackPrompter = {
+/** The @clack/prompts implementation; spinners write to `output` (stderr in the bin) so stdout stays pipeable. */
+const createClackPrompter = (output) => ({
 	select: async (message, choices, initial) => {
 		const answer = await select({
 			message,
@@ -1122,13 +1122,13 @@ const clackPrompter = {
 		return isCancel(answer) ? void 0 : answer;
 	},
 	spinner: (message) => {
-		const spin = spinner({ output: process.stderr });
+		const spin = spinner({ output });
 		spin.start(message);
 		return () => {
 			spin.clear();
 		};
 	}
-};
+});
 /** Runs `task` behind a spinner when `prompts` is set. */
 async function withSpinner(prompts, message, task) {
 	const stop = prompts?.spinner(message);
@@ -1139,4 +1139,4 @@ async function withSpinner(prompts, message, task) {
 	}
 }
 //#endregion
-export { withSpinner as n, clackPrompter as t };
+export { withSpinner as n, createClackPrompter as t };

package/dist/cli/{rolldown-runtime-BPOCksWG.js → rolldown-runtime-CMFfr-1z.js}

@@ -1,3 +1,4 @@
+import { createRequire } from "node:module";
 //#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -20,5 +21,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	value: mod,
 	enumerable: true
 }) : target, mod));
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
 //#endregion
-export { __toESM as n, __commonJSMin as t };
+export { __require as n, __toESM as r, __commonJSMin as t };

package/dist/cli/run-DA6_lg3w.js

@@ -0,0 +1,389 @@
+import { r as __toESM } from "./rolldown-runtime-CMFfr-1z.js";
+import { c as parseArgs$2, i as joinRepeated, l as renderUsage, n as cliContext, o as listArgs, s as defineCommand, t as GLOBAL_ARGS, u as runCommand } from "./command-DV-StG1x.js";
+import { n as CliError, o as toCliError } from "./errors-CqTLXe2M.js";
+import { n as highlight, r as painter } from "./style-CB3vxgh0.js";
+import { t as VERSION } from "./version-B4k0aUxS.js";
+import { stripVTControlCharacters } from "node:util";
+import { resolve } from "node:path";
+//#region src/cli/builtin-commands.ts
+const BUILTIN = [
+	["init", {
+		load: () => import("./init-CVZ3s5kl.js").then((m) => m.initCommand),
+		description: "Writes better-supabase.config.ts, src/lib/supabase/index.ts and glue for the frameworks in package.json"
+	}],
+	["add", {
+		load: () => import("./add-1dc5wM5k.js").then((m) => m.addCommand),
+		description: "Adds glue for an integration to an existing project"
+	}],
+	["env", {
+		load: () => import("./env-vzBG90Um.js").then((m) => m.envCommand),
+		description: "Writes the local stack's URL and keys from `supabase status` to an env file, keeping its other lines"
+	}],
+	["keys", {
+		load: () => import("./keys-CJhtIxJ3.js").then((m) => m.keysCommand),
+		description: "Creates an ES256 signing key for the local stack, so local tokens verify through JWKS like hosted ones"
+	}],
+	["skills", {
+		load: () => import("./skills-CnO8QFS7.js").then((m) => m.skillsCommand),
+		description: "Installs the Agent Skills that ship with this version of better-supabase"
+	}],
+	["gen", {
+		load: () => import("./gen-DmVj3u4L.js").then((m) => m.genCommand),
+		description: "Writes the typed client from the database, then every other generated file the config sets up"
+	}],
+	["introspect", {
+		load: () => import("./introspect-BToGNfm-.js").then((m) => m.introspectCommand),
+		description: "Saves the database schema as a snapshot for offline gen"
+	}],
+	["openapi", {
+		load: () => import("./openapi-DWa4Ir1q.js").then((m) => m.openapiCommand),
+		description: "Writes the document your createOpenApi() module exports, so CI can check it for drift"
+	}],
+	["spec", {
+		load: () => import("./spec-T_0Bcyw7.js").then((m) => m.specCommand),
+		description: "Writes, checks or validates the OpenAPI and other spec documents your defineApi() module renders"
+	}],
+	["scaffold", {
+		load: () => import("./scaffold-CwQUMFRb.js").then((m) => m.scaffoldCommand),
+		description: "Writes an API module, its resource routes and an OpenAPI route for Hono or Next.js"
+	}],
+	["seed", {
+		load: () => import("./seed-DOmit9Hq.js").then((m) => m.seedCommand),
+		description: "Renders the fixtures from defineSeed() (better-supabase/testing) to SQL"
+	}],
+	["doctor", {
+		load: () => import("./doctor-VcDtuusV.js").then((m) => m.doctorCommand),
+		description: "Checks RLS, indexes, drift, auth config and env files; exits 1 on errors, or on warnings with --strict"
+	}],
+	["sql", {
+		load: () => import("./sql-DJrNDxQm.js").then((m) => m.sqlCommand),
+		description: "Lists, adds, syncs, upgrades and prints SQL modules"
+	}],
+	["config", {
+		load: () => import("./config-C2Pz2_4A.js").then((m) => m.configCommand),
+		description: "Prints the resolved config: the file it came from, the active environment and every option with its default"
+	}],
+	["codemod", {
+		load: () => import("./codemod-JVlTQQG2.js").then((m) => m.codemodCommand),
+		description: "Rewrites imports and calls for renamed better-supabase APIs"
+	}]
+];
+/** A fresh registry of the built-in commands, for `createCli`. */
+function builtinCommands() {
+	return new Map(BUILTIN);
+}
+//#endregion
+//#region src/cli/legacy.ts
+const ARRAY_FLAGS = /* @__PURE__ */ new Set([
+	"schema",
+	"only",
+	"ignore",
+	"agent",
+	"block",
+	"with",
+	"explain"
+]);
+const BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
+	"check",
+	"watch",
+	"json",
+	"strict",
+	"help",
+	"version",
+	"force",
+	"dry-run",
+	"no-color",
+	"yes",
+	"local",
+	"rotate",
+	"apply",
+	"print",
+	"global",
+	"stats",
+	"fix-grants"
+]);
+function parseArgs$1(argv) {
+	const flags = {};
+	const positionals = [];
+	for (let index = 0; index < argv.length; index += 1) {
+		const token = argv[index];
+		if (token === void 0) continue;
+		if (token === "--") {
+			positionals.push(...argv.slice(index + 1));
+			break;
+		}
+		if (token === "-h") {
+			flags["help"] = true;
+			continue;
+		}
+		if (token.startsWith("--")) {
+			const body = token.slice(2);
+			const eq = body.indexOf("=");
+			if (eq !== -1) {
+				setFlag(flags, body.slice(0, eq), body.slice(eq + 1));
+				continue;
+			}
+			const next = argv[index + 1];
+			if (!BOOLEAN_FLAGS.has(body) && next !== void 0 && !next.startsWith("-")) {
+				setFlag(flags, body, next);
+				index += 1;
+				continue;
+			}
+			flags[body] = true;
+			continue;
+		}
+		positionals.push(token);
+	}
+	return {
+		command: positionals[0],
+		rest: positionals.slice(1),
+		flags
+	};
+}
+function setFlag(flags, name, value) {
+	if (ARRAY_FLAGS.has(name)) {
+		const current = flags[name];
+		const pieces = value.split(",").map((item) => item.trim()).filter(Boolean);
+		flags[name] = typeof current === "object" ? [...current, ...pieces] : pieces;
+		return;
+	}
+	flags[name] = value;
+}
+/**
+* Wraps a `(context) => CommandResult` command as a citty command. Its flags
+* are parsed the way 0.2 parsed them, because it declares no citty args.
+*/
+function legacyCommand(name, command, help) {
+	return defineCommand({
+		meta: {
+			name,
+			description: help ?? ""
+		},
+		run: ({ rawArgs, data }) => {
+			const parsed = parseArgs$1([name, ...rawArgs]);
+			const context = cliContext(data);
+			return command({
+				...context,
+				env: { ...context.env },
+				args: parsed
+			});
+		}
+	});
+}
+//#endregion
+//#region src/cli/output.ts
+const document = (value) => JSON.stringify(value, null, 2);
+/**
+* A command's result. Under `--json`, stdout gets the command's `data`, or
+* `{ "message": output }` when it has none, or Problem Details when it failed
+* without data; the text output moves to stderr as a diagnostic.
+*/
+function renderResult(result, options) {
+	if (!options.json) return {
+		...result.output ? { stdout: highlight(result.output, options.paint) } : {},
+		...result.error ? { stderr: options.paint("red", result.error) } : {}
+	};
+	if (result.data === void 0 && result.error) return {
+		stdout: document(new CliError("failed", result.error, { exitCode: result.code }).problem),
+		...result.output ? { stderr: result.output } : {}
+	};
+	const diagnostics = [...result.data !== void 0 && result.output ? [result.output] : [], ...result.error ? [result.error] : []];
+	return {
+		stdout: document(result.data ?? { message: result.output ?? "" }),
+		...diagnostics.length > 0 ? { stderr: diagnostics.join("\n") } : {}
+	};
+}
+/** An error that stopped the run, with the usage text for usage errors. */
+function renderError(error, options) {
+	if (options.json) return { stdout: document(error.problem) };
+	return { stderr: options.usage ? `${error.message}\n\n${options.usage}` : error.message };
+}
+//#endregion
+//#region src/cli/run.ts
+/** Global options that take a value, so the command name is the token after them. */
+const GLOBAL_VALUE_FLAGS = new Set(Object.entries(GLOBAL_ARGS).flatMap(([name, definition]) => definition.type === "string" ? [`--${name}`] : []));
+/** The index of the command name: the first token that is not an option or an option's value. */
+function commandIndex(argv) {
+	for (let index = 0; index < argv.length; index += 1) {
+		const token = argv[index];
+		if (token === "--") return -1;
+		if (!token.startsWith("-")) return index;
+		if (GLOBAL_VALUE_FLAGS.has(token)) index += 1;
+	}
+	return -1;
+}
+function isCommandResult(value) {
+	return typeof value === "object" && value !== null && "code" in value && typeof value.code === "number";
+}
+const SHOWS_USAGE = /* @__PURE__ */ new Set(["usage", "unknown_command"]);
+function withoutPrompts(io) {
+	const { prompts: _prompts, ...rest } = io;
+	return rest;
+}
+/** The registered command closest to a mistyped one, if it is close enough to be a typo. */
+async function suggestCommand(name, names) {
+	if (names.length === 0) return void 0;
+	const { closest, distance } = await import("./fastest-levenshtein-CF7BCi9l.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;
+}
+/** A CLI over its own command registry, so tests and embedders don't share state through the module. */
+function createCli(init) {
+	const commands = new Map(init.commands);
+	const root = defineCommand({
+		meta: {
+			name: "better-supabase",
+			version: VERSION,
+			description: "Typed Supabase: codegen, doctor, the SQL modules and project setup"
+		},
+		args: GLOBAL_ARGS,
+		subCommands: () => Object.fromEntries([...commands].map(([name, entry]) => [name, "command" in entry ? entry.command : defineCommand({ meta: {
+			name,
+			description: entry.description
+		} })]))
+	});
+	const help = async (command, color = false) => {
+		const load = command === void 0 ? void 0 : commands.get(command)?.load;
+		const text = load ? await renderUsage(await load(), root) : await renderUsage(root);
+		return color ? text : stripVTControlCharacters(text);
+	};
+	const run = async (argv, options = {}) => {
+		const stdout = [];
+		const stderr = [];
+		const io = options.io ?? {
+			stdout: (text) => {
+				stdout.push(text);
+			},
+			stderr: (text) => {
+				stderr.push(text);
+			}
+		};
+		const out = (text) => {
+			const line = text.endsWith("\n") ? text : `${text}\n`;
+			if (options.io) stdout.push(line);
+			io.stdout(line);
+		};
+		const fail = (text) => {
+			const line = text.endsWith("\n") ? text : `${text}\n`;
+			if (options.io) stderr.push(line);
+			io.stderr(line);
+		};
+		const paint = painter(io.color);
+		const usage = (command) => help(command, io.color === true);
+		const finish = (code) => ({
+			code,
+			stdout: stdout.join(""),
+			stderr: stderr.join("")
+		});
+		const index = commandIndex(argv);
+		const name = index === -1 ? void 0 : argv[index];
+		const rest = index === -1 ? [...argv] : argv.toSpliced(index, 1);
+		const flags = new Set(rest.slice(0, rest.includes("--") ? rest.indexOf("--") : void 0));
+		const wantsHelp = flags.has("--help") || flags.has("-h");
+		const json = flags.has("--json");
+		const report = (rendered) => {
+			if (rendered.stdout) out(rendered.stdout);
+			if (rendered.stderr) fail(rendered.stderr);
+		};
+		const reportError = async (cause) => {
+			const error = toCliError(cause);
+			const shown = error.code === "usage" ? new CliError("usage", stripVTControlCharacters(error.message)) : error;
+			report(renderError(shown, {
+				json,
+				paint,
+				...SHOWS_USAGE.has(error.code) ? { usage: await usage(error.code === "usage" ? name : void 0) } : {}
+			}));
+			return finish(error.exitCode);
+		};
+		if (flags.has("--version") || name === "version") {
+			out(json ? JSON.stringify({ version: VERSION }) : VERSION);
+			return finish(0);
+		}
+		if (name === void 0) {
+			(wantsHelp ? out : fail)(await usage());
+			return finish(wantsHelp ? 0 : 2);
+		}
+		if (name === "help") {
+			out(await usage(rest.find((token) => !token.startsWith("-"))));
+			return finish(0);
+		}
+		const load = commands.get(name)?.load;
+		if (!load) {
+			const suggestion = await suggestCommand(name, [...commands.keys()]);
+			return reportError(new CliError("unknown_command", `Unknown command "${name}".${suggestion ? ` Did you mean "${suggestion}"?` : ""}`, suggestion ? { suggestion } : {}));
+		}
+		if (wantsHelp) {
+			out(await usage(name));
+			return finish(0);
+		}
+		let context;
+		let command;
+		try {
+			const [loaded, { discoverConfig, loadConfig }, { configEnvironment, parseEnv }] = await Promise.all([
+				load(),
+				import("./config-DpbF8ML3.js"),
+				import("./env-zHJtMIBo.js")
+			]);
+			command = loaded;
+			const globals = parseArgs$2(rest, GLOBAL_ARGS);
+			const cwd = resolve(options.cwd ?? ".", globals.cwd ?? ".");
+			const env = parseEnv(options.env ?? {});
+			const environment = configEnvironment(globals.env, env);
+			const reloadConfig = () => loadConfig(cwd, globals.config, environment).catch((cause) => {
+				throw cause instanceof CliError ? cause : new CliError("config_invalid", toCliError(cause).message, { cause });
+			});
+			const config = await reloadConfig();
+			const configFile = discoverConfig(cwd, globals.config);
+			const interactive = globals.json !== true && globals.yes !== true && env.CI === void 0;
+			context = {
+				cwd,
+				config,
+				...configFile ? { configFile } : {},
+				reloadConfig,
+				io: interactive ? io : withoutPrompts(io),
+				env,
+				json: globals.json === true,
+				signal: options.signal
+			};
+		} catch (cause) {
+			return reportError(cause);
+		}
+		try {
+			const { result } = await runCommand(command, {
+				rawArgs: joinRepeated(rest, listArgs(command)),
+				data: context
+			});
+			if (!isCommandResult(result)) return finish(0);
+			report(renderResult(result, {
+				json,
+				paint
+			}));
+			return finish(result.code);
+		} catch (cause) {
+			return reportError(cause);
+		}
+	};
+	return {
+		run,
+		help,
+		commandNames: () => [...commands.keys()],
+		commandDescriptions: () => new Map([...commands].flatMap(([name, entry]) => "description" in entry ? [[name, entry.description]] : [])),
+		register: (name, command) => {
+			commands.set(name, {
+				load: () => Promise.resolve(command),
+				command
+			});
+		}
+	};
+}
+/** The CLI the `better-supabase` bin runs, with every built-in command. */
+const defaultCli = createCli({ commands: builtinCommands() });
+const run = (argv, options) => defaultCli.run(argv, options);
+const help = (command, color) => defaultCli.help(command, color);
+/** The names `run()` dispatches, registered commands included. */
+const commandNames = () => defaultCli.commandNames();
+function registerCommand(name, command, help) {
+	defaultCli.register(name, typeof command === "function" ? legacyCommand(name, command, help) : command);
+}
+//#endregion
+export { run as i, help as n, registerCommand as r, commandNames as t };