better-supabase 0.14.0 → 0.15.0

package/dist/cli/snapshot-C8MVPyO8.js

@@ -0,0 +1,729 @@
+import { n as CliError, r as errorText } from "./errors-BTe6A15O.js";
+import { d as readExtras, l as TYPEGEN_VERSION, r as cachedIntrospect } from "./cache-CXgR_Ahi.js";
+import { t as byCodePoint } from "./compare-BmIWVEui.js";
+import { n as managementSource, r as pgSource } from "./source-DANaJJVc.js";
+import { n as databaseUrl, u as accessToken } from "./config-9t5ec_N7.js";
+import { d as readSupabaseToml, f as schemaPaths, h as tomlGet, u as pgFunctionHooks } from "./supabase-toml-CncmQbO0.js";
+import { t as connect } from "./db-CQCLx7cx.js";
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { readFile, readdir } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+//#region src/cli/peers.ts
+const VERSION = /^v?(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+function parseVersion(text) {
+	const match = VERSION.exec(text.trim());
+	if (!match) return;
+	return [
+		Number(match[1]),
+		Number(match[2] ?? 0),
+		Number(match[3] ?? 0),
+		match[4] === void 0 ? [] : match[4].split(".")
+	];
+}
+const NUMERIC = /^\d+$/;
+function compareIdentifiers(a, b) {
+	const numeric = NUMERIC.test(a);
+	if (numeric !== NUMERIC.test(b)) return numeric ? -1 : 1;
+	if (numeric) return Number(a) - Number(b);
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+function compare(a, b) {
+	for (const index of [
+		0,
+		1,
+		2
+	]) if (a[index] !== b[index]) return a[index] - b[index];
+	const [, , , left] = a;
+	const [, , , right] = b;
+	if (left.length === 0 || right.length === 0) return right.length - left.length;
+	for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
+		const x = left[index];
+		const y = right[index];
+		if (x === void 0) return -1;
+		if (y === void 0) return 1;
+		const order = compareIdentifiers(x, y);
+		if (order !== 0) return order;
+	}
+	return 0;
+}
+const sameRelease = (a, b) => a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
+const COMPARATOR = /^(>=|<=|>|<|=|\^)?\s*(\S+)$/;
+/** The next version a caret range excludes: `^1.2` is below 2, `^0.4` below 0.5. */
+function caretCeiling([major, minor, patch]) {
+	if (major > 0) return [
+		major + 1,
+		0,
+		0,
+		[]
+	];
+	if (minor > 0) return [
+		0,
+		minor + 1,
+		0,
+		[]
+	];
+	return [
+		0,
+		0,
+		patch + 1,
+		[]
+	];
+}
+function comparators(range) {
+	const parts = range.trim().replaceAll(/(>=|<=|>|<|=|\^)\s+/g, "$1").split(/\s+/).filter((part) => part.length > 0);
+	const result = [];
+	for (const part of parts) {
+		const match = COMPARATOR.exec(part);
+		const version = match ? parseVersion(match[2]) : void 0;
+		if (!match || !version) return;
+		const operator = match[1] ?? "=";
+		if (operator === "^") result.push({
+			operator: ">=",
+			version
+		}, {
+			operator: "<",
+			version: caretCeiling(version)
+		});
+		else result.push({
+			operator,
+			version
+		});
+	}
+	return result;
+}
+function holds(version, { operator, version: bound }) {
+	const order = compare(version, bound);
+	switch (operator) {
+		case ">=": return order >= 0;
+		case ">": return order > 0;
+		case "<=": return order <= 0;
+		case "<": return order < 0;
+		case "=": return order === 0;
+		default: return operator;
+	}
+}
+/**
+* Whether `version` is in `range`, for the ranges better-supabase declares:
+* `||` alternatives of space-separated comparators (`>=`, `>`, `<=`, `<`,
+* exact) and caret ranges. As in npm, a prerelease only matches a set with a
+* comparator on the same release that has a prerelease too. `undefined` when
+* either can't be parsed.
+*/
+function satisfies(version, range) {
+	const parsed = parseVersion(version);
+	if (!parsed) return;
+	const sets = range.split("||").map(comparators);
+	if (sets.some((set) => set === void 0)) return;
+	return sets.some((set) => set !== void 0 && set.every((comparator) => holds(parsed, comparator)) && (parsed[3].length === 0 || set.some(({ version: bound }) => bound[3].length > 0 && sameRelease(bound, parsed))));
+}
+async function readManifest(path) {
+	try {
+		const data = JSON.parse(await readFile(path, "utf-8"));
+		return typeof data === "object" && data !== null ? data : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* The version of `name` that `root` resolves, looking in `node_modules` up to
+* the file system root.
+*/
+async function installedVersion(name, root) {
+	let dir = root;
+	for (;;) {
+		const manifest = await readManifest(join(dir, "node_modules", name, "package.json"));
+		if (typeof manifest?.["version"] === "string") return manifest["version"];
+		const parent = dirname(dir);
+		if (parent === dir) return;
+		dir = parent;
+	}
+}
+/** The version in the nearest `package.json` above a resolved module file. */
+async function versionAt(file) {
+	let dir = dirname(file);
+	for (;;) {
+		const manifest = await readManifest(join(dir, "package.json"));
+		if (manifest && typeof manifest["version"] === "string") return manifest["version"];
+		const parent = dirname(dir);
+		if (parent === dir) return;
+		dir = parent;
+	}
+}
+/** The `peerDependencies` of the better-supabase package this CLI ships in. */
+async function declaredPeers() {
+	const peers = (await readManifest(fileURLToPath(import.meta.resolve("better-supabase/package.json"))))?.["peerDependencies"];
+	if (typeof peers !== "object" || peers === null) return {};
+	return Object.fromEntries(Object.entries(peers).filter((entry) => typeof entry[1] === "string"));
+}
+/** Every declared peer with the version `root` resolves. */
+async function peerVersions(root) {
+	const peers = await declaredPeers();
+	return Promise.all(Object.entries(peers).map(async ([name, range]) => ({
+		name,
+		range,
+		installed: await installedVersion(name, root)
+	})));
+}
+//#endregion
+//#region src/cli/introspect/typegen.ts
+const TYPEGEN = "@supabase/postgrest-typegen";
+/** Why a command that reads or generates schema types stops without the peer. */
+const TYPEGEN_MISSING = `better-supabase needs the "${TYPEGEN}" package to read your schema and generate types. Install it: pnpm add -D ${TYPEGEN}@${TYPEGEN_VERSION}`;
+/** Thrown by every function here when the optional peer is not installed. */
+var TypegenMissingError = class extends Error {
+	constructor() {
+		super(TYPEGEN_MISSING);
+		this.name = "TypegenMissingError";
+	}
+};
+const missing = () => {
+	throw new TypegenMissingError();
+};
+/**
+* `/generation` is light and its functions are synchronous (`buildModel` calls
+* `tsTypeOf`), so it loads with this module, which the commands that need it
+* import on demand. The package root and `/introspection` build their arktype
+* schemas on import (about 90 ms), so they load when a command reads or
+* validates metadata, not for `--help`.
+*/
+const generation = await import("@supabase/postgrest-typegen/generation").catch(() => void 0);
+const loadGeneration = () => generation ?? missing();
+/** The installed postgrest-typegen release, `undefined` when it is missing. */
+async function typegenVersion() {
+	if (generation === void 0) return;
+	return versionAt(fileURLToPath(import.meta.resolve(`${TYPEGEN}/generation`)));
+}
+/**
+* Notice for a postgrest-typegen release other than the one this CLI is tested
+* against.
+*/
+function typegenVersionNotice(installed) {
+	if (installed === void 0 || installed === "0.6.0") return;
+	return `Notice: ${TYPEGEN}@${installed} is installed; this better-supabase release is tested against ${TYPEGEN_VERSION}. database.types.ts can differ from \`supabase gen types\` output until both use the same release. Pin it: pnpm add -D ${TYPEGEN}@${TYPEGEN_VERSION}`;
+}
+const metadataModule = () => import("@supabase/postgrest-typegen").catch(missing);
+const introspectionModule = () => import("@supabase/postgrest-typegen/introspection").catch(missing);
+/** Introspects `schemas`, keeping only the types they reference. */
+async function readGeneratorMetadata(db, schemas) {
+	const [metadata, positions] = await Promise.all([introspectionModule().then(({ introspect }) => introspect(db, { includedSchemas: [...schemas] })), db.query(argumentPositionsSql(schemas))]);
+	return pruneTypes(orderArgsByPosition(metadata, positions.rows), schemas);
+}
+const sqlLiteral = (value) => `'${value.replaceAll("'", "''")}'`;
+/**
+* The argument order postgrest-typegen loses: its catalog query aggregates the
+* arguments without an order, so two unnamed arguments (pgvector's operators,
+* citext casts) swap places between database resets.
+*/
+function argumentPositionsSql(schemas) {
+	return `select p.oid::int8 as id,
+  coalesce(p.proallargtypes, p.proargtypes::oid[])::int8[] as types,
+  p.proargnames as names
+from pg_catalog.pg_proc p
+join pg_catalog.pg_namespace n on n.oid = p.pronamespace
+where p.prokind = 'f'
+  and n.nspname = any (array[${schemas.map(sqlLiteral).join(", ") || "''"}]::text[])`;
+}
+/**
+* `rpcFunctions` is derived from `functions`, so it goes stale when they are
+* reordered, renumbered or filtered. Generators resolve it again when it is
+* absent.
+*/
+function withoutRpcFunctions({ rpcFunctions: _derived, ...metadata }) {
+	return metadata;
+}
+/**
+* Puts every function's arguments back in declaration order, so the sort by
+* name that follows (stable) keeps unnamed arguments by position.
+*/
+function orderArgsByPosition(metadata, rows) {
+	const byId = new Map(rows.map((row) => [Number(row.id), row]));
+	return {
+		...withoutRpcFunctions(metadata),
+		functions: metadata.functions.map((fn) => {
+			const row = byId.get(fn.id);
+			if (!row?.types || fn.args.length < 2) return fn;
+			const pending = [...fn.args];
+			const ordered = [];
+			for (const [index, type] of row.types.entries()) {
+				const name = row.names?.[index] ?? "";
+				const at = pending.findIndex((arg) => arg.type_id === Number(type) && arg.name === name);
+				if (at !== -1) ordered.push(...pending.splice(at, 1));
+			}
+			return {
+				...fn,
+				args: [...ordered, ...pending]
+			};
+		})
+	};
+}
+/** Postgres assigns oids below this to built-in objects; those are stable. */
+const FIRST_NORMAL_OID = 16384;
+/**
+* Replaces the oids of user objects with ids derived from their names and
+* zeroes size estimates, so a snapshot of the same schema is byte-identical
+* after `supabase db reset` or on another machine. Returns the id mapping for
+* data keyed by the old oids.
+*/
+function stabilizeMetadata(metadata) {
+	const ids = /* @__PURE__ */ new Map();
+	const assign = (base, entries) => {
+		const sorted = entries.toSorted((a, b) => byCodePoint(a.key, b.key));
+		for (const [index, entry] of sorted.entries()) if (entry.id >= FIRST_NORMAL_OID) ids.set(entry.id, base + index);
+	};
+	assign(1e6, [
+		...metadata.tables,
+		...metadata.foreignTables,
+		...metadata.views,
+		...metadata.materializedViews
+	].map((entry) => ({
+		id: entry.id,
+		key: `${entry.schema}.${entry.name}`
+	})));
+	assign(2e6, metadata.types.map((entry) => ({
+		id: entry.id,
+		key: `${entry.schema}.${entry.name}`
+	})));
+	assign(3e6, metadata.functions.map((entry) => ({
+		id: entry.id,
+		key: `${entry.schema}.${entry.name}(${entry.identity_argument_types})`
+	})));
+	assign(4e6, metadata.schemas.map((entry) => ({
+		id: entry.id,
+		key: entry.name
+	})));
+	const map = (id) => ids.get(id) ?? id;
+	const mapNullable = (id) => id === null ? null : map(id);
+	const stable = {
+		...withoutRpcFunctions(metadata),
+		schemas: metadata.schemas.map((entry) => ({
+			...entry,
+			id: map(entry.id)
+		})),
+		tables: metadata.tables.map((entry) => ({
+			...entry,
+			id: map(entry.id),
+			bytes: 0,
+			size: "0 bytes",
+			live_rows_estimate: 0,
+			dead_rows_estimate: 0
+		})),
+		foreignTables: metadata.foreignTables.map((entry) => ({
+			...entry,
+			id: map(entry.id)
+		})),
+		views: metadata.views.map((entry) => ({
+			...entry,
+			id: map(entry.id)
+		})),
+		materializedViews: metadata.materializedViews.map((entry) => ({
+			...entry,
+			id: map(entry.id)
+		})),
+		columns: metadata.columns.map((entry) => ({
+			...entry,
+			table_id: map(entry.table_id),
+			id: `${map(entry.table_id)}.${entry.ordinal_position}`
+		})),
+		primaryKeys: metadata.primaryKeys.map((entry) => ({
+			...entry,
+			table_id: map(entry.table_id)
+		})),
+		functions: metadata.functions.map((entry) => ({
+			...entry,
+			id: map(entry.id),
+			return_type_id: map(entry.return_type_id),
+			return_type_relation_id: mapNullable(entry.return_type_relation_id),
+			args: entry.args.map((arg) => ({
+				...arg,
+				type_id: map(arg.type_id)
+			}))
+		})),
+		types: metadata.types.map((entry) => ({
+			...entry,
+			id: map(entry.id),
+			type_relation_id: mapNullable(entry.type_relation_id),
+			attributes: entry.attributes.map((attribute) => ({
+				...attribute,
+				type_id: map(attribute.type_id)
+			}))
+		}))
+	};
+	return {
+		metadata: loadGeneration().sortGeneratorMetadata(stable),
+		ids
+	};
+}
+/** Validates metadata loaded from a snapshot file. */
+async function validateGeneratorMetadata(data) {
+	const { parseGeneratorMetadata } = await metadataModule();
+	return parseGeneratorMetadata(data);
+}
+/**
+* A `GeneratorMetadata` document `gen --metadata` refuses: not JSON, another
+* `GENERATOR_METADATA_VERSION`, or a shape the schema rejects. `gen` exits 65
+* for it, the code `@supabase/typegen` maps to `MetadataRejectedError`.
+*/
+var MetadataRejectedError = class extends Error {
+	/** The document's `version`, when it had one. */
+	version;
+	constructor(message, version) {
+		super(message);
+		this.name = "MetadataRejectedError";
+		this.version = version;
+	}
+};
+/**
+* Parses the JSON document an out-of-process generator reads on stdin, checking
+* its `version` against the `GENERATOR_METADATA_VERSION` this release of
+* `@supabase/postgrest-typegen` writes.
+*/
+async function parseMetadataDocument(text) {
+	const { GENERATOR_METADATA_VERSION, parseGeneratorMetadata } = await metadataModule();
+	let data;
+	try {
+		data = JSON.parse(text);
+	} catch (cause) {
+		throw new MetadataRejectedError(text.trim() === "" ? "The GeneratorMetadata document is empty." : `The GeneratorMetadata document is not JSON: ${errorText(cause)}`);
+	}
+	const version = typeof data === "object" && data !== null && "version" in data ? data.version : void 0;
+	if (version !== GENERATOR_METADATA_VERSION) throw new MetadataRejectedError(version === void 0 ? `The document has no "version", so it is not GeneratorMetadata. better-supabase reads version ${GENERATOR_METADATA_VERSION}.` : `The document is GeneratorMetadata version ${JSON.stringify(version)}, and better-supabase reads version ${GENERATOR_METADATA_VERSION} (${TYPEGEN}@${TYPEGEN_VERSION}). Update better-supabase or the tool that wrote the document so both agree.`, version);
+	try {
+		return parseGeneratorMetadata(data);
+	} catch (cause) {
+		throw new MetadataRejectedError(errorText(cause), version);
+	}
+}
+/** The JSON document out-of-process generators read. */
+async function serializeGenerator(metadata) {
+	const { serializeGeneratorMetadata } = await metadataModule();
+	return serializeGeneratorMetadata(loadGeneration().sortGeneratorMetadata(metadata));
+}
+/**
+* Keeps only what belongs to `schemas`, so the Database type matches `supabase
+* gen types --schema ...` for exactly those schemas.
+*/
+function restrictSchemas(metadata, schemas) {
+	const keep = new Set(schemas);
+	return {
+		...withoutRpcFunctions(metadata),
+		schemas: metadata.schemas.filter((schema) => keep.has(schema.name)),
+		tables: metadata.tables.filter((table) => keep.has(table.schema)),
+		foreignTables: metadata.foreignTables.filter((table) => keep.has(table.schema)),
+		views: metadata.views.filter((view) => keep.has(view.schema)),
+		materializedViews: metadata.materializedViews.filter((view) => keep.has(view.schema)),
+		columns: metadata.columns.filter((column) => keep.has(column.schema)),
+		primaryKeys: metadata.primaryKeys.filter((key) => keep.has(key.schema)),
+		relationships: metadata.relationships.filter((relationship) => keep.has(relationship.schema)),
+		functions: metadata.functions.filter((fn) => keep.has(fn.schema))
+	};
+}
+let oxfmt;
+/**
+* Oxfmt is an optional peer, loaded on demand; `undefined` when it is not
+* installed.
+*/
+function loadOxfmt() {
+	oxfmt ??= import("oxfmt").catch(() => void 0);
+	return oxfmt;
+}
+/** Whether `database.types.ts` comes out formatted. */
+async function oxfmtInstalled() {
+	return await loadOxfmt() !== void 0;
+}
+/** Formats like `supabase gen types`, or returns `code` as it is without oxfmt. */
+async function formatTypes(code) {
+	const formatter = await loadOxfmt();
+	if (!formatter) return code;
+	const { code: formatted, errors } = await formatter.format("output.ts", code, {
+		semi: false,
+		printWidth: 80
+	});
+	if (errors.length > 0) throw new Error(`oxfmt failed to format database.types.ts: ${errors.map((error) => error.message).join("; ")}`);
+	return formatted;
+}
+/**
+* Renders `database.types.ts` as `supabase gen types` prints it when oxfmt is
+* installed.
+*/
+function generateDatabaseTypes(metadata, options) {
+	const { generateTypescript, sortGeneratorMetadata } = loadGeneration();
+	return generateTypescript(sortGeneratorMetadata(restrictSchemas(metadata, options.schemas)), {
+		postgrestVersion: options.postgrestVersion,
+		detectOneToOneRelationships: true,
+		format: formatTypes
+	});
+}
+/**
+* TypeScript type for a column or argument, resolved exactly like the
+* `Database` type does (domains, composites, enums in other schemas).
+*/
+function tsTypeOf(metadata, schema, format, typeSchema) {
+	const owner = metadata.schemas.find((entry) => entry.name === schema) ?? {
+		id: 0,
+		name: schema,
+		owner: ""
+	};
+	return loadGeneration().pgTypeToTsType(owner, format, {
+		types: metadata.types,
+		schemas: metadata.schemas,
+		tables: metadata.tables,
+		views: metadata.views,
+		foreignTables: metadata.foreignTables,
+		materializedViews: metadata.materializedViews
+	}, typeSchema);
+}
+/**
+* `introspect()` returns every type in the database (hundreds of built-ins).
+* Keep the ones in the read schemas and those referenced by columns, functions
+* and composite attributes; built-in scalars resolve by name.
+*/
+function pruneTypes(metadata, schemas) {
+	const byId = new Map(metadata.types.map((type) => [type.id, type]));
+	const byName = new Map(metadata.types.map((type) => [`${type.schema}.${type.name}`, type]));
+	const keep = /* @__PURE__ */ new Set();
+	const visit = (id) => {
+		if (id === null || id === void 0 || keep.has(id)) return;
+		const type = byId.get(id);
+		if (!type) return;
+		keep.add(id);
+		for (const attribute of type.attributes) visit(attribute.type_id);
+	};
+	for (const type of metadata.types) if (schemas.includes(type.schema)) visit(type.id);
+	for (const column of metadata.columns) {
+		visit(byName.get(`${column.type_schema}.${column.format}`)?.id);
+		visit(byName.get(`${column.type_schema}.${column.format.replace(/^_/, "")}`)?.id);
+	}
+	for (const fn of metadata.functions) {
+		visit(fn.return_type_id);
+		for (const arg of fn.args) visit(arg.type_id);
+	}
+	return {
+		...metadata,
+		types: metadata.types.filter((type) => keep.has(type.id))
+	};
+}
+//#endregion
+//#region src/cli/introspect/index.ts
+/** Reads a v2 snapshot: typegen metadata plus the extras. */
+async function introspect(db, schemas, options = {}) {
+	const unique = [...new Set(schemas)].toSorted();
+	const [metadata, extras] = await Promise.all([readGeneratorMetadata(db, unique), readExtras(db, unique, options.hooks)]);
+	const { metadata: generator, ids } = stabilizeMetadata(metadata);
+	return {
+		version: 2,
+		schemas: unique,
+		generator,
+		extras: {
+			...extras,
+			tables: extras.tables.map((table) => ({
+				...table,
+				id: ids.get(table.id) ?? table.id
+			}))
+		}
+	};
+}
+//#endregion
+//#region src/cli/lite.ts
+const LITE_DRIVERS = [
+	"sqlite-postgres",
+	"sqlite",
+	"pglite",
+	"postgres"
+];
+/** The drivers that store data in SQLite, where Lite has no `rpc()`. */
+function isSqliteLiteDriver(driver) {
+	return driver === "sqlite-postgres" || driver === "sqlite";
+}
+/**
+* `@supabase/lite` is an optional peer, imported through variable specifiers so
+* the CLI build leaves it out; `undefined` when it is not installed.
+*/
+async function loadCliLite() {
+	const root = "@supabase/lite";
+	const pglite = "@supabase/lite/pglite";
+	try {
+		const [{ App }, pg] = await Promise.all([import(root), import(pglite)]);
+		return {
+			App,
+			createPgliteConnection: () => pg.createPgliteConnection()
+		};
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/cli/introspect/lite.ts
+function isLiteDriver(value) {
+	return LITE_DRIVERS.some((driver) => driver === value);
+}
+/**
+* `[db] driver` from `supabase/config.toml`. Only Supabase Lite reads this key,
+* so its presence marks a Lite project.
+*/
+function liteDriverOf(toml) {
+	const driver = tomlGet(toml?.document ?? {}, ["db", "driver"]);
+	if (driver === void 0) return;
+	if (isLiteDriver(driver)) return driver;
+	throw new CliError("config_invalid", `[db] driver = ${JSON.stringify(driver)} in ${toml?.path ?? "supabase/config.toml"} is not a Supabase Lite driver (${LITE_DRIVERS.join(", ")}).`, { flag: "[db] driver" });
+}
+/**
+* `supabase/migrations/*.sql` in version order, then the declarative schema
+* files.
+*/
+async function schemaSql(root, toml) {
+	const migrations = join(root, toml?.dir ?? "supabase", "migrations");
+	const files = existsSync(migrations) ? (await readdir(migrations)).filter((name) => name.endsWith(".sql")).toSorted().map((name) => join(migrations, name)) : [];
+	const { files: schemas } = await schemaPaths(root, toml);
+	return Promise.all([...files, ...schemas.map((path) => join(root, path))].map((path) => readFile(path, "utf-8")));
+}
+/**
+* Where `gen` reads a Supabase Lite project's schema: the `postgres` driver's
+* `[db] url`, or, for `pglite` and `sqlite-postgres`, an in-memory PGlite with
+* Lite's auth schema that `supabase/migrations` and the declarative schema
+* files are replayed into.
+*/
+async function liteSource(root, toml, driver, open = connect) {
+	switch (driver) {
+		case "postgres": {
+			const url = tomlGet(toml?.document ?? {}, ["db", "url"]);
+			if (typeof url !== "string" || !/^postgres(ql)?:\/\//.test(url)) throw new CliError("missing_value", "The Supabase Lite postgres driver needs [db] url = \"postgres://...\" in supabase/config.toml, or pass --db-url-stdin.", { flag: "[db] url" });
+			return pgSource(url, open);
+		}
+		case "sqlite": throw new CliError("config_invalid", "gen reads Postgres DDL, and the bare sqlite driver takes native SQLite DDL. Switch to [db] driver = \"sqlite-postgres\" or \"pglite\", or save a snapshot with `better-supabase gen --save-snapshot`.", { flag: "[db] driver" });
+		case "pglite":
+		case "sqlite-postgres": break;
+		default: return driver;
+	}
+	const lite = await loadCliLite();
+	if (!lite) throw new CliError("failed", "Reading a Supabase Lite project needs @supabase/lite: pnpm add -D @supabase/lite");
+	const connection = await lite.createPgliteConnection();
+	try {
+		await new lite.App({
+			connection,
+			auth: {
+				enabled: true,
+				jwt_secret: "better-supabase-gen".repeat(2)
+			}
+		}).init();
+		const ddl = (await schemaSql(root, toml)).filter((part) => part.trim() !== "").join("\n;\n");
+		if (ddl !== "") await connection.createMigrator(ddl).migrate();
+	} catch (error) {
+		await connection.close();
+		throw new CliError("failed", `Replaying the Supabase Lite schema into PGlite failed: ${errorText(error)}`, { cause: error });
+	}
+	return {
+		queryable: connection.driver,
+		describe: `Supabase Lite schema (${driver}, replayed into PGlite)`,
+		replay: `the Supabase Lite ${driver} schema was replayed into an in-memory PGlite, which has no statistics or Supabase roles. Set [db] driver = "postgres" with a [db] url, or pass --db-url-stdin, to check a database.`,
+		close: () => connection.close()
+	};
+}
+//#endregion
+//#region src/cli/commands/snapshot.ts
+const SNAPSHOT_SCHEMA_URL = "https://unpkg.com/better-supabase/schemas/snapshot-v2.json";
+/** Schemas that are always read, for doctor checks on helper functions. */
+const EXTRA_SCHEMAS = ["better_supabase"];
+/** The hosted project to read through the Management API, if any. */
+function managementTarget(config, env, source) {
+	if (source.dbUrl) return;
+	const projectRef = source.projectRef ?? (config.source.dbUrl ? void 0 : config.source.projectRef);
+	if (!projectRef) return;
+	const token = accessToken(config, env);
+	if (!token) throw new CliError("auth_required", `Reading project ${projectRef} needs a Supabase access token. Set SUPABASE_ACCESS_TOKEN to a token scoped to this project (https://supabase.com/dashboard/account/tokens), or read the database with $DATABASE_URL, $SUPABASE_DB_URL or --db-url-stdin.`, { flag: "SUPABASE_ACCESS_TOKEN" });
+	return {
+		projectRef,
+		accessToken: token.value,
+		...env.SUPABASE_API_URL ? { apiUrl: env.SUPABASE_API_URL } : {}
+	};
+}
+/**
+* Where to read the schema from: `--db-url-stdin`, `--project-ref`, then the
+* config's `source.dbUrl` / `source.projectRef`, a Supabase Lite project's
+* `[db] driver`, `$DATABASE_URL`, `$SUPABASE_DB_URL`, and finally the local
+* stack.
+*/
+async function openSource(config, env, source, open = connect) {
+	if (source.dbUrl) return pgSource(source.dbUrl, open, source.signal);
+	const target = managementTarget(config, env, source);
+	if (target) return managementSource({
+		...target,
+		...source.signal ? { signal: source.signal } : {}
+	});
+	if (!config.source.dbUrl && config.source.lite !== false) {
+		const toml = await readSupabaseToml(config.root);
+		const driver = liteDriverOf(toml) ?? (config.source.lite === true ? "sqlite-postgres" : void 0);
+		if (driver) return liteSource(config.root, toml, driver, open);
+	}
+	return pgSource(await databaseUrl(config, env), open, source.signal);
+}
+/** Whether `loadSnapshot` reads a saved file rather than a database. */
+function snapshotFile(config, source) {
+	return source.snapshotPath ?? (source.live || source.dbUrl || source.projectRef ? void 0 : config.source.snapshot);
+}
+/**
+* Loads a saved snapshot or introspects the database. With `shared`, it
+* introspects over that source and leaves closing it to the caller, so later
+* queries reuse the connection.
+*/
+async function loadSnapshot(config, env, source, open = connect, shared) {
+	const path = snapshotFile(config, source);
+	if (path) return readSnapshotFile(resolve(config.root, path), path);
+	const [tomlRead, opened] = await Promise.allSettled([readSupabaseToml(config.root), shared ? shared() : openSource(config, env, source, open)]);
+	if (tomlRead.status === "rejected") {
+		if (opened.status === "fulfilled" && !shared) await opened.value.close().catch(() => void 0);
+		throw tomlRead.reason;
+	}
+	if (opened.status === "rejected") throw opened.reason;
+	const toml = tomlRead.value;
+	const db = opened.value;
+	const hooks = toml ? pgFunctionHooks(toml.document) : [];
+	const schemas = [...config.schemas, ...EXTRA_SCHEMAS];
+	try {
+		const read = () => introspect(db.queryable, schemas, { hooks });
+		return await (source.cache ? cachedIntrospect(config.root, db, [schemas, hooks], read) : read());
+	} finally {
+		if (!shared) await db.close();
+	}
+}
+async function readSnapshotFile(absolute, label = absolute) {
+	if (!existsSync(absolute)) throw new CliError("not_found", `Snapshot not found: ${label}`);
+	return parseSnapshot(JSON.parse(await readFile(absolute, "utf-8")), label);
+}
+/** Validates a parsed snapshot document. */
+async function parseSnapshot(data, label = "snapshot") {
+	const doc = data;
+	if (!doc || typeof doc !== "object" || doc.version !== 2) throw new CliError("invalid_input", `${label} is not a version 2 snapshot. Run \`better-supabase gen --save-snapshot\` to refresh it.`);
+	if (!Array.isArray(doc.schemas) || !doc.extras || !Array.isArray(doc.extras.tables)) throw new CliError("invalid_input", `${label} is missing "schemas" or "extras".`);
+	let generator;
+	try {
+		generator = await validateGeneratorMetadata(doc.generator);
+	} catch (cause) {
+		if (cause instanceof TypegenMissingError) throw cause;
+		throw new CliError("invalid_input", `${label} has invalid "generator" metadata: ${errorText(cause)}`, { cause });
+	}
+	return {
+		version: 2,
+		schemas: doc.schemas,
+		generator,
+		extras: {
+			tables: doc.extras.tables,
+			buckets: doc.extras.buckets ?? [],
+			realtime: doc.extras.realtime ?? [],
+			...doc.extras.roleSettings ? { roleSettings: doc.extras.roleSettings } : {},
+			...doc.extras.functions ? { functions: doc.extras.functions } : {},
+			...doc.extras.hooks ? { hooks: doc.extras.hooks } : {},
+			...doc.extras.functionComments ? { functionComments: doc.extras.functionComments } : {},
+			...doc.extras.domains ? { domains: doc.extras.domains } : {}
+		}
+	};
+}
+function serializeSnapshot(snapshot) {
+	const { $schema: _ignored, ...rest } = snapshot;
+	return `${JSON.stringify({
+		$schema: SNAPSHOT_SCHEMA_URL,
+		...rest
+	}, null, 2)}\n`;
+}
+//#endregion
+export { satisfies as C, peerVersions as S, stabilizeMetadata as _, serializeSnapshot as a, typegenVersionNotice as b, isSqliteLiteDriver as c, TypegenMissingError as d, generateDatabaseTypes as f, serializeGenerator as g, restrictSchemas as h, parseSnapshot as i, introspect as l, parseMetadataDocument as m, managementTarget as n, snapshotFile as o, oxfmtInstalled as p, openSource as r, liteDriverOf as s, loadSnapshot as t, MetadataRejectedError as u, tsTypeOf as v, installedVersion as x, typegenVersion as y };