@prisma-next/sql-lane 0.3.0-dev.10 → 0.3.0-dev.113

package/src/sql/select-builder.ts

@@ -1,27 +1,19 @@
-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,
-  IncludeRef,
-  JoinAst,
-  OperationExpr,
-  TableRef,
-} from '@prisma-next/sql-relational-core/ast';
 import {
-  createColumnRef,
   createJoinOnBuilder,
-  createOrderByItem,
-  createSelectAst,
-  createTableRef,
+  OrderByItem,
+  type ParamRef,
+  ProjectionItem,
+  SelectAst,
+  type TableRef,
+  TableSource,
 } 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 +22,11 @@ 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 { ifDefined } from '@prisma-next/utils/defined';
 import type { ProjectionInput } from '../types/internal';
-import { assertColumnBuilder } from '../utils/assertions';
 import { checkIncludeCapabilities } from '../utils/capabilities';
 import {
   errorChildProjectionEmpty,
@@ -41,14 +34,13 @@ import {
   errorIncludeAliasCollision,
   errorLimitMustBeNonNegativeInteger,
   errorMissingAlias,
-  errorMissingColumnForAlias,
   errorSelectMustBeCalled,
   errorSelfJoinNotSupported,
   errorUnknownTable,
 } from '../utils/errors';
 import type { BuilderState, IncludeState, JoinState, ProjectionState } from '../utils/state';
 import {
-  buildIncludeAst,
+  buildIncludeJoinArtifact,
   type IncludeChildBuilder,
   IncludeChildBuilderImpl,
 } from './include-builder';
@@ -57,6 +49,18 @@ import { buildMeta } from './plan';
 import { buildWhereExpr } from './predicate-builder';
 import { buildProjectionState } from './projection';
 
+function deriveParamsFromAst(ast: { collectParamRefs(): ParamRef[] }) {
+  const collected = [...new Set(ast.collectParamRefs())];
+  return {
+    paramValues: collected.map((p) => p.value),
+    paramDescriptors: collected.map((p) => ({
+      ...ifDefined('name', p.name),
+      source: 'dsl' as const,
+      ...ifDefined('codecId', p.codecId),
+    })),
+  };
+}
+
 export class SelectBuilderImpl<
   TContract extends SqlContract<SqlStorage> = SqlContract<SqlStorage>,
   Row = unknown,
@@ -64,14 +68,12 @@ export class SelectBuilderImpl<
   Includes extends Record<string, unknown> = Record<string, never>,
 > {
   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) {
     this.context = options.context;
     this.contract = options.context.contract;
-    this.codecTypes = options.context.contract.mappings.codecTypes as CodecTypes;
     if (state) {
       this.state = state;
     }
@@ -146,7 +148,6 @@ export class SelectBuilderImpl<
     // Build child builder
     const childBuilderImpl = new IncludeChildBuilderImpl<TContract, CodecTypes, unknown>(
       this.contract,
-      this.codecTypes,
       childTable,
     );
     const builtChild = childBuilder(
@@ -238,7 +239,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,
@@ -304,43 +307,28 @@ export class SelectBuilderImpl<
       errorUnknownTable(table.name);
     }
 
-    const paramDescriptors: ParamDescriptor[] = [];
-    const paramValues: unknown[] = [];
-    const paramCodecs: Record<string, string> = {};
-
     const whereResult = this.state.where
-      ? buildWhereExpr(this.contract, this.state.where, paramsMap, paramDescriptors, paramValues)
+      ? buildWhereExpr(this.contract, this.state.where, paramsMap)
       : undefined;
     const whereExpr = whereResult?.expr;
 
-    if (whereResult?.codecId && whereResult.paramName) {
-      paramCodecs[whereResult.paramName] = whereResult.codecId;
-    }
-
     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)];
+          return [new OrderByItem(orderBy.expr, orderBy.dir)];
         })()
       : undefined;
 
