@prisma-next/sql-orm-lane 0.3.0-dev.2 → 0.3.0-dev.20

package/src/selection/predicates.ts

@@ -0,0 +1,120 @@
+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 { augmentDescriptorWithColumnMeta } from '@prisma-next/sql-relational-core/plan';
+import type { BinaryBuilder, ParamPlaceholder } from '@prisma-next/sql-relational-core/types';
+import {
+  getColumnInfo,
+  getColumnMeta,
+  getOperationExpr,
+  isColumnBuilder,
+  isParamPlaceholder,
+} from '@prisma-next/sql-relational-core/utils/guards';
+import { createBinaryExpr, createColumnRef, 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: ColumnRef | OperationExpr;
+  let codecId: string | undefined;
+  let rightExpr: ColumnRef | ParamRef;
+  let paramName: string;
+
+  const operationExpr = getOperationExpr(where.left);
+  if (operationExpr) {
+    leftExpr = operationExpr;
+  } else if (isColumnBuilder(where.left)) {
+    const { table, column } = getColumnInfo(where.left);
+
+    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;
+    }
+    leftExpr = createColumnRef(table, column);
+  } else {
+    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 if where.left is a ColumnBuilder
+    if (isColumnBuilder(where.left)) {
+      const { table, column } = getColumnInfo(where.left);
+      const contractTable = contract.storage.tables[table];
+      const columnMeta = contractTable?.columns[column];
+      const builderColumnMeta = getColumnMeta(where.left);
+
+      descriptors.push({
+        name: paramName,
+        source: 'dsl',
+        refs: { table, column },
+        ...(typeof builderColumnMeta?.nullable === 'boolean'
+          ? { nullable: builderColumnMeta.nullable }
+          : {}),
+      });
+
+      augmentDescriptorWithColumnMeta(descriptors, columnMeta);
+    }
+
+    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);
+    }
+
+    // If column not found in contract, still build expression
+    // This allows flexibility when columnMeta is available on the column builder
+    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 ? { codecId } : {}),
+    paramName,
+  };
+}

package/src/selection/projection.ts

@@ -0,0 +1,136 @@
+import type { TableRef } from '@prisma-next/sql-relational-core/ast';
+import type {
+  AnyBinaryBuilder,
+  AnyColumnBuilder,
+  AnyOrderBuilder,
+  JoinOnPredicate,
+  NestedProjection,
+} from '@prisma-next/sql-relational-core/types';
+import { isColumnBuilder } 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: AnyColumnBuilder[];
+}
+
+export type ProjectionInput = Record<string, AnyColumnBuilder | 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: 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<{
+    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: AnyColumnBuilder[] = [];
+
+  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,
+        },
+      } as AnyColumnBuilder);
+    } 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 };
+}

package/src/selection/select-builder.ts

@@ -0,0 +1,82 @@
+import type {
+  BinaryExpr,
+  ColumnRef,
+  Direction,
+  ExistsExpr,
+  IncludeAst,
+  IncludeRef,
+  OperationExpr,
+  SelectAst,
+  TableRef,
+} from '@prisma-next/sql-relational-core/ast';
+import type { IncludeState } from '../relations/include-plan';
+import { createColumnRef, 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: ColumnRef | IncludeRef | OperationExpr }> {
+  const projectEntries: Array<{ alias: string; expr: ColumnRef | IncludeRef | OperationExpr }> = [];
+  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 {
+      const operationExpr = (column as { _operationExpr?: OperationExpr })._operationExpr;
+      if (operationExpr) {
+        projectEntries.push({
+          alias,
+          expr: operationExpr,
+        });
+      } else {
+        const col = column as { table: string; column: string };
+        const tableName = col.table;
+        const columnName = col.column;
+        if (!tableName || !columnName) {
+          errorInvalidColumn(alias, i);
+        }
+        projectEntries.push({
+          alias,
+          expr: createColumnRef(tableName, columnName),
+        });
+      }
+    }
+  }
+  return projectEntries;
+}
+
+export function buildSelectAst(params: {
+  table: TableRef;
+  projectEntries: Array<{ alias: string; expr: ColumnRef | IncludeRef | OperationExpr }>;
+  includesAst?: ReadonlyArray<IncludeAst>;
+  whereExpr?: BinaryExpr | ExistsExpr;
+  orderByClause?: ReadonlyArray<{
+    expr: ColumnRef | OperationExpr;
+    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,
+  };
+}