@prisma/orm-family-sql 8.0.0-rc.17-dev.21 → 8.0.0-rc.17-dev.23

package/dist/builder.d.mts

@@ -1,3 +1,4 @@
-import { o as Expression, x as ScopeField } from "./expression-CvXfXCGs.mjs";
-import { C as TableProxy, D as WhereFilter, E as UpdateQuery, _ as ResolveRow, a as DeleteQuery, b as Subquery, c as GatedMethod, f as InsertQuery, i as Db, l as GroupedQuery, m as QueryContext, s as Functions, t as AggregateFunctions, v as Scope, y as SelectQuery } from "./db-DB1FVK1P-DbwoL7vg.mjs";
+import { o as Expression, x as ScopeField } from "./expression-Ck1wys3N-RNyviMcU.mjs";
+import { a as Subquery, r as Functions } from "./functions-CJ8Yf8uL.mjs";
+import { C as WhereFilter, S as UpdateQuery, d as QueryContext, g as SelectQuery, h as Scope, i as DeleteQuery, l as InsertQuery, m as ResolveRow, o as GatedMethod, r as Db, s as GroupedQuery, t as AggregateFunctions, y as TableProxy } from "./db-BmrN9nRS-DEogPltL.mjs";
 export type { AggregateFunctions, Db, DeleteQuery, Expression, Functions, GatedMethod, GroupedQuery, InsertQuery, QueryContext, ResolveRow, Scope, ScopeField, SelectQuery, Subquery, TableProxy, UpdateQuery, WhereFilter };

package/dist/builder__runtime.d.mts

@@ -1,36 +1,19 @@
 import { l as SqlStorage } from "./sql-storage-BTlJLUID-CGy3wuH4.mjs";
 import "./types-Uv3oTMAb.mjs";
 import { i as SqlOperationEntry } from "./index-We-mbWnZ.mjs";
-import { c as AnyExpression } from "./types-Sh5HuaZE-CqThc46M.mjs";
-import "./ast-Dp6lQXUX.mjs";
-import { l as RawCodecInferer, o as Expression, x as ScopeField } from "./expression-CvXfXCGs.mjs";
-import { h as RawLane, i as Db, m as QueryContext, o as FieldProxy, s as Functions, t as AggregateFunctions, v as Scope, w as TableProxyContract } from "./db-DB1FVK1P-DbwoL7vg.mjs";
-import { a as SqlAggregateDescriptorRegistry, n as ExecutionContext } from "./query-lane-context-CJoNBspB--ieuKEei.mjs";
-import "./query-lane-context-DNt2DeQu.mjs";
+import { l as RawCodecInferer } from "./expression-Ck1wys3N-RNyviMcU.mjs";
+import { t as ExpressionImpl } from "./expression-CNBCbbzU-BG3rv8Wb.mjs";
+import "./expression-DWcDQHh9.mjs";
+import { s as createFunctions } from "./functions-CJ8Yf8uL.mjs";
+import { a as FieldProxy, b as TableProxyContract, d as QueryContext, f as RawLane, h as Scope, r as Db, t as AggregateFunctions } from "./db-BmrN9nRS-DEogPltL.mjs";
+import { a as SqlAggregateDescriptorRegistry, n as ExecutionContext } from "./query-lane-context-C2AXsoFa-COSQOvZz.mjs";
+import "./query-lane-context-BsZs5lvB.mjs";
 import { Contract } from "@prisma/orm-framework/contract/types";
 //#region ../../../2-sql/4-lanes/sql-builder/dist/runtime/index.d.mts
-//#region src/runtime/expression-impl.d.ts
-/**
- * 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.
- *
- * `returnType.codec` records the column-bound codec ref 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.
- */
-declare class ExpressionImpl<T extends ScopeField = ScopeField> implements Expression<T> {
-  private readonly ast;
-  private readonly projectionAst;
-  readonly returnType: T;
-  constructor(ast: AnyExpression, returnType: T, projectionAst?: AnyExpression);
-  buildAst(): AnyExpression;
-  buildProjectionAst(): AnyExpression;
-}
-//#endregion
 //#region src/runtime/field-proxy.d.ts
 declare function createFieldProxy<S extends Scope>(scope: S): FieldProxy<S>;
 //#endregion
 //#region src/runtime/functions.d.ts
