@prisma/orm-family-sql 0.17.0-dev.1 → 0.17.0-dev.2

package/dist/builder__runtime.mjs

@@ -1,6 +1,6 @@
-import { C as LiteralExpr, D as OrExpr, F as SubqueryExpr, I as TableSource, L as UpdateAst, O as OrderByItem, P as SelectAst, S as ListExpression, T as NullCheckExpr, _ as InsertAst, c as DeleteAst, g as IdentifierRef, j as ProjectionItem, k as ParamRef, l as DerivedTableSource, n as AndExpr, o as ColumnRef, p as ExistsExpr, r as BinaryExpr, t as AggregateExpr, y as JoinAst } from "./types-BgkZru_1-H7yfikSQ.mjs";
+import { C as LiteralExpr, D as OrExpr, F as SubqueryExpr, I as TableSource, L as UpdateAst, O as OrderByItem, P as SelectAst, S as ListExpression, T as NullCheckExpr, _ as InsertAst, c as DeleteAst, g as IdentifierRef, j as ProjectionItem, k as ParamRef, l as DerivedTableSource, n as AndExpr, o as ColumnRef, p as ExistsExpr, r as BinaryExpr, t as AggregateExpr, y as JoinAst } from "./types-D43EhRac-DOJmnq_t.mjs";
 import { t as collectOrderedParamRefs } from "./util-DQQgv2j1-D6INZaRG.mjs";
-import { a as toExpr, n as codecOf, r as createRawSql } from "./expression-RUO52bJB.mjs";
+import { a as toExpr, n as codecOf, r as createRawSql } from "./expression-Dhu3dLiu.mjs";
 import { n as codecRefForStorageColumn } from "./codec-descriptor-registry-BJVJRftS.mjs";
 import { assertAnnotationsApplicable } from "@prisma/orm-framework/components/runtime";
 //#region ../../../2-sql/4-lanes/sql-builder/dist/runtime/index.mjs
@@ -8,20 +8,33 @@ import { assertAnnotationsApplicable } from "@prisma/orm-framework/components/ru
 * 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.
 *
 * `codec` records the column-bound {@link CodecRef} when the field-proxy knows the binding — both the namespaced form (`f.user.email` → `ColumnRef`) and the top-level shortcut (`f.email` → `IdentifierRef`) stamp the ref derived from contract storage. `codecOf(expression)` exposes it for operation implementations forwarding the ref to `toExpr`.
