metal-orm 1.0.17 → 1.0.18

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

@@ -1,6 +1,6 @@
 import { TableDef } from '../schema/table.js';
 import { ColumnDef } from '../schema/column.js';
-import { SelectQueryNode, CommonTableExpressionNode, SetOperationKind, SetOperationNode } from '../core/ast/query.js';
+import { SelectQueryNode, CommonTableExpressionNode, SetOperationKind, SetOperationNode, TableSourceNode } from '../core/ast/query.js';
 import { buildColumnNode } from '../core/ast/builders.js';
 import {
   ColumnNode,
@@ -47,30 +47,36 @@ export class QueryAstService {
    * @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 {
-    const existingAliases = new Set(
-      this.state.ast.columns.map(c => (c as ColumnNode).alias || (c as ColumnNode).name)
-    );
-
-    const newCols = Object.entries(columns).reduce<ProjectionNode[]>((acc, [alias, val]) => {
-      if (existingAliases.has(alias)) return acc;
-
-      if (isExpressionSelectionNode(val)) {
-        acc.push({ ...(val as FunctionNode | CaseExpressionNode | WindowFunctionNode), alias } as ProjectionNode);
-        return acc;
-      }
-
-      const colDef = val as ColumnDef;
-      acc.push({
-        type: 'Column',
-        table: colDef.table || this.table.name,
-        name: colDef.name,
-        alias
-      } as ColumnNode);
-      return acc;
-    }, []);
+  select(
+    columns: Record<string, ColumnDef | FunctionNode | CaseExpressionNode | WindowFunctionNode>
+  ): ColumnSelectionResult {
+    const existingAliases = new Set(
+      this.state.ast.columns.map(c => (c as ColumnNode).alias || (c as ColumnNode).name)
+    );
+    const from = this.state.ast.from;
+    const rootTableName = from.type === 'Table' && from.alias ? from.alias : this.table.name;
+
+    const newCols = Object.entries(columns).reduce<ProjectionNode[]>((acc, [alias, val]) => {
+      if (existingAliases.has(alias)) return acc;
+
+      if (isExpressionSelectionNode(val)) {
+        acc.push({ ...(val as FunctionNode | CaseExpressionNode | WindowFunctionNode), alias } as ProjectionNode);
+        return acc;
+      }
+
+      const colDef = val as ColumnDef;
+      const resolvedTable =
+        colDef.table && colDef.table === this.table.name && from.type === 'Table' && from.alias
+          ? from.alias
+          : colDef.table || rootTableName;
+      acc.push({
+        type: 'Column',
+        table: resolvedTable,
+        name: colDef.name,
+        alias
+      } as ColumnNode);
+      return acc;
+    }, []);
 
     const nextState = this.state.withColumns(newCols);
     return { state: nextState, addedColumns: newCols };
@@ -81,11 +87,13 @@ export class QueryAstService {
    * @param cols - Raw column expressions
    * @returns Column selection result with updated state and added columns
    */
-  selectRaw(cols: string[]): ColumnSelectionResult {
-    const newCols = cols.map(col => parseRawColumn(col, this.table.name, this.state.ast.ctes));
-    const nextState = this.state.withColumns(newCols);
-    return { state: nextState, addedColumns: newCols };
-  }
+  selectRaw(cols: string[]): ColumnSelectionResult {
+    const from = this.state.ast.from;
+    const defaultTable = from.type === 'Table' && from.alias ? from.alias : this.table.name;
+    const newCols = cols.map(col => parseRawColumn(col, defaultTable, this.state.ast.ctes));
+    const nextState = this.state.withColumns(newCols);
+    return { state: nextState, addedColumns: newCols };
+  }
 
   /**
    * Adds a Common Table Expression (CTE) to the query
@@ -121,6 +129,15 @@ export class QueryAstService {
     };
     return this.state.withSetOperation(op);
   }
+
+  /**
+   * Replaces the FROM clause for the current query.
+   * @param from - Table source to use in the FROM clause
+   * @returns Updated query state with new FROM
+   */
+  withFrom(from: TableSourceNode): SelectQueryState {
+    return this.state.withFrom(from);
+  }
 
   /**
    * Selects a subquery as a column
@@ -157,10 +174,12 @@ export class QueryAstService {
    * @param col - Column to group by
    * @returns Updated query state with GROUP BY clause
    */
-  withGroupBy(col: ColumnDef | ColumnNode): SelectQueryState {
-    const node = buildColumnNode(this.table, col);
-    return this.state.withGroupBy([node]);
-  }
+  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
@@ -178,10 +197,12 @@ export class QueryAstService {
    * @param direction - Order direction (ASC/DESC)
    * @returns Updated query state with ORDER BY clause
    */
-  withOrderBy(col: ColumnDef | ColumnNode, direction: OrderDirection): SelectQueryState {
-    const node = buildColumnNode(this.table, col);
-    return this.state.withOrderBy([{ type: 'OrderBy', column: node, direction }]);
-  }
+  withOrderBy(col: ColumnDef | ColumnNode, direction: OrderDirection): 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.withOrderBy([{ type: 'OrderBy', column: node, direction }]);
+  }
 
   /**
    * Adds a DISTINCT clause to the query

package/src/query-builder/relation-conditions.ts

@@ -21,25 +21,26 @@ const assertNever = (value: never): never => {
  * @param relation - Relation definition
  * @returns Expression node representing the join condition
  */
-const baseRelationCondition = (root: TableDef, relation: RelationDef): ExpressionNode => {
-  const defaultLocalKey =
+const baseRelationCondition = (root: TableDef, relation: RelationDef, rootAlias?: string): ExpressionNode => {
+  const rootTable = rootAlias || root.name;
+  const defaultLocalKey =
   relation.type === RelationKinds.HasMany || relation.type === RelationKinds.HasOne
     ? findPrimaryKey(root)
     : findPrimaryKey(relation.target);
-  const localKey = relation.localKey || defaultLocalKey;
+  const localKey = relation.localKey || defaultLocalKey;
 
   switch (relation.type) {
     case RelationKinds.HasMany:
     case RelationKinds.HasOne:
       return eq(
         { type: 'Column', table: relation.target.name, name: relation.foreignKey },
-        { type: 'Column', table: root.name, name: localKey }
+        { type: 'Column', table: rootTable, name: localKey }
+      );
+    case RelationKinds.BelongsTo:
+      return eq(
+        { type: 'Column', table: relation.target.name, name: localKey },
+        { type: 'Column', table: rootTable, name: relation.foreignKey }
       );
-    case RelationKinds.BelongsTo:
-      return eq(
-        { type: 'Column', table: relation.target.name, name: localKey },
-        { type: 'Column', table: root.name, name: relation.foreignKey }
-      );
     case RelationKinds.BelongsToMany:
       throw new Error('BelongsToMany relations do not support the standard join condition builder');
     default:
@@ -50,20 +51,22 @@ const baseRelationCondition = (root: TableDef, relation: RelationDef): Expressio
 /**
  * Builds the join nodes required to include a BelongsToMany relation.
  */
-export const buildBelongsToManyJoins = (
-  root: TableDef,
-  relationName: string,
-  relation: BelongsToManyRelation,
-  joinKind: JoinKind,
-  extra?: ExpressionNode
-): JoinNode[] => {
-  const rootKey = relation.localKey || findPrimaryKey(root);
-  const targetKey = relation.targetKey || findPrimaryKey(relation.target);
-
-  const pivotCondition = eq(
-    { type: 'Column', table: relation.pivotTable.name, name: relation.pivotForeignKeyToRoot },
-    { type: 'Column', table: root.name, name: rootKey }
-  );
+export const buildBelongsToManyJoins = (
+  root: TableDef,
+  relationName: string,
+  relation: BelongsToManyRelation,
+  joinKind: JoinKind,
+  extra?: ExpressionNode,
+  rootAlias?: string
+): JoinNode[] => {
+  const rootKey = relation.localKey || findPrimaryKey(root);
+  const targetKey = relation.targetKey || findPrimaryKey(relation.target);
+  const rootTable = rootAlias || root.name;
+
+  const pivotCondition = eq(
+    { type: 'Column', table: relation.pivotTable.name, name: relation.pivotForeignKeyToRoot },
+    { type: 'Column', table: rootTable, name: rootKey }
+  );
 
   const pivotJoin = createJoinNode(joinKind, relation.pivotTable.name, pivotCondition);
 
@@ -93,14 +96,15 @@ export const buildBelongsToManyJoins = (
  * @param extra - Optional additional expression to combine with AND
  * @returns Expression node representing the complete join condition
  */
-export const buildRelationJoinCondition = (
-  root: TableDef,
-  relation: RelationDef,
-  extra?: ExpressionNode
-): ExpressionNode => {
-  const base = baseRelationCondition(root, relation);
-  return extra ? and(base, extra) : base;
-};
+export const buildRelationJoinCondition = (
+  root: TableDef,
+  relation: RelationDef,
+  extra?: ExpressionNode,
+  rootAlias?: string
+): ExpressionNode => {
+  const base = baseRelationCondition(root, relation, rootAlias);
+  return extra ? and(base, extra) : base;
+};
 
 /**
  * Builds a relation correlation condition for subqueries
@@ -108,6 +112,6 @@ export const buildRelationJoinCondition = (
  * @param relation - Relation definition
  * @returns Expression node representing the correlation condition
  */
-export const buildRelationCorrelation = (root: TableDef, relation: RelationDef): ExpressionNode => {
-  return baseRelationCondition(root, relation);
-};
+export const buildRelationCorrelation = (root: TableDef, relation: RelationDef, rootAlias?: string): ExpressionNode => {
+  return baseRelationCondition(root, relation, rootAlias);
+};

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

@@ -67,9 +67,14 @@ export class RelationManager {
    * @param ast - Query AST to modify
    * @returns Modified query AST with relation correlation
    */
-  applyRelationCorrelation(context: SelectQueryBuilderContext, relationName: string, ast: SelectQueryNode): SelectQueryNode {
-    return this.createService(context).applyRelationCorrelation(relationName, ast);
-  }
+  applyRelationCorrelation(
+    context: SelectQueryBuilderContext,
+    relationName: string,
+    ast: SelectQueryNode,
+    additionalCorrelation?: ExpressionNode
+  ): SelectQueryNode {
+    return this.createService(context).applyRelationCorrelation(relationName, ast, additionalCorrelation);
+  }
 
   /**
    * Creates a relation service instance

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

@@ -70,17 +70,17 @@ export class RelationService {
    * @param predicate - Optional predicate expression
    * @returns Relation result with updated state and hydration
    */
-  match(
-    relationName: string,
-    predicate?: ExpressionNode
-  ): RelationResult {
-    const joined = this.joinRelation(relationName, JOIN_KINDS.INNER, predicate);
-    const pk = findPrimaryKey(this.table);
-    const distinctCols: ColumnNode[] = [{ type: 'Column', table: this.table.name, name: pk }];
-    const existingDistinct = joined.state.ast.distinct ? joined.state.ast.distinct : [];
-    const nextState = this.astService(joined.state).withDistinct([...existingDistinct, ...distinctCols]);
-    return { state: nextState, hydration: joined.hydration };
-  }
+  match(
+    relationName: string,
+    predicate?: ExpressionNode
+  ): RelationResult {
+    const joined = this.joinRelation(relationName, JOIN_KINDS.INNER, predicate);
+    const pk = findPrimaryKey(this.table);
+    const distinctCols: ColumnNode[] = [{ type: 'Column', table: this.rootTableName(), name: pk }];
+    const existingDistinct = joined.state.ast.distinct ? joined.state.ast.distinct : [];
+    const nextState = this.astService(joined.state).withDistinct([...existingDistinct, ...distinctCols]);
+    return { state: nextState, hydration: joined.hydration };
+  }
 
   /**
    * Includes a relation in the query result
@@ -190,17 +190,22 @@ export class RelationService {
    * @param ast - Query AST to modify
    * @returns Modified query AST with relation correlation
    */
-  applyRelationCorrelation(
-    relationName: string,
-    ast: SelectQueryNode
-  ): SelectQueryNode {
-    const relation = this.getRelation(relationName);
-    const correlation = buildRelationCorrelation(this.table, relation);
-    const whereInSubquery = ast.where
-      ? and(correlation, ast.where)
-      : correlation;
-
-    return {
+  applyRelationCorrelation(
+    relationName: string,
+    ast: SelectQueryNode,
+    additionalCorrelation?: ExpressionNode
+  ): SelectQueryNode {
+    const relation = this.getRelation(relationName);
+    const rootAlias = this.state.ast.from.type === 'Table' ? this.state.ast.from.alias : undefined;
+    let correlation = buildRelationCorrelation(this.table, relation, rootAlias);
+    if (additionalCorrelation) {
+      correlation = and(correlation, additionalCorrelation);
+    }
+    const whereInSubquery = ast.where
+      ? and(correlation, ast.where)
+      : correlation;
+
+    return {
       ...ast,
       where: whereInSubquery
     };
@@ -214,26 +219,28 @@ export class RelationService {
    * @param extraCondition - Additional join condition
    * @returns Updated query state with join
    */
-  private withJoin(
-    state: SelectQueryState,
-    relationName: string,
-    joinKind: JoinKind,
-    extraCondition?: ExpressionNode
-  ): SelectQueryState {
-    const relation = this.getRelation(relationName);
-    if (relation.type === RelationKinds.BelongsToMany) {
-      const joins = buildBelongsToManyJoins(
-        this.table,
-        relationName,
-        relation as BelongsToManyRelation,
-        joinKind,
-        extraCondition
-      );
-      return joins.reduce((current, join) => this.astService(current).withJoin(join), state);
-    }
-
-    const condition = buildRelationJoinCondition(this.table, relation, extraCondition);
-    const joinNode = createJoinNode(joinKind, relation.target.name, condition, relationName);
+  private withJoin(
+    state: SelectQueryState,
+    relationName: string,
+    joinKind: JoinKind,
+    extraCondition?: ExpressionNode
+  ): SelectQueryState {
+    const relation = this.getRelation(relationName);
+    const rootAlias = state.ast.from.type === 'Table' ? state.ast.from.alias : undefined;
+    if (relation.type === RelationKinds.BelongsToMany) {
+      const joins = buildBelongsToManyJoins(
+        this.table,
+        relationName,
+        relation as BelongsToManyRelation,
+        joinKind,
+        extraCondition,
+        rootAlias
+      );
+      return joins.reduce((current, join) => this.astService(current).withJoin(join), state);
+    }
+
+    const condition = buildRelationJoinCondition(this.table, relation, extraCondition, rootAlias);
+    const joinNode = createJoinNode(joinKind, relation.target.name, condition, relationName);
 
     return this.astService(state).withJoin(joinNode);
   }
@@ -277,9 +284,15 @@ export class RelationService {
    * @param state - Current query state
    * @returns QueryAstService instance
    */
-  private astService(state: SelectQueryState = this.state): QueryAstService {
-    return this.createQueryAstService(this.table, state);
-  }
-}
+  private astService(state: SelectQueryState = this.state): QueryAstService {
+    return this.createQueryAstService(this.table, state);
+  }
+
+  private rootTableName(): string {
+    const from = this.state.ast.from;
+    if (from.type === 'Table' && from.alias) return from.alias;
+    return this.table.name;
+  }
+}
 
 export type { RelationResult } from './relation-projection-helper.js';

package/src/query-builder/select-query-state.ts

@@ -1,5 +1,5 @@
 import { TableDef } from '../schema/table.js';
-import { SelectQueryNode, CommonTableExpressionNode, OrderByNode, SetOperationNode } from '../core/ast/query.js';
+import { SelectQueryNode, CommonTableExpressionNode, OrderByNode, SetOperationNode, TableSourceNode } from '../core/ast/query.js';
 import {
   ColumnNode,
   ExpressionNode,
@@ -74,12 +74,24 @@ export class SelectQueryState {
    * @param join - Join node to add
    * @returns New SelectQueryState with added join
    */
-  withJoin(join: JoinNode): SelectQueryState {
-    return this.clone({
-      ...this.ast,
-      joins: [...(this.ast.joins ?? []), join]
-    });
-  }
+  withJoin(join: JoinNode): SelectQueryState {
+    return this.clone({
+      ...this.ast,
+      joins: [...(this.ast.joins ?? []), join]
+    });
+  }
+
+  /**
+   * Replaces the FROM clause.
+   * @param from - Table source for the FROM clause
+   * @returns New SelectQueryState with updated FROM
+   */
+  withFrom(from: TableSourceNode): SelectQueryState {
+    return this.clone({
+      ...this.ast,
+      from
+    });
+  }
 
   /**
    * Adds a WHERE clause to the query