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

package/src/sql/plan.ts

@@ -1,72 +1,42 @@
 import type { PlanMeta } from '@prisma-next/contract/types';
-import type { Expression } from '@prisma-next/sql-relational-core/ast';
+import type { OperationExpr } from '@prisma-next/sql-relational-core/ast';
 import { compact } from '@prisma-next/sql-relational-core/ast';
-import type { AnyExpressionSource } from '@prisma-next/sql-relational-core/types';
+import type { AnyColumnBuilder } from '@prisma-next/sql-relational-core/types';
 import {
   collectColumnRefs,
+  getColumnInfo,
+  getOperationExpr,
   isColumnBuilder,
-  isExpressionBuilder,
   isOperationExpr,
 } from '@prisma-next/sql-relational-core/utils/guards';
 import type { MetaBuildArgs } from '../types/internal';
 import { assertColumnBuilder } from '../utils/assertions';
 import { errorMissingColumnForAlias } from '../utils/errors';
 
-/**
- * Extracts column references from an ExpressionSource (ColumnBuilder or ExpressionBuilder).
- */
-function collectRefsFromExpressionSource(
-  source: AnyExpressionSource,
-  refsColumns: Map<string, { table: string; column: string }>,
-): void {
-  if (isExpressionBuilder(source)) {
-    // ExpressionBuilder has an OperationExpr - collect all column refs
-    const allRefs = collectColumnRefs(source.expr);
-    for (const ref of allRefs) {
-      refsColumns.set(`${ref.table}.${ref.column}`, {
-        table: ref.table,
-        column: ref.column,
-      });
-    }
-  } else if (isColumnBuilder(source)) {
-    // ColumnBuilder - use table and column directly
-    const col = source as unknown as { table: string; column: string };
-    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);
+    // Skip null columns (include placeholders)
+    if (!column) {
+      continue;
+    }
+    const operationExpr = getOperationExpr(column);
+    if (operationExpr) {
+      const allRefs = collectColumnRefs(operationExpr);
+      for (const ref of allRefs) {
+        refsColumns.set(`${ref.table}.${ref.column}`, {
+          table: ref.table,
+          column: ref.column,
+        });
+      }
+    } else {
+      refsColumns.set(`${column.table}.${column.column}`, {
+        table: column.table,
+        column: column.column,
+      });
+    }
   }
 
   if (args.joins) {
@@ -111,27 +81,42 @@ export function buildMeta(args: MetaBuildArgs): PlanMeta {
       }
       // Add child WHERE columns if present
       if (include.childWhere) {
-        // childWhere.left is Expression (already converted at builder creation time)
-        collectRefsFromExpression(include.childWhere.left, refsColumns);
-        // Handle right side of child WHERE clause - can be ParamPlaceholder or ExpressionSource
+        const colInfo = getColumnInfo(include.childWhere.left);
+        refsColumns.set(`${colInfo.table}.${colInfo.column}`, {
+          table: colInfo.table,
+          column: colInfo.column,
+        });
+        // Handle right side of child WHERE clause
         const childWhereRight = include.childWhere.right;
-        if (isColumnBuilder(childWhereRight) || isExpressionBuilder(childWhereRight)) {
-          collectRefsFromExpressionSource(childWhereRight, refsColumns);
+        if (isColumnBuilder(childWhereRight)) {
+          const rightColInfo = getColumnInfo(childWhereRight);
+          refsColumns.set(`${rightColInfo.table}.${rightColInfo.column}`, {
+            table: rightColInfo.table,
+            column: rightColInfo.column,
+          });
         }
       }
       // Add child ORDER BY columns if present
       if (include.childOrderBy) {
-        // childOrderBy.expr is Expression (already converted at builder creation time)
-        collectRefsFromExpression(include.childOrderBy.expr, refsColumns);
+        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,
+          });
+        }
       }
     }
   }
 
   if (args.where) {
-    // args.where.left is Expression (already converted at builder creation time)
-    const leftExpr: Expression = args.where.left;
-    if (isOperationExpr(leftExpr)) {
-      const allRefs = collectColumnRefs(leftExpr);
+    const whereLeft = args.where.left;
+    // Check if whereLeft is an OperationExpr directly (not wrapped in ColumnBuilder)
+    if (isOperationExpr(whereLeft)) {
+      const allRefs = collectColumnRefs(whereLeft);
       for (const ref of allRefs) {
         refsColumns.set(`${ref.table}.${ref.column}`, {
           table: ref.table,
@@ -139,37 +124,56 @@ export function buildMeta(args: MetaBuildArgs): PlanMeta {
         });
       }
     } else {
-      // leftExpr is ColumnRef
-      refsColumns.set(`${leftExpr.table}.${leftExpr.column}`, {
-        table: leftExpr.table,
-        column: leftExpr.column,
-      });
+      // Check if whereLeft is a ColumnBuilder with an _operationExpr property
+      const operationExpr = (whereLeft as { _operationExpr?: OperationExpr })._operationExpr;
+      if (operationExpr) {
+        const allRefs = collectColumnRefs(operationExpr);
+        for (const ref of allRefs) {
+          refsColumns.set(`${ref.table}.${ref.column}`, {
+            table: ref.table,
+            column: ref.column,
+          });
+        }
+      } else {
+        const colBuilder = assertColumnBuilder(whereLeft, 'where clause must be a ColumnBuilder');
+        refsColumns.set(`${colBuilder.table}.${colBuilder.column}`, {
+          table: colBuilder.table,
+          column: colBuilder.column,
+        });
+      }
     }
 
-    // Handle right side of WHERE clause - can be ParamPlaceholder or AnyExpressionSource
+    // Handle right side of WHERE clause - can be ParamPlaceholder or AnyColumnBuilder
     const whereRight = args.where.right;
-    if (isColumnBuilder(whereRight) || isExpressionBuilder(whereRight)) {
-      collectRefsFromExpressionSource(whereRight, refsColumns);
+    if (isColumnBuilder(whereRight)) {
+      const colInfo = getColumnInfo(whereRight);
+      refsColumns.set(`${colInfo.table}.${colInfo.column}`, {
+        table: colInfo.table,
+        column: colInfo.column,
+      });
     }
   }
 
   if (args.orderBy) {
-    // 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,
+    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 {
+        refsColumns.set(`${orderByExpr.table}.${orderByExpr.column}`, {
+          table: orderByExpr.table,
+          column: orderByExpr.column,
         });
       }
-    } else {
-      // orderByExpr is ColumnRef
-      refsColumns.set(`${orderByExpr.table}.${orderByExpr.column}`, {
-        table: orderByExpr.table,
-        column: orderByExpr.column,
-      });
     }
   }
 
@@ -187,18 +191,13 @@ export function buildMeta(args: MetaBuildArgs): PlanMeta {
         // This shouldn't happen if projection building is correct, but handle gracefully
         errorMissingColumnForAlias(alias, index);
       }
-      // Check if column is an ExpressionBuilder (operation result)
-      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) {
-        // This is a placeholder column for an include - skip it
-        return [alias, `include:${alias}`];
+
+      const operationExpr = getOperationExpr(column);
+      if (operationExpr) {
+        return [alias, `operation:${operationExpr.method}`];
       }
 
-      return [alias, `${col.table}.${col.column}`];
+      return [alias, `${column.table}.${column.column}`];
     }),
   );
 
