better-supabase 0.8.0 → 0.10.0

package/dist/cli/snapshot-Dvcx0BSl.js

@@ -0,0 +1,347 @@
+import { t as VERSION } from "./version-D1wM9DNb.js";
+import { n as CliError, r as errorText } from "./errors-Caiz_0so.js";
+import { r as redactUrl } from "./redact-PjNswZOs.js";
+import { n as HTTP_CHANNEL } from "./trace-VbdO6bcN.js";
+import { o as readExtras, r as cachedIntrospect } from "./cache-CPBYJAkb.js";
+import { l as stabilizeMetadata, n as TypegenMissingError, o as readGeneratorMetadata, p as validateGeneratorMetadata } from "./typegen--TfvOPLh.js";
+import { n as databaseUrl, u as accessToken } from "./config-Bi_UBxXl.js";
+import { d as readSupabaseToml, f as schemaPaths, h as tomlGet, u as pgFunctionHooks } from "./supabase-toml-DjLgBYEo.js";
+import { t as connect } from "./db-DT1bGB02.js";
+import { channel } from "node:diagnostics_channel";
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { readFile, readdir } from "node:fs/promises";
+//#region src/cli/core/http.ts
+const httpChannel = channel(HTTP_CHANNEL);
+/** How long one request may take before it fails with `network_error`. */
+const REQUEST_TIMEOUT_MS = 3e4;
+const USER_AGENT = `better-supabase/${VERSION}`;
+/**
+* The response body of a request, with the CLI's user agent, the run's
+* signal and a timeout. A request that gets no response is `network_error`,
+* 401 and 403 are `auth_required`, and any other failed status is
+* `request_failed`. Each request is published on `HTTP_CHANNEL` for `--debug`.
+*/
+async function request(url, options) {
+	const method = options.method ?? "GET";
+	const timeout = AbortSignal.timeout(options.timeoutMs ?? REQUEST_TIMEOUT_MS);
+	const signal = options.signal ? AbortSignal.any([options.signal, timeout]) : timeout;
+	const started = performance.now();
+	const publish = (status) => {
+		if (httpChannel.hasSubscribers) {
+			const event = {
+				method,
+				url: redactUrl(url),
+				...status === void 0 ? {} : { status },
+				milliseconds: Math.round(performance.now() - started)
+			};
+			httpChannel.publish(event);
+		}
+	};
+	let response;
+	try {
+		response = await (options.fetch ?? fetch)(url, {
+			method,
+			headers: {
+				"user-agent": USER_AGENT,
+				...options.headers
+			},
+			...options.body === void 0 ? {} : { body: options.body },
+			signal
+		});
+	} catch (cause) {
+		publish();
+		if (options.signal?.aborted === true) throw cause;
+		const reason = timeout.aborted ? `timed out after ${Math.round((options.timeoutMs ?? REQUEST_TIMEOUT_MS) / 1e3)}s` : cause instanceof Error ? cause.message : String(cause);
+		throw new CliError("network_error", `${options.what} got no response from ${new URL(url).host}: ${reason}`, { cause });
+	}
+	publish(response.status);
+	const text = await response.text();
+	if (!response.ok) throw new CliError(response.status === 401 || response.status === 403 ? "auth_required" : "request_failed", `${options.what} failed (${response.status}): ${text.slice(0, 300)}`);
+	return text;
+}
+//#endregion
+//#region src/cli/introspect/source.ts
+const POOL_SIZE = 4;
+const STATEMENT_TIMEOUT_MS = 12e4;
+/**
+* Leads every introspection query. `pg_stat_statements` keeps a leading
+* comment in its text, so doctor (BS208) can tell the CLI's catalog reads
+* from the app's statements.
+*/
+const CLI_QUERY_TAG = "/* better-supabase */";
+const tagged = (sql) => `${CLI_QUERY_TAG}\n${sql}`;
+/**
+* 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: { query: (sql) => client.query(tagged(sql)) },
+		close,
+		describe
+	};
+	let queue = Promise.resolve();
+	return {
+		queryable: { query(sql) {
+			const next = queue.then(() => client.query(tagged(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 endpoint = `${(options.apiUrl ?? "https://api.supabase.com").replace(/\/$/, "")}/v1/projects/${encodeURIComponent(options.projectRef)}/database/query/read-only`;
+	return {
+		queryable: { async query(sql) {
+			const text = await request(endpoint, {
+				what: `Management API query for project ${options.projectRef}`,
+				method: "POST",
+				headers: {
+					authorization: `Bearer ${options.accessToken}`,
+					"content-type": "application/json"
+				},
+				body: JSON.stringify({ query: sql }),
+				...options.signal ? { signal: options.signal } : {},
+				...options.fetch ? { fetch: options.fetch } : {}
+			});
+			const rows = JSON.parse(text);
+			if (!Array.isArray(rows)) throw new CliError("request_failed", `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;
+	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, "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 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;
+	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 introspect\` 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 } : {}
+		}
+	};
+}
+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, managementSource as d, pgSource as f, parseSnapshot as i, introspect as l, managementTarget as n, snapshotFile as o, request as p, openSource as r, liteDriverOf as s, loadSnapshot as t, CLI_QUERY_TAG as u };

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

@@ -0,0 +1,47 @@
+import { n as CliError } from "./errors-Caiz_0so.js";
+import { l as stdinDatabaseUrl } from "./config-Bi_UBxXl.js";
+//#region src/cli/commands/source-args.ts
+/** The connection string from stdin, for commands that connect but read no schema. */
+const DB_URL_STDIN_ARG = { "db-url-stdin": {
+	type: "boolean",
+	description: "Read the connection string from stdin instead of the config, $DATABASE_URL or $SUPABASE_DB_URL"
+} };
+/** Where to read the schema from, shared by gen, introspect, doctor, adopt and apply. */
+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"
+	}
+};
+/** The source flags `args` sets, as typed on the command line. */
+function sourceFlags(args) {
+	return [
+		...args.snapshot === void 0 ? [] : ["--snapshot"],
+		...args["db-url-stdin"] === true ? ["--db-url-stdin"] : [],
+		...args["project-ref"] === void 0 ? [] : ["--project-ref"]
+	];
+}
+async function sourceArgs(args, io) {
+	const snapshotPath = args.snapshot;
+	const live = ["db-url-stdin", "project-ref"].find((flag) => args[flag] !== void 0 && args[flag] !== false);
+	if (snapshotPath && live) throw new CliError("usage", `--snapshot reads a saved file and --${live} reads a database. Pass one of them.`, { flag: "--snapshot" });
+	const dbUrl = await stdinDatabaseUrl(args["db-url-stdin"], io);
+	const projectRef = args["project-ref"];
+	return {
+		...snapshotPath ? { snapshotPath } : {},
+		...dbUrl ? { dbUrl } : {},
+		...projectRef ? { projectRef } : {}
+	};
+}
+//#endregion
+export { sourceFlags as i, SOURCE_ARGS as n, sourceArgs as r, DB_URL_STDIN_ARG as t };