automatically merge *joinRelation calls. closes Vincit#1114

koskimas · koskimas · commit 4a5315ce8ebd · 2018-12-29T20:20:14.000+02:00
diff --git a/lib/queryBuilder/QueryBuilder.js b/lib/queryBuilder/QueryBuilder.js
@@ -5,7 +5,7 @@ const Bluebird = require('bluebird');
 const { raw } = require('./RawBuilder');
 const { createModifier } = require('../utils/createModifier');
 const { Type: ValidationErrorType } = require('../model/ValidationError');
-const { isObject, isString, isFunction, last } = require('../utils/objectUtils');
+const { isObject, isString, isFunction, last, groupBy } = require('../utils/objectUtils');
 const { RelationExpression, DuplicateRelationError } = require('./RelationExpression');
 const { Selection } = require('./operations/select/Selection');
 
@@ -55,6 +55,7 @@ class QueryBuilder extends QueryBuilderBase {
     this._eagerModifiersAtPath = [];
     this._allowedEagerExpression = null;
     this._allowedUpsertExpression = null;
+    this._joinRelations = [];
 
     this._findOperationOptions = modelClass.defaultFindOptions;
     this._eagerOperationOptions = modelClass.defaultEagerOptions;
@@ -383,6 +384,10 @@ class QueryBuilder extends QueryBuilderBase {
     return !!this._eagerExpression;
   }
 
+  hasJoinRelation() {
+    return this._joinRelations.length > 0;
+  }
+
   isSelectAll() {
     if (this._operations.length === 0) {
       return true;
@@ -457,6 +462,7 @@ class QueryBuilder extends QueryBuilderBase {
 
     builder._findOperationOptions = this._findOperationOptions;
     builder._eagerOperationOptions = this._eagerOperationOptions;
+    builder._joinRelations = this._joinRelations.slice();
 
     builder._findOperationFactory = this._findOperationFactory;
     builder._insertOperationFactory = this._insertOperationFactory;
@@ -558,6 +564,12 @@ class QueryBuilder extends QueryBuilderBase {
     // Take a clone so that we don't modify this instance during build.
     const builder = this.clone();
 
+    if (builder.hasJoinRelation()) {
+      // If there are some *joinRelation calls, merge the expressions
+      // and add the needed operations.
+      addJoinRelationOperations(builder);
+    }
+
     if (builder.isFind()) {
       // If no write operations have been called at this point this query is a
       // find query and we need to call the custom find implementation.
@@ -980,60 +992,60 @@ class QueryBuilder extends QueryBuilderBase {
     return this.addOperation(new FirstOperation('first'), arguments);
   }
 
-  joinRelation() {
-    return this.addOperation(
-      new JoinRelationOperation('joinRelation', { joinOperation: 'join' }),
-      arguments
-    );
+  joinRelation(...args) {
+    return this.innerJoinRelation(...args);
   }
 
-  innerJoinRelation() {
-    return this.addOperation(
-      new JoinRelationOperation('innerJoinRelation', { joinOperation: 'innerJoin' }),
-      arguments
-    );
+  innerJoinRelation(expression, options) {
+    this._joinRelations.push({
+      joinOperation: 'innerJoin',
+      expression,
+      options
+    });
+
+    return this;
   }
 
-  outerJoinRelation() {
-    return this.addOperation(
-      new JoinRelationOperation('outerJoinRelation', { joinOperation: 'outerJoin' }),
-      arguments
-    );
+  outerJoinRelation(expression, options) {
+    this._joinRelations.push({
+      joinOperation: 'outerJoin',
+      expression,
+      options
+    });
+
+    return this;
   }
 
-  leftJoinRelation() {
-    return this.addOperation(
-      new JoinRelationOperation('leftJoinRelation', { joinOperation: 'leftJoin' }),
-      arguments
-    );
+  fullOuterJoinRelation(...args) {
+    return this.outerJoin(...args);
   }
 
-  leftOuterJoinRelation() {
-    return this.addOperation(
-      new JoinRelationOperation('leftOuterJoinRelation', { joinOperation: 'leftOuterJoin' }),
-      arguments
-    );
+  leftJoinRelation(expression, options) {
+    this._joinRelations.push({
+      joinOperation: 'leftJoin',
+      expression,
+      options
+    });
+
+    return this;
   }
 
-  rightJoinRelation() {
-    return this.addOperation(
-      new JoinRelationOperation('rightJoinRelation', { joinOperation: 'rightJoin' }),
-      arguments
-    );
+  leftOuterJoinRelation(...args) {
+    return this.leftJoinRelation(...args);
   }
 
-  rightOuterJoinRelation() {
-    return this.addOperation(
-      new JoinRelationOperation('rightOuterJoinRelation', { joinOperation: 'rightOuterJoin' }),
-      arguments
-    );
+  rightJoinRelation(expression, options) {
+    this._joinRelations.push({
+      joinOperation: 'rightJoin',
+      expression,
+      options
+    });
+
+    return this;
   }
 
-  fullOuterJoinRelation() {
-    return this.addOperation(
-      new JoinRelationOperation('fullOuterJoinRelation', { joinOperation: 'fullOuterJoin' }),
-      arguments
-    );
+  rightOuterJoinRelation(...args) {
+    return this.rightJoinRelation(...args);
   }
 
   deleteById() {
@@ -1144,6 +1156,12 @@ function findQueryExecutorOperation(builder) {
 function beforeExecute(builder) {
   let promise = Promise.resolve();
 
+  if (builder.hasJoinRelation()) {
+    // If there are some *joinRelation calls, merge the expressions
+    // and add the needed operations.
+    addJoinRelationOperations(builder);
+  }
+
   if (builder.isFind()) {
     // If no write operations have been called at this point this query is a
     // find query and we need to call the custom find implementation.
@@ -1251,6 +1269,16 @@ function handleExecuteError(builder, err) {
   return promise;
 }
 
+function addJoinRelationOperations(builder) {
+  if (!builder.has(JoinRelationOperation)) {
+    const callsGroupedByJoinOperation = groupBy(builder._joinRelations, call => call.joinOperation);
+
+    callsGroupedByJoinOperation.forEach(calls => {
+      builder.addOperation(new JoinRelationOperation(), calls);
+    });
+  }
+}
+
 function addFindOperation(builder) {
   if (!builder.has(FindOperation)) {
     const operation = builder._findOperationFactory(builder);
diff --git a/lib/queryBuilder/RelationExpression.js b/lib/queryBuilder/RelationExpression.js
@@ -83,6 +83,10 @@ class RelationExpression {
     }
   }
 
+  static getChildNames(exprObject) {
+    return getChildNames(exprObject);
+  }
+
   get numChildren() {
     return this.childNames.length;
   }
diff --git a/lib/queryBuilder/operations/JoinRelationOperation.js b/lib/queryBuilder/operations/JoinRelationOperation.js
@@ -6,54 +6,80 @@ const { RelationExpression } = require('../RelationExpression');
 const { isString } = require('../../utils/objectUtils');
 
 class JoinRelationOperation extends QueryBuilderOperation {
-  constructor(name, opt) {
-    super(name, opt);
-
-    this.expression = null;
-    this.callOpt = null;
-  }
-
-  onAdd(builder, args) {
-    this.expression = RelationExpression.create(args[0]);
-    this.callOpt = args[1] || {};
+  onAdd(_, calls) {
+    this.calls = calls;
     return true;
   }
 
   onBuild(builder) {
     const modelClass = builder.modelClass();
-    const opt = Object.assign({}, this.callOpt);
-
-    opt.aliases = Object.assign({}, opt.aliases);
-    opt.joinOperation = this.opt.joinOperation;
-
-    // Special case for one single relation.
-    if (this.expression.numChildren === 1) {
-      const relationNames = this.expression.childNames.map(it => this.expression[it].$relation);
-      const relationName = relationNames[0];
-      const relation = modelClass.getRelation(relationName);
-      let alias = null;
-
-      if (opt.alias === false) {
-        alias = builder.tableRefFor(relation.relatedModelClass.getTableName());
-      } else if (opt.alias === true || !opt.alias) {
-        alias = relation.name;
-      } else if (isString(opt.alias)) {
-        alias = opt.alias;
+    const joinOperation = this.calls[0].joinOperation;
+    let mergedExpr = RelationExpression.create();
+
+    for (const call of this.calls) {
+      const expr = RelationExpression.create(call.expression).toPojo();
+      const childNames = RelationExpression.getChildNames(expr);
+      const options = call.options || {};
+
+      if (childNames.length === 1) {
+        applyAlias(expr, modelClass, builder, options);
       }
 
-      if (alias) {
-        opt.aliases[relationName] = alias;
+      if (options.aliases) {
+        applyAliases(expr, modelClass, options);
       }
+
+      mergedExpr = mergedExpr.merge(expr);
     }
 
     const joinBuilder = new RelationJoinBuilder({
       modelClass,
-      expression: this.expression
+      expression: mergedExpr
     });
 
-    joinBuilder.setOptions(opt);
+    joinBuilder.setOptions({ joinOperation });
     joinBuilder.buildJoinOnly(builder);
   }
 }
 
+function applyAlias(expr, modelClass, builder, options) {
+  const childNames = RelationExpression.getChildNames(expr);
+  const childName = childNames[0];
+  const childExpr = expr[childName];
+  const relation = modelClass.getRelation(childExpr.$relation);
+
+  let alias = childName;
+
+  if (options.alias === false) {
+    alias = builder.tableRefFor(relation.relatedModelClass.getTableName());
+  } else if (isString(options.alias)) {
+    alias = options.alias;
+  }
+
+  if (childName !== alias) {
+    renameRelationExpressionNode(expr, childName, alias);
+  }
+}
+
+function applyAliases(expr, modelClass, options) {
+  for (const childName of RelationExpression.getChildNames(expr)) {
+    const childExpr = expr[childName];
+    const relation = modelClass.getRelation(childExpr.$relation);
+    const alias = options.aliases[childExpr.$relation];
+
+    if (alias && alias !== childName) {
+      renameRelationExpressionNode(expr, childName, alias);
+    }
+
+    applyAliases(childExpr, relation.relatedModelClass, options);
+  }
+}
+
+function renameRelationExpressionNode(expr, oldName, newName) {
+  const childExpr = expr[oldName];
+  delete expr[oldName];
+  expr[newName] = childExpr;
+  childExpr.$name = newName;
+}
+
 module.exports = JoinRelationOperation;
diff --git a/tests/integration/find.js b/tests/integration/find.js

Original file line number	Diff line number	Diff line change
`@@ -83,6 +83,10 @@ class RelationExpression {`
`83`	`83`	`}`
`84`	`84`	`}`
`85`	`85`
	`86`	`+ static getChildNames(exprObject) {`
	`87`	`+ return getChildNames(exprObject);`
	`88`	`+ }`
	`89`	`+`
`86`	`90`	`get numChildren() {`
`87`	`91`	`return this.childNames.length;`
`88`	`92`	`}`