better-supabase 0.3.0 → 0.4.0

package/dist/cli/rolldown-runtime-BPOCksWG.js

@@ -0,0 +1,24 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+export { __toESM as n, __commonJSMin as t };

package/dist/cli/run-CP20LKk_.js

@@ -0,0 +1,347 @@
+import { n as __toESM } from "./rolldown-runtime-BPOCksWG.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-CK14fP91.js";
+import { n as CliError, r as toCliError } from "./errors-4v4DTtda.js";
+import { n as highlight, r as painter } from "./style-C0NFdJRL.js";
+import { t as VERSION } from "./version-5mW_8sY1.js";
+import { stripVTControlCharacters } from "node:util";
+import { resolve } from "node:path";
+//#region src/cli/legacy.ts
+const ARRAY_FLAGS = /* @__PURE__ */ new Set([
+	"schema",
+	"only",
+	"ignore",
+	"agent",
+	"kit",
+	"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
+const COMMANDS = /* @__PURE__ */ new Map([
+	["init", {
+		load: () => import("./init-ClnxRYBF.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("./init-ClnxRYBF.js").then((m) => m.addCommand),
+		description: "Adds glue for an integration to an existing project"
+	}],
+	["env", {
+		load: () => import("./env-jIFUADLY.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-ByKHnvP9.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-LJJIhLFR.js").then((m) => m.skillsCommand),
+		description: "Installs the Agent Skills that ship with this version of better-supabase"
+	}],
+	["gen", {
+		load: () => import("./gen-D5cLCULx.js").then((m) => m.genCommand),
+		description: "Writes database.types.ts, generated.ts and its metadata module from the database"
+	}],
+	["introspect", {
+		load: () => import("./introspect-DxqfkVIv.js").then((m) => m.introspectCommand),
+		description: "Saves the database schema as a snapshot for offline gen"
+	}],
+	["openapi", {
+		load: () => import("./openapi-8WHjxiTJ.js").then((m) => m.openapiCommand),
+		description: "Writes the document your createOpenApi() module exports, so CI can check it for drift"
+	}],
+	["seed", {
+		load: () => import("./seed-5J6eu_Xg.js").then((m) => m.seedCommand),
+		description: "Renders the fixtures from defineSeed() (better-supabase/testing) to SQL"
+	}],
+	["doctor", {
+		load: () => import("./doctor-BOym3mbL.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-D4VbqmXi.js").then((m) => m.sqlCommand),
+		description: "Lists, adds, syncs and prints SQL kit modules"
+	}]
+]);
+function registerCommand(name, command, help) {
+	const def = typeof command === "function" ? legacyCommand(name, command, help) : command;
+	COMMANDS.set(name, {
+		load: () => Promise.resolve(def),
+		command: def
+	});
+}
+const ROOT = defineCommand({
+	meta: {
+		name: "better-supabase",
+		version: VERSION,
+		description: "Typed Supabase: codegen, doctor, the SQL kit 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
+	} })]))
+});
+/** The usage text for the CLI, or for one command; plain unless `color` is set. */
+async function help(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);
+}
+/** 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 (token === "--cwd" || token === "--config") index += 1;
+	}
+	return -1;
+}
+function isCommandResult(value) {
+	return typeof value === "object" && value !== null && "code" in value && typeof value.code === "number";
+}
+/** The names `run()` dispatches, registered commands included. */
+function commandNames() {
+	return [...COMMANDS.keys()];
+}
+/** The registered command closest to a mistyped one, if it is close enough to be a typo. */
+async function suggestCommand(name) {
+	const names = [...COMMANDS.keys()];
+	if (names.length === 0) return void 0;
+	const { closest, distance } = await import("./fastest-levenshtein-CFN-lNDv.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;
+}
+const SHOWS_USAGE = /* @__PURE__ */ new Set(["usage", "unknown_command"]);
+function withoutPrompts(io) {
+	const { prompts: _prompts, ...rest } = io;
+	return rest;
+}
+/** Runs the CLI. Never exits the process; returns the exit code and output. */
+async function run(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);
+		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, { loadConfig }, { parseEnv }] = await Promise.all([
+			load(),
+			import("./config-SSKSTUl2.js"),
+			import("./env-BZ0uy8XK.js")
+		]);
+		command = loaded;
+		const globals = parseArgs$2(rest, GLOBAL_ARGS);
+		const cwd = resolve(options.cwd ?? ".", globals.cwd ?? ".");
+		const env = parseEnv(options.env ?? {});
+		context = {
+			cwd,
+			config: await loadConfig(cwd, globals.config).catch((cause) => {
+				throw cause instanceof CliError ? cause : new CliError("config_invalid", toCliError(cause).message, { cause });
+			}),
+			io: globals.json !== true && globals.yes !== true && env.CI === void 0 ? 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);
+	}
+}
+//#endregion
+export { run as i, help as n, registerCommand as r, commandNames as t };

