better-supabase 0.7.0 → 0.8.0

package/dist/cli/init-CVZ3s5kl.js

@@ -0,0 +1,258 @@
+import { a as list, r as defineCliCommand } from "./command-DV-StG1x.js";
+import { a as writeIfChanged, t as display } from "./io-CFzJVJ68.js";
+import { t as TYPEGEN_VERSION } from "./typegen-version-DeFbtzYI.js";
+import { i as findConfig, o as loadConfig } from "./config-M-WzL9O2.js";
+import { a as findSupabaseRoot, p as tomlGet, r as diffEngine, t as PGDELTA_TABLE, u as readSupabaseToml } from "./supabase-toml-B-bIukQF.js";
+import { n as installCommand, t as detectProject } from "./project-DZRaBaY7.js";
+import { a as packagesFor, c as writeFiles, f as needsLib, i as overwrite, l as TEMPLATES, m as suggestedIntegrations, n as chooseIntegrations, o as parseIntegrations, p as resolveIntegrations, r as integrationFiles, s as templateContextFor, t as CANCELLED, u as baseFiles } from "./glue-C1UE8gQN.js";
+import { join, posix, resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { glob, readFile } from "node:fs/promises";
+//#region src/cli/workspace.ts
+const unquote = (value) => value.replace(/\s+#.*$/, "").trim().replace(/^(["'])(.*)\1$/, "$2");
+/** The `packages` globs of `pnpm-workspace.yaml`, in block or flow style. */
+function pnpmWorkspacePatterns(text) {
+	const lines = text.split(/\r?\n/);
+	const start = lines.findIndex((line) => /^packages\s*:/.test(line));
+	if (start === -1) return [];
+	const inline = /^packages\s*:\s*\[(.*)\]\s*(?:#.*)?$/.exec(lines[start]);
+	if (inline) return inline[1].split(",").map(unquote).filter((entry) => entry !== "");
+	const patterns = [];
+	for (const line of lines.slice(start + 1)) {
+		if (/^\s*(?:#.*)?$/.test(line)) continue;
+		const item = /^\s+-\s*(.+)$/.exec(line);
+		if (!item) break;
+		patterns.push(unquote(item[1]));
+	}
+	return patterns.filter((entry) => entry !== "");
+}
+function packageJsonPatterns(workspaces) {
+	let list = workspaces;
+	if (typeof workspaces === "object" && workspaces !== null && "packages" in workspaces) list = workspaces.packages;
+	return Array.isArray(list) ? list.filter((entry) => typeof entry === "string") : [];
+}
+async function matches(root, pattern) {
+	const dirs = [];
+	const base = pattern.replace(/^\.\//, "").replace(/\/$/, "");
+	for await (const path of glob(`${base}/package.json`, {
+		cwd: root,
+		exclude: (name) => name === "node_modules"
+	})) dirs.push(posix.dirname(path.replaceAll("\\", "/")));
+	return dirs;
+}
+/**
+* The workspace declared at `root` by `pnpm-workspace.yaml` or the
+* `workspaces` field of `package.json`, with its packages in path order.
+* `undefined` when `root` declares none.
+*/
+async function detectWorkspace(root) {
+	let file;
+	let patterns;
+	const yaml = join(root, "pnpm-workspace.yaml");
+	if (existsSync(yaml)) {
+		file = "pnpm-workspace.yaml";
+		patterns = pnpmWorkspacePatterns(await readFile(yaml, "utf8"));
+	} else {
+		const path = join(root, "package.json");
+		if (!existsSync(path)) return void 0;
+		let pkg;
+		try {
+			pkg = JSON.parse(await readFile(path, "utf8"));
+		} catch {
+			return;
+		}
+		if (typeof pkg !== "object" || pkg === null || !("workspaces" in pkg)) return void 0;
+		file = "package.json";
+		patterns = packageJsonPatterns(pkg.workspaces);
+		if (patterns.length === 0) return void 0;
+	}
+	const included = /* @__PURE__ */ new Set();
+	const excluded = /* @__PURE__ */ new Set();
+	for (const pattern of patterns) {
+		const negated = pattern.startsWith("!");
+		for (const dir of await matches(root, negated ? pattern.slice(1) : pattern)) (negated ? excluded : included).add(dir);
+	}
+	const dirs = [...included].filter((dir) => dir !== "." && !excluded.has(dir)).sort();
+	const packages = await Promise.all(dirs.map(async (dir) => ({
+		dir,
+		project: await detectProject(join(root, dir))
+	})));
+	return {
+		file,
+		packages
+	};
+}
+/** The package `init` suggests: one that uses better-supabase, then one with a framework. */
+function suggestedPackage(workspace) {
+	const packages = workspace.packages;
+	return (packages.find((entry) => "better-supabase" in entry.project.dependencies) ?? packages.find((entry) => entry.project.frameworks.length > 0) ?? packages[0])?.dir;
+}
+//#endregion
+//#region src/cli/commands/init.ts
+const INIT_ARGS = {
+	casing: {
+		type: "string",
+		description: "Row keys in camelCase (camel, the default) or the database's snake_case (snake)",
+		valueHint: "camel|snake"
+	},
+	with: {
+		type: "string",
+		description: "Integrations to add next to the detected ones: next, hono, orpc, edge, expo, mcp, client, react",
+		valueHint: "integration,..."
+	},
+	package: {
+		type: "string",
+		description: "Workspace package to write to, relative to --cwd",
+		valueHint: "dir"
+	},
+	lite: {
+		type: "boolean",
+		description: "Run on Supabase Lite: install @supabase/lite and use its CLI in the next steps"
+	},
+	force: {
+		type: "boolean",
+		description: "Overwrite files that exist"
+	},
+	"dry-run": {
+		type: "boolean",
+		description: "Show what would be written"
+	}
+};
+/**
+* Adds `[experimental.pgdelta] enabled = true` to `supabase/config.toml`
+* when it has no such table, so `supabase db schema declarative sync`
+* runs on pg-delta. A table set to `enabled = false` is left alone.
+*/
+async function enablePgDelta(root, args, base) {
+	const supabaseRoot = findSupabaseRoot(root);
+	const toml = await readSupabaseToml(root);
+	if (supabaseRoot === void 0 || toml === void 0) return [];
+	const path = join(supabaseRoot, "supabase/config.toml");
+	const shown = display(base, path);
+	if (diffEngine(toml) === "pg-delta") return [];
+	if (tomlGet(toml.document, ["experimental", "pgdelta"]) !== void 0 || toml.text.includes("pgdelta")) return [`Kept    ${shown} (pg-delta is off; set [experimental.pgdelta] enabled = true, remove [db.migrations] schema_paths and use \`supabase db schema declarative sync\` instead of \`supabase db diff\`)`];
+	if (args["dry-run"] === true) return [`Would enable pg-delta in ${shown}`];
+	const separator = toml.text === "" || toml.text.endsWith("\n\n") ? "" : toml.text.endsWith("\n") ? "\n" : "\n\n";
+	await writeIfChanged(path, `${toml.text}${separator}${PGDELTA_TABLE}`);
+	return [`Enabled pg-delta in ${shown}`];
+}
+/** The minor of `@supabase/lite` the `backend: 'lite'` option targets. */
+const LITE_VERSION = "0.11";
+/**
+* pg (or `@supabase/lite`, with `lite`) and the pinned postgrest-typegen as
+* dev dependencies, the ones the project lacks.
+*/
+function devPackages(project, lite) {
+	const database = lite ? "@supabase/lite" : "pg";
+	const missing = [...database in project.dependencies ? [] : [lite ? `${database}@${LITE_VERSION}` : database], ..."@supabase/postgrest-typegen" in project.dependencies ? [] : [`@supabase/postgrest-typegen@${TYPEGEN_VERSION}`]];
+	return missing.length === 0 ? [] : [missing];
+}
+/** Where `init` writes: `--cwd`, `--package`, or the workspace package the person picks. */
+async function initTarget(cwd, args, prompts) {
+	if (args.package !== void 0) {
+		const dir = posix.normalize(args.package.replaceAll("\\", "/"));
+		if (!existsSync(join(cwd, dir, "package.json"))) return {
+			code: 2,
+			error: `--package ${args.package} has no package.json. Pass the directory of a workspace package, relative to --cwd.`
+		};
+		return { dir: dir.replace(/\/$/, "") || "." };
+	}
+	const workspace = await detectWorkspace(cwd);
+	if (!workspace || workspace.packages.length === 0) return { dir: "." };
+	const suggested = suggestedPackage(workspace) ?? ".";
+	if (!prompts) return {
+		code: 2,
+		error: `${workspace.file} makes this a workspace root. Pass --package with the package that owns the runtime (${workspace.packages.map((entry) => entry.dir).join(", ")}), or --package . to write here.`
+	};
+	const dir = await prompts.select("Package that owns the runtime", [...workspace.packages.map((entry) => ({
+		value: entry.dir,
+		label: entry.dir,
+		...entry.project.name ? { hint: entry.project.name } : {}
+	})), {
+		value: ".",
+		label: ".",
+		hint: "the workspace root"
+	}], suggested);
+	return dir === void 0 ? CANCELLED : { dir };
+}
+async function runInit(config, args, prompts) {
+	const casing = args.casing ?? (prompts ? await prompts.select("Row keys", [{
+		value: "camel",
+		label: "camelCase",
+		hint: "customerId"
+	}, {
+		value: "snake",
+		label: "snake_case",
+		hint: "customer_id, as in the database"
+	}], "camel") : "camel");
+	if (casing === void 0) return CANCELLED;
+	if (casing !== "camel" && casing !== "snake") return {
+		code: 2,
+		error: "--casing must be \"camel\" or \"snake\""
+	};
+	const target = await initTarget(config.root, args, prompts);
+	if ("code" in target) return target;
+	const root = resolve(config.root, target.dir);
+	const inPackage = target.dir !== ".";
+	const workspaceProject = await detectProject(config.root);
+	const project = inPackage ? {
+		...await detectProject(root),
+		packageManager: workspaceProject.packageManager
+	} : workspaceProject;
+	const lite = args.lite === true;
+	const installTarget = inPackage ? {
+		dir: target.dir,
+		name: project.name
+	} : void 0;
+	const requested = parseIntegrations(list(args.with));
+	if (typeof requested === "string") return {
+		code: 2,
+		error: requested
+	};
+	const detected = resolveIntegrations([...suggestedIntegrations(project.frameworks), ...requested]);
+	const chosen = args.with === void 0 && prompts ? await chooseIntegrations(prompts, detected) : detected;
+	if (chosen === void 0) return CANCELLED;
+	const integrations = resolveIntegrations(chosen);
+	const hasConfig = findConfig(root) !== void 0;
+	let generated = posix.normalize(posix.join(project.srcDir, "lib/supabase/generated.ts"));
+	if (hasConfig) generated = inPackage ? (await loadConfig(root)).output : config.output;
+	const templateContext = templateContextFor(project, generated);
+	const files = [...baseFiles(templateContext, casing, needsLib(integrations), integrations), ...integrationFiles(integrations, templateContext)];
+	const force = await overwrite(root, files, args, prompts, config.root);
+	if (force === void 0) return CANCELLED;
+	const where = inPackage ? ` in ${target.dir}` : "";
+	const lines = [
+		project.frameworks.length > 0 ? `Found ${project.frameworks.join(", ")}${where}.` : `No framework found${where}.`,
+		"",
+		...await writeFiles(root, files, args, force, config.root),
+		...await enablePgDelta(root, args, config.root)
+	];
+	const packages = packagesFor(project, integrations);
+	const cwdFlag = inPackage ? ` --cwd ${target.dir}` : "";
+	const steps = [
+		...packages.length > 0 ? [installCommand(project.packageManager, packages, false, installTarget)] : [],
+		...devPackages(project, lite).map((names) => installCommand(project.packageManager, names, true, installTarget)),
+		...project.hasSupabase || workspaceProject.hasSupabase ? [] : [lite ? "npx lite init" : "supabase init"],
+		...lite ? ["Set jwt_secret = \"env(SUPABASE_JWT_SECRET)\" under [auth] in supabase/config.toml, and add SUPABASE_URL=http://127.0.0.1:54321 and a SUPABASE_JWT_SECRET of 32 or more characters to .env", "npx lite dev"] : ["supabase start", `better-supabase env${cwdFlag}`],
+		`better-supabase gen${cwdFlag}`
+	];
+	lines.push("", "Next:", ...steps.map((step, index) => `  ${index + 1}. ${step}`));
+	if (lite) lines.push("  - Pass backend: 'lite' to createServer (or createNext, createHono, createEdge, createOrpc): https://bettersupabase.com/docs/platform/lite");
+	for (const name of integrations) for (const hint of TEMPLATES[name].next ?? []) lines.push(`  - ${hint}`);
+	lines.push("", "Agent skills: better-supabase skills install");
+	return {
+		code: 0,
+		output: lines.join("\n")
+	};
+}
+const initCommand = defineCliCommand({
+	meta: {
+		name: "init",
+		description: "Writes better-supabase.config.ts, src/lib/supabase/index.ts and glue for the frameworks in package.json"
+	},
+	args: INIT_ARGS,
+	lists: ["with"],
+	run: (args, { config, io }) => runInit(config, args, io.prompts)
+});
+//#endregion
+export { initCommand };

package/dist/cli/{introspect-Bzuv1HHj.js → introspect-BToGNfm-.js}

@@ -1,11 +1,11 @@
-import { r as defineCliCommand } from "./command-CK14fP91.js";
-import { i as writeIfChanged, r as sameText, t as display } from "./io-DI1mTdSA.js";
-import { r as painter } from "./style-C0NFdJRL.js";
-import { t as fileDiff } from "./diff-SjkO5rNr.js";
-import { T as serializeGenerator, c as loadSnapshot, f as serializeSnapshot, s as sourceArgs, t as SOURCE_ARGS, w as restrictSchemas } from "./gen-AIf4MREI.js";
-import { n as withSpinner } from "./prompts-BNcNfAve.js";
-import { resolve } from "node:path";
-import { readFile } from "node:fs/promises";
+import { r as defineCliCommand } from "./command-DV-StG1x.js";
+import { r as painter } from "./style-CB3vxgh0.js";
+import { c as serializeGenerator, s as restrictSchemas } from "./typegen-Demi5-VQ.js";
+import { a as serializeSnapshot, t as loadSnapshot } from "./snapshot-Bstk6ulj.js";
+import { t as fileDiff } from "./diff-D1jGdb3Y.js";
+import { n as withSpinner } from "./prompts-DZJB1nTw.js";
+import { r as writeLine, t as fileState } from "./files-BVupXPIC.js";
+import { n as sourceArgs, t as SOURCE_ARGS } from "./source-args-BYfq6imV.js";
 //#region src/cli/commands/introspect.ts
 const ARGS = {
 	out: {
@@ -44,10 +44,10 @@ const introspectCommand = defineCliCommand({
 		}));
 		const out = args.out ?? (format === "snapshot" ? config.source.snapshot ?? "supabase/snapshot.json" : "supabase/generator-metadata.json");
 		const contents = format === "snapshot" ? serializeSnapshot(snapshot) : `${await serializeGenerator(restrictSchemas(snapshot.generator, config.schemas))}\n`;
+		const state = await fileState(config.root, out, contents);
 		if (args.check === true) {
-			const current = await readFile(resolve(config.root, out), "utf8").catch(() => void 0);
-			const file = display(config.root, out);
-			return sameText(current, contents) ? {
+			const { file, current, upToDate } = state;
+			return upToDate ? {
 				code: 0,
 				output: `${file} is up to date.`,
 				data: {
@@ -64,13 +64,13 @@ const introspectCommand = defineCliCommand({
 				}
 			};
 		}
-		const wrote = await writeIfChanged(resolve(config.root, out), contents);
 		const tables = snapshot.extras.tables.length;
+		const { wrote, line } = await writeLine(state.path, contents, state.file, ` (${tables} tables).`);
 		return {
 			code: 0,
-			output: `${wrote ? "Wrote" : "Unchanged"} ${display(config.root, out)} (${tables} tables).`,
+			output: line,
 			data: {
-				file: display(config.root, out),
+				file: state.file,
 				written: wrote,
 				tables
 			}

package/dist/cli/{io-DI1mTdSA.js → io-CFzJVJ68.js}

@@ -11,6 +11,10 @@ const withLf = (text) => text.replaceAll("\r\n", "\n");
 function sameText(current, expected) {
 	return current !== void 0 && withLf(current) === withLf(expected);
 }
+/** The file's text, or `undefined` when it does not exist. */
+async function readIfExists(path) {
+	return existsSync(path) ? readFile(path, "utf8") : void 0;
+}
 /** Writes a file when its contents changed, ignoring line endings. Returns whether it wrote. */
 async function writeIfChanged(path, contents) {
 	if (existsSync(path)) {
@@ -30,4 +34,4 @@ function display(root, path) {
 	return relative(root, resolve(root, path)).split(sep).join("/") || ".";
 }
 //#endregion
-export { writeIfChanged as i, importPath as n, sameText as r, display as t };
+export { writeIfChanged as a, sameText as i, importPath as n, readIfExists as r, display as t };

package/dist/cli/{keys-BGCnnb-s.js → keys-CJhtIxJ3.js}

@@ -1,5 +1,5 @@
-import { r as defineCliCommand } from "./command-CK14fP91.js";
-import { t as display } from "./io-DI1mTdSA.js";
+import { r as defineCliCommand } from "./command-DV-StG1x.js";
+import { t as display } from "./io-CFzJVJ68.js";
 import { f as supabaseDir } from "./supabase-toml-B-bIukQF.js";
 import { dirname, resolve } from "node:path";
 import { existsSync } from "node:fs";
@@ -8,7 +8,7 @@ import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
 const ARGS = {
 	out: {
 		type: "string",
-		description: "Defaults to supabase/signing_keys.json",
+		description: "Defaults to keys.output, then supabase/signing_keys.json",
 		valueHint: "file"
 	},
 	rotate: {
@@ -41,7 +41,7 @@ async function createSigningKey() {
 }
 async function runKeys(config, args) {
 	const dir = supabaseDir(config.root);
-	const out = args.out ?? `${dir}/signing_keys.json`;
+	const out = args.out ?? config.keys.output ?? `${dir}/signing_keys.json`;
 	const path = resolve(config.root, out);
 	const rotate = args.rotate === true;
 	const exists = existsSync(path);

package/dist/cli/metadata-DSRKCaf-.js

@@ -0,0 +1,133 @@
+import { r as errorText } from "./errors-CqTLXe2M.js";
+import { a as parseMetadataDocument, t as MetadataRejectedError } from "./typegen-Demi5-VQ.js";
+import { i as metaPaths } from "./emit-BHHfwUoT.js";
+import { i as generationNotices, n as runGen, o as fromMetadata, r as UNFORMATTED, t as refuseRowConditionedBuckets, v as render } from "./run-DuN1MX-7.js";
+import { basename, join, relative, resolve, sep } from "node:path";
+import { readFile } from "node:fs/promises";
+import { jsonSchema, standardSchema, valibot, zod } from "better-supabase/config";
+//#region src/cli/gen/metadata.ts
+/** The files `gen --metadata` can write to stdout. */
+const EMITS = [
+	"schema",
+	"types",
+	"zod",
+	"valibot",
+	"json-schema",
+	"standard-schema"
+];
+const isEmit = (value) => EMITS.some((emit) => emit === value);
+/** The configured generator for an `--emit` target, or one with its defaults. */
+function emitGenerator(config, emit) {
+	const configured = config.generators.find((generator) => generator.name === emit);
+	switch (emit) {
+		case "schema":
+		case "types": return;
+		case "zod": return configured ?? zod();
+		case "valibot": return configured ?? valibot();
+		case "json-schema": return configured ?? jsonSchema();
+		case "standard-schema": return configured ?? standardSchema();
+		default: throw new Error(`unknown --emit ${String(emit)}`);
+	}
+}
+/**
+* The one file `gen --metadata` prints: the `defineSchema` module with its
+* metadata inlined, `database.types.ts`, or one generator's output.
+*/
+async function renderEmit(config, snapshot, emit) {
+	const generator = emitGenerator(config, emit);
+	const { files, warnings } = await render({
+		...config,
+		generators: generator ? [generator] : []
+	}, snapshot, { inlineMeta: emit === "schema" });
+	const path = emit === "schema" ? config.output : emit === "types" ? config.databaseTypesOutput : void 0;
+	const own = /* @__PURE__ */ new Set([
+		config.databaseTypesOutput,
+		config.output,
+		...Object.values(metaPaths(config.output))
+	]);
+	const picked = path === void 0 ? files.filter((file) => !own.has(file.path)) : files.filter((file) => file.path === path);
+	const [file] = picked;
+	if (!file || picked.length > 1) throw new Error(`--emit ${emit} expects one file, and the generator wrote ${picked.length}. Pass --out <dir> to write them all.`);
+	return {
+		files: picked,
+		warnings,
+		contents: file.contents
+	};
+}
+/**
+* Reads `--metadata <path|->` (a file relative to `cwd`, or stdin for `-`)
+* into a snapshot. Throws `MetadataRejectedError` for a document that can't
+* be read or that `parseMetadataDocument` refuses.
+*/
+async function readMetadataSnapshot(source, cwd, io) {
+	let text;
+	try {
+		if (source !== "-") text = await readFile(resolve(cwd, source), "utf8");
+		else if (io.stdin) text = await io.stdin();
+		else throw new Error("there is no stdin to read");
+	} catch (cause) {
+		throw new MetadataRejectedError(`Could not read ${source === "-" ? "stdin" : source}: ${errorText(cause)}`);
+	}
+	return fromMetadata(await parseMetadataDocument(text));
+}
+/**
+* `gen --metadata`: the out-of-process generator contract of
+* `@supabase/typegen`. Without `--out` it prints one file on stdout and
+* everything else on stderr; with `--out` it writes the usual files there.
+*/
+async function runMetadataGen(options) {
+	const { config, io } = options;
+	const emit = options.emit ?? "schema";
+	if (!isEmit(emit)) return {
+		code: 2,
+		error: `--emit must be one of ${EMITS.join(", ")}, got "${emit}"`
+	};
+	if (options.out !== void 0 && options.emit !== void 0) return {
+		code: 2,
+		error: "--emit picks the one file gen prints; --out writes them all. Pass one of them."
+	};
+	if (options.out === void 0 && options.check) return {
+		code: 2,
+		error: "--check with --metadata needs --out <dir>"
+	};
+	if (options.out === void 0 && options.json) return {
+		code: 2,
+		error: "--metadata prints the generated code on stdout, so --json has nothing to print. Pass --out <dir> for the JSON summary."
+	};
+	let snapshot;
+	try {
+		snapshot = await readMetadataSnapshot(options.metadata, options.cwd, io);
+	} catch (cause) {
+		if (cause instanceof MetadataRejectedError) return {
+			code: 65,
+			error: cause.message
+		};
+		throw cause;
+	}
+	if (options.out !== void 0) {
+		const dir = relative(config.root, resolve(options.cwd, options.out));
+		const into = (path) => join(dir, basename(path)).split(sep).join("/");
+		return runGen({
+			config: {
+				...config,
+				output: into(config.output),
+				databaseTypesOutput: into(config.databaseTypesOutput)
+			},
+			env: options.env,
+			check: options.check,
+			snapshot,
+			isolated: true,
+			...options.paint ? { paint: options.paint } : {}
+		});
+	}
+	const refused = refuseRowConditionedBuckets(config);
+	if (refused) return refused;
+	const { contents, warnings } = await renderEmit(config, snapshot, emit);
+	io.stdout(contents);
+	const notices = await generationNotices(snapshot, warnings);
+	const shown = emit === "types" ? notices : notices.filter((line) => line !== UNFORMATTED);
+	for (const line of shown) io.stderr(`${line}\n`);
+	return { code: 0 };
+}
+//#endregion
+export { readMetadataSnapshot as n, runMetadataGen as r, EMITS as t };

package/dist/cli/names-D6LrQnOv.js

@@ -0,0 +1,6 @@
+import { GEN_TASKS, INTEGRATION_NAMES } from "better-supabase/config";
+//#region src/cli/names.ts
+const INTEGRATIONS = INTEGRATION_NAMES;
+const isGenTask = (value) => GEN_TASKS.some((task) => task === value);
+//#endregion
+export { INTEGRATIONS as n, isGenTask as r, GEN_TASKS as t };