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

package/src/sql/plan.ts

@@ -0,0 +1,290 @@
+import type { PlanMeta } from '@prisma-next/contract/types';
+import type { Expression } 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 {
+  collectColumnRefs,
+  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);
+  }
+
+  if (args.joins) {
+    for (const join of args.joins) {
+      refsTables.add(join.table.name);
+      const onLeft = assertColumnBuilder(join.on.left, 'join ON left');
+      const onRight = assertColumnBuilder(join.on.right, 'join ON right');
+      refsColumns.set(`${onLeft.table}.${onLeft.column}`, {
+        table: onLeft.table,
+        column: onLeft.column,
+      });
+      refsColumns.set(`${onRight.table}.${onRight.column}`, {
+        table: onRight.table,
+        column: onRight.column,
+      });
+    }
+  }
+
+  if (args.includes) {
+    for (const include of args.includes) {
+      refsTables.add(include.table.name);
+      // Add ON condition columns
+      // JoinOnPredicate.left and .right are always ColumnBuilder
+      const leftCol = assertColumnBuilder(include.on.left, 'include ON left');
+      const rightCol = assertColumnBuilder(include.on.right, 'include ON right');
+      refsColumns.set(`${leftCol.table}.${leftCol.column}`, {
+        table: leftCol.table,
+        column: leftCol.column,
+      });
+      refsColumns.set(`${rightCol.table}.${rightCol.column}`, {
+        table: rightCol.table,
+        column: rightCol.column,
+      });
+      // Add child projection columns
+      for (const column of include.childProjection.columns) {
+        const col = assertColumnBuilder(column, 'include child projection column');
+
+        refsColumns.set(`${col.table}.${col.column}`, {
+          table: col.table,
+          column: col.column,
+        });
+      }
+      // 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 childWhereRight = include.childWhere.right;
+        if (isColumnBuilder(childWhereRight) || isExpressionBuilder(childWhereRight)) {
+          collectRefsFromExpressionSource(childWhereRight, refsColumns);
+        }
+      }
+      // 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);
+      }
+    }
+  }
+
+  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,
+      });
+    }
+
+    // Handle right side of WHERE clause - can be ParamPlaceholder or AnyExpressionSource
+    const whereRight = args.where.right;
+    if (isColumnBuilder(whereRight) || isExpressionBuilder(whereRight)) {
+      collectRefsFromExpressionSource(whereRight, refsColumns);
+    }
+  }
+
+  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,
+      });
+    }
+  }
+
+  // Build projection map - mark include aliases with special marker
+  const includeAliases = new Set(args.includes?.map((inc) => inc.alias) ?? []);
+  const projectionMap = Object.fromEntries(
+    args.projection.aliases.map((alias, index) => {
+      if (includeAliases.has(alias)) {
+        // Mark include alias with special marker
+        return [alias, `include:${alias}`];
+      }
+      const column = args.projection.columns[index];
+      if (!column) {
+        // Null column means this is an include placeholder, but alias doesn't match includes
+        // 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}`];
+      }
+
+      return [alias, `${col.table}.${col.column}`];
+    }),
+  );
+
+  // Build projectionTypes mapping: alias → column type ID
+  // Skip include aliases - they don't have column types
+  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 column = args.projection.columns[i];
+    if (!column) {
+      continue;
+    }
+    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 {
+      // column is ColumnBuilder
+      const col = column as unknown as { columnMeta?: { codecId: string } };
+      const columnMeta = col.columnMeta;
+      const codecId = columnMeta?.codecId;
+      if (codecId) {
+        projectionTypes[alias] = codecId;
+      }
+    }
+  }
+
+  // Build codec assignments from column types
+  // Skip include aliases - they don't need codec entries
+  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 {
+      // Use columnMeta.codecId directly as typeId (already canonicalized)
+      // 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;
+      }
+    }
+  }
+
+  // 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,
+      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,
+  );
+}

package/src/sql/predicate-builder.ts