@@ -214,15 +213,15 @@ export function buildMeta(args: MetaBuildArgs): PlanMeta {
     if (!column) {
       continue;
     }
-    if (isExpressionBuilder(column)) {
-      const operationExpr = column.expr;
+    const operationExpr = (column as { _operationExpr?: OperationExpr })._operationExpr;
+    if (operationExpr) {
       if (operationExpr.returns.kind === 'typeId') {
         projectionTypes[alias] = operationExpr.returns.type;
       } else if (operationExpr.returns.kind === 'builtin') {
         projectionTypes[alias] = operationExpr.returns.type;
       }
     } else {
-      // column is ColumnBuilder
+      // TypeScript can't narrow ColumnBuilder properly
       const col = column as unknown as { columnMeta?: { codecId: string } };
       const columnMeta = col.columnMeta;
       const codecId = columnMeta?.codecId;
@@ -244,14 +243,14 @@ export function buildMeta(args: MetaBuildArgs): PlanMeta {
     if (!column) {
       continue;
     }
-    if (isExpressionBuilder(column)) {
-      const operationExpr = column.expr;
+    const operationExpr = (column as { _operationExpr?: OperationExpr })._operationExpr;
+    if (operationExpr) {
       if (operationExpr.returns.kind === 'typeId') {
         projectionCodecs[alias] = operationExpr.returns.type;
       }
     } else {
       // Use columnMeta.codecId directly as typeId (already canonicalized)
-      // column is ColumnBuilder
+      // TypeScript can't narrow ColumnBuilder properly
       const col = column as unknown as { columnMeta?: { codecId: string } };
       const columnMeta = col.columnMeta;
       const codecId = columnMeta?.codecId;

package/src/sql/predicate-builder.ts

@@ -1,11 +1,21 @@
 import type { ParamDescriptor } from '@prisma-next/contract/types';
 import type { SqlContract, SqlStorage, StorageColumn } from '@prisma-next/sql-contract/types';
-import type { BinaryExpr, Expression, ParamRef } from '@prisma-next/sql-relational-core/ast';
-import { createBinaryExpr, createParamRef } from '@prisma-next/sql-relational-core/ast';
+import type {
+  BinaryExpr,
+  ColumnRef,
+  OperationExpr,
+  ParamRef,
+} from '@prisma-next/sql-relational-core/ast';
+import {
+  createBinaryExpr,
+  createColumnRef,
+  createParamRef,
+} from '@prisma-next/sql-relational-core/ast';
 import type { BinaryBuilder, ParamPlaceholder } from '@prisma-next/sql-relational-core/types';
 import {
+  getColumnInfo,
+  getOperationExpr,
   isColumnBuilder,
-  isExpressionBuilder,
   isParamPlaceholder,
 } from '@prisma-next/sql-relational-core/utils/guards';
 import {
@@ -28,28 +38,20 @@ export function buildWhereExpr(
   descriptors: ParamDescriptor[],
   values: unknown[],
 ): BuildWhereExprResult {
-  let leftExpr: Expression;
+  let leftExpr: ColumnRef | OperationExpr;
   let codecId: string | undefined;
-  let rightExpr: Expression | ParamRef;
+  let rightExpr: ColumnRef | ParamRef;
   let paramName: string;
 
-  // Validate where.left is a valid Expression (col or operation)
-  const validExpressionKinds = ['col', 'operation'];
-  if (
-    !where.left ||
-    typeof where.left !== 'object' ||
-    !validExpressionKinds.includes((where.left as { kind?: string }).kind ?? '')
-  ) {
-    errorFailedToBuildWhereClause();
-  }
-
-  // where.left is an Expression (already converted at builder creation time)
-  // It could be a ColumnRef or OperationExpr
-  leftExpr = where.left;
+  // Check if where.left is an OperationExpr directly (from operation.eq())
+  // or a ColumnBuilder with _operationExpr property
+  const operationExpr = getOperationExpr(where.left);
+  if (operationExpr) {
+    leftExpr = operationExpr;
+  } else if (isColumnBuilder(where.left)) {
+    // where.left is a ColumnBuilder - use proper type narrowing
+    const { table, column } = getColumnInfo(where.left);
 
-  // If the left expression is a column reference, extract codecId for param descriptors
-  if (leftExpr.kind === 'col') {
-    const { table, column } = leftExpr;
     const contractTable = contract.storage.tables[table];
     if (!contractTable) {
       errorUnknownTable(table);
@@ -61,9 +63,13 @@ export function buildWhereExpr(
     }
 
     codecId = columnMeta.codecId;
+    leftExpr = createColumnRef(table, column);
+  } else {
+    // where.left is neither OperationExpr nor ColumnBuilder - invalid state
+    errorFailedToBuildWhereClause();
   }
 
-  // Handle where.right - can be ParamPlaceholder or ExpressionSource
+  // Handle where.right - can be ParamPlaceholder or AnyColumnBuilder
   if (isParamPlaceholder(where.right)) {
     // Handle param placeholder (existing logic)
     const placeholder: ParamPlaceholder = where.right;
@@ -76,9 +82,9 @@ export function buildWhereExpr(
     const value = paramsMap[paramName];
     const index = values.push(value);
 
-    // Construct descriptor directly from validated StorageColumn if left is a column
-    if (leftExpr.kind === 'col') {
-      const { table, column } = leftExpr;
+    // Construct descriptor directly from validated StorageColumn
+    if (isColumnBuilder(where.left)) {
+      const { table, column } = getColumnInfo(where.left);
       const contractTable = contract.storage.tables[table];
       const columnMeta = contractTable?.columns[column];
       if (columnMeta) {
@@ -94,28 +100,25 @@ export function buildWhereExpr(
     }
 
     rightExpr = createParamRef(index, paramName);
-  } else if (isColumnBuilder(where.right) || isExpressionBuilder(where.right)) {
-    // Handle ExpressionSource (ColumnBuilder or ExpressionBuilder) on the right
-    rightExpr = where.right.toExpr();
+  } else if (isColumnBuilder(where.right)) {
+    // Handle column builder on the right
+    const { table, column } = getColumnInfo(where.right);
 
-    // Validate column exists in contract if it's a ColumnRef
-    if (rightExpr.kind === 'col') {
-      const { table, column } = rightExpr;
-      const contractTable = contract.storage.tables[table];
-      if (!contractTable) {
-        errorUnknownTable(table);
-      }
+    const contractTable = contract.storage.tables[table];
+    if (!contractTable) {
+      errorUnknownTable(table);
+    }
 
-      const columnMeta: StorageColumn | undefined = contractTable.columns[column];
-      if (!columnMeta) {
-        errorUnknownColumn(column, table);
-      }
+    const columnMeta: StorageColumn | undefined = contractTable.columns[column];
+    if (!columnMeta) {
+      errorUnknownColumn(column, table);
     }
 
-    // Use a placeholder paramName for expression references (not used for params)
+    rightExpr = createColumnRef(table, column);
+    // Use a placeholder paramName for column references (not used for params)
     paramName = '';
   } else {
-    // where.right is neither ParamPlaceholder nor ExpressionSource - invalid state
+    // where.right is neither ParamPlaceholder nor ColumnBuilder - invalid state
     errorFailedToBuildWhereClause();
   }
 

package/src/sql/projection.ts

@@ -1,6 +1,6 @@
 import type { TableRef } from '@prisma-next/sql-relational-core/ast';
-import type { AnyExpressionSource, NestedProjection } from '@prisma-next/sql-relational-core/types';
-import { isExpressionSource } from '@prisma-next/sql-relational-core/utils/guards';
+import type { AnyColumnBuilder, NestedProjection } from '@prisma-next/sql-relational-core/types';
+import { isColumnBuilder } from '@prisma-next/sql-relational-core/utils/guards';
 import type { ProjectionInput } from '../types/internal';
 import {
   errorAliasCollision,
@@ -47,14 +47,14 @@ export function flattenProjection(
   projection: NestedProjection,
   tracker: AliasTracker,
   currentPath: string[] = [],
-): { aliases: string[]; columns: AnyExpressionSource[] } {
+): { aliases: string[]; columns: AnyColumnBuilder[] } {
   const aliases: string[] = [];
-  const columns: AnyExpressionSource[] = [];
+  const columns: AnyColumnBuilder[] = [];
 
   for (const [key, value] of Object.entries(projection)) {
     const path = [...currentPath, key];
 
-    if (isExpressionSource(value)) {
+    if (isColumnBuilder(value)) {
       const alias = tracker.register(path);
       aliases.push(alias);
       columns.push(value);
@@ -77,7 +77,7 @@ export function buildProjectionState(
 ): ProjectionState {
   const tracker = new AliasTracker();
   const aliases: string[] = [];
-  const columns: AnyExpressionSource[] = [];
+  const columns: (AnyColumnBuilder | null)[] = [];
 
   for (const [key, value] of Object.entries(projection)) {
     if (value === true) {
@@ -86,17 +86,12 @@ export function buildProjectionState(
       if (!matchingInclude) {
         errorIncludeAliasNotFound(key);
       }
-      // For include references, we track the alias but use a placeholder object
+      // For include references, we track the alias but use null as placeholder
       // The actual handling happens in AST building where we create includeRef
+      // Using null instead of invalid ColumnBuilder avoids code smell
       aliases.push(key);
-      columns.push({
-        kind: 'column',
-        table: matchingInclude.table.name,
-        column: '',
-        columnMeta: { nativeType: 'jsonb', codecId: 'core/json@1', nullable: true },
-        toExpr: () => ({ kind: 'col', table: matchingInclude.table.name, column: '' }),
-      } as AnyExpressionSource);
-    } else if (isExpressionSource(value)) {
+      columns.push(null);
+    } else if (isColumnBuilder(value)) {
       const alias = tracker.register([key]);
       aliases.push(alias);
       columns.push(value);

package/src/sql/select-builder.ts

@@ -11,6 +11,7 @@ import type {
   TableRef,
 } from '@prisma-next/sql-relational-core/ast';
 import {
+  createColumnRef,
   createJoinOnBuilder,
   createOrderByItem,
   createSelectAst,
@@ -30,8 +31,9 @@ import type {
   OrderBuilder,
   SqlBuilderOptions,
 } from '@prisma-next/sql-relational-core/types';
-import { isExpressionBuilder } from '@prisma-next/sql-relational-core/utils/guards';
+import { getOperationExpr } from '@prisma-next/sql-relational-core/utils/guards';
 import type { ProjectionInput } from '../types/internal';
+import { assertColumnBuilder } from '../utils/assertions';
 import { checkIncludeCapabilities } from '../utils/capabilities';
 import {
   errorChildProjectionEmpty,
@@ -39,6 +41,7 @@ import {
   errorIncludeAliasCollision,
   errorLimitMustBeNonNegativeInteger,
   errorMissingAlias,
+  errorMissingColumnForAlias,
   errorSelectMustBeCalled,
   errorSelfJoinNotSupported,
   errorUnknownTable,
@@ -317,8 +320,15 @@ export class SelectBuilderImpl<
     const orderByClause = this.state.orderBy
       ? (() => {
           const orderBy = this.state.orderBy as OrderBuilder<string, StorageColumn, unknown>;
-          // orderBy.expr is already an Expression (ColumnRef or OperationExpr)
-          return [createOrderByItem(orderBy.expr, orderBy.dir)];
+          const orderExpr = orderBy.expr;
+          const operationExpr = getOperationExpr(orderExpr);
+          const expr: ColumnRef | OperationExpr = operationExpr
+            ? operationExpr
+            : (() => {
+                const colBuilder = orderExpr as { table: string; column: string };
+                return createColumnRef(colBuilder.table, colBuilder.column);
+              })();
+          return [createOrderByItem(expr, orderBy.dir)];
         })()
       : undefined;
 
@@ -347,19 +357,28 @@ export class SelectBuilderImpl<
           alias,
           expr: { kind: 'includeRef', alias },
         });
-      } else if (column && isExpressionBuilder(column)) {
-        // This is an ExpressionBuilder (operation result) - use its expr
-        projectEntries.push({
-          alias,
-          expr: column.expr,
-        });
-      } else if (column) {
-        // This is a regular ColumnBuilder - use toExpr() to get ColumnRef
-        const columnRef = column.toExpr();
-        projectEntries.push({
-          alias,
-          expr: columnRef,
-        });
+      } else {
+        // Not an include - column must not be null
+        if (!column) {
+          errorMissingColumnForAlias(alias, i);
+        }
+        // Check if this column has an operation expression
+        const operationExpr = (column as { _operationExpr?: OperationExpr })._operationExpr;
+        if (operationExpr) {
+          projectEntries.push({
+            alias,
+            expr: operationExpr,
+          });
+        } else {
+          // This is a regular column
+          // TypeScript can't narrow ColumnBuilder properly
+          const col = column as { table: string; column: string };
+          assertColumnBuilder(col, 'projection column');
+          projectEntries.push({
+            alias,
+            expr: createColumnRef(col.table, col.column),
+          });
+        }
       }
     }
 

package/src/types/internal.ts

@@ -3,13 +3,13 @@ import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
 import type { TableRef } from '@prisma-next/sql-relational-core/ast';
 import type {
   AnyBinaryBuilder,
-  AnyExpressionSource,
+  AnyColumnBuilder,
   AnyOrderBuilder,
   NestedProjection,
 } from '@prisma-next/sql-relational-core/types';
 import type { ProjectionState } from '../utils/state';
 
-export type ProjectionInput = Record<string, AnyExpressionSource | boolean | NestedProjection>;
+export type ProjectionInput = Record<string, AnyColumnBuilder | boolean | NestedProjection>;
 
 export interface MetaBuildArgs {
   readonly contract: SqlContract<SqlStorage>;

package/src/utils/errors.ts

@@ -98,7 +98,7 @@ export function errorMissingParameter(paramName: string): never {
 
 export function errorInvalidProjectionValue(path: string[]): never {
   throw planInvalid(
-    `Invalid projection value at path ${path.join('.')}: expected ExpressionSource (ColumnBuilder or ExpressionBuilder) or nested object`,
+    `Invalid projection value at path ${path.join('.')}: expected ColumnBuilder or nested object`,
   );
 }
 

package/src/utils/state.ts

@@ -1,14 +1,16 @@
 import type { TableRef } from '@prisma-next/sql-relational-core/ast';
 import type {
   AnyBinaryBuilder,
-  AnyExpressionSource,
+  AnyColumnBuilder,
   AnyOrderBuilder,
   JoinOnPredicate,
 } from '@prisma-next/sql-relational-core/types';
 
 export interface ProjectionState {
   readonly aliases: string[];
-  readonly columns: AnyExpressionSource[];
+  // columns can be null for include placeholders (when alias matches an include)
+  // This maintains array alignment but avoids creating invalid ColumnBuilders
+  readonly columns: (AnyColumnBuilder | null)[];
 }
 
 export interface JoinState {