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

package/src/selection/pagination.ts

@@ -0,0 +1,11 @@
+export interface PaginationState {
+  limit?: number;
+  offset?: number;
+}
+
+export function createPaginationState(limit?: number, offset?: number): PaginationState {
+  return {
+    ...(limit !== undefined ? { limit } : {}),
+    ...(offset !== undefined ? { offset } : {}),
+  };
+}

package/src/selection/predicates.ts

@@ -0,0 +1,104 @@
+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 { augmentDescriptorWithColumnMeta } from '@prisma-next/sql-relational-core/plan';
+import type { BinaryBuilder, ParamPlaceholder } from '@prisma-next/sql-relational-core/types';
+import {
+  isColumnBuilder,
+  isExpressionBuilder,
+  isParamPlaceholder,
+} from '@prisma-next/sql-relational-core/utils/guards';
+import { createBinaryExpr, createParamRef } from '../utils/ast';
+import {
+  errorFailedToBuildWhereClause,
+  errorMissingParameter,
+  errorUnknownTable,
+} from '../utils/errors';
+
+export function buildWhereExpr(
+  where: BinaryBuilder,
+  contract: SqlContract<SqlStorage>,
+  paramsMap: Record<string, unknown>,
+  descriptors: ParamDescriptor[],
+  values: unknown[],
+): {
+  expr: BinaryExpr;
+  codecId?: string;
+  paramName: string;
+} {
+  let leftExpr: Expression;
+  let codecId: string | undefined;
+  let rightExpr: Expression | ParamRef;
+  let paramName: string;
+
+  // where.left is now an Expression (ColumnRef or OperationExpr)
+  leftExpr = where.left;
+
+  // If leftExpr is a ColumnRef, extract codecId from contract
+  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 column not found in contract, still build expression but without codecId
+    // This allows flexibility when columnMeta is available on the column builder
+    if (columnMeta) {
+      codecId = columnMeta.codecId;
+    }
+  }
+
+  // Handle where.right - can be ParamPlaceholder or AnyExpressionSource
+  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 from where.left Expression
+    // For ColumnRef, we can extract table/column directly
+    // For OperationExpr, we extract the base column reference
+    if (leftExpr.kind === 'col') {
+      const { table, column } = leftExpr;
+      const contractTable = contract.storage.tables[table];
+      const columnMeta = contractTable?.columns[column];
+
+      descriptors.push({
+        name: paramName,
+        source: 'dsl',
+        refs: { table, column },
+        ...(columnMeta && typeof columnMeta.nullable === 'boolean'
+          ? { nullable: columnMeta.nullable }
+          : {}),
+      });
+
+      augmentDescriptorWithColumnMeta(descriptors, columnMeta);
+    }
+    // For OperationExpr, we don't create descriptors since we can't reliably extract column info
+
+    rightExpr = createParamRef(index, paramName);
+  } else if (isColumnBuilder(where.right) || isExpressionBuilder(where.right)) {
+    // Handle ExpressionSource on the right - use toExpr() to get the Expression
+    rightExpr = where.right.toExpr();
+    // 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 ? { codecId } : {}),
+    paramName,
+  };
+}

package/src/selection/projection.ts

