objection 3.9.0 → 4.0.0-rc.1

package/lib/queryBuilder/operations/RunBeforeOperation.js

@@ -1,8 +1,6 @@
-'use strict';
+import { QueryBuilderOperation } from './QueryBuilderOperation.js';
 
-const { QueryBuilderOperation } = require('./QueryBuilderOperation');
-
-class RunBeforeOperation extends QueryBuilderOperation {
+export class RunBeforeOperation extends QueryBuilderOperation {
   constructor(name, opt) {
     super(name, opt);
     this.func = null;
@@ -23,7 +21,3 @@ class RunBeforeOperation extends QueryBuilderOperation {
     return clone;
   }
 }
-
-module.exports = {
-  RunBeforeOperation,
-};

package/lib/queryBuilder/operations/UnrelateOperation.js

@@ -1,8 +1,6 @@
-'use strict';
+import { QueryBuilderOperation } from './QueryBuilderOperation.js';
 
-const { QueryBuilderOperation } = require('./QueryBuilderOperation');
-
-class UnrelateOperation extends QueryBuilderOperation {
+export class UnrelateOperation extends QueryBuilderOperation {
   constructor(name, opt) {
     super(name, opt);
 
@@ -17,7 +15,3 @@ class UnrelateOperation extends QueryBuilderOperation {
     return clone;
   }
 }
-
-module.exports = {
-  UnrelateOperation,
-};

package/lib/queryBuilder/operations/UpdateAndFetchOperation.js

@@ -1,11 +1,8 @@
-'use strict';
+import { DelegateOperation } from './DelegateOperation.js';
+import { FindByIdOperation } from './FindByIdOperation.js';
+import { UpdateOperation } from './UpdateOperation.js';
 
-const { DelegateOperation } = require('./DelegateOperation');
-const { FindByIdOperation } = require('./FindByIdOperation');
-const { UpdateOperation } = require('./UpdateOperation');
-const { addWhereGroup, assignWhereGroup } = require('../whereGroups');
-
-class UpdateAndFetchOperation extends DelegateOperation {
+export class UpdateAndFetchOperation extends DelegateOperation {
   constructor(name, opt) {
     super(name, opt);
 
@@ -42,7 +39,7 @@ class UpdateAndFetchOperation extends DelegateOperation {
 
   onBuild(builder) {
     if (!this.skipIdWhere) {
-      addWhereGroup(builder, () => builder.findById(this.id));
+      builder.findById(this.id);
     }
 
     super.onBuild(builder);
@@ -67,6 +64,13 @@ class UpdateAndFetchOperation extends DelegateOperation {
       .castTo(builder.resultModelClass());
 
     if (fetched) {
+      if (!fetched.$isObjectionModel) {
+        throw new Error(
+          `Unable to merge the result of ${builder.modelClass().name}.afterFind() in ` +
+            `${this.name}(): expected a model.`,
+        );
+      }
+
       this.model.$set(fetched);
       // A custom `select` may not include the id. The row was fetched by
       // id, so make sure the result still has it.
@@ -84,12 +88,9 @@ class UpdateAndFetchOperation extends DelegateOperation {
     // many-to-many updates move to a subquery when the query is built.
     const delegate = this.delegate.toFindOperation(builder);
 
-    // Keep the id condition in its own where group, like `onBuild()` does. The
-    // delegate isn't named `findById`, as that would put all the wheres that it
-    // adds in the user's group.
     return delegate
       ? new FindByIdDelegateOperation('find', { delegate, id: this.id })
-      : assignWhereGroup(new FindByIdOperation('findById', { id: this.id }));
+      : new FindByIdOperation('findById', { id: this.id });
   }
 
   clone() {
@@ -107,10 +108,6 @@ class UpdateAndFetchOperation extends DelegateOperation {
 class FindByIdDelegateOperation extends DelegateOperation {
   onBuild(builder) {
     super.onBuild(builder);
-    addWhereGroup(builder, () => builder.findById(this.opt.id));
+    builder.findById(this.opt.id);
   }
 }
-
-module.exports = {
-  UpdateAndFetchOperation,
-};

package/lib/queryBuilder/operations/UpdateOperation.js

@@ -1,18 +1,14 @@
-'use strict';
-
-const { ref } = require('../../queryBuilder/ReferenceBuilder');
-const { isEmpty, isObject } = require('../../utils/objectUtils');
-const {
-  isFieldExpressionKey,
-  toPostgresJsonPathLiteral,
-} = require('../../utils/parseFieldExpression');
-const { isKnexRaw, isKnexQueryBuilder } = require('../../utils/knexUtils');
-const { QueryBuilderOperation } = require('./QueryBuilderOperation');
-const { warnIfNotPostgres } = require('./jsonApi/postgresJsonApi');
-const { StaticHookArguments } = require('../StaticHookArguments');
-const { ValidationErrorType } = require('../../model/ValidationError');
-
-class UpdateOperation extends QueryBuilderOperation {
+import { isEmpty } from '../../utils/objectUtils.js';
+import { QueryBuilderOperation } from './QueryBuilderOperation.js';
+import { StaticHookArguments } from '../StaticHookArguments.js';
+import { removeOverriddenValues } from '../../model/modelQueryProps.js';
+import {
+  checkFieldExpressions,
+  convertFieldExpressionsToRaw,
+  removeFieldExpressions,
+} from './fieldExpressions.js';
+
+export class UpdateOperation extends QueryBuilderOperation {
   constructor(name, opt) {
     super(name, opt);
 
@@ -31,6 +27,7 @@ class UpdateOperation extends QueryBuilderOperation {
 
   async onBefore2(builder, result) {
     await callBeforeUpdate(builder, this.model, this.modelOptions);
+    removeOverriddenValues(this.model);
     return result;
   }
 
@@ -52,15 +49,38 @@ class UpdateOperation extends QueryBuilderOperation {
     return builder.isExplicitlyResolvedOrRejected() && !this.hasNothingToUpdate;
   }
 
+  // Returns true if the query was resolved without writing anything, by a hook
+  // or because there is nothing to update in the table.
+  // @overridable
+  isResolvedWithoutWrite(builder) {
+    return builder.isExplicitlyResolvedOrRejected();
+  }
+
+  // knex leaves the offset out of updates, and on SQL Server the limit as well.
+  // Throw when the query is executed.
+  onAfterBuild(builder) {
+    if (builder.has('offset')) {
+      throw new Error('offset() is not supported in update queries, as knex leaves it out.');
+    }
+  }
+
   onBuildKnex(knexBuilder, builder) {
     const json = this.model.$toDatabaseJson(builder);
-    const convertedJson = convertFieldExpressionsToRaw(builder, this.model, json);
 
-    return knexBuilder.update(convertedJson);
+    if (this.modelOptions.patch) {
+      return knexBuilder.update(convertFieldExpressionsToRaw(builder, json));
+    } else {
+      checkFieldExpressions(builder.modelClass(), this.model, 'update');
+      return knexBuilder.update(json);
+    }
   }
 
-  onAfter2(builder, numUpdated) {
-    return callAfterUpdate(builder, this.model, this.modelOptions, numUpdated);
+  async onAfter2(builder, numUpdated) {
+    await this.model.$afterUpdate(this.modelOptions, builder.context());
+    // The patched model is what the write returns, e.g. to `upsertGraph()` and
+    // `patchAndFetch()`, or what it merges into the instance of `$query()`:
+    removeFieldExpressions(builder.modelClass(), this.model);
+    return numUpdated;
   }
 
   toFindOperation() {
@@ -88,109 +108,3 @@ function callStaticBeforeUpdate(builder) {
   const args = StaticHookArguments.create({ builder });
   return builder.modelClass().beforeUpdate(args);
 }
-
-async function callAfterUpdate(builder, model, modelOptions, result) {
-  await callInstanceAfterUpdate(builder, model, modelOptions);
-  return callStaticAfterUpdate(builder, result);
-}
-
-function callInstanceAfterUpdate(builder, model, modelOptions) {
-  return model.$afterUpdate(modelOptions, builder.context());
-}
-
-async function callStaticAfterUpdate(builder, result) {
-  const args = StaticHookArguments.create({ builder, result });
-  const maybeResult = await builder.modelClass().afterUpdate(args);
-
-  if (maybeResult === undefined) {
-    return result;
-  } else {
-    return maybeResult;
-  }
-}
-
-function convertFieldExpressionsToRaw(builder, model, json) {
-  const knex = builder.knex();
-  const modelClass = builder.modelClass();
-  const declaredColumns = getDeclaredColumns(modelClass);
-  const convertedJson = {};
-
-  for (const key of Object.keys(json)) {
-    let val = json[key];
-
-    if (isFieldExpressionKey(key, declaredColumns)) {
-      // 'col:attr' : ref('other:lol') is transformed to
-      // "col" : raw(`jsonb_set("table"."col", '{attr}', to_jsonb("other"#>'{lol}'), true)`)
-      // with the column qualified, as it is ambiguous with `excluded` in merge().
-      warnIfNotPostgres(knex);
-
-      let parsed = ref(key);
-
-      // The field expression would be lost or produce invalid SQL next to a
-      // value for the whole json column. Report it with the property names:
-      if (Object.prototype.hasOwnProperty.call(json, parsed.column)) {
-        const property = modelClass.columnNameToPropertyName(parsed.column);
-        throw modelClass.createValidationError({
-          type: ValidationErrorType.ModelValidation,
-          data: {
-            [modelClass.columnNameToPropertyName(key)]: [
-              {
-                message: `can't be combined with a value for the json column '${property}'`,
-                keyword: null,
-                params: { property },
-              },
-            ],
-          },
-        });
-      }
-
-      let jsonPath = toPostgresJsonPathLiteral(parsed.parsedExpr.access);
-      let valuePlaceholder = '?';
-
-      if (isKnexQueryBuilder(val) || isKnexRaw(val)) {
-        valuePlaceholder = 'to_jsonb(?)';
-      } else {
-        val = JSON.stringify(val);
-      }
-
-      convertedJson[parsed.column] = knex.raw(
-        `jsonb_set(??, ${jsonPath}, ${valuePlaceholder}, true)`,
-        [convertedJson[parsed.column] || `${builder.tableRef()}.${parsed.column}`, val],
-      );
-
-      delete model[key];
-    } else {
-      convertedJson[key] = val;
-    }
-  }
-
-  return convertedJson;
-}
-
-const declaredColumnsByModelClass = new WeakMap();
-
-// The keys of `json` are column names, so map the properties with a ':' that the
-// schema declares to their columns, once per model class. Properties that only
-// the schema returned by `$beforeValidate()` declares aren't known here.
-function getDeclaredColumns(modelClass) {
-  let declaredColumns = declaredColumnsByModelClass.get(modelClass);
-
-  if (!declaredColumns) {
-    const jsonSchema = modelClass.getJsonSchema();
-    const properties = jsonSchema && jsonSchema.properties;
-    declaredColumns = Object.fromEntries(
-      (isObject(properties) ? Object.keys(properties) : [])
-        .filter((key) => key.includes(':'))
-        .map((key) => [modelClass.propertyNameToColumnName(key), true]),
-    );
-    declaredColumnsByModelClass.set(modelClass, declaredColumns);
-  }
-
-  return declaredColumns;
-}
-
-module.exports = {
-  UpdateOperation,
-  convertFieldExpressionsToRaw,
-  getDeclaredColumns,
-};

package/lib/queryBuilder/operations/UpsertGraphAndFetchOperation.js

@@ -1,10 +1,8 @@
-'use strict';
+import { DelegateOperation } from './DelegateOperation.js';
+import { UpsertGraphOperation } from './UpsertGraphOperation.js';
+import { RelationExpression } from '../RelationExpression.js';
 
-const { DelegateOperation } = require('./DelegateOperation');
-const { UpsertGraphOperation } = require('./UpsertGraphOperation');
-const { RelationExpression } = require('../RelationExpression');
-
-class UpsertGraphAndFetchOperation extends DelegateOperation {
+export class UpsertGraphAndFetchOperation extends DelegateOperation {
   constructor(name, opt) {
     super(name, opt);
 
@@ -21,7 +19,10 @@ class UpsertGraphAndFetchOperation extends DelegateOperation {
     return this.delegate.isArray;
   }
 
-  async onAfter3(builder) {
+  // Refetch the graph before the graph operations of the query run, so that a
+  // `withGraphFetched()` with its modifiers and options loads its relations
+  // into the fetched models, like in `InsertGraphAndFetchOperation` (#839).
+  async onAfter2(builder) {
     if (this.models.length === 0) {
       return this.isArray ? [] : null;
     }
@@ -39,7 +40,3 @@ class UpsertGraphAndFetchOperation extends DelegateOperation {
     return this.isArray ? models : models[0] || null;
   }
 }
-
-module.exports = {
-  UpsertGraphAndFetchOperation,
-};

package/lib/queryBuilder/operations/UpsertGraphOperation.js

@@ -1,10 +1,8 @@
-'use strict';
+import { QueryBuilderOperation } from './QueryBuilderOperation.js';
+import { GraphUpsert } from '../graph/GraphUpsert.js';
+import { RelationFindOperation } from '../../relations/RelationFindOperation.js';
 
-const { QueryBuilderOperation } = require('./QueryBuilderOperation');
-const { GraphUpsert } = require('../graph/GraphUpsert');
-const { RelationFindOperation } = require('../../relations/RelationFindOperation');
-
-class UpsertGraphOperation extends QueryBuilderOperation {
+export class UpsertGraphOperation extends QueryBuilderOperation {
   constructor(name, opt) {
     super(
       name,
@@ -41,14 +39,14 @@ class UpsertGraphOperation extends QueryBuilderOperation {
   }
 
   onBefore1(builder, result) {
-    GraphUpsert.warnOnConflict(builder, this.name);
+    GraphUpsert.checkForOnConflict(builder, this.name);
     return result;
   }
 
   onAfter1(builder) {
     if (hasOtherSqlModifyingQueryBuilderCalls(builder)) {
       throw new Error(
-        'upsertGraph query should contain no other query builder calls like `findById`, `where` or `$relatedQuery` that would affect the SQL. They have no effect.',
+        'upsertGraph query should contain no other query builder calls like `findById`, `where`, `$query` or `$relatedQuery` that would affect the SQL. They have no effect.',
       );
     }
 
@@ -65,7 +63,3 @@ class UpsertGraphOperation extends QueryBuilderOperation {
 function hasOtherSqlModifyingQueryBuilderCalls(builder) {
   return builder.has(/where/) || builder.has(RelationFindOperation);
 }
-
-module.exports = {
-  UpsertGraphOperation,
-};

package/lib/queryBuilder/operations/WhereCompositeOperation.js

@@ -1,9 +1,7 @@
-'use strict';
+import { ObjectionToKnexConvertingOperation } from './ObjectionToKnexConvertingOperation.js';
+import { asSingle } from '../../utils/objectUtils.js';
 
-const { ObjectionToKnexConvertingOperation } = require('./ObjectionToKnexConvertingOperation');
-const { asSingle } = require('../../utils/objectUtils');
-
-class WhereCompositeOperation extends ObjectionToKnexConvertingOperation {
+export class WhereCompositeOperation extends ObjectionToKnexConvertingOperation {
   onBuildKnex(knexBuilder, builder) {
     const args = this.getKnexArgs(builder);
 
@@ -51,7 +49,3 @@ function buildCompositeWhereArgs(cols, op, values) {
     },
   ];
 }
-
-module.exports = {
-  WhereCompositeOperation,
-};

package/lib/queryBuilder/operations/WhereGroupOperation.js

@@ -1,10 +1,8 @@
-'use strict';
-
-const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+import { QueryBuilderOperation } from './QueryBuilderOperation.js';
 
 // Builds a set of where operations inside a single knex `where(callback)`
 // group, i.e. wraps them in parentheses. See `getWhereGroupOperations()`.
-class WhereGroupOperation extends QueryBuilderOperation {
+export class WhereGroupOperation extends QueryBuilderOperation {
   constructor(name, opt) {
     super(name, opt);
     this.operations = opt.operations;
@@ -29,7 +27,3 @@ class WhereGroupOperation extends QueryBuilderOperation {
     });
   }
 }
-
-module.exports = {
-  WhereGroupOperation,
-};

package/lib/queryBuilder/operations/eager/EagerOperation.js

@@ -1,9 +1,7 @@
-'use strict';
+import { QueryBuilderOperation } from '../QueryBuilderOperation.js';
+import { RelationExpression } from '../../RelationExpression.js';
 
-const { QueryBuilderOperation } = require('../QueryBuilderOperation');
-const { RelationExpression } = require('../../RelationExpression');
-
-class EagerOperation extends QueryBuilderOperation {
+export class EagerOperation extends QueryBuilderOperation {
   constructor(name, opt) {
     super(name, opt);
 
@@ -57,7 +55,3 @@ class EagerOperation extends QueryBuilderOperation {
 function getModifierName(index) {
   return `_f${index}_`;
 }
-
-module.exports = {
-  EagerOperation,
-};

package/lib/queryBuilder/operations/eager/JoinEagerOperation.js

@@ -1,12 +1,13 @@
-'use strict';
+import { EagerOperation } from './EagerOperation.js';
+import { RelationJoiner } from '../../join/RelationJoiner.js';
+import { JoinedStaticHookArguments } from '../../StaticHookArguments.js';
+import { asArray } from '../../../utils/objectUtils.js';
 
-const { EagerOperation } = require('./EagerOperation');
-const { RelationJoiner } = require('../../join/RelationJoiner');
-
-class JoinEagerOperation extends EagerOperation {
+export class JoinEagerOperation extends EagerOperation {
   constructor(name, opt) {
     super(name, opt);
     this.joiner = null;
+    this.models = null;
   }
 
   onAdd(builder) {
@@ -43,7 +44,72 @@ class JoinEagerOperation extends EagerOperation {
   }
 
   onRawResult(builder, rows) {
-    return this.joiner.parseResult(builder, rows);
+    this.models = this.joiner.parseResult(builder, rows);
+    return this.models;
+  }
+
+  // Call the static `afterFind()` hooks of the joined relations bottom-up, after
+  // the `$afterFind()` hooks of all models, and assign the related models that
+  // they return, like `withGraphFetched()` does.
+  async onAfter3(builder, result) {
+    if (Array.isArray(this.models)) {
+      const [rootNode, ...nodes] = this.joiner.tableTree.nodes;
+      const modelsByNode = new Map([[rootNode, this.models]]);
+      const ownerByModel = new Map();
+
+      // The nodes are ordered from the root down, so the owners come first:
+      for (const node of nodes) {
+        const models = [];
+
+        for (const owner of modelsByNode.get(node.parentNode)) {
+          for (const model of asArray(owner[node.relationProperty])) {
+            if (model) {
+              models.push(model);
+              ownerByModel.set(model, owner);
+            }
+          }
+        }
+
+        modelsByNode.set(node, models);
+      }
+
+      for (const node of nodes.reverse()) {
+        const { modelClass, relation, relationProperty } = node;
+        const owners = modelsByNode.get(node.parentNode);
+        const models = modelsByNode.get(node);
+        const args = JoinedStaticHookArguments.create({
+          builder,
+          result: models,
+          relation,
+          items: owners,
+        });
+        const related = await modelClass.afterFind(args);
+
+        if (related !== undefined) {
+          const relatedByOwner = new Map(owners.map((owner) => [owner, []]));
+
+          for (const model of asArray(related)) {
+            const relatedOfOwner = relatedByOwner.get(ownerByModel.get(model));
+
+            if (!relatedOfOwner) {
+              throw new Error(
+                `Unable to assign the result of ${modelClass.name}.afterFind() to the relation ` +
+                  `"${relation.name}" of ${relation.ownerModelClass.name}: return the models ` +
+                  'you got, filtered or reordered.',
+              );
+            }
+
+            relatedOfOwner.push(model);
+          }
+
+          for (const [owner, related] of relatedByOwner) {
+            owner[relationProperty] = relation.isOneToOne() ? related[0] || null : related;
+          }
+        }
+      }
+    }
+
+    return result;
   }
 
   clone() {
@@ -52,7 +118,3 @@ class JoinEagerOperation extends EagerOperation {
     return clone;
   }
 }
-
-module.exports = {
-  JoinEagerOperation,
-};

package/lib/queryBuilder/operations/eager/NaiveEagerOperation.js

@@ -1,13 +1,7 @@
-'use strict';
+import { WhereInEagerOperation } from './WhereInEagerOperation.js';
 
-const { WhereInEagerOperation } = require('./WhereInEagerOperation');
-
-class NaiveEagerOperation extends WhereInEagerOperation {
+export class NaiveEagerOperation extends WhereInEagerOperation {
   batchSize() {
     return 1;
   }
 }
-
-module.exports = {
-  NaiveEagerOperation,
-};

package/lib/queryBuilder/operations/eager/WhereInEagerOperation.js

@@ -1,17 +1,16 @@
-'use strict';
-
-const promiseUtils = require('../../../utils/promiseUtils');
-
-const { EagerOperation } = require('./EagerOperation');
-const { LimitPerParentOperation } = require('../LimitPerParentOperation');
-const { isMsSql, isOracle, isSqlite, hasWindowFunctions } = require('../../../utils/knexUtils');
-const { isObject, asArray, flatten, chunk } = require('../../../utils/objectUtils');
-const { ValidationErrorType } = require('../../../model/ValidationError');
-const { createModifier } = require('../../../utils/createModifier');
-const { RelationDoesNotExistError } = require('../../../model/RelationDoesNotExistError');
-const { RelationOwner } = require('../../../relations/RelationOwner');
-
-class WhereInEagerOperation extends EagerOperation {
+import * as promiseUtils from '../../../utils/promiseUtils/index.js';
+
+import { EagerOperation } from './EagerOperation.js';
+import { LimitPerParentOperation } from '../LimitPerParentOperation.js';
+import { isMsSql, isOracle, isSqlite } from '../../../utils/knexUtils.js';
+import { isObject, asArray, flatten, chunk } from '../../../utils/objectUtils.js';
+import { ValidationErrorType } from '../../../model/ValidationError.js';
+import { createModifier } from '../../../utils/createModifier.js';
+import { RelationDoesNotExistError } from '../../../model/RelationDoesNotExistError.js';
+import { RelationOwner } from '../../../relations/RelationOwner.js';
+import { hasAliasSelection } from '../select/Selection.js';
+
+export class WhereInEagerOperation extends EagerOperation {
   constructor(name, opt) {
     super(name, opt);
 
@@ -64,10 +63,6 @@ class WhereInEagerOperation extends EagerOperation {
   async onAfter2(builder, result) {
     const modelClass = builder.resultModelClass();
 
-    if (!result) {
-      return result;
-    }
-
     const models = asArray(result);
 
     // Check models to be actual objects, to filter out `count` results (#2397).
@@ -86,9 +81,7 @@ class WhereInEagerOperation extends EagerOperation {
 
   async fetchRelation(builder, models, relation, expr) {
     const modelClass = builder.resultModelClass();
-    const batchSize = this.shouldFetchPerParent(builder, models, relation, expr)
-      ? 1
-      : this.batchSize(builder.knex());
+    const batchSize = this.batchSize(builder.knex());
     const modelBatches = chunk(models, batchSize);
 
     const result = await promiseUtils.map(
@@ -139,30 +132,16 @@ class WhereInEagerOperation extends EagerOperation {
       }
     }
 
-    if (this.graphOptions.limitPerParent) {
+    if (this.graphOptions.limitPerParent !== false) {
       queryBuilder.addOperation(
         new LimitPerParentOperation('limitPerParent', { findOperation }),
         [],
       );
     }
 
-    return queryBuilder;
-  }
-
-  // Without window functions, the related models can only be limited per
-  // parent with one query per parent.
-  shouldFetchPerParent(builder, models, relation, expr) {
-    if (this.graphOptions.limitPerParent && !hasWindowFunctions(builder.knex())) {
-      // Build the query to find its limits, also those of the relation's
-      // `modify` and of `onBuildKnex()` hooks. This runs its modifiers and
-      // build hooks once more than for fetching the relation.
-      const query = this.fetchRelationBatch(builder, models, relation, expr);
-      query.executeOnBuild();
-      const knexQuery = query.executeOnBuildKnex(query.knex().queryBuilder());
-      return !!query.findOperation(LimitPerParentOperation)?.getRange(knexQuery, query);
-    } else {
-      return false;
-    }
+    // The relation gets what its query returns, after its hooks and `runAfter()`
+    // callbacks:
+    return queryBuilder.then((result) => findOperation.assignResult(queryBuilder, result));
   }
 
   shouldSkipFetched(models, relation, expr) {
@@ -262,7 +241,11 @@ function findRelationPropsToSelect(builder, relationsToFetch) {
       const prop = ownerProp.props[c];
       const col = ownerProp.cols[c];
 
-      if (!builder.hasSelectionAs(fullCol, col) && selectionsToAdd.indexOf(fullCol) === -1) {
+      if (
+        !builder.hasSelectionAs(fullCol, col) &&
+        !hasAliasSelection(builder, col) &&
+        selectionsToAdd.indexOf(fullCol) === -1
+      ) {
         selectedProps.push(prop);
         selectionsToAdd.push(fullCol);
       }
@@ -294,7 +277,3 @@ function getRelatedModels(models, expr) {
 
   return allRelated;
 }
-
-module.exports = {
-  WhereInEagerOperation,
-};