better-supabase 0.7.1 → 0.8.0

package/dist/cli/snapshot-Bstk6ulj.js

@@ -0,0 +1,287 @@
+import { n as CliError, r as errorText } from "./errors-CqTLXe2M.js";
+import { o as readExtras, r as cachedIntrospect } from "./cache-CIfA-jBV.js";
+import { l as stabilizeMetadata, n as TypegenMissingError, o as readGeneratorMetadata, p as validateGeneratorMetadata } from "./typegen-Demi5-VQ.js";
+import { n as databaseUrl } from "./config-M-WzL9O2.js";
+import { d as schemaPaths, l as pgFunctionHooks, p as tomlGet, u as readSupabaseToml } from "./supabase-toml-B-bIukQF.js";
+import { t as connect } from "./db-BkcfOlyB.js";
+import { join, resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { readFile, readdir } from "node:fs/promises";
+//#region src/cli/introspect/source.ts
+const POOL_SIZE = 4;
+const STATEMENT_TIMEOUT_MS = 12e4;
+/**
+* A small `pg` pool, since introspection issues its queries concurrently. A
+* `connect` that returns a single client gets its queries queued, because one
+* `pg.Client` runs them one at a time.
+*/
+async function pgSource(url, open = connect, signal) {
+	const { client, pooled, close, describe } = await open(url, void 0, {
+		pool: POOL_SIZE,
+		statementTimeout: STATEMENT_TIMEOUT_MS,
+		...signal ? { signal } : {}
+	});
+	if (pooled) return {
+		queryable: client,
+		close,
+		describe
+	};
+	let queue = Promise.resolve();
+	return {
+		queryable: { query(sql) {
+			const next = queue.then(() => client.query(sql));
+			queue = next.catch(() => void 0);
+			return next;
+		} },
+		close,
+		describe
+	};
+}
+/**
+* Runs introspection SQL through the Supabase Management API as the
+* read-only database user, so hosted projects need no database password.
+*/
+function managementSource(options) {
+	const base = (options.apiUrl ?? "https://api.supabase.com").replace(/\/$/, "");
+	const doFetch = options.fetch ?? fetch;
+	const endpoint = `${base}/v1/projects/${encodeURIComponent(options.projectRef)}/database/query/read-only`;
+	return {
+		queryable: { async query(sql) {
+			const response = await doFetch(endpoint, {
+				method: "POST",
+				headers: {
+					authorization: `Bearer ${options.accessToken}`,
+					"content-type": "application/json"
+				},
+				body: JSON.stringify({ query: sql }),
+				...options.signal ? { signal: options.signal } : {}
+			});
+			const text = await response.text();
+			if (!response.ok) throw new Error(`Management API query failed (${response.status}) for project ${options.projectRef}: ${text.slice(0, 500)}`);
+			const rows = JSON.parse(text);
+			if (!Array.isArray(rows)) throw new TypeError(`Management API returned an unexpected body for project ${options.projectRef}.`);
+			return { rows };
+		} },
+		describe: `project ${options.projectRef} (Management API)`,
+		close: () => Promise.resolve()
+	};
+}
+//#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)].sort();
+	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 void 0;
+	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")).sort().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, "utf8")));
+}
+/**
+* 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 introspect`.", { 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 void 0;
+	const projectRef = source.projectRef ?? (config.source.dbUrl ? void 0 : config.source.projectRef);
+	if (!projectRef) return void 0;
+	const accessToken = config.source.accessToken ?? env.SUPABASE_ACCESS_TOKEN;
+	if (!accessToken) throw new CliError("missing_value", `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,
+		...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 Error(`Snapshot not found: ${label}`);
+	return parseSnapshot(JSON.parse(await readFile(absolute, "utf8")), 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 Error(`${label} is not a version 2 snapshot. Run \`better-supabase introspect\` to refresh it.`);
+	if (!Array.isArray(doc.schemas) || !doc.extras || !Array.isArray(doc.extras.tables)) throw new Error(`${label} is missing "schemas" or "extras".`);
+	let generator;
+	try {
+		generator = await validateGeneratorMetadata(doc.generator);
+	} catch (cause) {
+		if (cause instanceof TypegenMissingError) throw cause;
+		throw new Error(`${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 } : {}
+		}
+	};
+}
+function serializeSnapshot(snapshot) {
+	const { $schema: _ignored, ...rest } = snapshot;
+	return `${JSON.stringify({
+		$schema: SNAPSHOT_SCHEMA_URL,
+		...rest
+	}, null, 2)}\n`;
+}
+//#endregion
+export { serializeSnapshot as a, isSqliteLiteDriver as c, pgSource as d, parseSnapshot as i, introspect as l, managementTarget as n, snapshotFile as o, openSource as r, liteDriverOf as s, loadSnapshot as t, managementSource as u };

package/dist/cli/source-args-BYfq6imV.js

@@ -0,0 +1,31 @@
+import { c as stdinDatabaseUrl } from "./config-M-WzL9O2.js";
+//#region src/cli/commands/source-args.ts
+/** Where to read the schema from, shared by gen, introspect and doctor. */
+const SOURCE_ARGS = {
+	snapshot: {
+		type: "string",
+		description: "Read a saved snapshot instead of the database",
+		valueHint: "file"
+	},
+	"db-url-stdin": {
+		type: "boolean",
+		description: "Read the connection string from stdin instead of the config, $DATABASE_URL or $SUPABASE_DB_URL"
+	},
+	"project-ref": {
+		type: "string",
+		description: "Read a hosted project through the Management API",
+		valueHint: "ref"
+	}
+};
+async function sourceArgs(args, io) {
+	const snapshotPath = args.snapshot;
+	const dbUrl = await stdinDatabaseUrl(args["db-url-stdin"], io);
+	const projectRef = args["project-ref"];
+	return {
+		...snapshotPath ? { snapshotPath } : {},
+		...dbUrl ? { dbUrl } : {},
+		...projectRef ? { projectRef } : {}
+	};
+}
+//#endregion
+export { sourceArgs as n, SOURCE_ARGS as t };