-    const joins = this.state.joins?.map((join) => buildJoinAst(join));
-
-    const includes = this.state.includes?.map((include) =>
-      buildIncludeAst(include, this.contract, paramsMap, paramDescriptors, paramValues),
+    const joins = this.state.joins?.map((join) => buildJoinAst(join)) ?? [];
+    const includeArtifacts =
+      this.state.includes?.map((include) =>
+        buildIncludeJoinArtifact(include, this.contract, paramsMap),
+      ) ?? [];
+    const includeProjectionByAlias = new Map(
+      includeArtifacts.map((artifact) => [artifact.projection.alias, artifact.projection]),
     );
 
-    // Build projection with support for includeRef and OperationExpr
-    const projectEntries: Array<{ alias: string; expr: ColumnRef | IncludeRef | OperationExpr }> =
-      [];
+    const projectEntries: ProjectionItem[] = [];
     for (let i = 0; i < projection.aliases.length; i++) {
       const alias = projection.aliases[i];
       if (!alias) {
@@ -348,57 +336,31 @@ export class SelectBuilderImpl<
       }
       const column = projection.columns[i];
 
-      // Check if this alias matches an include alias first
-      // Include placeholders have null columns
-      const matchingInclude = this.state.includes?.find((inc) => inc.alias === alias);
-      if (matchingInclude) {
-        // This is an include reference - column can be null for placeholders
-        projectEntries.push({
-          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),
-          });
-        }
+      const includeProjection = includeProjectionByAlias.get(alias);
+      if (includeProjection) {
+        projectEntries.push(includeProjection);
+      } else if (column && isExpressionBuilder(column)) {
+        projectEntries.push(ProjectionItem.of(alias, column.expr));
+      } else if (column) {
+        projectEntries.push(ProjectionItem.of(alias, column.toExpr()));
       }
     }
 
-    const ast = createSelectAst({
-      from: createTableRef(table.name),
-      joins,
-      includes,
-      project: projectEntries,
-      where: whereExpr,
-      orderBy: orderByClause,
-      limit: this.state.limit,
-    } as {
-      from: TableRef;
-      joins?: ReadonlyArray<JoinAst>;
-      includes?: ReadonlyArray<IncludeAst>;
-      project: ReadonlyArray<{ alias: string; expr: ColumnRef | IncludeRef | OperationExpr }>;
-      where?: BinaryExpr;
-      orderBy?: ReadonlyArray<{ expr: ColumnRef | OperationExpr; dir: Direction }>;
-      limit?: number;
-    });
+    let ast = SelectAst.from(TableSource.named(table.name, table.alias))
+      .withProjection(projectEntries)
+      .withWhere(whereExpr);
+    const allJoins = [...joins, ...includeArtifacts.map((artifact) => artifact.join)];
+    if (allJoins.length > 0) {
+      ast = ast.withJoins(allJoins);
+    }
+    if (orderByClause) {
+      ast = ast.withOrderBy(orderByClause);
+    }
+    if (this.state.limit !== undefined) {
+      ast = ast.withLimit(this.state.limit);
+    }
+
+    const { paramValues, paramDescriptors } = deriveParamsFromAst(ast);
 
     const planMeta = buildMeta({
       contract: this.contract,
@@ -407,19 +369,19 @@ export class SelectBuilderImpl<
       joins: this.state.joins,
       includes: this.state.includes,
       paramDescriptors,
-      paramCodecs,
       where: this.state.where,
       orderBy: this.state.orderBy,
+      limit: this.state.limit,
     } as {
       contract: SqlContract<SqlStorage>;
       table: TableRef;
       projection: ProjectionState;
       joins?: ReadonlyArray<JoinState>;
       includes?: ReadonlyArray<IncludeState>;
-      where?: BinaryBuilder;
+      where?: BinaryBuilder | UnaryBuilder;
       orderBy?: AnyOrderBuilder;
-      paramDescriptors: ParamDescriptor[];
-      paramCodecs?: Record<string, string>;
+      limit?: number;
+      paramDescriptors: typeof paramDescriptors;
     });
 
     const queryPlan: SqlQueryPlan<Row> = Object.freeze({

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,11 +32,11 @@ 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 limit?: number;
   readonly paramDescriptors: ParamDescriptor[];
-  readonly paramCodecs?: Record<string, string>;
 }

package/src/utils/errors.ts

@@ -73,7 +73,7 @@ export function errorIncludeAliasCollision(alias: string, type: 'projection' | '
 }
 
 export function errorMissingColumnForAlias(alias: string, index: number): never {
-  throw planInvalid(`Missing column for alias ${alias ?? 'unknown'} at index ${index}`);
+  throw planInvalid(`Missing column for alias ${alias} at index ${index}`);
 }
 
 export function errorMissingAlias(index: number): never {
@@ -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;
 }