@prisma/orm-target-postgres 0.17.0-dev.1 → 0.17.0-dev.2

package/dist/{control-adapter-B9t0g7Pf-HrCxlM65.mjs → control-adapter-CipVam9p-B-E2SF8_.mjs}

@@ -1,32 +1,27 @@
-import { n as buildPostgresCodecDescriptorRegistry } from "./codec-descriptor-CB6x0xEu-C-Zn2IEz.mjs";
 import { x as PG_TIMESTAMPTZ_CODEC_ID } from "./codec-ids-tX7Svtz--BuOfRaVU.mjs";
+import { n as buildPostgresCodecDescriptorRegistry } from "./codec-descriptor-CB6x0xEu-C-Zn2IEz.mjs";
 import { n as postgresError } from "./errors-kYxOQjdD-D4T3rbVp.mjs";
-import { n as isPgEnumParams } from "./codecs-CBl0nD44-CaWPc1bd.mjs";
-import { n as postgresCodecRegistry, t as postgresCodecDescriptorRegistry } from "./codecs-CHIVTNZs.mjs";
-import { i as quoteQualifiedName, r as quoteIdentifier, t as escapeLiteral } from "./sql-utils-BnBlQxyh-DaX9Nb7Z.mjs";
+import { n as postgresCodecRegistry, t as postgresCodecDescriptorRegistry } from "./codecs-rujsdlZR.mjs";
+import { r as quoteIdentifier, t as escapeLiteral } from "./sql-utils-BnBlQxyh-DaX9Nb7Z.mjs";
 import { a as jsonb, c as textArray, i as int8, l as timestamptz, n as buildSignMarkerBootstrapQueries, o as pgTable, r as int4, s as text, t as buildControlTableBootstrapQueries } from "./contract-free-BZUS18FU.mjs";
 import { t as parsePostgresDefault } from "./default-normalizer-Ba5ZebHM-isV86rjy.mjs";
 import { n as PostgresSchemaNodeKind, r as PostgresTableSchemaNode, t as PostgresNativeEnumSchemaNode } from "./postgres-table-schema-node-BBkitBQh-DT1T5VWU.mjs";
 import { i as PostgresRoleSchemaNode, n as PostgresNamespaceSchemaNode, r as PostgresPolicySchemaNode, t as PostgresDatabaseSchemaNode } from "./postgres-role-schema-node-B8Z5i5D--PObwlU2Z.mjs";
 import { t as normalizeSchemaNativeType } from "./native-type-normalizer-yvd3tqv-.mjs";
-import { LiteralExpr, RawExpr, collectOrderedParamRefs, isDdlNode } from "@prisma/orm-family-sql/relational-core/ast";
+import { n as renderLoweredSql, t as adapterError } from "./sql-renderer-CZE98PJj-Bx5D-Txz.mjs";
+import { RawExpr, isDdlNode } from "@prisma/orm-family-sql/relational-core/ast";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
-import { structuredError } from "@prisma/orm-framework/utils/structured-error";
 import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import { namingOfLiveName } from "@prisma/orm-family-sql/schema-ir/naming";
 import { APP_SPACE_ID, extractCodecLookup } from "@prisma/orm-framework/components/control";
 import { RelationalSchemaNodeKind } from "@prisma/orm-family-sql/schema-ir/types";
-import { InternalError, assertNever } from "@prisma/orm-framework/utils/internal-error";
+import { InternalError } from "@prisma/orm-framework/utils/internal-error";
 import { REFERENTIAL_ACTION_SQL } from "@prisma/orm-family-sql/contract/referential-action-sql";
 import { parseMarkerRowSafely, rethrowMarkerReadError, withMarkerReadErrorHandling } from "@prisma/orm-framework/errors/execution";
 import { parseContractMarkerRow } from "@prisma/orm-family-sql/family/verify";
 import { createAstCodecRegistry, deriveParamMetadata, encodeParamsWithMetadata } from "@prisma/orm-family-sql/runtime";
