better-supabase 0.12.0 → 0.13.0

package/dist/cli/env-cbCEa79W.js

@@ -0,0 +1 @@
+export { n as envCommand } from "./env-BrLZfqsL.js";

package/dist/cli/errors-BTe6A15O.js

@@ -0,0 +1,98 @@
+//#region src/cli/core/errors.ts
+/** Each code has a heading on this page, so `type` links to its explanation. */
+const CLI_ERRORS_URL = "https://bettersupabase.com/docs/cli/errors";
+const ERRORS = {
+	usage: ["Invalid arguments", 2],
+	unknown_command: ["Unknown command", 2],
+	unknown_flag: ["Unknown flag", 2],
+	invalid_value: ["Invalid value", 2],
+	command_moved: ["Command moved", 2],
+	flag_renamed: ["Flag renamed", 2],
+	missing_value: ["Missing value", 2],
+	outside_root: ["Path outside the project", 2],
+	config_not_found: ["Config file not found", 2],
+	config_invalid: ["Invalid config", 2],
+	env_invalid: ["Invalid environment variable", 2],
+	not_found: ["File not found", 1],
+	invalid_input: ["Invalid input file", 1],
+	dependency_missing: ["Missing dependency", 1],
+	database_unreachable: ["Database unreachable", 1],
+	supabase_cli_missing: ["Supabase CLI not found", 1],
+	supabase_cli_failed: ["Supabase CLI failed", 1],
+	network_error: ["No response", 1],
+	request_failed: ["Request failed", 1],
+	auth_required: ["Authentication required", 3],
+	integrity_failed: ["Integrity check failed", 1],
+	generator_failed: ["Generator failed", 1],
+	check_failed: ["Out of date", 1],
+	file_conflict: ["File not written by better-supabase", 1],
+	findings: ["Checks failed", 1],
+	input_required: ["Input required", 3],
+	consent_required: ["Consent required", 3],
+	cancelled: ["Cancelled", 130],
+	failed: ["Command failed", 1],
+	internal: ["Unexpected error", 1]
+};
+Object.keys(ERRORS);
+/** An error the CLI reports as text, or as Problem Details under `--json`. */
+var CliError = class extends Error {
+	name = "CliError";
+	code;
+	exitCode;
+	problem;
+	next;
+	constructor(code, message, options = {}) {
+		super(message, options.cause === void 0 ? {} : { cause: options.cause });
+		const [title, defaultExit] = ERRORS[code];
+		const { exitCode = defaultExit, cause: _cause, next = [], ...extensions } = options;
+		this.code = code;
+		this.exitCode = exitCode;
+		this.next = next;
+		this.problem = {
+			type: `${CLI_ERRORS_URL}#${code}`,
+			title,
+			detail: message,
+			code,
+			exitCode,
+			...extensions
+		};
+	}
+};
+/** Citty's own argument errors. */
+function isCittyUsageError(cause) {
+	return cause instanceof Error && cause.name === "CLIError";
+}
+const MISSING_POSITIONAL = /^Missing required positional argument: (\S+)$/;
+/**
+* Any thrown value as a `CliError`: a missing required positional becomes
+* `input_required`, citty's other argument errors `usage`, the rest
+* `internal`.
+*/
+function toCliError(cause) {
+	if (cause instanceof CliError) return cause;
+	const positional = isCittyUsageError(cause) ? MISSING_POSITIONAL.exec(cause.message)?.[1] : void 0;
+	if (positional !== void 0) {
+		const name = positional.toLowerCase();
+		return new CliError("input_required", `<${name}> is required.`, { missing: [`<${name}>`] });
+	}
+	if (isCittyUsageError(cause)) return new CliError("usage", cause.message);
+	return new CliError("internal", errorText(cause), { cause });
+}
+/** A thrown value as the message to print. */
+const errorText = (cause) => cause instanceof Error ? cause.message : String(cause);
+/** A step that threw, as a failed command result. */
+const failedResult = (cause) => ({
+	code: 1,
+	error: errorText(cause)
+});
+/**
+* The `values` that `isValid` accepts, or a usage message naming the ones it
+* rejects and the `available` names.
+*/
+function parseNames(values, isValid, noun, available) {
+	const unknown = values.filter((value) => !isValid(value));
+	if (unknown.length > 0) return `Unknown ${noun} ${unknown.map((value) => `"${value}"`).join(", ")}. Available: ${available.join(", ")}.`;
+	return values.filter(isValid);
+}
+//#endregion
+export { parseNames as a, failedResult as i, CliError as n, toCliError as o, errorText as r, CLI_ERRORS_URL as t };

