better-supabase 0.11.0 → 0.13.0

package/dist/cli/cache-CVJmPGpd.js

@@ -1,507 +0,0 @@
-import { t as VERSION } from "./version-CUKjFbNd.js";
-import { t as TYPEGEN_VERSION } from "./typegen-version-BNBPI4Eu.js";
-import { dirname, resolve } from "node:path";
-import { createHash } from "node:crypto";
-import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
-//#region src/cli/introspect/extras.ts
-/**
-* Catalog details `@supabase/postgrest-typegen` leaves out: named unique and
-* CHECK constraints, foreign key actions, ordered primary keys, indexes,
-* policies, triggers, grants, buckets and the realtime publication.
-*
-* The SQL takes no bind parameters because the Management API endpoint only
-* accepts a query string; schema names are inlined as escaped literals.
-*/
-const literalArray = (values) => `array[${values.map((value) => `'${value.replaceAll("'", "''")}'`).join(", ")}]::text[]`;
-/** Row estimate from which a table counts as large in the snapshot. */
-const LARGE_TABLE_ROWS = 1e4;
-const RELATIONS = (schemas) => `
-select c.oid::int8 as id, n.nspname as schema, c.relname as name,
-  c.reltuples >= ${LARGE_TABLE_ROWS} as large,
-  (select pn.nspname || '.' || pc.relname from pg_inherits i
-    join pg_class pc on pc.oid = i.inhparent
-    join pg_namespace pn on pn.oid = pc.relnamespace
-    where i.inhrelid = c.oid and c.relispartition) as partition_of
-from pg_class c
-join pg_namespace n on n.oid = c.relnamespace
-where n.nspname = any(${schemas}) and c.relkind in ('r', 'p', 'v', 'm', 'f')
-order by 2, 3`;
-const CONSTRAINTS = (schemas) => `
-select con.conrelid::int8 as table_id, con.conname as name, con.contype as type,
-  array(select a.attname from unnest(con.conkey) with ordinality k(attnum, ord)
-    join pg_attribute a on a.attrelid = con.conrelid and a.attnum = k.attnum order by k.ord)::text[] as columns,
-  con.confdeltype as on_delete, con.confupdtype as on_update,
-  pg_get_constraintdef(con.oid) as definition
-from pg_constraint con
-join pg_class c on c.oid = con.conrelid
-join pg_namespace n on n.oid = c.relnamespace
-where n.nspname = any(${schemas}) and con.contype in ('p', 'u', 'f', 'c')
-order by 1, 2`;
-const INDEXES = (schemas) => `
-select ix.indrelid::int8 as table_id, i.relname as name,
-  ix.indisunique as unique, ix.indisprimary as primary,
-  (ix.indpred is not null or 0 = any(ix.indkey::int2[])) as partial,
-  am.amname as method, pg_get_expr(ix.indpred, ix.indrelid) as predicate,
-  array(select a.attname from unnest((ix.indkey::int2[])[0:ix.indnkeyatts - 1]) with ordinality k(attnum, ord)
-    join pg_attribute a on a.attrelid = ix.indrelid and a.attnum = k.attnum order by k.ord)::text[] as columns
-from pg_index ix
-join pg_class i on i.oid = ix.indexrelid
-join pg_am am on am.oid = i.relam
-join pg_class c on c.oid = ix.indrelid
-join pg_namespace n on n.oid = c.relnamespace
-where n.nspname = any(${schemas}) and ix.indisvalid
-order by 1, 2`;
-const POLICIES = (schemas) => `
-select c.oid::int8 as table_id, p.policyname as name,
-  (p.permissive = 'PERMISSIVE') as permissive, p.roles::text[] as roles, lower(p.cmd) as command,
-  p.qual as using_expr, p.with_check as check_expr,
-  array(
-    select distinct fn.nspname || '.' || pr.proname
-    from pg_policy pol
-    join pg_depend d on d.classid = 'pg_policy'::regclass and d.objid = pol.oid
-      and d.refclassid = 'pg_proc'::regclass
-    join pg_proc pr on pr.oid = d.refobjid
-    join pg_namespace fn on fn.oid = pr.pronamespace
-    where pol.polrelid = c.oid and pol.polname = p.policyname
-    order by 1
-  )::text[] as functions
-from pg_policies p
-join pg_namespace n on n.nspname = p.schemaname
-join pg_class c on c.relnamespace = n.oid and c.relname = p.tablename
-where p.schemaname = any(${schemas})
-order by 1, 2`;
-const FUNCTIONS = (schemas) => `
-select n.nspname as schema, p.proname as name,
-  pg_get_function_identity_arguments(p.oid) as signature,
-  l.lanname as language, p.provolatile as volatility,
-  p.prosecdef as security_definer, coalesce(p.proconfig, '{}')::text[] as config,
-  array(
-    select r from unnest(array['anon', 'authenticated']) r
-    where has_function_privilege(r, p.oid, 'EXECUTE')
-  ) as execute
-from pg_proc p
-join pg_namespace n on n.oid = p.pronamespace
-join pg_language l on l.oid = p.prolang
-where p.oid in (
-    select d.refobjid
-    from pg_depend d
-    join pg_policy pol on d.classid = 'pg_policy'::regclass and d.objid = pol.oid
-    join pg_class c on c.oid = pol.polrelid
-    join pg_namespace cn on cn.oid = c.relnamespace
-    where d.refclassid = 'pg_proc'::regclass and cn.nspname = any(${schemas})
-  )
-  or (n.nspname = any(${schemas}) and ((p.prosecdef
-    and p.prorettype not in ('trigger'::regtype, 'event_trigger'::regtype)) or exists (
-    select 1 from unnest(p.proconfig) setting where setting not like 'search_path=%'
-  )))
-order by 1, 2, 3`;
-/** Roles the hook checks care about: the one Auth calls it as, and the API roles. */
-const HOOK_ROLES = literalArray([
-	"supabase_auth_admin",
-	"authenticated",
-	"anon"
-]);
-const HOOKS = (names) => `
-select n.nspname as schema, p.proname as name,
-  pg_get_function_identity_arguments(p.oid) as signature,
-  l.lanname as language, p.provolatile as volatility,
-  p.prosecdef as security_definer, coalesce(p.proconfig, '{}')::text[] as config,
-  array(select r.rolname::text from pg_roles r
-    where r.rolname = any(${HOOK_ROLES}) and has_function_privilege(r.oid, p.oid, 'execute')
-    order by 1) as execute,
-  exists(select 1 from aclexplode(coalesce(p.proacl, acldefault('f', p.proowner))) a
-    where a.grantee = 0 and a.privilege_type = 'EXECUTE') as public_execute,
-  array(select r.rolname::text from pg_roles r
-    where r.rolname = any(${HOOK_ROLES}) and has_schema_privilege(r.oid, n.oid, 'usage')
-    order by 1) as schema_usage,
-  p.prosrc as source
-from pg_proc p
-join pg_namespace n on n.oid = p.pronamespace
-join pg_language l on l.oid = p.prolang
-where n.nspname || '.' || p.proname = any(${names})
-order by 1, 2, 3`;
-const TRIGGERS = (schemas) => `
-select t.tgrelid::int8 as table_id, t.tgname as name,
-  pn.nspname || '.' || p.proname as function,
-  case when t.tgtype & 2 = 2 then 'before' when t.tgtype & 64 = 64 then 'instead of' else 'after' end as timing,
-  array_remove(array[
-    case when t.tgtype & 4 = 4 then 'insert' end,
-    case when t.tgtype & 16 = 16 then 'update' end,
-    case when t.tgtype & 8 = 8 then 'delete' end,
-    case when t.tgtype & 32 = 32 then 'truncate' end
-  ], null)::text[] as events,
-  case when t.tgtype & 1 = 1 then 'row' else 'statement' end as level,
-  case when t.tgnargs > 0 then array(
-    select replace(a, '\\\\', '\\') from unnest(string_to_array(left(encode(t.tgargs, 'escape'), -4), '\\000')) with ordinality as x(a, i) order by i
-  ) end as args,
-  case when pn.nspname || '.' || p.proname <> 'better_supabase.broadcast_topic'
-    and p.prosrc ~ 'realtime\\.(broadcast_changes|send)\\s*\\(' then p.prosrc end as source,
-  case when pn.nspname || '.' || p.proname <> 'better_supabase.broadcast_topic'
-    and p.prosrc ~ 'realtime\\.(broadcast_changes|send)\\s*\\(' then obj_description(p.oid, 'pg_proc') end as comment
-from pg_trigger t
-join pg_class c on c.oid = t.tgrelid
-join pg_namespace n on n.oid = c.relnamespace
-join pg_proc p on p.oid = t.tgfoid
-join pg_namespace pn on pn.oid = p.pronamespace
-where not t.tgisinternal and n.nspname = any(${schemas})
-order by 1, 2`;
-const GRANTS = (schemas) => `
-select c.oid::int8 as table_id, coalesce(r.rolname, 'PUBLIC') as role,
-  array_agg(distinct acl.privilege_type order by acl.privilege_type)::text[] as privileges
-from pg_class c
-join pg_namespace n on n.oid = c.relnamespace
-cross join lateral aclexplode(coalesce(c.relacl, acldefault('r', c.relowner))) acl
-left join pg_roles r on r.oid = acl.grantee
-where n.nspname = any(${schemas}) and c.relkind in ('r', 'p', 'v', 'm', 'f')
-  and (acl.grantee = 0 or r.rolname in ('anon', 'authenticated', 'service_role'))
-  and acl.privilege_type <> 'MAINTAIN'
-group by 1, 2
-order by 1, 2`;
-const COLUMN_GRANTS = (schemas) => `
-select c.oid::int8 as table_id, a.attname as column, coalesce(r.rolname, 'PUBLIC') as role,
-  array_agg(distinct acl.privilege_type order by acl.privilege_type)::text[] as privileges
-from pg_class c
-join pg_namespace n on n.oid = c.relnamespace
-join pg_attribute a on a.attrelid = c.oid and a.attnum > 0 and not a.attisdropped and a.attacl is not null
-cross join lateral aclexplode(a.attacl) acl
-left join pg_roles r on r.oid = acl.grantee
-where n.nspname = any(${schemas})
-  and (acl.grantee = 0 or r.rolname in ('anon', 'authenticated'))
-  and acl.privilege_type in ('SELECT', 'INSERT', 'UPDATE')
-group by 1, 2, 3
-order by 1, 2, 3`;
-const BUCKETS = `
-select id, public, file_size_limit, allowed_mime_types,
-  to_jsonb(b) ? 'versioning_status' as has_versioning,
-  to_jsonb(b) -> 'versioning_status' as versioning_status,
-  to_jsonb(b) ? 'lifecycle_configuration' as has_lifecycle,
-  to_jsonb(b) -> 'lifecycle_configuration' as lifecycle_configuration
-from storage.buckets b
-order by id`;
-const REALTIME = `
-select schemaname || '.' || tablename as name
-from pg_publication_tables
-where pubname = 'supabase_realtime'
-order by 1`;
-const ROLE_SETTINGS = `
-select r.rolname as role, s.setconfig as config
-from pg_catalog.pg_db_role_setting s
-join pg_catalog.pg_roles r on r.oid = s.setrole
-where r.rolname in ('authenticator', 'anon', 'authenticated')
-  and s.setdatabase in (0, (select oid from pg_catalog.pg_database where datname = current_database()))
-order by s.setdatabase`;
-const FUNCTION_COMMENTS = (schemas) => `
-select n.nspname || '.' || p.proname || '(' || pg_get_function_identity_arguments(p.oid) || ')' as key,
-  obj_description(p.oid, 'pg_proc') as comment
-from pg_proc p
-join pg_namespace n on n.oid = p.pronamespace
-where n.nspname = any(${schemas}) and obj_description(p.oid, 'pg_proc') ~ '@notNull'
-order by 1`;
-const HAS_TABLE = (qualified) => `select to_regclass('${qualified}') is not null as present`;
-const ACTIONS = {
-	a: "no action",
-	r: "restrict",
-	c: "cascade",
-	n: "set null",
-	d: "set default"
-};
-const VOLATILITY = {
-	i: "immutable",
-	s: "stable",
-	v: "volatile"
-};
-/** `['statement_timeout=5s']` as `{ statement_timeout: '5s' }`. */
-function settingsOf(config) {
-	const settings = {};
-	for (const entry of config ?? []) {
-		const at = entry.indexOf("=");
-		if (at > 0) settings[entry.slice(0, at)] = entry.slice(at + 1);
-	}
-	return settings;
-}
-const functionOf = (row) => ({
-	schema: row.schema,
-	name: row.name,
-	signature: row.signature,
-	language: row.language,
-	volatility: VOLATILITY[row.volatility],
-	securityDefiner: row.security_definer,
-	settings: settingsOf(row.config)
-});
-/** The functions behind Auth hooks, in any schema, with their ACLs. */
-async function readHooks(db, targets) {
-	if (targets.length === 0) return [];
-	const found = await rows(db, HOOKS(literalArray(targets.map((t) => `${t.schema}.${t.name}`))));
-	return targets.map((target) => ({
-		hook: target.hook,
-		schema: target.schema,
-		name: target.name,
-		functions: found.filter((row) => row.schema === target.schema && row.name === target.name).map((row) => ({
-			...functionOf(row),
-			execute: row.execute,
-			publicExecute: row.public_execute,
-			schemaUsage: row.schema_usage,
-			...row.source === null ? {} : { source: row.source }
-		}))
-	}));
-}
-async function rows(db, sql) {
-	return (await db.query(sql)).rows;
-}
-/** Rows from a table owned by another Supabase service, if it exists. */
-async function serviceRows(db, qualified, sql) {
-	const [probe] = await rows(db, HAS_TABLE(qualified));
-	return probe?.present ? rows(db, sql) : [];
-}
-function groupById(list) {
-	const map = /* @__PURE__ */ new Map();
-	for (const row of list) {
-		const id = Number(row.table_id);
-		const entry = map.get(id);
-		if (entry) entry.push(row);
-		else map.set(id, [row]);
-	}
-	return map;
-}
-/** Reads the extras for `schemas`, with the catalog queries in flight together. */
-async function readExtras(db, schemas, hooks = []) {
-	const list = literalArray(schemas);
-	const [relations, constraintRows, indexRows, policyRows, triggerRows, grantRows, columnGrantRows, buckets, realtime, functions, roleRows, hookRows, commentRows] = await Promise.all([
-		rows(db, RELATIONS(list)),
-		rows(db, CONSTRAINTS(list)),
-		rows(db, INDEXES(list)),
-		rows(db, POLICIES(list)),
-		rows(db, TRIGGERS(list)),
-		rows(db, GRANTS(list)),
-		rows(db, COLUMN_GRANTS(list)),
-		serviceRows(db, "storage.buckets", BUCKETS),
-		rows(db, REALTIME),
-		rows(db, FUNCTIONS(list)),
-		rows(db, ROLE_SETTINGS),
-		hooks.length > 0 ? readHooks(db, hooks) : void 0,
-		rows(db, FUNCTION_COMMENTS(list))
-	]);
-	const constraints = groupById(constraintRows);
-	const indexes = groupById(indexRows);
-	const policies = groupById(policyRows);
-	const triggers = groupById(triggerRows);
-	const grants = groupById(grantRows);
-	const columnGrants = groupById(columnGrantRows);
-	const roleSettings = {};
-	for (const row of roleRows) Object.assign(roleSettings[row.role] ??= {}, settingsOf(row.config));
-	return {
-		tables: relations.map((relation) => {
-			const id = Number(relation.id);
-			const own = constraints.get(id) ?? [];
-			const ownIndexes = indexes.get(id) ?? [];
-			const uniques = own.filter((con) => con.type === "u").map((con) => ({
-				name: con.name,
-				columns: con.columns
-			}));
-			const constraintNames = new Set(own.map((con) => con.name));
-			for (const index of ownIndexes) if (index.unique && !index.primary && !index.partial && !constraintNames.has(index.name)) uniques.push({
-				name: index.name,
-				columns: index.columns
-			});
-			return {
-				id,
-				schema: relation.schema,
-				name: relation.name,
-				primaryKey: own.find((con) => con.type === "p")?.columns ?? [],
-				uniques,
-				foreignKeys: own.filter((con) => con.type === "f").map((con) => ({
-					name: con.name,
-					onDelete: ACTIONS[con.on_delete] ?? "no action",
-					onUpdate: ACTIONS[con.on_update] ?? "no action"
-				})),
-				checks: own.filter((con) => con.type === "c").map((con) => ({
-					name: con.name,
-					definition: con.definition
-				})),
-				indexes: ownIndexes.map((index) => ({
-					name: index.name,
-					columns: index.columns,
-					unique: index.unique,
-					primary: index.primary,
-					partial: index.partial,
-					method: index.method,
-					predicate: index.predicate
-				})),
-				policies: (policies.get(id) ?? []).map((policy) => ({
-					name: policy.name,
-					command: policy.command,
-					roles: policy.roles,
-					permissive: policy.permissive,
-					using: policy.using_expr,
-					check: policy.check_expr,
-					functions: policy.functions ?? []
-				})),
-				triggers: (triggers.get(id) ?? []).map((trigger) => ({
-					name: trigger.name,
-					timing: trigger.timing,
-					events: trigger.events,
-					level: trigger.level,
-					function: trigger.function,
-					...trigger.args === null ? {} : { args: trigger.args },
-					...trigger.source === null ? {} : { source: trigger.source },
-					...trigger.comment === null ? {} : { comment: trigger.comment }
-				})),
-				grants: (grants.get(id) ?? []).map((grant) => ({
-					role: grant.role,
-					privileges: grant.privileges
-				})),
-				columnGrants: (columnGrants.get(id) ?? []).map((grant) => ({
-					column: grant.column,
-					role: grant.role,
-					privileges: grant.privileges
-				})),
-				...relation.large ? { large: true } : {},
-				...relation.partition_of ? { partitionOf: relation.partition_of } : {}
-			};
-		}),
-		buckets: buckets.map((row) => ({
-			id: row.id,
-			public: row.public,
-			fileSizeLimit: row.file_size_limit === null ? null : Number(row.file_size_limit),
-			allowedMimeTypes: row.allowed_mime_types,
-			...row.has_versioning ? { versioning: row.versioning_status } : {},
-			...row.has_lifecycle ? { lifecycle: row.lifecycle_configuration } : {}
-		})),
-		realtime: realtime.map((row) => row.name),
-		roleSettings,
-		functions: functions.map((row) => ({
-			...functionOf(row),
-			execute: row.execute
-		})),
-		...hookRows ? { hooks: hookRows } : {},
-		...commentRows.length > 0 ? { functionComments: Object.fromEntries(commentRows.map((row) => [row.key, row.comment])) } : {}
-	};
-}
-//#endregion
-//#region src/cli/introspect/fingerprint.ts
-/**
-* Catalogs whose rows only change with DDL, grants, comments or settings,
-* with the column that ties a row to a relation or namespace, if any.
-*/
-const CATALOGS = [
-	["pg_namespace", "oid"],
-	["pg_attribute", "attrelid"],
-	["pg_attrdef", "adrelid"],
-	["pg_constraint", "conrelid"],
-	["pg_index", "indrelid"],
-	["pg_inherits"],
-	["pg_rewrite"],
-	["pg_policy"],
-	["pg_trigger", "tgrelid"],
-	["pg_proc"],
-	["pg_type", "typnamespace"],
-	["pg_enum"],
-	["pg_description"],
-	["pg_db_role_setting"],
-	["pg_publication"],
-	["pg_publication_rel"],
-	["pg_extension"]
-];
-const TEMP_NAMESPACES = String.raw`(select oid from pg_catalog.pg_namespace where nspname like 'pg\_temp\_%' or nspname like 'pg\_toast\_temp\_%')`;
-const TEMP_RELATIONS = `(select oid from pg_catalog.pg_class where relnamespace in ${TEMP_NAMESPACES})`;
-const catalogRows = ([name, column]) => {
-	if (column === void 0) return `pg_catalog.${name}`;
-	return `(select * from pg_catalog.${name} where ${column} not in ${column === "oid" || column === "typnamespace" ? TEMP_NAMESPACES : TEMP_RELATIONS})`;
-};
-const digest = (from) => `(select md5(coalesce(string_agg(x::text, ',' order by x::text), '')) from ${from} x)`;
-/**
-* One cheap query whose result changes whenever introspection could. pg_class
-* leaves out the planner statistics that VACUUM and ANALYZE rewrite, except
-* the row-count threshold the snapshot records. pg_depend is limited to the
-* policies' rows, which name the tables and functions each policy uses.
-* pg_auth_members decides which privileges a role inherits, so the execute
-* lists change with it. Bucket rows are data, so they are hashed when
-* `storage.buckets` exists.
-*/
-const FINGERPRINT_SQL = `select md5(concat_ws('|',
-  ${digest(`(select oid, relname, relnamespace, relkind, relacl, reloptions, relrowsecurity, relforcerowsecurity, relreplident, relispartition, reltuples >= ${LARGE_TABLE_ROWS} as large from pg_catalog.pg_class where relnamespace not in ${TEMP_NAMESPACES})`)},
-  ${CATALOGS.map((entry) => digest(catalogRows(entry))).join(",\n  ")},
-  ${digest(`(select objid, refclassid, refobjid, refobjsubid, deptype from pg_catalog.pg_depend where classid = 'pg_catalog.pg_policy'::regclass)`)},
-  (select md5(coalesce(string_agg(rolname, ',' order by rolname), '')) from pg_catalog.pg_roles),
-  ${digest("pg_catalog.pg_auth_members")},
-  case when to_regclass('storage.buckets') is not null
-    then md5(query_to_xml('select id, public, file_size_limit, allowed_mime_types, to_jsonb(b) -> ''versioning_status'' as versioning, to_jsonb(b) -> ''lifecycle_configuration'' as lifecycle from storage.buckets b order by id', false, false, '')::text)
-  end
-)) as fingerprint`;
-/** A hash of the catalog; equal values mean introspection would return the same snapshot. */
-async function catalogFingerprint(db) {
-	const [row] = (await db.query(FINGERPRINT_SQL)).rows;
-	const value = row && typeof row === "object" && "fingerprint" in row ? row.fingerprint : void 0;
-	if (typeof value !== "string") throw new TypeError("The catalog fingerprint query returned no row.");
-	return value;
-}
-//#endregion
-//#region src/cli/introspect/cache.ts
-/** Shared with the splinter download cache. */
-const CACHE_DIR = "node_modules/.cache/better-supabase";
-const sha256 = (text) => createHash("sha256").update(text).digest("hex");
-function isEntry(value) {
-	return typeof value === "object" && value !== null && "key" in value && typeof value.key === "string" && "snapshot" in value && typeof value.snapshot === "object";
-}
-/**
-* Calls `read`, or returns the snapshot cached under `root` when the catalog
-* fingerprint, the `inputs` (schemas and hooks), the CLI version and the
-* typegen version all match. One file per source keeps the cache from growing. A source that
-* cannot report a fingerprint is read every time.
-*/
-async function cachedIntrospect(root, source, inputs, read) {
-	const fingerprint = await catalogFingerprint(source.queryable).catch(() => void 0);
-	if (fingerprint === void 0) return read();
-	const key = sha256(JSON.stringify([
-		VERSION,
-		TYPEGEN_VERSION,
-		source.describe,
-		inputs,
-		fingerprint
-	]));
-	const file = resolve(root, CACHE_DIR, `snapshot-${sha256(source.describe).slice(0, 16)}.json`);
-	const cached = await readFile(file, "utf-8").then((text) => JSON.parse(text)).catch(() => void 0);
-	if (isEntry(cached) && cached.key === key) return cached.snapshot;
-	const snapshot = await read();
-	await writeAtomic(file, JSON.stringify({
-		key,
-		snapshot
-	})).catch(() => void 0);
-	return snapshot;
-}
-/**
-* Calls `produce`, or returns the `database.types.ts` cached under `root`
-* for the same `inputs`, CLI version and typegen version. Typegen and oxfmt
-* are most of a `gen` run on a large schema, and their output only depends
-* on the inputs.
-*/
-async function cachedDatabaseTypes(root, inputs, produce) {
-	const key = sha256(JSON.stringify([
-		VERSION,
-		TYPEGEN_VERSION,
-		inputs
-	]));
-	const file = resolve(root, CACHE_DIR, "database-types.json");
-	const cached = await readFile(file, "utf-8").then((text) => JSON.parse(text)).catch(() => void 0);
-	if (typeof cached === "object" && cached !== null && "key" in cached && cached.key === key && "contents" in cached && typeof cached.contents === "string") return cached.contents;
-	const contents = await produce();
-	await writeAtomic(file, JSON.stringify({
-		key,
-		contents
-	})).catch(() => void 0);
-	return contents;
-}
-/** Writes through a temporary file, so a concurrent reader never sees half a file. */
-async function writeAtomic(file, contents) {
-	await mkdir(dirname(file), { recursive: true });
-	const temporary = `${file}.${process.pid}-${crypto.randomUUID()}.tmp`;
-	try {
-		await writeFile(temporary, contents);
-		await rename(temporary, file);
-	} catch (cause) {
-		await rm(temporary, { force: true });
-		throw cause;
-	}
-}
-//#endregion
-export { catalogFingerprint as a, writeAtomic as i, cachedDatabaseTypes as n, readExtras as o, cachedIntrospect as r, CACHE_DIR as t };

