better-supabase 0.12.0 → 0.14.0

package/dist/cli/sync-CjkKpI6d.js

@@ -0,0 +1,91 @@
+import { t as display } from "./io-DH1kcmmP.js";
+import { b as sqlPlan, g as layoutFor, l as writesMigrations, o as renderModuleMigration, r as latestMigration, s as sameModuleMigration, t as MODULES_SUFFIX, v as migrationsDir } from "./module-migration-CbX-jRhV.js";
+import { c as fileDiff, n as applyPlan, r as changeLines, s as planResult } from "./files-C5JfVnj5.js";
+import { a as write, o as topicPolicyFile, r as staleModuleTests, t as moduleFile } from "./write-3qdrpS1v.js";
+import { resolve } from "node:path";
+import { readFile } from "node:fs/promises";
+import { moduleTopics, renderModules, sameModuleFile } from "better-supabase/sql";
+//#region src/cli/sql/sync.ts
+async function syncModules(config, args, paint, now) {
+	const topics = await topicPolicyFile(config, config.blockNames.length === 0 ? [] : moduleTopics(config.blockNames, await layoutFor(config, args, config.blockNames)));
+	const hasSql = config.blockNames.length > 0 || Object.keys(config.appTables).length > 0;
+	if (!hasSql && topics === void 0) return {
+		code: 0,
+		output: "blocks is empty; nothing to sync.",
+		data: { blocks: [] }
+	};
+	if (await writesMigrations(config)) {
+		const sqlLayout = await layoutFor(config, args, config.blockNames);
+		if (args.check === true) return checkModuleMigration(config, sqlLayout, paint, topics?.contents);
+		return {
+			code: 0,
+			output: (await write(config, args, config.blockNames, sqlLayout, now)).join("\n"),
+			data: { blocks: config.blockNames }
+		};
+	}
+	const sqlLayout = await layoutFor(config, args, config.blockNames);
+	const topicsFile = topics === void 0 ? [] : [{
+		...topics,
+		note: "topics"
+	}];
+	if (args.check !== true) {
+		const lines = hasSql ? await write(config, args, config.blockNames, sqlLayout, now) : [];
+		if (topics !== void 0) lines.push(...changeLines(await applyPlan({
+			root: config.root,
+			regenerate: "better-supabase sql sync",
+			files: topicsFile
+		}, { "dry-run": args["dry-run"] })));
+		return {
+			code: 0,
+			output: lines.join("\n"),
+			data: { blocks: config.blockNames }
+		};
+	}
+	const rendered = renderModules(config.blockNames, sqlLayout);
+	const plan = sqlPlan(config, {
+		regenerate: "better-supabase sql sync",
+		files: [...rendered.map((file) => moduleFile(file)), ...topicsFile],
+		remove: await staleModuleTests(config, config.blockNames, sqlLayout, rendered)
+	});
+	return planResult(plan, await applyPlan(plan, { check: true }, paint), { data: { blocks: config.blockNames } });
+}
+/**
+* `sql sync --check` under the migrations workflow: the newest module migration
+* against what `sql sync` would write.
+*/
+async function checkModuleMigration(config, sqlLayout, paint, topics) {
+	const files = renderModules(config.blockNames, sqlLayout);
+	const expected = renderModuleMigration({
+		files,
+		...topics === void 0 ? {} : { topics }
+	});
+	const latest = await latestMigration(config, MODULES_SUFFIX);
+	const stale = (await staleModuleTests(config, config.blockNames, sqlLayout, files)).map((path) => display(config.root, path));
+	const diffs = stale.map((path) => `${path} is no longer written; \`sql sync\` removes it.`);
+	for (const file of files.filter((entry) => entry.kind === "test")) {
+		const current = await readFile(resolve(config.root, file.path), "utf-8").catch(() => void 0);
+		if (!sameModuleFile(current, file.contents)) {
+			const shown = display(config.root, file.path);
+			stale.push(shown);
+			diffs.push(fileDiff(shown, current, file.contents, paint));
+		}
+	}
+	if (!sameModuleMigration(latest?.text, expected)) {
+		const shown = latest?.path ?? `${migrationsDir(config)}/<stamp>_better_supabase_modules.sql`;
+		stale.push(shown);
+		diffs.push(fileDiff(shown, latest?.text, expected, paint));
+	}
+	return stale.length === 0 ? {
+		code: 0,
+		output: "SQL module migration is up to date.",
+		data: { stale }
+	} : {
+		code: 1,
+		data: { stale },
+		output: diffs.join("\n\n"),
+		error: `Out of date: ${stale.join(", ")}. Run \`better-supabase sql sync\`, then \`supabase migration up\`.`,
+		errorCode: "check_failed"
+	};
+}
+//#endregion
+export { syncModules as t };

package/dist/cli/topics-BpdnYmWb.js

@@ -0,0 +1,30 @@
+import { n as CliError } from "./errors-BTe6A15O.js";
+import { t as importFresh } from "./fresh-import-DzgsGHkX.js";
+import { resolve } from "node:path";
+//#region src/cli/topics.ts
+const isLoadedTopic = (value) => typeof value === "object" && value !== null && "template" in value && typeof value.template === "string" && "params" in value && Array.isArray(value.params) && "private" in value && typeof value.private === "boolean" && "sql" in value && typeof value.sql === "function" && "trigger" in value && typeof value.trigger === "function" && "subscribe" in value && typeof value.subscribe === "function";
+/**
+* The topics the `from` modules export (`realtime.policies.from`), loaded
+* fresh, each once, sorted by template. Throws for a module that exports no
+* topic.
+*/
+async function loadTopics(root, from) {
+	const found = [];
+	for (const entry of from) {
+		const loaded = await importFresh(resolve(root, entry));
+		let count = 0;
+		for (const [exportName, value] of Object.entries(loaded)) {
+			if (!isLoadedTopic(value)) continue;
+			count += 1;
+			if (!found.some((each) => each.topic === value)) found.push({
+				entry,
+				exportName,
+				topic: value
+			});
+		}
+		if (count === 0) throw new CliError("invalid_input", `${entry} exports no topic (defineTopic)`);
+	}
+	return found.toSorted((a, b) => a.topic.template < b.topic.template ? -1 : a.topic.template > b.topic.template ? 1 : 0);
+}
+//#endregion
+export { loadTopics as t };

package/dist/cli/typegen-F9GEjpvD.js

@@ -0,0 +1,502 @@
+import { r as errorText } from "./errors-BTe6A15O.js";
+import { t as TYPEGEN_VERSION } from "./typegen-version-BNBPI4Eu.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;
+	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
+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 };