@prisma-next/adapter-postgres 0.14.0 → 0.15.0-dev.10

package/dist/{control-adapter-Dspz5uKp.mjs → control-adapter-aFfSI2bK.mjs}

@@ -5,10 +5,13 @@ import { parseMarkerRowSafely, rethrowMarkerReadError, withMarkerReadErrorHandli
 import { parseContractMarkerRow } from "@prisma-next/family-sql/verify";
 import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
 import { REFERENTIAL_ACTION_SQL } from "@prisma-next/sql-contract/referential-action-sql";
+import { RelationalSchemaNodeKind } from "@prisma-next/sql-schema-ir/types";
 import { buildControlTableBootstrapQueries, buildSignMarkerBootstrapQueries, int4, int8, jsonb, pgTable, text, textArray, timestamptz } from "@prisma-next/target-postgres/contract-free";
 import { parsePostgresDefault } from "@prisma-next/target-postgres/default-normalizer";
 import { normalizeSchemaNativeType } from "@prisma-next/target-postgres/native-type-normalizer";
+import { parseRlsPolicyWireName } from "@prisma-next/target-postgres/rls-canonicalize";
 import { escapeLiteral, quoteIdentifier } from "@prisma-next/target-postgres/sql-utils";
+import { PostgresDatabaseSchemaNode, PostgresNamespaceSchemaNode, PostgresNativeEnumSchemaNode, PostgresPolicySchemaNode, PostgresRoleSchemaNode, PostgresSchemaNodeKind, PostgresTableSchemaNode } from "@prisma-next/target-postgres/types";
 import { blindCast } from "@prisma-next/utils/casts";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { createAstCodecRegistry, deriveParamMetadata, encodeParamsWithMetadata } from "@prisma-next/sql-runtime";
@@ -76,6 +79,20 @@ const ledger = pgTable({
 	operations: jsonb()
 });
 /**
+* Content-addressed contract store: one row per distinct contract, keyed
+* by its storage hash. The ledger's `origin_core_hash` /
+* `destination_core_hash` resolve here by hash equality, so both
+* endpoints of every edge are direct lookups and a contract revisited by
+* a rollback cycle is stored exactly once (upsert DO NOTHING).
+*/
+const ledgerContract = pgTable({
+	name: "contract",
+	schema: "prisma_contract"
+}, {
+	core_hash: text(),
+	contract_json: jsonb()
+});
+/**
 * Read-side handle covering every column of `prisma_contract.ledger`,
 * including the DB-generated `id` (for ORDER BY) and `created_at`.
 */
@@ -107,7 +124,7 @@ const NOW = new RawExpr({
 	}
 });
 function mergeInvariants(current, incoming) {
-	return [...new Set([...current, ...incoming])].sort();
+	return [.../* @__PURE__ */ new Set([...current, ...incoming])].sort();
 }
 async function execute(lower, driver, query) {
 	const lowered = lower(query);
@@ -123,7 +140,7 @@ async function execute(lower, driver, query) {
 *
 * Spellings match the on-disk `meta.db.sql.postgres.nativeType` values in `@prisma-next/target-postgres`'s codec definitions, not the `udt_name` abbreviations that ADR 205 used as illustrative shorthand. The lookup-based cast policy compares against these strings directly.
 */
-const POSTGRES_INFERRABLE_NATIVE_TYPES = new Set([
+const POSTGRES_INFERRABLE_NATIVE_TYPES = /* @__PURE__ */ new Set([
 	"integer",
 	"smallint",
 	"bigint",
@@ -143,15 +160,19 @@ const POSTGRES_INFERRABLE_NATIVE_TYPES = new Set([
 	"bit",
 	"bit varying"
 ]);
-function renderTypedParam(index, codecId, codecLookup) {
+function renderTypedParam(index, codecId, codecLookup, many, typeParams) {
 	if (codecId === void 0) return `$${index}`;
-	const meta = codecLookup.metaFor(codecId);
+	const meta = codecLookup.metaFor(codecId, typeParams);
 	if (!(codecLookup.get(codecId) !== void 0 || meta !== void 0 || codecLookup.targetTypesFor(codecId) !== void 0)) throw new Error(`Postgres lowering: ParamRef carries codecId "${codecId}" but the assembled codec lookup has no entry for it. This usually indicates a missing extension pack in the runtime stack — register the pack that contributes this codec (e.g. \`extensionPacks: [pgvectorRuntime]\`), or use the codec directly from \`@prisma-next/target-postgres/codecs\` if it's a builtin.`);
 	const dbRecord = meta?.db;
 	const sqlBlock = isRecord(dbRecord) ? dbRecord["sql"] : void 0;
 	const dialectBlock = isRecord(sqlBlock) ? sqlBlock["postgres"] : void 0;
 	const nativeType = isRecord(dialectBlock) ? dialectBlock["nativeType"] : void 0;
-	if (typeof nativeType === "string" && !POSTGRES_INFERRABLE_NATIVE_TYPES.has(nativeType)) return `$${index}::${nativeType}`;
+	if (typeof nativeType === "string") {
+		const arraySuffix = many ? "[]" : "";
+		if (!POSTGRES_INFERRABLE_NATIVE_TYPES.has(nativeType)) return `$${index}::${nativeType}${arraySuffix}`;
+		if (many) return `$${index}::${nativeType}${arraySuffix}`;
+	}
 	return `$${index}`;
 }
 function isRecord(value) {
@@ -497,12 +518,12 @@ function renderExpr(expr, contract, pim) {
 function renderParamRef(ref, pim) {
 	const index = pim.indexMap.get(ref);
 	if (index === void 0) throw new Error("ParamRef not found in index map");
-	if (ref.kind === "prepared-param-ref") return renderTypedParam(index, ref.codec.codecId, pim.codecLookup);
+	if (ref.kind === "prepared-param-ref") return renderTypedParam(index, ref.codec.codecId, pim.codecLookup, ref.codec.many, ref.codec.typeParams);
 	if (ref.codec === void 0) throw runtimeError("RUNTIME.PARAM_REF_MISSING_CODEC", "Postgres renderer: ParamRef reached lowering without a bound CodecRef. Every column-bound ParamRef must carry a codec under the AST-bound codec contract. This usually indicates a builder path that constructed a ParamRef without threading the column codec.", {
 		paramIndex: index,
 		...ifDefined("name", ref.name)
 	});
-	return renderTypedParam(index, ref.codec.codecId, pim.codecLookup);
+	return renderTypedParam(index, ref.codec.codecId, pim.codecLookup, ref.codec.many, ref.codec.typeParams);
 }
 function renderLiteral(expr) {
 	if (typeof expr.value === "string") return `'${escapeLiteral(expr.value)}'`;
@@ -824,11 +845,20 @@ var PostgresControlAdapter = class {
 		}).where(marker.space.eq(space).and(marker.core_hash.eq(expectedFrom))).returning(marker.space).build())).length > 0;
 	}
 	/**
-	* Appends a ledger entry for `space`. See the
+	* Appends a ledger entry for `space`. When the edge carries a
+	* destination contract snapshot, the content-addressed
+	* `prisma_contract.contract` store is populated first (keyed by the
+	* destination hash, DO NOTHING on revisit) so a reader never sees a
+	* ledger row whose stored destination contract is missing. See the
 	* `SqlControlAdapter.writeLedgerEntry` contract.
 	*/
 	async writeLedgerEntry(driver, space, entry) {
-		await execute((query) => this.lower(query, { contract: void 0 }), driver, ledger.insert({
+		const lower = (query) => this.lower(query, { contract: void 0 });
+		if (entry.destinationContractJson !== void 0) await execute(lower, driver, ledgerContract.upsert({
+			core_hash: entry.to,
+			contract_json: entry.destinationContractJson
+		}).onConflict(ledgerContract.core_hash).doNothing().build());
+		await execute(lower, driver, ledger.insert({
 			space,
 			migration_name: entry.migrationName,
 			migration_hash: entry.migrationHash,
@@ -887,20 +917,34 @@ var PostgresControlAdapter = class {
 	*/
 	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
-				}
-			}
-		};
+		const resolvedSchemas = declaredNamespaces.length > 0 ? await this.resolveNamespaceSchemas(driver, declaredNamespaces) : [schema];
+		const namespaces = {};
+		let pgVersion = "unknown";
+		for (const resolved of resolvedSchemas) {
+			const { namespace, pgVersion: version } = await this.introspectSchema(driver, resolved);
+			namespaces[resolved] = namespace;
+			pgVersion = version;
+		}
+		return new PostgresDatabaseSchemaNode({
+			namespaces,
+			roles: await this.introspectRoles(driver),
+			existingSchemas: await this.listExistingSchemas(driver),
+			pgVersion
+		});
+	}
+	/**
+	* Reads cluster-scoped database roles. Roles are not schema-qualified, so
+	* this is queried once for the whole database rather than per namespace.
+	*/
+	async introspectRoles(driver) {
+		return (await driver.query(`SELECT rolname
+       FROM pg_catalog.pg_roles
+       WHERE rolname NOT LIKE 'pg_%'
+         AND rolname != 'postgres'
+       ORDER BY rolname`)).rows.map((row) => new PostgresRoleSchemaNode({
+			name: row.rolname,
+			namespaceId: UNBOUND_NAMESPACE_ID
+		}));
 	}
 	/**
 	* Lists every non-system schema present in the connected database.
@@ -919,36 +963,24 @@ var PostgresControlAdapter = class {
        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.
+	* Resolves the declared namespace ids to their live DDL schema names,
+	* mapping `UNBOUND_NAMESPACE_ID` to the connection's `current_schema()`
+	* and de-duplicating. The caller introspects one namespace node per
+	* resolved schema — there is no flat cross-schema merge, so two schemas
+	* holding a same-named table no longer collide.
 	*/
-	async introspectNamespaces(driver, namespaceIds) {
+	async resolveNamespaceSchemas(driver, namespaceIds) {
 		const resolvedSchemas = [];
 		for (const id of namespaceIds) if (id === UNBOUND_NAMESPACE_ID) {
 			const { rows } = await driver.query("SELECT current_schema() AS current_schema");
 			resolvedSchemas.push(rows[0]?.current_schema ?? "public");
 		} else resolvedSchemas.push(id);
-		const uniqueSchemas = Array.from(new Set(resolvedSchemas));
-		const perSchema = [];
-		for (const schema of uniqueSchemas) perSchema.push(await this.introspectSchema(driver, schema));
-		const mergedTables = {};
-		for (const ir of perSchema) for (const [tableName, table] of Object.entries(ir.tables)) mergedTables[tableName] = table;
-		const firstAnnotations = perSchema[0]?.annotations;
-		const firstPg = blindCast(firstAnnotations?.["pg"]) ?? {};
-		return {
-			tables: mergedTables,
-			...ifDefined("annotations", {
-				...firstAnnotations,
-				pg: { ...firstPg }
-			})
-		};
+		return Array.from(new Set(resolvedSchemas));
 	}
 	/**
-	* Introspects a single Postgres schema and returns a raw SqlSchemaIR
-	* containing only the tables in that schema. Used by `introspect` as
+	* Introspects a single Postgres schema and returns the namespace node for
+	* that schema (its tables, their policies, and its native enum type names),
+	* alongside the cluster-scoped Postgres version. Used by `introspect` as
 	* the per-namespace walk.
 	*/
 	async introspectSchema(driver, schema) {
@@ -982,64 +1014,74 @@ var PostgresControlAdapter = class {
          WHERE c.table_schema = $1
          ORDER BY c.table_name, c.ordinal_position`, [schema]);
 		const pkResult = await 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]);
+           cl.relname AS table_name,
+           con.conname AS constraint_name,
+           a.attname AS column_name,
+           k.ord AS ordinal_position
+         FROM pg_catalog.pg_constraint con
+         JOIN pg_catalog.pg_class cl ON cl.oid = con.conrelid
+         JOIN pg_catalog.pg_namespace ns ON ns.oid = cl.relnamespace
+         JOIN LATERAL unnest(con.conkey) WITH ORDINALITY AS k(attnum, ord) ON true
+         JOIN pg_catalog.pg_attribute a
+           ON a.attrelid = con.conrelid
+           AND a.attnum = k.attnum
+         WHERE ns.nspname = $1
+           AND con.contype = 'p'
+         ORDER BY cl.relname, k.ord`, [schema]);
 		const fkResult = await driver.query(`SELECT
-           tc.table_name,
-           tc.constraint_name,
-           kcu.column_name,
-           kcu.ordinal_position,
+           cl.relname AS table_name,
+           con.conname AS constraint_name,
+           a.attname AS column_name,
+           k.ord AS 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
-           )
+           CASE con.confdeltype
+             WHEN 'a' THEN 'NO ACTION'
+             WHEN 'r' THEN 'RESTRICT'
+             WHEN 'c' THEN 'CASCADE'
+             WHEN 'n' THEN 'SET NULL'
+             WHEN 'd' THEN 'SET DEFAULT'
+           END AS delete_rule,
+           CASE con.confupdtype
+             WHEN 'a' THEN 'NO ACTION'
+             WHEN 'r' THEN 'RESTRICT'
+             WHEN 'c' THEN 'CASCADE'
+             WHEN 'n' THEN 'SET NULL'
+             WHEN 'd' THEN 'SET DEFAULT'
+           END AS update_rule
+         FROM pg_catalog.pg_constraint con
+         JOIN pg_catalog.pg_class cl ON cl.oid = con.conrelid
+         JOIN pg_catalog.pg_namespace ns ON ns.oid = cl.relnamespace
+         JOIN LATERAL unnest(con.conkey) WITH ORDINALITY AS k(attnum, ord) ON true
+         JOIN pg_catalog.pg_attribute a
+           ON a.attrelid = con.conrelid
+           AND a.attnum = k.attnum
          JOIN pg_catalog.pg_class ref_cl
-           ON ref_cl.oid = pgc.confrelid
+           ON ref_cl.oid = con.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]);
+           ON ref_att.attrelid = con.confrelid
+           AND ref_att.attnum = con.confkey[k.ord]
+         WHERE ns.nspname = $1
+           AND con.contype = 'f'
+         ORDER BY cl.relname, con.conname, k.ord`, [schema]);
 		const uniqueResult = await 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]);
+           cl.relname AS table_name,
+           con.conname AS constraint_name,
+           a.attname AS column_name,
+           k.ord AS ordinal_position
+         FROM pg_catalog.pg_constraint con
+         JOIN pg_catalog.pg_class cl ON cl.oid = con.conrelid
+         JOIN pg_catalog.pg_namespace ns ON ns.oid = cl.relnamespace
+         JOIN LATERAL unnest(con.conkey) WITH ORDINALITY AS k(attnum, ord) ON true
+         JOIN pg_catalog.pg_attribute a
+           ON a.attrelid = con.conrelid
+           AND a.attnum = k.attnum
+         WHERE ns.nspname = $1
+           AND con.contype = 'u'
+         ORDER BY cl.relname, con.conname, k.ord`, [schema]);
 		const indexResult = await driver.query(`SELECT
            i.tablename,
            i.indexname,
@@ -1060,10 +1102,9 @@ var PostgresControlAdapter = class {
          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
+             FROM pg_catalog.pg_constraint con
+             WHERE con.conindid = ic.oid
+               AND con.contype IN ('p', 'u', 'x')
            )
          ORDER BY i.tablename, i.indexname, k.ord`, [schema]);
 		const checkResult = await driver.query(`SELECT
@@ -1091,7 +1132,7 @@ var PostgresControlAdapter = class {
 			}
 			constraints.add(row.constraint_name);
 		}
-		const tables = {};
+		const tableInputs = {};
 		for (const tableRow of tablesResult.rows) {
 			const tableName = tableRow.table_name;
 			const columns = {};
@@ -1105,18 +1146,26 @@ var PostgresControlAdapter = class {
 				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;
+				const many = nativeType.endsWith("[]") ? true : void 0;
+				if (many) nativeType = normalizeSchemaNativeType(nativeType.slice(0, -2));
+				const resolvedNativeType = `${normalizeSchemaNativeType(nativeType)}${many ? "[]" : ""}`;
+				const rawDefault = colRow.column_default ?? void 0;
 				columns[colRow.column_name] = {
 					name: colRow.column_name,
 					nativeType,
 					nullable: colRow.is_nullable === "YES",
-					...ifDefined("default", colRow.column_default ?? void 0)
+					...ifDefined("default", rawDefault),
+					...ifDefined("many", many),
+					resolvedNativeType,
+					...ifDefined("resolvedDefault", rawDefault !== void 0 ? parsePostgresDefault(rawDefault, resolvedNativeType) : 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 } : {}
+				...pkRows[0]?.constraint_name ? { name: pkRows[0].constraint_name } : {},
+				dependsOn: postgresColumnDependsOn(schema, tableName, primaryKeyColumns)
 			} : void 0;
 			const foreignKeysMap = /* @__PURE__ */ new Map();
 			for (const fkRow of fksByTable.get(tableName) ?? []) {
@@ -1141,7 +1190,8 @@ var PostgresControlAdapter = class {
 				referencedColumns: Object.freeze([...fk.referencedColumns]),
 				name: fk.name,
 				...ifDefined("onDelete", mapReferentialAction(fk.deleteRule)),
-				...ifDefined("onUpdate", mapReferentialAction(fk.updateRule))
+				...ifDefined("onUpdate", mapReferentialAction(fk.updateRule)),
+				dependsOn: [postgresTableDependsOn(fk.referencedSchema, fk.referencedTable), ...postgresColumnDependsOn(schema, tableName, fk.columns)]
 			}));
 			const pkConstraints = pkConstraintsByTable.get(tableName) ?? /* @__PURE__ */ new Set();
 			const uniquesMap = /* @__PURE__ */ new Map();
@@ -1156,11 +1206,16 @@ var PostgresControlAdapter = class {
 			}
 			const uniques = Array.from(uniquesMap.values()).map((uq) => ({
 				columns: Object.freeze([...uq.columns]),
-				name: uq.name
+				name: uq.name,
+				dependsOn: postgresColumnDependsOn(schema, tableName, uq.columns)
 			}));
 			const indexesMap = /* @__PURE__ */ new Map();
+			const indexNamesWithExpressionKey = /* @__PURE__ */ new Set();
 			for (const idxRow of indexesByTable.get(tableName) ?? []) {
-				if (!idxRow.attname) continue;
+				if (!idxRow.attname) {
+					indexNamesWithExpressionKey.add(idxRow.indexname);
+					continue;
+				}
 				const existing = indexesMap.get(idxRow.indexname);
 				if (existing) existing.columns.push(idxRow.attname);
 				else {
@@ -1175,12 +1230,20 @@ var PostgresControlAdapter = class {
 					});
 				}
 			}
-			const indexes = Array.from(indexesMap.values()).map((idx) => ({
+			const survivingIndexes = Array.from(indexesMap.values()).filter((idx) => !indexNamesWithExpressionKey.has(idx.name));
+			const bestByColumnTuple = /* @__PURE__ */ new Map();
+			for (const idx of survivingIndexes) {
+				const tupleKey = idx.columns.join(",");
+				const existing = bestByColumnTuple.get(tupleKey);
+				if (!existing || idx.unique && !existing.unique || idx.unique === existing.unique && idx.name < existing.name) bestByColumnTuple.set(tupleKey, idx);
+			}
+			const indexes = Array.from(bestByColumnTuple.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 }
+				...idx.options !== void 0 && { options: idx.options },
+				dependsOn: postgresColumnDependsOn(schema, tableName, idx.columns)
 			}));
 			const checksForTable = [];
 			for (const checkRow of checksByTable.get(tableName) ?? []) {
@@ -1191,7 +1254,7 @@ var PostgresControlAdapter = class {
 					permittedValues: parsed.permittedValues
 				});
 			}
-			tables[tableName] = {
+			tableInputs[tableName] = {
 				name: tableName,
 				columns,
 				...ifDefined("primaryKey", primaryKey),
@@ -1201,19 +1264,64 @@ var PostgresControlAdapter = class {
 				...ifDefined("checks", checksForTable.length > 0 ? checksForTable : void 0)
 			};
 		}
-		const nativeEnumTypeNames = (await driver.query(`SELECT t.typname
+		const enums = (await driver.query(`SELECT t.typname, array_agg(e.enumlabel ORDER BY e.enumsortorder) AS enumvalues
          FROM pg_catalog.pg_type t
          JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+         JOIN pg_catalog.pg_enum e ON e.enumtypid = t.oid
          WHERE t.typtype = 'e'
            AND n.nspname = $1
-         ORDER BY t.typname`, [schema])).rows.map((r) => r.typname);
+         GROUP BY t.typname
+         ORDER BY t.typname`, [schema])).rows.map((r) => new PostgresNativeEnumSchemaNode({
+			typeName: r.typname,
+			namespaceId: schema,
+			members: parsePgNameArray(r.enumvalues)
+		}));
+		const policiesResult = await driver.query(`SELECT schemaname, tablename, policyname, cmd, roles, qual, with_check, permissive
+       FROM pg_catalog.pg_policies
+       WHERE schemaname = $1
+       ORDER BY tablename, policyname`, [schema]);
+		const policiesByTable = /* @__PURE__ */ new Map();
+		for (const row of policiesResult.rows) {
+			const operation = mapPgCmd(row.cmd);
+			const policyRoles = [...new Set(parsePgNameArray(row.roles).map((r) => r.toLowerCase()))].sort();
+			const permissive = row.permissive.toUpperCase() === "PERMISSIVE";
+			const prefix = parseRlsPolicyWireName(row.policyname)?.prefix ?? row.policyname;
+			const policy = new PostgresPolicySchemaNode({
+				name: row.policyname,
+				prefix,
+				tableName: row.tablename,
+				namespaceId: row.schemaname,
+				operation,
+				roles: policyRoles,
+				...row.qual !== null ? { using: row.qual } : {},
+				...row.with_check !== null ? { withCheck: row.with_check } : {},
+				permissive,
+				dependsOn: [postgresTableDependsOn(row.schemaname, row.tablename), ...policyRoles.map(postgresRoleDependsOn)]
+			});
+			const list = policiesByTable.get(row.tablename) ?? [];
+			list.push(policy);
+			policiesByTable.set(row.tablename, list);
+		}
+		const rlsEnabledResult = await driver.query(`SELECT c.relname AS tablename, c.relrowsecurity AS rls_enabled
+         FROM pg_catalog.pg_class c
+         JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+         WHERE n.nspname = $1
+           AND c.relkind IN ('r', 'p')
+         ORDER BY c.relname`, [schema]);
+		const rlsEnabledByTable = new Map(rlsEnabledResult.rows.map((row) => [row.tablename, row.rls_enabled]));
+		const tables = {};
+		for (const [tableName, input] of Object.entries(tableInputs)) tables[tableName] = new PostgresTableSchemaNode({
+			...input,
+			policies: policiesByTable.get(tableName) ?? [],
+			rlsEnabled: rlsEnabledByTable.get(tableName) ?? false
+		});
 		return {
-			tables,
-			annotations: { pg: {
-				schema,
-				version: await this.getPostgresVersion(driver),
-				...nativeEnumTypeNames.length > 0 && { nativeEnumTypeNames }
-			} }
+			namespace: new PostgresNamespaceSchemaNode({
+				schemaName: schema,
+				tables,
+				nativeEnums: enums
+			}),
+			pgVersion: await this.getPostgresVersion(driver)
 		};
 	}
 	/**
@@ -1224,6 +1332,86 @@ var PostgresControlAdapter = class {
 	}
 };
 /**
+* Normalises a `name[]` column value from `pg_policies.roles`.
+*
+* The `pg` client's type-parser registry handles `text[]` (OID 1009) but not
+* `name[]` (OID 1003). When the parser is absent the raw Postgres text-array
+* literal (`{role1,role2}`) is returned as a string instead of a JS array.
+* This function accepts either form and returns a plain string array.
+*
+* The string branch honors Postgres array-literal quoting: an element
+* containing a comma, quote, backslash, brace, or significant whitespace is
+* emitted double-quoted with `\"` / `\\` escapes, and unquoted elements are
+* whitespace-trimmed — so a label like `in progress` or `say "hi"` parses to
+* its true value instead of being split or kept escaped.
+*/
+function parsePgNameArray(value) {
+	if (Array.isArray(value)) return value.map(String);
+	if (typeof value !== "string") return [];
+	const trimmed = value.trim();
+	if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return [];
+	const inner = trimmed.slice(1, -1);
+	if (inner === "") return [];
+	const elements = [];
+	let current = "";
+	let inQuotes = false;
+	let wasQuoted = false;
+	const pushCurrent = () => {
+		elements.push(wasQuoted ? current : current.trim());
+		current = "";
+		wasQuoted = false;
+	};
+	let i = 0;
+	while (i < inner.length) {
+		const char = inner.charAt(i);
+		if (inQuotes) {
+			if (char === "\\") {
+				current += inner[i + 1] ?? "";
+				i += 2;
+				continue;
+			}
+			if (char === "\"") {
+				inQuotes = false;
+				i++;
+				continue;
+			}
+			current += char;
+			i++;
+			continue;
+		}
+		if (char === "\"") {
+			inQuotes = true;
+			wasQuoted = true;
+			i++;
+			continue;
+		}
+		if (char === ",") {
+			pushCurrent();
+			i++;
+			continue;
+		}
+		current += char;
+		i++;
+	}
+	if (inQuotes) return [];
+	pushCurrent();
+	return elements;
+}
+/**
+* Maps `pg_policies.cmd` text values to the `RlsPolicyOperation` union.
+* The `pg_policies` view renders the internal command code as an uppercase
+* English keyword; this function lowercases to match the IR type.
+*/
+function mapPgCmd(cmd) {
+	switch (cmd.toUpperCase()) {
+		case "SELECT": return "select";
+		case "INSERT": return "insert";
+		case "UPDATE": return "update";
+		case "DELETE": return "delete";
+		default: return "all";
+	}
+}
+/**
 * 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
@@ -1238,6 +1426,7 @@ function extractContractNamespaceIds(contract) {
 	return Object.keys(namespaces);
 }
 function normalizeFormattedType(formattedType, dataType, udtName) {
+	if (formattedType.endsWith("[]")) return `${normalizeFormattedType(formattedType.slice(0, -2), dataType, udtName)}[]`;
 	if (formattedType === "integer") return "int4";
 	if (formattedType === "smallint") return "int2";
 	if (formattedType === "bigint") return "int8";
@@ -1273,6 +1462,49 @@ function mapReferentialAction(rule) {
 	return mapped;
 }
 /**
+* A FK/policy dependency chain, mirroring the shape the expected-side
+* derivation stamps (`contractToPostgresDatabaseSchemaNode`): the database
+* root's fixed sentinel id, then the namespace, then the table.
+*/
+function postgresTableDependsOn(namespaceId, tableName) {
+	return [
+		{
+			nodeKind: PostgresSchemaNodeKind.database,
+			id: "database"
+		},
+		{
+			nodeKind: PostgresSchemaNodeKind.namespace,
+			id: namespaceId
+		},
+		{
+			nodeKind: PostgresSchemaNodeKind.table,
+			id: tableName
+		}
+	];
+}
+/** A policy's dependency chain onto one of the roles it grants to. */
+function postgresRoleDependsOn(role) {
+	return [{
+		nodeKind: PostgresSchemaNodeKind.database,
+		id: "database"
+	}, {
+		nodeKind: PostgresSchemaNodeKind.role,
+		id: role
+	}];
+}
+/**
+* The chains from a table-child object (foreign key, index, unique, primary
+* key) to each of the own columns it is built on — the introspection-side
+* mirror of `contractToPostgresDatabaseSchemaNode`'s `columnDependsOn`. An
+* object is dropped before the columns it covers.
+*/
+function postgresColumnDependsOn(namespaceId, tableName, columns) {
+	return columns.map((column) => [...postgresTableDependsOn(namespaceId, tableName), {
+		nodeKind: RelationalSchemaNodeKind.column,
+		id: `column:${column}`
+	}]);
+}
+/**
 * Groups an array of objects by a specified key.
 * Returns a Map for O(1) lookup by group key.
 */
@@ -1383,6 +1615,16 @@ function extractQuotedLiterals(listBody) {
 function pgIsTextLikeNativeType(nativeType) {
 	return nativeType === "text" || nativeType === "varchar" || nativeType.startsWith("varchar(") || nativeType === "character varying" || nativeType.startsWith("character varying(") || nativeType === "char" || nativeType.startsWith("char(") || nativeType === "character" || nativeType.startsWith("character(");
 }
+function pgRenderArrayElement(el) {
+	if (el === null) return "NULL";
+	if (typeof el === "number" || typeof el === "boolean") return String(el);
+	if (typeof el === "string") return `'${escapeLiteral(el)}'`;
+	return `'${escapeLiteral(JSON.stringify(el))}'`;
+}
+function pgRenderArrayLiteral(elements) {
+	if (elements.length === 0) return "'{}'";
+	return `ARRAY[${elements.map(pgRenderArrayElement).join(", ")}]`;
+}
 function pgInlineLiteral(wire, nativeType) {
 	if (wire === null) return "NULL";
 	if (typeof wire === "boolean") return wire ? "true" : "false";
@@ -1401,6 +1643,7 @@ function pgInlineLiteral(wire, nativeType) {
 		return pgIsTextLikeNativeType(nativeType) ? quoted : `${quoted}::${nativeType}`;
 	}
 	if (wire instanceof Uint8Array) return `'\\x${Array.from(wire).map((b) => b.toString(16).padStart(2, "0")).join("")}'::${nativeType}`;
+	if (Array.isArray(wire) && nativeType.endsWith("[]")) return pgRenderArrayLiteral(wire);
 	if (typeof wire === "object") return `${`'${escapeLiteral(JSON.stringify(wire))}'`}::${nativeType}`;
 	throw new Error(`pgRenderDdlExecuteRequest: unexpected wire type "${typeof wire}" for native type "${nativeType}"`);
 }
@@ -1438,6 +1681,7 @@ function pgRenderDdlConstraint(constraint) {
 		if (constraint.name !== void 0) sql = `CONSTRAINT ${quoteIdentifier(constraint.name)} ${sql}`;
 		return sql;
 	}
+	if (constraint.kind === "check-expression") return `CONSTRAINT ${quoteIdentifier(constraint.name)} CHECK (${constraint.expression})`;
 	const cols = constraint.columns.map(quoteIdentifier).join(", ");
 	if (constraint.name !== void 0) return `CONSTRAINT ${quoteIdentifier(constraint.name)} UNIQUE (${cols})`;
 	return `UNIQUE (${cols})`;
@@ -1458,24 +1702,87 @@ function pgRenderCreateSchema(node) {
 		params: []
 	};
 }
+function pgRenderCreateType(node) {
+	return {
+		sql: `CREATE TYPE ${node.schema ? `${quoteIdentifier(node.schema)}.${quoteIdentifier(node.name)}` : quoteIdentifier(node.name)} AS ENUM (${node.values.map((value) => `'${escapeLiteral(value)}'`).join(", ")})`,
+		params: []
+	};
+}
+function pgRenderDropType(node) {
+	return {
+		sql: `DROP TYPE ${node.schema ? `${quoteIdentifier(node.schema)}.${quoteIdentifier(node.name)}` : quoteIdentifier(node.name)}`,
+		params: []
+	};
+}
 async function pgRenderAlterTable(node, codecLookup) {
 	const tableRef = node.schema ? `${quoteIdentifier(node.schema)}.${quoteIdentifier(node.table)}` : quoteIdentifier(node.table);
-	const actionVisitor = { async addColumn(action) {
-		return `ADD COLUMN ${await pgRenderDdlColumn(action.column, codecLookup)}`;
-	} };
+	const actionVisitor = {
+		async addColumn(action) {
+			return `ADD COLUMN ${await pgRenderDdlColumn(action.column, codecLookup)}`;
+		},
+		dropDefault(action) {
+			return Promise.resolve(`ALTER COLUMN ${quoteIdentifier(action.columnName)} DROP DEFAULT`);
+		}
+	};
 	return {
 		sql: `ALTER TABLE ${tableRef} ${(await Promise.all(node.actions.map((a) => a.accept(actionVisitor)))).join(", ")}`,
 		params: []
 	};
 }
+const POLICY_OPERATION_SQL = {
+	select: "SELECT",
+	insert: "INSERT",
+	update: "UPDATE",
+	delete: "DELETE",
+	all: "ALL"
+};
+function pgRenderCreatePolicy(node) {
+	const tableRef = `${quoteIdentifier(node.schema)}.${quoteIdentifier(node.table)}`;
+	const permissiveness = node.permissive ? "PERMISSIVE" : "RESTRICTIVE";
+	const command = POLICY_OPERATION_SQL[node.operation];
+	const roles = node.roles.length === 0 ? "PUBLIC" : node.roles.join(", ");
+	let sql = `CREATE POLICY ${quoteIdentifier(node.name)} ON ${tableRef} AS ${permissiveness} FOR ${command} TO ${roles}`;
+	if (node.using !== void 0) sql += ` USING (${node.using})`;
+	if (node.withCheck !== void 0) sql += ` WITH CHECK (${node.withCheck})`;
+	return {
+		sql,
+		params: []
+	};
+}
+function pgRenderDropPolicy(node) {
+	const tableRef = `${quoteIdentifier(node.schema)}.${quoteIdentifier(node.table)}`;
+	return {
+		sql: `DROP POLICY ${quoteIdentifier(node.name)} ON ${tableRef}`,
+		params: []
+	};
+}
+function pgRenderAlterPolicyRename(node) {
+	const tableRef = `${quoteIdentifier(node.schema)}.${quoteIdentifier(node.table)}`;
+	return {
+		sql: `ALTER POLICY ${quoteIdentifier(node.name)} ON ${tableRef} RENAME TO ${quoteIdentifier(node.newName)}`,
+		params: []
+	};
+}
+function pgRenderDisableRowLevelSecurity(node) {
+	return {
+		sql: `ALTER TABLE ${`${quoteIdentifier(node.schema)}.${quoteIdentifier(node.table)}`} DISABLE ROW LEVEL SECURITY`,
+		params: []
+	};
+}
 async function pgRenderDdlExecuteRequest(ast, codecLookup) {
 	return ast.accept({
 		createTable: (node) => pgRenderCreateTable(node, codecLookup),
 		createSchema: (node) => Promise.resolve(pgRenderCreateSchema(node)),
-		alterTable: (node) => pgRenderAlterTable(node, codecLookup)
+		createType: (node) => Promise.resolve(pgRenderCreateType(node)),
+		dropType: (node) => Promise.resolve(pgRenderDropType(node)),
+		alterTable: (node) => pgRenderAlterTable(node, codecLookup),
+		createPolicy: (node) => Promise.resolve(pgRenderCreatePolicy(node)),
+		dropPolicy: (node) => Promise.resolve(pgRenderDropPolicy(node)),
+		alterPolicyRename: (node) => Promise.resolve(pgRenderAlterPolicyRename(node)),
+		disableRowLevelSecurity: (node) => Promise.resolve(pgRenderDisableRowLevelSecurity(node))
 	});
 }
 //#endregion
 export { renderLoweredSql as n, createPostgresBuiltinCodecLookup as r, PostgresControlAdapter as t };
 
-//# sourceMappingURL=control-adapter-Dspz5uKp.mjs.map
+//# sourceMappingURL=control-adapter-aFfSI2bK.mjs.map