better-supabase 0.8.0 → 0.10.0

package/dist/cli/typegen-Demi5-VQ.js

@@ -1,486 +0,0 @@
-import { r as errorText } from "./errors-CqTLXe2M.js";
-import { t as TYPEGEN_VERSION } from "./typegen-version-DeFbtzYI.js";
-import { t as byCodePoint } from "./compare-BmIWVEui.js";
-import { dirname, join } from "node:path";
-import { readFile } 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 void 0;
-	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++) {
-		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 void 0;
-		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 void 0;
-	const sets = range.split("||").map(comparators);
-	if (sets.some((set) => set === void 0)) return void 0;
-	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, "utf8"));
-		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 void 0;
-		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 void 0;
-		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 void 0;
-	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.4.0") return void 0;
-	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[])`;
-}
-/**
-* 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 {
-		...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 = [];
-			row.types.forEach((type, index) => {
-				const name = row.names?.[index] ?? "";
-				const at = pending.findIndex((arg) => arg.type_id === Number(type) && arg.name === name);
-				if (at >= 0) 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) => {
-		[...entries].sort((a, b) => byCodePoint(a.key, b.key)).forEach((entry, index) => {
-			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 = {
-		...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 {
-		...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, plus the `ComputedFields` keys Supabase CLI 2.119 doesn't write.
-*/
-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
-export { parseMetadataDocument as a, serializeGenerator as c, typegenVersion as d, typegenVersionNotice as f, satisfies as h, oxfmtInstalled as i, stabilizeMetadata as l, peerVersions as m, TypegenMissingError as n, readGeneratorMetadata as o, validateGeneratorMetadata as p, generateDatabaseTypes as r, restrictSchemas as s, MetadataRejectedError as t, tsTypeOf as u };

package/dist/cli/typegen-version-DeFbtzYI.js

@@ -1,8 +0,0 @@
-//#region src/cli/introspect/typegen-version.ts
-/**
-* The `@supabase/postgrest-typegen` version `database.types.ts` output is
-* pinned to. The peer range is this exact version; a test checks the catalog.
-*/
-const TYPEGEN_VERSION = "0.4.0";
-//#endregion
-export { TYPEGEN_VERSION as t };