package/dist/cli/exec--Q1ZEWUW.js

@@ -0,0 +1,463 @@
+import { n as CliError, r as errorText } from "./errors-BTe6A15O.js";
+import { t as EXEC_CHANNEL } from "./trace-VbdO6bcN.js";
+import { s as findUp } from "./supabase-toml-CncmQbO0.js";
+import { t as PROCESS_ENV } from "./env-DMgjB_4y.js";
+import { channel } from "node:diagnostics_channel";
+import { closeSync, existsSync, openSync, readSync, statSync } from "node:fs";
+import { basename, delimiter, dirname, join, normalize, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { cwd } from "node:process";
+import { spawn } from "node:child_process";
+import { pipeline } from "node:stream/promises";
+import { PassThrough } from "node:stream";
+import readline from "node:readline";
+//#region ../../node_modules/.pnpm/tinyexec@1.3.1/node_modules/tinyexec/dist/main.mjs
+const isPathLikePattern = /^path$/i;
+const defaultEnvPathInfo = {
+	key: "PATH",
+	value: ""
+};
+function getPathFromEnv(env) {
+	for (const key in env) {
+		if (!Object.prototype.hasOwnProperty.call(env, key) || !isPathLikePattern.test(key)) continue;
+		const value = env[key];
+		if (!value) return defaultEnvPathInfo;
+		return {
+			key,
+			value
+		};
+	}
+	return defaultEnvPathInfo;
+}
+function addNodeBinToPath(cwd, path) {
+	const parts = path.value.split(delimiter);
+	const nodeBinPaths = [];
+	let currentPath = typeof cwd === "string" ? cwd : fileURLToPath(cwd, { windows: false });
+	let lastPath;
+	do {
+		nodeBinPaths.push(resolve(currentPath, "node_modules", ".bin"));
+		lastPath = currentPath;
+		currentPath = dirname(currentPath);
+	} while (currentPath !== lastPath);
+	nodeBinPaths.push(dirname(process.execPath));
+	const newPath = nodeBinPaths.concat(parts).join(delimiter);
+	return {
+		key: path.key,
+		value: newPath
+	};
+}
+function computeEnv(cwd, env, nodePath = true) {
+	const envWithDefault = {
+		...process.env,
+		...env
+	};
+	if (!nodePath) return envWithDefault;
+	const envPathInfo = addNodeBinToPath(cwd, getPathFromEnv(envWithDefault));
+	envWithDefault[envPathInfo.key] = envPathInfo.value;
+	return envWithDefault;
+}
+const combineStreams = (streams) => {
+	let streamCount = streams.length;
+	const combined = new PassThrough();
+	const maybeEmitEnd = () => {
+		if (--streamCount === 0) combined.end();
+	};
+	for (const stream of streams) pipeline(stream, combined, { end: false }).then(maybeEmitEnd).catch(maybeEmitEnd);
+	return combined;
+};
+const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+const shebangRegExp = /^#!\s*(.+)/;
+const isWindowsExecutableRegExp = /\.(?:com|exe)$/i;
+const isNodeModulesCmdRegExp = /node_modules[\\/]\.bin[\\/][^\\/]+\.cmd$/i;
+const isWindows = process.platform === "win32";
+const defaultPathExt = [
+	".EXE",
+	".CMD",
+	".BAT",
+	".COM"
+];
+const noPathExt = [""];
+/**
+* Normalizes the command and arguments to work cross-platform.
+* On Windows, this basically handles things like shebangs, calling
+* `node_modules/.bin` commands, and escaping meta characters.
+* On other platforms, it just returns the command and arguments as-is.
+*/
+function normalizeSpawnCommand(command, args = [], options = {}) {
+	if (options.shell === true || !isWindows) return {
+		command,
+		args,
+		options
+	};
+	let file = resolveCommand(command, options);
+	let shebang = null;
+	if (file !== null) {
+		const size = 150;
+		const buffer = Buffer.alloc(size);
+		let fd = null;
+		try {
+			fd = openSync(file, "r");
+			readSync(fd, buffer, 0, size, 0);
+		} catch {} finally {
+			if (fd !== null) closeSync(fd);
+		}
+		const match = buffer.toString().match(shebangRegExp);
+		if (match !== null) {
+			const line = match[1].trim();
+			const separatorIndex = line.indexOf(" ");
+			const path = separatorIndex !== -1 ? line.slice(0, separatorIndex) : line;
+			const argument = separatorIndex !== -1 ? line.slice(separatorIndex + 1) : "";
+			const binary = basename(path);
+			shebang = binary === "env" ? argument || null : binary;
+		}
+	}
+	if (shebang !== null && file !== null) {
+		args = [file, ...args];
+		command = shebang;
+		file = resolveCommand(command, options);
+	}
+	if (file === null || !isWindowsExecutableRegExp.test(file)) {
+		const needsDoubleEscapeMetaChars = file !== null && isNodeModulesCmdRegExp.test(file);
+		command = normalize(command);
+		command = command.replace(metaCharsRegExp, "^$1");
+		args = args.map((arg) => {
+			arg = arg.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"");
+			arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+			arg = `"${arg}"`;
+			arg = arg.replace(metaCharsRegExp, "^$1");
+			if (needsDoubleEscapeMetaChars) arg = arg.replace(metaCharsRegExp, "^$1");
+			return arg;
+		});
+		args = [
+			"/d",
+			"/s",
+			"/c",
+			`"${[command, ...args].join(" ")}"`
+		];
+		command = options.env?.comspec ?? "cmd.exe";
+		options = {
+			...options,
+			windowsVerbatimArguments: true
+		};
+	}
+	return {
+		command,
+		args,
+		options
+	};
+}
+/**
+* Resolves the command to an absolute path if possible.
+* Handles things like traversing PATH and adding extensions from PATHEXT
+*/
+function resolveCommand(command, options) {
+	const cwd$3 = (options.cwd ?? cwd()).toString();
+	const env = options.env ?? process.env;
+	const PATH = getPathFromEnv(env).value;
+	const pathEnv = command.includes("/") || command.includes("\\") ? [""] : [cwd$3, ...PATH.split(delimiter)];
+	let pathExt = env.PATHEXT ? env.PATHEXT.split(delimiter) : defaultPathExt;
+	if (command.includes(".") && pathExt[0] !== "") pathExt = ["", ...pathExt];
+	for (const extensions of [pathExt, noPathExt]) for (const path of pathEnv) {
+		const unquoted = path.startsWith("\"") && path.endsWith("\"") && path.length > 1 ? path.slice(1, -1) : path;
+		const dest = resolve(cwd$3, unquoted, command);
+		for (const ext of extensions) {
+			const destWithExt = dest + ext;
+			try {
+				if (statSync(destWithExt).isFile()) return destWithExt;
+			} catch {}
+		}
+	}
+	return null;
+}
+var NonZeroExitError = class extends Error {
+	result;
+	output;
+	exitCode;
+	get signalCode() {
+		return this.result.signalCode;
+	}
+	constructor(result, output, command, args) {
+		let target = "The process";
+		if (command) target = `The command \`${args?.length ? `${command} ${args.map((a) => /[ "'`()]/.test(a) ? JSON.stringify(a) : a).join(" ")}` : command}\``;
+		const exitCode = result.exitCode ?? 1;
+		super(result.signalCode !== null ? `${target} was killed by the signal ${result.signalCode}` : `${target} exited with a non-zero status (${exitCode})`);
+		this.result = result;
+		this.output = output;
+		this.exitCode = exitCode;
+		Object.defineProperty(this, "result", {
+			enumerable: false,
+			writable: false,
+			configurable: false
+		});
+	}
+};
+const defaultOptions = {
+	timeout: void 0,
+	persist: false
+};
+const defaultNodeOptions = { windowsHide: true };
+function combineSignals(signals) {
+	const controller = new AbortController();
+	for (const signal of signals) {
+		if (signal.aborted) {
+			controller.abort();
+			return signal;
+		}
+		const onAbort = () => {
+			controller.abort(signal.reason);
+		};
+		signal.addEventListener("abort", onAbort, { signal: controller.signal });
+	}
+	return controller.signal;
+}
+async function readStream(stream) {
+	let output = "";
+	try {
+		for await (const chunk of stream) output += chunk.toString();
+	} catch {}
+	return output;
+}
+var ExecProcess = class {
+	_process;
+	_aborted = false;
+	_options;
+	_command;
+	_args;
+	_resolveClose;
+	_processClosed;
+	_thrownError;
+	get process() {
+		return this._process;
+	}
+	get pid() {
+		return this._process?.pid;
+	}
+	get exitCode() {
+		if (this._process && this._process.exitCode !== null) return this._process.exitCode;
+	}
+	get signalCode() {
+		return this._process?.signalCode ?? null;
+	}
+	constructor(command, args, options) {
+		this._options = {
+			...defaultOptions,
+			...options
+		};
+		this._command = command;
+		this._args = args ?? [];
+		this._processClosed = new Promise((resolve) => {
+			this._resolveClose = resolve;
+		});
+	}
+	kill(signal) {
+		return this._process?.kill(signal) === true;
+	}
+	get aborted() {
+		return this._aborted;
+	}
+	get killed() {
+		return this._process?.killed === true;
+	}
+	pipe(command, args, options) {
+		return exec$1(command, args, {
+			...options,
+			stdin: this
+		});
+	}
+	async *[Symbol.asyncIterator]() {
+		const proc = this._process;
+		if (!proc) return;
+		const streams = [];
+		if (this._streamErr) streams.push(this._streamErr);
+		if (this._streamOut) streams.push(this._streamOut);
+		const streamCombined = combineStreams(streams);
+		const rl = readline.createInterface({ input: streamCombined });
+		for await (const chunk of rl) yield chunk.toString();
+		await this._processClosed;
+		proc.removeAllListeners();
+		if (this._thrownError) throw this._thrownError;
+		if (this._options?.throwOnError && (this.exitCode !== 0 && this.exitCode !== void 0 || this.signalCode !== null)) throw new NonZeroExitError(this, void 0, this._command, this._args);
+	}
+	async _waitForOutput() {
+		const proc = this._process;
+		if (!proc) throw new Error("No process was started");
+		const [stdout, stderr] = await Promise.all([this._streamOut ? readStream(this._streamOut) : "", this._streamErr ? readStream(this._streamErr) : ""]);
+		await this._processClosed;
+		const { stdin } = this._options;
+		if (stdin && typeof stdin !== "string") await stdin;
+		proc.removeAllListeners();
+		if (this._thrownError) throw this._thrownError;
+		const result = {
+			stderr,
+			stdout,
+			exitCode: this.exitCode
+		};
+		if (this._options.throwOnError && (this.exitCode !== 0 && this.exitCode !== void 0 || this.signalCode !== null)) throw new NonZeroExitError(this, result, this._command, this._args);
+		return result;
+	}
+	then(onfulfilled, onrejected) {
+		return this._waitForOutput().then(onfulfilled, onrejected);
+	}
+	_streamOut;
+	_streamErr;
+	spawn() {
+		const options = this._options;
+		const nodeOptions = {
+			...defaultNodeOptions,
+			...options.nodeOptions
+		};
+		const cwd$1 = nodeOptions?.cwd ?? cwd();
+		const signals = [];
+		this._resetState();
+		if (options.timeout !== void 0) signals.push(AbortSignal.timeout(options.timeout));
+		if (options.signal !== void 0) signals.push(options.signal);
+		if (options.persist === true) nodeOptions.detached = true;
+		if (signals.length > 0) nodeOptions.signal = combineSignals(signals);
+		nodeOptions.env = computeEnv(cwd$1, nodeOptions.env, options.nodePath);
+		const crossResult = normalizeSpawnCommand(this._command, this._args, nodeOptions);
+		const handle = spawn(crossResult.command, crossResult.args, crossResult.options);
+		if (handle.stderr) this._streamErr = handle.stderr;
+		if (handle.stdout) this._streamOut = handle.stdout;
+		this._process = handle;
+		handle.once("error", this._onError);
+		handle.once("close", this._onClose);
+		if (handle.stdin) {
+			const { stdin } = options;
+			if (typeof stdin === "string") handle.stdin.end(stdin);
+			else stdin?.process?.stdout?.pipe(handle.stdin);
+		}
+	}
+	_resetState() {
+		this._aborted = false;
+		this._processClosed = new Promise((resolve) => {
+			this._resolveClose = resolve;
+		});
+		this._thrownError = void 0;
+	}
+	_onError = (err) => {
+		if (err.name === "AbortError" && (!(err.cause instanceof Error) || err.cause.name !== "TimeoutError")) {
+			this._aborted = true;
+			return;
+		}
+		this._thrownError = err;
+	};
+	_onClose = () => {
+		if (this._resolveClose) this._resolveClose();
+	};
+};
+const x = (command, args, userOptions) => {
+	const proc = new ExecProcess(command, args, userOptions);
+	proc.spawn();
+	return proc;
+};
+const exec$1 = x;
+//#endregion
+//#region src/cli/exec.ts
+const NOT_FOUND = 127;
+const execChannel = channel(EXEC_CHANNEL);
+async function exec(command, args, cwd, env, options) {
+	const childEnv = env[PROCESS_ENV];
+	const start = performance.now();
+	const publish = (result) => {
+		if (execChannel.hasSubscribers) execChannel.publish({
+			command,
+			args,
+			cwd,
+			code: result.code,
+			milliseconds: Math.round(performance.now() - start)
+		});
+		return result;
+	};
+	try {
+		const result = await x(command, [...args], {
+			nodeOptions: {
+				cwd,
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				],
+				...childEnv ? { env: { ...childEnv } } : {}
+			},
+			...options.signal ? { signal: options.signal } : {},
+			throwOnError: false
+		});
+		return publish({
+			code: result.exitCode ?? 1,
+			stdout: result.stdout,
+			stderr: result.stderr
+		});
+	} catch (error) {
+		return publish({
+			code: NOT_FOUND,
+			stdout: "",
+			stderr: errorText(error)
+		});
+	}
+}
+/** Runs any command with piped output; 127 when it could not start. */
+function runProcess(command, args, cwd, env, options = {}) {
+	return exec(command, args, cwd, env, options);
+}
+const SIGNAL_NUMBERS = {
+	SIGHUP: 1,
+	SIGINT: 2,
+	SIGKILL: 9,
+	SIGTERM: 15
+};
+const FORWARDED_SIGNALS = ["SIGINT", "SIGTERM"];
+/**
+* Runs a command on the terminal (stdin, stdout and stderr inherited) and
+* resolves to its exit code, `128 + n` when signal `n` ended it. SIGINT and
+* SIGTERM sent to the CLI go on to the command, so a process manager that
+* signals only the CLI still stops it. 127 when it could not start.
+*/
+async function spawnInherited(command, args, options) {
+	const running = x(command, [...args], {
+		nodeOptions: {
+			cwd: options.cwd,
+			stdio: "inherit",
+			env: { ...options.env }
+		},
+		throwOnError: false
+	});
+	const forwards = FORWARDED_SIGNALS.map((name) => {
+		const forward = () => {
+			running.kill(name);
+		};
+		process.on(name, forward);
+		return () => process.off(name, forward);
+	});
+	try {
+		const result = await running;
+		const signal = running.process?.signalCode;
+		if (signal) return 128 + (SIGNAL_NUMBERS[signal] ?? 1);
+		return result.exitCode ?? NOT_FOUND;
+	} catch {
+		return NOT_FOUND;
+	} finally {
+		for (const off of forwards) off();
+	}
+}
+/**
+* `node_modules/.bin/supabase` in `cwd` or a parent, when the project installs
+* the CLI.
+*/
+function localSupabase(cwd) {
+	const bin = join("node_modules", ".bin", process.platform === "win32" ? "supabase.cmd" : "supabase");
+	const dir = findUp(cwd, (candidate) => existsSync(join(candidate, bin)));
+	return dir === void 0 ? void 0 : join(dir, bin);
+}
+/**
+* Runs the Supabase CLI: `$SUPABASE_BIN`, then the project's
+* `node_modules/.bin/supabase`, then `supabase` on the PATH. It never downloads
+* one; without any it fails with `supabase_cli_missing`.
+*/
+async function supabaseCli(args, cwd, env, options = {}) {
+	const command = env.SUPABASE_BIN ?? localSupabase(cwd) ?? "supabase";
+	const result = await exec(command, args, cwd, env, options);
+	if (result.code === NOT_FOUND && options.signal?.aborted !== true) throw new CliError("supabase_cli_missing", `Could not run the Supabase CLI (${command}): ${result.stderr || "not found"}. Install it in the project (pnpm add -D supabase) or set $SUPABASE_BIN.`, { suggestion: "pnpm add -D supabase" });
+	return result;
+}
+//#endregion
+export { spawnInherited as n, supabaseCli as r, runProcess as t };