better-supabase 0.8.0 → 0.9.0

package/dist/cli/init-CVZ3s5kl.js

@@ -1,258 +0,0 @@
-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-BToGNfm-.js

@@ -1,81 +0,0 @@
-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: {
-		type: "string",
-		description: "Defaults to source.snapshot, supabase/snapshot.json, or supabase/generator-metadata.json",
-		valueHint: "file"
-	},
-	format: {
-		type: "string",
-		description: "snapshot (the default) or generator-metadata (postgrest-typegen's input)",
-		valueHint: "snapshot|generator-metadata"
-	},
-	check: {
-		type: "boolean",
-		description: "Fail when the file is out of date"
-	},
-	...SOURCE_ARGS
-};
-const introspectCommand = defineCliCommand({
-	meta: {
-		name: "introspect",
-		description: "Saves the database schema as a snapshot for offline gen"
-	},
-	args: ARGS,
-	run: async (args, { config, env, io, signal }) => {
-		const format = args.format ?? "snapshot";
-		if (format !== "snapshot" && format !== "generator-metadata") return {
-			code: 2,
-			error: "--format must be \"snapshot\" or \"generator-metadata\""
-		};
-		const { snapshotPath: _ignored, ...source } = await sourceArgs(args, io);
-		const snapshot = await withSpinner(io.prompts, "Reading the schema", () => loadSnapshot(config, env, {
-			...source,
-			live: true,
-			...signal ? { signal } : {}
-		}));
-		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 { file, current, upToDate } = state;
-			return upToDate ? {
-				code: 0,
-				output: `${file} is up to date.`,
-				data: {
-					file,
-					upToDate: true
-				}
-			} : {
-				code: 1,
-				output: fileDiff(file, current, contents, painter(io.color)),
-				error: `${file} is out of date. Run \`better-supabase introspect\`.`,
-				data: {
-					file,
-					upToDate: false
-				}
-			};
-		}
-		const tables = snapshot.extras.tables.length;
-		const { wrote, line } = await writeLine(state.path, contents, state.file, ` (${tables} tables).`);
-		return {
-			code: 0,
-			output: line,
-			data: {
-				file: state.file,
-				written: wrote,
-				tables
-			}
-		};
-	}
-});
-//#endregion
-export { introspectCommand };

package/dist/cli/io-CFzJVJ68.js

@@ -1,37 +0,0 @@
-import { dirname, relative, resolve, sep } from "node:path";
-import { existsSync } from "node:fs";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-//#region src/cli/io.ts
-/** `text` with `\r\n` line endings turned into `\n`. */
-const withLf = (text) => text.replaceAll("\r\n", "\n");
-/**
-* Whether a file on disk holds `expected`, ignoring line endings: a checkout
-* with `core.autocrlf` turns every `\n` into `\r\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)) {
-		if (sameText(await readFile(path, "utf8"), contents)) return false;
-	}
-	await mkdir(dirname(path), { recursive: true });
-	await writeFile(path, contents);
-	return true;
-}
-/** Relative ESM import specifier from one file to another, keeping `.ts`. */
-function importPath(fromFile, toFile) {
-	let path = relative(dirname(fromFile), toFile).split(sep).join("/");
-	if (!path.startsWith(".")) path = `./${path}`;
-	return path;
-}
-function display(root, path) {
-	return relative(root, resolve(root, path)).split(sep).join("/") || ".";
-}
-//#endregion
-export { writeIfChanged as a, sameText as i, importPath as n, readIfExists as r, display as t };

package/dist/cli/jsonc-BUniUpOk.js

@@ -1,2 +0,0 @@
-import { t as i } from "./jsonc-D5Fu67jw.js";
-export { i as parseJSONC };

package/dist/cli/keys-CJhtIxJ3.js

