@prisma-next/sql-builder 0.5.0-dev.6 → 0.5.0-dev.61

package/dist/runtime/index.mjs

@@ -1,16 +1,20 @@
-import { AggregateExpr, AndExpr, BinaryExpr, ColumnRef, DeleteAst, DerivedTableSource, ExistsExpr, IdentifierRef, InsertAst, JoinAst, ListExpression, LiteralExpr, NullCheckExpr, OperationExpr, OrExpr, OrderByItem, ParamRef, ProjectionItem, SelectAst, SubqueryExpr, TableSource, UpdateAst } from "@prisma-next/sql-relational-core/ast";
+import { AggregateExpr, AndExpr, BinaryExpr, ColumnRef, DeleteAst, DerivedTableSource, ExistsExpr, IdentifierRef, InsertAst, JoinAst, ListExpression, LiteralExpr, NullCheckExpr, OrExpr, OrderByItem, ParamRef, ProjectionItem, SelectAst, SubqueryExpr, TableSource, UpdateAst, collectOrderedParamRefs } from "@prisma-next/sql-relational-core/ast";
+import { refsOf, toExpr } from "@prisma-next/sql-relational-core/expression";
 
 //#region src/runtime/expression-impl.ts
 /**
-* Runtime wrapper around a relational-core AST expression node.
-* Carries ScopeField metadata (codecId, nullable) for plan generation.
+* Runtime wrapper around a relational-core AST expression node. Carries ScopeField metadata (codecId, nullable) so aggregate-like combinators can propagate the input codec onto their result.
+*
+* `refs` records the column-bound binding (`{ table, column }`) when known — the field-proxy populates it for both the namespaced form (`f.user.email` → `ColumnRef`) and the top-level shortcut (`f.email` → `IdentifierRef` + refs metadata). Encode-side dispatch and the `validateParamRefRefs` pass read it via `refsOf(expression)`.
 */
 var ExpressionImpl = class {
 	ast;
-	field;
-	constructor(ast, field) {
+	returnType;
+	refs;
+	constructor(ast, returnType, refs) {
 		this.ast = ast;
-		this.field = field;
+		this.returnType = returnType;
+		this.refs = refs;
 	}
 	buildAst() {
 		return this.ast;
@@ -19,11 +23,30 @@ var ExpressionImpl = class {
 
 //#endregion
 //#region src/runtime/field-proxy.ts
+/**
+* For a top-level field name, find the namespace (table alias) that contributed it. When exactly one namespace owns the field, the top-level binding is unambiguously column-bound and we record that `(table, column)` pair on the `ExpressionImpl` so encode-side dispatch (`forColumn`) and the `validateParamRefRefs` pass can find it. The AST stays as `IdentifierRef` to preserve SQL rendering — adapters render top-level
+* identifiers without an explicit table qualifier — so this change is metadata-only and produces no SQL drift.
+*/
+function findUniqueNamespaceFor$1(scope, fieldName) {
+	let found;
+	for (const [namespace, fields] of Object.entries(scope.namespaces)) if (Object.hasOwn(fields, fieldName)) {
+		if (found !== void 0) return void 0;
+		found = namespace;
+	}
+	return found;
+}
 function createFieldProxy(scope) {
 	return new Proxy({}, { get(_target, prop) {
 		if (Object.hasOwn(scope.topLevel, prop)) {
 			const topField = scope.topLevel[prop];
-			if (topField) return new ExpressionImpl(IdentifierRef.of(prop), topField);
+			if (topField) {
+				const namespace = findUniqueNamespaceFor$1(scope, prop);
+				const refs = namespace ? {
+					table: namespace,
+					column: prop
+				} : void 0;
+				return new ExpressionImpl(IdentifierRef.of(prop), topField, refs);
+			}
 		}
 		if (Object.hasOwn(scope.namespaces, prop)) {
 			const nsFields = scope.namespaces[prop];
@@ -46,42 +69,72 @@ const BOOL_FIELD = {
 	codecId: "pg/bool@1",
 	nullable: false
 };
-function resolve(value) {
-	if (value instanceof ExpressionImpl) return value.buildAst();
-	return ParamRef.of(value);
+const resolve = toExpr;
+/**
+* Resolve a binary-comparison operand into an AST expression, threading the column-bound side's `codecId` + `refs` to the raw-value side.
+*
+* For `fns.eq(f.email, 'alice@example.com')`, `f.email` is the column-bound expression carrying a `ColumnRef` AST and a `returnType.codecId` (`pg/varchar@1`); the raw string operand has no codec context. By deriving the codec context from the column-bound side and forwarding it via `toExpr(value, codecId, refs)`, the resulting `ParamRef` carries the column refs that encode-side `forColumn` dispatch needs (and that the
+* validator pass requires for parameterized codec ids like `pg/varchar@1` with a length parameter).
+*/
+function resolveOperand(operand, otherCodecId, otherRefs) {
+	if (isExpressionLike(operand)) return operand.buildAst();
+	return toExpr(operand, otherCodecId, otherRefs);
+}
+function isExpressionLike(value) {
+	return typeof value === "object" && value !== null && "buildAst" in value && typeof value.buildAst === "function";
+}
+function operandCodecId(operand) {
+	if (!isExpressionLike(operand)) return void 0;
+	return operand.returnType?.codecId;
 }
-function resolveToAst(value) {
-	if (value instanceof ExpressionImpl) return value.buildAst();
+function operandRefs(operand) {
+	return refsOf(operand);
+}
+/**
+* Resolves an Expression via `buildAst()`, or wraps a raw value as a `LiteralExpr` — an SQL literal inlined into the query text, not a bound parameter.
+*
+* Used for `and` / `or` operands. The usual operand is an `Expression<bool>` (e.g. the result of `fns.eq`), which this function passes through by calling `buildAst()`. The only time the raw-value branch fires is when the caller writes `fns.and(true, x)` or similar — inlining `TRUE`/`FALSE` literals lets the SQL planner statically simplify `TRUE AND x` to `x`, which it cannot do for an opaque `ParamRef`.
+*/
+function toLiteralExpr(value) {
+	if (typeof value === "object" && value !== null && "buildAst" in value && typeof value.buildAst === "function") return value.buildAst();
 	return new LiteralExpr(value);
 }
 function boolExpr(astNode) {
 	return new ExpressionImpl(astNode, BOOL_FIELD);
 }
+function binaryWithSharedCodec(a, b, build) {
+	const aCodecId = operandCodecId(a);
+	const bCodecId = operandCodecId(b);
+	const aRefs = operandRefs(a);
+	return build(resolveOperand(a, bCodecId, operandRefs(b)), resolveOperand(b, aCodecId, aRefs));
+}
 function eq(a, b) {
 	if (b === null) return boolExpr(NullCheckExpr.isNull(resolve(a)));
 	if (a === null) return boolExpr(NullCheckExpr.isNull(resolve(b)));
-	return boolExpr(new BinaryExpr("eq", resolve(a), resolve(b)));
+	return boolExpr(binaryWithSharedCodec(a, b, (l, r) => new BinaryExpr("eq", l, r)));
 }
 function ne(a, b) {
 	if (b === null) return boolExpr(NullCheckExpr.isNotNull(resolve(a)));
 	if (a === null) return boolExpr(NullCheckExpr.isNotNull(resolve(b)));
-	return boolExpr(new BinaryExpr("neq", resolve(a), resolve(b)));
+	return boolExpr(binaryWithSharedCodec(a, b, (l, r) => new BinaryExpr("neq", l, r)));
 }
 function comparison(a, b, op) {
-	return boolExpr(new BinaryExpr(op, resolve(a), resolve(b)));
+	return boolExpr(binaryWithSharedCodec(a, b, (l, r) => new BinaryExpr(op, l, r)));
 }
 function inOrNotIn(expr, valuesOrSubquery, op) {
 	const left = expr.buildAst();
+	const leftCodecId = expr.returnType.codecId;
+	const leftRefs = refsOf(expr);
 	const binaryFn = op === "in" ? BinaryExpr.in : BinaryExpr.notIn;
 	if (Array.isArray(valuesOrSubquery)) {
-		const refs = valuesOrSubquery.map((v) => resolve(v));
+		const refs = valuesOrSubquery.map((v) => resolveOperand(v, leftCodecId, leftRefs));
 		return boolExpr(binaryFn(left, ListExpression.of(refs)));
 	}
 	return boolExpr(binaryFn(left, SubqueryExpr.of(valuesOrSubquery.buildAst())));
 }
 function numericAgg(fn, expr) {
 	return new ExpressionImpl(AggregateExpr[fn](expr.buildAst()), {
-		codecId: expr.field.codecId,
+		codecId: expr.returnType.codecId,
 		nullable: true
 	});
 }
@@ -93,8 +146,8 @@ function createBuiltinFunctions() {
 		gte: (a, b) => comparison(a, b, "gte"),
 		lt: (a, b) => comparison(a, b, "lt"),
 		lte: (a, b) => comparison(a, b, "lte"),
-		and: (...exprs) => boolExpr(AndExpr.of(exprs.map(resolveToAst))),
-		or: (...exprs) => boolExpr(OrExpr.of(exprs.map(resolveToAst))),
+		and: (...exprs) => boolExpr(AndExpr.of(exprs.map(toLiteralExpr))),
+		or: (...exprs) => boolExpr(OrExpr.of(exprs.map(toLiteralExpr))),
 		exists: (subquery) => boolExpr(ExistsExpr.exists(subquery.buildAst())),
 		notExists: (subquery) => boolExpr(ExistsExpr.notExists(subquery.buildAst())),
 		in: (expr, valuesOrSubquery) => inOrNotIn(expr, valuesOrSubquery, "in"),
@@ -116,35 +169,17 @@ function createAggregateOnlyFunctions() {
 		max: (expr) => numericAgg("max", expr)
 	};
 }
-function createExtensionFunction(name, entry) {
-	return (...args) => {
-		const resolvedArgs = args.map((arg, i) => {
-			if (arg instanceof ExpressionImpl) return arg.buildAst();
-			const codecId = entry.args[i]?.codecId;
-			return ParamRef.of(arg, codecId ? { codecId } : void 0);
-		});
-		const self = resolvedArgs[0];
-		const restArgs = resolvedArgs.slice(1);
-		return new ExpressionImpl(new OperationExpr({
-			method: name,
-			self,
-			args: restArgs.length > 0 ? restArgs : void 0,
-			returns: entry.returns,
-			lowering: entry.lowering
-		}), entry.returns);
-	};
-}
-function createFunctions(queryOperationTypes) {
+function createFunctions(operations) {
 	const builtins = createBuiltinFunctions();
 	return new Proxy({}, { get(_target, prop) {
 		const builtin = builtins[prop];
 		if (builtin) return builtin;
-		const extOp = queryOperationTypes[prop];
-		if (extOp) return createExtensionFunction(prop, extOp);
+		const op = operations[prop];
+		if (op) return op.impl;
 	} });
 }
-function createAggregateFunctions(queryOperationTypes) {
-	const baseFns = createFunctions(queryOperationTypes);
+function createAggregateFunctions(operations) {
+	const baseFns = createFunctions(operations);
 	const aggregates = createAggregateOnlyFunctions();
 	return new Proxy({}, { get(_target, prop) {
 		const agg = aggregates[prop];
@@ -195,6 +230,17 @@ function combineWhereExprs(exprs) {
 	if (exprs.length === 1) return exprs[0];
 	return AndExpr.of(exprs);
 }
+/**
+* Same uniqueness rule as the field-proxy's `findUniqueNamespaceFor`: when exactly one namespace owns a top-level field, the binding is unambiguous. Used by `select('col', ...)` to attach `refs` metadata to the resulting `ProjectionItem` while keeping the AST as `IdentifierRef` (so SQL renders unchanged).
+*/
+function findUniqueNamespaceFor(scope, fieldName) {
+	let found;
+	for (const [namespace, fields] of Object.entries(scope.namespaces)) if (Object.hasOwn(fields, fieldName)) {
+		if (found !== void 0) return void 0;
+		found = namespace;
+	}
+	return found;
+}
 function buildSelectAst(state) {
 	const where = combineWhereExprs(state.where);
 	return new SelectAst({
@@ -212,36 +258,12 @@ function buildSelectAst(state) {
 		selectAllIntent: void 0
 	});
 }
-function buildQueryPlan(ast, rowFields, ctx) {
-	const projectionTypes = {};
-	const codecs = {};
-	for (const [alias, field] of Object.entries(rowFields)) {
-		projectionTypes[alias] = field.codecId;
-		codecs[alias] = field.codecId;
-	}
-	const paramRefs = ast.collectParamRefs();
-	const seen = /* @__PURE__ */ new Set();
-	const uniqueRefs = [];
-	for (const ref of paramRefs) if (!seen.has(ref)) {
-		seen.add(ref);
-		uniqueRefs.push(ref);
-	}
-	const paramValues = uniqueRefs.map((r) => r.value);
-	const paramDescriptors = uniqueRefs.map((ref, i) => ({
-		index: i + 1,
-		source: "dsl",
-		...ref.codecId ? { codecId: ref.codecId } : {}
-	}));
-	for (const [i, ref] of uniqueRefs.entries()) if (ref.codecId) codecs[`$${i + 1}`] = ref.codecId;
-	const hasProjectionTypes = Object.keys(projectionTypes).length > 0;
-	const hasCodecs = Object.keys(codecs).length > 0;
+function buildQueryPlan(ast, ctx) {
+	const paramValues = collectOrderedParamRefs(ast).map((r) => r.value);
 	const meta = Object.freeze({
 		target: ctx.target,
 		storageHash: ctx.storageHash,
-		lane: "dsl",
-		paramDescriptors,
-		...hasProjectionTypes ? { projectionTypes } : {},
-		...hasCodecs ? { annotations: Object.freeze({ codecs: Object.freeze(codecs) }) } : {}
+		lane: "dsl"
 	});
 	return Object.freeze({
 		ast,
@@ -250,7 +272,7 @@ function buildQueryPlan(ast, rowFields, ctx) {
 	});
 }
 function buildPlan(state, ctx) {
-	return buildQueryPlan(buildSelectAst(state), state.rowFields, ctx);
+	return buildQueryPlan(buildSelectAst(state), ctx);
 }
 function tableToScope(name, table) {
 	const fields = {};
@@ -314,7 +336,12 @@ function resolveSelectArgs(args, scope, ctx) {
 		for (const colName of args) {
 			const field = scope.topLevel[colName];
 			if (!field) throw new Error(`Column "${colName}" not found in scope`);
-			projections.push(ProjectionItem.of(colName, IdentifierRef.of(colName)));
+			const namespace = findUniqueNamespaceFor(scope, colName);
+			const refs = namespace ? {
+				table: namespace,
+				column: colName
+			} : void 0;
+			projections.push(ProjectionItem.of(colName, IdentifierRef.of(colName), field.codecId, refs));
 			newRowFields[colName] = field;
 		}
 		return {
@@ -327,8 +354,9 @@ function resolveSelectArgs(args, scope, ctx) {
 		const exprFn = args[1];
 		const fns = createAggregateFunctions(ctx.queryOperationTypes);
 		const result = exprFn(createFieldProxy(scope), fns);
-		projections.push(ProjectionItem.of(alias, result.buildAst()));
-		newRowFields[alias] = result.field;
+		const field = result.returnType;
+		projections.push(ProjectionItem.of(alias, result.buildAst(), field.codecId));
+		newRowFields[alias] = field;
 		return {
 			projections,
 			newRowFields
@@ -339,8 +367,9 @@ function resolveSelectArgs(args, scope, ctx) {
 		const fns = createAggregateFunctions(ctx.queryOperationTypes);
 		const record = callbackFn(createFieldProxy(scope), fns);
 		for (const [key, expr] of Object.entries(record)) {
-			projections.push(ProjectionItem.of(key, expr.buildAst()));
-			newRowFields[key] = expr.field;
+			const field = expr.returnType;
+			projections.push(ProjectionItem.of(key, expr.buildAst(), field.codecId));
+			newRowFields[key] = field;
 		}
 		return {
 			projections,
@@ -562,7 +591,13 @@ function buildParamValues(values, table, tableName, op, ctx) {
 	const params = {};
 	for (const [col, value] of Object.entries(values)) {
 		const column = table.columns[col];
-		params[col] = ParamRef.of(value, column ? { codecId: column.codecId } : void 0);
+		params[col] = ParamRef.of(value, column ? {
+			codecId: column.codecId,
+			refs: {
+				table: tableName,
+				column: col
+			}
+		} : void 0);
 	}
 	for (const def of ctx.applyMutationDefaults({
 		op,
@@ -570,12 +605,18 @@ function buildParamValues(values, table, tableName, op, ctx) {
 		values
 	})) {
 		const column = table.columns[def.column];
-		params[def.column] = ParamRef.of(def.value, column ? { codecId: column.codecId } : void 0);
+		params[def.column] = ParamRef.of(def.value, column ? {
+			codecId: column.codecId,
+			refs: {
+				table: tableName,
+				column: def.column
+			}
+		} : void 0);
 	}
 	return params;
 }
-function buildReturningColumnRefs(tableName, columns) {
-	return columns.map((col) => ColumnRef.of(tableName, col));
+function buildReturningProjections(tableName, columns, rowFields) {
+	return columns.map((col) => ProjectionItem.of(col, ColumnRef.of(tableName, col), rowFields[col]?.codecId));
 }
 function evaluateWhere(whereCallback, scope, queryOperationTypes) {
 	return whereCallback(createFieldProxy(scope), createFunctions(queryOperationTypes)).buildAst();
@@ -608,8 +649,8 @@ var InsertQueryImpl = class InsertQueryImpl extends BuilderBase {
 	build() {
 		const paramValues = buildParamValues(this.#values, this.#table, this.#tableName, "create", this.ctx);
 		let ast = InsertAst.into(TableSource.named(this.#tableName)).withValues(paramValues);
-		if (this.#returningColumns.length > 0) ast = ast.withReturning(buildReturningColumnRefs(this.#tableName, this.#returningColumns));
-		return buildQueryPlan(ast, this.#rowFields, this.ctx);
+		if (this.#returningColumns.length > 0) ast = ast.withReturning(buildReturningProjections(this.#tableName, this.#returningColumns, this.#rowFields));
+		return buildQueryPlan(ast, this.ctx);
 	}
 };
 var UpdateQueryImpl = class UpdateQueryImpl extends BuilderBase {
@@ -646,8 +687,8 @@ var UpdateQueryImpl = class UpdateQueryImpl extends BuilderBase {
 		const setParams = buildParamValues(this.#setValues, this.#table, this.#tableName, "update", this.ctx);
 		const whereExpr = combineWhereExprs(this.#whereCallbacks.map((cb) => evaluateWhere(cb, this.#scope, this.ctx.queryOperationTypes)));
 		let ast = UpdateAst.table(TableSource.named(this.#tableName)).withSet(setParams).withWhere(whereExpr);
-		if (this.#returningColumns.length > 0) ast = ast.withReturning(buildReturningColumnRefs(this.#tableName, this.#returningColumns));
-		return buildQueryPlan(ast, this.#rowFields, this.ctx);
+		if (this.#returningColumns.length > 0) ast = ast.withReturning(buildReturningProjections(this.#tableName, this.#returningColumns, this.#rowFields));
+		return buildQueryPlan(ast, this.ctx);
 	}
 };
 var DeleteQueryImpl = class DeleteQueryImpl extends BuilderBase {
@@ -679,8 +720,8 @@ var DeleteQueryImpl = class DeleteQueryImpl extends BuilderBase {
 	build() {
 		const whereExpr = combineWhereExprs(this.#whereCallbacks.map((cb) => evaluateWhere(cb, this.#scope, this.ctx.queryOperationTypes)));
 		let ast = DeleteAst.from(TableSource.named(this.#tableName)).withWhere(whereExpr);
-		if (this.#returningColumns.length > 0) ast = ast.withReturning(buildReturningColumnRefs(this.#tableName, this.#returningColumns));
-		return buildQueryPlan(ast, this.#rowFields, this.ctx);
+		if (this.#returningColumns.length > 0) ast = ast.withReturning(buildReturningProjections(this.#tableName, this.#returningColumns, this.#rowFields));
+		return buildQueryPlan(ast, this.ctx);
 	}
 };