@prisma-next/adapter-postgres 0.13.0-dev.2 → 0.13.0-dev.21

package/dist/{adapter-CAlWA4ug.mjs → adapter-CoRrSTXZ.mjs}

@@ -1,4 +1,4 @@
-import { i as createPostgresBuiltinCodecLookup, n as renderLoweredSql, r as renderLoweredDdl, t as PostgresControlAdapter } from "./control-adapter-ZWrjGBq7.mjs";
+import { n as renderLoweredSql, r as createPostgresBuiltinCodecLookup, t as PostgresControlAdapter } from "./control-adapter-BeSqyOGl.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
@@ -41,7 +41,7 @@ var PostgresAdapterImpl = class {
 		});
 	}
 	lower(ast, context) {
-		if (isDdlNode(ast)) return renderLoweredDdl(ast);
+		if (isDdlNode(ast)) throw new Error("lower() does not lower DDL on the runtime adapter — DDL lowering is a control-plane concern handled by the control adapter.");
 		return renderLoweredSql(ast, context.contract, this.codecLookup);
 	}
 };
@@ -62,4 +62,4 @@ function createPostgresAdapter(options) {
 //#endregion
 export { postgresRawCodecInferer as n, createPostgresAdapter as t };
 
-//# sourceMappingURL=adapter-CAlWA4ug.mjs.map
+//# sourceMappingURL=adapter-CoRrSTXZ.mjs.map

package/dist/adapter-CoRrSTXZ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-CoRrSTXZ.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  },\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;CACX;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-Dv7M8jx8.mjs";
+import { c as PostgresContract, l as PostgresLoweredStatement, s as PostgresAdapterOptions } from "./types-KXRwRZU8.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":";;;;;;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;;cASQ,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":";;;;;;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"}

package/dist/adapter.mjs

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

package/dist/{control-adapter-ZWrjGBq7.mjs → control-adapter-BeSqyOGl.mjs}

