@prisma-next/sql-lane 0.3.0-dev.11 → 0.3.0-dev.114

package/src/sql/plan.ts

@@ -1,42 +1,60 @@
 import type { PlanMeta } from '@prisma-next/contract/types';
-import type { OperationExpr } from '@prisma-next/sql-relational-core/ast';
-import { compact } from '@prisma-next/sql-relational-core/ast';
-import type { AnyColumnBuilder } from '@prisma-next/sql-relational-core/types';
+import { type AnyExpression, compact } from '@prisma-next/sql-relational-core/ast';
+import type { AnyExpressionSource } from '@prisma-next/sql-relational-core/types';
 import {
-  collectColumnRefs,
-  getColumnInfo,
-  getOperationExpr,
   isColumnBuilder,
-  isOperationExpr,
+  isExpressionBuilder,
 } 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)) {
+    const allRefs = source.expr.collectColumnRefs();
+    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: AnyExpression,
+  refsColumns: Map<string, { table: string; column: string }>,
+): void {
+  for (const ref of expr.collectColumnRefs()) {
+    refsColumns.set(`${ref.table}.${ref.column}`, {
+      table: ref.table,
+      column: ref.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) {
-    // 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,
-      });
-    }
+    collectRefsFromExpressionSource(column, refsColumns);
   }
 
   if (args.joins) {
@@ -81,100 +99,38 @@ export function buildMeta(args: MetaBuildArgs): PlanMeta {
       }
       // Add child WHERE columns if present
       if (include.childWhere) {
-        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)) {
-          const rightColInfo = getColumnInfo(childWhereRight);
-          refsColumns.set(`${rightColInfo.table}.${rightColInfo.column}`, {
-            table: rightColInfo.table,
-            column: rightColInfo.column,
-          });
+        if (include.childWhere.kind === 'nullCheck') {
+          collectRefsFromExpression(include.childWhere.expr, refsColumns);
+        } else {
+          collectRefsFromExpression(include.childWhere.left, refsColumns);
+          const childWhereRight = include.childWhere.right;
+          if (isColumnBuilder(childWhereRight) || isExpressionBuilder(childWhereRight)) {
+            collectRefsFromExpressionSource(childWhereRight, refsColumns);
+          }
         }
       }
       // Add child ORDER BY columns if present
       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;
-    // 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,
-          column: ref.column,
-        });
-      }
+    if (args.where.kind === 'nullCheck') {
+      collectRefsFromExpression(args.where.expr, refsColumns);
     } else {
-      // 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,
-        });
+      collectRefsFromExpression(args.where.left, refsColumns);
+      const whereRight = args.where.right;
+      if (isColumnBuilder(whereRight) || isExpressionBuilder(whereRight)) {
+        collectRefsFromExpressionSource(whereRight, refsColumns);
       }
     }
-
-    // Handle right side of WHERE clause - can be ParamPlaceholder or AnyColumnBuilder
-    const whereRight = args.where.right;
-    if (isColumnBuilder(whereRight)) {
-      const colInfo = getColumnInfo(whereRight);
-      refsColumns.set(`${colInfo.table}.${colInfo.column}`, {
-        table: colInfo.table,
-        column: colInfo.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 {
-        refsColumns.set(`${orderByExpr.table}.${orderByExpr.column}`, {
-          table: orderByExpr.table,
-          column: orderByExpr.column,
-        });
-      }
-    }
+    collectRefsFromExpression(args.orderBy.expr, refsColumns);
   }
 
   // Build projection map - mark include aliases with special marker
@@ -191,13 +147,18 @@ export function buildMeta(args: MetaBuildArgs): PlanMeta {
         // This shouldn't happen if projection building is correct, but handle gracefully
         errorMissingColumnForAlias(alias, index);
       }
-
-      const operationExpr = getOperationExpr(column);
-      if (operationExpr) {
-        return [alias, `operation:${operationExpr.method}`];
+      // 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}`];
       }
 
-      return [alias, `${column.table}.${column.column}`];
+      return [alias, `${col.table}.${col.column}`];
     }),
   );
 
