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

package/src/mutation-executor.ts

@@ -7,6 +7,7 @@ import {
   LiteralExpr,
 } from '@prisma-next/sql-relational-core/ast';
 import type { ExecutionContext } from '@prisma-next/sql-relational-core/query-lane-context';
+import type { RuntimeScope } from '@prisma-next/sql-relational-core/types';
 import {
   getColumnToFieldMap,
   resolveFieldToColumn,
@@ -40,7 +41,6 @@ import type {
   RelationMutation,
   RelationMutator,
   RuntimeQueryable,
-  RuntimeScope,
 } from './types';
 import { emptyState } from './types';
 
@@ -236,6 +236,15 @@ async function updateFirstGraph(
 
   const mappedUpdateData = mapModelDataToStorageRow(contract, modelName, scalarData);
   if (Object.keys(mappedUpdateData).length > 0) {
+    const tableName = resolveModelTableName(contract, modelName);
+    const appliedUpdateDefaults = context.applyMutationDefaults({
+      op: 'update',
+      table: tableName,
+      values: mappedUpdateData,
+    });
+    for (const def of appliedUpdateDefaults) {
+      mappedUpdateData[def.column] = def.value;
+    }
     const pkFilter = buildPrimaryKeyFilterFromRow(contract, modelName, existingRow);
     const pkWhere = shorthandToWhereExpr(
       context,
@@ -246,7 +255,6 @@ async function updateFirstGraph(
       throw new Error(`Failed to build primary key filter for model "${modelName}"`);
     }
 
-    const tableName = resolveModelTableName(contract, modelName);
     const compiled = compileUpdateReturning(
       contract,
       tableName,

package/src/query-plan-aggregate.ts

@@ -18,16 +18,30 @@ import { buildOrmQueryPlan, deriveParamsFromAst } from './query-plan-meta';
 import type { AggregateSelector } from './types';
 import { combineWhereExprs } from './where-utils';
 
-function toAggregateExpr(tableName: string, selector: AggregateSelector<unknown>): AggregateExpr {
+function toAggregateProjection(
+  contract: Contract<SqlStorage>,
+  tableName: string,
+  selector: AggregateSelector<unknown>,
+): { expr: AggregateExpr; codecId: string | undefined } {
   if (selector.fn === 'count') {
-    return AggregateExpr.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 };
   }
 
   if (!selector.column) {
     throw new Error(`Aggregate selector "${selector.fn}" requires a field`);
   }
 
-  return new AggregateExpr(selector.fn, ColumnRef.of(tableName, selector.column));
+  const expr = new AggregateExpr(selector.fn, ColumnRef.of(tableName, selector.column));
+  // min/max preserve the input column's type, so propagate the column codec.
+  // 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 };
+  }
+  return { expr, codecId: undefined };
 }
 
 // ORM HAVING filters use literal binding (values inlined at plan-build time),
@@ -115,17 +129,18 @@ export function compileAggregate(
     throw new Error('aggregate() requires at least one aggregation selector');
   }
 
-  const projection: ProjectionItem[] = entries.map(([alias, selector]) =>
-    ProjectionItem.of(alias, toAggregateExpr(tableName, selector)),
-  );
+  const projection: ProjectionItem[] = entries.map(([alias, selector]) => {
+    const { expr, codecId } = toAggregateProjection(contract, tableName, selector);
+    return ProjectionItem.of(alias, expr, codecId);
+  });
   let ast = SelectAst.from(TableSource.named(tableName)).withProjection(projection);
   const where = combineWhereExprs(filters);
   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 compileGroupedAggregate(
@@ -145,11 +160,15 @@ 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))),
-    ...entries.map(([alias, selector]) =>
-      ProjectionItem.of(alias, toAggregateExpr(tableName, selector)),
+    ...groupByColumns.map((column) =>
+      ProjectionItem.of(column, ColumnRef.of(tableName, column), table?.columns[column]?.codecId),
     ),
+    ...entries.map(([alias, selector]) => {
+      const { expr, codecId } = toAggregateProjection(contract, tableName, selector);
+      return ProjectionItem.of(alias, expr, codecId);
+    }),
   ];
 
   let ast = SelectAst.from(TableSource.named(tableName))
@@ -164,6 +183,6 @@ export function compileGroupedAggregate(
     ast = ast.withHaving(validateGroupedHavingExpr(havingExpr));
   }
 
-  const { params, paramDescriptors } = deriveParamsFromAst(ast);
-  return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+  const { params } = deriveParamsFromAst(ast);
+  return buildOrmQueryPlan(contract, ast, params);
 }

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