@@ -1,85 +0,0 @@
-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";
-import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
-//#region src/cli/commands/keys.ts
-const ARGS = {
-	out: {
-		type: "string",
-		description: "Defaults to keys.output, then supabase/signing_keys.json",
-		valueHint: "file"
-	},
-	rotate: {
-		type: "boolean",
-		description: "Put a new key first (it signs) and keep the old ones (they still verify)"
-	},
-	force: {
-		type: "boolean",
-		description: "Replace the file"
-	}
-};
-async function createSigningKey() {
-	const pair = await crypto.subtle.generateKey({
-		name: "ECDSA",
-		namedCurve: "P-256"
-	}, true, ["sign", "verify"]);
-	const jwk = await crypto.subtle.exportKey("jwk", pair.privateKey);
-	return {
-		kty: "EC",
-		kid: crypto.randomUUID(),
-		use: "sig",
-		key_ops: ["sign", "verify"],
-		alg: "ES256",
-		ext: true,
-		crv: jwk.crv,
-		x: jwk.x,
-		y: jwk.y,
-		d: jwk.d
-	};
-}
-async function runKeys(config, args) {
-	const dir = supabaseDir(config.root);
-	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);
-	if (exists && !rotate && args.force !== true) return {
-		code: 1,
-		error: `${display(config.root, out)} exists. Use --rotate to add a key or --force to replace it.`
-	};
-	const previous = exists && rotate ? JSON.parse(await readFile(path, "utf8")) : [];
-	if (!Array.isArray(previous)) return {
-		code: 1,
-		error: `${display(config.root, out)} is not a JSON array of keys.`
-	};
-	const key = await createSigningKey();
-	await mkdir(dirname(path), { recursive: true });
-	await writeFile(path, `${JSON.stringify([key, ...previous], null, 2)}\n`, { mode: 384 });
-	await chmod(path, 384);
-	const lines = [`Wrote ${display(config.root, out)} with key ${key.kid}${previous.length > 0 ? ` (${previous.length} older key${previous.length === 1 ? "" : "s"} kept for verification)` : ""}.`];
-	const toml = resolve(config.root, dir, "config.toml");
-	if (!(existsSync(toml) && /^\s*signing_keys_path\s*=/m.test(await readFile(toml, "utf8")))) {
-		const relativeToSupabase = out.startsWith(`${dir}/`) ? `./${out.slice(dir.length + 1)}` : out;
-		lines.push("", `Add it to ${dir}/config.toml and restart the stack:`, "  [auth]", `  signing_keys_path = "${relativeToSupabase}"`);
-	}
-	const gitignored = [resolve(config.root, ".gitignore"), resolve(config.root, dir, ".gitignore")];
-	let ignored = false;
-	for (const file of gitignored) if (existsSync(file) && (await readFile(file, "utf8")).includes("signing_keys")) ignored = true;
-	if (!ignored) lines.push("", `Warning: add ${out} to .gitignore; it holds a private key.`);
-	return {
-		code: 0,
-		output: lines.join("\n")
-	};
-}
-const keysCommand = defineCliCommand({
-	meta: {
-		name: "keys",
-		description: "Creates an ES256 signing key for the local stack, so local tokens verify through JWKS like hosted ones"
-	},
-	args: ARGS,
-	run: (args, { config }) => runKeys(config, args)
-});
-//#endregion
-export { keysCommand };

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

@@ -1,133 +0,0 @@
-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/openapi-DWa4Ir1q.js

@@ -1,60 +0,0 @@
-import { r as defineCliCommand } from "./command-DV-StG1x.js";
-import { t as display } from "./io-CFzJVJ68.js";
-import { a as importExport } from "./config-M-WzL9O2.js";
-import { n as staleResult, r as writeLine, t as fileState } from "./files-BVupXPIC.js";
-import { resolve } from "node:path";
-//#region src/cli/commands/openapi.ts
-const ARGS = {
-	action: {
-		type: "positional",
-		required: false,
-		description: "emit"
-	},
-	check: {
-		type: "boolean",
-		description: "Fail when the file differs from the document"
-	},
-	entry: {
-		type: "string",
-		description: "Defaults to openapi.entry. Exports `openapi` or default: a document or a function returning one",
-		valueHint: "file"
-	},
-	out: {
-		type: "string",
-		description: "Defaults to openapi.output",
-		valueHint: "file"
-	}
-};
-async function runOpenApi(config, args) {
-	const [action] = args._;
-	if (action !== "emit") return {
-		code: 2,
-		error: `${action ? `Unknown openapi action "${action}"` : "Name an action"}. Run \`better-supabase openapi emit\`.`
-	};
-	const entry = args.entry ?? config.openapi.entry;
-	const out = args.out ?? config.openapi.output;
-	const exported = await importExport(resolve(config.root, entry), "openapi");
-	const document = typeof exported === "function" ? await exported() : exported;
-	if (typeof document !== "object" || document === null || !("openapi" in document)) return {
-		code: 1,
-		error: `${display(config.root, entry)} must export an OpenAPI document (createOpenApi(...)) as \`openapi\` or default.`
-	};
-	const contents = `${JSON.stringify(document, null, 2)}\n`;
-	const state = await fileState(config.root, out, contents);
-	if (args.check === true) return staleResult(state, "better-supabase openapi emit");
-	const { line } = await writeLine(state.path, contents, state.file);
-	return {
-		code: 0,
-		output: line
-	};
-}
-const openapiCommand = defineCliCommand({
-	meta: {
-		name: "openapi",
-		description: "Writes the document your createOpenApi() module exports, so CI can check it for drift"
-	},
-	args: ARGS,
-	run: (args, { config }) => runOpenApi(config, args)
-});
-//#endregion
-export { openapiCommand };