better-supabase 0.8.0 → 0.9.0

package/dist/cli/cache-Cx6qlRDR.js

@@ -0,0 +1,502 @@
+import { t as VERSION } from "./version-DNRW4DAP.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
+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 ('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 } : {}
+			};
+		}),
+		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-Di15TkM2.js

@@ -0,0 +1,187 @@
+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 } : {}
+		};
+	};
+	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 };