better-supabase 0.14.0 → 0.15.0

package/dist/cli/db-DrBI_HNv.js

@@ -0,0 +1,223 @@
+import { p as commandMeta, r as defineCliCommand } from "./command-CQ61x6gN.js";
+import { n as CliError, r as errorText } from "./errors-BTe6A15O.js";
+import { i as isLocalDatabaseUrl, r as databaseHost } from "./agent-CbuPvI2x.js";
+import { t as display } from "./io-DH1kcmmP.js";
+import { l as stdinDatabaseUrl, n as databaseUrl } from "./config-9t5ec_N7.js";
+import { d as readSupabaseToml, f as schemaPaths, n as declarativeSchemasDir, p as sqlWorkflow } from "./supabase-toml-CncmQbO0.js";
+import { r as supabaseCli } from "./exec--Q1ZEWUW.js";
+import { t as connect } from "./db-CQCLx7cx.js";
+import { r as STACK_ARG, t as DB_URL_STDIN_ARG } from "./source-args-IpJRJO5t.js";
+import { a as migrationFiles, i as isShadowFailure, o as migrationVersion, r as inStackDiff, t as MIGRATION_HEADER } from "./in-stack-diff-DQTW53Vf.js";
+import { dirname, join, resolve } from "node:path";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+//#region src/cli/commands/db.ts
+const ARGS = {
+	file: {
+		type: "positional",
+		required: true,
+		variadic: true,
+		description: "SQL files, run in the order given"
+	},
+	"single-transaction": {
+		type: "boolean",
+		description: "Wrap every file in one transaction, so a failure keeps none"
+	}
+};
+/** Runs each file as one multi-statement script and reports the files it ran. */
+async function runDbQuery(config, args, env, open = connect, dbUrl, requireConsent = () => {}) {
+	const files = [...args._];
+	if (files.length === 0) throw new CliError("usage", "Pass at least one SQL file.", { flag: "file" });
+	const scripts = [];
+	for (const file of files) {
+		const path = resolve(config.root, file);
+		try {
+			scripts.push({
+				name: display(config.root, path),
+				sql: await readFile(path, "utf-8")
+			});
+		} catch (cause) {
+			throw new CliError("invalid_input", `Could not read ${file}: ${errorText(cause)}.`);
+		}
+	}
+	const url = await databaseUrl(config, env, dbUrl, args.stack ?? env.BSB_STACK);
+	if (!isLocalDatabaseUrl(url)) requireConsent({
+		effect: "database-write",
+		detail: `db query runs ${String(files.length)} file(s) against ${databaseHost(url)}`
+	});
+	const single = args["single-transaction"] === true;
+	const { client, close } = await open(url);
+	const ran = [];
+	try {
+		if (single) await client.query("begin");
+		for (const script of scripts) try {
+			await client.query(script.sql);
+			ran.push(script.name);
+		} catch (cause) {
+			if (single) await client.query("rollback");
+			return {
+				code: 1,
+				errorCode: "failed",
+				error: `${script.name}: ${errorText(cause)}${single ? " (nothing was kept)" : ""}`,
+				data: {
+					ran,
+					failed: script.name
+				}
+			};
+		}
+		if (single) await client.query("commit");
+	} finally {
+		await close();
+	}
+	return {
+		code: 0,
+		output: ran.map((name) => `Ran ${name}`).join("\n"),
+		data: {
+			ran,
+			singleTransaction: single
+		}
+	};
+}
+const dbQueryCommand = defineCliCommand({
+	meta: commandMeta("db query"),
+	args: {
+		...ARGS,
+		...DB_URL_STDIN_ARG,
+		...STACK_ARG
+	},
+	run: async (args, { config, env, io, log, requireConsent }) => {
+		const dbUrl = await stdinDatabaseUrl(args["db-url-stdin"], io);
+		return log.progress("Running the SQL files", () => runDbQuery(config, args, env, connect, dbUrl, requireConsent));
+	}
+});
+const DIFF_ARGS = {
+	file: {
+		type: "string",
+		alias: "f",
+		description: "Save the diff as supabase/migrations/<timestamp>_<name>.sql instead of printing it",
+		valueHint: "name"
+	},
+	"in-stack": {
+		type: "boolean",
+		description: "Diff inside the running stack with pg-delta, without the Supabase CLI's shadow database"
+	}
+};
+const DEFAULT_DIFF_DEPS = {
+	supabase: (args, root, env) => supabaseCli(args, root, env),
+	inStackDiff,
+	now: () => /* @__PURE__ */ new Date(),
+	log: () => {}
+};
+/**
+* The Supabase CLI's diff for the workflow. pg-delta's `declarative sync`
+* always writes a migration, so printing a diff under pg-delta runs in the
+* stack.
+*/
+function cliDiffCommand(workflow, name) {
+	switch (workflow) {
+		case "pg-delta": return name === void 0 ? void 0 : [
+			"db",
+			"schema",
+			"declarative",
+			"sync",
+			"--no-apply",
+			"-f",
+			name
+		];
+		case "migra": return name === void 0 ? ["db", "diff"] : [
+			"db",
+			"diff",
+			"-f",
+			name
+		];
+		default: return workflow;
+	}
+}
+/**
+* Turns the declarative schema into a migration with the Supabase CLI's command
+* for the project's workflow. When the CLI can't start its shadow database (no
+* shared memory segment left), or with `--in-stack`, it diffs inside the
+* running stack instead.
+*/
+async function runDbDiff(config, args, env, deps = DEFAULT_DIFF_DEPS) {
+	const name = args.file;
+	if (name !== void 0 && !/^[\w-]+$/u.test(name)) throw new CliError("invalid_value", `--file "${name}" must be letters, digits, dashes or underscores.`, { flag: "--file" });
+	const toml = await readSupabaseToml(config.root);
+	const workflow = sqlWorkflow(config, toml);
+	if (workflow === "migrations") throw new CliError("usage", "db diff turns declarative schema files into a migration, and this project writes migrations directly (database.sql.workflow = migrations).");
+	let fellBack = false;
+	const command = cliDiffCommand(workflow, name);
+	if (args["in-stack"] !== true && command !== void 0) {
+		const result = await deps.supabase(command, config.root, env);
+		if (result.code === 0) return {
+			code: 0,
+			output: result.stdout.trim() || "No schema changes.",
+			data: {
+				engine: "supabase",
+				command: ["supabase", ...command]
+			}
+		};
+		const output = `${result.stderr}\n${result.stdout}`;
+		if (!isShadowFailure(output)) return {
+			code: 1,
+			errorCode: "supabase_cli_failed",
+			error: `supabase ${command.join(" ")} failed: ${output.trim()}`,
+			data: {
+				engine: "supabase",
+				command: ["supabase", ...command]
+			}
+		};
+		fellBack = true;
+		deps.log("The Supabase CLI could not start its shadow database (no shared memory segment left), so db diff diffs inside the running stack. better-supabase dev stack prune frees segments.");
+	}
+	const url = await databaseUrl(config, env, void 0, args.stack ?? env.BSB_STACK);
+	if (!isLocalDatabaseUrl(url)) throw new CliError("usage", `db diff --in-stack works on a local stack, and the database is ${databaseHost(url)}.`);
+	const dir = toml?.dir ?? "supabase";
+	const sql = await deps.inStackDiff({
+		url,
+		root: config.root,
+		env,
+		files: (await schemaPaths(config.root, toml, workflow)).files,
+		schemasDir: declarativeSchemasDir(toml, workflow),
+		migrations: await migrationFiles(config.root, dir),
+		log: deps.log
+	});
+	const data = {
+		engine: "in-stack",
+		fellBack,
+		changes: sql !== ""
+	};
+	if (sql === "") return {
+		code: 0,
+		output: "No schema changes.",
+		data
+	};
+	if (name === void 0) return {
+		code: 0,
+		output: sql,
+		data
+	};
+	const path = join(config.root, dir, "migrations", `${migrationVersion(deps.now())}_${name}.sql`);
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, `${MIGRATION_HEADER}\n${sql}\n`);
+	return {
+		code: 0,
+		output: `Wrote ${display(config.root, path)}. Review it before you apply it.`,
+		data: {
+			...data,
+			file: display(config.root, path)
+		}
+	};
+}
+const dbDiffCommand = defineCliCommand({
+	meta: commandMeta("db diff"),
+	args: {
+		...DIFF_ARGS,
+		...STACK_ARG
+	},
+	run: (args, { config, env, log }) => log.progress("Diffing the schema files", () => runDbDiff(config, args, env, {
+		...DEFAULT_DIFF_DEPS,
+		log: log.info
+	}))
+});
+//#endregion
+export { dbDiffCommand, dbQueryCommand };

