@prisma-next/sql-orm-lane 0.3.0-pr.96.1 → 0.3.0-pr.96.4

package/src/plan/plan-assembly.ts

@@ -4,21 +4,22 @@ import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
 import type {
   BinaryExpr,
   ExistsExpr,
+  Expression,
   LoweredStatement,
-  OperationExpr,
   SelectAst,
   TableRef,
 } from '@prisma-next/sql-relational-core/ast';
 import { compact } from '@prisma-next/sql-relational-core/ast';
 import type {
-  AnyColumnBuilder,
+  AnyExpressionSource,
   AnyOrderBuilder,
   BinaryBuilder,
 } from '@prisma-next/sql-relational-core/types';
 import {
   collectColumnRefs,
-  getColumnInfo,
   getColumnMeta,
+  isColumnBuilder,
+  isExpressionBuilder,
   isOperationExpr,
 } from '@prisma-next/sql-relational-core/utils/guards';
 import type { IncludeState } from '../relations/include-plan';
@@ -35,30 +36,67 @@ export interface MetaBuildArgs {
   readonly paramCodecs?: Record<string, string>;
 }
 
-export function buildMeta(args: MetaBuildArgs): PlanMeta {
-  const refsColumns = new Map<string, { table: string; column: string }>();
-  const refsTables = new Set<string>([args.table.name]);
-
-  for (const column of args.projection.columns) {
-    const operationExpr = (column as { _operationExpr?: OperationExpr })._operationExpr;
-    if (operationExpr) {
-      const allRefs = collectColumnRefs(operationExpr);
-      for (const ref of allRefs) {
+/**
+ * Extracts column references from an ExpressionSource (ColumnBuilder or ExpressionBuilder).
+ * Skips entries with empty table or column names (e.g., placeholder columns for includes).
+ */
+function collectRefsFromExpressionSource(
+  source: AnyExpressionSource,
+  refsColumns: Map<string, { table: string; column: string }>,
+): void {
+  if (isExpressionBuilder(source)) {
+    const allRefs = collectColumnRefs(source.expr);
+    for (const ref of allRefs) {
+      // Skip empty table/column (placeholders for includes)
+      if (ref.table && ref.column) {
         refsColumns.set(`${ref.table}.${ref.column}`, {
           table: ref.table,
           column: ref.column,
         });
       }
-    } else {
-      const col = column as unknown as { table?: string; column?: string };
-      if (col.table && col.column) {
-        refsColumns.set(`${col.table}.${col.column}`, {
-          table: col.table,
-          column: col.column,
-        });
-      }
+    }
+  } else if (isColumnBuilder(source)) {
+    const col = source as unknown as { table: string; column: string };
+    // Skip empty table/column (placeholders for includes)
+    if (col.table && col.column) {
+      refsColumns.set(`${col.table}.${col.column}`, {
+        table: col.table,
+        column: col.column,
+      });
     }
   }
+}
+
+/**
+ * Extracts column references from an Expression (AST node).
+ */
+function collectRefsFromExpression(
+  expr: Expression,
+  refsColumns: Map<string, { table: string; column: string }>,
+): void {
+  if (isOperationExpr(expr)) {
+    const allRefs = collectColumnRefs(expr);
+    for (const ref of allRefs) {
+      refsColumns.set(`${ref.table}.${ref.column}`, {
+        table: ref.table,
+        column: ref.column,
+      });
+    }
+  } else if (expr.kind === 'col') {
+    refsColumns.set(`${expr.table}.${expr.column}`, {
+      table: expr.table,
+      column: expr.column,
+    });
+  }
+}
+
+export function buildMeta(args: MetaBuildArgs): PlanMeta {
+  const refsColumns = new Map<string, { table: string; column: string }>();
+  const refsTables = new Set<string>([args.table.name]);
+
+  for (const column of args.projection.columns) {
+    collectRefsFromExpressionSource(column, refsColumns);
+  }
 
   if (args.includes) {
     for (const include of args.includes) {
@@ -85,32 +123,21 @@ export function buildMeta(args: MetaBuildArgs): PlanMeta {
         }
       }
       if (include.childWhere) {
-        const colInfo = getColumnInfo(include.childWhere.left);
-        refsColumns.set(`${colInfo.table}.${colInfo.column}`, {
-          table: colInfo.table,
-          column: colInfo.column,
-        });
+        // childWhere.left is Expression (already converted at builder creation time)
+        collectRefsFromExpression(include.childWhere.left, refsColumns);
       }
       if (include.childOrderBy) {
-        const orderBy = include.childOrderBy as unknown as {
-          expr?: AnyColumnBuilder | OperationExpr;
-        };
-        if (orderBy.expr) {
-          const colInfo = getColumnInfo(orderBy.expr);
-          refsColumns.set(`${colInfo.table}.${colInfo.column}`, {
-            table: colInfo.table,
-            column: colInfo.column,
-          });
-        }
+        // childOrderBy.expr is Expression (already converted at builder creation time)
+        collectRefsFromExpression(include.childOrderBy.expr, refsColumns);
       }
     }
   }
 
   if (args.where) {
-    const whereLeft = args.where.left;
-    const operationExpr = (whereLeft as { _operationExpr?: OperationExpr })._operationExpr;
-    if (operationExpr) {
-      const allRefs = collectColumnRefs(operationExpr);
+    // args.where.left is Expression (already converted at builder creation time)
+    const leftExpr: Expression = args.where.left;
+    if (isOperationExpr(leftExpr)) {
+      const allRefs = collectColumnRefs(leftExpr);
       for (const ref of allRefs) {
         refsColumns.set(`${ref.table}.${ref.column}`, {
           table: ref.table,
@@ -118,39 +145,31 @@ export function buildMeta(args: MetaBuildArgs): PlanMeta {
         });
       }
     } else {
-      const colBuilder = whereLeft as unknown as { table?: string; column?: string };
-      if (colBuilder.table && colBuilder.column) {
-        refsColumns.set(`${colBuilder.table}.${colBuilder.column}`, {
-          table: colBuilder.table,
-          column: colBuilder.column,
-        });
-      }
+      // leftExpr is ColumnRef
+      refsColumns.set(`${leftExpr.table}.${leftExpr.column}`, {
+        table: leftExpr.table,
+        column: leftExpr.column,
+      });
     }
   }
 
   if (args.orderBy) {
-    const orderBy = args.orderBy as unknown as {
-      expr?: AnyColumnBuilder | OperationExpr;
-    };
-    const orderByExpr = orderBy.expr;
-    if (orderByExpr) {
-      if (isOperationExpr(orderByExpr)) {
-        const allRefs = collectColumnRefs(orderByExpr);
-        for (const ref of allRefs) {
-          refsColumns.set(`${ref.table}.${ref.column}`, {
-            table: ref.table,
-            column: ref.column,
-          });
-        }
-      } else {
-        const colBuilder = orderByExpr as unknown as { table?: string; column?: string };
-        if (colBuilder.table && colBuilder.column) {
-          refsColumns.set(`${colBuilder.table}.${colBuilder.column}`, {
-            table: colBuilder.table,
-            column: colBuilder.column,
-          });
-        }
+    // args.orderBy.expr is Expression (already converted at builder creation time)
+    const orderByExpr: Expression = args.orderBy.expr;
+    if (isOperationExpr(orderByExpr)) {
+      const allRefs = collectColumnRefs(orderByExpr);
+      for (const ref of allRefs) {
+        refsColumns.set(`${ref.table}.${ref.column}`, {
+          table: ref.table,
+          column: ref.column,
+        });
       }
+    } else {
+      // orderByExpr is ColumnRef
+      refsColumns.set(`${orderByExpr.table}.${orderByExpr.column}`, {
+        table: orderByExpr.table,
+        column: orderByExpr.column,
+      });
     }
   }
 
@@ -164,18 +183,14 @@ export function buildMeta(args: MetaBuildArgs): PlanMeta {
       if (!column) {
         throw planInvalid(`Missing column for alias ${alias} at index ${index}`);
       }
-      const col = column as unknown as {
-        table?: string;
-        column?: string;
-        _operationExpr?: OperationExpr;
-      };
+      if (isExpressionBuilder(column)) {
+        return [alias, `operation:${column.expr.method}`];
+      }
+      // column is ColumnBuilder
+      const col = column as unknown as { table?: string; column?: string };
       if (!col.table || !col.column) {
         return [alias, `include:${alias}`];
       }
-      const operationExpr = col._operationExpr;
-      if (operationExpr) {
-        return [alias, `operation:${operationExpr.method}`];
-      }
       return [alias, `${col.table}.${col.column}`];
     }),
   );
@@ -190,8 +205,8 @@ export function buildMeta(args: MetaBuildArgs): PlanMeta {
     if (!col) {
       continue;
     }
-    const operationExpr = (col as { _operationExpr?: OperationExpr })._operationExpr;
-    if (operationExpr) {
+    if (isExpressionBuilder(col)) {
+      const operationExpr = col.expr;
       if (operationExpr.returns.kind === 'typeId') {
         projectionTypes[alias] = operationExpr.returns.type;
       } else if (operationExpr.returns.kind === 'builtin') {
@@ -216,8 +231,8 @@ export function buildMeta(args: MetaBuildArgs): PlanMeta {
     if (!column) {
       continue;
     }
-    const operationExpr = (column as { _operationExpr?: OperationExpr })._operationExpr;
-    if (operationExpr) {
+    if (isExpressionBuilder(column)) {
+      const operationExpr = column.expr;
       if (operationExpr.returns.kind === 'typeId') {
         projectionCodecs[alias] = operationExpr.returns.type;
       }

package/src/relations/include-plan.ts

@@ -19,6 +19,7 @@ import type {
   BuildOptions,
   NestedProjection,
 } from '@prisma-next/sql-relational-core/types';
+import { isExpressionBuilder } from '@prisma-next/sql-relational-core/utils/guards';
 import { checkIncludeCapabilities } from '../orm/capabilities';
 import type { OrmIncludeState, RelationFilter } from '../orm/state';
 import { buildJoinOnExpr } from '../selection/join';
@@ -175,12 +176,11 @@ export function buildIncludeAsts(input: BuildIncludeAstsInput): {
       if (!column) {
         errorMissingColumn(alias, i);
       }
-      const operationExpr = (column as { _operationExpr?: OperationExpr })._operationExpr;
-      if (operationExpr) {
-        childProjectionItems.push({ alias, expr: operationExpr });
+      if (isExpressionBuilder(column)) {
+        childProjectionItems.push({ alias, expr: column.expr });
       } else {
-        const col = column as { table: string; column: string };
-        childProjectionItems.push({ alias, expr: createColumnRef(col.table, col.column) });
+        // ColumnBuilder - use toExpr() to get ColumnRef
+        childProjectionItems.push({ alias, expr: column.toExpr() });
       }
     }
 

package/src/selection/predicates.ts

@@ -1,21 +1,14 @@
 import type { ParamDescriptor } from '@prisma-next/contract/types';
 import type { SqlContract, SqlStorage, StorageColumn } from '@prisma-next/sql-contract/types';
-import type {
-  BinaryExpr,
-  ColumnRef,
-  OperationExpr,
-  ParamRef,
-} from '@prisma-next/sql-relational-core/ast';
+import type { BinaryExpr, Expression, ParamRef } from '@prisma-next/sql-relational-core/ast';
 import { augmentDescriptorWithColumnMeta } from '@prisma-next/sql-relational-core/plan';
 import type { BinaryBuilder, ParamPlaceholder } from '@prisma-next/sql-relational-core/types';
 import {
-  getColumnInfo,
-  getColumnMeta,
-  getOperationExpr,
   isColumnBuilder,
+  isExpressionBuilder,
   isParamPlaceholder,
 } from '@prisma-next/sql-relational-core/utils/guards';
-import { createBinaryExpr, createColumnRef, createParamRef } from '../utils/ast';
+import { createBinaryExpr, createParamRef } from '../utils/ast';
 import {
   errorFailedToBuildWhereClause,
   errorMissingParameter,
@@ -33,16 +26,17 @@ export function buildWhereExpr(
   codecId?: string;
   paramName: string;
 } {
-  let leftExpr: ColumnRef | OperationExpr;
+  let leftExpr: Expression;
   let codecId: string | undefined;
-  let rightExpr: ColumnRef | ParamRef;
+  let rightExpr: Expression | ParamRef;
   let paramName: string;
 
-  const operationExpr = getOperationExpr(where.left);
-  if (operationExpr) {
-    leftExpr = operationExpr;
-  } else if (isColumnBuilder(where.left)) {
-    const { table, column } = getColumnInfo(where.left);
+  // where.left is now an Expression (ColumnRef or OperationExpr)
+  leftExpr = where.left;
+
+  // If leftExpr is a ColumnRef, extract codecId from contract
+  if (leftExpr.kind === 'col') {
+    const { table, column } = leftExpr;
 
     const contractTable = contract.storage.tables[table];
     if (!contractTable) {
@@ -55,12 +49,9 @@ export function buildWhereExpr(
     if (columnMeta) {
       codecId = columnMeta.codecId;
     }
-    leftExpr = createColumnRef(table, column);
-  } else {
-    errorFailedToBuildWhereClause();
   }
 
-  // Handle where.right - can be ParamPlaceholder or AnyColumnBuilder
+  // Handle where.right - can be ParamPlaceholder or AnyExpressionSource
   if (isParamPlaceholder(where.right)) {
     // Handle param placeholder (existing logic)
     const placeholder: ParamPlaceholder = where.right;
@@ -73,42 +64,35 @@ export function buildWhereExpr(
     const value = paramsMap[paramName];
     const index = values.push(value);
 
-    // Construct descriptor if where.left is a ColumnBuilder
-    if (isColumnBuilder(where.left)) {
-      const { table, column } = getColumnInfo(where.left);
+    // Construct descriptor from where.left Expression
+    // For ColumnRef, we can extract table/column directly
+    // For OperationExpr, we extract the base column reference
+    if (leftExpr.kind === 'col') {
+      const { table, column } = leftExpr;
       const contractTable = contract.storage.tables[table];
       const columnMeta = contractTable?.columns[column];
-      const builderColumnMeta = getColumnMeta(where.left);
 
       descriptors.push({
         name: paramName,
         source: 'dsl',
         refs: { table, column },
-        ...(typeof builderColumnMeta?.nullable === 'boolean'
-          ? { nullable: builderColumnMeta.nullable }
+        ...(columnMeta && typeof columnMeta.nullable === 'boolean'
+          ? { nullable: columnMeta.nullable }
           : {}),
       });
 
       augmentDescriptorWithColumnMeta(descriptors, columnMeta);
     }
+    // For OperationExpr, we don't create descriptors since we can't reliably extract column info
 
     rightExpr = createParamRef(index, paramName);
-  } else if (isColumnBuilder(where.right)) {
-    // Handle column builder on the right
-    const { table, column } = getColumnInfo(where.right);
-
-    const contractTable = contract.storage.tables[table];
-    if (!contractTable) {
-      errorUnknownTable(table);
-    }
-
-    // If column not found in contract, still build expression
-    // This allows flexibility when columnMeta is available on the column builder
-    rightExpr = createColumnRef(table, column);
-    // Use a placeholder paramName for column references (not used for params)
+  } else if (isColumnBuilder(where.right) || isExpressionBuilder(where.right)) {
+    // Handle ExpressionSource on the right - use toExpr() to get the Expression
+    rightExpr = where.right.toExpr();
+    // Use a placeholder paramName for expression references (not used for params)
     paramName = '';
   } else {
-    // where.right is neither ParamPlaceholder nor ColumnBuilder - invalid state
+    // where.right is neither ParamPlaceholder nor ExpressionSource - invalid state
     errorFailedToBuildWhereClause();
   }
 

package/src/selection/projection.ts

@@ -1,12 +1,15 @@
 import type { TableRef } from '@prisma-next/sql-relational-core/ast';
 import type {
   AnyBinaryBuilder,
-  AnyColumnBuilder,
+  AnyExpressionSource,
   AnyOrderBuilder,
   JoinOnPredicate,
   NestedProjection,
 } from '@prisma-next/sql-relational-core/types';
-import { isColumnBuilder } from '@prisma-next/sql-relational-core/utils/guards';
+import {
+  isColumnBuilder,
+  isExpressionBuilder,
+} from '@prisma-next/sql-relational-core/utils/guards';
 import {
   errorAliasCollision,
   errorAliasPathEmpty,
@@ -18,10 +21,10 @@ import {
 
 export interface ProjectionState {
   readonly aliases: string[];
-  readonly columns: AnyColumnBuilder[];
+  readonly columns: AnyExpressionSource[];
 }
 
-export type ProjectionInput = Record<string, AnyColumnBuilder | boolean | NestedProjection>;
+export type ProjectionInput = Record<string, AnyExpressionSource | boolean | NestedProjection>;
 
 function generateAlias(path: string[]): string {
   if (path.length === 0) {
@@ -58,14 +61,14 @@ export function flattenProjection(
   projection: NestedProjection,
   tracker: AliasTracker,
   currentPath: string[] = [],
-): { aliases: string[]; columns: AnyColumnBuilder[] } {
+): { aliases: string[]; columns: AnyExpressionSource[] } {
   const aliases: string[] = [];
-  const columns: AnyColumnBuilder[] = [];
+  const columns: AnyExpressionSource[] = [];
 
   for (const [key, value] of Object.entries(projection)) {
     const path = [...currentPath, key];
 
-    if (isColumnBuilder(value)) {
+    if (isColumnBuilder(value) || isExpressionBuilder(value)) {
       const alias = tracker.register(path);
       aliases.push(alias);
       columns.push(value);
@@ -96,7 +99,7 @@ export function buildProjectionState(
 ): ProjectionState {
   const tracker = new AliasTracker();
   const aliases: string[] = [];
-  const columns: AnyColumnBuilder[] = [];
+  const columns: AnyExpressionSource[] = [];
 
   for (const [key, value] of Object.entries(projection)) {
     if (value === true) {
@@ -114,8 +117,11 @@ export function buildProjectionState(
           codecId: 'core/json@1',
           nullable: true,
         },
-      } as AnyColumnBuilder);
-    } else if (isColumnBuilder(value)) {
+        toExpr() {
+          return { kind: 'col', table: matchingInclude.table.name, column: '' };
+        },
+      } as AnyExpressionSource);
+    } else if (isColumnBuilder(value) || isExpressionBuilder(value)) {
       const alias = tracker.register([key]);
       aliases.push(alias);
       columns.push(value);

package/src/selection/select-builder.ts

@@ -1,24 +1,24 @@
 import type {
   BinaryExpr,
-  ColumnRef,
   Direction,
   ExistsExpr,
+  Expression,
   IncludeAst,
   IncludeRef,
-  OperationExpr,
   SelectAst,
   TableRef,
 } from '@prisma-next/sql-relational-core/ast';
+import { isExpressionBuilder } from '@prisma-next/sql-relational-core/utils/guards';
 import type { IncludeState } from '../relations/include-plan';
-import { createColumnRef, createSelectAst, createTableRef } from '../utils/ast';
+import { createSelectAst, createTableRef } from '../utils/ast';
 import { errorInvalidColumn, errorMissingAlias, errorMissingColumn } from '../utils/errors';
 import type { ProjectionState } from './projection';
 
 export function buildProjectionItems(
   projectionState: ProjectionState,
   includesForMeta: ReadonlyArray<IncludeState>,
-): Array<{ alias: string; expr: ColumnRef | IncludeRef | OperationExpr }> {
-  const projectEntries: Array<{ alias: string; expr: ColumnRef | IncludeRef | OperationExpr }> = [];
+): Array<{ alias: string; expr: Expression | IncludeRef }> {
+  const projectEntries: Array<{ alias: string; expr: Expression | IncludeRef }> = [];
   for (let i = 0; i < projectionState.aliases.length; i++) {
     const alias = projectionState.aliases[i];
     if (!alias) {
@@ -35,25 +35,23 @@ export function buildProjectionItems(
         alias,
         expr: { kind: 'includeRef', alias },
       });
+    } else if (isExpressionBuilder(column)) {
+      // ExpressionBuilder (operation result) - use its expr
+      projectEntries.push({
+        alias,
+        expr: column.expr,
+      });
     } else {
-      const operationExpr = (column as { _operationExpr?: OperationExpr })._operationExpr;
-      if (operationExpr) {
-        projectEntries.push({
-          alias,
-          expr: operationExpr,
-        });
-      } else {
-        const col = column as { table: string; column: string };
-        const tableName = col.table;
-        const columnName = col.column;
-        if (!tableName || !columnName) {
-          errorInvalidColumn(alias, i);
-        }
-        projectEntries.push({
-          alias,
-          expr: createColumnRef(tableName, columnName),
-        });
+      // ColumnBuilder - use toExpr() to get ColumnRef
+      const expr = column.toExpr();
+      // Validate the expression has valid table and column values
+      if (expr.kind === 'col' && (!expr.table || !expr.column)) {
+        errorInvalidColumn(alias, i);
       }
+      projectEntries.push({
+        alias,
+        expr,
+      });
     }
   }
   return projectEntries;
@@ -61,11 +59,11 @@ export function buildProjectionItems(
 
 export function buildSelectAst(params: {
   table: TableRef;
-  projectEntries: Array<{ alias: string; expr: ColumnRef | IncludeRef | OperationExpr }>;
+  projectEntries: Array<{ alias: string; expr: Expression | IncludeRef }>;
   includesAst?: ReadonlyArray<IncludeAst>;
   whereExpr?: BinaryExpr | ExistsExpr;
   orderByClause?: ReadonlyArray<{
-    expr: ColumnRef | OperationExpr;
+    expr: Expression;
     dir: Direction;
   }>;
   limit?: number;