-declare function createFunctions<QC extends QueryContext>(operations: Readonly<Record<string, SqlOperationEntry>>, rawCodecInferer: RawCodecInferer): Functions<QC>;
 declare function createAggregateFunctions<QC extends QueryContext>(operations: Readonly<Record<string, SqlOperationEntry>>, rawCodecInferer: RawCodecInferer, aggregateRegistry: SqlAggregateDescriptorRegistry): AggregateFunctions<QC>;
 //#endregion
 //#region src/runtime/raw-lane.d.ts

package/dist/builder__runtime.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"builder__runtime.d.mts","names":[],"sources":["../../../../2-sql/4-lanes/sql-builder/dist/runtime/index.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;cAec,eAAe,UAAU,aAAa,uBAAuB,WAAW;mBACnE;mBACA;WACR,YAAY;EACrB,YAAY,KAAK,eAAe,YAAY,GAAG,gBAAgB;EAC/D,YAAY;EACZ,sBAAsB;;;;iBAIP,iBAAiB,UAAU,OAAO,OAAO,IAAI,WAAW;;;iBAGxD,gBAAgB,WAAW,cAAc,YAAY,SAAS,eAAe,qBAAqB,iBAAiB,kBAAkB,UAAU;iBAC/I,yBAAyB,WAAW,cAAc,YAAY,SAAS,eAAe,qBAAqB,iBAAiB,iBAAiB,mBAAmB,iCAAiC,mBAAmB;;;UAG3N,eAAe,UAAU,SAAS,cAAc;WAC/C,SAAS,iBAAiB;WAC1B,iBAAiB;;;;;;;;;;;;iBAYX,cAAc,UAAU,SAAS,cAAc,oBAAoB,SAAS,eAAe,KAAK,QAAQ;;;UAG/G,WAAW,UAAU,SAAS,cAAc;WAC3C,SAAS,iBAAiB;WAC1B,iBAAiB;;iBAEX,IAAI,UAAU,SAAS,cAAc,oBAAoB,SAAS,WAAW,KAAK,GAAG"}
+{"version":3,"file":"builder__runtime.d.mts","names":[],"sources":["../../../../2-sql/4-lanes/sql-builder/dist/runtime/index.d.mts"],"mappings":";;;;;;;;;;;;;iBAQiB,iBAAiB,UAAU,OAAO,OAAO,IAAI,WAAW;;;iBAGxD,yBAAyB,WAAW,cAAc,YAAY,SAAS,eAAe,qBAAqB,iBAAiB,iBAAiB,mBAAmB,iCAAiC,mBAAmB;;;UAG3N,eAAe,UAAU,SAAS,cAAc;WAC/C,SAAS,iBAAiB;WAC1B,iBAAiB;;;;;;;;;;;;iBAYX,cAAc,UAAU,SAAS,cAAc,oBAAoB,SAAS,eAAe,KAAK,QAAQ;;;UAG/G,WAAW,UAAU,SAAS,cAAc;WAC3C,SAAS,iBAAiB;WAC1B,iBAAiB;;iBAEX,IAAI,UAAU,SAAS,cAAc,oBAAoB,SAAS,WAAW,KAAK,GAAG"}

package/dist/builder__runtime.mjs

@@ -1,8 +1,10 @@
-import { A as ParamRef, C as LiteralExpr, E as NullCheckExpr, F as SelectAst, G as isOrderByNulls, I as SubqueryExpr, L as TableSource, M as ProjectionItem, O as OrExpr, R as UpdateAst, S as ListExpression, U as isAggregateFn, W as isOrderByDirection, _ as InsertAst, c as DeleteAst, g as IdentifierRef, k as OrderByItem, l as DerivedTableSource, n as AndExpr, o as ColumnRef, p as ExistsExpr, r as BinaryExpr, t as AggregateExpr, w as LockingClause, y as JoinAst } from "./types-NTQsD2MS-DAP2yVDn.mjs";
+import { A as ParamRef, F as SelectAst, G as isOrderByNulls, L as TableSource, M as ProjectionItem, R as UpdateAst, U as isAggregateFn, W as isOrderByDirection, _ as InsertAst, c as DeleteAst, g as IdentifierRef, k as OrderByItem, l as DerivedTableSource, n as AndExpr, o as ColumnRef, t as AggregateExpr, w as LockingClause, y as JoinAst } from "./types-NTQsD2MS-DAP2yVDn.mjs";
 import { r as isAggregateProjection, t as collectOrderedParamRefs } from "./util-BBgcP3gI-XJBkxo1K.mjs";
 import { C as lockStrengthCapabilities, S as lockOptionCapabilities, w as lockWaitPolicyOf, x as lockIncompatible } from "./ast-De8XGuVW.mjs";
