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

package/src/sql/plan.ts

@@ -0,0 +1,289 @@
+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 {
+  collectColumnRefs,
+  getColumnInfo,
+  getOperationExpr,
+  isColumnBuilder,
+  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';
+
+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,
+      });
+    }
+  }
+
+  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) {
+        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,
+          });
+        }
+      }
+      // 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,
+          });
+        }
+      }
+    }
+  }
+
+  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,
+        });
+      }
+    } 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,
+        });
+      }
+    }
+
+    // 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,
+        });
+      }
+    }
+  }
+
+  // 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);
+      }
+
+      const operationExpr = getOperationExpr(column);
+      if (operationExpr) {
+        return [alias, `operation:${operationExpr.method}`];
+      }
+
+      return [alias, `${column.table}.${column.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;
+    }
+    const operationExpr = (column as { _operationExpr?: OperationExpr })._operationExpr;
+    if (operationExpr) {
+      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
+      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;
+    }
+    const operationExpr = (column as { _operationExpr?: OperationExpr })._operationExpr;
+    if (operationExpr) {
+      if (operationExpr.returns.kind === 'typeId') {
+        projectionCodecs[alias] = operationExpr.returns.type;
+      }
+    } else {
+      // Use columnMeta.codecId directly as typeId (already canonicalized)
+      // TypeScript can't narrow ColumnBuilder properly
+      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,130 @@
+import type { ParamDescriptor } from '@prisma-next/contract/types';
+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 {
+  createBinaryExpr,
+  createColumnRef,
+  createParamRef,
+} from '@prisma-next/sql-relational-core/ast';
+import type { BinaryBuilder, ParamPlaceholder } from '@prisma-next/sql-relational-core/types';
+import {
+  getColumnInfo,
+  getOperationExpr,
+  isColumnBuilder,
+  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: ColumnRef | OperationExpr;
+  let codecId: string | undefined;
+  let rightExpr: ColumnRef | ParamRef;
+  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);
+
+    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;
+    leftExpr = createColumnRef(table, column);
+  } else {
+    // where.left is neither OperationExpr nor ColumnBuilder - invalid state
+    errorFailedToBuildWhereClause();
+  }
+
+  // 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;
+
+    if (!Object.hasOwn(paramsMap, paramName)) {
+      errorMissingParameter(paramName);
+    }
+
+    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,
+        });
+      }
+    }
+
+    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);
+    }
+
+    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),
+    codecId,
+    paramName,
+  };
+}

package/src/sql/projection.ts

@@ -0,0 +1,112 @@
+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 { 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: AnyColumnBuilder[] } {
+  const aliases: string[] = [];
+  const columns: AnyColumnBuilder[] = [];
+
+  for (const [key, value] of Object.entries(projection)) {
+    const path = [...currentPath, key];
+
+    if (isColumnBuilder(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: (AnyColumnBuilder | null)[] = [];
+
+  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 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)) {
+      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 };
+}