@prisma-next/sql-orm-lane 0.3.0-dev.3 → 0.3.0-dev.30

package/src/plan/plan-assembly.ts

@@ -0,0 +1,312 @@
+import type { ExecutionPlan, ParamDescriptor, PlanMeta } from '@prisma-next/contract/types';
+import { planInvalid } from '@prisma-next/plan';
+import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
+import type {
+  BinaryExpr,
+  ExistsExpr,
+  Expression,
+  LoweredStatement,
+  SelectAst,
+  TableRef,
+} from '@prisma-next/sql-relational-core/ast';
+import { compact } from '@prisma-next/sql-relational-core/ast';
+import type {
+  AnyExpressionSource,
+  AnyOrderBuilder,
+  BinaryBuilder,
+} from '@prisma-next/sql-relational-core/types';
+import {
+  collectColumnRefs,
+  getColumnMeta,
+  isColumnBuilder,
+  isExpressionBuilder,
+  isOperationExpr,
+} from '@prisma-next/sql-relational-core/utils/guards';
+import type { IncludeState } from '../relations/include-plan';
+import type { ProjectionState } from '../selection/projection';
+
+export interface MetaBuildArgs {
+  readonly contract: SqlContract<SqlStorage>;
+  readonly table: TableRef;
+  readonly projection: ProjectionState;
+  readonly includes?: ReadonlyArray<IncludeState>;
+  readonly where?: BinaryBuilder;
+  readonly orderBy?: AnyOrderBuilder;
+  readonly paramDescriptors: ParamDescriptor[];
+  readonly paramCodecs?: Record<string, string>;
+}
+
+/**
+ * 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 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) {
+      refsTables.add(include.table.name);
+      const onLeft = include.on.left as unknown as { table: string; column: string };
+      const onRight = include.on.right as unknown as { table: string; column: string };
+      if (onLeft.table && onLeft.column && onRight.table && onRight.column) {
+        refsColumns.set(`${onLeft.table}.${onLeft.column}`, {
+          table: onLeft.table,
+          column: onLeft.column,
+        });
+        refsColumns.set(`${onRight.table}.${onRight.column}`, {
+          table: onRight.table,
+          column: onRight.column,
+        });
+      }
+      for (const column of include.childProjection.columns) {
+        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,
+          });
+        }
+      }
+      if (include.childWhere) {
+        // childWhere.left is Expression (already converted at builder creation time)
+        collectRefsFromExpression(include.childWhere.left, refsColumns);
+      }
+      if (include.childOrderBy) {
+        // childOrderBy.expr is Expression (already converted at builder creation time)
+        collectRefsFromExpression(include.childOrderBy.expr, refsColumns);
+      }
+    }
+  }
+
+  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);
+      for (const ref of allRefs) {
+        refsColumns.set(`${ref.table}.${ref.column}`, {
+          table: ref.table,
+          column: ref.column,
+        });
+      }
+    } else {
+      // leftExpr is ColumnRef
+      refsColumns.set(`${leftExpr.table}.${leftExpr.column}`, {
+        table: leftExpr.table,
+        column: leftExpr.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,
+        });
+      }
+    } else {
+      // orderByExpr is ColumnRef
+      refsColumns.set(`${orderByExpr.table}.${orderByExpr.column}`, {
+        table: orderByExpr.table,
+        column: orderByExpr.column,
+      });
+    }
+  }
+
+  const includeAliases = new Set(args.includes?.map((inc) => inc.alias) ?? []);
+  const projectionMap = Object.fromEntries(
+    args.projection.aliases.map((alias, index) => {
+      if (includeAliases.has(alias)) {
+        return [alias, `include:${alias}`];
+      }
+      const column = args.projection.columns[index];
+      if (!column) {
+        throw planInvalid(`Missing column for alias ${alias} at index ${index}`);
+      }
+      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}`];
+      }
+      return [alias, `${col.table}.${col.column}`];
+    }),
+  );
+
+  const projectionTypes: Record<string, string> = {};
+  for (let i = 0; i < args.projection.aliases.length; i++) {
+    const alias = args.projection.aliases[i];
+    if (!alias || includeAliases.has(alias)) {
+      continue;
+    }
+    const col = args.projection.columns[i];
+    if (!col) {
+      continue;
+    }
+    if (isExpressionBuilder(col)) {
+      const operationExpr = col.expr;
+      if (operationExpr.returns.kind === 'typeId') {
+        projectionTypes[alias] = operationExpr.returns.type;
+      } else if (operationExpr.returns.kind === 'builtin') {
+        projectionTypes[alias] = operationExpr.returns.type;
+      }
+    } else {
+      const columnMeta = getColumnMeta(col);
+      const codecId = columnMeta?.codecId;
+      if (codecId) {
+        projectionTypes[alias] = codecId;
+      }
+    }
+  }
+
+  const projectionCodecs: Record<string, string> = {};
+  for (let i = 0; i < args.projection.aliases.length; i++) {
+    const alias = args.projection.aliases[i];
+    if (!alias || includeAliases.has(alias)) {
+      continue;
+    }
+    const column = args.projection.columns[i];
+    if (!column) {
+      continue;
+    }
+    if (isExpressionBuilder(column)) {
+      const operationExpr = column.expr;
+      if (operationExpr.returns.kind === 'typeId') {
+        projectionCodecs[alias] = operationExpr.returns.type;
+      }
+    } else {
+      const columnMeta = getColumnMeta(column);
+      const codecId = columnMeta?.codecId;
+      if (codecId) {
+        projectionCodecs[alias] = codecId;
+      }
+    }
+  }
+
+  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,
+      lane: 'dsl',
+      refs: {
+        tables: Array.from(refsTables),
+        columns: Array.from(refsColumns.values()),
+      },
+      projection: projectionMap,
+      projectionTypes: Object.keys(projectionTypes).length > 0 ? projectionTypes : undefined,
+      annotations:
+        Object.keys(allCodecs).length > 0
+          ? Object.freeze({ codecs: Object.freeze(allCodecs) })
+          : undefined,
+      paramDescriptors: args.paramDescriptors,
+      profileHash: args.contract.profileHash,
+    }) as PlanMeta,
+  );
+}
+
+export function createPlan<Row>(
+  ast: SelectAst,
+  lowered: { body: LoweredStatement },
+  paramValues: unknown[],
+  planMeta: PlanMeta,
+): ExecutionPlan<Row> {
+  return Object.freeze({
+    ast,
+    sql: lowered.body.sql,
+    params: lowered.body.params ?? paramValues,
+    meta: {
+      ...planMeta,
+      lane: 'orm',
+    },
+  });
+}
+
+export function createPlanWithExists<Row>(
+  ast: SelectAst,
+  combinedWhere: BinaryExpr | ExistsExpr | undefined,
+  lowered: { body: LoweredStatement },
+  paramValues: unknown[],
+  planMeta: PlanMeta,
+): ExecutionPlan<Row> {
+  const modifiedAst: SelectAst = {
+    ...ast,
+    ...(combinedWhere !== undefined ? { where: combinedWhere } : {}),
+  };
+  return Object.freeze({
+    ast: modifiedAst,
+    sql: lowered.body.sql,
+    params: lowered.body.params ?? paramValues,
+    meta: {
+      ...planMeta,
+      lane: 'orm',
+    },
+  });
+}

package/src/plan/result-typing.ts

@@ -0,0 +1 @@
+export type {};

package/src/relations/include-plan.ts

@@ -0,0 +1,324 @@
+import type { ParamDescriptor } from '@prisma-next/contract/types';
+import type { SqlContract, SqlStorage, StorageColumn } from '@prisma-next/sql-contract/types';
+import type {
+  BinaryExpr,
+  ColumnRef,
+  ExistsExpr,
+  IncludeAst,
+  OperationExpr,
+  ParamRef,
+  TableRef,
+} from '@prisma-next/sql-relational-core/ast';
+import { compact } from '@prisma-next/sql-relational-core/ast';
+import type { QueryLaneContext } from '@prisma-next/sql-relational-core/query-lane-context';
+import { schema } from '@prisma-next/sql-relational-core/schema';
+import type {
+  AnyBinaryBuilder,
+  AnyColumnBuilder,
+  AnyOrderBuilder,
+  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';
+import { buildChildOrderByClause } from '../selection/ordering';
+import { buildWhereExpr } from '../selection/predicates';
+import {
+  buildProjectionState,
+  type ProjectionInput,
+  type ProjectionState,
+} from '../selection/projection';
+import { createColumnRef, createSelectAst } from '../utils/ast';
+import {
+  errorChildProjectionEmpty,
+  errorChildProjectionMustBeSpecified,
+  errorColumnNotFound,
+  errorJoinColumnsMustBeDefined,
+  errorMissingAlias,
+  errorMissingColumn,
+  errorModelNotFound,
+  errorMultiColumnJoinsNotSupported,
+  errorTableNotFound,
+} from '../utils/errors';
+
+export interface IncludeState {
+  readonly alias: string;
+  readonly table: TableRef;
+  readonly on: {
+    kind: 'join-on';
+    left: StorageColumn;
+    right: StorageColumn;
+  };
+  readonly childProjection: ProjectionState;
+  readonly childWhere?: AnyBinaryBuilder;
+  readonly childOrderBy?: AnyOrderBuilder;
+  readonly childLimit?: number;
+}
+
+interface BuildIncludeAstsInput {
+  readonly includes: OrmIncludeState[];
+  readonly contract: SqlContract<SqlStorage>;
+  readonly context: QueryLaneContext<SqlContract<SqlStorage>>;
+  readonly modelName: string;
+  readonly paramsMap: Record<string, unknown>;
+  readonly paramDescriptors: ParamDescriptor[];
+  readonly paramValues: unknown[];
+  readonly paramCodecs: Record<string, string>;
+}
+
+export function buildIncludeAsts(input: BuildIncludeAstsInput): {
+  includesAst: IncludeAst[];
+  includesForMeta: IncludeState[];
+} {
+  const {
+    includes,
+    contract,
+    context,
+    modelName,
+    paramsMap,
+    paramDescriptors,
+    paramValues,
+    paramCodecs,
+  } = input;
+
+  const includesAst: IncludeAst[] = [];
+  const includesForMeta: IncludeState[] = [];
+
+  for (const includeState of includes) {
+    checkIncludeCapabilities(contract);
+
+    const parentTableName = contract.mappings.modelToTable?.[modelName];
+    if (!parentTableName) {
+      errorModelNotFound(modelName);
+    }
+
+    const parentSchemaHandle = schema(context);
+    const parentSchemaTable = parentSchemaHandle.tables[parentTableName];
+    if (!parentSchemaTable) {
+      errorTableNotFound(parentTableName);
+    }
+    const childSchemaHandle = schema(context);
+    const childSchemaTable = childSchemaHandle.tables[includeState.childTable.name];
+    if (!childSchemaTable) {
+      errorTableNotFound(includeState.childTable.name);
+    }
+
+    if (
+      includeState.relation.on.parentCols.length !== 1 ||
+      includeState.relation.on.childCols.length !== 1
+    ) {
+      errorMultiColumnJoinsNotSupported();
+    }
+    const parentColName = includeState.relation.on.parentCols[0];
+    const childColName = includeState.relation.on.childCols[0];
+    if (!parentColName || !childColName) {
+      errorJoinColumnsMustBeDefined();
+    }
+    const parentCol = parentSchemaTable.columns[parentColName];
+    const childCol = childSchemaTable.columns[childColName];
+    if (!parentCol) {
+      errorColumnNotFound(parentColName, parentTableName);
+    }
+    if (!childCol) {
+      errorColumnNotFound(childColName, includeState.childTable.name);
+    }
+
+    const onExpr = buildJoinOnExpr(
+      parentTableName,
+      parentColName,
+      includeState.childTable.name,
+      childColName,
+    );
+
+    if (!includeState.childProjection) {
+      errorChildProjectionMustBeSpecified();
+    }
+    const filteredProjection: Record<string, AnyColumnBuilder | NestedProjection> = {};
+    for (const [key, value] of Object.entries(includeState.childProjection)) {
+      if (value !== true && value !== false) {
+        filteredProjection[key] = value as AnyColumnBuilder | NestedProjection;
+      }
+    }
+    if (Object.keys(filteredProjection).length === 0) {
+      errorChildProjectionEmpty();
+    }
+    const childProjectionState = buildProjectionState(
+      includeState.childTable,
+      filteredProjection as ProjectionInput,
+    );
+
+    let childWhere: BinaryExpr | undefined;
+    if (includeState.childWhere) {
+      const whereResult = buildWhereExpr(
+        includeState.childWhere,
+        contract,
+        paramsMap,
+        paramDescriptors,
+        paramValues,
+      );
+      childWhere = whereResult.expr;
+      if (whereResult.codecId && whereResult.paramName) {
+        paramCodecs[whereResult.paramName] = whereResult.codecId;
+      }
+    }
+
+    const childOrderBy = buildChildOrderByClause(includeState.childOrderBy);
+
+    const childProjectionItems: Array<{ alias: string; expr: ColumnRef | OperationExpr }> = [];
+    for (let i = 0; i < childProjectionState.aliases.length; i++) {
+      const alias = childProjectionState.aliases[i];
+      if (!alias) {
+        errorMissingAlias(i);
+      }
+      const column = childProjectionState.columns[i];
+      if (!column) {
+        errorMissingColumn(alias, i);
+      }
+      if (isExpressionBuilder(column)) {
+        childProjectionItems.push({ alias, expr: column.expr });
+      } else {
+        // ColumnBuilder - use toExpr() to get ColumnRef
+        childProjectionItems.push({ alias, expr: column.toExpr() });
+      }
+    }
+
+    const includeAst: IncludeAst = compact({
+      kind: 'includeMany',
+      alias: includeState.alias,
+      child: compact({
+        table: includeState.childTable,
+        on: onExpr,
+        project: childProjectionItems,
+        where: childWhere,
+        orderBy: childOrderBy,
+        limit: includeState.childLimit,
+      }),
+    }) as IncludeAst;
+    includesAst.push(includeAst);
+
+    const includeForMeta: IncludeState = compact({
+      alias: includeState.alias,
+      table: includeState.childTable,
+      on: {
+        kind: 'join-on',
+        left: parentCol as unknown as StorageColumn,
+        right: childCol as unknown as StorageColumn,
+      },
+      childProjection: childProjectionState,
+      childWhere: includeState.childWhere,
+      childOrderBy: includeState.childOrderBy,
+      childLimit: includeState.childLimit,
+    }) as IncludeState;
+    includesForMeta.push(includeForMeta);
+  }
+
+  return { includesAst, includesForMeta };
+}
+
+export function buildExistsSubqueries(
+  relationFilters: RelationFilter[],
+  contract: SqlContract<SqlStorage>,
+  modelName: string,
+  options?: BuildOptions,
+): ExistsExpr[] {
+  const existsExprs: ExistsExpr[] = [];
+
+  for (const filter of relationFilters) {
+    const childTableName = contract.mappings.modelToTable?.[filter.childModelName];
+    if (!childTableName) {
+      errorModelNotFound(filter.childModelName);
+    }
+
+    const childTable: TableRef = { kind: 'table', name: childTableName };
+    const parentTableName = contract.mappings.modelToTable?.[modelName];
+    if (!parentTableName) {
+      errorModelNotFound(modelName);
+    }
+
+    const joinConditions: Array<{ left: ColumnRef; right: ColumnRef }> = [];
+    for (let i = 0; i < filter.relation.on.parentCols.length; i++) {
+      const parentCol = filter.relation.on.parentCols[i];
+      const childCol = filter.relation.on.childCols[i];
+      if (!parentCol || !childCol) {
+        continue;
+      }
+      joinConditions.push({
+        left: { kind: 'col', table: parentTableName, column: parentCol },
+        right: { kind: 'col', table: childTableName, column: childCol },
+      });
+    }
+
+    let childWhere: BinaryExpr | undefined;
+    if (filter.childWhere) {
+      const paramsMap = (options?.params ?? {}) as Record<string, unknown>;
+      const paramDescriptors: ParamDescriptor[] = [];
+      const paramValues: unknown[] = [];
+      const whereResult = buildWhereExpr(
+        filter.childWhere,
+        contract,
+        paramsMap,
+        paramDescriptors,
+        paramValues,
+      );
+      childWhere = whereResult.expr;
+    }
+
+    let subqueryWhere: BinaryExpr | undefined = childWhere;
+    if (joinConditions.length > 0) {
+      const firstJoinCondition = joinConditions[0];
+      if (firstJoinCondition) {
+        const joinWhere: BinaryExpr = {
+          kind: 'bin',
+          op: 'eq',
+          left: firstJoinCondition.left,
+          right: firstJoinCondition.right as unknown as ParamRef,
+        };
+        if (childWhere) {
+          subqueryWhere = joinWhere;
+        } else {
+          subqueryWhere = joinWhere;
+        }
+      }
+    }
+    const projectionColumn = joinConditions[0]?.right ?? createColumnRef(childTableName, 'id');
+    const subquery = createSelectAst({
+      from: childTable,
+      project: [{ alias: '_exists', expr: projectionColumn }],
+      where: subqueryWhere,
+    } as {
+      from: TableRef;
+      project: ReadonlyArray<{ alias: string; expr: ColumnRef }>;
+      where?: BinaryExpr | ExistsExpr;
+    });
+
+    const notExists = filter.filterType === 'none' || filter.filterType === 'every';
+
+    const existsExpr: ExistsExpr = {
+      kind: 'exists',
+      subquery,
+      not: notExists,
+    };
+
+    existsExprs.push(existsExpr);
+  }
+
+  return existsExprs;
+}
+
+export function combineWhereClauses(
+  mainWhere: BinaryExpr | ExistsExpr | undefined,
+  existsExprs: ExistsExpr[],
+): BinaryExpr | ExistsExpr | undefined {
+  if (existsExprs.length === 1) {
+    return existsExprs[0];
+  }
+  if (mainWhere) {
+    return mainWhere;
+  }
+  if (existsExprs.length > 0) {
+    return existsExprs[0];
+  }
+  return undefined;
+}

package/src/selection/join.ts

@@ -0,0 +1,13 @@
+import type { JoinOnExpr } from '@prisma-next/sql-relational-core/ast';
+import { createColumnRef, createJoinOnExpr } from '../utils/ast';
+
+export function buildJoinOnExpr(
+  parentTableName: string,
+  parentColName: string,
+  childTableName: string,
+  childColName: string,
+): JoinOnExpr {
+  const leftCol = createColumnRef(parentTableName, parentColName);
+  const rightCol = createColumnRef(childTableName, childColName);
+  return createJoinOnExpr(leftCol, rightCol);
+}

package/src/selection/ordering.ts

@@ -0,0 +1,52 @@
+import type { StorageColumn } from '@prisma-next/sql-contract/types';
+import type { ColumnRef, Direction, OperationExpr } from '@prisma-next/sql-relational-core/ast';
+import type { AnyOrderBuilder, OrderBuilder } from '@prisma-next/sql-relational-core/types';
+import {
+  extractBaseColumnRef,
+  isOperationExpr,
+} from '@prisma-next/sql-relational-core/utils/guards';
+import { createColumnRef, createOrderByItem } from '../utils/ast';
+
+export function buildOrderByClause(orderBy: AnyOrderBuilder | undefined):
+  | ReadonlyArray<{
+      expr: ColumnRef | OperationExpr;
+      dir: Direction;
+    }>
+  | undefined {
+  if (!orderBy) {
+    return undefined;
+  }
+
+  const orderByBuilder = orderBy as OrderBuilder<string, StorageColumn, unknown>;
+  const orderExpr = orderByBuilder.expr;
+  const expr: ColumnRef | OperationExpr = isOperationExpr(orderExpr)
+    ? orderExpr
+    : (() => {
+        const colBuilder = orderExpr as { table: string; column: string };
+        return createColumnRef(colBuilder.table, colBuilder.column);
+      })();
+  return [createOrderByItem(expr, orderByBuilder.dir)];
+}
+
+export function buildChildOrderByClause(orderBy: AnyOrderBuilder | undefined):
+  | ReadonlyArray<{
+      expr: ColumnRef | OperationExpr;
+      dir: Direction;
+    }>
+  | undefined {
+  if (!orderBy) {
+    return undefined;
+  }
+
+  const orderByBuilder = orderBy as OrderBuilder<string, StorageColumn, unknown>;
+  const orderExpr = orderByBuilder.expr;
+  const expr: ColumnRef | OperationExpr = (() => {
+    if (isOperationExpr(orderExpr)) {
+      const baseCol = extractBaseColumnRef(orderExpr);
+      return createColumnRef(baseCol.table, baseCol.column);
+    }
+    const colBuilder = orderExpr as { table: string; column: string };
+    return createColumnRef(colBuilder.table, colBuilder.column);
+  })();
+  return [createOrderByItem(expr, orderByBuilder.dir)];
+}