@@ -0,0 +1,127 @@
+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 { BinaryBuilder, ParamPlaceholder } from '@prisma-next/sql-relational-core/types';
+import {
+  isColumnBuilder,
+  isExpressionBuilder,
+  isParamPlaceholder,
+} from '@prisma-next/sql-relational-core/utils/guards';
+import {
+  errorFailedToBuildWhereClause,
+  errorMissingParameter,
+  errorUnknownColumn,
+  errorUnknownTable,
+} from '../utils/errors';
+
+export interface BuildWhereExprResult {
+  expr: BinaryExpr;
+  codecId: string | undefined;
+  paramName: string;
+}
+
+export function buildWhereExpr(
+  contract: SqlContract<SqlStorage>,
+  where: BinaryBuilder,
+  paramsMap: Record<string, unknown>,
+  descriptors: ParamDescriptor[],
+  values: unknown[],
+): BuildWhereExprResult {
+  let leftExpr: Expression;
+  let codecId: string | undefined;
+  let rightExpr: Expression | 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;
+
+  // 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);
+    }
+
+    const columnMeta: StorageColumn | undefined = contractTable.columns[column];
+    if (!columnMeta) {
+      errorUnknownColumn(column, table);
+    }
+
+    codecId = columnMeta.codecId;
+  }
+
+  // Handle where.right - can be ParamPlaceholder or ExpressionSource
+  if (isParamPlaceholder(where.right)) {
+    // Handle param placeholder (existing logic)
+    const placeholder: ParamPlaceholder = where.right;
+    paramName = placeholder.name;
+
+    if (!Object.hasOwn(paramsMap, paramName)) {
+      errorMissingParameter(paramName);
+    }
+
+    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;
+      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,
+        });
+      }
+    }
+
+    rightExpr = createParamRef(index, paramName);
+  } else if (isColumnBuilder(where.right) || isExpressionBuilder(where.right)) {
+    // Handle ExpressionSource (ColumnBuilder or ExpressionBuilder) on the right
+    rightExpr = where.right.toExpr();
+
+    // 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 columnMeta: StorageColumn | undefined = contractTable.columns[column];
+      if (!columnMeta) {
+        errorUnknownColumn(column, table);
+      }
+    }
+
+    // Use a placeholder paramName for expression references (not used for params)
+    paramName = '';
+  } else {
+    // where.right is neither ParamPlaceholder nor ExpressionSource - invalid state
+    errorFailedToBuildWhereClause();
+  }
+
+  return {
+    expr: createBinaryExpr(where.op, leftExpr, rightExpr),
+    codecId,
+    paramName,
+  };
+}

package/src/sql/projection.ts

@@ -0,0 +1,117 @@
+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 { ProjectionInput } from '../types/internal';
+import {
+  errorAliasCollision,
+  errorAliasPathEmpty,
+  errorIncludeAliasNotFound,
+  errorInvalidProjectionKey,
+  errorInvalidProjectionValue,
+  errorProjectionEmpty,
+} from '../utils/errors';
+import type { IncludeState, ProjectionState } from '../utils/state';
+
+export function generateAlias(path: string[]): string {
+  if (path.length === 0) {
+    errorAliasPathEmpty();
+  }
+  return path.join('_');
+}
+
+export class AliasTracker {
+  private readonly aliases = new Set<string>();
+  private readonly aliasToPath = new Map<string, string[]>();
+
+  register(path: string[]): string {
+    const alias = generateAlias(path);
+    if (this.aliases.has(alias)) {
+      const existingPath = this.aliasToPath.get(alias);
+      errorAliasCollision(path, alias, existingPath);
+    }
+    this.aliases.add(alias);
+    this.aliasToPath.set(alias, path);
+    return alias;
+  }
+
+  getPath(alias: string): string[] | undefined {
+    return this.aliasToPath.get(alias);
+  }
+
+  has(alias: string): boolean {
+    return this.aliases.has(alias);
+  }
+}
+
+export function flattenProjection(
+  projection: NestedProjection,
+  tracker: AliasTracker,
+  currentPath: string[] = [],
+): { aliases: string[]; columns: AnyExpressionSource[] } {
+  const aliases: string[] = [];
+  const columns: AnyExpressionSource[] = [];
+
+  for (const [key, value] of Object.entries(projection)) {
+    const path = [...currentPath, key];
+
+    if (isExpressionSource(value)) {
+      const alias = tracker.register(path);
+      aliases.push(alias);
+      columns.push(value);
+    } else if (typeof value === 'object' && value !== null) {
+      const nested = flattenProjection(value, tracker, path);
+      aliases.push(...nested.aliases);
+      columns.push(...nested.columns);
+    } else {
+      errorInvalidProjectionValue(path);
+    }
+  }
+
+  return { aliases, columns };
+}
+
+export function buildProjectionState(
+  _table: TableRef,
+  projection: ProjectionInput,
+  includes?: ReadonlyArray<IncludeState>,
+): ProjectionState {
+  const tracker = new AliasTracker();
+  const aliases: string[] = [];
+  const columns: AnyExpressionSource[] = [];
+
+  for (const [key, value] of Object.entries(projection)) {
+    if (value === true) {
+      // Boolean true means this is an include reference
+      const matchingInclude = includes?.find((inc) => inc.alias === key);
+      if (!matchingInclude) {
+        errorIncludeAliasNotFound(key);
+      }
+      // For include references, we track the alias but use a placeholder object
+      // The actual handling happens in AST building where we create includeRef
+      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)) {
+      const alias = tracker.register([key]);
+      aliases.push(alias);
+      columns.push(value);
+    } else if (typeof value === 'object' && value !== null) {
+      const nested = flattenProjection(value as NestedProjection, tracker, [key]);
+      aliases.push(...nested.aliases);
+      columns.push(...nested.columns);
+    } else {
+      errorInvalidProjectionKey(key);
+    }
+  }
+
+  if (aliases.length === 0) {
+    errorProjectionEmpty();
+  }
+
+  return { aliases, columns };
+}