metal-orm 1.0.16 → 1.0.18

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-helpers.ts

@@ -0,0 +1,50 @@
+import type { TableDef } from '../schema/table.js';
+import type { ColumnDef } from '../schema/column.js';
+import { getTableDefFromEntity } from '../decorators/bootstrap.js';
+
+/**
+ * Build a typed selection map from a TableDef.
+ */
+export function sel<
+  TTable extends TableDef,
+  K extends keyof TTable['columns'] & string
+>(table: TTable, ...cols: K[]): Record<K, TTable['columns'][K]> {
+  const selection = {} as Record<K, TTable['columns'][K]>;
+
+  for (const col of cols) {
+    const def = table.columns[col] as TTable['columns'][K];
+    if (!def) {
+      throw new Error(`Column '${col}' not found on table '${table.name}'`);
+    }
+    selection[col] = def;
+  }
+
+  return selection;
+}
+
+type Ctor<T> = { new (...args: any[]): T };
+
+/**
+ * Build a typed selection map from an entity constructor.
+ */
+export function esel<TEntity, K extends keyof TEntity & string>(
+  entity: Ctor<TEntity>,
+  ...props: K[]
+): Record<K, ColumnDef> {
+  const table = getTableDefFromEntity(entity) as TableDef | undefined;
+  if (!table) {
+    throw new Error(`No table definition registered for entity '${entity.name}'`);
+  }
+
+  const selection = {} as Record<K, ColumnDef>;
+
+  for (const prop of props) {
+    const col = table.columns[prop];
+    if (!col) {
+      throw new Error(`No column '${prop}' found for entity '${entity.name}'`);
+    }
+    selection[prop] = col;
+  }
+
+  return selection;
+}

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