package/dist/cli/seed-5J6eu_Xg.js

@@ -0,0 +1,98 @@
+import { r as defineCliCommand } from "./command-CK14fP91.js";
+import { r as writeIfChanged, t as display } from "./io-k41_z-jT.js";
+import { r as importExport, s as stdinDatabaseUrl, t as databaseUrl } from "./config-D9R0o1LH.js";
+import { n as withSpinner } from "./prompts-BNcNfAve.js";
+import { t as connect } from "./db-DOBPt660.js";
+import { resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { isSeed } from "better-supabase/testing";
+//#region src/cli/commands/seed.ts
+const ARGS = {
+	check: {
+		type: "boolean",
+		description: "Fail when the SQL file is out of date"
+	},
+	apply: {
+		type: "boolean",
+		description: "Also insert the rows into the database ($DATABASE_URL, --db-url-stdin, or the local stack)"
+	},
+	entry: {
+		type: "string",
+		description: "Defaults to seed.entry (supabase/seed.ts)",
+		valueHint: "file"
+	},
+	out: {
+		type: "string",
+		description: "Defaults to seed.output (supabase/seeds/000_better_supabase.sql)",
+		valueHint: "file"
+	},
+	"db-url-stdin": {
+		type: "boolean",
+		description: "Read the connection string from stdin instead of $DATABASE_URL or the config"
+	}
+};
+const HEADER = "-- Generated by `better-supabase seed`";
+async function runSeed(config, args, env, open = connect, dbUrl) {
+	const entry = args.entry ?? config.seed.entry;
+	const out = args.out ?? config.seed.output;
+	const seed = await importExport(resolve(config.root, entry), "seed");
+	if (!isSeed(seed)) return {
+		code: 1,
+		error: `${display(config.root, entry)} must export defineSeed(...) as \`seed\` or default.`
+	};
+	const statements = seed.statements();
+	const contents = `${HEADER} from ${display(config.root, entry)}. Do not edit.\n\n${statements.join("\n\n")}\n`;
+	const path = resolve(config.root, out);
+	const current = existsSync(path) ? await readFile(path, "utf8") : void 0;
+	if (args.check === true) return current === 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 seed\`.`
+	};
+	if (current !== void 0 && !current.startsWith(HEADER)) return {
+		code: 1,
+		error: `${display(config.root, out)} was not written by better-supabase; pass --out to write elsewhere.`
+	};
+	const lines = [`${await writeIfChanged(path, contents) ? "Wrote" : "Unchanged"} ${display(config.root, out)} (${statements.length} table${statements.length === 1 ? "" : "s"})`];
+	if (args.apply === true) {
+		const { client, close } = await open(await databaseUrl(config, env, dbUrl));
+		try {
+			await client.query("begin");
+			for (const text of statements) await client.query(text);
+			await client.query("commit");
+		} catch (error) {
+			await client.query("rollback");
+			throw error;
+		} finally {
+			await close();
+		}
+		lines.push("Inserted the fixtures (existing rows were kept).");
+	}
+	const toml = resolve(config.root, "supabase/config.toml");
+	const seedPath = out.startsWith("supabase/") ? `./${out.slice(9)}` : out;
+	if (existsSync(toml)) {
+		const text = await readFile(toml, "utf8");
+		const folder = seedPath.replace(/[^/]+$/, "");
+		if (!text.includes(seedPath) && !text.includes(`${folder}*`)) lines.push("", "Add it to supabase/config.toml so `supabase db reset` runs it:", "  [db.seed]", `  sql_paths = ["./seed.sql", "${seedPath}"]`);
+	}
+	return {
+		code: 0,
+		output: lines.join("\n")
+	};
+}
+const seedCommand = defineCliCommand({
+	meta: {
+		name: "seed",
+		description: "Renders the fixtures from defineSeed() (better-supabase/testing) to SQL"
+	},
+	args: ARGS,
+	run: async (args, { config, env, io }) => {
+		const dbUrl = await stdinDatabaseUrl(args["db-url-stdin"], io);
+		return withSpinner(args.apply === true ? io.prompts : void 0, "Inserting the seed rows", () => runSeed(config, args, env, connect, dbUrl));
+	}
+});
+//#endregion
+export { seedCommand };

package/dist/cli/skills-LJJIhLFR.js

