@prisma-next/adapter-postgres 0.13.0 → 0.14.0

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

@@ -4,24 +4,23 @@ 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 { PostgresTableSource, buildControlTableBootstrapQueries, buildSignMarkerBootstrapQueries, int4, int8, jsonb, pgTable, text, textArray, timestamptz } from "@prisma-next/target-postgres/contract-free";
+import { REFERENTIAL_ACTION_SQL } from "@prisma-next/sql-contract/referential-action-sql";
+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 { createResolveExistingEnumValues, enumStorageCompoundKey, 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_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,173 +35,16 @@ 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([])
-	});
-}
-//#endregion
-//#region src/core/enum-control-hooks.ts
-const ENUM_INTROSPECT_QUERY = `
-  SELECT
-    n.nspname AS schema_name,
-    t.typname AS type_name,
-    array_agg(e.enumlabel ORDER BY e.enumsortorder) AS values
-  FROM pg_type t
-  JOIN pg_namespace n ON t.typnamespace = n.oid
-  JOIN pg_enum e ON t.oid = e.enumtypid
-  WHERE n.nspname = $1
-  GROUP BY n.nspname, t.typname
-  ORDER BY n.nspname, t.typname
-`;
-function isStringArray(value) {
-	return Array.isArray(value) && value.every((entry) => typeof entry === "string");
-}
-/**
-* Parses a PostgreSQL array value into a JavaScript string array.
-*
-* The `pg` library returns `array_agg` results either as a JS array
-* (when type parsers are configured) or as a string in PostgreSQL array
-* literal format (`{value1,value2,...}`). Handles PG's quoting rules:
-* - Elements containing commas, quotes, backslashes, or whitespace are
-*   double-quoted.
-* - Inside quoted elements, `\"` represents `"` and `\\` represents `\`.
-*
-* Returns `null` when the input cannot be parsed as a PG array.
-*/
-function parsePostgresArray(value) {
-	if (isStringArray(value)) return value;
-	if (typeof value === "string" && value.startsWith("{") && value.endsWith("}")) {
-		const inner = value.slice(1, -1);
-		if (inner === "") return [];
-		return parseArrayElements(inner);
-	}
-	return null;
-}
-function parseArrayElements(input) {
-	const result = [];
-	let i = 0;
-	while (i < input.length) {
-		if (input[i] === ",") {
-			i++;
-			continue;
-		}
-		if (input[i] === "\"") {
-			i++;
-			let element = "";
-			while (i < input.length && input[i] !== "\"") {
-				if (input[i] === "\\" && i + 1 < input.length) {
-					i++;
-					element += input[i];
-				} else element += input[i];
-				i++;
-			}
-			i++;
-			result.push(element);
-		} else {
-			const nextComma = input.indexOf(",", i);
-			if (nextComma === -1) {
-				result.push(input.slice(i).trim());
-				i = input.length;
-			} else {
-				result.push(input.slice(i, nextComma).trim());
-				i = nextComma;
-			}
-		}
-	}
-	return result;
-}
-/**
-* Reads enum types from the live Postgres schema and returns them in
-* the codec-typed annotation shape consumed by `control-adapter.ts`
-* (which writes them under `schema.annotations.pg.storageTypes`).
-*/
-async function introspectPostgresEnumTypes(options) {
-	const namespace = options.schemaName ?? "public";
-	const result = await options.driver.query(ENUM_INTROSPECT_QUERY, [namespace]);
-	const types = {};
-	for (const row of result.rows) {
-		const values = parsePostgresArray(row.values);
-		if (!values) throw new Error(`Failed to parse enum values for type "${row.type_name}": unexpected format: ${JSON.stringify(row.values)}`);
-		types[row.type_name] = {
-			codecId: PG_ENUM_CODEC_ID,
-			nativeType: row.type_name,
-			typeParams: { values }
-		};
-	}
-	return types;
+//#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/marker-ledger.ts
-const CONTROL_CODECS = createAstCodecRegistry(postgresCodecRegistry);
 const marker = pgTable({
 	name: "marker",
 	schema: "prisma_contract"
@@ -269,10 +111,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 +211,87 @@ function renderLimitOffset(keyword, value, contract, pim) {
 	return `${keyword} ${renderExpr(value, contract, pim)}`;
 }
 function renderSelect(ast, 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)}`,
+		`SELECT ${renderDistinctPrefix(ast.distinct, ast.distinctOn, sourcesByRef, contract, pim)}${renderProjection(ast.projection, contract, pim)}`,
+		ast.from !== void 0 ? `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)}` : "",
 		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
+		});
+	};
+	if (ast.from !== void 0) 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 sourceNs = contract.storage.namespaces[source.namespaceId];
+	const valueSet = (sourceNs !== void 0 ? sourceNs.entries.table?.[source.name]?.columns[ref.column] : void 0)?.valueSet;
+	if (valueSet === void 0) return;
+	const valueSetNs = contract.storage.namespaces[valueSet.namespaceId];
+	return valueSetNs !== void 0 ? valueSetNs.entries.valueSet?.[valueSet.entityName]?.values : void 0;
+}
+/**
+* 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 identNs = contract.storage.namespaces[source.namespaceId];
+		const column = identNs !== void 0 ? identNs.entries.table?.[source.name]?.columns[name] : void 0;
+		if (column === void 0) continue;
+		matchedColumns += 1;
+		if (matchedColumns > 1) return;
+		const valueSet = column.valueSet;
+		if (valueSet === void 0) return;
+		const valueSetNs = contract.storage.namespaces[valueSet.namespaceId];
+		resolved = valueSetNs !== void 0 ? valueSetNs.entries.valueSet?.[valueSet.entityName]?.values : void 0;
+	}
+	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);
@@ -403,13 +309,16 @@ function renderReturning(items, contract, pim) {
 		return `${renderExpr(item.expr, contract, pim)} AS ${quoteIdentifier(item.alias)}`;
 	}).join(", ");
 }
-function renderDistinctPrefix(distinct, distinctOn, contract, pim) {
-	if (distinctOn && distinctOn.length > 0) return `DISTINCT ON (${distinctOn.map((expr) => renderExpr(expr, contract, pim)).join(", ")}) `;
+function renderDistinctPrefix(distinct, distinctOn, sourcesByRef, contract, pim) {
+	if (distinctOn && distinctOn.length > 0) return `DISTINCT ON (${distinctOn.map((expr) => renderOrderByExpr(expr, sourcesByRef, contract, pim)).join(", ")}) `;
 	if (distinct) return "DISTINCT ";
 	return "";
 }
+function hasExplicitSchema(table) {
+	return "schema" in table && typeof table.schema === "string";
+}
 function qualifyTableFromNamespaceCoordinate(table, contract) {
-	if (table instanceof PostgresTableSource && table.schema !== void 0) return `${quoteIdentifier(table.schema)}.${quoteIdentifier(table.name)}`;
+	if (hasExplicitSchema(table)) return `${quoteIdentifier(table.schema)}.${quoteIdentifier(table.name)}`;
 	if (table.namespaceId === void 0) return quoteIdentifier(table.name);
 	const namespace = contract.storage.namespaces[table.namespaceId];
 	if (namespace === void 0) throw new Error(`Table "${table.name}" references namespace "${table.namespaceId}" which is not present as a Postgres schema on the contract`);
@@ -427,6 +336,11 @@ function renderSource(source, contract, pim) {
 	switch (node.kind) {
 		case "table-source": return renderTableSource(node, contract);
 		case "derived-table-source": return `(${renderSelect(node.query, contract, pim)}) AS ${quoteIdentifier(node.alias)}`;
+		case "function-source": {
+			const args = node.args.map((arg) => renderExpr(arg, contract, pim)).join(", ");
+			const call = `${node.fn}(${args})`;
+			return node.alias !== void 0 ? `${call} AS ${quoteIdentifier(node.alias)}` : call;
+		}
 		// v8 ignore next 4
 		default: throw new Error(`Unsupported source node kind: ${node.kind}`);
 	}
@@ -632,9 +546,12 @@ function getInsertColumnOrder(rows, contract, tableRef) {
 	}
 	if (orderedColumns.length > 0) return orderedColumns;
 	let table;
-	if (tableRef.namespaceId !== void 0) table = contract.storage.namespaces[tableRef.namespaceId]?.entries.table[tableName];
+	if (tableRef.namespaceId !== void 0) {
+		const ns = contract.storage.namespaces[tableRef.namespaceId];
+		table = ns !== void 0 ? ns.entries.table?.[tableName] : void 0;
+	}
 	if (table === void 0) for (const ns of Object.values(contract.storage.namespaces)) {
-		const found = ns.entries.table[tableName];
+		const found = ns.entries.table?.[tableName];
 		if (found !== void 0) {
 			table = found;
 			break;
@@ -732,16 +649,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.
@@ -754,16 +664,6 @@ var PostgresControlAdapter = class {
 	* before comparison with contract native types.
 	*/
 	normalizeNativeType = normalizeSchemaNativeType;
-	/**
-	* Bridges native `PostgresEnumStorageEntry` IR walks against the Postgres
-	* introspection shape (`schema.annotations.pg.storageTypes`). Lets
-	* the family-level schema verifier walk enum types without reaching
-	* into target-specific annotation layouts itself.
-	*/
-	resolveExistingEnumValues = (schema, enumType, namespaceId) => {
-		return readExistingEnumValues(schema, namespaceId === UNBOUND_NAMESPACE_ID ? readPostgresSchemaIrAnnotations(schema).schema ?? "public" : namespaceId, enumType.nativeType);
-	};
-	resolveExistingEnumValuesForContract = (contract) => createResolveExistingEnumValues(contract.storage);
 	bootstrapControlTableQueries() {
 		return buildControlTableBootstrapQueries();
 	}
@@ -779,8 +679,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,23 +936,13 @@ 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 firstAnnotations = perSchema[0]?.annotations;
 		const firstPg = blindCast(firstAnnotations?.["pg"]) ?? {};
 		return {
 			tables: mergedTables,
 			...ifDefined("annotations", {
 				...firstAnnotations,
-				pg: {
-					...firstPg,
-					...ifDefined("storageTypes", Object.keys(mergedStorageTypes).length > 0 ? mergedStorageTypes : void 0)
-				}
+				pg: { ...firstPg }
 			})
 		};
 	}
@@ -1295,18 +1201,18 @@ var PostgresControlAdapter = class {
 				...ifDefined("checks", checksForTable.length > 0 ? checksForTable : void 0)
 			};
 		}
-		const rawStorageTypes = await introspectPostgresEnumTypes({
-			driver,
-			schemaName: schema
-		});
-		const storageTypes = {};
-		for (const [typeName, annotation] of Object.entries(rawStorageTypes)) storageTypes[enumStorageCompoundKey(schema, typeName)] = annotation;
+		const nativeEnumTypeNames = (await driver.query(`SELECT t.typname
+         FROM pg_catalog.pg_type t
+         JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+         WHERE t.typtype = 'e'
+           AND n.nspname = $1
+         ORDER BY t.typname`, [schema])).rows.map((r) => r.typname);
 		return {
 			tables,
 			annotations: { pg: {
 				schema,
 				version: await this.getPostgresVersion(driver),
-				...ifDefined("storageTypes", Object.keys(storageTypes).length > 0 ? storageTypes : void 0)
+				...nativeEnumTypeNames.length > 0 && { nativeEnumTypeNames }
 			} }
 		};
 	}
@@ -1474,7 +1380,102 @@ 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.default) {
+		const clause = await pgRenderDdlColumnDefault(column.default, column.type, codecLookup, column.codecRef);
+		if (clause.length > 0) parts.push(clause);
+	}
+	if (column.notNull) parts.push("NOT NULL");
+	if (column.primaryKey) parts.push("PRIMARY KEY");
+	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 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)}`;
+	} };
+	return {
+		sql: `ALTER TABLE ${tableRef} ${(await Promise.all(node.actions.map((a) => a.accept(actionVisitor)))).join(", ")}`,
+		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)
+	});
+}
 //#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-Dspz5uKp.mjs.map