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

package/src/query-plan-meta.ts

@@ -1,53 +1,13 @@
-import type { Contract, ParamDescriptor, PlanMeta } from '@prisma-next/contract/types';
+import type { Contract, PlanMeta } from '@prisma-next/contract/types';
 import type { SqlStorage } from '@prisma-next/sql-contract/types';
-import type { AnyQueryAst, ParamRef } from '@prisma-next/sql-relational-core/ast';
+import { type AnyQueryAst, collectOrderedParamRefs } from '@prisma-next/sql-relational-core/ast';
 import type { SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';
-import { ifDefined } from '@prisma-next/utils/defined';
 
-function resolveProjectionCodecs(
-  contract: Contract<SqlStorage>,
-  ast: AnyQueryAst,
-): Record<string, string> | undefined {
-  const codecs: Record<string, string> = {};
-
-  if (ast.kind === 'select') {
-    for (const item of ast.projection) {
-      if (item.expr.kind === 'column-ref') {
-        const table = contract.storage.tables[item.expr.table];
-        const col = table?.columns[item.expr.column];
-        if (col?.codecId) {
-          codecs[item.alias] = col.codecId;
-        }
-      }
-    }
-  } else if (ast.returning) {
-    const tableName = ast.table.name;
-    const table = contract.storage.tables[tableName];
-    if (!table) return undefined;
-
-    for (const colRef of ast.returning) {
-      const col = table.columns[colRef.column];
-      if (col?.codecId) {
-        codecs[colRef.column] = col.codecId;
-      }
-    }
-  }
-
-  return Object.keys(codecs).length > 0 ? codecs : undefined;
-}
-
-export function deriveParamsFromAst(ast: { collectParamRefs(): ParamRef[] }): {
+export function deriveParamsFromAst(ast: AnyQueryAst): {
   params: unknown[];
-  paramDescriptors: ParamDescriptor[];
 } {
-  const collectedParams = [...new Set(ast.collectParamRefs())];
   return {
-    params: collectedParams.map((p) => p.value),
-    paramDescriptors: collectedParams.map((p) => ({
-      ...ifDefined('name', p.name),
-      ...ifDefined('codecId', p.codecId),
-      source: 'dsl' as const,
-    })),
+    params: collectOrderedParamRefs(ast).map((p) => p.value),
   };
 }
 
@@ -59,17 +19,13 @@ export function resolveTableColumns(contract: Contract<SqlStorage>, tableName: s
   return Object.keys(table.columns);
 }
 
-export function buildOrmPlanMeta(
-  contract: Contract<SqlStorage>,
-  paramDescriptors: readonly ParamDescriptor[] = [],
-): PlanMeta {
+export function buildOrmPlanMeta(contract: Contract<SqlStorage>): PlanMeta {
   return {
     target: contract.target,
     targetFamily: contract.targetFamily,
     storageHash: contract.storage.storageHash,
     ...(contract.profileHash !== undefined ? { profileHash: contract.profileHash } : {}),
     lane: 'orm-client',
-    paramDescriptors: [...paramDescriptors],
   };
 }
 
@@ -77,26 +33,10 @@ export function buildOrmQueryPlan<Row>(
   contract: Contract<SqlStorage>,
   ast: AnyQueryAst,
   params: readonly unknown[],
-  paramDescriptors: readonly ParamDescriptor[] = [],
 ): SqlQueryPlan<Row> {
-  const projectionTypes = resolveProjectionCodecs(contract, ast);
-  const codecAnnotations = projectionTypes
-    ? { codecs: Object.freeze({ ...projectionTypes }) }
-    : undefined;
-  const limitAnnotation =
-    ast.kind === 'select' && ast.limit !== undefined ? { limit: ast.limit } : undefined;
-  const annotations =
-    codecAnnotations || limitAnnotation
-      ? Object.freeze({ ...codecAnnotations, ...limitAnnotation })
-      : undefined;
-
   return Object.freeze({
     ast,
     params: [...params],
-    meta: {
-      ...buildOrmPlanMeta(contract, paramDescriptors),
-      ...ifDefined('projectionTypes', projectionTypes),
-      ...ifDefined('annotations', annotations),
-    },
+    meta: buildOrmPlanMeta(contract),
   });
 }

package/src/query-plan-mutations.ts

@@ -8,6 +8,7 @@ import {
   InsertAst,
   InsertOnConflict,
   ParamRef,
+  ProjectionItem,
   TableSource,
   UpdateAst,
 } from '@prisma-next/sql-relational-core/ast';
@@ -19,13 +20,16 @@ function buildReturningColumns(
   contract: Contract<SqlStorage>,
   tableName: string,
   returningColumns: readonly string[] | undefined,
-) {
+): ReadonlyArray<ProjectionItem> {
   const columns =
     returningColumns && returningColumns.length > 0
       ? [...returningColumns]
       : resolveTableColumns(contract, tableName);
 
-  return columns.map((column) => ColumnRef.of(tableName, column));
+  const table = contract.storage.tables[tableName];
+  return columns.map((column) =>
+    ProjectionItem.of(column, ColumnRef.of(tableName, column), table?.columns[column]?.codecId),
+  );
 }
 
 function toParamAssignments(
@@ -47,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 };
@@ -93,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();
@@ -114,8 +126,8 @@ export function compileInsertReturning(
   const ast = InsertAst.into(TableSource.named(tableName))
     .withRows(normalizedRows)
     .withReturning(buildReturningColumns(contract, tableName, returningColumns));
-  const { params, paramDescriptors } = deriveParamsFromAst(ast);
-  return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+  const { params } = deriveParamsFromAst(ast);
+  return buildOrmQueryPlan(contract, ast, params);
 }
 
 export function compileInsertCount(
@@ -125,8 +137,8 @@ export function compileInsertCount(
 ): SqlQueryPlan<Record<string, unknown>> {
   const { rows: normalizedRows } = normalizeInsertRows(contract, tableName, rows);
   const ast = InsertAst.into(TableSource.named(tableName)).withRows(normalizedRows);
-  const { params, paramDescriptors } = deriveParamsFromAst(ast);
-  return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+  const { params } = deriveParamsFromAst(ast);
+  return buildOrmQueryPlan(contract, ast, params);
 }
 
 function stripUndefinedValues(row: Record<string, unknown>): Record<string, unknown> {
@@ -139,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>[]> {
@@ -224,8 +232,8 @@ export function compileUpsertReturning(
     .withOnConflict(onConflict)
     .withReturning(buildReturningColumns(contract, tableName, returningColumns));
 
-  const { params, paramDescriptors } = deriveParamsFromAst(ast);
-  return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+  const { params } = deriveParamsFromAst(ast);
+  return buildOrmQueryPlan(contract, ast, params);
 }
 
 export function compileUpdateReturning(
@@ -243,8 +251,8 @@ export function compileUpdateReturning(
   if (where) {
     ast = ast.withWhere(where);
   }
-  const { params, paramDescriptors } = deriveParamsFromAst(ast);
-  return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+  const { params } = deriveParamsFromAst(ast);
+  return buildOrmQueryPlan(contract, ast, params);
 }
 
 export function compileUpdateCount(
@@ -259,8 +267,8 @@ export function compileUpdateCount(
   if (where) {
     ast = ast.withWhere(where);
   }
-  const { params, paramDescriptors } = deriveParamsFromAst(ast);
-  return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+  const { params } = deriveParamsFromAst(ast);
+  return buildOrmQueryPlan(contract, ast, params);
 }
 
 export function compileDeleteReturning(
@@ -276,8 +284,8 @@ export function compileDeleteReturning(
   if (where) {
     ast = ast.withWhere(where);
   }
-  const { params, paramDescriptors } = deriveParamsFromAst(ast);
-  return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+  const { params } = deriveParamsFromAst(ast);
+  return buildOrmQueryPlan(contract, ast, params);
 }
 
 export function compileDeleteCount(
@@ -290,6 +298,6 @@ export function compileDeleteCount(
   if (where) {
     ast = ast.withWhere(where);
   }
-  const { params, paramDescriptors } = deriveParamsFromAst(ast);
-  return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+  const { params } = deriveParamsFromAst(ast);
+  return buildOrmQueryPlan(contract, ast, params);
 }

package/src/query-plan-select.ts

@@ -49,7 +49,10 @@ function buildProjection(
       ? [...selectedFields]
       : resolveTableColumns(contract, tableName);
 
-  return columns.map((column) => ProjectionItem.of(column, ColumnRef.of(tableRef, column)));
+  const table = contract.storage.tables[tableName];
+  return columns.map((column) =>
+    ProjectionItem.of(column, ColumnRef.of(tableRef, column), table?.columns[column]?.codecId),
+  );
 }
 
 function createBoundaryExpr(tableName: string, entry: CursorOrderEntry): AnyExpression {
@@ -403,10 +406,17 @@ function buildMtiJoins(
     joins.push(join);
 
     const variantColumns = resolveTableColumns(contract, variant.table);
+    const variantTable = contract.storage.tables[variant.table];
     for (const col of variantColumns) {
       if (col === pkColumn) continue;
       const alias = `${variant.table}__${col}`;
-      projection.push(ProjectionItem.of(alias, ColumnRef.of(variant.table, col)));
+      projection.push(
+        ProjectionItem.of(
+          alias,
+          ColumnRef.of(variant.table, col),
+          variantTable?.columns[col]?.codecId,
+        ),
+      );
     }
   }
 
@@ -437,8 +447,8 @@ export function compileSelect(
       : undefined,
   );
 
-  const { params, paramDescriptors } = deriveParamsFromAst(ast);
-  return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+  const { params } = deriveParamsFromAst(ast);
+  return buildOrmQueryPlan(contract, ast, params);
 }
 
 export function compileRelationSelect(
@@ -513,6 +523,6 @@ export function compileSelectWithIncludeStrategy(
     },
   );
 
-  const { params, paramDescriptors } = deriveParamsFromAst(ast);
-  return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+  const { params } = deriveParamsFromAst(ast);
+  return buildOrmQueryPlan(contract, ast, params);
 }

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)),