@@ -4,24 +4,24 @@ import { postgresCodecRegistry } from "@prisma-next/target-postgres/codecs";
 import { parseMarkerRowSafely, rethrowMarkerReadError, 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 { REFERENTIAL_ACTION_SQL } from "@prisma-next/sql-contract/referential-action-sql";
 import { PostgresTableSource, 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 { createResolveExistingEnumValues, enumStorageCompoundKey, readExistingEnumValues, readPostgresSchemaIrAnnotations } from "@prisma-next/target-postgres/enum-planning";
+import { createResolveExistingEnumValues, readExistingEnumValues, readPostgresSchemaIrAnnotations } from "@prisma-next/target-postgres/enum-planning";
 import { normalizeSchemaNativeType } from "@prisma-next/target-postgres/native-type-normalizer";
+import { escapeLiteral, quoteIdentifier } from "@prisma-next/target-postgres/sql-utils";
 import { blindCast } from "@prisma-next/utils/casts";
 import { ifDefined } from "@prisma-next/utils/defined";
-import { REFERENTIAL_ACTION_SQL } from "@prisma-next/sql-contract/referential-action-sql";
-import { escapeLiteral, quoteIdentifier } from "@prisma-next/target-postgres/sql-utils";
-import { PG_ENUM_CODEC_ID, PG_TIMESTAMPTZ_CODEC_ID } from "@prisma-next/target-postgres/codec-ids";
 import { createAstCodecRegistry, deriveParamMetadata, encodeParamsWithMetadata } from "@prisma-next/sql-runtime";
+import { PG_ENUM_CODEC_ID, PG_TIMESTAMPTZ_CODEC_ID } from "@prisma-next/target-postgres/codec-ids";
 import { runtimeError } from "@prisma-next/framework-components/runtime";
 //#region src/core/codec-lookup.ts
 /**
-* Build a {@link CodecLookup} populated with the Postgres-builtin codec definitions only.
+* Build a {@link CodecRegistry} populated with the Postgres-builtin codec definitions only.
 *
-* This is the default lookup used by `createPostgresAdapter()` and `new PostgresControlAdapter()` when called without a stack-derived lookup (e.g. from tests, or one-off scripts that don't compose a full stack).
+* This is the default registry used by `createPostgresAdapter()` and `new PostgresControlAdapter()` when called without a stack-derived registry (e.g. from tests, or one-off scripts that don't compose a full stack).
 *
-* Extension codecs (e.g. `pg/vector@1` from `@prisma-next/extension-pgvector`) are intentionally NOT included here: a bare adapter cannot see extensions. Stack-composed paths (`SqlControlAdapterDescriptor.create(stack)` / `SqlRuntimeAdapterDescriptor.create(stack)`) supply the broader, extension-inclusive lookup at construction time.
+* Extension codecs (e.g. `pg/vector@1` from `@prisma-next/extension-pgvector`) are intentionally NOT included here: a bare adapter cannot see extensions. Stack-composed paths (`SqlControlAdapterDescriptor.create(stack)` / `SqlRuntimeAdapterDescriptor.create(stack)`) supply the broader, extension-inclusive registry at construction time.
 */
 function createPostgresBuiltinCodecLookup() {
 	return extractCodecLookup([{
@@ -36,78 +36,13 @@ function ledgerOriginFromStored(originCoreHash) {
 	return originCoreHash;
 }
 //#endregion
-//#region src/core/ddl-renderer.ts
-function quoteQualifiedIdentifier(name) {
-	return name.split(".").map(quoteIdentifier).join(".");
-}
-function renderPrimaryKeyConstraint(constraint) {
-	const cols = constraint.columns.map(quoteIdentifier).join(", ");
-	if (constraint.name !== void 0) return `CONSTRAINT ${quoteIdentifier(constraint.name)} PRIMARY KEY (${cols})`;
-	return `PRIMARY KEY (${cols})`;
-}
-function renderForeignKeyConstraint(constraint) {
-	const cols = constraint.columns.map(quoteIdentifier).join(", ");
-	const refCols = constraint.refColumns.map(quoteIdentifier).join(", ");
-	let sql = `FOREIGN KEY (${cols}) REFERENCES ${quoteQualifiedIdentifier(constraint.refTable)} (${refCols})`;
-	if (constraint.onDelete !== void 0) sql += ` ON DELETE ${REFERENTIAL_ACTION_SQL[constraint.onDelete]}`;
-	if (constraint.onUpdate !== void 0) sql += ` ON UPDATE ${REFERENTIAL_ACTION_SQL[constraint.onUpdate]}`;
-	if (constraint.name !== void 0) sql = `CONSTRAINT ${quoteIdentifier(constraint.name)} ${sql}`;
-	return sql;
-}
-function renderUniqueConstraint(constraint) {
-	const cols = constraint.columns.map(quoteIdentifier).join(", ");
-	if (constraint.name !== void 0) return `CONSTRAINT ${quoteIdentifier(constraint.name)} UNIQUE (${cols})`;
-	return `UNIQUE (${cols})`;
-}
-function renderTableConstraint(constraint) {
-	switch (constraint.kind) {
-		case "primary-key": return renderPrimaryKeyConstraint(constraint);
-		case "foreign-key": return renderForeignKeyConstraint(constraint);
-		case "unique": return renderUniqueConstraint(constraint);
-	}
-}
-var PostgresDdlVisitorImpl = class {
-	createTable(node) {
-		const ifNotExists = node.ifNotExists ? "IF NOT EXISTS " : "";
-		const tableRef = node.schema ? `${quoteIdentifier(node.schema)}.${quoteIdentifier(node.table)}` : quoteIdentifier(node.table);
-		const columnDefs = node.columns.map((column) => renderColumn$1(column));
-		const constraintDefs = node.constraints !== void 0 ? node.constraints.map(renderTableConstraint) : [];
-		return `CREATE TABLE ${ifNotExists}${tableRef} (\n  ${[...columnDefs, ...constraintDefs].join(",\n  ")}\n)`;
-	}
-	createSchema(node) {
-		return `CREATE SCHEMA ${node.ifNotExists ? "IF NOT EXISTS " : ""}${quoteIdentifier(node.schema)}`;
-	}
-};
-function isTextLikeNativeType(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(");
-}
-const defaultVisitor = {
-	literal(node, ctx) {
-		const { value } = node;
-		if (typeof value === "number" || typeof value === "boolean") return `DEFAULT ${String(value)}`;
-		if (value === null) return "DEFAULT NULL";
-		const literal = `'${escapeLiteral(typeof value === "string" ? value : JSON.stringify(value))}'`;
-		return isTextLikeNativeType(ctx.nativeType) ? `DEFAULT ${literal}` : `DEFAULT ${literal}::${ctx.nativeType}`;
-	},
-	function(node, _ctx) {
-		if (node.expression === "autoincrement()") return "";
-		return `DEFAULT (${node.expression})`;
-	}
-};
-function renderColumn$1(column) {
-	const parts = [quoteIdentifier(column.name), column.type];
-	if (column.notNull) parts.push("NOT NULL");
-	if (column.primaryKey) parts.push("PRIMARY KEY");
-	const defaultClause = column.default ? column.default.accept(defaultVisitor, { nativeType: column.type }) : "";
-	if (defaultClause.length > 0) parts.push(defaultClause);
-	return parts.join(" ");
-}
-function renderLoweredDdl(ast) {
-	const sql = ast.accept(new PostgresDdlVisitorImpl());
-	return Object.freeze({
-		sql,
-		params: Object.freeze([])
-	});
+//#region src/core/control-codecs.ts
+const CONTROL_CODECS = createAstCodecRegistry(postgresCodecRegistry);
+async function encodeControlQueryParams(lowered, ast, codecs = CONTROL_CODECS) {
+	return encodeParamsWithMetadata(lowered.params.map((slot) => {
+		if (slot.kind === "literal") return slot.value;
+		throw new Error(`control query lowered to a bind slot '${slot.name}', which is unsupported`);
+	}), deriveParamMetadata(ast), {}, codecs);
 }
 //#endregion
 //#region src/core/enum-control-hooks.ts
@@ -202,7 +137,6 @@ async function introspectPostgresEnumTypes(options) {
 }
 //#endregion
 //#region src/core/marker-ledger.ts
-const CONTROL_CODECS = createAstCodecRegistry(postgresCodecRegistry);
 const marker = pgTable({
 	name: "marker",
 	schema: "prisma_contract"
@@ -269,10 +203,7 @@ function mergeInvariants(current, incoming) {
 }
 async function execute(lower, driver, query) {
 	const lowered = lower(query);
-	const encoded = await encodeParamsWithMetadata(lowered.params.map((slot) => {
-		if (slot.kind === "literal") return slot.value;
-		throw new Error("Postgres control DML lowered to a bind parameter, which is unsupported");
-	}), deriveParamMetadata(query), {}, CONTROL_CODECS);
+	const encoded = await encodeControlQueryParams(lowered, query);
 	return (await driver.query(lowered.sql, encoded)).rows;
 }
 //#endregion
@@ -372,20 +303,89 @@ function renderLimitOffset(keyword, value, contract, pim) {
 	return `${keyword} ${renderExpr(value, contract, pim)}`;
 }
 function renderSelect(ast, contract, pim) {
+	const selectClause = `SELECT ${renderDistinctPrefix(ast.distinct, ast.distinctOn, contract, pim)}${renderProjection(ast.projection, contract, pim)}`;
+	const fromClause = `FROM ${renderSource(ast.from, contract, pim)}`;
+	const joinsClause = ast.joins?.length ? ast.joins.map((join) => renderJoin(join, contract, pim)).join(" ") : "";
+	const whereClause = ast.where ? `WHERE ${renderWhere(ast.where, contract, pim)}` : "";
+	const groupByClause = ast.groupBy?.length ? `GROUP BY ${ast.groupBy.map((expr) => renderExpr(expr, contract, pim)).join(", ")}` : "";
+	const havingClause = ast.having ? `HAVING ${renderWhere(ast.having, contract, pim)}` : "";
+	const sourcesByRef = collectTableSources(ast);
 	return [
-		`SELECT ${renderDistinctPrefix(ast.distinct, ast.distinctOn, contract, pim)}${renderProjection(ast.projection, contract, pim)}`,
-		`FROM ${renderSource(ast.from, contract, pim)}`,
-		ast.joins?.length ? ast.joins.map((join) => renderJoin(join, contract, pim)).join(" ") : "",
-		ast.where ? `WHERE ${renderWhere(ast.where, contract, pim)}` : "",
-		ast.groupBy?.length ? `GROUP BY ${ast.groupBy.map((expr) => renderExpr(expr, contract, pim)).join(", ")}` : "",
-		ast.having ? `HAVING ${renderWhere(ast.having, contract, pim)}` : "",
+		selectClause,
+		fromClause,
+		joinsClause,
+		whereClause,
+		groupByClause,
+		havingClause,
 		ast.orderBy?.length ? `ORDER BY ${ast.orderBy.map((order) => {
-			return `${renderExpr(order.expr, contract, pim)} ${order.dir.toUpperCase()}`;
+			return `${renderOrderByExpr(order.expr, sourcesByRef, contract, pim)} ${order.dir.toUpperCase()}`;
 		}).join(", ")}` : "",
 		renderLimitOffset("LIMIT", ast.limit, contract, pim),
 		renderLimitOffset("OFFSET", ast.offset, contract, pim)
 	].filter((part) => part.length > 0).join(" ").trim();
 }
+/**
+* Map a SELECT's table references (the FROM source and any JOIN sources) to their storage coordinate, keyed by the name a `ColumnRef.table` would carry (the alias when present, otherwise the table name). Derived-table sources are skipped — their columns are projected through a sub-select, not a base storage column, so the enum hook does not apply.
+*/
+function collectTableSources(ast) {
+	const sources = /* @__PURE__ */ new Map();
+	const add = (source) => {
+		if (source.kind !== "table-source") return;
+		const ref = source.alias ?? source.name;
+		sources.set(ref, {
+			name: source.name,
+			namespaceId: source.namespaceId
+		});
+	};
+	add(ast.from);
+	for (const join of ast.joins ?? []) add(join.source);
+	return sources;
+}
+/**
+* Ordered, codec-encoded values of the value-set a storage column restricts to, or `undefined` when the referenced column carries no value-set (the common, non-enum case). Resolves the column's storage coordinate from the SELECT's table sources, then the column's `valueSet` ref to the value-set's `values`.
+*/
+function allStrings(values) {
+	return values.every((value) => typeof value === "string");
+}
+function resolveEnumOrderValues(ref, sourcesByRef, contract) {
+	const source = sourcesByRef.get(ref.table);
+	if (source === void 0 || source.namespaceId === void 0) return;
+	const valueSet = (contract.storage.namespaces[source.namespaceId]?.entries.table[source.name]?.columns[ref.column])?.valueSet;
+	if (valueSet === void 0) return;
+	return contract.storage.namespaces[valueSet.namespaceId]?.entries.valueSet?.[valueSet.entityName]?.values;
+}
+/**
+* Ordered values for an unqualified ORDER BY column (an `identifier-ref`, the shape the sql-builder emits for `.orderBy('col')`). Scans every FROM/JOIN source for a column of that name. Resolves only when exactly one source has a column of that name and it carries a value-set; if more than one source has such a column the bare identifier is ambiguous (regardless of which are enum-backed), so it falls through to the plain column rendering.
+*/
+function resolveEnumOrderValuesForIdentifier(name, sourcesByRef, contract) {
+	let matchedColumns = 0;
+	let resolved;
+	for (const source of sourcesByRef.values()) {
+		if (source.namespaceId === void 0) continue;
+		const column = contract.storage.namespaces[source.namespaceId]?.entries.table[source.name]?.columns[name];
+		if (column === void 0) continue;
+		matchedColumns += 1;
+		if (matchedColumns > 1) return;
+		const valueSet = column.valueSet;
+		if (valueSet === void 0) return;
+		resolved = contract.storage.namespaces[valueSet.namespaceId]?.entries.valueSet?.[valueSet.entityName]?.values;
+	}
+	return resolved;
+}
+/**
+* Render an ORDER BY expression. A column reference onto an enum-restricted column sorts by declaration order via `array_position(ARRAY[…]::text[], <col>)` over the value-set's ordered values (NULLs return `NULL` from `array_position`, sorting per the clause's default NULL handling). Both qualified `column-ref`s and the unqualified `identifier-ref`s the sql-builder emits for `.orderBy('col')` are intercepted. Every other expression renders unchanged.
+*/
+function renderOrderByExpr(expr, sourcesByRef, contract, pim) {
+	if (expr.kind === "column-ref") {
+		const orderValues = resolveEnumOrderValues(expr, sourcesByRef, contract);
+		if (orderValues !== void 0 && allStrings(orderValues)) return `array_position(ARRAY[${orderValues.map((value) => `'${escapeLiteral(value)}'`).join(", ")}]::text[], ${renderColumn(expr)})`;
+	}
+	if (expr.kind === "identifier-ref") {
+		const orderValues = resolveEnumOrderValuesForIdentifier(expr.name, sourcesByRef, contract);
+		if (orderValues !== void 0 && allStrings(orderValues)) return `array_position(ARRAY[${orderValues.map((value) => `'${escapeLiteral(value)}'`).join(", ")}]::text[], ${quoteIdentifier(expr.name)})`;
+	}
+	return renderExpr(expr, contract, pim);
+}
 function renderProjection(projection, contract, pim) {
 	return projection.map((item) => {
 		const alias = quoteIdentifier(item.alias);
@@ -732,16 +732,9 @@ const POSTGRES_LEDGER_TABLE = "prisma_contract.ledger";
 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();
+	codecRegistry;
+	constructor(codecRegistry) {
+		this.codecRegistry = codecRegistry;
 	}
 	/**
 	* Target-specific normalizer for raw Postgres default expressions.
@@ -779,8 +772,24 @@ var PostgresControlAdapter = class {
 	* without instantiating the runtime adapter.
 	*/
 	lower(ast, context) {
-		if (isDdlNode(ast)) return renderLoweredDdl(ast);
-		return renderLoweredSql(ast, context.contract, this.codecLookup);
+		if (isDdlNode(ast)) throw new Error("lower() cannot lower DDL: DDL default literals require inline codec encoding, which is async. Use lowerToExecuteRequest().");
+		return renderLoweredSql(ast, blindCast(context.contract), this.codecRegistry);
+	}
+	/**
+	* Lower an AST all the way to a driver-ready statement. For DDL nodes,
+	* literal column defaults are formatted as inline SQL with proper quoting and
+	* `::nativeType` cast suffixes. For query ASTs, params are kept as `$N`
+	* placeholders; wire values go in `params`. Does NOT call `this.lower()` —
+	* independent implementation.
+	*/
+	async lowerToExecuteRequest(ast, context) {
+		if (isDdlNode(ast)) return pgRenderDdlExecuteRequest(blindCast(ast), this.codecRegistry);
+		const lowered = renderLoweredSql(ast, blindCast(context?.contract), this.codecRegistry);
+		const params = await encodeControlQueryParams(lowered, ast, blindCast(this.codecRegistry));
+		return {
+			sql: lowered.sql,
+			params
+		};
 	}
 	/**
 	* Reads the contract marker from `prisma_contract.marker`. Probes
@@ -1020,12 +1029,15 @@ var PostgresControlAdapter = class {
 		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 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 mergedEnumTypes = {};
+		for (const ir of perSchema) {
+			const enumTypes = blindCast(ir?.annotations?.["pg"])?.enumTypes;
+			if (!enumTypes) continue;
+			for (const [schemaName, byType] of Object.entries(enumTypes)) {
+				const merged = mergedEnumTypes[schemaName] ?? {};
+				Object.assign(merged, byType);
+				mergedEnumTypes[schemaName] = merged;
+			}
 		}
 		const firstAnnotations = perSchema[0]?.annotations;
 		const firstPg = blindCast(firstAnnotations?.["pg"]) ?? {};
@@ -1035,7 +1047,7 @@ var PostgresControlAdapter = class {
 				...firstAnnotations,
 				pg: {
 					...firstPg,
-					...ifDefined("storageTypes", Object.keys(mergedStorageTypes).length > 0 ? mergedStorageTypes : void 0)
+					...ifDefined("enumTypes", Object.keys(mergedEnumTypes).length > 0 ? mergedEnumTypes : void 0)
 				}
 			})
 		};
@@ -1295,18 +1307,17 @@ var PostgresControlAdapter = class {
 				...ifDefined("checks", checksForTable.length > 0 ? checksForTable : void 0)
 			};
 		}
-		const rawStorageTypes = await introspectPostgresEnumTypes({
+		const rawEnumTypes = await introspectPostgresEnumTypes({
 			driver,
 			schemaName: schema
 		});
-		const storageTypes = {};
-		for (const [typeName, annotation] of Object.entries(rawStorageTypes)) storageTypes[enumStorageCompoundKey(schema, typeName)] = annotation;
+		const enumTypes = Object.keys(rawEnumTypes).length > 0 ? { [schema]: rawEnumTypes } : {};
 		return {
 			tables,
 			annotations: { pg: {
 				schema,
 				version: await this.getPostgresVersion(driver),
-				...ifDefined("storageTypes", Object.keys(storageTypes).length > 0 ? storageTypes : void 0)
+				...ifDefined("enumTypes", Object.keys(enumTypes).length > 0 ? enumTypes : void 0)
 			} }
 		};
 	}
@@ -1474,7 +1485,89 @@ function extractQuotedLiterals(listBody) {
 	const values = [...listBody.matchAll(/'((?:[^'\\]|\\.|'')*)'/g)].map((m) => (m[1] ?? "").replace(/''/g, "'"));
 	return values.length > 0 ? values : void 0;
 }
+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 pgInlineLiteral(wire, nativeType) {
+	if (wire === null) return "NULL";
+	if (typeof wire === "boolean") return wire ? "true" : "false";
+	if (typeof wire === "number") {
+		if (!Number.isFinite(wire)) throw new Error(`pgRenderDdlExecuteRequest: non-finite number wire value ${String(wire)} cannot be emitted as a DEFAULT literal for native type "${nativeType}"`);
+		return String(wire);
+	}
+	if (typeof wire === "bigint") return String(wire);
+	if (wire instanceof Date) {
+		if (Number.isNaN(wire.getTime())) throw new Error(`pgRenderDdlExecuteRequest: invalid Date value cannot be emitted as a DEFAULT literal for native type "${nativeType}"`);
+		const quoted = `'${escapeLiteral(wire.toISOString())}'`;
+		return pgIsTextLikeNativeType(nativeType) ? quoted : `${quoted}::${nativeType}`;
+	}
+	if (typeof wire === "string") {
+		const quoted = `'${escapeLiteral(wire)}'`;
+		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 (typeof wire === "object") return `${`'${escapeLiteral(JSON.stringify(wire))}'`}::${nativeType}`;
+	throw new Error(`pgRenderDdlExecuteRequest: unexpected wire type "${typeof wire}" for native type "${nativeType}"`);
+}
+async function pgRenderDdlColumnDefault(def, nativeType, codecLookup, codecRef) {
+	if (def.kind === "function") {
+		if (def.expression === "autoincrement()") return "";
+		return `DEFAULT (${def.expression})`;
+	}
+	if (codecRef !== void 0) {
+		const codec = codecLookup.get(codecRef.codecId);
+		if (codec !== void 0) return `DEFAULT ${pgInlineLiteral(await codec.encode(def.value, {}), nativeType)}`;
+	}
+	return `DEFAULT ${pgInlineLiteral(def.value, nativeType)}`;
+}
+async function pgRenderDdlColumn(column, codecLookup) {
+	const parts = [quoteIdentifier(column.name), column.type];
+	if (column.notNull) parts.push("NOT NULL");
+	if (column.primaryKey) parts.push("PRIMARY KEY");
+	if (column.default) {
+		const clause = await pgRenderDdlColumnDefault(column.default, column.type, codecLookup, column.codecRef);
+		if (clause.length > 0) parts.push(clause);
+	}
+	return parts.join(" ");
+}
+function pgRenderDdlConstraint(constraint) {
+	if (constraint.kind === "primary-key") {
+		const cols = constraint.columns.map(quoteIdentifier).join(", ");
+		if (constraint.name !== void 0) return `CONSTRAINT ${quoteIdentifier(constraint.name)} PRIMARY KEY (${cols})`;
+		return `PRIMARY KEY (${cols})`;
+	}
+	if (constraint.kind === "foreign-key") {
+		let sql = `FOREIGN KEY (${constraint.columns.map(quoteIdentifier).join(", ")}) REFERENCES ${constraint.refTable.split(".").map(quoteIdentifier).join(".")} (${constraint.refColumns.map(quoteIdentifier).join(", ")})`;
+		if (constraint.onDelete !== void 0) sql += ` ON DELETE ${REFERENTIAL_ACTION_SQL[constraint.onDelete]}`;
+		if (constraint.onUpdate !== void 0) sql += ` ON UPDATE ${REFERENTIAL_ACTION_SQL[constraint.onUpdate]}`;
+		if (constraint.name !== void 0) sql = `CONSTRAINT ${quoteIdentifier(constraint.name)} ${sql}`;
+		return sql;
+	}
+	const cols = constraint.columns.map(quoteIdentifier).join(", ");
+	if (constraint.name !== void 0) return `CONSTRAINT ${quoteIdentifier(constraint.name)} UNIQUE (${cols})`;
+	return `UNIQUE (${cols})`;
+}
+async function pgRenderCreateTable(node, codecLookup) {
+	const ifNotExists = node.ifNotExists ? "IF NOT EXISTS " : "";
+	const tableRef = node.schema ? `${quoteIdentifier(node.schema)}.${quoteIdentifier(node.table)}` : quoteIdentifier(node.table);
+	const columnDefs = await Promise.all(node.columns.map((col) => pgRenderDdlColumn(col, codecLookup)));
+	const constraintDefs = node.constraints !== void 0 ? node.constraints.map(pgRenderDdlConstraint) : [];
+	return {
+		sql: `CREATE TABLE ${ifNotExists}${tableRef} (\n  ${[...columnDefs, ...constraintDefs].join(",\n  ")}\n)`,
+		params: []
+	};
+}
+function pgRenderCreateSchema(node) {
+	return {
+		sql: `CREATE SCHEMA ${node.ifNotExists ? "IF NOT EXISTS " : ""}${quoteIdentifier(node.schema)}`,
+		params: []
+	};
+}
+async function pgRenderDdlExecuteRequest(ast, codecLookup) {
+	if (ast.kind === "create-table") return pgRenderCreateTable(blindCast(ast), codecLookup);
+	return pgRenderCreateSchema(blindCast(ast));
+}
 //#endregion
-export { createPostgresBuiltinCodecLookup as i, renderLoweredSql as n, renderLoweredDdl as r, PostgresControlAdapter as t };
+export { renderLoweredSql as n, createPostgresBuiltinCodecLookup as r, PostgresControlAdapter as t };
 
-//# sourceMappingURL=control-adapter-ZWrjGBq7.mjs.map
+//# sourceMappingURL=control-adapter-BeSqyOGl.mjs.map