@prisma-next/adapter-postgres 0.12.0-dev.6 → 0.12.0-dev.60

package/dist/control.mjs

@@ -1,666 +1,10 @@
-import { n as createPostgresBuiltinCodecLookup, t as renderLoweredSql } from "./sql-renderer-DlZhVI9B.mjs";
-import { t as postgresAdapterDescriptorMeta } from "./descriptor-meta-C1wNCHkd.mjs";
-import { APP_SPACE_ID } from "@prisma-next/framework-components/control";
+import { t as PostgresControlAdapter } from "./control-adapter-B7tCv02A.mjs";
+import { t as postgresAdapterDescriptorMeta } from "./descriptor-meta-NBwpqHS7.mjs";
+import { parsePostgresDefault } from "@prisma-next/target-postgres/default-normalizer";
+import { normalizeSchemaNativeType } from "@prisma-next/target-postgres/native-type-normalizer";
 import { SqlEscapeError, escapeLiteral, qualifyName, quoteIdentifier } from "@prisma-next/target-postgres/sql-utils";
-import { ifDefined } from "@prisma-next/utils/defined";
-import { PG_ENUM_CODEC_ID } from "@prisma-next/target-postgres/codec-ids";
-import { parseMarkerRowSafely, withMarkerReadErrorHandling } from "@prisma-next/errors/execution";
-import { parseContractMarkerRow } from "@prisma-next/family-sql/verify";
-import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
-import { parsePostgresDefault, parsePostgresDefault as parsePostgresDefault$1 } from "@prisma-next/target-postgres/default-normalizer";
-import { createResolveExistingEnumValues, enumStorageCompoundKey, readExistingEnumValues, readPostgresSchemaIrAnnotations } from "@prisma-next/target-postgres/enum-planning";
-import { normalizeSchemaNativeType, normalizeSchemaNativeType as normalizeSchemaNativeType$1 } from "@prisma-next/target-postgres/native-type-normalizer";
-import { blindCast } from "@prisma-next/utils/casts";
 import { timestampNowControlDescriptor } from "@prisma-next/family-sql/control";
 import { builtinGeneratorRegistryMetadata, resolveBuiltinGeneratedColumnDescriptor } from "@prisma-next/ids";