@@ -213,15 +174,15 @@ 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') {
         projectionTypes[alias] = operationExpr.returns.type;
       } else if (operationExpr.returns.kind === 'builtin') {
         projectionTypes[alias] = operationExpr.returns.type;
       }
     } else {
-      // TypeScript can't narrow ColumnBuilder properly
+      // column is ColumnBuilder
       const col = column as unknown as { columnMeta?: { codecId: string } };
       const columnMeta = col.columnMeta;
       const codecId = columnMeta?.codecId;
@@ -233,7 +194,7 @@ export function buildMeta(args: MetaBuildArgs): PlanMeta {
 
   // Build codec assignments from column types
   // Skip include aliases - they don't need codec entries
-  const projectionCodecs: Record<string, string> = {};
+  const codecs: Record<string, string> = {};
   for (let i = 0; i < args.projection.aliases.length; i++) {
     const alias = args.projection.aliases[i];
     if (!alias || includeAliases.has(alias)) {
@@ -243,34 +204,28 @@ 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;
+        codecs[alias] = operationExpr.returns.type;
       }
     } else {
       // Use columnMeta.codecId directly as typeId (already canonicalized)
-      // TypeScript can't narrow ColumnBuilder properly
+      // column is ColumnBuilder
       const col = column as unknown as { columnMeta?: { codecId: string } };
       const columnMeta = col.columnMeta;
       const codecId = columnMeta?.codecId;
       if (codecId) {
-        projectionCodecs[alias] = codecId;
+        codecs[alias] = codecId;
       }
     }
   }
 
-  // Merge projection and parameter codecs
-  const allCodecs: Record<string, string> = {
-    ...projectionCodecs,
-    ...(args.paramCodecs ? args.paramCodecs : {}),
-  };
-
   return Object.freeze(
     compact({
       target: args.contract.target,
       targetFamily: args.contract.targetFamily,
-      coreHash: args.contract.coreHash,
+      storageHash: args.contract.storageHash,
       lane: 'dsl',
       refs: {
         tables: Array.from(refsTables),
@@ -279,8 +234,13 @@ export function buildMeta(args: MetaBuildArgs): PlanMeta {
       projection: projectionMap,
       projectionTypes: Object.keys(projectionTypes).length > 0 ? projectionTypes : undefined,
       annotations:
-        Object.keys(allCodecs).length > 0
-          ? Object.freeze({ codecs: Object.freeze(allCodecs) })
+        Object.keys(codecs).length > 0 || args.limit !== undefined
+          ? Object.freeze(
+              compact({
+                codecs: Object.keys(codecs).length > 0 ? Object.freeze(codecs) : undefined,
+                limit: args.limit,
+              }),
+            )
           : undefined,
       paramDescriptors: args.paramDescriptors,
       profileHash: args.contract.profileHash,

package/src/sql/predicate-builder.ts

@@ -1,21 +1,20 @@
-import type { ParamDescriptor } from '@prisma-next/contract/types';
+import { planInvalid } from '@prisma-next/plan';
 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 { AnyExpression, NullCheckExpr } from '@prisma-next/sql-relational-core/ast';
 import {
-  createBinaryExpr,
-  createColumnRef,
-  createParamRef,
+  BinaryExpr,
+  NullCheckExpr as NullCheckExprNode,
+  ParamRef as ParamRefNode,
 } from '@prisma-next/sql-relational-core/ast';
-import type { BinaryBuilder, ParamPlaceholder } from '@prisma-next/sql-relational-core/types';
+import type {
+  BinaryBuilder,
+  NullCheckBuilder,
+  ParamPlaceholder,
+  UnaryBuilder,
+} from '@prisma-next/sql-relational-core/types';
 import {
-  getColumnInfo,
-  getOperationExpr,
   isColumnBuilder,
+  isExpressionBuilder,
   isParamPlaceholder,
 } from '@prisma-next/sql-relational-core/utils/guards';
 import {
@@ -26,32 +25,59 @@ import {
 } from '../utils/errors';
 
 export interface BuildWhereExprResult {
-  expr: BinaryExpr;
+  expr: AnyExpression;
   codecId: string | undefined;
   paramName: string;
 }
 
+function isNullCheckBuilder(builder: BinaryBuilder | UnaryBuilder): builder is NullCheckBuilder {
+  return builder.kind === 'nullCheck';
+}
+
+function buildNullCheckExpr(
+  contract: SqlContract<SqlStorage>,
+  where: NullCheckBuilder,
+): NullCheckExpr {
+  const expr = where.expr;
+
+  if (expr.kind === 'column-ref') {
+    const { table, column } = expr;
+    const contractTable = contract.storage.tables[table];
+    if (!contractTable) {
+      errorUnknownTable(table);
+    }
+
+    const columnMeta: StorageColumn | undefined = contractTable.columns[column];
+    if (!columnMeta) {
+      errorUnknownColumn(column, table);
+    }
+  }
+
+  return where.isNull ? NullCheckExprNode.isNull(expr) : NullCheckExprNode.isNotNull(expr);
+}
+
 export function buildWhereExpr(
   contract: SqlContract<SqlStorage>,
-  where: BinaryBuilder,
+  where: BinaryBuilder | UnaryBuilder,
   paramsMap: Record<string, unknown>,
-  descriptors: ParamDescriptor[],
-  values: unknown[],
 ): BuildWhereExprResult {
-  let leftExpr: ColumnRef | OperationExpr;
+  if (isNullCheckBuilder(where)) {
+    return {
+      expr: buildNullCheckExpr(contract, where),
+      codecId: undefined,
+      paramName: '',
+    };
+  }
+
+  let leftExpr: AnyExpression;
   let codecId: string | undefined;
-  let rightExpr: ColumnRef | ParamRef;
+  let rightExpr: AnyExpression;
   let paramName: string;
 
-  // 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);
+  leftExpr = where.left;
 
+  if (leftExpr.kind === 'column-ref') {
+    const { table, column } = leftExpr;
     const contractTable = contract.storage.tables[table];
     if (!contractTable) {
       errorUnknownTable(table);
@@ -63,15 +89,11 @@ export function buildWhereExpr(
     }
 
     codecId = columnMeta.codecId;
-    leftExpr = createColumnRef(table, column);
-  } else {
-    // where.left is neither OperationExpr nor ColumnBuilder - invalid state
-    errorFailedToBuildWhereClause();
+  } else if (leftExpr.kind === 'operation') {
+    codecId = leftExpr.returns.kind === 'typeId' ? leftExpr.returns.type : leftExpr.forTypeId;
   }
 
-  // Handle where.right - can be ParamPlaceholder or AnyColumnBuilder
   if (isParamPlaceholder(where.right)) {
-    // Handle param placeholder (existing logic)
     const placeholder: ParamPlaceholder = where.right;
     paramName = placeholder.name;
 
@@ -80,50 +102,37 @@ export function buildWhereExpr(
     }
 
     const value = paramsMap[paramName];
-    const index = values.push(value);
 
-    // 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) {
-        descriptors.push({
-          name: paramName,
-          source: 'dsl',
-          refs: { table, column },
-          nullable: columnMeta.nullable,
-          codecId: columnMeta.codecId,
-          nativeType: columnMeta.nativeType,
-        });
-      }
+    if (!codecId) {
+      throw planInvalid(`Cannot determine codecId for parameter '${paramName}'`);
     }
+    rightExpr = ParamRefNode.of(value, {
+      name: paramName,
+      codecId,
+    });
+  } else if (isColumnBuilder(where.right) || isExpressionBuilder(where.right)) {
+    rightExpr = where.right.toExpr();
 
-    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 (rightExpr.kind === 'column-ref') {
+      const { table, column } = rightExpr;
+      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);
+      }
     }
 
-    rightExpr = createColumnRef(table, column);
-    // Use a placeholder paramName for column references (not used for params)
     paramName = '';
   } else {
-    // where.right is neither ParamPlaceholder nor ColumnBuilder - invalid state
     errorFailedToBuildWhereClause();
   }
 
   return {
-    expr: createBinaryExpr(where.op, leftExpr, rightExpr),
+    expr: new BinaryExpr(where.op, leftExpr, rightExpr),
     codecId,
     paramName,
   };

package/src/sql/projection.ts

@@ -1,6 +1,7 @@
 import type { TableRef } from '@prisma-next/sql-relational-core/ast';
-import type { AnyColumnBuilder, NestedProjection } from '@prisma-next/sql-relational-core/types';
-import { isColumnBuilder } from '@prisma-next/sql-relational-core/utils/guards';
+import { ColumnRef } 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 { ProjectionInput } from '../types/internal';
 import {
   errorAliasCollision,
@@ -47,14 +48,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 (isExpressionSource(value)) {
       const alias = tracker.register(path);
       aliases.push(alias);
       columns.push(value);
@@ -77,21 +78,25 @@ export function buildProjectionState(
 ): ProjectionState {
   const tracker = new AliasTracker();
   const aliases: string[] = [];
-  const columns: (AnyColumnBuilder | null)[] = [];
+  const columns: AnyExpressionSource[] = [];
 
   for (const [key, value] of Object.entries(projection)) {
     if (value === true) {
-      // Boolean true means this is an include reference
+      // Boolean true marks an include projection alias. The concrete expression
+      // is stitched during include AST construction.
       const matchingInclude = includes?.find((inc) => inc.alias === key);
       if (!matchingInclude) {
         errorIncludeAliasNotFound(key);
       }
-      // 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(null);
-    } else if (isColumnBuilder(value)) {
+      columns.push({
+        kind: 'column',
+        table: matchingInclude.table.name,
+        column: '',
+        columnMeta: { nativeType: 'jsonb', codecId: 'core/json@1', nullable: true },
+        toExpr: () => ColumnRef.of(matchingInclude.table.name, ''),
+      } as AnyExpressionSource);
+    } else if (isExpressionSource(value)) {
       const alias = tracker.register([key]);
       aliases.push(alias);
       columns.push(value);