@prisma-next/sql-orm-client 0.5.0-dev.60 → 0.5.0-dev.61

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "@prisma-next/sql-orm-client",
-  "version": "0.5.0-dev.60",
+  "version": "0.5.0-dev.61",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "ORM client for Prisma Next — fluent, type-safe model collections",
   "dependencies": {
-    "@prisma-next/contract": "0.5.0-dev.60",
-    "@prisma-next/framework-components": "0.5.0-dev.60",
-    "@prisma-next/sql-relational-core": "0.5.0-dev.60",
-    "@prisma-next/operations": "0.5.0-dev.60",
-    "@prisma-next/sql-runtime": "0.5.0-dev.60",
-    "@prisma-next/sql-operations": "0.5.0-dev.60",
-    "@prisma-next/utils": "0.5.0-dev.60",
-    "@prisma-next/sql-contract": "0.5.0-dev.60"
+    "@prisma-next/contract": "0.5.0-dev.61",
+    "@prisma-next/framework-components": "0.5.0-dev.61",
+    "@prisma-next/operations": "0.5.0-dev.61",
+    "@prisma-next/sql-operations": "0.5.0-dev.61",
+    "@prisma-next/sql-relational-core": "0.5.0-dev.61",
+    "@prisma-next/sql-contract": "0.5.0-dev.61",
+    "@prisma-next/utils": "0.5.0-dev.61",
+    "@prisma-next/sql-runtime": "0.5.0-dev.61"
   },
   "devDependencies": {
     "@types/pg": "8.16.0",
@@ -21,17 +21,17 @@
     "tsdown": "0.18.4",
     "typescript": "5.9.3",
     "vitest": "4.0.17",
-    "@prisma-next/adapter-postgres": "0.5.0-dev.60",
-    "@prisma-next/driver-postgres": "0.5.0-dev.60",
-    "@prisma-next/cli": "0.5.0-dev.60",
-    "@prisma-next/ids": "0.5.0-dev.60",
-    "@prisma-next/sql-contract-ts": "0.5.0-dev.60",
-    "@prisma-next/target-postgres": "0.5.0-dev.60",
-    "@prisma-next/family-sql": "0.5.0-dev.60",
-    "@prisma-next/test-utils": "0.0.1",
+    "@prisma-next/adapter-postgres": "0.5.0-dev.61",
+    "@prisma-next/cli": "0.5.0-dev.61",
+    "@prisma-next/driver-postgres": "0.5.0-dev.61",
+    "@prisma-next/extension-pgvector": "0.5.0-dev.61",
+    "@prisma-next/family-sql": "0.5.0-dev.61",
+    "@prisma-next/sql-contract-ts": "0.5.0-dev.61",
+    "@prisma-next/ids": "0.5.0-dev.61",
+    "@prisma-next/target-postgres": "0.5.0-dev.61",
     "@prisma-next/tsconfig": "0.0.0",
     "@prisma-next/tsdown": "0.0.0",
-    "@prisma-next/extension-pgvector": "0.5.0-dev.60"
+    "@prisma-next/test-utils": "0.0.1"
   },
   "files": [
     "dist",

package/src/query-plan-mutations.ts

@@ -51,7 +51,11 @@ function toParamAssignments(
     if (!codecId) {
       throw new Error(`Unknown column "${column}" in table "${tableName}"`);
     }
-    assignments[column] = ParamRef.of(value, { name: column, codecId });
+    assignments[column] = ParamRef.of(value, {
+      name: column,
+      codecId,
+      refs: { table: tableName, column },
+    });
   }
 
   return { assignments };
@@ -97,7 +101,11 @@ function normalizeInsertRows(
         if (!codecId) {
           throw new Error(`Unknown column "${column}" in table "${tableName}"`);
         }
-        normalizedRow[column] = ParamRef.of(row[column], { name: column, codecId });
+        normalizedRow[column] = ParamRef.of(row[column], {
+          name: column,
+          codecId,
+          refs: { table: tableName, column },
+        });
         continue;
       }
       normalizedRow[column] = new DefaultValueExpr();
@@ -143,11 +151,7 @@ function stripUndefinedValues(row: Record<string, unknown>): Record<string, unkn
   return result;
 }
 