-//#region src/core/enum-control-hooks.ts
-const ENUM_INTROSPECT_QUERY = `
-  SELECT
-    n.nspname AS schema_name,
-    t.typname AS type_name,
-    array_agg(e.enumlabel ORDER BY e.enumsortorder) AS values
-  FROM pg_type t
-  JOIN pg_namespace n ON t.typnamespace = n.oid
-  JOIN pg_enum e ON t.oid = e.enumtypid
-  WHERE n.nspname = $1
-  GROUP BY n.nspname, t.typname
-  ORDER BY n.nspname, t.typname
-`;
-function isStringArray(value) {
-	return Array.isArray(value) && value.every((entry) => typeof entry === "string");
-}
-/**
-* Parses a PostgreSQL array value into a JavaScript string array.
-*
-* The `pg` library returns `array_agg` results either as a JS array
-* (when type parsers are configured) or as a string in PostgreSQL array
-* literal format (`{value1,value2,...}`). Handles PG's quoting rules:
-* - Elements containing commas, quotes, backslashes, or whitespace are
-*   double-quoted.
-* - Inside quoted elements, `\"` represents `"` and `\\` represents `\`.
-*
-* Returns `null` when the input cannot be parsed as a PG array.
-*/
-function parsePostgresArray(value) {
-	if (isStringArray(value)) return value;
-	if (typeof value === "string" && value.startsWith("{") && value.endsWith("}")) {
-		const inner = value.slice(1, -1);
-		if (inner === "") return [];
-		return parseArrayElements(inner);
-	}
-	return null;
-}
-function parseArrayElements(input) {
-	const result = [];
-	let i = 0;
-	while (i < input.length) {
-		if (input[i] === ",") {
-			i++;
-			continue;
-		}
-		if (input[i] === "\"") {
-			i++;
-			let element = "";
-			while (i < input.length && input[i] !== "\"") {
-				if (input[i] === "\\" && i + 1 < input.length) {
-					i++;
-					element += input[i];
-				} else element += input[i];
-				i++;
-			}
-			i++;
-			result.push(element);
-		} else {
-			const nextComma = input.indexOf(",", i);
-			if (nextComma === -1) {
-				result.push(input.slice(i).trim());
-				i = input.length;
-			} else {
-				result.push(input.slice(i, nextComma).trim());
-				i = nextComma;
-			}
-		}
-	}
-	return result;
-}
-/**
-* Reads enum types from the live Postgres schema and returns them in
-* the codec-typed annotation shape consumed by `control-adapter.ts`
-* (which writes them under `schema.annotations.pg.storageTypes`).
-*/
-async function introspectPostgresEnumTypes(options) {
-	const namespace = options.schemaName ?? "public";
-	const result = await options.driver.query(ENUM_INTROSPECT_QUERY, [namespace]);
-	const types = {};
-	for (const row of result.rows) {
-		const values = parsePostgresArray(row.values);
-		if (!values) throw new Error(`Failed to parse enum values for type "${row.type_name}": unexpected format: ${JSON.stringify(row.values)}`);
-		types[row.type_name] = {
-			codecId: PG_ENUM_CODEC_ID,
-			nativeType: row.type_name,
-			typeParams: { values }
-		};
-	}
-	return types;
-}
-//#endregion
-//#region src/core/control-adapter.ts
-const POSTGRES_MARKER_TABLE = "prisma_contract.marker";
-/**
-* Postgres control plane adapter for control-plane operations like introspection.
-* Provides target-specific implementations for control-plane domain actions.
-*/
-var PostgresControlAdapter = class {
-	familyId = "sql";
-	targetId = "postgres";
-	codecLookup;
-	/**
-	* @param codecLookup - Codec lookup used by the SQL renderer to resolve
-	*   per-codec metadata at lower-time. Defaults to a Postgres-builtins-only
-	*   lookup when omitted. Stack-aware callers
-	*   (`SqlControlAdapterDescriptor.create(stack)`) supply
-	*   `stack.codecLookup` so extension codecs are visible to the renderer.
-	*/
-	constructor(codecLookup) {
-		this.codecLookup = codecLookup ?? createPostgresBuiltinCodecLookup();
-	}
-	/**
-	* Target-specific normalizer for raw Postgres default expressions.
-	* Used by schema verification to normalize raw defaults before comparison.
-	*/
-	normalizeDefault = parsePostgresDefault$1;
-	/**
-	* Target-specific normalizer for Postgres schema native type names.
-	* Used by schema verification to normalize introspected type names
-	* before comparison with contract native types.
-	*/
-	normalizeNativeType = normalizeSchemaNativeType$1;
-	/**
-	* Bridges native `PostgresEnumStorageEntry` IR walks against the Postgres
-	* introspection shape (`schema.annotations.pg.storageTypes`). Lets
-	* the family-level schema verifier walk enum types without reaching
-	* into target-specific annotation layouts itself.
-	*/
-	resolveExistingEnumValues = (schema, enumType, namespaceId) => {
-		return readExistingEnumValues(schema, namespaceId === UNBOUND_NAMESPACE_ID ? readPostgresSchemaIrAnnotations(schema).schema ?? "public" : namespaceId, enumType.nativeType);
-	};
-	resolveExistingEnumValuesForContract = (contract) => createResolveExistingEnumValues(contract.storage);
-	/**
-	* Lower a SQL query AST into a Postgres-flavored `{ sql, params }` payload.
-	*
-	* Delegates to the shared `renderLoweredSql` renderer so the control adapter
-	* emits byte-identical SQL to `PostgresAdapterImpl.lower()` for the same AST
-	* and contract. Used at migration plan/emit time (e.g. by `dataTransform`)
-	* without instantiating the runtime adapter.
-	*/
-	lower(ast, context) {
-		return renderLoweredSql(ast, context.contract, this.codecLookup);
-	}
-	/**
-	* Reads the contract marker from `prisma_contract.marker`. Probes
-	* `information_schema.tables` first so a fresh database (where the
-	* `prisma_contract` schema doesn't yet exist) returns `null` instead of a
-	* "relation does not exist" error — some Postgres wire-protocol clients
-	* (e.g. PGlite's TCP proxy) don't fully recover from extended-protocol
-	* parse errors, so we probe before reading.
-	*/
-	async readMarker(driver, space) {
-		const markerContext = {
-			space,
-			markerLocation: POSTGRES_MARKER_TABLE
-		};
-		if ((await withMarkerReadErrorHandling(() => driver.query(`select 1
-       from information_schema.tables
-       where table_schema = $1 and table_name = $2`, ["prisma_contract", "marker"]), markerContext)).rows.length === 0) return null;
-		const row = (await withMarkerReadErrorHandling(() => driver.query(`select
-         core_hash,
-         profile_hash,
-         contract_json,
-         canonical_version,
-         updated_at,
-         app_tag,
-         meta,
-         invariants
-       from prisma_contract.marker
-       where space = $1`, [space]), markerContext)).rows[0];
-		if (!row) return null;
-		return parseMarkerRowSafely(row, parseContractMarkerRow, markerContext);
-	}
-	/**
-	* Reads every row from `prisma_contract.marker` and returns them keyed
-	* by `space`. Mirrors the existence probe in {@link readMarker}: a
-	* fresh database without the `prisma_contract` schema returns an empty
-	* map rather than raising "relation does not exist".
-	*/
-	async readAllMarkers(driver) {
-		const markerContext = {
-			space: APP_SPACE_ID,
-			markerLocation: POSTGRES_MARKER_TABLE
-		};
-		if ((await withMarkerReadErrorHandling(() => driver.query(`select 1
-       from information_schema.tables
-       where table_schema = $1 and table_name = $2`, ["prisma_contract", "marker"]), markerContext)).rows.length === 0) return /* @__PURE__ */ new Map();
-		const result = await withMarkerReadErrorHandling(() => driver.query(`select
-         space,
-         core_hash,
-         profile_hash,
-         contract_json,
-         canonical_version,
-         updated_at,
-         app_tag,
-         meta,
-         invariants
-       from prisma_contract.marker`), markerContext);
-		const rows = /* @__PURE__ */ new Map();
-		for (const row of result.rows) rows.set(row.space, parseMarkerRowSafely(row, parseContractMarkerRow, {
-			space: row.space,
-			markerLocation: POSTGRES_MARKER_TABLE
-		}));
-		return rows;
-	}
-	/**
-	* Introspects a Postgres database schema and returns a raw SqlSchemaIR.
-	*
-	* This is a pure schema discovery operation that queries the Postgres catalog
-	* and returns the schema structure without type mapping or contract enrichment.
-	* Type mapping and enrichment are handled separately by enrichment helpers.
-	*
-	* When `contract` is provided and its storage declares more than one
-	* namespace (or any explicit bound namespace), the adapter walks every
-	* declared namespace and merges the per-schema introspection results
-	* into a single `SqlSchemaIR`. `UNBOUND_NAMESPACE_ID` resolves to the
-	* connection's `current_schema()` so late-bound tables follow the
-	* runtime `search_path`. When no contract is passed, the adapter falls
-	* back to introspecting the single `schema` argument (defaulting to
-	* `'public'`).
-	*
-	* Uses batched queries to minimize database round trips (6 queries per
-	* schema walked).
-	*
-	* @param driver - ControlDriverInstance<'sql', 'postgres'> instance for executing queries
-	* @param contract - Optional contract for contract-guided introspection (multi-namespace walk, filtering)
-	* @param schema - Schema name to introspect when no contract is provided (defaults to 'public')
-	* @returns Promise resolving to SqlSchemaIR representing the live database schema
-	*/
-	async introspect(driver, contract, schema = "public") {
-		const declaredNamespaces = extractContractNamespaceIds(contract);
-		const ir = declaredNamespaces.length > 0 ? await this.introspectNamespaces(driver, declaredNamespaces) : await this.introspectSchema(driver, schema);
-		const existingSchemas = await this.listExistingSchemas(driver);
-		const annotations = ir.annotations ?? {};
-		const pg = annotations.pg ?? {};
-		return {
-			...ir,
-			annotations: {
-				...annotations,
-				pg: {
-					...pg,
-					existingSchemas
-				}
-			}
-		};
-	}
-	/**
-	* Lists every non-system schema present in the connected database.
-	* The introspection consumer (`verifyPostgresNamespacePresence`)
-	* treats the result as the authoritative ground truth — declared
-	* namespaces whose `ddlSchemaName` is missing from this list become
-	* `missing_schema` issues, and the planner emits the matching
-	* `CREATE SCHEMA` before table DDL.
-	*/
-	async listExistingSchemas(driver) {
-		return (await driver.query(`SELECT nspname
-       FROM pg_catalog.pg_namespace
-       WHERE nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
-         AND nspname NOT LIKE 'pg_temp_%'
-         AND nspname NOT LIKE 'pg_toast_temp_%'
-       ORDER BY nspname`)).rows.map((row) => row.nspname);
-	}
-	/**
-	* Walks every declared namespace, resolving `UNBOUND_NAMESPACE_ID` to
-	* the connection's `current_schema()`, and merges the per-schema results
-	* into a single `SqlSchemaIR`. The merged `tables` map is flat (keyed by
-	* table name) so callers that look up by `tableName` see every contract
-	* table regardless of which namespace it lives in.
-	*/
-	async introspectNamespaces(driver, namespaceIds) {
-		const resolvedSchemas = await Promise.all(namespaceIds.map(async (id) => {
-			if (id === UNBOUND_NAMESPACE_ID) {
-				const { rows } = await driver.query("SELECT current_schema() AS current_schema");
-				return rows[0]?.current_schema ?? "public";
-			}
-			return id;
-		}));
-		const uniqueSchemas = Array.from(new Set(resolvedSchemas));
-		const perSchema = await Promise.all(uniqueSchemas.map((s) => this.introspectSchema(driver, s)));
-		const mergedTables = {};
-		for (const ir of perSchema) for (const [tableName, table] of Object.entries(ir.tables)) mergedTables[tableName] = table;
-		const mergedStorageTypes = {};
-		for (let i = 0; i < perSchema.length; i++) {
-			const ir = perSchema[i];
-			const pg = blindCast(ir?.annotations?.["pg"])?.storageTypes;
-			if (!pg) continue;
-			for (const [key, value] of Object.entries(pg)) mergedStorageTypes[key] = value;
-		}
-		const firstAnnotations = perSchema[0]?.annotations;
-		const firstPg = blindCast(firstAnnotations?.["pg"]) ?? {};
-		return {
-			tables: mergedTables,
-			...ifDefined("annotations", {
-				...firstAnnotations,
-				pg: {
-					...firstPg,
-					...ifDefined("storageTypes", Object.keys(mergedStorageTypes).length > 0 ? mergedStorageTypes : void 0)
-				}
-			})
-		};
-	}
-	/**
-	* Introspects a single Postgres schema and returns a raw SqlSchemaIR
-	* containing only the tables in that schema. Used by `introspect` as
-	* the per-namespace walk.
-	*/
-	async introspectSchema(driver, schema) {
-		const [tablesResult, columnsResult, pkResult, fkResult, uniqueResult, indexResult] = await Promise.all([
-			driver.query(`SELECT table_name
-         FROM information_schema.tables
-         WHERE table_schema = $1
-           AND table_type = 'BASE TABLE'
-         ORDER BY table_name`, [schema]),
-			driver.query(`SELECT
-           c.table_name,
-           column_name,
-           data_type,
-           udt_name,
-           is_nullable,
-           character_maximum_length,
-           numeric_precision,
-           numeric_scale,
-           column_default,
-           format_type(a.atttypid, a.atttypmod) AS formatted_type
-         FROM information_schema.columns c
-         JOIN pg_catalog.pg_class cl
-           ON cl.relname = c.table_name
-         JOIN pg_catalog.pg_namespace ns
-           ON ns.nspname = c.table_schema
-           AND ns.oid = cl.relnamespace
-         JOIN pg_catalog.pg_attribute a
-           ON a.attrelid = cl.oid
-           AND a.attname = c.column_name
-           AND a.attnum > 0
-           AND NOT a.attisdropped
-         WHERE c.table_schema = $1
-         ORDER BY c.table_name, c.ordinal_position`, [schema]),
-			driver.query(`SELECT
-           tc.table_name,
-           tc.constraint_name,
-           kcu.column_name,
-           kcu.ordinal_position
-         FROM information_schema.table_constraints tc
-         JOIN information_schema.key_column_usage kcu
-           ON tc.constraint_name = kcu.constraint_name
-           AND tc.table_schema = kcu.table_schema
-           AND tc.table_name = kcu.table_name
-         WHERE tc.table_schema = $1
-           AND tc.constraint_type = 'PRIMARY KEY'
-         ORDER BY tc.table_name, kcu.ordinal_position`, [schema]),
-			driver.query(`SELECT
-           tc.table_name,
-           tc.constraint_name,
-           kcu.column_name,
-           kcu.ordinal_position,
-           ref_ns.nspname AS referenced_table_schema,
-           ref_cl.relname AS referenced_table_name,
-           ref_att.attname AS referenced_column_name,
-           rc.delete_rule,
-           rc.update_rule
-         FROM information_schema.table_constraints tc
-         JOIN information_schema.key_column_usage kcu
-           ON tc.constraint_name = kcu.constraint_name
-           AND tc.table_schema = kcu.table_schema
-           AND tc.table_name = kcu.table_name
-         JOIN pg_catalog.pg_constraint pgc
-           ON pgc.conname = tc.constraint_name
-           AND pgc.connamespace = (
-             SELECT oid FROM pg_catalog.pg_namespace WHERE nspname = tc.table_schema
-           )
-         JOIN pg_catalog.pg_class ref_cl
-           ON ref_cl.oid = pgc.confrelid
-         JOIN pg_catalog.pg_namespace ref_ns
-           ON ref_ns.oid = ref_cl.relnamespace
-         JOIN pg_catalog.pg_attribute ref_att
-           ON ref_att.attrelid = pgc.confrelid
-           AND ref_att.attnum = pgc.confkey[kcu.ordinal_position]
-         JOIN information_schema.referential_constraints rc
-           ON rc.constraint_name = tc.constraint_name
-           AND rc.constraint_schema = tc.table_schema
-         WHERE tc.table_schema = $1
-           AND tc.constraint_type = 'FOREIGN KEY'
-         ORDER BY tc.table_name, tc.constraint_name, kcu.ordinal_position`, [schema]),
-			driver.query(`SELECT
-           tc.table_name,
-           tc.constraint_name,
-           kcu.column_name,
-           kcu.ordinal_position
-         FROM information_schema.table_constraints tc
-         JOIN information_schema.key_column_usage kcu
-           ON tc.constraint_name = kcu.constraint_name
-           AND tc.table_schema = kcu.table_schema
-           AND tc.table_name = kcu.table_name
-         WHERE tc.table_schema = $1
-           AND tc.constraint_type = 'UNIQUE'
-         ORDER BY tc.table_name, tc.constraint_name, kcu.ordinal_position`, [schema]),
-			driver.query(`SELECT
-           i.tablename,
-           i.indexname,
-           ix.indisunique,
-           a.attname,
-           k.ord AS index_position,
-           am.amname,
-           ic.reloptions
-         FROM pg_indexes i
-         JOIN pg_class ic ON ic.relname = i.indexname
-         JOIN pg_namespace ins ON ins.oid = ic.relnamespace AND ins.nspname = $1
-         JOIN pg_index ix ON ix.indexrelid = ic.oid
-         JOIN pg_am am ON am.oid = ic.relam
-         JOIN pg_class t ON t.oid = ix.indrelid
-         JOIN pg_namespace tn ON tn.oid = t.relnamespace AND tn.nspname = $1
-         JOIN LATERAL unnest(ix.indkey::int[]) WITH ORDINALITY AS k(attnum, ord) ON true
-         LEFT JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum AND a.attnum > 0
-         WHERE i.schemaname = $1
-           AND NOT EXISTS (
-             SELECT 1
-             FROM information_schema.table_constraints tc
-             WHERE tc.table_schema = $1
-               AND tc.table_name = i.tablename
-               AND tc.constraint_name = i.indexname
-           )
-         ORDER BY i.tablename, i.indexname, k.ord`, [schema])
-		]);
-		const columnsByTable = groupBy(columnsResult.rows, "table_name");
-		const pksByTable = groupBy(pkResult.rows, "table_name");
-		const fksByTable = groupBy(fkResult.rows, "table_name");
-		const uniquesByTable = groupBy(uniqueResult.rows, "table_name");
-		const indexesByTable = groupBy(indexResult.rows, "tablename");
-		const pkConstraintsByTable = /* @__PURE__ */ new Map();
-		for (const row of pkResult.rows) {
-			let constraints = pkConstraintsByTable.get(row.table_name);
-			if (!constraints) {
-				constraints = /* @__PURE__ */ new Set();
-				pkConstraintsByTable.set(row.table_name, constraints);
-			}
-			constraints.add(row.constraint_name);
-		}
-		const tables = {};
-		for (const tableRow of tablesResult.rows) {
-			const tableName = tableRow.table_name;
-			const columns = {};
-			for (const colRow of columnsByTable.get(tableName) ?? []) {
-				let nativeType = colRow.udt_name;
-				const formattedType = colRow.formatted_type ? normalizeFormattedType(colRow.formatted_type, colRow.data_type, colRow.udt_name) : null;
-				if (formattedType) nativeType = formattedType;
-				else if (colRow.data_type === "character varying" || colRow.data_type === "character") if (colRow.character_maximum_length) nativeType = `${colRow.data_type}(${colRow.character_maximum_length})`;
-				else nativeType = colRow.data_type;
-				else if (colRow.data_type === "numeric" || colRow.data_type === "decimal") if (colRow.numeric_precision && colRow.numeric_scale !== null) nativeType = `${colRow.data_type}(${colRow.numeric_precision},${colRow.numeric_scale})`;
-				else if (colRow.numeric_precision) nativeType = `${colRow.data_type}(${colRow.numeric_precision})`;
-				else nativeType = colRow.data_type;
-				else nativeType = colRow.udt_name || colRow.data_type;
-				columns[colRow.column_name] = {
-					name: colRow.column_name,
-					nativeType,
-					nullable: colRow.is_nullable === "YES",
-					...ifDefined("default", colRow.column_default ?? void 0)
-				};
-			}
-			const pkRows = [...pksByTable.get(tableName) ?? []];
-			const primaryKeyColumns = pkRows.sort((a, b) => a.ordinal_position - b.ordinal_position).map((row) => row.column_name);
-			const primaryKey = primaryKeyColumns.length > 0 ? {
-				columns: primaryKeyColumns,
-				...pkRows[0]?.constraint_name ? { name: pkRows[0].constraint_name } : {}
-			} : void 0;
-			const foreignKeysMap = /* @__PURE__ */ new Map();
-			for (const fkRow of fksByTable.get(tableName) ?? []) {
-				const existing = foreignKeysMap.get(fkRow.constraint_name);
-				if (existing) {
-					existing.columns.push(fkRow.column_name);
-					existing.referencedColumns.push(fkRow.referenced_column_name);
-				} else foreignKeysMap.set(fkRow.constraint_name, {
-					columns: [fkRow.column_name],
-					referencedTable: fkRow.referenced_table_name,
-					referencedSchema: fkRow.referenced_table_schema,
-					referencedColumns: [fkRow.referenced_column_name],
-					name: fkRow.constraint_name,
-					deleteRule: fkRow.delete_rule,
-					updateRule: fkRow.update_rule
-				});
-			}
-			const foreignKeys = Array.from(foreignKeysMap.values()).map((fk) => ({
-				columns: Object.freeze([...fk.columns]),
-				referencedTable: fk.referencedTable,
-				referencedSchema: fk.referencedSchema,
-				referencedColumns: Object.freeze([...fk.referencedColumns]),
-				name: fk.name,
-				...ifDefined("onDelete", mapReferentialAction(fk.deleteRule)),
-				...ifDefined("onUpdate", mapReferentialAction(fk.updateRule))
-			}));
-			const pkConstraints = pkConstraintsByTable.get(tableName) ?? /* @__PURE__ */ new Set();
-			const uniquesMap = /* @__PURE__ */ new Map();
-			for (const uniqueRow of uniquesByTable.get(tableName) ?? []) {
-				if (pkConstraints.has(uniqueRow.constraint_name)) continue;
-				const existing = uniquesMap.get(uniqueRow.constraint_name);
-				if (existing) existing.columns.push(uniqueRow.column_name);
-				else uniquesMap.set(uniqueRow.constraint_name, {
-					columns: [uniqueRow.column_name],
-					name: uniqueRow.constraint_name
-				});
-			}
-			const uniques = Array.from(uniquesMap.values()).map((uq) => ({
-				columns: Object.freeze([...uq.columns]),
-				name: uq.name
-			}));
-			const indexesMap = /* @__PURE__ */ new Map();
-			for (const idxRow of indexesByTable.get(tableName) ?? []) {
-				if (!idxRow.attname) continue;
-				const existing = indexesMap.get(idxRow.indexname);
-				if (existing) existing.columns.push(idxRow.attname);
-				else {
-					const indexType = idxRow.amname && idxRow.amname !== "btree" ? idxRow.amname : void 0;
-					const indexOptions = parsePgReloptions(idxRow.reloptions, idxRow.indexname);
-					indexesMap.set(idxRow.indexname, {
-						columns: [idxRow.attname],
-						name: idxRow.indexname,
-						unique: idxRow.indisunique,
-						type: indexType,
-						options: indexOptions
-					});
-				}
-			}
-			const indexes = Array.from(indexesMap.values()).map((idx) => ({
-				columns: Object.freeze([...idx.columns]),
-				name: idx.name,
-				unique: idx.unique,
-				...idx.type !== void 0 && { type: idx.type },
-				...idx.options !== void 0 && { options: idx.options }
-			}));
-			tables[tableName] = {
-				name: tableName,
-				columns,
-				...ifDefined("primaryKey", primaryKey),
-				foreignKeys,
-				uniques,
-				indexes
-			};
-		}
-		const rawStorageTypes = await introspectPostgresEnumTypes({
-			driver,
-			schemaName: schema
-		});
-		const storageTypes = {};
-		for (const [typeName, annotation] of Object.entries(rawStorageTypes)) storageTypes[enumStorageCompoundKey(schema, typeName)] = annotation;
-		return {
-			tables,
-			annotations: { pg: {
-				schema,
-				version: await this.getPostgresVersion(driver),
-				...ifDefined("storageTypes", Object.keys(storageTypes).length > 0 ? storageTypes : void 0)
-			} }
-		};
-	}
-	/**
-	* Gets the Postgres version from the database.
-	*/
-	async getPostgresVersion(driver) {
-		return ((await driver.query("SELECT version() AS version", [])).rows[0]?.version ?? "").match(/PostgreSQL (\d+\.\d+)/)?.[1] ?? "unknown";
-	}
-};
-/**
-* Extracts the namespace coordinate ids declared on a contract's storage,
-* or returns an empty array when no contract (or no storage / namespaces)
-* is present. Used by `PostgresControlAdapter.introspect` to decide
-* between the multi-namespace walk and the single-schema fallback.
-*/
-function extractContractNamespaceIds(contract) {
-	if (contract === null || typeof contract !== "object") return [];
-	const storage = contract.storage;
-	if (storage === null || typeof storage !== "object") return [];
-	const namespaces = storage.namespaces;
-	if (namespaces === null || typeof namespaces !== "object") return [];
-	return Object.keys(namespaces);
-}
-function normalizeFormattedType(formattedType, dataType, udtName) {
-	if (formattedType === "integer") return "int4";
-	if (formattedType === "smallint") return "int2";
-	if (formattedType === "bigint") return "int8";
-	if (formattedType === "real") return "float4";
-	if (formattedType === "double precision") return "float8";
-	if (formattedType === "boolean") return "bool";
-	if (formattedType.startsWith("varchar")) return formattedType.replace("varchar", "character varying");
-	if (formattedType.startsWith("bpchar")) return formattedType.replace("bpchar", "character");
-	if (formattedType.startsWith("varbit")) return formattedType.replace("varbit", "bit varying");
-	if (dataType === "timestamp with time zone" || udtName === "timestamptz") return formattedType.replace("timestamp", "timestamptz").replace(" with time zone", "").trim();
-	if (dataType === "timestamp without time zone" || udtName === "timestamp") return formattedType.replace(" without time zone", "").trim();
-	if (dataType === "time with time zone" || udtName === "timetz") return formattedType.replace("time", "timetz").replace(" with time zone", "").trim();
-	if (dataType === "time without time zone" || udtName === "time") return formattedType.replace(" without time zone", "").trim();
-	if (formattedType.startsWith("\"") && formattedType.endsWith("\"")) return formattedType.slice(1, -1);
-	return formattedType;
-}
-const PG_REFERENTIAL_ACTION_MAP = {
-	"NO ACTION": "noAction",
-	RESTRICT: "restrict",
-	CASCADE: "cascade",
-	"SET NULL": "setNull",
-	"SET DEFAULT": "setDefault"
-};
-/**
-* Maps a Postgres referential action rule to the canonical SqlReferentialAction.
-* Returns undefined for 'NO ACTION' (the database default) to keep the IR sparse.
-* Throws for unrecognized rules to prevent silent data loss.
-*/
-function mapReferentialAction(rule) {
-	const mapped = PG_REFERENTIAL_ACTION_MAP[rule];
-	if (mapped === void 0) throw new Error(`Unknown PostgreSQL referential action rule: "${rule}". Expected one of: NO ACTION, RESTRICT, CASCADE, SET NULL, SET DEFAULT.`);
-	if (mapped === "noAction") return void 0;
-	return mapped;
-}
-/**
-* Groups an array of objects by a specified key.
-* Returns a Map for O(1) lookup by group key.
-*/
-/**
-* Parses a `pg_class.reloptions` array into a `Record<string, string>`.
-*
-* Postgres returns reloptions as a `text[]` whose entries are `key=value`
-* strings; the value side is always a string regardless of the underlying
-* scalar type. The verifier compares contract options to introspected
-* options after coercing both sides to strings, so keeping the raw text
-* here is correct.
-*
-* Returns `undefined` when the input is null/empty (no WITH clause).
-*/
-function parsePgReloptions(reloptions, indexName) {
-	if (!reloptions || reloptions.length === 0) return;
-	const result = {};
-	for (const entry of reloptions) {
-		const eq = entry.indexOf("=");
-		if (eq === -1) throw new Error(`Postgres introspection: malformed reloption entry "${entry}" on index "${indexName}" (expected "key=value")`);
-		const key = entry.slice(0, eq);
-		result[key] = entry.slice(eq + 1);
-	}
-	return Object.keys(result).length > 0 ? result : void 0;
-}
-function groupBy(items, key) {
-	const map = /* @__PURE__ */ new Map();
-	for (const item of items) {
-		const groupKey = item[key];
-		let group = map.get(groupKey);
-		if (!group) {
-			group = [];
-			map.set(groupKey, group);
-		}
-		group.push(item);
-	}
-	return map;
-}
-//#endregion
 //#region src/core/control-mutation-defaults.ts
 function invalidArgumentDiagnostic(input) {
 	return {