@prisma-next/sql-lane 0.3.0-dev.6 → 0.3.0-dev.63

package/src/sql/projection.ts

@@ -1,6 +1,6 @@
 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 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 +47,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,7 +77,7 @@ 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) {
@@ -86,12 +86,17 @@ export function buildProjectionState(
       if (!matchingInclude) {
         errorIncludeAliasNotFound(key);
       }
-      // For include references, we track the alias but use null as placeholder
+      // For include references, we track the alias but use a placeholder object
       // 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: () => ({ kind: 'col', table: matchingInclude.table.name, column: '' }),
+      } as AnyExpressionSource);
+    } else if (isExpressionSource(value)) {
       const alias = tracker.register([key]);
       aliases.push(alias);
       columns.push(value);

package/src/sql/select-builder.ts

@@ -1,7 +1,6 @@
 import type { ParamDescriptor } from '@prisma-next/contract/types';
 import type { SqlContract, SqlStorage, StorageColumn } from '@prisma-next/sql-contract/types';
 import type {
-  BinaryExpr,
   ColumnRef,
   Direction,
   IncludeAst,
@@ -9,19 +8,20 @@ import type {
   JoinAst,
   OperationExpr,
   TableRef,
+  WhereExpr,
 } from '@prisma-next/sql-relational-core/ast';
 import {
-  createColumnRef,
   createJoinOnBuilder,
   createOrderByItem,
   createSelectAst,
   createTableRef,
 } from '@prisma-next/sql-relational-core/ast';
 import type { SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';
-import type { QueryLaneContext } from '@prisma-next/sql-relational-core/query-lane-context';
+import type { ExecutionContext } from '@prisma-next/sql-relational-core/query-lane-context';
 import type {
   AnyBinaryBuilder,
   AnyOrderBuilder,
+  AnyUnaryBuilder,
   BinaryBuilder,
   BuildOptions,
   InferNestedProjectionRow,
@@ -30,10 +30,10 @@ import type {
   NestedProjection,
   OrderBuilder,
   SqlBuilderOptions,
+  UnaryBuilder,
 } from '@prisma-next/sql-relational-core/types';
-import { getOperationExpr } from '@prisma-next/sql-relational-core/utils/guards';
+import { isExpressionBuilder } 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,
@@ -41,7 +41,6 @@ import {
   errorIncludeAliasCollision,
   errorLimitMustBeNonNegativeInteger,
   errorMissingAlias,
-  errorMissingColumnForAlias,
   errorSelectMustBeCalled,
   errorSelfJoinNotSupported,
   errorUnknownTable,
@@ -65,7 +64,7 @@ export class SelectBuilderImpl<
 > {
   private readonly contract: TContract;
   private readonly codecTypes: CodecTypes;
-  private readonly context: QueryLaneContext<TContract>;
+  private readonly context: ExecutionContext<TContract>;
   private state: BuilderState = {};
 
   constructor(options: SqlBuilderOptions<TContract>, state?: BuilderState) {
@@ -238,7 +237,9 @@ export class SelectBuilderImpl<
     );
   }
 
-  where(expr: AnyBinaryBuilder): SelectBuilderImpl<TContract, Row, CodecTypes, Includes> {
+  where(
+    expr: AnyBinaryBuilder | AnyUnaryBuilder,
+  ): SelectBuilderImpl<TContract, Row, CodecTypes, Includes> {
     return new SelectBuilderImpl<TContract, Row, CodecTypes, Includes>(
       {
         context: this.context,
@@ -320,15 +321,8 @@ export class SelectBuilderImpl<
     const orderByClause = this.state.orderBy
       ? (() => {
           const orderBy = this.state.orderBy as OrderBuilder<string, StorageColumn, unknown>;
-          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)];
+          // orderBy.expr is already an Expression (ColumnRef or OperationExpr)
+          return [createOrderByItem(orderBy.expr, orderBy.dir)];
         })()
       : undefined;
 
@@ -357,28 +351,19 @@ export class SelectBuilderImpl<
           alias,
           expr: { kind: 'includeRef', alias },
         });
-      } 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),
-          });
-        }
+      } 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,
+        });
       }
     }
 