@@ -0,0 +1,142 @@
+import type { TableRef } from '@prisma-next/sql-relational-core/ast';
+import type {
+  AnyBinaryBuilder,
+  AnyExpressionSource,
+  AnyOrderBuilder,
+  JoinOnPredicate,
+  NestedProjection,
+} from '@prisma-next/sql-relational-core/types';
+import {
+  isColumnBuilder,
+  isExpressionBuilder,
+} from '@prisma-next/sql-relational-core/utils/guards';
+import {
+  errorAliasCollision,
+  errorAliasPathEmpty,
+  errorIncludeAliasNotFound,
+  errorInvalidProjectionKey,
+  errorInvalidProjectionValue,
+  errorProjectionEmpty,
+} from '../utils/errors';
+
+export interface ProjectionState {
+  readonly aliases: string[];
+  readonly columns: AnyExpressionSource[];
+}
+
+export type ProjectionInput = Record<string, AnyExpressionSource | boolean | NestedProjection>;
+
+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 (isColumnBuilder(value) || isExpressionBuilder(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<{
+    readonly alias: string;
+    readonly table: TableRef;
+    readonly on: JoinOnPredicate;
+    readonly childProjection: ProjectionState;
+    readonly childWhere?: AnyBinaryBuilder;
+    readonly childOrderBy?: AnyOrderBuilder;
+    readonly childLimit?: number;
+  }>,
+): ProjectionState {
+  const tracker = new AliasTracker();
+  const aliases: string[] = [];
+  const columns: AnyExpressionSource[] = [];
+
+  for (const [key, value] of Object.entries(projection)) {
+    if (value === true) {
+      const matchingInclude = includes?.find((inc) => inc.alias === key);
+      if (!matchingInclude) {
+        errorIncludeAliasNotFound(key);
+      }
+      aliases.push(key);
+      columns.push({
+        kind: 'column',
+        table: matchingInclude.table.name,
+        column: '',
+        columnMeta: {
+          nativeType: 'jsonb',
+          codecId: 'core/json@1',
+          nullable: true,
+        },
+        toExpr() {
+          return { kind: 'col', table: matchingInclude.table.name, column: '' };
+        },
+      } as AnyExpressionSource);
+    } else if (isColumnBuilder(value) || isExpressionBuilder(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 };
+}

package/src/selection/select-builder.ts

@@ -0,0 +1,80 @@
+import type {
+  BinaryExpr,
+  Direction,
+  ExistsExpr,
+  Expression,
+  IncludeAst,
+  IncludeRef,
+  SelectAst,
+  TableRef,
+} from '@prisma-next/sql-relational-core/ast';
+import { isExpressionBuilder } from '@prisma-next/sql-relational-core/utils/guards';
+import type { IncludeState } from '../relations/include-plan';
+import { createSelectAst, createTableRef } from '../utils/ast';
+import { errorInvalidColumn, errorMissingAlias, errorMissingColumn } from '../utils/errors';
+import type { ProjectionState } from './projection';
+
+export function buildProjectionItems(
+  projectionState: ProjectionState,
+  includesForMeta: ReadonlyArray<IncludeState>,
+): Array<{ alias: string; expr: Expression | IncludeRef }> {
+  const projectEntries: Array<{ alias: string; expr: Expression | IncludeRef }> = [];
+  for (let i = 0; i < projectionState.aliases.length; i++) {
+    const alias = projectionState.aliases[i];
+    if (!alias) {
+      errorMissingAlias(i);
+    }
+    const column = projectionState.columns[i];
+    if (!column) {
+      errorMissingColumn(alias, i);
+    }
+
+    const matchingInclude = includesForMeta.find((inc) => inc.alias === alias);
+    if (matchingInclude) {
+      projectEntries.push({
+        alias,
+        expr: { kind: 'includeRef', alias },
+      });
+    } else if (isExpressionBuilder(column)) {
+      // ExpressionBuilder (operation result) - use its expr
+      projectEntries.push({
+        alias,
+        expr: column.expr,
+      });
+    } else {
+      // ColumnBuilder - use toExpr() to get ColumnRef
+      const expr = column.toExpr();
+      // Validate the expression has valid table and column values
+      if (expr.kind === 'col' && (!expr.table || !expr.column)) {
+        errorInvalidColumn(alias, i);
+      }
+      projectEntries.push({
+        alias,
+        expr,
+      });
+    }
+  }
+  return projectEntries;
+}
+
+export function buildSelectAst(params: {
+  table: TableRef;
+  projectEntries: Array<{ alias: string; expr: Expression | IncludeRef }>;
+  includesAst?: ReadonlyArray<IncludeAst>;
+  whereExpr?: BinaryExpr | ExistsExpr;
+  orderByClause?: ReadonlyArray<{
+    expr: Expression;
+    dir: Direction;
+  }>;
+  limit?: number;
+}): SelectAst {
+  const { table, projectEntries, includesAst, whereExpr, orderByClause, limit } = params;
+  return createSelectAst({
+    from: createTableRef(table.name),
+    project: projectEntries,
+    ...(includesAst ? { includes: includesAst } : {}),
+    ...(whereExpr ? { where: whereExpr } : {}),
+    ...(orderByClause ? { orderBy: orderByClause } : {}),
+    ...(limit !== undefined ? { limit } : {}),
+  });
+}

package/src/types/internal.ts

@@ -0,0 +1,3 @@
+export type { OrmBuilderState, OrmIncludeState, RelationFilter } from '../orm/state';
+export type { MetaBuildArgs } from '../plan/plan-assembly';
+export type { IncludeState } from '../relations/include-plan';

package/src/utils/ast.ts

@@ -0,0 +1,12 @@
+export {
+  createBinaryExpr,
+  createColumnRef,
+  createDeleteAst,
+  createInsertAst,
+  createJoinOnExpr,
+  createOrderByItem,
+  createParamRef,
+  createSelectAst,
+  createTableRef,
+  createUpdateAst,
+} from '@prisma-next/sql-relational-core/ast';

package/src/utils/errors.ts

@@ -0,0 +1,130 @@
+import { planInvalid } from '@prisma-next/plan';
+import type { StorageColumn } from '@prisma-next/sql-contract/types';
+
+export function errorModelNotFound(modelName: string): never {
+  throw planInvalid(`Model ${modelName} not found in mappings`);
+}
+
+export function errorTableNotFound(tableName: string): never {
+  throw planInvalid(`Table ${tableName} not found in schema`);
+}
+
+export function errorUnknownTable(tableName: string): never {
+  throw planInvalid(`Unknown table ${tableName}`);
+}
+
+export function errorUnknownColumn(columnName: string, tableName: string): never {
+  throw planInvalid(`Unknown column ${columnName} in table ${tableName}`);
+}
+
+export function errorMissingParameter(paramName: string): never {
+  throw planInvalid(`Missing value for parameter ${paramName}`);
+}
+
+export function errorAliasPathEmpty(): never {
+  throw planInvalid('Alias path cannot be empty');
+}
+
+export function errorAliasCollision(path: string[], alias: string, existingPath?: string[]): never {
+  throw planInvalid(
+    `Alias collision: path ${path.join('.')} would generate alias "${alias}" which conflicts with path ${existingPath?.join('.') ?? 'unknown'}`,
+  );
+}
+
+export function errorInvalidProjectionValue(path: string[]): never {
+  throw planInvalid(
+    `Invalid projection value at path ${path.join('.')}: expected ColumnBuilder or nested object`,
+  );
+}
+
+export function errorIncludeAliasNotFound(alias: string): never {
+  throw planInvalid(
+    `Include alias "${alias}" not found. Did you call includeMany() with alias "${alias}"?`,
+  );
+}
+
+export function errorInvalidProjectionKey(key: string): never {
+  throw planInvalid(
+    `Invalid projection value at key "${key}": expected ColumnBuilder, boolean true (for includes), or nested object`,
+  );
+}
+
+export function errorProjectionEmpty(): never {
+  throw planInvalid('select() requires at least one column or include');
+}
+
+export function errorCreateRequiresFields(): never {
+  throw planInvalid('create() requires at least one field');
+}
+
+export function errorUpdateRequiresFields(): never {
+  throw planInvalid('update() requires at least one field');
+}
+
+export function errorIncludeRequiresCapabilities(): never {
+  throw planInvalid('includeMany requires lateral and jsonAgg capabilities');
+}
+
+export function errorIncludeCapabilitiesNotTrue(): never {
+  throw planInvalid('includeMany requires lateral and jsonAgg capabilities to be true');
+}
+
+export function errorMultiColumnJoinsNotSupported(): never {
+  throw planInvalid('Multi-column joins in includes are not yet supported');
+}
+
+export function errorJoinColumnsMustBeDefined(): never {
+  throw planInvalid('Join columns must be defined');
+}
+
+export function errorColumnNotFound(columnName: string, tableName: string): never {
+  throw planInvalid(`Column ${columnName} not found in table ${tableName}`);
+}
+
+export function errorChildProjectionMustBeSpecified(): never {
+  throw planInvalid('Child projection must be specified');
+}
+
+export function errorChildProjectionEmpty(): never {
+  throw planInvalid('Child projection must not be empty after filtering boolean values');
+}
+
+export function errorMissingAlias(index: number): never {
+  throw planInvalid(`Missing alias at index ${index}`);
+}
+
+export function errorMissingColumn(alias: string, index: number): never {
+  throw planInvalid(`Missing column for alias "${alias}" at index ${index}`);
+}
+
+export function errorInvalidColumn(alias: string, index: number): never {
+  throw planInvalid(`Invalid column for alias "${alias}" at index ${index}`);
+}
+
+export function errorRelationNotFound(relationName: string, modelName: string): never {
+  throw planInvalid(`Relation ${relationName} not found on model ${modelName}`);
+}
+
+export function errorFailedToBuildWhereClause(): never {
+  throw planInvalid('Failed to build WHERE clause');
+}
+
+export function assertColumnExists(
+  columnMeta: StorageColumn | undefined,
+  columnName: string,
+  tableName: string,
+): asserts columnMeta is StorageColumn {
+  if (!columnMeta) {
+    errorUnknownColumn(columnName, tableName);
+  }
+}
+
+export function assertParameterExists(
+  paramsMap: Record<string, unknown>,
+  paramName: string,
+): unknown {
+  if (!Object.hasOwn(paramsMap, paramName)) {
+    errorMissingParameter(paramName);
+  }
+  return paramsMap[paramName];
+}

package/src/utils/param-descriptor.ts

@@ -0,0 +1,19 @@
+import type { ParamDescriptor } from '@prisma-next/contract/types';
+
+export function createParamDescriptor(args: {
+  name: string;
+  table: string;
+  column: string;
+  codecId?: string;
+  nativeType?: string;
+  nullable: boolean;
+}): ParamDescriptor {
+  return {
+    name: args.name,
+    source: 'dsl',
+    refs: { table: args.table, column: args.column },
+    ...(args.codecId ? { codecId: args.codecId } : {}),
+    ...(args.nativeType ? { nativeType: args.nativeType } : {}),
+    nullable: args.nullable,
+  };
+}