better-supabase 0.7.1 → 0.8.0

package/dist/cli/{env-qXgyMV6r.js → env-B--LMhEe.js}

@@ -1,6 +1,8 @@
-import { r as defineCliCommand } from "./command-CK14fP91.js";
-import { i as writeIfChanged, t as display } from "./io-DI1mTdSA.js";
+import { r as defineCliCommand } from "./command-DV-StG1x.js";
+import { r as errorText } from "./errors-CqTLXe2M.js";
+import { r as readIfExists, t as display } from "./io-CFzJVJ68.js";
 import { r as publicPrefix, t as detectProject } from "./project-DZRaBaY7.js";
+import { r as writeLine } from "./files-BVupXPIC.js";
 import { basename, delimiter, dirname, normalize, resolve } from "node:path";
 import { closeSync, existsSync, openSync, readSync, statSync } from "node:fs";
 import { readFile } from "node:fs/promises";
@@ -374,7 +376,7 @@ async function exec(command, args, cwd) {
 		return {
 			code: 127,
 			stdout: "",
-			stderr: error instanceof Error ? error.message : String(error)
+			stderr: errorText(error)
 		};
 	}
 }
@@ -393,12 +395,12 @@ async function supabaseCli(args, cwd, env) {
 const ARGS = {
 	out: {
 		type: "string",
-		description: "Env file to write. Defaults to .env.local",
+		description: "Env file to write. Defaults to env.output, then .env.local",
 		valueHint: "file"
 	},
 	prefix: {
 		type: "string",
-		description: "Prefix for browser variables, detected from your framework; \"none\" for no prefix",
+		description: "Prefix for browser variables. Defaults to env.prefix, then one detected from your framework; \"none\" for no prefix",
 		valueHint: "prefix"
 	},
 	from: {
@@ -459,7 +461,7 @@ function mergeEnv(current, values) {
 async function runEnv(config, args, env) {
 	const status = await readStatus(config, args, env);
 	const project = await detectProject(config.root);
-	const prefixFlag = args.prefix;
+	const prefixFlag = args.prefix ?? config.env.prefix;
 	const prefix = prefixFlag === void 0 ? publicPrefix(project) : prefixFlag === "none" ? "" : prefixFlag;
 	const url = text(status, "API_URL");
 	const publishableKey = text(status, "PUBLISHABLE_KEY", "ANON_KEY");
@@ -481,10 +483,11 @@ async function runEnv(config, args, env) {
 		code: 0,
 		output: Object.entries(values).map(([key, value]) => `${key}=${value}`).join("\n")
 	};
-	const out = args.out ?? ".env.local";
+	const out = args.out ?? config.env.output;
 	const path = resolve(config.root, out);
-	const current = existsSync(path) ? await readFile(path, "utf8") : "";
-	const lines = [`${await writeIfChanged(path, mergeEnv(current, values)) ? "Wrote" : "Unchanged"} ${display(config.root, out)}: ${Object.keys(values).join(", ")}`];
+	const current = await readIfExists(path) ?? "";
+	const { line } = await writeLine(path, mergeEnv(current, values), display(config.root, out), `: ${Object.keys(values).join(", ")}`);
+	const lines = [line];
 	if (!text(status, "PUBLISHABLE_KEY")) lines.push("Warning: this Supabase CLI prints only legacy JWT keys. Upgrade it to get sb_publishable_/sb_secret_ keys.");
 	const gitignore = resolve(config.root, ".gitignore");
 	if (!(existsSync(gitignore) && (await readFile(gitignore, "utf8")).split("\n").some((line) => [
@@ -508,4 +511,4 @@ const envCommand = defineCliCommand({
 	run: (args, { config, env }) => runEnv(config, args, env)
 });
 //#endregion
-export { envCommand };
+export { mergeEnv as n, runEnv as r, envCommand as t };

package/dist/cli/env-vzBG90Um.js

@@ -0,0 +1,2 @@
+import { t as envCommand } from "./env-B--LMhEe.js";
+export { envCommand };

package/dist/cli/{env-CJLbUVPB.js → env-zHJtMIBo.js}

@@ -1,4 +1,4 @@
-import { n as CliError } from "./errors-4v4DTtda.js";
+import { n as CliError } from "./errors-CqTLXe2M.js";
 import { h as pipe, p as optional, w as url, x as string } from "./dist-DRAVaE6w.js";
 //#region ../../node_modules/.pnpm/@t3-oss+env-core@0.13.11_arktype@2.2.3_typescript@7.0.2_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/@t3-oss/env-core/dist/standard.js
 function ensureSynchronous(value, message) {
@@ -82,6 +82,12 @@ function createEnv(opts) {
 }
 //#endregion
 //#region src/cli/env.ts
+/** `--env`, then `$BETTER_SUPABASE_ENV`, then `ci` when `$CI` is set to anything but false. */
+function configEnvironment(flag, env) {
+	if (flag !== void 0 && flag !== "") return flag;
+	if (env.BETTER_SUPABASE_ENV !== void 0) return env.BETTER_SUPABASE_ENV;
+	return env.CI !== void 0 && env.CI !== "false" && env.CI !== "0" ? "ci" : void 0;
+}
 const optionalString = optional(string());
 const optionalUrl = optional(pipe(string(), url("must be a URL, e.g. postgresql://user@host/db")));
 /** Parses the variables the CLI reads; an invalid value is a `env_invalid` usage error. */
@@ -89,11 +95,13 @@ function parseEnv(env) {
 	return createEnv({
 		server: {
 			DATABASE_URL: optionalUrl,
+			SUPABASE_DB_URL: optionalUrl,
 			SUPABASE_ACCESS_TOKEN: optionalString,
 			SUPABASE_API_URL: optionalUrl,
 			SUPABASE_BIN: optionalString,
 			HOME: optionalString,
-			CI: optionalString
+			CI: optionalString,
+			BETTER_SUPABASE_ENV: optionalString
 		},
 		runtimeEnv: env,
 		isServer: true,
@@ -105,4 +113,4 @@ function parseEnv(env) {
 	});
 }
 //#endregion
-export { parseEnv };
+export { configEnvironment, parseEnv };

package/dist/cli/{errors-4v4DTtda.js → errors-CqTLXe2M.js}

@@ -50,7 +50,23 @@ function isCittyUsageError(cause) {
 function toCliError(cause) {
 	if (cause instanceof CliError) return cause;
 	if (isCittyUsageError(cause)) return new CliError("usage", cause.message);
-	return new CliError("internal", cause instanceof Error ? cause.message : String(cause), { cause });
+	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 { CliError as n, toCliError as r, CLI_ERRORS_URL as t };
+export { parseNames as a, failedResult as i, CliError as n, toCliError as o, errorText as r, CLI_ERRORS_URL as t };

package/dist/cli/{fastest-levenshtein-CFN-lNDv.js → fastest-levenshtein-CF7BCi9l.js}

@@ -1,4 +1,4 @@
-import { t as __commonJSMin } from "./rolldown-runtime-BPOCksWG.js";
+import { t as __commonJSMin } from "./rolldown-runtime-CMFfr-1z.js";
 //#region ../../node_modules/.pnpm/fastest-levenshtein@1.0.16/node_modules/fastest-levenshtein/mod.js
 var require_fastest_levenshtein = /* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.__esModule = true;

package/dist/cli/files-BVupXPIC.js

@@ -0,0 +1,34 @@
+import { a as writeIfChanged, i as sameText, r as readIfExists, t as display } from "./io-CFzJVJ68.js";
+import { resolve } from "node:path";
+//#region src/cli/files.ts
+/** Reads `out` under `root` and compares it with `contents`, ignoring line endings. */
+async function fileState(root, out, contents) {
+	const path = resolve(root, out);
+	const current = await readIfExists(path);
+	return {
+		file: display(root, out),
+		path,
+		current,
+		upToDate: sameText(current, contents)
+	};
+}
+/** The result of `--check` for one file: up to date, or failed with the command that rewrites it. */
+function staleResult(state, regenerate) {
+	return state.upToDate ? {
+		code: 0,
+		output: `${state.file} is up to date.`
+	} : {
+		code: 1,
+		error: `${state.file} is out of date. Run \`${regenerate}\`.`
+	};
+}
+/** Writes `contents` when it changed and returns the `Wrote` or `Unchanged` line for `shown`. */
+async function writeLine(path, contents, shown, suffix = "") {
+	const wrote = await writeIfChanged(path, contents);
+	return {
+		wrote,
+		line: `${wrote ? "Wrote" : "Unchanged"} ${shown}${suffix}`
+	};
+}
+//#endregion
+export { staleResult as n, writeLine as r, fileState as t };

package/dist/cli/gen-DmVj3u4L.js

@@ -0,0 +1,322 @@
+import { a as list, r as defineCliCommand } from "./command-DV-StG1x.js";
+import { a as parseNames, i as failedResult, r as errorText } from "./errors-CqTLXe2M.js";
+import { i as plain, r as painter } from "./style-CB3vxgh0.js";
+import { a as catalogFingerprint } from "./cache-CIfA-jBV.js";
+import { n as runGen } from "./run-DuN1MX-7.js";
+import { r as isGenTask, t as GEN_TASKS } from "./names-D6LrQnOv.js";
+import { o as snapshotFile, r as openSource, t as loadSnapshot } from "./snapshot-Bstk6ulj.js";
+import { r as runMetadataGen, t as EMITS } from "./metadata-DSRKCaf-.js";
+import { n as withSpinner } from "./prompts-DZJB1nTw.js";
+import { r as runEnv } from "./env-B--LMhEe.js";
+import { a as modifiedTime, c as sleep, l as stampFiles, o as onceReporter, r as specOptionsFromConfig, s as parseInterval, t as runSpec } from "./spec-CzosTYm3.js";
+import { t as runScaffold } from "./scaffold-5DenHSxF.js";
+import { t as runSeed } from "./seed-CzBmrGON.js";
+import { t as runSql } from "./sql-BKOOQAX3.js";
+import { n as sourceArgs, t as SOURCE_ARGS } from "./source-args-BYfq6imV.js";
+import { resolve } from "node:path";
+import { existsSync } from "node:fs";
+//#region src/cli/commands/gen-pipeline.ts
+/** Tasks run in this order whatever order the config lists them in. */
+const ORDER = new Map(GEN_TASKS.map((task, index) => [task, index]));
+/** Checks `--tasks` names. Returns an error message for an unknown one. */
+function parseTasks(names) {
+	return parseNames(names, isGenTask, "gen task", GEN_TASKS);
+}
+/**
+* The tasks `gen` runs, in pipeline order: `--tasks`, then `gen.tasks`, then
+* every task the config sets up.
+*/
+function selectTasks(config, requested) {
+	const named = requested ?? config.gen.tasks;
+	if (named === void 0) return configuredTasks(config);
+	return [...new Set(named)].toSorted((a, b) => (ORDER.get(a) ?? 0) - (ORDER.get(b) ?? 0));
+}
+/** Every task the config sets up. `env` runs only when a task list names it. */
+function configuredTasks(config) {
+	const exists = (path) => existsSync(resolve(config.root, path));
+	const configured = {
+		types: () => true,
+		sql: () => config.sql.moduleNames.length > 0 || config.realtime.policies !== void 0,
+		spec: () => exists(config.specs.entry),
+		seed: () => exists(config.seed.entry),
+		scaffold: () => config.scaffold.api !== void 0,
+		env: () => false
+	};
+	return GEN_TASKS.filter((task) => configured[task]());
+}
+/** Files the steps after `types` read, so `gen --watch` reruns them when one changes. */
+function stepInputs(config, tasks) {
+	const at = (path) => resolve(config.root, path);
+	const inputs = {
+		types: () => [],
+		sql: () => [],
+		spec: () => [at(config.specs.entry), ...config.specs.outputs.flatMap((output) => (output.overlays ?? []).map(at))],
+		seed: () => [at(config.seed.entry)],
+		scaffold: () => [],
+		env: () => []
+	};
+	return tasks.flatMap((task) => inputs[task]());
+}
+const STEPS = {
+	sql: ({ config, check, paint }) => runSql(config, {
+		_: ["sync"],
+		check
+	}, paint),
+	spec: ({ config, check }) => runSpec(specOptionsFromConfig(config, check ? "check" : "emit")),
+	seed: ({ config, check, env }) => runSeed(config, { check }, env),
+	scaffold: ({ config, check }) => runScaffold(config, { _: ["api"] }, {
+		generatedOnly: true,
+		check
+	}),
+	env: async ({ config, check, env }) => check ? {
+		code: 0,
+		output: "Skipped: env writes local keys, so --check leaves it out."
+	} : runEnv(config, {}, env)
+};
+/**
+* Runs the steps after `types`, in order. A write run stops at the first
+* failure, since later steps read what earlier ones wrote; `--check` runs
+* every step so it reports everything that is out of date.
+*/
+async function runSteps(tasks, options, previous = []) {
+	const results = [...previous];
+	for (const task of tasks) {
+		if (task === "types") continue;
+		if (!options.check && results.some(({ result }) => result.code !== 0)) break;
+		const result = await STEPS[task](options).catch(failedResult);
+		results.push({
+			task,
+			result
+		});
+	}
+	return results;
+}
+const indent = (text) => text.split("\n").map((line) => line === "" ? line : `  ${line}`).join("\n");
+/**
+* One result for the run. A single task returns its own result unchanged;
+* several tasks get a section each, the first failing exit code and every
+* error.
+*/
+function combineResults(results) {
+	const [only] = results;
+	if (results.length === 1 && only) return only.result;
+	const output = results.flatMap(({ task, result }) => result.output ? [`[${task}]\n${indent(result.output)}`] : [`[${task}] done`]).join("\n");
+	const errors = results.flatMap(({ task, result }) => result.error ? [`[${task}] ${result.error}`] : []);
+	return {
+		code: results.find(({ result }) => result.code !== 0)?.result.code ?? 0,
+		output,
+		...errors.length > 0 ? { error: errors.join("\n") } : {},
+		data: { tasks: Object.fromEntries(results.map(({ task, result }) => [task, {
+			code: result.code,
+			...result.data === void 0 ? {} : { data: result.data }
+		}])) }
+	};
+}
+//#endregion
+//#region src/cli/commands/gen.ts
+const ARGS = {
+	metadata: {
+		type: "string",
+		description: "Read a GeneratorMetadata document (- for stdin) and print one file on stdout",
+		valueHint: "path|-"
+	},
+	emit: {
+		type: "string",
+		description: `With --metadata, the file to print: ${EMITS.join(", ")}. Defaults to schema`,
+		valueHint: "file"
+	},
+	out: {
+		type: "string",
+		description: "With --metadata, write every generated file into this directory instead of printing one",
+		valueHint: "dir"
+	},
+	tasks: {
+		type: "string",
+		description: `Tasks to run: ${GEN_TASKS.join(", ")}. Defaults to gen.tasks, or every task the config sets up`,
+		valueHint: "list"
+	},
+	check: {
+		type: "boolean",
+		description: "Fail when a generated file is out of date"
+	},
+	watch: {
+		type: "boolean",
+		description: "Run again whenever the schema, the config file or a task's input changes"
+	},
+	interval: {
+		type: "string",
+		description: "Milliseconds between checks in --watch. Defaults to gen.watchInterval, then 2000",
+		valueHint: "ms"
+	},
+	...SOURCE_ARGS
+};
+/**
+* Reads the schema when it may have changed. Returns the new change marker (the
+* catalog fingerprint, or the snapshot itself when the source has none) and
+* the snapshot, or no snapshot when the fingerprint still matches `last`.
+*/
+async function poll(options, db, last) {
+	const fingerprint = db ? await catalogFingerprint(db.queryable).catch(() => void 0) : void 0;
+	if (fingerprint !== void 0 && fingerprint === last) return { marker: last };
+	const snapshot = await loadSnapshot(options.config, options.env, options, void 0, db ? () => Promise.resolve(db) : void 0);
+	const marker = fingerprint ?? JSON.stringify(snapshot);
+	return marker === last ? { marker } : {
+		marker,
+		snapshot
+	};
+}
+/**
+* Runs `tasks`: `types` through `runGen`, then the steps after it. Without
+* `types` in the list, `snapshot` is unused.
+*/
+async function runTasks(tasks, options) {
+	const types = tasks.includes("types") ? [{
+		task: "types",
+		result: await runGen(options).catch(failedResult)
+	}] : [];
+	return combineResults(await runSteps(tasks, {
+		config: options.config,
+		env: options.env,
+		check: options.check,
+		paint: options.paint ?? plain
+	}, types));
+}
+/**
+* Runs the tasks again whenever the schema, the config file or a task's
+* input (the spec entry and its overlays, the seed entry) changes. A
+* database source keeps one connection open and polls the catalog
+* fingerprint, so an unchanged schema costs one small query per interval; a
+* source without a fingerprint is introspected each time and compared. The
+* schema is read only when `types` runs. A changed config file is loaded
+* again and forces a run; a changed input reruns the steps after `types`. A
+* failed run is retried every interval until it succeeds, and the same
+* error is printed once.
+*/
+async function watch(initial, requested, interval, { io, signal, configFile, reloadConfig }) {
+	let options = initial;
+	let last = "";
+	let inputs = "";
+	const fresh = onceReporter();
+	let stamp = await modifiedTime(configFile);
+	let db;
+	const aborted = () => signal?.aborted ?? false;
+	const report = (message) => {
+		if (fresh(message)) io.stderr(`${message}\n`);
+	};
+	const closeDb = async () => {
+		await db?.close().catch(() => void 0);
+		db = void 0;
+	};
+	try {
+		while (!aborted()) {
+			const changed = await modifiedTime(configFile);
+			if (reloadConfig && changed !== stamp) try {
+				options = {
+					...options,
+					config: await reloadConfig()
+				};
+				stamp = changed;
+				last = "";
+				inputs = "";
+				await closeDb();
+			} catch (cause) {
+				report(errorText(cause));
+				await sleep(interval, signal);
+				continue;
+			}
+			const tasks = selectTasks(options.config, requested);
+			const current = await stampFiles(stepInputs(options.config, tasks));
+			let polled;
+			if (tasks.includes("types")) try {
+				db ??= snapshotFile(options.config, options) === void 0 ? await openSource(options.config, options.env, options) : void 0;
+				polled = await poll(options, db, last);
+			} catch (cause) {
+				report(errorText(cause));
+				await closeDb();
+				await sleep(interval, signal);
+				continue;
+			}
+			const run = polled?.snapshot ? tasks : current === inputs ? void 0 : tasks.filter((task) => task !== "types");
+			const result = run && run.length > 0 ? await runTasks(run, {
+				...options,
+				...polled?.snapshot ? { snapshot: polled.snapshot } : {}
+			}) : void 0;
+			if (result && result.code !== 0) report(result.error ?? `gen exited with code ${result.code}`);
+			else {
+				if (result?.output) io.stdout(`${result.output}\n`);
+				if (polled) last = polled.marker;
+				inputs = current;
+				fresh("");
+			}
+			await sleep(interval, signal);
+		}
+	} finally {
+		await closeDb();
+	}
+	return { code: 0 };
+}
+const genCommand = defineCliCommand({
+	meta: {
+		name: "gen",
+		description: "Writes the typed client from the database, then every other generated file the config sets up"
+	},
+	args: ARGS,
+	lists: ["tasks"],
+	run: async (args, context) => {
+		if (args.metadata !== void 0) {
+			const conflicting = [
+				...args.watch === true ? ["--watch"] : [],
+				...args.snapshot === void 0 ? [] : ["--snapshot"],
+				...args["db-url-stdin"] === true ? ["--db-url-stdin"] : [],
+				...args["project-ref"] === void 0 ? [] : ["--project-ref"]
+			];
+			if (conflicting.length > 0) return {
+				code: 2,
+				error: `--metadata reads the schema from the document, so it can't be combined with ${conflicting.join(", ")}`
+			};
+			return runMetadataGen({
+				config: context.config,
+				env: context.env,
+				cwd: context.cwd,
+				io: context.io,
+				metadata: args.metadata,
+				check: args.check === true,
+				json: context.json,
+				paint: painter(context.io.color),
+				...args.emit === void 0 ? {} : { emit: args.emit },
+				...args.out === void 0 ? {} : { out: args.out }
+			});
+		}
+		if (args.emit !== void 0 || args.out !== void 0) return {
+			code: 2,
+			error: `${args.emit === void 0 ? "--out" : "--emit"} only applies with --metadata`
+		};
+		const requested = args.tasks === void 0 ? void 0 : parseTasks(list(args.tasks));
+		if (typeof requested === "string") return {
+			code: 2,
+			error: requested
+		};
+		const tasks = selectTasks(context.config, requested);
+		if (tasks.length === 0) return {
+			code: 2,
+			error: "--tasks names no task."
+		};
+		const options = {
+			config: context.config,
+			env: context.env,
+			check: args.check === true,
+			paint: painter(context.io.color),
+			...await sourceArgs(args, context.io),
+			...context.signal ? { signal: context.signal } : {},
+			cache: true
+		};
+		const interval = parseInterval(args.interval, context.config.gen.watchInterval);
+		if (typeof interval === "string") return {
+			code: 2,
+			error: interval
+		};
+		return args.watch === true ? watch(options, requested, interval, context) : withSpinner(context.io.prompts, "Generating from the schema", () => runTasks(tasks, options));
+	}
+});
+//#endregion
+export { genCommand };