@prisma-next/sql-orm-client 0.6.0-dev.6 → 0.6.0-dev.8

package/package.json

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

package/src/model-accessor.ts

@@ -5,12 +5,14 @@ import {
   AndExpr,
   type AnyExpression,
   BinaryExpr,
+  type CodecRef,
   ColumnRef,
   ExistsExpr,
   ProjectionItem,
   SelectAst,
   TableSource,
 } from '@prisma-next/sql-relational-core/ast';
+import { codecRefForStorageColumn } from '@prisma-next/sql-relational-core/codec-descriptor-registry';
 import type { Expression, ScopeField } from '@prisma-next/sql-relational-core/expression';
 import type { ExecutionContext } from '@prisma-next/sql-relational-core/query-lane-context';
 import {
@@ -104,11 +106,13 @@ export function createModelAccessor<
       }
       const traits = context.codecDescriptors.descriptorFor(column.codecId)?.traits ?? [];
       const operations = opsByCodecId.get(column.codecId) ?? [];
+      const codec = codecRefForStorageColumn(contract.storage, tableName, columnName);
       return createScalarFieldAccessor(
         tableName,
         columnName,
         column.codecId,
         column.nullable,
+        codec,
         traits,
         operations,
         context,
@@ -132,6 +136,7 @@ function createScalarFieldAccessor(
   columnName: string,
   codecId: string,
   nullable: boolean,
+  codec: CodecRef | undefined,
   traits: readonly string[],
   operations: readonly NamedOp[],
   context: ExecutionContext,
@@ -140,11 +145,12 @@ function createScalarFieldAccessor(
   const comparisonEntries: Array<[string, unknown]> = [];
   for (const [name, meta] of Object.entries(COMPARISON_METHODS_META)) {
     if (meta.traits.some((t) => !traits.includes(t))) continue;
-    comparisonEntries.push([name, meta.create(column, codecId)]);
+    comparisonEntries.push([name, meta.create(column, codec)]);
   }
 
   const accessor = {
-    returnType: { codecId, nullable },
+    returnType: { codecId, nullable, codec },
+    codec,
     buildAst: () => column,
     ...Object.fromEntries(comparisonEntries),
   } as Expression<ScopeField> & Record<string, unknown>;
@@ -178,10 +184,11 @@ function createExtensionMethodFactory(
     }
 
     const resultAst = result.buildAst();
+    const returnCodec: CodecRef = { codecId: returnCodecId };
     const methods: Record<string, unknown> = {};
     for (const [resultMethodName, meta] of Object.entries(COMPARISON_METHODS_META)) {
       if (meta.traits.some((t) => !returnTraits.includes(t))) continue;
-      methods[resultMethodName] = meta.create(resultAst, returnCodecId);
+      methods[resultMethodName] = meta.create(resultAst, returnCodec);
     }
     return methods;
   };

package/src/query-plan-aggregate.ts

@@ -5,6 +5,7 @@ import {
   AndExpr,
   type AnyExpression,
   BinaryExpr,
+  type CodecRef,
   ColumnRef,
   NotExpr,
   NullCheckExpr,
@@ -13,6 +14,7 @@ import {
   SelectAst,
   TableSource,
 } from '@prisma-next/sql-relational-core/ast';
+import { codecRefForStorageColumn } from '@prisma-next/sql-relational-core/codec-descriptor-registry';
 import type { SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';
 import { buildOrmQueryPlan, deriveParamsFromAst } from './query-plan-meta';
 import type { AggregateSelector } from './types';
@@ -22,11 +24,11 @@ function toAggregateProjection(
   contract: Contract<SqlStorage>,
   tableName: string,
   selector: AggregateSelector<unknown>,
-): { expr: AggregateExpr; codecId: string | undefined } {
+): { expr: AggregateExpr; codec: CodecRef | undefined } {
   if (selector.fn === 'count') {
     // count() returns a target-specific bigint; mapping isn't derivable here
-    // without target coupling, so we leave codecId unstamped.
-    return { expr: AggregateExpr.count(), codecId: undefined };
+    // without target coupling, so we leave the codec slot empty.
+    return { expr: AggregateExpr.count(), codec: undefined };
   }
 
   if (!selector.column) {
@@ -38,10 +40,10 @@ function toAggregateProjection(
   // sum widens (int4 → int8 in Postgres) and avg → numeric; both need
   // target+input-aware mapping that doesn't exist yet, so leave unstamped.
   if (selector.fn === 'min' || selector.fn === 'max') {
-    const codecId = contract.storage.tables[tableName]?.columns[selector.column]?.codecId;
-    return { expr, codecId };
+    const codec = codecRefForStorageColumn(contract.storage, tableName, selector.column);
+    return { expr, codec };
   }
-  return { expr, codecId: undefined };
+  return { expr, codec: undefined };
 }
 
 // ORM HAVING filters use literal binding (values inlined at plan-build time),
@@ -130,8 +132,8 @@ export function compileAggregate(
   }
 
   const projection: ProjectionItem[] = entries.map(([alias, selector]) => {
-    const { expr, codecId } = toAggregateProjection(contract, tableName, selector);
-    return ProjectionItem.of(alias, expr, codecId);
+    const { expr, codec } = toAggregateProjection(contract, tableName, selector);
+    return ProjectionItem.of(alias, expr, codec);
   });
   let ast = SelectAst.from(TableSource.named(tableName)).withProjection(projection);
   const where = combineWhereExprs(filters);
@@ -160,14 +162,17 @@ export function compileGroupedAggregate(
     throw new Error('groupBy().aggregate() requires at least one aggregation selector');
   }
 
-  const table = contract.storage.tables[tableName];
   const projection: ProjectionItem[] = [
     ...groupByColumns.map((column) =>
-      ProjectionItem.of(column, ColumnRef.of(tableName, column), table?.columns[column]?.codecId),
+      ProjectionItem.of(
+        column,
+        ColumnRef.of(tableName, column),
+        codecRefForStorageColumn(contract.storage, tableName, column),
+      ),
     ),
     ...entries.map(([alias, selector]) => {
-      const { expr, codecId } = toAggregateProjection(contract, tableName, selector);
-      return ProjectionItem.of(alias, expr, codecId);
+      const { expr, codec } = toAggregateProjection(contract, tableName, selector);
+      return ProjectionItem.of(alias, expr, codec);
     }),
   ];
 

package/src/query-plan-mutations.ts

@@ -12,7 +12,9 @@ import {
   TableSource,
   UpdateAst,
 } from '@prisma-next/sql-relational-core/ast';
+import { codecRefForStorageColumn } from '@prisma-next/sql-relational-core/codec-descriptor-registry';
 import type { SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';
+import { ifDefined } from '@prisma-next/utils/defined';
 import { buildOrmQueryPlan, deriveParamsFromAst, resolveTableColumns } from './query-plan-meta';
 import { combineWhereExprs } from './where-utils';
 
@@ -26,9 +28,12 @@ function buildReturningColumns(
       ? [...returningColumns]
       : resolveTableColumns(contract, tableName);
 
-  const table = contract.storage.tables[tableName];
   return columns.map((column) =>
-    ProjectionItem.of(column, ColumnRef.of(tableName, column), table?.columns[column]?.codecId),
+    ProjectionItem.of(
+      column,
+      ColumnRef.of(tableName, column),
+      codecRefForStorageColumn(contract.storage, tableName, column),
+    ),
   );
 }
 
@@ -47,14 +52,13 @@ function toParamAssignments(
   }
 
   for (const [column, value] of Object.entries(values)) {
-    const codecId = table.columns[column]?.codecId;
-    if (!codecId) {
+    if (!table.columns[column]) {
       throw new Error(`Unknown column "${column}" in table "${tableName}"`);
     }
+    const codec = codecRefForStorageColumn(contract.storage, tableName, column);
     assignments[column] = ParamRef.of(value, {
       name: column,
-      codecId,
-      refs: { table: tableName, column },
+      ...ifDefined('codec', codec),
     });
   }
 
@@ -85,6 +89,11 @@ function normalizeInsertRows(
     }
   }
 
+  const table = contract.storage.tables[tableName];
+  if (!table) {
+    throw new Error(`Unknown table "${tableName}"`);
+  }
+
   const normalizedRows = rows.map((row) => {
     if (orderedColumns.length === 0) {
       return {};
@@ -93,18 +102,13 @@ function normalizeInsertRows(
     const normalizedRow: Record<string, ParamRef | DefaultValueExpr> = {};
     for (const column of orderedColumns) {
       if (Object.hasOwn(row, column)) {
-        const table = contract.storage.tables[tableName];
-        if (!table) {
-          throw new Error(`Unknown table "${tableName}"`);
-        }
-        const codecId = table?.columns[column]?.codecId;
-        if (!codecId) {
+        if (!table.columns[column]) {
           throw new Error(`Unknown column "${column}" in table "${tableName}"`);
         }
+        const codec = codecRefForStorageColumn(contract.storage, tableName, column);
         normalizedRow[column] = ParamRef.of(row[column], {
           name: column,
-          codecId,
-          refs: { table: tableName, column },
+          ...ifDefined('codec', codec),
         });
         continue;
       }

package/src/query-plan-select.ts

@@ -21,6 +21,7 @@ import {
   SubqueryExpr,
   TableSource,
 } from '@prisma-next/sql-relational-core/ast';
+import { codecRefForStorageColumn } from '@prisma-next/sql-relational-core/codec-descriptor-registry';
 import type { SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';
 import {
   type PolymorphismInfo,
@@ -49,9 +50,12 @@ function buildProjection(
       ? [...selectedFields]
       : resolveTableColumns(contract, tableName);
 
-  const table = contract.storage.tables[tableName];
   return columns.map((column) =>
-    ProjectionItem.of(column, ColumnRef.of(tableRef, column), table?.columns[column]?.codecId),
+    ProjectionItem.of(
+      column,
+      ColumnRef.of(tableRef, column),
+      codecRefForStorageColumn(contract.storage, tableName, column),
+    ),
   );
 }
 
@@ -406,7 +410,6 @@ 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}`;
@@ -414,7 +417,7 @@ function buildMtiJoins(
         ProjectionItem.of(
           alias,
           ColumnRef.of(variant.table, col),
-          variantTable?.columns[col]?.codecId,
+          codecRefForStorageColumn(contract.storage, variant.table, col),
         ),
       );
     }

package/src/types.ts

@@ -10,6 +10,7 @@ import {
   type AnyExpression,
   BinaryExpr,
   type BinaryOp,
+  type CodecRef,
   type CodecTrait,
   ListExpression,
   NullCheckExpr,
@@ -19,7 +20,6 @@ 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';
 
 export type AggregateFn = 'count' | 'sum' | 'avg' | 'min' | 'max';
@@ -255,46 +255,19 @@ type FieldOperations<
     : unknown
   : unknown;
 
-/**
- * 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(codec: CodecRef | undefined, value: unknown): ParamRef {
+  if (codec === undefined) return ParamRef.of(value);
+  return ParamRef.of(value, { codec });
 }
 
-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[],
-  refs: { table: string; column: string } | undefined,
-): ListExpression {
-  return ListExpression.of(values.map((value) => param(codecId, value, refs)));
+function paramList(codec: CodecRef | undefined, values: readonly unknown[]): ListExpression {
+  return ListExpression.of(values.map((value) => param(codec, value)));
 }
 
 // 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,
+  codec: CodecRef | undefined,
 ) => (...args: never[]) => unknown;
 
 type ComparisonMethodMeta = {
@@ -303,17 +276,17 @@ type ComparisonMethodMeta = {
 };
 
 function scalarComparisonMethod(op: BinaryOp) {
-  return ((left, codecId) => (value: unknown) =>
-    new BinaryExpr(op, left, param(codecId, value, refsFromLeft(left)))) satisfies MethodFactory;
+  return ((left, codec) => (value: unknown) => {
+    if (value === null && (op === 'eq' || op === 'neq')) {
+      return op === 'eq' ? NullCheckExpr.isNull(left) : NullCheckExpr.isNotNull(left);
+    }
+    return new BinaryExpr(op, left, param(codec, value));
+  }) satisfies MethodFactory;
 }
 
 function listComparisonMethod(op: BinaryOp) {
-  return ((left, codecId) => (values: readonly unknown[]) =>
-    new BinaryExpr(
-      op,
-      left,
-      paramList(codecId, values, refsFromLeft(left)),
-    )) satisfies MethodFactory;
+  return ((left, codec) => (values: readonly unknown[]) =>
+    new BinaryExpr(op, left, paramList(codec, values))) satisfies MethodFactory;
 }
 
 /**

package/src/where-binding.ts

@@ -20,6 +20,7 @@ import {
   ProjectionItem,
   SelectAst,
 } from '@prisma-next/sql-relational-core/ast';
+import { codecRefForStorageColumn } from '@prisma-next/sql-relational-core/codec-descriptor-registry';
 
 export function bindWhereExpr(contract: Contract<SqlStorage>, expr: AnyExpression): AnyExpression {
   return bindWhereExprNode(contract, expr);
@@ -118,14 +119,11 @@ function createParamRef(
   columnRef: ColumnRef,
   value: unknown,
 ): ParamRef {
-  const codecId = contract.storage.tables[columnRef.table]?.columns[columnRef.column]?.codecId;
-  if (!codecId) {
+  if (!contract.storage.tables[columnRef.table]?.columns[columnRef.column]) {
     throw new Error(`Unknown column "${columnRef.column}" in table "${columnRef.table}"`);
   }
-  return ParamRef.of(value, {
-    codecId,
-    refs: { table: columnRef.table, column: columnRef.column },
-  });
+  const codec = codecRefForStorageColumn(contract.storage, columnRef.table, columnRef.column);
+  return ParamRef.of(value, codec ? { codec } : undefined);
 }
 
 function createExpressionBinder(contract: Contract<SqlStorage>): ExpressionRewriter {
@@ -176,8 +174,7 @@ function bindSelectAst(contract: Contract<SqlStorage>, ast: SelectAst): SelectAs
         new ProjectionItem(
           projection.alias,
           bindProjectionExpr(contract, projection.expr),
-          projection.codecId,
-          projection.refs,
+          projection.codec,
         ),
     ),
     where: ast.where ? bindWhereExprNode(contract, ast.where) : undefined,