+*
+* `projectionAst` carries the descriptor-lowered rendering of the expression, where a target declares one (e.g. SQLite's `CAST(count(*) AS TEXT)`). Lowering exists to carry the value across the driver boundary, so only the projection site consumes it — predicate and ordering positions (`buildAst()`) keep the plain form, where the rendering would change SQL semantics.
 */
 var ExpressionImpl = class {
 	ast;
+	projectionAst;
 	returnType;
 	codec;
-	constructor(ast, returnType, codec) {
+	constructor(ast, returnType, codec, projectionAst) {
 		this.ast = ast;
 		this.returnType = returnType;
 		this.codec = codec;
+		this.projectionAst = projectionAst;
 	}
 	buildAst() {
 		return this.ast;
 	}
+	buildProjectionAst() {
+		return this.projectionAst ?? this.ast;
+	}
 };
+/**
+* The AST to project for an expression: the descriptor-lowered form when the expression carries one, the plain form otherwise. `resolveSelectArgs` calls this where a lane expression becomes a `ProjectionItem` — the one place the value crosses the driver boundary.
+*/
+function projectionAstOf(expr) {
+	return expr instanceof ExpressionImpl ? expr.buildProjectionAst() : expr.buildAst();
+}
 function createFieldProxy(scope) {
 	return new Proxy({}, { get(_target, prop) {
 		if (Object.hasOwn(scope.topLevel, prop)) {
@@ -42,6 +55,85 @@ function createNamespaceProxy(namespaceName, fields) {
 		}
 	} });
 }
+/**
+* **Last-resort escape hatch for unsafe type assertions. Not a sanctioned tool to reach for.**
+*
+* Before reaching for `blindCast`, **rewrite the surrounding code so the cast becomes
+* unnecessary**: tighten an input type, add a runtime check that narrows via a type
+* predicate, restructure a generic so the compiler can see the relationship you're
+* asserting, or use {@link castAs} when the value already satisfies the target type.
+* Only when no rewrite is feasible does `blindCast` become the right answer — and at
+* that point, the `Reason` literal you supply must articulate the compromise in
+* language a reviewer can evaluate.
+*
+* The reviewer **will** validate the `Reason`. If it doesn't hold up under scrutiny,
+* that is not a signal to soften the reason; it is a signal to go back and solve the
+* underlying type-system problem properly. An unconvincing justification is rework,
+* not a free pass.
+*
+* `blindCast` is the auditable form of `as Foo` / `as unknown as Foo`: it bypasses
+* the compiler's checks (the input type is `unknown`, the output type is whatever the
+* caller asks for), but it forces the unsafety to be named at the call site instead of
+* smuggled in via a bare `as`. The `Reason` type parameter exists only at compile
+* time — it is not present in the emitted JavaScript — but it is grep-able and
+* visible to future readers.
+*
+* @example
+* ```typescript
+* const stringValue = blindCast<
+*   string,
+*   "JSON.parse returns `unknown`; this field is documented to be a string in the API contract"
+* >(parsed[key]);
+* ```
+*
+* @typeParam TargetType - The type the caller is asserting the input has.
+* @typeParam _Reason - A string literal describing why bypassing the type system is necessary here.
+*                     Only meaningful at compile time. The reviewer evaluates whether it justifies the unsafety.
+*/
+function blindCast(input) {
+	return input;
+}
+/**
+* Returns an object with the key/value if value is defined, otherwise an empty object.
+*
+* Use with spread to conditionally include optional properties while satisfying
+* exactOptionalPropertyTypes. This is explicit about which properties are optional
+* and won't inadvertently strip other undefined values.
+*
+* @example
+* ```typescript
+* // Instead of:
+* const obj = {
+*   required: 'value',
+*   ...(optional ? { optional } : {}),
+* };
+*
+* // Use:
+* const obj = {
+*   required: 'value',
+*   ...ifDefined('optional', optional),
+* };
+* ```
+*/
+function ifDefined(key, value) {
+	return value !== void 0 ? blindCast({ [key]: value }) : {};
+}
+function structuredError(code, message, options) {
+	const error = options?.cause !== void 0 ? new Error(message, { cause: options.cause }) : new Error(message);
+	Object.defineProperty(error, "name", {
+		value: "StructuredError",
+		configurable: true
+	});
+	return Object.assign(error, {
+		code,
+		...ifDefined("why", options?.why),
+		...ifDefined("fix", options?.fix),
+		...ifDefined("where", options?.where),
+		...ifDefined("severity", options?.severity),
+		...ifDefined("meta", options?.meta),
+		...ifDefined("docsUrl", options?.docsUrl)
+	});
+}
 const BOOL_FIELD = {
 	codecId: "pg/bool@1",
 	nullable: false
@@ -98,11 +190,50 @@ function inOrNotIn(expr, valuesOrSubquery, op) {
 	}
 	return boolExpr(binaryFn(left, SubqueryExpr.of(valuesOrSubquery.buildAst())));
 }
-function numericAgg(fn, expr) {
-	return new ExpressionImpl(AggregateExpr[fn](expr.buildAst()), {
-		codecId: expr.returnType.codecId,
-		nullable: true
+/**
+* Build an aggregate through the target's own answer for it.
+*
+* What an aggregate returns is neither the input's codec nor a fixed id: a
+* target widens `sum` over small integers, takes `avg` somewhere else again,
+* and may want the result rendered a particular way. All three come from the
+* registry, and the result carries the codec it declared so decoding resolves
+* through the ordinary path.
+*
+* The declared rendering (`lower`) exists to carry the value across the driver
+* boundary — a projection concern. It is carried beside the plain form so only
+* the projection site consumes it; HAVING and ORDER BY compare the value inside
+* the database, where the rendering would change SQL semantics (SQLite's
+* `CAST(count(*) AS TEXT)` compares and sorts lexicographically).
+*
+* A pair the target declares no overload for is rejected outright. The typed
+* surface already makes it inexpressible; this backs that up for dynamic
+* invocation, instead of executing SQL whose result no declaration types or
+* decodes — SQLite's `sum` over text, which reads whatever leading numbers the
+* rows happened to hold, is the shape of value that path would hand back.
+*/
+function aggregate(aggregates, fn, expr) {
+	const field = expr?.returnType;
+	const inputCodec = field === void 0 ? void 0 : field.codec ?? { codecId: field.codecId };
+	const resolved = aggregates.resolve(fn, inputCodec);
+	if (resolved === void 0) throw structuredError("ORM.AGGREGATE_UNSUPPORTED", inputCodec === void 0 ? `The composed target declares no '${fn}' aggregate for a call without an input.` : `The composed target declares no '${fn}' aggregate over codec '${inputCodec.codecId}'.`, {
+		why: "An aggregate result decodes through the codec its target declares; an undeclared pair has no declared result to type or decode.",
+		fix: `Aggregate an input the target declares '${fn}' for, or contribute an aggregate descriptor for this pair.`,
+		meta: {
+			operation: fn,
+			...ifDefined("inputCodecId", inputCodec?.codecId)
+		}
 	});
+	const inputAst = expr?.buildAst();
+	const ast = new AggregateExpr(fn, inputAst);
+	const projectionAst = resolved.lower?.({
+		expr: inputAst,
+		inputCodec
+	});
+	return new ExpressionImpl(ast, {
+		codecId: resolved.output.codecId,
+		nullable: resolved.nullable,
+		codec: resolved.output
+	}, void 0, projectionAst);
 }
 function createBuiltinFunctions(rawCodecInferer) {
 	return {
@@ -121,19 +252,20 @@ function createBuiltinFunctions(rawCodecInferer) {
 		raw: createRawSql(rawCodecInferer)
 	};
 }
-function createAggregateOnlyFunctions() {
+/**
+* The aggregate implementations, erased.
+*
+* What each returns is the contract's answer — a function of the target's map
+* and the input's codec — which no runtime value can state. The typed surface
+* is `AggregateFunctions<QC>`, applied where these are handed out.
+*/
+function createAggregateOnlyFunctions(aggregates) {
 	return {
-		count: (expr) => {
-			const astExpr = expr ? expr.buildAst() : void 0;
-			return new ExpressionImpl(AggregateExpr.count(astExpr), {
-				codecId: "pg/int8@1",
-				nullable: false
-			});
-		},
-		sum: (expr) => numericAgg("sum", expr),
-		avg: (expr) => numericAgg("avg", expr),
-		min: (expr) => numericAgg("min", expr),
-		max: (expr) => numericAgg("max", expr)
+		count: (expr) => aggregate(aggregates, "count", expr),
+		sum: (expr) => aggregate(aggregates, "sum", expr),
+		avg: (expr) => aggregate(aggregates, "avg", expr),
+		min: (expr) => aggregate(aggregates, "min", expr),
+		max: (expr) => aggregate(aggregates, "max", expr)
 	};
 }
 function createFunctions(operations, rawCodecInferer) {
@@ -144,9 +276,9 @@ function createFunctions(operations, rawCodecInferer) {
 		if (op) return op.impl;
 	} });
 }
-function createAggregateFunctions(operations, rawCodecInferer) {
+function createAggregateFunctions(operations, rawCodecInferer, aggregateRegistry) {
 	const baseFns = createFunctions(operations, rawCodecInferer);
-	const aggregates = createAggregateOnlyFunctions();
+	const aggregates = createAggregateOnlyFunctions(aggregateRegistry);
 	return new Proxy({}, { get(_target, prop) {
 		const agg = aggregates[prop];
 		if (agg) return agg;
@@ -160,85 +292,6 @@ function resolveTableInNamespace(storage, namespaceId, tableName) {
 	if (tables === void 0 || !Object.hasOwn(tables, tableName)) return void 0;
 	return tables[tableName];
 }
-/**
-* **Last-resort escape hatch for unsafe type assertions. Not a sanctioned tool to reach for.**
-*
-* Before reaching for `blindCast`, **rewrite the surrounding code so the cast becomes
-* unnecessary**: tighten an input type, add a runtime check that narrows via a type
-* predicate, restructure a generic so the compiler can see the relationship you're
-* asserting, or use {@link castAs} when the value already satisfies the target type.
-* Only when no rewrite is feasible does `blindCast` become the right answer — and at
-* that point, the `Reason` literal you supply must articulate the compromise in
-* language a reviewer can evaluate.
-*
-* The reviewer **will** validate the `Reason`. If it doesn't hold up under scrutiny,
-* that is not a signal to soften the reason; it is a signal to go back and solve the
-* underlying type-system problem properly. An unconvincing justification is rework,
-* not a free pass.
-*
-* `blindCast` is the auditable form of `as Foo` / `as unknown as Foo`: it bypasses
-* the compiler's checks (the input type is `unknown`, the output type is whatever the
-* caller asks for), but it forces the unsafety to be named at the call site instead of
-* smuggled in via a bare `as`. The `Reason` type parameter exists only at compile
-* time — it is not present in the emitted JavaScript — but it is grep-able and
-* visible to future readers.
-*
-* @example
-* ```typescript
-* const stringValue = blindCast<
-*   string,
-*   "JSON.parse returns `unknown`; this field is documented to be a string in the API contract"
-* >(parsed[key]);
-* ```
-*
-* @typeParam TargetType - The type the caller is asserting the input has.
-* @typeParam _Reason - A string literal describing why bypassing the type system is necessary here.
-*                     Only meaningful at compile time. The reviewer evaluates whether it justifies the unsafety.
-*/
-function blindCast(input) {
-	return input;
-}
-/**
-* Returns an object with the key/value if value is defined, otherwise an empty object.
-*
-* Use with spread to conditionally include optional properties while satisfying
-* exactOptionalPropertyTypes. This is explicit about which properties are optional
-* and won't inadvertently strip other undefined values.
-*
-* @example
-* ```typescript
-* // Instead of:
-* const obj = {
-*   required: 'value',
-*   ...(optional ? { optional } : {}),
-* };
-*
-* // Use:
-* const obj = {
-*   required: 'value',
-*   ...ifDefined('optional', optional),
-* };
-* ```
-*/
-function ifDefined(key, value) {
-	return value !== void 0 ? blindCast({ [key]: value }) : {};
-}
-function structuredError(code, message, options) {
-	const error = options?.cause !== void 0 ? new Error(message, { cause: options.cause }) : new Error(message);
-	Object.defineProperty(error, "name", {
-		value: "StructuredError",
-		configurable: true
-	});
-	return Object.assign(error, {
-		code,
-		...ifDefined("why", options?.why),
-		...ifDefined("fix", options?.fix),
-		...ifDefined("where", options?.where),
-		...ifDefined("severity", options?.severity),
-		...ifDefined("meta", options?.meta),
-		...ifDefined("docsUrl", options?.docsUrl)
-	});
-}
 var BuilderBase = class {
 	ctx;
 	constructor(ctx) {
@@ -407,10 +460,10 @@ function resolveSelectArgs(args, scope, ctx) {
 	if (typeof args[0] === "string" && typeof args[1] === "function") {
 		const alias = args[0];
 		const exprFn = args[1];
-		const fns = createAggregateFunctions(ctx.queryOperationTypes, ctx.rawCodecInferer);
+		const fns = createAggregateFunctions(ctx.queryOperationTypes, ctx.rawCodecInferer, ctx.aggregates);
 		const result = exprFn(createFieldProxy(scope), fns);
 		const field = result.returnType;
-		projections.push(ProjectionItem.of(alias, result.buildAst(), field.codec));
+		projections.push(ProjectionItem.of(alias, projectionAstOf(result), field.codec));
 		newRowFields[alias] = field;
 		return {
 			projections,
@@ -419,11 +472,11 @@ function resolveSelectArgs(args, scope, ctx) {
 	}
 	if (typeof args[0] === "function") {
 		const callbackFn = args[0];
-		const fns = createAggregateFunctions(ctx.queryOperationTypes, ctx.rawCodecInferer);
+		const fns = createAggregateFunctions(ctx.queryOperationTypes, ctx.rawCodecInferer, ctx.aggregates);
 		const record = callbackFn(createFieldProxy(scope), fns);
 		for (const [key, expr] of Object.entries(record)) {
 			const field = expr.returnType;
-			projections.push(ProjectionItem.of(key, expr.buildAst(), field.codec));
+			projections.push(ProjectionItem.of(key, projectionAstOf(expr), field.codec));
 			newRowFields[key] = field;
 		}
 		return {
@@ -442,7 +495,7 @@ function resolveOrderBy(arg, options, scope, rowFields, ctx, useAggregateFns) {
 	}
 	if (typeof arg === "function") {
 		const combined = orderByScopeOf(scope, rowFields);
-		const fns = useAggregateFns ? createAggregateFunctions(ctx.queryOperationTypes, ctx.rawCodecInferer) : createFunctions(ctx.queryOperationTypes, ctx.rawCodecInferer);
+		const fns = useAggregateFns ? createAggregateFunctions(ctx.queryOperationTypes, ctx.rawCodecInferer, ctx.aggregates) : createFunctions(ctx.queryOperationTypes, ctx.rawCodecInferer);
 		const result = arg(createFieldProxy(combined), fns);
 		return dir === "asc" ? OrderByItem.asc(result.buildAst()) : OrderByItem.desc(result.buildAst());
 	}
@@ -574,7 +627,7 @@ var GroupedQueryImpl = class GroupedQueryImpl extends QueryBase {
 	}
 	having(expr) {
 		const combined = orderByScopeOf(this.state.scope, this.state.rowFields);
-		const fns = createAggregateFunctions(this.ctx.queryOperationTypes, this.ctx.rawCodecInferer);
+		const fns = createAggregateFunctions(this.ctx.queryOperationTypes, this.ctx.rawCodecInferer, this.ctx.aggregates);
 		const result = expr(createFieldProxy(combined), fns);
 		return new GroupedQueryImpl(cloneState(this.state, { having: result.buildAst() }), this.ctx);
 	}
@@ -935,7 +988,8 @@ function sql(options) {
 		storageHash: context.contract.storage.storageHash ?? "unknown",
 		storage: context.contract.storage,
 		applyMutationDefaults: (options) => context.applyMutationDefaults(options),
-		rawCodecInferer
+		rawCodecInferer,
+		aggregates: context.aggregateDescriptors
 	};
 	const { storage } = context.contract;
 	return new Proxy({}, { get(_target, prop) {