@prisma-next/sql-orm-client 0.5.1 → 0.6.0-dev.17

package/package.json

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

package/src/collection-internal-types.ts

@@ -109,13 +109,14 @@ export type IncludeRefinementValue<
   RelName extends string,
   DefaultIncludedRow,
   RefinedResult,
-> = RefinedResult extends RowSelection<infer V>
-  ? // IncludeScalar / IncludeCombine carry a final value that must not be
-    // cardinality-wrapped; Collection carries a raw row that still needs it.
-    RefinedResult extends { readonly kind: 'includeScalar' | 'includeCombine' }
-    ? V
-    : IncludeRelationValue<TContract, ParentModelName, RelName, V>
-  : IncludeRelationValue<TContract, ParentModelName, RelName, DefaultIncludedRow>;
+> =
+  RefinedResult extends RowSelection<infer V>
+    ? // IncludeScalar / IncludeCombine carry a final value that must not be
+      // cardinality-wrapped; Collection carries a raw row that still needs it.
+      RefinedResult extends { readonly kind: 'includeScalar' | 'includeCombine' }
+      ? V
+      : IncludeRelationValue<TContract, ParentModelName, RelName, V>
+    : IncludeRelationValue<TContract, ParentModelName, RelName, DefaultIncludedRow>;
 
 export type WhereInput<TContract extends Contract<SqlStorage>, ModelName extends string> =
   | ((model: ModelAccessor<TContract, ModelName>) => AnyExpression)

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