-// Groups rows by their set of present columns so each group can be emitted as a
-// single INSERT statement. Groups are created in input order — rows with the same
-// signature that are non-adjacent produce separate groups. This is deliberate:
-// preserving insertion order ensures autogenerated/autoincrement columns are
-// assigned in the same order as the caller's input.
+// Groups rows by their set of present columns so each group can be emitted as a single INSERT statement. Groups are created in input order — rows with the same signature that are non-adjacent produce separate groups. This is deliberate: preserving insertion order ensures autogenerated/autoincrement columns are assigned in the same order as the caller's input.
 function groupRowsByColumnSignature(
   rows: readonly Record<string, unknown>[],
 ): ReadonlyArray<readonly Record<string, unknown>[]> {

package/src/types.ts

@@ -19,12 +19,9 @@ import {
 import type { Expression } from '@prisma-next/sql-relational-core/expression';
 import type { ExecutionContext } from '@prisma-next/sql-relational-core/query-lane-context';
 import type { ComputeColumnJsType, RuntimeScope } from '@prisma-next/sql-relational-core/types';
+import { ifDefined } from '@prisma-next/utils/defined';
 import type { RowSelection } from './collection-internal-types';
 
-// ---------------------------------------------------------------------------
-// Comparison / Filter / Order / Include
-// ---------------------------------------------------------------------------
-
 export type AggregateFn = 'count' | 'sum' | 'avg' | 'min' | 'max';
 
 export interface IncludeScalar<Result> extends RowSelection<Result> {
@@ -64,10 +61,6 @@ export interface IncludeExpr {
   readonly combine: Readonly<Record<string, IncludeCombineBranch>> | undefined;
 }
 
-// ---------------------------------------------------------------------------
-// CollectionState — plain data, no query builder types
-// ---------------------------------------------------------------------------
-
 export interface CollectionState {
   readonly filters: readonly AnyExpression[];
   readonly includes: readonly IncludeExpr[];
@@ -112,10 +105,6 @@ export type DefaultCollectionTypeState = {
   readonly variantName: undefined;
 };
 
-// ---------------------------------------------------------------------------
-// CollectionContext — bundles lane context + runtime
-// ---------------------------------------------------------------------------
-
 export interface RuntimeConnection extends RuntimeScope {
   release?(): Promise<void>;
   transaction?(): Promise<RuntimeTransaction>;
@@ -136,10 +125,6 @@ export interface CollectionContext<TContract extends Contract<SqlStorage>> {
   readonly context: ExecutionContext<TContract>;
 }
 
-// ---------------------------------------------------------------------------
-// ModelAccessor — type-safe proxy for where() callbacks
-// ---------------------------------------------------------------------------
-
 export type ComparisonMethodFns<T> = {
   eq(value: T): AnyExpression;
   neq(value: T): AnyExpression;
@@ -157,8 +142,7 @@ export type ComparisonMethodFns<T> = {
 };
 
 /**
- * Trait-gated comparison methods. Only methods whose required traits are
- * all present in `Traits` are included.
+ * Trait-gated comparison methods. Only methods whose required traits are all present in `Traits` are included.
  *
  * - `traits: []` → always available (isNull, isNotNull)
  */
@@ -168,10 +152,6 @@ export type ComparisonMethods<T, Traits> = {
     : never]: ComparisonMethodFns<T>[K];
 };
 
-// ---------------------------------------------------------------------------
-// Extension operation result — returned by calling an extension method
-// ---------------------------------------------------------------------------
-
 type QueryOperationReturnTraits<
   Returns,
   TCodecTypes extends Record<string, unknown>,
@@ -209,9 +189,7 @@ type IsBooleanReturn<Returns, TCodecTypes extends Record<string, unknown>> = Ret
   : false;
 
 /**
- * Extract the `{codecId, nullable}` spec carried inside an `Expression<T>`.
- * Used to recover the op's return spec from its impl signature so the
- * pre-existing `QueryOperationReturn*` helpers can consume it unchanged.
+ * Extract the `{codecId, nullable}` spec carried inside an `Expression<T>`. Used to recover the op's return spec from its impl signature so the pre-existing `QueryOperationReturn*` helpers can consume it unchanged.
  */
 type SpecOf<E> = E extends Expression<infer T> ? T : never;
 
@@ -220,14 +198,8 @@ type ImplReturnSpec<Impl> = Impl extends (...args: never[]) => infer Ret ? SpecO
 /**
  * Builds the ORM column-method signature for an operation.
  *
- * - User args: drops the impl's first parameter (the column is bound at access
- *   time) and forwards the rest unchanged. Each remaining arg keeps its
- *   authored `CodecExpression` / `TraitExpression` shape — so callers can pass
- *   a raw JS value, another column handle (which itself implements
- *   `Expression`), or `null` when nullable.
- * - Return: predicate ops (boolean-traited return) yield `AnyExpression`;
- *   non-predicate ops yield `ComparisonMethods<JsType, Traits>` of the return
- *   codec.
+ * - User args: drops the impl's first parameter (the column is bound at access time) and forwards the rest unchanged. Each remaining arg keeps its authored `CodecExpression` / `TraitExpression` shape — so callers can pass a raw JS value, another column handle (which itself implements `Expression`), or `null` when nullable.
+ * - Return: predicate ops (boolean-traited return) yield `AnyExpression`; non-predicate ops yield `ComparisonMethods<JsType, Traits>` of the return codec.
  */
 type QueryOperationMethod<Op, TCodecTypes extends Record<string, unknown>> = Op extends {
   readonly impl: (...args: never[]) => unknown;
@@ -247,9 +219,7 @@ type QueryOperationMethod<Op, TCodecTypes extends Record<string, unknown>> = Op
   : never;
 
 /**
- * Tests whether an operation's `self` dispatch hint reaches a field with the
- * given codec identity. Codec hints match by identity; trait hints match when
- * every required trait is present in the field codec's trait set.
+ * Tests whether an operation's `self` dispatch hint reaches a field with the given codec identity. Codec hints match by identity; trait hints match when every required trait is present in the field codec's trait set.
  */
 type OpMatchesField<Op, CodecId extends string, CT extends Record<string, unknown>> = Op extends {
   readonly self: infer Self;
@@ -285,21 +255,43 @@ type FieldOperations<
     : unknown
   : unknown;
 
-// ---------------------------------------------------------------------------
-// COMPARISON_METHODS_META — single source of truth for traits + factories
-// ---------------------------------------------------------------------------
+/**
+ * Resolve the unique column ref carried by `left` so its surrounding `ParamRef` can dispatch through `forColumn`. The previous implementation only matched bare `column-ref` expressions, which lost refs the moment the expression got wrapped (`upper(f.id)`, `BinaryExpr`, function-call expressions, etc.) — and column-aware dispatch (AC-5) silently degraded for any predicate that touched a computed column.
+ *
+ * Walking via `collectColumnRefs()` and accepting only a single unambiguous ref gives `eq(upper(f.id), value)` and friends correct dispatch without inventing refs for ambiguous shapes (e.g. `eq(concat(f.firstName, f.lastName), value)` returns `undefined` and falls through to the codec-id path, which is correct for non-parameterized comparisons).
+ */
+function refsFromLeft(left: AnyExpression): { table: string; column: string } | undefined {
+  if (left.kind === 'column-ref') {
+    return { table: left.table, column: left.column };
+  }
+  const columnRefs = left.collectColumnRefs();
+  if (columnRefs.length !== 1) return undefined;
+  const single = columnRefs[0];
+  if (!single) return undefined;
+  return { table: single.table, column: single.column };
+}
 
-function param(codecId: string | undefined, value: unknown): ParamRef {
-  return codecId ? ParamRef.of(value, { codecId }) : ParamRef.of(value);
+function param(
+  codecId: string | undefined,
+  value: unknown,
+  refs: { table: string; column: string } | undefined,
+): ParamRef {
+  if (codecId === undefined && refs === undefined) return ParamRef.of(value);
+  return ParamRef.of(value, {
+    ...ifDefined('codecId', codecId),
+    ...ifDefined('refs', refs),
+  });
 }
 
-function paramList(codecId: string | undefined, values: readonly unknown[]): ListExpression {
-  return ListExpression.of(values.map((value) => param(codecId, value)));
+function paramList(
+  codecId: string | undefined,
+  values: readonly unknown[],
+  refs: { table: string; column: string } | undefined,
+): ListExpression {
+  return ListExpression.of(values.map((value) => param(codecId, value, refs)));
 }
 
-// never[] is intentional: factories have heterogeneous signatures (value: unknown,
-// values: readonly unknown[], pattern: string, etc.) but are only called through
-// the typed ComparisonMethodFns interface, never through this type directly.
+// never[] is intentional: factories have heterogeneous signatures (value: unknown, values: readonly unknown[], pattern: string, etc.) but are only called through the typed ComparisonMethodFns interface, never through this type directly.
 type MethodFactory = (
   left: AnyExpression,
   codecId: string | undefined,
@@ -312,12 +304,16 @@ type ComparisonMethodMeta = {
 
 function scalarComparisonMethod(op: BinaryOp) {
   return ((left, codecId) => (value: unknown) =>
-    new BinaryExpr(op, left, param(codecId, value))) satisfies MethodFactory;
+    new BinaryExpr(op, left, param(codecId, value, refsFromLeft(left)))) satisfies MethodFactory;
 }
 
 function listComparisonMethod(op: BinaryOp) {
   return ((left, codecId) => (values: readonly unknown[]) =>
-    new BinaryExpr(op, left, paramList(codecId, values))) satisfies MethodFactory;
+    new BinaryExpr(
+      op,
+      left,
+      paramList(codecId, values, refsFromLeft(left)),
+    )) satisfies MethodFactory;
 }
 
 /**
@@ -422,18 +418,10 @@ export type ModelAccessor<
   ModelName extends string,
 > = ScalarModelAccessor<TContract, ModelName> & RelationModelAccessor<TContract, ModelName>;
 
-// ---------------------------------------------------------------------------
-// DefaultModelRow — all scalar fields with JS types
-// ---------------------------------------------------------------------------
-
 export type DefaultModelRow<TContract extends Contract<SqlStorage>, ModelName extends string> = {
   [K in keyof FieldsOf<TContract, ModelName> & string]: FieldJsType<TContract, ModelName, K>;
 };
 
-// ---------------------------------------------------------------------------
-// InferRootRow — discriminated union for polymorphic base models
-// ---------------------------------------------------------------------------
-
 type Simplify<T> = { [K in keyof T]: T[K] } & {};
 
 type VariantRow<TContract extends Contract<SqlStorage>, ModelName extends string> = ModelDef<
@@ -554,10 +542,6 @@ export type ShorthandWhereFilter<
     | undefined;
 }>;
 
-// ---------------------------------------------------------------------------
-// Helpers for extracting fields / types from the contract
-// ---------------------------------------------------------------------------
-
 type ModelsOf<TContract extends Contract<SqlStorage>> =
   TContract['models'] extends Record<string, unknown> ? TContract['models'] : Record<string, never>;
 
@@ -671,10 +655,6 @@ type FieldStorageColumn<
   FieldName extends string,
 > = ResolvedStorageColumn<TContract, ModelName, FieldName>;
 
-// ---------------------------------------------------------------------------
-// Field trait resolution from contract CodecTypes
-// ---------------------------------------------------------------------------
-
 type FieldCodecId<
   TContract extends Contract<SqlStorage>,
   ModelName extends string,
@@ -795,10 +775,6 @@ export type CreateInput<TContract extends Contract<SqlStorage>, ModelName extend
   > &
   RelationMutationFields<TContract, ModelName>;
 
-// ---------------------------------------------------------------------------
-// Polymorphic write gating
-// ---------------------------------------------------------------------------
-
 type IsPolymorphicBase<TContract extends Contract<SqlStorage>, ModelName extends string> = ModelDef<
   TContract,
   ModelName
@@ -1070,10 +1046,6 @@ export type MutationUpdateInput<
   ModelName extends string,
 > = Partial<DefaultModelRow<TContract, ModelName>> & RelationMutationFields<TContract, ModelName>;
 
-// ---------------------------------------------------------------------------
-// Relation helpers
-// ---------------------------------------------------------------------------
-
 type ModelRelations<TContract extends Contract<SqlStorage>, ModelName extends string> = ModelDef<
   TContract,
   ModelName

package/src/where-binding.ts

@@ -122,7 +122,10 @@ function createParamRef(
   if (!codecId) {
     throw new Error(`Unknown column "${columnRef.column}" in table "${columnRef.table}"`);
   }
-  return ParamRef.of(value, { codecId });
+  return ParamRef.of(value, {
+    codecId,
+    refs: { table: columnRef.table, column: columnRef.column },
+  });
 }
 
 function createExpressionBinder(contract: Contract<SqlStorage>): ExpressionRewriter {
@@ -174,6 +177,7 @@ function bindSelectAst(contract: Contract<SqlStorage>, ast: SelectAst): SelectAs
           projection.alias,
           bindProjectionExpr(contract, projection.expr),
           projection.codecId,
+          projection.refs,
         ),
     ),
     where: ast.where ? bindWhereExprNode(contract, ast.where) : undefined,