@@ -0,0 +1,137 @@
+import { a as list, r as defineCliCommand } from "./command-CK14fP91.js";
+import { r as writeIfChanged, t as display } from "./io-k41_z-jT.js";
+import { t as byCodePoint } from "./compare-BmIWVEui.js";
+import { dirname, join, resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { readFile, readdir } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
+//#region src/cli/commands/skills.ts
+const ARGS = {
+	action: {
+		type: "positional",
+		required: false,
+		description: "list or install"
+	},
+	agent: {
+		type: "string",
+		description: "cursor (.cursor/skills), claude (.claude/skills) or agents (.agents/skills). Defaults to the agent folders the project has, else agents",
+		valueHint: "names"
+	},
+	global: {
+		type: "boolean",
+		description: "Install into your home directory instead of the project"
+	},
+	check: {
+		type: "boolean",
+		description: "Fail when installed skills differ from this version"
+	},
+	from: {
+		type: "string",
+		description: "Read skills from this folder instead of the package",
+		valueHint: "dir"
+	}
+};
+const AGENT_DIRS = {
+	cursor: ".cursor/skills",
+	claude: ".claude/skills",
+	agents: ".agents/skills"
+};
+const isAgent = (name) => name in AGENT_DIRS;
+/** The `skills/` folder of the `better-supabase` package this CLI depends on. */
+function skillsRoot() {
+	const root = join(dirname(fileURLToPath(import.meta.resolve("better-supabase/package.json"))), "skills");
+	if (!existsSync(root)) throw new Error("Could not find the better-supabase skills folder.");
+	return root;
+}
+async function readTree(root, prefix = "") {
+	const files = [];
+	const entries = await readdir(join(root, prefix), { withFileTypes: true });
+	for (const entry of entries.sort((a, b) => byCodePoint(a.name, b.name))) {
+		const path = prefix ? `${prefix}/${entry.name}` : entry.name;
+		if (entry.isDirectory()) files.push(...await readTree(root, path));
+		else if (entry.isFile()) files.push({
+			path,
+			contents: await readFile(join(root, path), "utf8")
+		});
+	}
+	return files;
+}
+async function loadSkills(root = skillsRoot()) {
+	const skills = [];
+	for (const entry of (await readdir(root, { withFileTypes: true })).filter((item) => item.isDirectory())) {
+		const folder = join(root, entry.name);
+		if (!existsSync(join(folder, "SKILL.md"))) continue;
+		const tree = await readTree(folder);
+		const main = tree.find((file) => file.path === "SKILL.md");
+		const files = [main, ...tree.filter((file) => file !== main)];
+		const description = /^description:\s*(.+)$/m.exec(main.contents)?.[1] ?? "";
+		skills.push({
+			name: entry.name,
+			description,
+			contents: main.contents,
+			files
+		});
+	}
+	return skills.sort((a, b) => byCodePoint(a.name, b.name));
+}
+async function runSkills(config, args, env) {
+	const [action] = args._;
+	const skills = await loadSkills(args.from ?? skillsRoot());
+	if (action === "list") return {
+		code: 0,
+		output: skills.map((skill) => `${skill.name}\n  ${skill.description}`).join("\n")
+	};
+	if (action !== "install") return {
+		code: 2,
+		error: `${action ? `Unknown skills action "${action}"` : "Name an action"}. Use \`skills list\` or \`skills install\`.`
+	};
+	const global = args.global === true;
+	const base = global ? env.HOME ?? homedir() : config.root;
+	const requested = list(args.agent);
+	const unknown = requested.filter((name) => !isAgent(name));
+	if (unknown.length > 0) return {
+		code: 2,
+		error: `Unknown agent ${unknown.join(", ")}. Use ${Object.keys(AGENT_DIRS).join(", ")}.`
+	};
+	const detected = Object.keys(AGENT_DIRS).filter((agent) => existsSync(join(base, AGENT_DIRS[agent].split("/")[0])));
+	const agents = requested.length > 0 ? requested.filter(isAgent) : detected.length > 0 ? detected : ["agents"];
+	const check = args.check === true;
+	const lines = [];
+	const stale = [];
+	const targets = agents.flatMap((agent) => skills.flatMap((skill) => skill.files.map((file) => ({
+		file,
+		relativePath: join(AGENT_DIRS[agent], skill.name, file.path)
+	}))));
+	for (const { file, relativePath } of targets) {
+		const path = resolve(base, relativePath);
+		const shown = global ? `~/${relativePath}` : display(config.root, relativePath);
+		if (check) {
+			if ((existsSync(path) ? await readFile(path, "utf8") : void 0) !== file.contents) stale.push(shown);
+			continue;
+		}
+		lines.push(`${await writeIfChanged(path, file.contents) ? "Wrote" : "Unchanged"} ${shown}`);
+	}
+	if (check) return stale.length === 0 ? {
+		code: 0,
+		output: "Skills are up to date."
+	} : {
+		code: 1,
+		error: `Out of date: ${stale.join(", ")}. Run \`better-supabase skills install\`.`
+	};
+	return {
+		code: 0,
+		output: lines.join("\n")
+	};
+}
+const skillsCommand = defineCliCommand({
+	meta: {
+		name: "skills",
+		description: "Installs the Agent Skills that ship with this version of better-supabase"
+	},
+	args: ARGS,
+	lists: ["agent"],
+	run: (args, { config, env }) => runSkills(config, args, env)
+});
+//#endregion
+export { skillsCommand };