metal-orm 1.0.38 → 1.0.40

package/src/query-builder/hydration-manager.ts

@@ -7,63 +7,63 @@ import { ProjectionNode, SelectQueryState } from './select-query-state.js';
 import { ColumnNode, eq } from '../core/ast/expression.js';
 import { createJoinNode } from '../core/ast/join-node.js';
 import { JOIN_KINDS } from '../core/sql/sql.js';
-
-/**
- * Manages hydration planning for query results
- */
-export class HydrationManager {
-  /**
-   * Creates a new HydrationManager instance
-   * @param table - Table definition
-   * @param planner - Hydration planner
-   */
-  constructor(
-    private readonly table: TableDef,
-    private readonly planner: HydrationPlanner
-  ) {}
-
-  /**
-   * Creates a new HydrationManager with updated planner
-   * @param nextPlanner - Updated hydration planner
-   * @returns New HydrationManager instance
-   */
-  private clone(nextPlanner: HydrationPlanner): HydrationManager {
-    return new HydrationManager(this.table, nextPlanner);
-  }
-
-  /**
-   * Handles column selection for hydration planning
-   * @param state - Current query state
-   * @param newColumns - Newly selected columns
-   * @returns Updated HydrationManager with captured columns
-   */
-  onColumnsSelected(state: SelectQueryState, newColumns: ProjectionNode[]): HydrationManager {
-    const updated = this.planner.captureRootColumns(newColumns);
-    return this.clone(updated);
-  }
-
-  /**
-   * Handles relation inclusion for hydration planning
-   * @param state - Current query state
-   * @param relation - Relation definition
-   * @param relationName - Name of the relation
-   * @param aliasPrefix - Alias prefix for the relation
-   * @param targetColumns - Target columns to include
-   * @returns Updated HydrationManager with included relation
-   */
-  onRelationIncluded(
-    state: SelectQueryState,
-    relation: RelationDef,
-    relationName: string,
-    aliasPrefix: string,
-    targetColumns: string[],
-    pivot?: { aliasPrefix: string; columns: string[] }
-  ): HydrationManager {
-    const withRoots = this.planner.captureRootColumns(state.ast.columns);
-    const next = withRoots.includeRelation(relation, relationName, aliasPrefix, targetColumns, pivot);
-    return this.clone(next);
-  }
-
+
+/**
+ * Manages hydration planning for query results
+ */
+export class HydrationManager {
+  /**
+   * Creates a new HydrationManager instance
+   * @param table - Table definition
+   * @param planner - Hydration planner
+   */
+  constructor(
+    private readonly table: TableDef,
+    private readonly planner: HydrationPlanner
+  ) {}
+
+  /**
+   * Creates a new HydrationManager with updated planner
+   * @param nextPlanner - Updated hydration planner
+   * @returns New HydrationManager instance
+   */
+  private clone(nextPlanner: HydrationPlanner): HydrationManager {
+    return new HydrationManager(this.table, nextPlanner);
+  }
+
+  /**
+   * Handles column selection for hydration planning
+   * @param state - Current query state
+   * @param newColumns - Newly selected columns
+   * @returns Updated HydrationManager with captured columns
+   */
+  onColumnsSelected(state: SelectQueryState, newColumns: ProjectionNode[]): HydrationManager {
+    const updated = this.planner.captureRootColumns(newColumns);
+    return this.clone(updated);
+  }
+
+  /**
+   * Handles relation inclusion for hydration planning
+   * @param state - Current query state
+   * @param relation - Relation definition
+   * @param relationName - Name of the relation
+   * @param aliasPrefix - Alias prefix for the relation
+   * @param targetColumns - Target columns to include
+   * @returns Updated HydrationManager with included relation
+   */
+  onRelationIncluded(
+    state: SelectQueryState,
+    relation: RelationDef,
+    relationName: string,
+    aliasPrefix: string,
+    targetColumns: string[],
+    pivot?: { aliasPrefix: string; columns: string[] }
+  ): HydrationManager {
+    const withRoots = this.planner.captureRootColumns(state.ast.columns);
+    const next = withRoots.includeRelation(relation, relationName, aliasPrefix, targetColumns, pivot);
+    return this.clone(next);
+  }
+
   /**
    * Applies hydration plan to the AST
    * @param ast - Query AST to modify
@@ -82,11 +82,11 @@ export class HydrationManager {
     const rewritten = needsPaginationGuard ? this.wrapForParentPagination(ast, plan) : ast;
     return this.attachHydrationMeta(rewritten, plan);
   }
-
-  /**
-   * Gets the current hydration plan
-   * @returns Hydration plan or undefined if none exists
-   */
+
+  /**
+   * Gets the current hydration plan
+   * @returns Hydration plan or undefined if none exists
+   */
   getPlan(): HydrationPlan | undefined {
     return this.planner.getPlan();
   }
@@ -251,38 +251,52 @@ export class HydrationManager {
     const mapped: OrderByNode[] = [];
 
     for (const ob of orderBy) {
-      // Only rewrite when ordering by root columns; child columns would reintroduce the pagination bug.
-      if (ob.column.table !== plan.rootTable) {
-        return null;
-      }
+      const mappedTerm = this.mapOrderingTerm(ob.term, plan, projectionAliases, baseAlias, availableColumns);
+      if (!mappedTerm) return null;
 
-      const alias = projectionAliases.get(`${ob.column.table}.${ob.column.name}`) ?? ob.column.name;
-      if (!availableColumns.has(alias)) {
-        return null;
-      }
-
-      mapped.push({
-        type: 'OrderBy',
-        column: { type: 'Column', table: baseAlias, name: alias },
-        direction: ob.direction
-      });
+      mapped.push({ ...ob, term: mappedTerm });
     }
 
     return mapped;
   }
 
+  private mapOrderingTerm(
+    term: OrderByNode['term'],
+    plan: HydrationPlan,
+    projectionAliases: Map<string, string>,
+    baseAlias: string,
+    availableColumns: Set<string>
+  ): OrderByNode['term'] | null {
+    if ((term as any).type === 'Column') {
+      const col = term as ColumnNode;
+      if (col.table !== plan.rootTable) return null;
+      const alias = projectionAliases.get(`${col.table}.${col.name}`) ?? col.name;
+      if (!availableColumns.has(alias)) return null;
+      return { type: 'Column', table: baseAlias, name: alias };
+    }
+
+    if ((term as any).type === 'AliasRef') {
+      const aliasName = (term as any).name;
+      if (!availableColumns.has(aliasName)) return null;
+      return { type: 'Column', table: baseAlias, name: aliasName };
+    }
+
+    return null;
+  }
+
   private buildPagingColumns(primaryKey: string, orderBy: OrderByNode[] | undefined, tableAlias: string): ColumnNode[] {
     const columns: ColumnNode[] = [{ type: 'Column', table: tableAlias, name: primaryKey, alias: primaryKey }];
 
     if (!orderBy) return columns;
 
     for (const ob of orderBy) {
-      if (!columns.some(col => col.name === ob.column.name)) {
+      const term = ob.term as ColumnNode;
+      if (!columns.some(col => col.name === term.name)) {
         columns.push({
           type: 'Column',
           table: tableAlias,
-          name: ob.column.name,
-          alias: ob.column.name
+          name: term.name,
+          alias: term.name
         });
       }
     }

package/src/query-builder/query-ast-service.ts

@@ -1,52 +1,61 @@
-import { TableDef } from '../schema/table.js';
-import { ColumnDef } from '../schema/column.js';
-import { SelectQueryNode, CommonTableExpressionNode, SetOperationKind, SetOperationNode, TableSourceNode } from '../core/ast/query.js';
-import { buildColumnNode } from '../core/ast/builders.js';
-import {
-  ColumnNode,
-  ExpressionNode,
-  FunctionNode,
-  CaseExpressionNode,
-  WindowFunctionNode,
-  ScalarSubqueryNode,
-  and,
-  isExpressionSelectionNode
-} from '../core/ast/expression.js';
-import { JoinNode } from '../core/ast/join.js';
-import { SelectQueryState, ProjectionNode } from './select-query-state.js';
-import { OrderDirection } from '../core/sql/sql.js';
-import { parseRawColumn } from './raw-column-parser.js';
-
-/**
- * Result of column selection operation
- */
-export interface ColumnSelectionResult {
-  /**
-   * Updated query state
-   */
-  state: SelectQueryState;
-  /**
-   * Columns that were added
-   */
-  addedColumns: ProjectionNode[];
-}
-
-/**
- * Service for manipulating query AST (Abstract Syntax Tree)
- */
-export class QueryAstService {
-  /**
-   * Creates a new QueryAstService instance
-   * @param table - Table definition
-   * @param state - Current query state
-   */
-  constructor(private readonly table: TableDef, private readonly state: SelectQueryState) {}
-
-  /**
-   * Selects columns for the query
-   * @param columns - Columns to select (key: alias, value: column definition or expression)
-   * @returns Column selection result with updated state and added columns
-   */
+import { TableDef } from '../schema/table.js';
+import { ColumnDef } from '../schema/column.js';
+import {
+  SelectQueryNode,
+  CommonTableExpressionNode,
+  SetOperationKind,
+  SetOperationNode,
+  TableSourceNode,
+  OrderingTerm
+} from '../core/ast/query.js';
+import { buildColumnNode } from '../core/ast/builders.js';
+import {
+  AliasRefNode,
+  ColumnNode,
+  ExpressionNode,
+  FunctionNode,
+  CaseExpressionNode,
+  WindowFunctionNode,
+  ScalarSubqueryNode,
+  and,
+  isExpressionSelectionNode,
+  isOperandNode
+} from '../core/ast/expression.js';
+import { JoinNode } from '../core/ast/join.js';
+import { SelectQueryState, ProjectionNode } from './select-query-state.js';
+import { OrderDirection } from '../core/sql/sql.js';
+import { parseRawColumn } from './raw-column-parser.js';
+
+/**
+ * Result of column selection operation
+ */
+export interface ColumnSelectionResult {
+  /**
+   * Updated query state
+   */
+  state: SelectQueryState;
+  /**
+   * Columns that were added
+   */
+  addedColumns: ProjectionNode[];
+}
+
+/**
+ * Service for manipulating query AST (Abstract Syntax Tree)
+ */
+export class QueryAstService {
+  /**
+   * Creates a new QueryAstService instance
+   * @param table - Table definition
+   * @param state - Current query state
+   */
+  constructor(private readonly table: TableDef, private readonly state: SelectQueryState) {}
+
+  /**
+   * Selects columns for the query
+   * @param columns - Columns to select (key: alias, value: column definition or expression)
+   * @returns Column selection result with updated state and added columns
+   */
   select(
     columns: Record<string, ColumnDef | FunctionNode | CaseExpressionNode | WindowFunctionNode>
   ): ColumnSelectionResult {
@@ -77,16 +86,16 @@ export class QueryAstService {
       } as ColumnNode);
       return acc;
     }, []);
-
-    const nextState = this.state.withColumns(newCols);
-    return { state: nextState, addedColumns: newCols };
-  }
-
-  /**
-   * Selects raw column expressions (best-effort parser for simple references/functions)
-   * @param cols - Raw column expressions
-   * @returns Column selection result with updated state and added columns
-   */
+
+    const nextState = this.state.withColumns(newCols);
+    return { state: nextState, addedColumns: newCols };
+  }
+
+  /**
+   * Selects raw column expressions (best-effort parser for simple references/functions)
+   * @param cols - Raw column expressions
+   * @returns Column selection result with updated state and added columns
+   */
   selectRaw(cols: string[]): ColumnSelectionResult {
     const from = this.state.ast.from;
     const defaultTable = from.type === 'Table' && from.alias ? from.alias : this.table.name;
@@ -94,15 +103,15 @@ export class QueryAstService {
     const nextState = this.state.withColumns(newCols);
     return { state: nextState, addedColumns: newCols };
   }
-
-  /**
-   * Adds a Common Table Expression (CTE) to the query
-   * @param name - Name of the CTE
-   * @param query - Query for the CTE
-   * @param columns - Optional column names for the CTE
-   * @param recursive - Whether the CTE is recursive
-   * @returns Updated query state with CTE
-   */
+
+  /**
+   * Adds a Common Table Expression (CTE) to the query
+   * @param name - Name of the CTE
+   * @param query - Query for the CTE
+   * @param columns - Optional column names for the CTE
+   * @param recursive - Whether the CTE is recursive
+   * @returns Updated query state with CTE
+   */
   withCte(name: string, query: SelectQueryNode, columns?: string[], recursive = false): SelectQueryState {
     const cte: CommonTableExpressionNode = {
       type: 'CommonTableExpression',
@@ -138,107 +147,135 @@ export class QueryAstService {
   withFrom(from: TableSourceNode): SelectQueryState {
     return this.state.withFrom(from);
   }
-
-  /**
-   * Selects a subquery as a column
-   * @param alias - Alias for the subquery
-   * @param query - Subquery to select
-   * @returns Updated query state with subquery selection
-   */
-  selectSubquery(alias: string, query: SelectQueryNode): SelectQueryState {
-    const node: ScalarSubqueryNode = { type: 'ScalarSubquery', query, alias };
-    return this.state.withColumns([node]);
-  }
-
-  /**
-   * Adds a JOIN clause to the query
-   * @param join - Join node to add
-   * @returns Updated query state with JOIN
-   */
-  withJoin(join: JoinNode): SelectQueryState {
-    return this.state.withJoin(join);
-  }
-
-  /**
-   * Adds a WHERE clause to the query
-   * @param expr - Expression for the WHERE clause
-   * @returns Updated query state with WHERE clause
-   */
-  withWhere(expr: ExpressionNode): SelectQueryState {
-    const combined = this.combineExpressions(this.state.ast.where, expr);
-    return this.state.withWhere(combined);
-  }
-
-  /**
-   * Adds a GROUP BY clause to the query
-   * @param col - Column to group by
-   * @returns Updated query state with GROUP BY clause
-   */
-  withGroupBy(col: ColumnDef | ColumnNode): SelectQueryState {
-    const from = this.state.ast.from;
-    const tableRef = from.type === 'Table' && from.alias ? { ...this.table, alias: from.alias } : this.table;
-    const node = buildColumnNode(tableRef, col);
-    return this.state.withGroupBy([node]);
-  }
-
-  /**
-   * Adds a HAVING clause to the query
-   * @param expr - Expression for the HAVING clause
-   * @returns Updated query state with HAVING clause
-   */
-  withHaving(expr: ExpressionNode): SelectQueryState {
-    const combined = this.combineExpressions(this.state.ast.having, expr);
-    return this.state.withHaving(combined);
-  }
-
-  /**
-   * Adds an ORDER BY clause to the query
-   * @param col - Column to order by
-   * @param direction - Order direction (ASC/DESC)
-   * @returns Updated query state with ORDER BY clause
-   */
-  withOrderBy(col: ColumnDef | ColumnNode, direction: OrderDirection): SelectQueryState {
+
+  /**
+   * Selects a subquery as a column
+   * @param alias - Alias for the subquery
+   * @param query - Subquery to select
+   * @returns Updated query state with subquery selection
+   */
+  selectSubquery(alias: string, query: SelectQueryNode): SelectQueryState {
+    const node: ScalarSubqueryNode = { type: 'ScalarSubquery', query, alias };
+    return this.state.withColumns([node]);
+  }
+
+  /**
+   * Adds a JOIN clause to the query
+   * @param join - Join node to add
+   * @returns Updated query state with JOIN
+   */
+  withJoin(join: JoinNode): SelectQueryState {
+    return this.state.withJoin(join);
+  }
+
+  /**
+   * Adds a WHERE clause to the query
+   * @param expr - Expression for the WHERE clause
+   * @returns Updated query state with WHERE clause
+   */
+  withWhere(expr: ExpressionNode): SelectQueryState {
+    const combined = this.combineExpressions(this.state.ast.where, expr);
+    return this.state.withWhere(combined);
+  }
+
+  /**
+   * Adds a GROUP BY clause to the query
+   * @param col - Column to group by
+   * @returns Updated query state with GROUP BY clause
+   */
+  withGroupBy(col: ColumnDef | OrderingTerm): SelectQueryState {
+    const term = this.normalizeOrderingTerm(col);
+    return this.state.withGroupBy([term]);
+  }
+
+  /**
+   * Adds a HAVING clause to the query
+   * @param expr - Expression for the HAVING clause
+   * @returns Updated query state with HAVING clause
+   */
+  withHaving(expr: ExpressionNode): SelectQueryState {
+    const combined = this.combineExpressions(this.state.ast.having, expr);
+    return this.state.withHaving(combined);
+  }
+
+  /**
+   * Adds an ORDER BY clause to the query
+   * @param col - Column to order by
+   * @param direction - Order direction (ASC/DESC)
+   * @returns Updated query state with ORDER BY clause
+   */
+  withOrderBy(
+    term: ColumnDef | OrderingTerm,
+    direction: OrderDirection,
+    nulls?: 'FIRST' | 'LAST',
+    collation?: string
+  ): SelectQueryState {
+    const normalized = this.normalizeOrderingTerm(term);
+    return this.state.withOrderBy([{ type: 'OrderBy', term: normalized, direction, nulls, collation }]);
+  }
+
+  /**
+   * Adds a DISTINCT clause to the query
+   * @param cols - Columns to make distinct
+   * @returns Updated query state with DISTINCT clause
+   */
+  withDistinct(cols: ColumnNode[]): SelectQueryState {
+    return this.state.withDistinct(cols);
+  }
+
+  /**
+   * Adds a LIMIT clause to the query
+   * @param limit - Maximum number of rows to return
+   * @returns Updated query state with LIMIT clause
+   */
+  withLimit(limit: number): SelectQueryState {
+    return this.state.withLimit(limit);
+  }
+
+  /**
+   * Adds an OFFSET clause to the query
+   * @param offset - Number of rows to skip
+   * @returns Updated query state with OFFSET clause
+   */
+  withOffset(offset: number): SelectQueryState {
+    return this.state.withOffset(offset);
+  }
+
+  /**
+   * Combines expressions with AND operator
+   * @param existing - Existing expression
+   * @param next - New expression to combine
+   * @returns Combined expression
+   */
+  private combineExpressions(existing: ExpressionNode | undefined, next: ExpressionNode): ExpressionNode {
+    return existing ? and(existing, next) : next;
+  }
+
+  private normalizeOrderingTerm(term: ColumnDef | OrderingTerm): OrderingTerm {
     const from = this.state.ast.from;
     const tableRef = from.type === 'Table' && from.alias ? { ...this.table, alias: from.alias } : this.table;
-    const node = buildColumnNode(tableRef, col);
-    return this.state.withOrderBy([{ type: 'OrderBy', column: node, direction }]);
-  }
-
-  /**
-   * Adds a DISTINCT clause to the query
-   * @param cols - Columns to make distinct
-   * @returns Updated query state with DISTINCT clause
-   */
-  withDistinct(cols: ColumnNode[]): SelectQueryState {
-    return this.state.withDistinct(cols);
-  }
-
-  /**
-   * Adds a LIMIT clause to the query
-   * @param limit - Maximum number of rows to return
-   * @returns Updated query state with LIMIT clause
-   */
-  withLimit(limit: number): SelectQueryState {
-    return this.state.withLimit(limit);
-  }
-
-  /**
-   * Adds an OFFSET clause to the query
-   * @param offset - Number of rows to skip
-   * @returns Updated query state with OFFSET clause
-   */
-  withOffset(offset: number): SelectQueryState {
-    return this.state.withOffset(offset);
-  }
-
-  /**
-   * Combines expressions with AND operator
-   * @param existing - Existing expression
-   * @param next - New expression to combine
-   * @returns Combined expression
-   */
-  private combineExpressions(existing: ExpressionNode | undefined, next: ExpressionNode): ExpressionNode {
-    return existing ? and(existing, next) : next;
-  }
-
-}
+    const termType = (term as any)?.type;
+    if (termType === 'Column') {
+      return term as ColumnNode;
+    }
+    if (termType === 'AliasRef') {
+      return term as AliasRefNode;
+    }
+    if (isOperandNode(term)) {
+      return term as OrderingTerm;
+    }
+    if (
+      termType === 'BinaryExpression' ||
+      termType === 'LogicalExpression' ||
+      termType === 'NullExpression' ||
+      termType === 'InExpression' ||
+      termType === 'ExistsExpression' ||
+      termType === 'BetweenExpression' ||
+      termType === 'ArithmeticExpression'
+    ) {
+      return term as ExpressionNode;
+    }
+    return buildColumnNode(tableRef, term as ColumnDef);
+  }
+
+}