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

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(
@@ -114,8 +118,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 +129,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> {
@@ -224,8 +228,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 +247,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 +263,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 +280,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 +294,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,9 +16,9 @@ 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 type { RowSelection } from './collection-internal-types';
 
 // ---------------------------------------------------------------------------
@@ -117,12 +116,6 @@ export type DefaultCollectionTypeState = {
 // 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>;
@@ -203,26 +196,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 +208,51 @@ 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
@@ -400,10 +402,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>;
 };
 
@@ -682,6 +685,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,

package/src/where-binding.ts

@@ -170,7 +170,11 @@ 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,
+        ),
     ),
     where: ast.where ? bindWhereExprNode(contract, ast.where) : undefined,
     orderBy: ast.orderBy?.map((orderItem) => bindOrderByItem(contract, orderItem)),