-import { runtimeError } from "@prisma/orm-framework/components/runtime";
-//#region ../../../3-targets/6-adapters/postgres/dist/control-adapter-B9t0g7Pf.mjs
-function adapterError(code, message, options) {
-	return structuredError(code, message, options);
-}
+//#region ../../../3-targets/6-adapters/postgres/dist/control-adapter-CipVam9p.mjs
 function buildPostgresCodecRegistry(descriptors) {
 	const descriptorRegistry = buildPostgresCodecDescriptorRegistry(descriptors);
 	const registry = {
@@ -147,570 +142,6 @@ async function execute(lower, driver, query) {
 	const encoded = await encodeControlQueryParams(lowered, query);
 	return (await driver.query(lowered.sql, encoded)).rows;
 }
-/**
-* Postgres native types whose unknown-OID parameter inference is reliable in arbitrary expression positions. Parameters bound to a descriptor whose `nativeTypeFor` result falls in this set are emitted as plain `$N`; everything else (including `json`, `jsonb`, extension types like `vector`, and unknown user types) is emitted as `$N::<nativeType>` so the planner picks an unambiguous overload.
-*
-* `json` / `jsonb` are intentionally excluded despite being Postgres builtins: their operator overloads make context inference unreliable in expression positions (e.g. `$1 -> 'key'` is ambiguous between the two).
-*
-* Spellings match the target descriptors' `nativeTypeFor` results, not the `udt_name` abbreviations that ADR 205 used as illustrative shorthand. The registry-based cast policy compares against these strings directly.
-*/
-const POSTGRES_INFERRABLE_NATIVE_TYPES = /* @__PURE__ */ new Set([
-	"integer",
-	"smallint",
-	"bigint",
-	"real",
-	"double precision",
-	"numeric",
-	"boolean",
-	"text",
-	"character",
-	"character varying",
-	"timestamp",
-	"timestamp without time zone",
-	"timestamp with time zone",
-	"time",
-	"timetz",
-	"interval",
-	"bit",
-	"bit varying"
-]);
-function renderTypedParam(index, codecId, codecDescriptorRegistry, many, typeParams) {
-	if (codecId === void 0) return `$${index}`;
-	const descriptor = codecDescriptorRegistry.descriptorFor(codecId);
-	if (descriptor === void 0) throw adapterError("RUNTIME.PARAM_REF_MISSING_CODEC", `Postgres lowering: ParamRef carries codecId "${codecId}" but the validated PostgreSQL codec registry 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. \`extensions: [pgvectorRuntime]\`), or use the codec directly from \`@internal/target-postgres/codecs\` if it's a builtin.`, { meta: { codecId } });
-	const ref = {
-		codecId,
-		...ifDefined("many", many),
-		...ifDefined("typeParams", typeParams)
-	};
-	const nativeType = descriptor.nativeTypeFor(ref);
-	const arraySuffix = many ? "[]" : "";
-	if (isPgEnumParams(typeParams)) return `$${index}::${quoteQualifiedName(nativeType)}${arraySuffix}`;
-	if (!POSTGRES_INFERRABLE_NATIVE_TYPES.has(nativeType) || many) return `$${index}::${nativeType}${arraySuffix}`;
-	return `$${index}`;
-}
-function unreachableKind(value) {
-	const candidate = value;
-	if (typeof candidate === "object" && candidate !== null && "kind" in candidate && typeof candidate.kind === "string") return candidate.kind;
-	return "unknown";
-}
-/**
-* Render a SQL query AST to a Postgres-flavored `{ sql, params }` payload.
-*
-* Shared between the runtime (`PostgresAdapterImpl.lower`) and control (`PostgresControlAdapter.lower`) entrypoints so emit-time and run-time paths produce byte-identical output for the same AST.
-*/
-function renderLoweredSql(ast, contract, codecDescriptorRegistry) {
-	const orderedRefs = collectOrderedParamRefs(ast);
-	const indexMap = /* @__PURE__ */ new Map();
-	const params = orderedRefs.map((ref, i) => {
-		indexMap.set(ref, i + 1);
-		return ref.kind === "prepared-param-ref" ? {
-			kind: "bind",
-			name: ref.name
-		} : {
-			kind: "literal",
-			value: ref.value
-		};
-	});
-	const pim = {
-		indexMap,
-		codecDescriptorRegistry
-	};
-	const node = ast;
-	let sql;
-	switch (node.kind) {
-		case "select":
-			sql = renderSelect(node, contract, pim);
-			break;
-		case "insert":
-			sql = renderInsert(node, contract, pim);
-			break;
-		case "update":
-			sql = renderUpdate(node, contract, pim);
-			break;
-		case "delete":
-			sql = renderDelete(node, contract, pim);
-			break;
-		case "raw-sql":
-			sql = renderRawSql(node, contract, pim);
-			break;
-		// v8 ignore next 4
-		default: assertNever(node, `Unsupported AST node kind: ${unreachableKind(node)}`);
-	}
-	return Object.freeze({
-		sql,
-		params: Object.freeze(params)
-	});
-}
-function renderLimitOffset(keyword, value, contract, pim) {
-	if (value === void 0) return "";
-	if (typeof value === "number") return `${keyword} ${value}`;
-	return `${keyword} ${renderExpr(value, contract, pim)}`;
-}
-function renderSelect(ast, contract, pim) {
-	const sourcesByRef = collectTableSources(ast);
-	return [
-		`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 `${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);
-		if (item.expr.kind === "literal") return `${renderLiteral(item.expr)} AS ${alias}`;
-		return `${renderExpr(item.expr, contract, pim)} AS ${alias}`;
-	}).join(", ");
-}
-function renderReturning(items, contract, pim) {
-	return items.map((item) => {
-		if (item.expr.kind === "column-ref") {
-			const rendered = renderColumn(item.expr);
-			return item.expr.column === item.alias ? rendered : `${rendered} AS ${quoteIdentifier(item.alias)}`;
-		}
-		if (item.expr.kind === "literal") return `${renderLiteral(item.expr)} AS ${quoteIdentifier(item.alias)}`;
-		return `${renderExpr(item.expr, contract, pim)} AS ${quoteIdentifier(item.alias)}`;
-	}).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 (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 adapterError("RUNTIME.NAMESPACE_UNKNOWN", `Table "${table.name}" references namespace "${table.namespaceId}" which is not present as a Postgres schema on the contract`, { meta: {
-		table: table.name,
-		namespaceId: table.namespaceId,
-		reason: "not-present"
-	} });
-	const qualifyTable = namespace.qualifyTable;
-	if (qualifyTable === void 0) throw adapterError("RUNTIME.NAMESPACE_UNKNOWN", `Table "${table.name}" references namespace "${table.namespaceId}" which is not materialised as a Postgres schema on the contract`, { meta: {
-		table: table.name,
-		namespaceId: table.namespaceId,
-		reason: "not-materialised"
-	} });
-	return qualifyTable.call(namespace, table.name);
-}
-function renderTableSource(source, contract) {
-	const qualified = qualifyTableFromNamespaceCoordinate(source, contract);
-	if (!source.alias) return qualified;
-	return `${qualified} AS ${quoteIdentifier(source.alias)}`;
-}
-function renderSource(source, contract, pim) {
-	const node = source;
-	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(", ");
-			return `${`${node.fn}(${args})`}${node.ordinality ? " WITH ORDINALITY" : ""}${node.alias === void 0 ? "" : ` AS ${quoteIdentifier(node.alias)}`}${node.columnAliases === void 0 ? "" : `(${node.columnAliases.map((column) => quoteIdentifier(column)).join(", ")})`}`;
-		}
-		// v8 ignore next 4
-		default: assertNever(node, `Unsupported source node kind: ${unreachableKind(node)}`);
-	}
-}
-function assertScalarSubquery(query) {
-	if (query.projection.length !== 1) throw adapterError("RUNTIME.AST_INVALID", "Subquery expressions must project exactly one column", { meta: { node: "subquery-expr" } });
-}
-function renderSubqueryExpr(expr, contract, pim) {
-	assertScalarSubquery(expr.query);
-	return `(${renderSelect(expr.query, contract, pim)})`;
-}
-function renderWhere(expr, contract, pim) {
-	return renderExpr(expr, contract, pim);
-}
-function renderNullCheck(expr, contract, pim) {
-	const rendered = renderExpr(expr.expr, contract, pim);
-	const renderedExpr = isAtomicExpressionKind(expr.expr.kind) ? rendered : `(${rendered})`;
-	return expr.isNull ? `${renderedExpr} IS NULL` : `${renderedExpr} IS NOT NULL`;
-}
-/**
-* Atomic expression kinds whose rendered SQL is already self-delimited (a column reference, parameter, literal, function call, aggregate, etc.) and therefore does not need surrounding parentheses when used as the left operand of a postfix predicate like `IS NULL` or `IS NOT NULL`, or as either operand of a binary infix operator.
-*
-* Anything not in this set is treated as composite (binary, AND/OR/NOT, EXISTS, nested IS NULL, subqueries, operation templates) and gets wrapped to preserve grouping.
-*/
-function isAtomicExpressionKind(kind) {
-	switch (kind) {
-		case "column-ref":
-		case "identifier-ref":
-		case "param-ref":
-		case "prepared-param-ref":
-		case "literal":
-		case "aggregate":
-		case "window-func":
-		case "function-call":
-		case "cast":
-		case "case":
-		case "json-object":
-		case "json-array-agg":
-		case "list": return true;
-		case "subquery":
-		case "operation":
-		case "binary":
-		case "and":
-		case "or":
-		case "exists":
-		case "null-check":
-		case "not":
-		case "raw-expr": return false;
-	}
-}
-function renderBinary(expr, contract, pim) {
-	if (expr.right.kind === "list" && expr.right.values.length === 0) {
-		if (expr.op === "in") return "FALSE";
-		if (expr.op === "notIn") return "TRUE";
-	}
-	const leftExpr = expr.left;
-	const left = renderExpr(leftExpr, contract, pim);
-	const leftRendered = leftExpr.kind === "operation" || leftExpr.kind === "subquery" ? `(${left})` : left;
-	const rightNode = expr.right;
-	let right;
-	switch (rightNode.kind) {
-		case "list":
-			right = renderListLiteral(rightNode, contract, pim);
-			break;
-		case "literal":
-			right = renderLiteral(rightNode);
-			break;
-		case "column-ref":
-			right = renderColumn(rightNode);
-			break;
-		case "param-ref":
-		case "prepared-param-ref":
-			right = renderParamRef(rightNode, pim);
-			break;
-		default:
-			right = renderExpr(rightNode, contract, pim);
-			break;
-	}
-	return `${leftRendered} ${{
-		eq: "=",
-		neq: "!=",
-		gt: ">",
-		lt: "<",
-		gte: ">=",
-		lte: "<=",
-		like: "LIKE",
-		in: "IN",
-		notIn: "NOT IN"
-	}[expr.op]} ${right}`;
-}
-function renderListLiteral(expr, contract, pim) {
-	if (expr.values.length === 0) return "(NULL)";
-	return `(${expr.values.map((v) => {
-		if (v.kind === "param-ref" || v.kind === "prepared-param-ref") return renderParamRef(v, pim);
-		if (v.kind === "literal") return renderLiteral(v);
-		return renderExpr(v, contract, pim);
-	}).join(", ")})`;
-}
-function renderColumn(ref) {
-	if (ref.table === "excluded") return `excluded.${quoteIdentifier(ref.column)}`;
-	return `${quoteIdentifier(ref.table)}.${quoteIdentifier(ref.column)}`;
-}
-function renderAggregateExpr(expr, contract, pim) {
-	const fn = expr.fn.toUpperCase();
-	if (!expr.expr) return `${fn}(*)`;
-	return `${fn}(${renderExpr(expr.expr, contract, pim)})`;
-}
-function renderWindowFuncExpr(expr, contract, pim) {
-	return `${expr.fn.toUpperCase()}(${expr.args.map((arg) => renderExpr(arg, contract, pim)).join(", ")}) OVER (${[expr.partitionBy && expr.partitionBy.length > 0 ? `PARTITION BY ${expr.partitionBy.map((e) => renderExpr(e, contract, pim)).join(", ")}` : "", expr.orderBy && expr.orderBy.length > 0 ? `ORDER BY ${renderOrderByItems(expr.orderBy, contract, pim)}` : ""].filter((part) => part.length > 0).join(" ")})`;
-}
-function renderFunctionCallExpr(expr, contract, pim) {
-	const args = expr.args.map((arg) => renderExpr(arg, contract, pim)).join(", ");
-	return `${expr.fn}(${args})`;
-}
-function renderCastExpr(expr, contract, pim) {
-	return `CAST(${renderExpr(expr.expr, contract, pim)} AS ${expr.targetType})`;
-}
-function renderCaseExpr(expr, contract, pim) {
-	return `CASE ${expr.branches.map((branch) => `WHEN ${renderExpr(branch.condition, contract, pim)} THEN ${renderExpr(branch.value, contract, pim)}`).join(" ")}${expr.elseExpr === void 0 ? "" : ` ELSE ${renderExpr(expr.elseExpr, contract, pim)}`} END`;
-}
-function renderJsonValueProjection(projection, contract, pim) {
-	return projection.accept({
-		codec: ({ value, codec }) => renderExpr(projectJsonThroughCodec(value, codec, pim), contract, pim),
-		native: ({ value }) => renderExpr(value, contract, pim),
-		document: ({ value }) => renderExpr(value, contract, pim)
-	});
-}
-function projectJsonThroughCodec(value, codec, pim) {
-	const descriptor = pim.codecDescriptorRegistry.descriptorFor(codec.codecId);
-	if (descriptor === void 0) throw adapterError("RUNTIME.PARAM_REF_MISSING_CODEC", `Postgres lowering: a JSON projection carries codecId "${codec.codecId}" but the validated PostgreSQL codec registry 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. \`extensions: [pgvectorRuntime]\`), or use the codec directly from \`@internal/target-postgres/codecs\` if it's a builtin.`, { meta: { codecId: codec.codecId } });
-	return descriptor.projectJson(value, codec);
-}
-function renderJsonObjectExpr(expr, contract, pim) {
-	return `json_build_object(${expr.entries.flatMap((entry) => {
-		return [`'${escapeLiteral(entry.key)}'`, renderJsonValueProjection(entry.value, contract, pim)];
-	}).join(", ")})`;
-}
-function renderOrderByItems(items, contract, pim) {
-	return items.map((item) => `${renderExpr(item.expr, contract, pim)} ${item.dir.toUpperCase()}`).join(", ");
-}
-function renderJsonArrayAggExpr(expr, contract, pim) {
-	const aggregateOrderBy = expr.orderBy && expr.orderBy.length > 0 ? ` ORDER BY ${renderOrderByItems(expr.orderBy, contract, pim)}` : "";
-	const aggregated = `json_agg(${renderJsonValueProjection(expr.expr, contract, pim)}${aggregateOrderBy})`;
-	if (expr.onEmpty === "emptyArray") return `coalesce(${aggregated}, json_build_array())`;
-	return aggregated;
-}
-function renderExpr(expr, contract, pim) {
-	const node = expr;
-	switch (node.kind) {
-		case "column-ref": return renderColumn(node);
-		case "identifier-ref": return quoteIdentifier(node.name);
-		case "operation": return renderOperation(node, contract, pim);
-		case "subquery": return renderSubqueryExpr(node, contract, pim);
-		case "aggregate": return renderAggregateExpr(node, contract, pim);
-		case "window-func": return renderWindowFuncExpr(node, contract, pim);
-		case "function-call": return renderFunctionCallExpr(node, contract, pim);
-		case "cast": return renderCastExpr(node, contract, pim);
-		case "case": return renderCaseExpr(node, contract, pim);
-		case "json-object": return renderJsonObjectExpr(node, contract, pim);
-		case "json-array-agg": return renderJsonArrayAggExpr(node, contract, pim);
-		case "binary": return renderBinary(node, contract, pim);
-		case "and":
-			if (node.exprs.length === 0) return "TRUE";
-			return `(${node.exprs.map((part) => renderExpr(part, contract, pim)).join(" AND ")})`;
-		case "or":
-			if (node.exprs.length === 0) return "FALSE";
-			return `(${node.exprs.map((part) => renderExpr(part, contract, pim)).join(" OR ")})`;
-		case "exists": return `${node.notExists ? "NOT " : ""}EXISTS (${renderSelect(node.subquery, contract, pim)})`;
-		case "null-check": return renderNullCheck(node, contract, pim);
-		case "not": return `NOT (${renderExpr(node.expr, contract, pim)})`;
-		case "param-ref":
-		case "prepared-param-ref": return renderParamRef(node, pim);
-		case "literal": return renderLiteral(node);
-		case "list": return renderListLiteral(node, contract, pim);
-		case "raw-expr": return renderRawExpr(node, contract, pim);
-		// v8 ignore next 4
-		default: assertNever(node, `Unsupported expression node kind: ${unreachableKind(node)}`);
-	}
-}
-function renderParamRef(ref, pim) {
-	const index = pim.indexMap.get(ref);
-	if (index === void 0) throw new InternalError("ParamRef not found in index map");
-	if (ref.kind === "prepared-param-ref") return renderTypedParam(index, ref.codec.codecId, pim.codecDescriptorRegistry, 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.codecDescriptorRegistry, ref.codec.many, ref.codec.typeParams);
-}
-function renderLiteral(expr) {
-	if (typeof expr.value === "string") return `'${escapeLiteral(expr.value)}'`;
-	if (typeof expr.value === "number" || typeof expr.value === "boolean") return String(expr.value);
-	if (typeof expr.value === "bigint") return String(expr.value);
-	if (expr.value === null) return "NULL";
-	if (expr.value === void 0) return "NULL";
-	if (expr.value instanceof Date) return `'${escapeLiteral(expr.value.toISOString())}'`;
-	if (Array.isArray(expr.value)) return `ARRAY[${expr.value.map((v) => renderLiteral(new LiteralExpr(v))).join(", ")}]`;
-	const json = JSON.stringify(expr.value);
-	if (json === void 0) return "NULL";
-	return `'${escapeLiteral(json)}'`;
-}
-function renderOperation(expr, contract, pim) {
-	const self = renderExpr(expr.self, contract, pim);
-	const args = expr.args.map((arg) => {
-		return renderExpr(arg, contract, pim);
-	});
-	return expr.lowering.template.replace(/\{\{self\}\}|\{\{arg(\d+)\}\}/g, (token, argIndex) => {
-		if (token === "{{self}}") return self;
-		const arg = args[Number(argIndex)];
-		if (arg === void 0) throw adapterError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Operation lowering template for "${expr.method}" referenced missing argument {{arg${argIndex}}}; template has ${args.length} arg(s)`, { meta: { method: expr.method } });
-		return arg;
-	});
-}
-function renderJoin(join, contract, pim) {
-	return `${join.joinType.toUpperCase()} JOIN ${join.lateral ? "LATERAL " : ""}${renderSource(join.source, contract, pim)} ON ${renderJoinOn(join.on, contract, pim)}`;
-}
-function renderJoinOn(on, contract, pim) {
-	if (on.kind === "eq-col-join-on") return `${renderColumn(on.left)} = ${renderColumn(on.right)}`;
-	return renderWhere(on, contract, pim);
-}
-function getInsertColumnOrder(rows, contract, tableRef) {
-	const tableName = tableRef.name;
-	const orderedColumns = [];
-	const seenColumns = /* @__PURE__ */ new Set();
-	for (const row of rows) for (const column of Object.keys(row)) {
-		if (seenColumns.has(column)) continue;
-		seenColumns.add(column);
-		orderedColumns.push(column);
-	}
-	if (orderedColumns.length > 0) return orderedColumns;
-	let table;
-	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];
-		if (found !== void 0) {
-			table = found;
-			break;
-		}
-	}
-	if (!table) throw adapterError("RUNTIME.AST_INVALID", `INSERT target table not found in contract storage: ${tableName}`, { meta: {
-		node: "insert",
-		table: tableName
-	} });
-	return Object.keys(table.columns);
-}
-function renderInsertValue(value, contract, pim) {
-	if (!value || value.kind === "default-value") return "DEFAULT";
-	switch (value.kind) {
-		case "param-ref":
-		case "prepared-param-ref": return renderParamRef(value, pim);
-		case "column-ref": return renderColumn(value);
-		case "raw-expr": return renderExpr(value, contract, pim);
-		// v8 ignore next 4
-		default: assertNever(value, `Unsupported value node in INSERT: ${unreachableKind(value)}`);
-	}
-}
-function renderInsert(ast, contract, pim) {
-	const table = qualifyTableFromNamespaceCoordinate(ast.table, contract);
-	const rows = ast.rows;
-	if (rows.length === 0) throw adapterError("RUNTIME.AST_INVALID", "INSERT requires at least one row", { meta: { node: "insert" } });
-	const hasExplicitValues = rows.some((row) => Object.keys(row).length > 0);
-	return `${(() => {
-		if (!hasExplicitValues) {
-			if (rows.length === 1) return `INSERT INTO ${table} DEFAULT VALUES`;
-			const defaultColumns = getInsertColumnOrder(rows, contract, ast.table);
-			if (defaultColumns.length === 0) return `INSERT INTO ${table} VALUES ${rows.map(() => "()").join(", ")}`;
-			const quotedColumns = defaultColumns.map((column) => quoteIdentifier(column));
-			const defaultRow = `(${defaultColumns.map(() => "DEFAULT").join(", ")})`;
-			return `INSERT INTO ${table} (${quotedColumns.join(", ")}) VALUES ${rows.map(() => defaultRow).join(", ")}`;
-		}
-		const columnOrder = getInsertColumnOrder(rows, contract, ast.table);
-		const columns = columnOrder.map((column) => quoteIdentifier(column));
-		const values = rows.map((row) => {
-			return `(${columnOrder.map((column) => renderInsertValue(row[column], contract, pim)).join(", ")})`;
-		}).join(", ");
-		return `INSERT INTO ${table} (${columns.join(", ")}) VALUES ${values}`;
-	})()}${ast.onConflict ? (() => {
-		const conflictColumns = ast.onConflict.columns.map((col) => quoteIdentifier(col.column));
-		if (conflictColumns.length === 0) throw adapterError("RUNTIME.AST_INVALID", "INSERT onConflict requires at least one conflict column", { meta: { node: "insert-on-conflict" } });
-		const action = ast.onConflict.action;
-		switch (action.kind) {
-			case "do-nothing": return ` ON CONFLICT (${conflictColumns.join(", ")}) DO NOTHING`;
-			case "do-update-set": {
-				const updateEntries = Object.entries(action.set);
-				if (updateEntries.length === 0) throw adapterError("RUNTIME.AST_INVALID", "INSERT onConflict do-update-set requires at least one assignment", { meta: { node: "insert-on-conflict" } });
-				const updates = updateEntries.map(([colName, value]) => {
-					return `${quoteIdentifier(colName)} = ${renderExpr(value, contract, pim)}`;
-				});
-				return ` ON CONFLICT (${conflictColumns.join(", ")}) DO UPDATE SET ${updates.join(", ")}`;
-			}
-			// v8 ignore next 4
-			default: assertNever(action, `Unsupported onConflict action: ${unreachableKind(action)}`);
-		}
-	})() : ""}${ast.returning?.length ? ` RETURNING ${renderReturning(ast.returning, contract, pim)}` : ""}`;
-}
-function renderUpdate(ast, contract, pim) {
-	const table = qualifyTableFromNamespaceCoordinate(ast.table, contract);
-	const setEntries = Object.entries(ast.set);
-	if (setEntries.length === 0) throw adapterError("RUNTIME.AST_INVALID", "UPDATE requires at least one SET assignment", { meta: { node: "update" } });
-	const setClauses = setEntries.map(([col, val]) => {
-		return `${quoteIdentifier(col)} = ${renderExpr(val, contract, pim)}`;
-	});
-	const whereClause = ast.where ? ` WHERE ${renderWhere(ast.where, contract, pim)}` : "";
-	const returningClause = ast.returning?.length ? ` RETURNING ${renderReturning(ast.returning, contract, pim)}` : "";
-	return `UPDATE ${table} SET ${setClauses.join(", ")}${whereClause}${returningClause}`;
-}
-function renderDelete(ast, contract, pim) {
-	return `DELETE FROM ${qualifyTableFromNamespaceCoordinate(ast.table, contract)}${ast.where ? ` WHERE ${renderWhere(ast.where, contract, pim)}` : ""}${ast.returning?.length ? ` RETURNING ${renderReturning(ast.returning, contract, pim)}` : ""}`;
-}
-function renderRawSql(ast, contract, pim) {
-	const out = [];
-	for (let i = 0; i < ast.fragments.length; i++) {
-		out.push(ast.fragments[i] ?? "");
-		if (i < ast.args.length) {
-			const arg = ast.args[i];
-			if (arg !== void 0) out.push(renderExpr(arg, contract, pim));
-		}
-	}
-	return out.join("");
-}
-function renderRawExpr(node, contract, pim) {
-	return node.parts.map((part) => typeof part === "string" ? part : renderExpr(part, contract, pim)).join("");
-}
 const POSTGRES_MARKER_TABLE = "prisma_contract.marker";
 const POSTGRES_LEDGER_TABLE = "prisma_contract.ledger";
 /**
@@ -1896,6 +1327,6 @@ async function pgRenderDdlExecuteRequest(ast, codecLookup) {
 	});
 }
 //#endregion
-export { createPostgresCodecRegistryWithBuiltins as a, createPostgresBuiltinCodecLookup as i, adapterError as n, renderLoweredSql as o, assemblePostgresCodecRegistry as r, PostgresControlAdapter as t };
+export { createPostgresCodecRegistryWithBuiltins as i, assemblePostgresCodecRegistry as n, createPostgresBuiltinCodecLookup as r, PostgresControlAdapter as t };
 
-//# sourceMappingURL=control-adapter-B9t0g7Pf-HrCxlM65.mjs.map
+//# sourceMappingURL=control-adapter-CipVam9p-B-E2SF8_.mjs.map