package/dist/cli/catalog-Cm6BtquM.js

@@ -1,188 +0,0 @@
-import { t as byCodePoint } from "./compare-BmIWVEui.js";
-//#region src/cli/introspect/catalog.ts
-const byName = (a, b) => a.schema === b.schema ? a.name < b.name ? -1 : a.name > b.name ? 1 : 0 : a.schema < b.schema ? -1 : 1;
-function toColumn(column) {
-	const isArray = column.data_type === "ARRAY";
-	const udt = isArray ? column.format.replace(/^_/, "") : column.format;
-	const defaultValue = column.default_value === null || column.default_value === void 0 ? null : String(column.default_value);
-	return {
-		name: column.name,
-		udt,
-		format: column.format,
-		typeSchema: column.type_schema,
-		isArray,
-		isEnum: column.enums.length > 0,
-		nullable: column.is_nullable,
-		hasDefault: defaultValue !== null || column.identity_generation !== null || column.is_generated,
-		default: defaultValue,
-		identity: column.identity_generation === "ALWAYS" ? "always" : column.identity_generation === "BY DEFAULT" ? "by default" : null,
-		generated: column.is_generated,
-		updatable: column.is_updatable,
-		comment: column.comment
-	};
-}
-function toFunction(fn, typeOf, relationName) {
-	const args = [];
-	const table = [];
-	fn.args.forEach((arg, index) => {
-		const type = typeOf(arg.type_id);
-		const raw = type?.name ?? "unknown";
-		const typeSchema = type ? { typeSchema: type.schema } : {};
-		const name = arg.name || `arg${index + 1}`;
-		if (arg.mode === "in" || arg.mode === "inout" || arg.mode === "variadic") {
-			const isArray = raw.startsWith("_");
-			args.push({
-				name,
-				udt: isArray ? raw.slice(1) : raw,
-				...typeSchema,
-				isArray,
-				hasDefault: arg.has_default === true
-			});
-		}
-		if (arg.mode === "table" || arg.mode === "out" || arg.mode === "inout") table.push({
-			name,
-			udt: raw,
-			...typeSchema
-		});
-	});
-	const returnType = typeOf(fn.return_type_id);
-	const searchPath = fn.config_params?.["search_path"];
-	return {
-		schema: fn.schema,
-		name: fn.name,
-		signature: fn.identity_argument_types,
-		args,
-		returnsTable: fn.args.some((arg) => arg.mode === "table") ? table : null,
-		returns: returnType?.name ?? fn.return_type,
-		...returnType ? { returnsSchema: returnType.schema } : {},
-		returnsRelation: relationName(fn.return_type_relation_id),
-		returnsSet: fn.is_set_returning_function,
-		volatility: fn.behavior.toLowerCase(),
-		securityDefiner: fn.security_definer,
-		language: fn.language,
-		searchPath: searchPath === void 0 ? null : searchPath.replace(/^""$/, "")
-	};
-}
-/** Joins the typegen metadata and the extras into one record per object. */
-function toCatalog(snapshot) {
-	const meta = snapshot.generator;
-	const extras = new Map(snapshot.extras.tables.map((table) => [table.id, table]));
-	const columns = /* @__PURE__ */ new Map();
-	for (const column of meta.columns) {
-		const list = columns.get(column.table_id);
-		if (list) list.push(column);
-		else columns.set(column.table_id, [column]);
-	}
-	const primaryKeys = /* @__PURE__ */ new Map();
-	for (const key of meta.primaryKeys) {
-		const list = primaryKeys.get(key.table_id);
-		if (list) list.push(key.name);
-		else primaryKeys.set(key.table_id, [key.name]);
-	}
-	const relationNames = /* @__PURE__ */ new Map();
-	for (const list of [
-		meta.tables,
-		meta.foreignTables,
-		meta.views,
-		meta.materializedViews
-	]) for (const entry of list) relationNames.set(entry.id, `${entry.schema}.${entry.name}`);
-	const viewNames = new Set([...meta.views, ...meta.materializedViews].map((view) => `${view.schema}.${view.name}`));
-	const foreignKeysOf = (schema, name, extra) => {
-		const actions = new Map((extra?.foreignKeys ?? []).map((fk) => [fk.name, fk]));
-		return meta.relationships.filter((rel) => rel.schema === schema && rel.relation === name && actions.has(rel.foreign_key_name) && !viewNames.has(`${rel.referenced_schema}.${rel.referenced_relation}`)).map((rel) => {
-			const action = actions.get(rel.foreign_key_name);
-			return {
-				name: rel.foreign_key_name,
-				columns: rel.columns,
-				refSchema: rel.referenced_schema,
-				refTable: rel.referenced_relation,
-				refColumns: rel.referenced_columns,
-				oneToOne: rel.is_one_to_one,
-				onDelete: action?.onDelete ?? "no action",
-				onUpdate: action?.onUpdate ?? "no action"
-			};
-		}).sort((a, b) => byCodePoint(a.name, b.name));
-	};
-	const build = (entry, flags) => {
-		const extra = extras.get(entry.id);
-		const own = [...columns.get(entry.id) ?? []].sort((a, b) => a.ordinal_position - b.ordinal_position);
-		return {
-			id: entry.id,
-			schema: entry.schema,
-			name: entry.name,
-			comment: entry.comment,
-			...flags,
-			columns: own.map(toColumn),
-			primaryKey: extra && extra.primaryKey.length > 0 ? extra.primaryKey : primaryKeys.get(entry.id) ?? [],
-			uniques: extra?.uniques ?? [],
-			foreignKeys: foreignKeysOf(entry.schema, entry.name, extra),
-			checks: extra?.checks ?? [],
-			indexes: extra?.indexes ?? [],
-			policies: extra?.policies ?? [],
-			triggers: extra?.triggers ?? [],
-			grants: extra?.grants ?? [],
-			...extra?.columnGrants ? { columnGrants: extra.columnGrants } : {},
-			...extra?.partitionOf ? { partitionOf: extra.partitionOf } : {}
-		};
-	};
-	const tables = [
-		...meta.tables.map((table) => build(table, {
-			kind: "table",
-			rls: table.rls_enabled,
-			forceRls: table.rls_forced,
-			replicaIdentity: table.replica_identity,
-			insertable: true,
-			updatable: true
-		})),
-		...meta.foreignTables.map((table) => build(table, {
-			kind: "table",
-			rls: false,
-			forceRls: false,
-			replicaIdentity: null,
-			insertable: true,
-			updatable: true
-		})),
-		...meta.views.map((view) => build(view, {
-			kind: "view",
-			rls: false,
-			forceRls: false,
-			replicaIdentity: null,
-			insertable: view.is_insert_enabled ?? view.is_updatable,
-			updatable: view.is_update_enabled ?? view.is_updatable
-		})),
-		...meta.materializedViews.map((view) => build(view, {
-			kind: "view",
-			rls: false,
-			forceRls: false,
-			replicaIdentity: null,
-			insertable: false,
-			updatable: false
-		}))
-	].sort(byName);
-	const included = new Set(snapshot.schemas);
-	const enums = meta.types.filter((type) => type.enums.length > 0 && included.has(type.schema)).map((type) => ({
-		schema: type.schema,
-		name: type.name,
-		values: type.enums
-	})).sort(byName);
-	const types = new Map(meta.types.map((type) => [type.id, type]));
-	const comments = snapshot.extras.functionComments ?? {};
-	const functions = meta.functions.map((fn) => {
-		const entry = toFunction(fn, (id) => types.get(id), (id) => id === null ? null : relationNames.get(id) ?? null);
-		const comment = comments[`${fn.schema}.${fn.name}(${fn.identity_argument_types})`];
-		return comment === void 0 ? entry : {
-			...entry,
-			comment
-		};
-	}).sort((a, b) => byName(a, b) || byCodePoint(a.signature, b.signature));
-	return {
-		schemas: snapshot.schemas,
-		tables,
-		enums,
-		functions,
-		buckets: snapshot.extras.buckets,
-		realtime: snapshot.extras.realtime
-	};
-}
-//#endregion
-export { toCatalog as t };