@@ -395,7 +380,7 @@ export class SelectBuilderImpl<
       joins?: ReadonlyArray<JoinAst>;
       includes?: ReadonlyArray<IncludeAst>;
       project: ReadonlyArray<{ alias: string; expr: ColumnRef | IncludeRef | OperationExpr }>;
-      where?: BinaryExpr;
+      where?: WhereExpr;
       orderBy?: ReadonlyArray<{ expr: ColumnRef | OperationExpr; dir: Direction }>;
       limit?: number;
     });
@@ -416,7 +401,7 @@ export class SelectBuilderImpl<
       projection: ProjectionState;
       joins?: ReadonlyArray<JoinState>;
       includes?: ReadonlyArray<IncludeState>;
-      where?: BinaryBuilder;
+      where?: BinaryBuilder | UnaryBuilder;
       orderBy?: AnyOrderBuilder;
       paramDescriptors: ParamDescriptor[];
       paramCodecs?: Record<string, string>;

package/src/types/internal.ts

@@ -3,13 +3,14 @@ import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
 import type { TableRef } from '@prisma-next/sql-relational-core/ast';
 import type {
   AnyBinaryBuilder,
-  AnyColumnBuilder,
+  AnyExpressionSource,
   AnyOrderBuilder,
+  AnyUnaryBuilder,
   NestedProjection,
 } from '@prisma-next/sql-relational-core/types';
 import type { ProjectionState } from '../utils/state';
 
-export type ProjectionInput = Record<string, AnyColumnBuilder | boolean | NestedProjection>;
+export type ProjectionInput = Record<string, AnyExpressionSource | boolean | NestedProjection>;
 
 export interface MetaBuildArgs {
   readonly contract: SqlContract<SqlStorage>;
@@ -31,10 +32,10 @@ export interface MetaBuildArgs {
       readonly right: unknown;
     };
     readonly childProjection: ProjectionState;
-    readonly childWhere?: AnyBinaryBuilder;
+    readonly childWhere?: AnyBinaryBuilder | AnyUnaryBuilder;
     readonly childOrderBy?: AnyOrderBuilder;
   }>;
-  readonly where?: AnyBinaryBuilder;
+  readonly where?: AnyBinaryBuilder | AnyUnaryBuilder;
   readonly orderBy?: AnyOrderBuilder;
   readonly paramDescriptors: ParamDescriptor[];
   readonly paramCodecs?: Record<string, string>;

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 ColumnBuilder or nested object`,
+    `Invalid projection value at path ${path.join('.')}: expected ExpressionSource (ColumnBuilder or ExpressionBuilder) or nested object`,
   );
 }
 

package/src/utils/state.ts

@@ -1,16 +1,15 @@
 import type { TableRef } from '@prisma-next/sql-relational-core/ast';
 import type {
   AnyBinaryBuilder,
-  AnyColumnBuilder,
+  AnyExpressionSource,
   AnyOrderBuilder,
+  AnyUnaryBuilder,
   JoinOnPredicate,
 } from '@prisma-next/sql-relational-core/types';
 
 export interface ProjectionState {
   readonly aliases: string[];
-  // 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)[];
+  readonly columns: AnyExpressionSource[];
 }
 
 export interface JoinState {
@@ -24,7 +23,7 @@ export interface IncludeState {
   readonly table: TableRef;
   readonly on: JoinOnPredicate;
   readonly childProjection: ProjectionState;
-  readonly childWhere?: AnyBinaryBuilder;
+  readonly childWhere?: AnyBinaryBuilder | AnyUnaryBuilder;
   readonly childOrderBy?: AnyOrderBuilder;
   readonly childLimit?: number;
 }
@@ -34,7 +33,7 @@ export interface BuilderState {
   joins?: ReadonlyArray<JoinState>;
   includes?: ReadonlyArray<IncludeState>;
   projection?: ProjectionState;
-  where?: AnyBinaryBuilder;
+  where?: AnyBinaryBuilder | AnyUnaryBuilder;
   orderBy?: AnyOrderBuilder;
   limit?: number;
 }