@prisma-next/sql-orm-client 0.5.0-dev.8 → 0.5.0-dev.85

package/src/types.ts

@@ -1,5 +1,4 @@
-import type { Contract, ExecutionPlan } from '@prisma-next/contract/types';
-import type { AsyncIterableResult } from '@prisma-next/runtime-executor';
+import type { Contract } from '@prisma-next/contract/types';
 import type {
   ExtractCodecTypes,
   ExtractQueryOperationTypes,
@@ -17,15 +16,12 @@ import {
   OrderByItem,
   ParamRef,
 } from '@prisma-next/sql-relational-core/ast';
-import type { SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';
+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 } from '@prisma-next/sql-relational-core/types';
+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> {
@@ -65,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[];
@@ -113,16 +105,6 @@ export type DefaultCollectionTypeState = {
   readonly variantName: undefined;
 };
 
-// ---------------------------------------------------------------------------
-// CollectionContext — bundles lane context + runtime
-// ---------------------------------------------------------------------------
-
-export interface RuntimeScope {
-  execute<Row = Record<string, unknown>>(
-    plan: ExecutionPlan<Row> | SqlQueryPlan<Row>,
-  ): AsyncIterableResult<Row>;
-}
-
 export interface RuntimeConnection extends RuntimeScope {
   release?(): Promise<void>;
   transaction?(): Promise<RuntimeTransaction>;
@@ -143,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;
@@ -164,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)
  */
@@ -175,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>,
@@ -203,26 +176,6 @@ type QueryOperationReturnJsType<
     : unknown
   : unknown;
 
-type CodecArgJsType<Arg, TCodecTypes extends Record<string, unknown>> = Arg extends {
-  readonly codecId: infer CId extends string;
-  readonly nullable: infer N;
-}
-  ? CId extends keyof TCodecTypes
-    ? TCodecTypes[CId] extends { readonly output: infer O }
-      ? N extends true
-        ? O | null
-        : O
-      : unknown
-    : unknown
-  : unknown;
-
-type MapArgsToJsTypes<
-  Args extends readonly unknown[],
-  TCodecTypes extends Record<string, unknown>,
-> = Args extends readonly [infer Head, ...infer Tail]
-  ? [CodecArgJsType<Head, TCodecTypes>, ...MapArgsToJsTypes<Tail, TCodecTypes>]
-  : [];
-
 type IsBooleanReturn<Returns, TCodecTypes extends Record<string, unknown>> = Returns extends {
   readonly codecId: infer Id extends string;
 }
@@ -235,22 +188,41 @@ type IsBooleanReturn<Returns, TCodecTypes extends Record<string, unknown>> = Ret
     : false
   : 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.
+ */
+type SpecOf<E> = E extends Expression<infer T> ? T : never;
+
+type ImplReturnSpec<Impl> = Impl extends (...args: never[]) => infer Ret ? SpecOf<Ret> : never;
+
+/**
+ * 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.
+ */
 type QueryOperationMethod<Op, TCodecTypes extends Record<string, unknown>> = Op extends {
-  readonly args: readonly [unknown, ...infer UserArgs];
-  readonly returns: infer Returns;
+  readonly impl: (...args: never[]) => unknown;
 }
-  ? IsBooleanReturn<Returns, TCodecTypes> extends true
-    ? (...args: MapArgsToJsTypes<UserArgs, TCodecTypes>) => AnyExpression
-    : (
-        ...args: MapArgsToJsTypes<UserArgs, TCodecTypes>
-      ) => ComparisonMethods<
-        QueryOperationReturnJsType<Returns, TCodecTypes>,
-        QueryOperationReturnTraits<Returns, TCodecTypes>
-      >
+  ? Op['impl'] extends (first: never, ...rest: infer UserArgs extends readonly unknown[]) => unknown
+    ? ImplReturnSpec<Op['impl']> extends infer Returns
+      ? IsBooleanReturn<Returns, TCodecTypes> extends true
+        ? (...args: UserArgs) => AnyExpression
+        : (
+            ...args: UserArgs
+          ) => ComparisonMethods<
+            QueryOperationReturnJsType<Returns, TCodecTypes>,
+            QueryOperationReturnTraits<Returns, TCodecTypes>
+          >
+      : never
+    : never
   : 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.
+ */
 type OpMatchesField<Op, CodecId extends string, CT extends Record<string, unknown>> = Op extends {
-  readonly args: readonly [infer Self, ...(readonly unknown[])];
+  readonly self: infer Self;
 }
   ? Self extends { readonly codecId: CodecId }
     ? true
@@ -283,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,
@@ -310,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;
 }
 
 /**
@@ -400,10 +398,11 @@ export type RelationFilterAccessor<
 };
 
 type ScalarModelAccessor<TContract extends Contract<SqlStorage>, ModelName extends string> = {
-  [K in keyof FieldsOf<TContract, ModelName> & string]: ComparisonMethods<
-    FieldJsType<TContract, ModelName, K>,
-    FieldTraits<TContract, ModelName, K>
-  > &
+  [K in keyof FieldsOf<TContract, ModelName> & string]: Expression<{
+    codecId: FieldCodecId<TContract, ModelName, K>;
+    nullable: FieldNullable<TContract, ModelName, K>;
+  }> &
+    ComparisonMethods<FieldJsType<TContract, ModelName, K>, FieldTraits<TContract, ModelName, K>> &
     FieldOperations<TContract, ModelName, K>;
 };
 
@@ -419,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<
@@ -551,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>;
 
@@ -668,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,
@@ -682,6 +665,16 @@ type FieldCodecId<
   ? Id
   : never;
 
+type FieldNullable<
+  TContract extends Contract<SqlStorage>,
+  ModelName extends string,
+  FieldName extends string,
+> = FieldStorageColumn<TContract, ModelName, FieldName> extends {
+  readonly nullable: infer N extends boolean;
+}
+  ? N
+  : false;
+
 type FieldTraits<
   TContract extends Contract<SqlStorage>,
   ModelName extends string,
@@ -782,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
@@ -1057,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 {
@@ -170,7 +173,12 @@ function bindSelectAst(contract: Contract<SqlStorage>, ast: SelectAst): SelectAs
     joins: ast.joins?.map((join) => bindJoin(contract, join)),
     projection: ast.projection.map(
       (projection) =>
-        new ProjectionItem(projection.alias, bindProjectionExpr(contract, projection.expr)),
+        new ProjectionItem(
+          projection.alias,
+          bindProjectionExpr(contract, projection.expr),
+          projection.codecId,
+          projection.refs,
+        ),
     ),
     where: ast.where ? bindWhereExprNode(contract, ast.where) : undefined,
     orderBy: ast.orderBy?.map((orderItem) => bindOrderByItem(contract, orderItem)),