@prisma-next/adapter-postgres 0.14.0-dev.9 → 0.14.0-dev.90

package/dist/{adapter-CwkcdpM_.mjs → adapter-CssyjkaR.mjs}

@@ -1,4 +1,4 @@
-import { n as renderLoweredSql, r as createPostgresBuiltinCodecLookup, t as PostgresControlAdapter } from "./control-adapter-Dspz5uKp.mjs";
+import { n as renderLoweredSql, r as createPostgresBuiltinCodecLookup, t as PostgresControlAdapter } from "./control-adapter-w2BFxQ--.mjs";
 import { APP_SPACE_ID } from "@prisma-next/framework-components/control";
 import { isDdlNode } from "@prisma-next/sql-relational-core/ast";
 //#region src/core/adapter.ts
@@ -15,7 +15,8 @@ const defaultCapabilities = Object.freeze({
 		enums: true,
 		returning: true,
 		defaultInInsert: true,
-		lateral: true
+		lateral: true,
+		scalarList: true
 	}
 });
 var PostgresAdapterImpl = class {
@@ -62,4 +63,4 @@ function createPostgresAdapter(options) {
 //#endregion
 export { postgresRawCodecInferer as n, createPostgresAdapter as t };
 
-//# sourceMappingURL=adapter-CwkcdpM_.mjs.map
+//# sourceMappingURL=adapter-CssyjkaR.mjs.map

package/dist/adapter-CssyjkaR.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-CssyjkaR.mjs","names":[],"sources":["../src/core/adapter.ts"],"sourcesContent":["import type { CodecRegistry } from '@prisma-next/framework-components/codec';\nimport { APP_SPACE_ID } from '@prisma-next/framework-components/control';\nimport type {\n  Adapter,\n  AdapterProfile,\n  AnyQueryAst,\n  LowererContext,\n  RawSqlLiteral,\n  SqlQueryable,\n} from '@prisma-next/sql-relational-core/ast';\nimport { isDdlNode } from '@prisma-next/sql-relational-core/ast';\nimport type { RawCodecInferer } from '@prisma-next/sql-relational-core/expression';\nimport type { PostgresDdlNode } from '@prisma-next/target-postgres/ddl';\nimport { createPostgresBuiltinCodecLookup } from './codec-lookup';\nimport { PostgresControlAdapter } from './control-adapter';\nimport { renderLoweredSql } from './sql-renderer';\nimport type { PostgresAdapterOptions, PostgresContract, PostgresLoweredStatement } from './types';\n\nconst defaultCapabilities = Object.freeze({\n  postgres: {\n    orderBy: true,\n    limit: true,\n    lateral: true,\n    jsonAgg: true,\n    returning: true,\n    distinctOn: true,\n  },\n  sql: {\n    enums: true,\n    returning: true,\n    defaultInInsert: true,\n    lateral: true,\n    scalarList: true,\n  },\n});\n\nclass PostgresAdapterImpl\n  implements Adapter<AnyQueryAst, PostgresContract, PostgresLoweredStatement>\n{\n  // These fields make the adapter instance structurally compatible with RuntimeAdapterInstance<'sql', 'postgres'> without introducing a runtime-plane dependency.\n  readonly familyId = 'sql' as const;\n  readonly targetId = 'postgres' as const;\n\n  readonly profile: AdapterProfile<'postgres'>;\n  private readonly codecLookup: CodecRegistry;\n\n  constructor(options?: PostgresAdapterOptions) {\n    this.codecLookup = options?.codecLookup ?? createPostgresBuiltinCodecLookup();\n    const controlAdapter = new PostgresControlAdapter(this.codecLookup);\n    this.profile = Object.freeze({\n      id: options?.profileId ?? 'postgres/default@1',\n      target: 'postgres',\n      capabilities: defaultCapabilities,\n      readMarker: (queryable: SqlQueryable) =>\n        controlAdapter.readMarkerDiscriminated(\n          {\n            familyId: 'sql',\n            targetId: 'postgres',\n            query: async <Row = Record<string, unknown>>(\n              sql: string,\n              params?: readonly unknown[],\n            ) => {\n              const result = await queryable.query<Row>(sql, params);\n              return { rows: [...result.rows] };\n            },\n            close: async () => {},\n          },\n          APP_SPACE_ID,\n        ),\n    });\n  }\n\n  lower(\n    ast: AnyQueryAst | PostgresDdlNode,\n    context: LowererContext<PostgresContract>,\n  ): PostgresLoweredStatement {\n    if (isDdlNode(ast)) {\n      throw new Error(\n        'lower() does not lower DDL on the runtime adapter — DDL lowering is a control-plane concern handled by the control adapter.',\n      );\n    }\n    return renderLoweredSql(ast, context.contract, this.codecLookup);\n  }\n}\n\n/** Codec-id lookup for bare-literal interpolations used by `fns.raw` on a postgres client. Contributed as the descriptor's static `rawCodecInferer` slot. */\nexport const postgresRawCodecInferer: RawCodecInferer = {\n  inferCodec(value: RawSqlLiteral): string {\n    switch (typeof value) {\n      case 'number':\n        return Number.isSafeInteger(value) && value % 1 === 0 ? 'pg/int4' : 'pg/float8';\n      case 'bigint':\n        return 'pg/int8';\n      case 'string':\n        return 'pg/text';\n      case 'boolean':\n        return 'pg/bool';\n      case 'object':\n        if (value instanceof Uint8Array) return 'pg/bytea';\n    }\n    throw new Error(\n      'unsupported JS value type for raw-SQL interpolation: wrap this value in `param(...)` with an explicit codec',\n    );\n  },\n};\n\nexport function createPostgresAdapter(options?: PostgresAdapterOptions) {\n  return Object.freeze(new PostgresAdapterImpl(options));\n}\n"],"mappings":";;;;AAkBA,MAAM,sBAAsB,OAAO,OAAO;CACxC,UAAU;EACR,SAAS;EACT,OAAO;EACP,SAAS;EACT,SAAS;EACT,WAAW;EACX,YAAY;CACd;CACA,KAAK;EACH,OAAO;EACP,WAAW;EACX,iBAAiB;EACjB,SAAS;EACT,YAAY;CACd;AACF,CAAC;AAED,IAAM,sBAAN,MAEA;CAEE,WAAoB;CACpB,WAAoB;CAEpB;CACA;CAEA,YAAY,SAAkC;EAC5C,KAAK,cAAc,SAAS,eAAe,iCAAiC;EAC5E,MAAM,iBAAiB,IAAI,uBAAuB,KAAK,WAAW;EAClE,KAAK,UAAU,OAAO,OAAO;GAC3B,IAAI,SAAS,aAAa;GAC1B,QAAQ;GACR,cAAc;GACd,aAAa,cACX,eAAe,wBACb;IACE,UAAU;IACV,UAAU;IACV,OAAO,OACL,KACA,WACG;KAEH,OAAO,EAAE,MAAM,CAAC,IAAG,MADE,UAAU,MAAW,KAAK,MAAM,EAAA,CAC3B,IAAI,EAAE;IAClC;IACA,OAAO,YAAY,CAAC;GACtB,GACA,YACF;EACJ,CAAC;CACH;CAEA,MACE,KACA,SAC0B;EAC1B,IAAI,UAAU,GAAG,GACf,MAAM,IAAI,MACR,6HACF;EAEF,OAAO,iBAAiB,KAAK,QAAQ,UAAU,KAAK,WAAW;CACjE;AACF;;AAGA,MAAa,0BAA2C,EACtD,WAAW,OAA8B;CACvC,QAAQ,OAAO,OAAf;EACE,KAAK,UACH,OAAO,OAAO,cAAc,KAAK,KAAK,QAAQ,MAAM,IAAI,YAAY;EACtE,KAAK,UACH,OAAO;EACT,KAAK,UACH,OAAO;EACT,KAAK,WACH,OAAO;EACT,KAAK,UACH,IAAI,iBAAiB,YAAY,OAAO;CAC5C;CACA,MAAM,IAAI,MACR,6GACF;AACF,EACF;AAEA,SAAgB,sBAAsB,SAAkC;CACtE,OAAO,OAAO,OAAO,IAAI,oBAAoB,OAAO,CAAC;AACvD"}

package/dist/adapter.d.mts

@@ -1,4 +1,4 @@
-import { c as PostgresContract, l as PostgresLoweredStatement, s as PostgresAdapterOptions } from "./types-KXRwRZU8.mjs";
+import { c as PostgresContract, l as PostgresLoweredStatement, s as PostgresAdapterOptions } from "./types-DkGeLfUp.mjs";
 import { Adapter, AdapterProfile, AnyQueryAst, LowererContext } from "@prisma-next/sql-relational-core/ast";
 import { RawCodecInferer } from "@prisma-next/sql-relational-core/expression";
 import { PostgresDdlNode } from "@prisma-next/target-postgres/ddl";

package/dist/adapter.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.mts","names":[],"sources":["../src/core/adapter.ts"],"mappings":";;;;;;cAmCM,mBAAA,YACO,OAAA,CAAQ,WAAA,EAAa,gBAAA,EAAkB,wBAAA;EAAA,SAGzC,QAAA;EAAA,SACA,QAAA;EAAA,SAEA,OAAA,EAAS,cAAA;EAAA,iBACD,WAAA;cAEL,OAAA,GAAU,sBAAA;EA0BtB,KAAA,CACE,GAAA,EAAK,WAAA,GAAc,eAAA,EACnB,OAAA,EAAS,cAAA,CAAe,gBAAA,IACvB,wBAAA;AAAA;;cAWQ,uBAAA,EAAyB,eAkBrC;AAAA,iBAEe,qBAAA,CAAsB,OAAA,GAAU,sBAAA,GAAsB,QAAA,CAAA,mBAAA"}
+{"version":3,"file":"adapter.d.mts","names":[],"sources":["../src/core/adapter.ts"],"mappings":";;;;;;cAoCM,mBAAA,YACO,OAAA,CAAQ,WAAA,EAAa,gBAAA,EAAkB,wBAAA;EAAA,SAGzC,QAAA;EAAA,SACA,QAAA;EAAA,SAEA,OAAA,EAAS,cAAA;EAAA,iBACD,WAAA;cAEL,OAAA,GAAU,sBAAA;EA0BtB,KAAA,CACE,GAAA,EAAK,WAAA,GAAc,eAAA,EACnB,OAAA,EAAS,cAAA,CAAe,gBAAA,IACvB,wBAAA;AAAA;;cAWQ,uBAAA,EAAyB,eAkBrC;AAAA,iBAEe,qBAAA,CAAsB,OAAA,GAAU,sBAAA,GAAsB,QAAA,CAAA,mBAAA"}

package/dist/adapter.mjs

@@ -1,2 +1,2 @@
-import { n as postgresRawCodecInferer, t as createPostgresAdapter } from "./adapter-CwkcdpM_.mjs";
+import { n as postgresRawCodecInferer, t as createPostgresAdapter } from "./adapter-CssyjkaR.mjs";
 export { createPostgresAdapter, postgresRawCodecInferer };

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

@@ -8,7 +8,9 @@ import { REFERENTIAL_ACTION_SQL } from "@prisma-next/sql-contract/referential-ac
 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, 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 +78,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 +123,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 +139,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 +159,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 +517,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 +844,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 +916,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 +962,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) {
@@ -1091,7 +1122,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,11 +1136,18 @@ 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) ?? []];
@@ -1159,8 +1197,12 @@ var PostgresControlAdapter = class {
 				name: uq.name
 			}));
 			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,7 +1217,14 @@ 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,
@@ -1191,7 +1240,7 @@ var PostgresControlAdapter = class {
 					permittedValues: parsed.permittedValues
 				});
 			}
-			tables[tableName] = {
+			tableInputs[tableName] = {
 				name: tableName,
 				columns,
 				...ifDefined("primaryKey", primaryKey),
@@ -1201,19 +1250,63 @@ 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
+			});
+			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 +1317,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 +1411,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";
@@ -1383,6 +1557,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 +1585,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 +1623,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 +1644,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-w2BFxQ--.mjs.map