metal-orm 1.0.57 → 1.0.58

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

@@ -1,10 +1,11 @@
-import { TableDef } from '../schema/table.js';
-import { RelationDef, RelationKinds, BelongsToManyRelation } from '../schema/relation.js';
-import { ExpressionNode, eq, and } from '../core/ast/expression.js';
-import { findPrimaryKey } from './hydration-planner.js';
-import { JoinNode } from '../core/ast/join.js';
-import { JoinKind } from '../core/sql/sql.js';
-import { createJoinNode } from '../core/ast/join-node.js';
+import { TableDef } from '../schema/table.js';
+import { RelationDef, RelationKinds, BelongsToManyRelation } from '../schema/relation.js';
+import { ExpressionNode, eq, and } from '../core/ast/expression.js';
+import { TableSourceNode } from '../core/ast/query.js';
+import { findPrimaryKey } from './hydration-planner.js';
+import { JoinNode } from '../core/ast/join.js';
+import { JoinKind } from '../core/sql/sql.js';
+import { createJoinNode } from '../core/ast/join-node.js';
 
 /**
  * Utility function to handle unreachable code paths
@@ -21,26 +22,32 @@ const assertNever = (value: never): never => {
  * @param relation - Relation definition
  * @returns Expression node representing the join condition
  */
-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 baseRelationCondition = (
+  root: TableDef,
+  relation: RelationDef,
+  rootAlias?: string,
+  targetTableName?: string
+): ExpressionNode => {
+  const rootTable = rootAlias || root.name;
+  const targetTable = targetTableName ?? relation.target.name;
+  const defaultLocalKey =
+    relation.type === RelationKinds.HasMany || relation.type === RelationKinds.HasOne
+      ? findPrimaryKey(root)
+      : findPrimaryKey(relation.target);
   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: 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.HasMany:
+    case RelationKinds.HasOne:
+      return eq(
+        { type: 'Column', table: targetTable, name: relation.foreignKey },
+        { type: 'Column', table: rootTable, name: localKey }
+      );
+    case RelationKinds.BelongsTo:
+      return eq(
+        { type: 'Column', table: targetTable, name: localKey },
+        { type: 'Column', table: rootTable, name: relation.foreignKey }
+      );
     case RelationKinds.BelongsToMany:
       throw new Error('BelongsToMany relations do not support the standard join condition builder');
     default:
@@ -58,14 +65,16 @@ const baseRelationCondition = (root: TableDef, relation: RelationDef, rootAlias?
  * @param rootAlias - Optional alias for the root table
  * @returns Array of join nodes for the pivot and target tables
  */
-export const buildBelongsToManyJoins = (
-  root: TableDef,
-  relationName: string,
-  relation: BelongsToManyRelation,
-  joinKind: JoinKind,
-  extra?: ExpressionNode,
-  rootAlias?: string
-): JoinNode[] => {
+export const buildBelongsToManyJoins = (
+  root: TableDef,
+  relationName: string,
+  relation: BelongsToManyRelation,
+  joinKind: JoinKind,
+  extra?: ExpressionNode,
+  rootAlias?: string,
+  targetTable?: TableSourceNode,
+  targetTableName?: string
+): JoinNode[] => {
   const rootKey = relation.localKey || findPrimaryKey(root);
   const targetKey = relation.targetKey || findPrimaryKey(relation.target);
   const rootTable = rootAlias || root.name;
@@ -81,21 +90,27 @@ export const buildBelongsToManyJoins = (
     pivotCondition
   );
 
-  let targetCondition: ExpressionNode = eq(
-    { type: 'Column', table: relation.target.name, name: targetKey },
-    { type: 'Column', table: relation.pivotTable.name, name: relation.pivotForeignKeyToTarget }
-  );
-
-  if (extra) {
-    targetCondition = and(targetCondition, extra);
-  }
-
-  const targetJoin = createJoinNode(
-    joinKind,
-    { type: 'Table', name: relation.target.name, schema: relation.target.schema },
-    targetCondition,
-    relationName
-  );
+  const targetSource: TableSourceNode = targetTable ?? {
+    type: 'Table',
+    name: relation.target.name,
+    schema: relation.target.schema
+  };
+  const effectiveTargetName = targetTableName ?? relation.target.name;
+  let targetCondition: ExpressionNode = eq(
+    { type: 'Column', table: effectiveTargetName, name: targetKey },
+    { type: 'Column', table: relation.pivotTable.name, name: relation.pivotForeignKeyToTarget }
+  );
+
+  if (extra) {
+    targetCondition = and(targetCondition, extra);
+  }
+
+  const targetJoin = createJoinNode(
+    joinKind,
+    targetSource,
+    targetCondition,
+    relationName
+  );
 
   return [pivotJoin, targetJoin];
 };
@@ -108,15 +123,16 @@ export const buildBelongsToManyJoins = (
  * @param rootAlias - Optional alias for the root table
  * @returns Expression node representing the complete join condition
  */
-export const buildRelationJoinCondition = (
-  root: TableDef,
-  relation: RelationDef,
-  extra?: ExpressionNode,
-  rootAlias?: string
-): ExpressionNode => {
-  const base = baseRelationCondition(root, relation, rootAlias);
-  return extra ? and(base, extra) : base;
-};
+export const buildRelationJoinCondition = (
+  root: TableDef,
+  relation: RelationDef,
+  extra?: ExpressionNode,
+  rootAlias?: string,
+  targetTableName?: string
+): ExpressionNode => {
+  const base = baseRelationCondition(root, relation, rootAlias, targetTableName);
+  return extra ? and(base, extra) : base;
+};
 
 /**
  * Builds a relation correlation condition for subqueries
@@ -125,6 +141,11 @@ export const buildRelationJoinCondition = (
  * @param rootAlias - Optional alias for the root table
  * @returns Expression node representing the correlation condition
  */
-export const buildRelationCorrelation = (root: TableDef, relation: RelationDef, rootAlias?: string): ExpressionNode => {
-  return baseRelationCondition(root, relation, rootAlias);
-};
+export const buildRelationCorrelation = (
+  root: TableDef,
+  relation: RelationDef,
+  rootAlias?: string,
+  targetTableName?: string
+): ExpressionNode => {
+  return baseRelationCondition(root, relation, rootAlias, targetTableName);
+};