package/dist/cli/detect-D9JaAX20.js

@@ -0,0 +1,84 @@
+import { n as shellQuote } from "./shell-Btv_4Yhe.js";
+import { t as isRecord } from "./guards-CUlDNYZs.js";
+import { o as findSupabaseRoot } from "./supabase-toml-CncmQbO0.js";
+import { t as i } from "./jsonc-D5Fu67jw.js";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { readFile } from "node:fs/promises";
+//#region src/cli/project/detect.ts
+const FRAMEWORK_PACKAGES = [
+	["next", "next"],
+	["hono", "hono"],
+	["orpc", "@orpc/server"],
+	["vite", "vite"],
+	["expo", "expo"],
+	["tanstack-query", "@tanstack/react-query"]
+];
+async function readJson(path) {
+	if (!existsSync(path)) return;
+	const text = await readFile(path, "utf-8");
+	try {
+		const parsed = i(text, { allowTrailingComma: true });
+		return isRecord(parsed) ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+function packageManager(root, declared) {
+	if (typeof declared === "string") {
+		const name = declared.split("@")[0];
+		if (name === "pnpm" || name === "npm" || name === "yarn" || name === "bun") return name;
+	}
+	if (existsSync(join(root, "pnpm-lock.yaml"))) return "pnpm";
+	if (existsSync(join(root, "bun.lock")) || existsSync(join(root, "bun.lockb"))) return "bun";
+	if (existsSync(join(root, "yarn.lock"))) return "yarn";
+	return existsSync(join(root, "package-lock.json")) ? "npm" : "pnpm";
+}
+async function detectProject(root) {
+	const pkg = await readJson(join(root, "package.json")) ?? {};
+	const dependencies = {};
+	for (const field of [
+		"peerDependencies",
+		"devDependencies",
+		"dependencies"
+	]) Object.assign(dependencies, pkg[field] ?? {});
+	const options = (await readJson(join(root, "tsconfig.json")))?.["compilerOptions"] ?? {};
+	return {
+		root,
+		name: typeof pkg["name"] === "string" ? pkg["name"] : void 0,
+		frameworks: FRAMEWORK_PACKAGES.filter(([, name]) => name in dependencies).map(([framework]) => framework),
+		packageManager: packageManager(root, pkg["packageManager"]),
+		dependencies,
+		srcDir: existsSync(join(root, "src")) ? "src" : ".",
+		tsExtensions: options["allowImportingTsExtensions"] === true || options["rewriteRelativeImportExtensions"] === true,
+		hasSupabase: findSupabaseRoot(root) !== void 0
+	};
+}
+function installCommand(manager, packages, dev = false, installTarget) {
+	const list = packages.map(shellQuote).join(" ");
+	const target = installTarget && {
+		dir: shellQuote(installTarget.dir),
+		name: installTarget.name === void 0 ? void 0 : shellQuote(installTarget.name),
+		filter: shellQuote(installTarget.name ?? `./${installTarget.dir}`)
+	};
+	switch (manager) {
+		case "pnpm": return `pnpm ${target ? `--filter ${target.filter} ` : ""}add ${dev ? "-D " : ""}${list}`;
+		case "bun": return `bun add ${dev ? "-d " : ""}${list}${target ? ` --cwd ${target.dir}` : ""}`;
+		case "yarn": {
+			const command = `add ${dev ? "-D " : ""}${list}`;
+			if (!target) return `yarn ${command}`;
+			return target.name ? `yarn workspace ${target.name} ${command}` : `cd ${target.dir} && yarn ${command}`;
+		}
+		case "npm": return `npm install ${dev ? "-D " : ""}${list}${target ? ` -w ${target.dir}` : ""}`;
+		default: return manager;
+	}
+}
+/** Env variable prefix the framework exposes to the browser. */
+function publicPrefix(project) {
+	if (project.frameworks.includes("next")) return "NEXT_PUBLIC_";
+	if (project.frameworks.includes("expo")) return "EXPO_PUBLIC_";
+	if (project.frameworks.includes("vite")) return "VITE_";
+	return "";
+}
+//#endregion
+export { installCommand as n, publicPrefix as r, detectProject as t };

package/dist/cli/dist-D_VbPAMR.js

@@ -0,0 +1,129 @@
+import { a as isAbsolute, c as resolve, o as join, r as dirname, s as normalize, t as resolveModulePath } from "./dist-DuiMMRbJ.js";
+import { n as o, t as i } from "./_format-Cax5EsM9.js";
+import { t as i$1 } from "./jsonc-D5Fu67jw.js";
+import { promises, statSync } from "node:fs";
+import "node:fs/promises";
+import { fileURLToPath } from "node:url";
+//#region ../../node_modules/.pnpm/confbox@0.3.1/node_modules/confbox/dist/json.mjs
+function r(e, r) {
+	let i$2 = JSON.parse(i(e), r?.reviver);
+	return o(e, i$2, r), i$2;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/pkg-types@2.3.3/node_modules/pkg-types/dist/index.mjs
+const defaultFindOptions = {
+	startingFrom: ".",
+	rootPattern: /^node_modules$/,
+	reverse: false,
+	test: (filePath) => {
+		try {
+			if (statSync(filePath).isFile()) return true;
+		} catch {}
+	}
+};
+async function findFile(filename, _options = {}) {
+	const filenames = Array.isArray(filename) ? filename : [filename];
+	const options = {
+		...defaultFindOptions,
+		..._options
+	};
+	const basePath = resolve(options.startingFrom);
+	const leadingSlash = basePath[0] === "/";
+	const segments = basePath.split("/").filter(Boolean);
+	if (filenames.includes(segments.at(-1)) && await options.test(basePath)) return basePath;
+	if (leadingSlash) segments[0] = "/" + segments[0];
+	let root = segments.findIndex((r) => r.match(options.rootPattern));
+	if (root === -1) root = 0;
+	if (options.reverse) for (let index = root + 1; index <= segments.length; index++) for (const filename of filenames) {
+		const filePath = join(...segments.slice(0, index), filename);
+		if (await options.test(filePath)) return filePath;
+	}
+	else for (let index = segments.length; index > root; index--) for (const filename of filenames) {
+		const filePath = join(...segments.slice(0, index), filename);
+		if (await options.test(filePath)) return filePath;
+	}
+	throw new Error(`Cannot find matching ${filename} in ${options.startingFrom} or parent directories`);
+}
+function findNearestFile(filename, options = {}) {
+	return findFile(filename, options);
+}
+function _resolvePath(id, opts = {}) {
+	if (id instanceof URL || id.startsWith("file://")) return normalize(fileURLToPath(id));
+	if (isAbsolute(id)) return normalize(id);
+	return resolveModulePath(id, {
+		...opts,
+		from: opts.from || opts.parent || opts.url
+	});
+}
+const lockFiles = [
+	"yarn.lock",
+	"package-lock.json",
+	"pnpm-lock.yaml",
+	"npm-shrinkwrap.json",
+	"bun.lockb",
+	"bun.lock",
+	"deno.lock"
+];
+const packageFiles = [
+	"package.json",
+	"package.json5",
+	"package.yaml"
+];
+const workspaceFiles = [
+	"pnpm-workspace.yaml",
+	"lerna.json",
+	"turbo.json",
+	"rush.json",
+	"deno.json",
+	"deno.jsonc"
+];
+const FileCache = /* #__PURE__ */ new Map();
+async function readPackageJSON(id, options = {}) {
+	const resolvedPath = await resolvePackageJSON(id, options);
+	const cache = options.cache && typeof options.cache !== "boolean" ? options.cache : FileCache;
+	if (options.cache && cache.has(resolvedPath)) return cache.get(resolvedPath);
+	const blob = await promises.readFile(resolvedPath, "utf8");
+	let parsed;
+	try {
+		parsed = r(blob);
+	} catch {
+		parsed = i$1(blob);
+	}
+	cache.set(resolvedPath, parsed);
+	return parsed;
+}
+async function resolvePackageJSON(id = process.cwd(), options = {}) {
+	return findNearestFile("package.json", {
+		...options,
+		startingFrom: _resolvePath(id, options)
+	});
+}
+const workspaceTests = {
+	workspaceFile: (opts) => findFile(workspaceFiles, opts).then((r) => dirname(r)),
+	gitConfig: (opts) => findFile(".git/config", opts).then((r) => resolve(r, "../..")),
+	lockFile: (opts) => findFile(lockFiles, opts).then((r) => dirname(r)),
+	packageJson: (opts) => findFile(packageFiles, opts).then((r) => dirname(r))
+};
+async function findWorkspaceDir(id = process.cwd(), options = {}) {
+	const startingFrom = _resolvePath(id, options);
+	const tests = options.tests || [
+		"workspaceFile",
+		"gitConfig",
+		"lockFile",
+		"packageJson"
+	];
+	for (const testName of tests) {
+		const test = workspaceTests[testName];
+		if (options[testName] === false || !test) continue;
+		const direction = options[testName] || (testName === "gitConfig" ? "closest" : "furthest");
+		const detected = await test({
+			...options,
+			startingFrom,
+			reverse: direction === "furthest"
+		}).catch(() => {});
+		if (detected) return detected;
+	}
+	throw new Error(`Cannot detect workspace root from ${id}`);
+}
+//#endregion
+export { findWorkspaceDir, readPackageJSON };