-import { i as isExpression, n as codecOf, o as toExpr, r as createRawSql } from "./expression-JOe6lo4g.mjs";
+import { i as createRawSql, s as toExpr, t as ExpressionImpl } from "./expression-impl-B-XNINxr-vYwKVFeP.mjs";
 import { n as codecRefForStorageColumn } from "./codec-descriptor-registry-CYK0Wzja.mjs";
+import { t as createFunctions } from "./functions-0YWByawj.mjs";
+import { t as createIndexReferences } from "./index-reference-D693Lu-E.mjs";
 import { assertAnnotationsApplicable } from "@prisma/orm-framework/components/runtime";
 //#region ../../../2-sql/4-lanes/sql-builder/dist/runtime/index.mjs
 /**
@@ -43,6 +45,55 @@ import { assertAnnotationsApplicable } from "@prisma/orm-framework/components/ru
 function blindCast(input) {
 	return input;
 }
+function createFieldProxy(scope) {
+	return new Proxy(blindCast({}), { get(_target, prop) {
+		if (Object.hasOwn(scope.topLevel, prop)) {
+			const topField = scope.topLevel[prop];
+			if (topField) return new ExpressionImpl(IdentifierRef.of(prop), topField);
+		}
+		if (Object.hasOwn(scope.namespaces, prop)) {
+			const nsFields = scope.namespaces[prop];
+			if (nsFields) return createNamespaceProxy(prop, nsFields);
+		}
+	} });
+}
+function createNamespaceProxy(namespaceName, fields) {
+	return new Proxy({}, { get(_target, prop) {
+		if (Object.hasOwn(fields, prop)) {
+			const field = fields[prop];
+			if (field) return new ExpressionImpl(ColumnRef.of(namespaceName, prop), field);
+		}
+	} });
+}
+/**
+* A bug in Prisma 8, not a user error. Never catch this except at the
+* outermost boundary for crash reporting — an InternalError means an invariant
+* broke and the process cannot reliably continue. User-facing failures use
+* `structuredError` with a dotted code instead.
+*/
+var InternalError = class extends Error {
+	isPrismaInternalError = true;
+	constructor(message, options) {
+		super(message, options?.cause !== void 0 ? { cause: options.cause } : void 0);
+		this.name = "InternalError";
+	}
+};
+/**
+* Asserts that a value is defined (not null or undefined).
+* Use for invariants where the value should always exist at runtime.
+*
+* @throws Error if value is null or undefined
+*
+* @example
+* ```typescript
+* const table = storage.namespaces[namespaceId].entries.table[tableName];
+* assertDefined(table, `Table "${tableName}" not found`);
+* // table is now narrowed to non-nullable
+* ```
+*/
+function assertDefined(value, message) {
+	if (value === null || value === void 0) throw new InternalError(message);
+}
 /**
 * Returns an object with the key/value if value is defined, otherwise an empty object.
 *
@@ -86,29 +137,6 @@ function structuredError(code, message, options) {
 	});
 }
 /**
-* 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.
-*
-* `returnType.codec` records the column-bound codec ref 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;
-	constructor(ast, returnType, projectionAst) {
-		this.ast = ast;
-		this.returnType = returnType;
-		this.projectionAst = projectionAst;
-	}
-	buildAst() {
-		return this.ast;
-	}
-	buildProjectionAst() {
-		return this.projectionAst ?? this.ast;
-	}
-};
-/**
 * An aggregate whose operation lies outside the SQL aggregate alphabet: the expression exists only in its descriptor-lowered form, so only the projection may consume it.
 *
 * Predicate and ordering positions build the plain form through `buildAst()` and are refused at authoring time — the lowered rendering exists to carry the value across the driver boundary, and comparing or sorting by it inside the database would change SQL semantics (a textual rendering compares lexicographically).
@@ -133,108 +161,6 @@ var ProjectionOnlyExpressionImpl = class extends ExpressionImpl {
 function projectionAstOf(expr) {
 	return expr instanceof ExpressionImpl ? expr.buildProjectionAst() : expr.buildAst();
 }
-function createFieldProxy(scope) {
-	return new Proxy(blindCast({}), { get(_target, prop) {
-		if (Object.hasOwn(scope.topLevel, prop)) {
-			const topField = scope.topLevel[prop];
-			if (topField) return new ExpressionImpl(IdentifierRef.of(prop), topField);
-		}
-		if (Object.hasOwn(scope.namespaces, prop)) {
-			const nsFields = scope.namespaces[prop];
-			if (nsFields) return createNamespaceProxy(prop, nsFields);
-		}
-	} });
-}
-function createNamespaceProxy(namespaceName, fields) {
-	return new Proxy({}, { get(_target, prop) {
-		if (Object.hasOwn(fields, prop)) {
-			const field = fields[prop];
-			if (field) return new ExpressionImpl(ColumnRef.of(namespaceName, prop), field);
-		}
-	} });
-}
-/**
-* A bug in Prisma 8, not a user error. Never catch this except at the
-* outermost boundary for crash reporting — an InternalError means an invariant
-* broke and the process cannot reliably continue. User-facing failures use
-* `structuredError` with a dotted code instead.
-*/
-var InternalError = class extends Error {
-	isPrismaInternalError = true;
-	constructor(message, options) {
-		super(message, options?.cause !== void 0 ? { cause: options.cause } : void 0);
-		this.name = "InternalError";
-	}
-};
-/**
-* Asserts that a value is defined (not null or undefined).
-* Use for invariants where the value should always exist at runtime.
-*
-* @throws Error if value is null or undefined
-*
-* @example
-* ```typescript
-* const table = storage.namespaces[namespaceId].entries.table[tableName];
-* assertDefined(table, `Table "${tableName}" not found`);
-* // table is now narrowed to non-nullable
-* ```
-*/
-function assertDefined(value, message) {
-	if (value === null || value === void 0) throw new InternalError(message);
-}
-const BOOL_FIELD = {
-	codecId: "pg/bool@1",
-	nullable: false
-};
-const resolve = toExpr;
-/**
-* Resolve a binary-comparison operand into an AST expression, threading the column-bound side's {@link CodecRef} 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 `CodecRef` derived from contract storage; the raw string operand has no codec context. By deriving the codec context from the column-bound side and forwarding it via `toExpr(value, codec)`, the resulting `ParamRef` carries the `CodecRef` that encode-side dispatch needs to materialise the per-instance codec for parameterized codec ids (`vector(1024)` vs. `vector(1536)`).
-*/
-function resolveOperand(operand, otherCodec) {
-	if (isExpression(operand)) return operand.buildAst();
-	return toExpr(operand, otherCodec);
-}
-/**
-* 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 (isExpression(value)) return value.buildAst();
-	return new LiteralExpr(value);
-}
-function boolExpr(astNode) {
-	return new ExpressionImpl(astNode, BOOL_FIELD);
-}
-function binaryWithSharedCodec(a, b, build) {
-	const aCodec = codecOf(a);
-	return build(resolveOperand(a, codecOf(b)), resolveOperand(b, aCodec));
-}
-function eq(a, b) {
-	if (b === null) return boolExpr(NullCheckExpr.isNull(resolve(a)));
-	if (a === null) return boolExpr(NullCheckExpr.isNull(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(binaryWithSharedCodec(a, b, (l, r) => new BinaryExpr("neq", l, r)));
-}
-function comparison(a, b, op) {
-	return boolExpr(binaryWithSharedCodec(a, b, (l, r) => new BinaryExpr(op, l, r)));
-}
-function inOrNotIn(expr, valuesOrSubquery, op) {
-	const left = expr.buildAst();
-	const leftCodec = codecOf(expr);
-	const binaryFn = op === "in" ? BinaryExpr.in : BinaryExpr.notIn;
-	if (Array.isArray(valuesOrSubquery)) {
-		const refs = valuesOrSubquery.map((v) => resolveOperand(v, leftCodec));
-		return boolExpr(binaryFn(left, ListExpression.of(refs)));
-	}
-	return boolExpr(binaryFn(left, SubqueryExpr.of(valuesOrSubquery.buildAst())));
-}
 /**
 * Build an aggregate through the target's own answer for it.
 *
@@ -292,23 +218,6 @@ function aggregate(aggregates, operation, expr) {
 	});
 	return new ExpressionImpl(ast, returnType, projectionAst);
 }
-function createBuiltinFunctions(rawCodecInferer) {
-	return {
-		eq: (a, b) => eq(a, b),
-		ne: (a, b) => ne(a, b),
-		gt: (a, b) => comparison(a, b, "gt"),
-		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(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"),
-		notIn: (expr, valuesOrSubquery) => inOrNotIn(expr, valuesOrSubquery, "notIn"),
-		raw: createRawSql(rawCodecInferer)
-	};
-}
 /**
 * The aggregate implementations, one per operation the registry contributes,
 * erased.
@@ -328,14 +237,6 @@ function createAggregateOnlyFunctions(aggregates) {
 	}
 	return Object.fromEntries(methods);
 }
-function createFunctions(operations, rawCodecInferer) {
-	const builtins = createBuiltinFunctions(rawCodecInferer);
-	return new Proxy(blindCast({}), { get(_target, prop) {
-		if (Object.hasOwn(builtins, prop)) return blindCast(builtins)[prop];
-		const op = operations[prop];
-		if (op) return op.impl;
-	} });
-}
 function createAggregateFunctions(operations, rawCodecInferer, aggregateRegistry) {
 	const baseFns = createFunctions(operations, rawCodecInferer);
 	const aggregates = createAggregateOnlyFunctions(aggregateRegistry);
@@ -1161,41 +1062,16 @@ var TableProxyImpl = class TableProxyImpl extends BuilderBase {
 	#indexReferences() {
 		const fields = this.#scope.namespaces[this.#alias];
 		assertDefined(fields, "a table proxy scopes its own alias");
-		const byName = /* @__PURE__ */ new Map();
-		for (const index of this.#table.indexes) {
-			const authoredName = index.prefix ?? index.name;
-			const columns = Object.fromEntries((index.columns ?? []).map((column) => {
+		return blindCast(createIndexReferences({
+			namespaceId: this.#namespaceId,
+			tableName: this.#tableName,
+			table: this.#table,
+			column: (column) => {
 				const field = fields[column];
-				assertDefined(field, `index "${index.name}" covers a column of its table`);
-				return [column, new ExpressionImpl(ColumnRef.of(this.#alias, column), field)];
-			}));
-			const reference = Object.freeze({
-				columns: Object.freeze(columns),
-				type: index.type,
-				options: index.options
-			});
-			byName.set(authoredName, [...byName.get(authoredName) ?? [], reference]);
-		}
-		const references = {};
-		for (const [authoredName, [reference, ...others]] of byName) Object.defineProperty(references, authoredName, {
-			enumerable: true,
-			get: () => {
-				if (others.length > 0) throw this.#ambiguousIndexName(authoredName);
-				return reference;
-			}
-		});
-		return blindCast(Object.freeze(references));
-	}
-	#ambiguousIndexName(authoredName) {
-		return structuredError("ORM.ARGUMENT_INVALID", `Table "${this.#tableName}" has more than one index named "${authoredName}".`, {
-			why: "An index is read by the name its contract source gave it, and these indexes share that name.",
-			fix: `Give each of these indexes of table "${this.#tableName}" its own name in the contract source.`,
-			meta: {
-				namespaceId: this.#namespaceId,
-				tableName: this.#tableName,
-				index: authoredName
+				assertDefined(field, `an index covers a column of table "${this.#tableName}"`);
+				return new ExpressionImpl(ColumnRef.of(this.#alias, column), field);
 			}
-		});
+		}));
 	}
 	lateralJoin = this._gate({ sql: { lateral: true } }, "lateralJoin", (alias, builder) => {
 		return this.#toJoined().lateralJoin(alias, builder);