taon-typeorm 18.0.19 → 18.0.20

package/lib/typeorm/query-builder/SelectQueryBuilder.js

@@ -1,59 +1,59 @@
 "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var SelectQueryBuilder_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SelectQueryBuilder = void 0;
-var tslib_1 = require("tslib");
-var RawSqlResultsToEntityTransformer_1 = require("./transformer/RawSqlResultsToEntityTransformer");
-var PessimisticLockTransactionRequiredError_1 = require("../error/PessimisticLockTransactionRequiredError");
-var NoVersionOrUpdateDateColumnError_1 = require("../error/NoVersionOrUpdateDateColumnError");
-var OptimisticLockVersionMismatchError_1 = require("../error/OptimisticLockVersionMismatchError");
-var OptimisticLockCanNotBeUsedError_1 = require("../error/OptimisticLockCanNotBeUsedError");
-var JoinAttribute_1 = require("./JoinAttribute");
-var RelationIdAttribute_1 = require("./relation-id/RelationIdAttribute");
-var RelationCountAttribute_1 = require("./relation-count/RelationCountAttribute");
-var RelationIdLoader_1 = require("./relation-id/RelationIdLoader");
-var RelationIdMetadataToAttributeTransformer_1 = require("./relation-id/RelationIdMetadataToAttributeTransformer");
-var RelationCountLoader_1 = require("./relation-count/RelationCountLoader");
-var RelationCountMetadataToAttributeTransformer_1 = require("./relation-count/RelationCountMetadataToAttributeTransformer");
-var QueryBuilder_1 = require("./QueryBuilder");
+const RawSqlResultsToEntityTransformer_1 = require("./transformer/RawSqlResultsToEntityTransformer");
+const PessimisticLockTransactionRequiredError_1 = require("../error/PessimisticLockTransactionRequiredError");
+const NoVersionOrUpdateDateColumnError_1 = require("../error/NoVersionOrUpdateDateColumnError");
+const OptimisticLockVersionMismatchError_1 = require("../error/OptimisticLockVersionMismatchError");
+const OptimisticLockCanNotBeUsedError_1 = require("../error/OptimisticLockCanNotBeUsedError");
+const JoinAttribute_1 = require("./JoinAttribute");
+const RelationIdAttribute_1 = require("./relation-id/RelationIdAttribute");
+const RelationCountAttribute_1 = require("./relation-count/RelationCountAttribute");
+const RelationIdLoader_1 = require("./relation-id/RelationIdLoader");
+const RelationIdMetadataToAttributeTransformer_1 = require("./relation-id/RelationIdMetadataToAttributeTransformer");
+const RelationCountLoader_1 = require("./relation-count/RelationCountLoader");
+const RelationCountMetadataToAttributeTransformer_1 = require("./relation-count/RelationCountMetadataToAttributeTransformer");
+const QueryBuilder_1 = require("./QueryBuilder");
 //#endregion
-var LockNotSupportedOnGivenDriverError_1 = require("../error/LockNotSupportedOnGivenDriverError");
-var OffsetWithoutLimitNotSupportedError_1 = require("../error/OffsetWithoutLimitNotSupportedError");
-var ObjectUtils_1 = require("../util/ObjectUtils");
-var DriverUtils_1 = require("../driver/DriverUtils");
-var EntityNotFoundError_1 = require("../error/EntityNotFoundError");
-var error_1 = require("../error");
-var FindOptionsUtils_1 = require("../find-options/FindOptionsUtils");
-var ApplyValueTransformers_1 = require("../util/ApplyValueTransformers");
-var OrmUtils_1 = require("../util/OrmUtils");
-var EntityPropertyNotFoundError_1 = require("../error/EntityPropertyNotFoundError");
+const LockNotSupportedOnGivenDriverError_1 = require("../error/LockNotSupportedOnGivenDriverError");
+const OffsetWithoutLimitNotSupportedError_1 = require("../error/OffsetWithoutLimitNotSupportedError");
+const ObjectUtils_1 = require("../util/ObjectUtils");
+const DriverUtils_1 = require("../driver/DriverUtils");
+const EntityNotFoundError_1 = require("../error/EntityNotFoundError");
+const error_1 = require("../error");
+const FindOptionsUtils_1 = require("../find-options/FindOptionsUtils");
+const ApplyValueTransformers_1 = require("../util/ApplyValueTransformers");
+const OrmUtils_1 = require("../util/OrmUtils");
+const EntityPropertyNotFoundError_1 = require("../error/EntityPropertyNotFoundError");
 //#endregion
-var InstanceChecker_1 = require("../util/InstanceChecker");
-var typescript_class_helpers_1 = require("typescript-class-helpers");
+const InstanceChecker_1 = require("../util/InstanceChecker");
+const typescript_class_helpers_1 = require("typescript-class-helpers");
 /**
  * Allows to build complex sql queries in a fashion way and execute those queries.
  */
-var SelectQueryBuilder = /** @class */ (function (_super) {
-    tslib_1.__extends(SelectQueryBuilder, _super);
-    function SelectQueryBuilder() {
-        var _this = _super.apply(this, tslib_1.__spreadArray([], tslib_1.__read(arguments), false)) || this;
-        _this["@instanceof"] = Symbol.for("SelectQueryBuilder");
-        _this.findOptions = {};
-        _this.selects = [];
-        _this.joins = [];
-        _this.conditions = "";
-        _this.orderBys = [];
-        _this.relationMetadatas = [];
-        return _this;
-    }
-    SelectQueryBuilder_1 = SelectQueryBuilder;
+let SelectQueryBuilder = SelectQueryBuilder_1 = class SelectQueryBuilder extends QueryBuilder_1.QueryBuilder {
+    "@instanceof" = Symbol.for("SelectQueryBuilder");
+    findOptions = {};
+    selects = [];
+    joins = [];
+    conditions = "";
+    orderBys = [];
+    relationMetadatas = [];
     // -------------------------------------------------------------------------
     // Public Implemented Methods
     // -------------------------------------------------------------------------
     /**
      * Gets generated SQL query without parameters being replaced.
      */
-    SelectQueryBuilder.prototype.getQuery = function () {
-        var sql = this.createComment();
+    getQuery() {
+        let sql = this.createComment();
         sql += this.createCteExpression();
         sql += this.createSelectExpression();
         sql += this.createJoinExpression();
@@ -67,37 +67,37 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
         if (this.expressionMap.subQuery)
             sql = "(" + sql + ")";
         return sql;
-    };
+    }
     // -------------------------------------------------------------------------
     // Public Methods
     // -------------------------------------------------------------------------
-    SelectQueryBuilder.prototype.setFindOptions = function (findOptions) {
+    setFindOptions(findOptions) {
         this.findOptions = findOptions;
         this.applyFindOptions();
         return this;
-    };
+    }
     /**
      * Creates a subquery - query that can be used inside other queries.
      */
-    SelectQueryBuilder.prototype.subQuery = function () {
-        var qb = this.createQueryBuilder();
+    subQuery() {
+        const qb = this.createQueryBuilder();
         qb.expressionMap.subQuery = true;
         qb.parentQueryBuilder = this;
         return qb;
-    };
+    }
     /**
      * Creates SELECT query and selects given data.
      * Replaces all previous selections if they exist.
      */
-    SelectQueryBuilder.prototype.select = function (selection, selectionAliasName) {
+    select(selection, selectionAliasName) {
         this.expressionMap.queryType = "select";
         if (Array.isArray(selection)) {
-            this.expressionMap.selects = selection.map(function (selection) { return ({
+            this.expressionMap.selects = selection.map((selection) => ({
                 selection: selection,
-            }); });
+            }));
         }
         else if (typeof selection === "function") {
-            var subQueryBuilder = selection(this.subQuery());
+            const subQueryBuilder = selection(this.subQuery());
             this.setParameters(subQueryBuilder.getParameters());
             this.expressionMap.selects.push({
                 selection: subQueryBuilder.getQuery(),
@@ -110,18 +110,18 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
             ];
         }
         return this;
-    };
+    }
     /**
      * Adds new selection to the SELECT query.
      */
-    SelectQueryBuilder.prototype.addSelect = function (selection, selectionAliasName) {
+    addSelect(selection, selectionAliasName) {
         if (!selection)
             return this;
         if (Array.isArray(selection)) {
-            this.expressionMap.selects = this.expressionMap.selects.concat(selection.map(function (selection) { return ({ selection: selection }); }));
+            this.expressionMap.selects = this.expressionMap.selects.concat(selection.map((selection) => ({ selection: selection })));
         }
         else if (typeof selection === "function") {
-            var subQueryBuilder = selection(this.subQuery());
+            const subQueryBuilder = selection(this.subQuery());
             this.setParameters(subQueryBuilder.getParameters());
             this.expressionMap.selects.push({
                 selection: subQueryBuilder.getQuery(),
@@ -135,88 +135,87 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
             });
         }
         return this;
-    };
+    }
     /**
      * Set max execution time.
      * @param milliseconds
      */
-    SelectQueryBuilder.prototype.maxExecutionTime = function (milliseconds) {
+    maxExecutionTime(milliseconds) {
         this.expressionMap.maxExecutionTime = milliseconds;
         return this;
-    };
+    }
     /**
      * Sets whether the selection is DISTINCT.
      */
-    SelectQueryBuilder.prototype.distinct = function (distinct) {
-        if (distinct === void 0) { distinct = true; }
+    distinct(distinct = true) {
         this.expressionMap.selectDistinct = distinct;
         return this;
-    };
+    }
     /**
      * Sets the distinct on clause for Postgres.
      */
-    SelectQueryBuilder.prototype.distinctOn = function (distinctOn) {
+    distinctOn(distinctOn) {
         this.expressionMap.selectDistinctOn = distinctOn;
         return this;
-    };
+    }
     /**
      * Specifies FROM which entity's table select/update/delete will be executed.
      * Also sets a main string alias of the selection data.
      * Removes all previously set from-s.
      */
-    SelectQueryBuilder.prototype.from = function (entityTarget, aliasName) {
-        var mainAlias = this.createFromAlias(entityTarget, aliasName);
+    from(entityTarget, aliasName) {
+        const mainAlias = this.createFromAlias(entityTarget, aliasName);
         this.expressionMap.setMainAlias(mainAlias);
         return this;
-    };
+    }
     /**
      * Specifies FROM which entity's table select/update/delete will be executed.
      * Also sets a main string alias of the selection data.
      */
-    SelectQueryBuilder.prototype.addFrom = function (entityTarget, aliasName) {
-        var alias = this.createFromAlias(entityTarget, aliasName);
+    addFrom(entityTarget, aliasName) {
+        const alias = this.createFromAlias(entityTarget, aliasName);
         if (!this.expressionMap.mainAlias)
             this.expressionMap.setMainAlias(alias);
         return this;
-    };
+    }
     /**
      * INNER JOINs (without selection).
      * You also need to specify an alias of the joined data.
      * Optionally, you can add condition and parameters used in condition.
      */
-    SelectQueryBuilder.prototype.innerJoin = function (entityOrProperty, alias, condition, parameters) {
+    innerJoin(entityOrProperty, alias, condition, parameters) {
         this.join("INNER", entityOrProperty, alias, condition, parameters);
         return this;
-    };
+    }
     /**
      * LEFT JOINs (without selection).
      * You also need to specify an alias of the joined data.
      * Optionally, you can add condition and parameters used in condition.
      */
-    SelectQueryBuilder.prototype.leftJoin = function (entityOrProperty, alias, condition, parameters) {
+    leftJoin(entityOrProperty, alias, condition, parameters) {
         this.join("LEFT", entityOrProperty, alias, condition, parameters);
         return this;
-    };
+    }
     /**
      * INNER JOINs and adds all selection properties to SELECT.
      * You also need to specify an alias of the joined data.
      * Optionally, you can add condition and parameters used in condition.
      */
-    SelectQueryBuilder.prototype.innerJoinAndSelect = function (entityOrProperty, alias, condition, parameters) {
+    innerJoinAndSelect(entityOrProperty, alias, condition, parameters) {
         this.addSelect(alias);
         this.innerJoin(entityOrProperty, alias, condition, parameters);
         return this;
-    };
+    }
     /**
      * LEFT JOINs and adds all selection properties to SELECT.
      * You also need to specify an alias of the joined data.
      * Optionally, you can add condition and parameters used in condition.
      */
-    SelectQueryBuilder.prototype.leftJoinAndSelect = function (entityOrProperty, alias, condition, parameters) {
+    leftJoinAndSelect(entityOrProperty, alias, condition, parameters) {
         this.addSelect(alias);
         this.leftJoin(entityOrProperty, alias, condition, parameters);
         return this;
-    };
+    }
     /**
      * INNER JOINs, SELECTs the data returned by a join and MAPs all that data to some entity's property.
      * This is extremely useful when you want to select some data and map it to some virtual property.
@@ -224,11 +223,11 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
      * You also need to specify an alias of the joined data.
      * Optionally, you can add condition and parameters used in condition.
      */
-    SelectQueryBuilder.prototype.innerJoinAndMapMany = function (mapToProperty, entityOrProperty, alias, condition, parameters) {
+    innerJoinAndMapMany(mapToProperty, entityOrProperty, alias, condition, parameters) {
         this.addSelect(alias);
         this.join("INNER", entityOrProperty, alias, condition, parameters, mapToProperty, true);
         return this;
-    };
+    }
     /**
      * INNER JOINs, SELECTs the data returned by a join and MAPs all that data to some entity's property.
      * This is extremely useful when you want to select some data and map it to some virtual property.
@@ -236,11 +235,11 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
      * You also need to specify an alias of the joined data.
      * Optionally, you can add condition and parameters used in condition.
      */
-    SelectQueryBuilder.prototype.innerJoinAndMapOne = function (mapToProperty, entityOrProperty, alias, condition, parameters) {
+    innerJoinAndMapOne(mapToProperty, entityOrProperty, alias, condition, parameters) {
         this.addSelect(alias);
         this.join("INNER", entityOrProperty, alias, condition, parameters, mapToProperty, false);
         return this;
-    };
+    }
     /**
      * LEFT JOINs, SELECTs the data returned by a join and MAPs all that data to some entity's property.
      * This is extremely useful when you want to select some data and map it to some virtual property.
@@ -248,11 +247,11 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
      * You also need to specify an alias of the joined data.
      * Optionally, you can add condition and parameters used in condition.
      */
-    SelectQueryBuilder.prototype.leftJoinAndMapMany = function (mapToProperty, entityOrProperty, alias, condition, parameters) {
+    leftJoinAndMapMany(mapToProperty, entityOrProperty, alias, condition, parameters) {
         this.addSelect(alias);
         this.join("LEFT", entityOrProperty, alias, condition, parameters, mapToProperty, true);
         return this;
-    };
+    }
     /**
      * LEFT JOINs, SELECTs the data returned by a join and MAPs all that data to some entity's property.
      * This is extremely useful when you want to select some data and map it to some virtual property.
@@ -260,17 +259,17 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
      * You also need to specify an alias of the joined data.
      * Optionally, you can add condition and parameters used in condition.
      */
-    SelectQueryBuilder.prototype.leftJoinAndMapOne = function (mapToProperty, entityOrProperty, alias, condition, parameters) {
+    leftJoinAndMapOne(mapToProperty, entityOrProperty, alias, condition, parameters) {
         this.addSelect(alias);
         this.join("LEFT", entityOrProperty, alias, condition, parameters, mapToProperty, false);
         return this;
-    };
+    }
     /**
      * LEFT JOINs relation id and maps it into some entity's property.
      * Optionally, you can add condition and parameters used in condition.
      */
-    SelectQueryBuilder.prototype.loadRelationIdAndMap = function (mapToProperty, relationName, aliasNameOrOptions, queryBuilderFactory) {
-        var relationIdAttribute = new RelationIdAttribute_1.RelationIdAttribute(this.expressionMap);
+    loadRelationIdAndMap(mapToProperty, relationName, aliasNameOrOptions, queryBuilderFactory) {
+        const relationIdAttribute = new RelationIdAttribute_1.RelationIdAttribute(this.expressionMap);
         relationIdAttribute.mapToProperty = mapToProperty;
         relationIdAttribute.relationName = relationName;
         if (typeof aliasNameOrOptions === "string")
@@ -288,13 +287,13 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
             });
         }
         return this;
-    };
+    }
     /**
      * Counts number of entities of entity's relation and maps the value into some entity's property.
      * Optionally, you can add condition and parameters used in condition.
      */
-    SelectQueryBuilder.prototype.loadRelationCountAndMap = function (mapToProperty, relationName, aliasName, queryBuilderFactory) {
-        var relationCountAttribute = new RelationCountAttribute_1.RelationCountAttribute(this.expressionMap);
+    loadRelationCountAndMap(mapToProperty, relationName, aliasName, queryBuilderFactory) {
+        const relationCountAttribute = new RelationCountAttribute_1.RelationCountAttribute(this.expressionMap);
         relationCountAttribute.mapToProperty = mapToProperty;
         relationCountAttribute.relationName = relationName;
         relationCountAttribute.alias = aliasName;
@@ -312,37 +311,36 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
             });
         }
         return this;
-    };
+    }
     /**
      * Loads all relation ids for all relations of the selected entity.
      * All relation ids will be mapped to relation property themself.
      * If array of strings is given then loads only relation ids of the given properties.
      */
-    SelectQueryBuilder.prototype.loadAllRelationIds = function (options) {
-        var _this = this;
+    loadAllRelationIds(options) {
         // todo: add skip relations
-        this.expressionMap.mainAlias.metadata.relations.forEach(function (relation) {
+        this.expressionMap.mainAlias.metadata.relations.forEach((relation) => {
             if (options !== undefined &&
                 options.relations !== undefined &&
                 options.relations.indexOf(relation.propertyPath) === -1)
                 return;
-            _this.loadRelationIdAndMap(_this.expressionMap.mainAlias.name +
+            this.loadRelationIdAndMap(this.expressionMap.mainAlias.name +
                 "." +
-                relation.propertyPath, _this.expressionMap.mainAlias.name +
+                relation.propertyPath, this.expressionMap.mainAlias.name +
                 "." +
                 relation.propertyPath, options);
         });
         return this;
-    };
+    }
     /**
      * Sets WHERE condition in the query builder.
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      * Additionally you can add parameters used in where expression.
      */
-    SelectQueryBuilder.prototype.where = function (where, parameters) {
+    where(where, parameters) {
         this.expressionMap.wheres = []; // don't move this block below since computeWhereParameter can add where expressions
-        var condition = this.getWhereCondition(where);
+        const condition = this.getWhereCondition(where);
         if (condition)
             this.expressionMap.wheres = [
                 { type: "simple", condition: condition },
@@ -350,12 +348,12 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
         if (parameters)
             this.setParameters(parameters);
         return this;
-    };
+    }
     /**
      * Adds new AND WHERE condition in the query builder.
      * Additionally you can add parameters used in where expression.
      */
-    SelectQueryBuilder.prototype.andWhere = function (where, parameters) {
+    andWhere(where, parameters) {
         this.expressionMap.wheres.push({
             type: "and",
             condition: this.getWhereCondition(where),
@@ -363,12 +361,12 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
         if (parameters)
             this.setParameters(parameters);
         return this;
-    };
+    }
     /**
      * Adds new OR WHERE condition in the query builder.
      * Additionally you can add parameters used in where expression.
      */
-    SelectQueryBuilder.prototype.orWhere = function (where, parameters) {
+    orWhere(where, parameters) {
         this.expressionMap.wheres.push({
             type: "or",
             condition: this.getWhereCondition(where),
@@ -376,7 +374,7 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
         if (parameters)
             this.setParameters(parameters);
         return this;
-    };
+    }
     /**
      * Adds new AND WHERE with conditions for the given ids.
      *
@@ -385,9 +383,9 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
      * If you have multiple primary keys you need to pass object with property names and values specified,
      * for example [{ firstId: 1, secondId: 2 }, { firstId: 2, secondId: 3 }, ...]
      */
-    SelectQueryBuilder.prototype.whereInIds = function (ids) {
+    whereInIds(ids) {
         return this.where(this.getWhereInIdsCondition(ids));
-    };
+    }
     /**
      * Adds new AND WHERE with conditions for the given ids.
      *
@@ -396,9 +394,9 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
      * If you have multiple primary keys you need to pass object with property names and values specified,
      * for example [{ firstId: 1, secondId: 2 }, { firstId: 2, secondId: 3 }, ...]
      */
-    SelectQueryBuilder.prototype.andWhereInIds = function (ids) {
+    andWhereInIds(ids) {
         return this.andWhere(this.getWhereInIdsCondition(ids));
-    };
+    }
     /**
      * Adds new OR WHERE with conditions for the given ids.
      *
@@ -407,47 +405,47 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
      * If you have multiple primary keys you need to pass object with property names and values specified,
      * for example [{ firstId: 1, secondId: 2 }, { firstId: 2, secondId: 3 }, ...]
      */
-    SelectQueryBuilder.prototype.orWhereInIds = function (ids) {
+    orWhereInIds(ids) {
         return this.orWhere(this.getWhereInIdsCondition(ids));
-    };
+    }
     /**
      * Sets HAVING condition in the query builder.
      * If you had previously HAVING expression defined,
      * calling this function will override previously set HAVING conditions.
      * Additionally you can add parameters used in where expression.
      */
-    SelectQueryBuilder.prototype.having = function (having, parameters) {
+    having(having, parameters) {
         this.expressionMap.havings.push({ type: "simple", condition: having });
         if (parameters)
             this.setParameters(parameters);
         return this;
-    };
+    }
     /**
      * Adds new AND HAVING condition in the query builder.
      * Additionally you can add parameters used in where expression.
      */
-    SelectQueryBuilder.prototype.andHaving = function (having, parameters) {
+    andHaving(having, parameters) {
         this.expressionMap.havings.push({ type: "and", condition: having });
         if (parameters)
             this.setParameters(parameters);
         return this;
-    };
+    }
     /**
      * Adds new OR HAVING condition in the query builder.
      * Additionally you can add parameters used in where expression.
      */
-    SelectQueryBuilder.prototype.orHaving = function (having, parameters) {
+    orHaving(having, parameters) {
         this.expressionMap.havings.push({ type: "or", condition: having });
         if (parameters)
             this.setParameters(parameters);
         return this;
-    };
+    }
     /**
      * Sets GROUP BY condition in the query builder.
      * If you had previously GROUP BY expression defined,
      * calling this function will override previously set GROUP BY conditions.
      */
-    SelectQueryBuilder.prototype.groupBy = function (groupBy) {
+    groupBy(groupBy) {
         if (groupBy) {
             this.expressionMap.groupBys = [groupBy];
         }
@@ -455,40 +453,38 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
             this.expressionMap.groupBys = [];
         }
         return this;
-    };
+    }
     /**
      * Adds GROUP BY condition in the query builder.
      */
-    SelectQueryBuilder.prototype.addGroupBy = function (groupBy) {
+    addGroupBy(groupBy) {
         this.expressionMap.groupBys.push(groupBy);
         return this;
-    };
+    }
     /**
      * Sets ORDER BY condition in the query builder.
      * If you had previously ORDER BY expression defined,
      * calling this function will override previously set ORDER BY conditions.
      */
-    SelectQueryBuilder.prototype.orderBy = function (sort, order, nulls) {
-        var _a, _b;
-        if (order === void 0) { order = "ASC"; }
+    orderBy(sort, order = "ASC", nulls) {
         if (order !== undefined && order !== "ASC" && order !== "DESC")
-            throw new error_1.TypeORMError("SelectQueryBuilder.addOrderBy \"order\" can accept only \"ASC\" and \"DESC\" values.");
+            throw new error_1.TypeORMError(`SelectQueryBuilder.addOrderBy "order" can accept only "ASC" and "DESC" values.`);
         if (nulls !== undefined &&
             nulls !== "NULLS FIRST" &&
             nulls !== "NULLS LAST")
-            throw new error_1.TypeORMError("SelectQueryBuilder.addOrderBy \"nulls\" can accept only \"NULLS FIRST\" and \"NULLS LAST\" values.");
+            throw new error_1.TypeORMError(`SelectQueryBuilder.addOrderBy "nulls" can accept only "NULLS FIRST" and "NULLS LAST" values.`);
         if (sort) {
             if (typeof sort === "object") {
                 this.expressionMap.orderBys = sort;
             }
             else {
                 if (nulls) {
-                    this.expressionMap.orderBys = (_a = {},
-                        _a[sort] = { order: order, nulls: nulls },
-                        _a);
+                    this.expressionMap.orderBys = {
+                        [sort]: { order, nulls },
+                    };
                 }
                 else {
-                    this.expressionMap.orderBys = (_b = {}, _b[sort] = order, _b);
+                    this.expressionMap.orderBys = { [sort]: order };
                 }
             }
         }
@@ -496,517 +492,363 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
             this.expressionMap.orderBys = {};
         }
         return this;
-    };
+    }
     /**
      * Adds ORDER BY condition in the query builder.
      */
-    SelectQueryBuilder.prototype.addOrderBy = function (sort, order, nulls) {
-        if (order === void 0) { order = "ASC"; }
+    addOrderBy(sort, order = "ASC", nulls) {
         if (order !== undefined && order !== "ASC" && order !== "DESC")
-            throw new error_1.TypeORMError("SelectQueryBuilder.addOrderBy \"order\" can accept only \"ASC\" and \"DESC\" values.");
+            throw new error_1.TypeORMError(`SelectQueryBuilder.addOrderBy "order" can accept only "ASC" and "DESC" values.`);
         if (nulls !== undefined &&
             nulls !== "NULLS FIRST" &&
             nulls !== "NULLS LAST")
-            throw new error_1.TypeORMError("SelectQueryBuilder.addOrderBy \"nulls\" can accept only \"NULLS FIRST\" and \"NULLS LAST\" values.");
+            throw new error_1.TypeORMError(`SelectQueryBuilder.addOrderBy "nulls" can accept only "NULLS FIRST" and "NULLS LAST" values.`);
         if (nulls) {
-            this.expressionMap.orderBys[sort] = { order: order, nulls: nulls };
+            this.expressionMap.orderBys[sort] = { order, nulls };
         }
         else {
             this.expressionMap.orderBys[sort] = order;
         }
         return this;
-    };
+    }
     /**
      * Set's LIMIT - maximum number of rows to be selected.
      * NOTE that it may not work as you expect if you are using joins.
      * If you want to implement pagination, and you are having join in your query,
      * then use instead take method instead.
      */
-    SelectQueryBuilder.prototype.limit = function (limit) {
+    limit(limit) {
         this.expressionMap.limit = this.normalizeNumber(limit);
         if (this.expressionMap.limit !== undefined &&
             isNaN(this.expressionMap.limit))
-            throw new error_1.TypeORMError("Provided \"limit\" value is not a number. Please provide a numeric value.");
+            throw new error_1.TypeORMError(`Provided "limit" value is not a number. Please provide a numeric value.`);
         return this;
-    };
+    }
     /**
      * Set's OFFSET - selection offset.
      * NOTE that it may not work as you expect if you are using joins.
      * If you want to implement pagination, and you are having join in your query,
      * then use instead skip method instead.
      */
-    SelectQueryBuilder.prototype.offset = function (offset) {
+    offset(offset) {
         this.expressionMap.offset = this.normalizeNumber(offset);
         if (this.expressionMap.offset !== undefined &&
             isNaN(this.expressionMap.offset))
-            throw new error_1.TypeORMError("Provided \"offset\" value is not a number. Please provide a numeric value.");
+            throw new error_1.TypeORMError(`Provided "offset" value is not a number. Please provide a numeric value.`);
         return this;
-    };
+    }
     /**
      * Sets maximal number of entities to take.
      */
-    SelectQueryBuilder.prototype.take = function (take) {
+    take(take) {
         this.expressionMap.take = this.normalizeNumber(take);
         if (this.expressionMap.take !== undefined &&
             isNaN(this.expressionMap.take))
-            throw new error_1.TypeORMError("Provided \"take\" value is not a number. Please provide a numeric value.");
+            throw new error_1.TypeORMError(`Provided "take" value is not a number. Please provide a numeric value.`);
         return this;
-    };
+    }
     /**
      * Sets number of entities to skip.
      */
-    SelectQueryBuilder.prototype.skip = function (skip) {
+    skip(skip) {
         this.expressionMap.skip = this.normalizeNumber(skip);
         if (this.expressionMap.skip !== undefined &&
             isNaN(this.expressionMap.skip))
-            throw new error_1.TypeORMError("Provided \"skip\" value is not a number. Please provide a numeric value.");
+            throw new error_1.TypeORMError(`Provided "skip" value is not a number. Please provide a numeric value.`);
         return this;
-    };
+    }
     /**
      * Set certain index to be used by the query.
      *
      * @param index Name of index to be used.
      */
-    SelectQueryBuilder.prototype.useIndex = function (index) {
+    useIndex(index) {
         this.expressionMap.useIndex = index;
         return this;
-    };
+    }
     /**
      * Sets locking mode.
      */
-    SelectQueryBuilder.prototype.setLock = function (lockMode, lockVersion, lockTables) {
+    setLock(lockMode, lockVersion, lockTables) {
         this.expressionMap.lockMode = lockMode;
         this.expressionMap.lockVersion = lockVersion;
         this.expressionMap.lockTables = lockTables;
         return this;
-    };
+    }
     /**
      * Sets lock handling by adding NO WAIT or SKIP LOCKED.
      */
-    SelectQueryBuilder.prototype.setOnLocked = function (onLocked) {
+    setOnLocked(onLocked) {
         this.expressionMap.onLocked = onLocked;
         return this;
-    };
+    }
     /**
      * Disables the global condition of "non-deleted" for the entity with delete date columns.
      */
-    SelectQueryBuilder.prototype.withDeleted = function () {
+    withDeleted() {
         this.expressionMap.withDeleted = true;
         return this;
-    };
+    }
     /**
      * Gets first raw result returned by execution of generated query builder sql.
      */
-    SelectQueryBuilder.prototype.getRawOne = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getRawMany()];
-                    case 1: return [2 /*return*/, (_a.sent())[0]];
-                }
-            });
-        });
-    };
+    async getRawOne() {
+        return (await this.getRawMany())[0];
+    }
     /**
      * Gets all raw results returned by execution of generated query builder sql.
      */
-    SelectQueryBuilder.prototype.getRawMany = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var queryRunner, transactionStartedByUs, results, error_2, rollbackError_1;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (this.expressionMap.lockMode === "optimistic")
-                            throw new OptimisticLockCanNotBeUsedError_1.OptimisticLockCanNotBeUsedError();
-                        this.expressionMap.queryEntity = false;
-                        queryRunner = this.obtainQueryRunner();
-                        transactionStartedByUs = false;
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 7, 12, 15]);
-                        if (!(this.expressionMap.useTransaction === true &&
-                            queryRunner.isTransactionActive === false)) return [3 /*break*/, 3];
-                        return [4 /*yield*/, queryRunner.startTransaction()];
-                    case 2:
-                        _a.sent();
-                        transactionStartedByUs = true;
-                        _a.label = 3;
-                    case 3: return [4 /*yield*/, this.loadRawResults(queryRunner)
-                        // close transaction if we started it
-                    ];
-                    case 4:
-                        results = _a.sent();
-                        if (!transactionStartedByUs) return [3 /*break*/, 6];
-                        return [4 /*yield*/, queryRunner.commitTransaction()];
-                    case 5:
-                        _a.sent();
-                        _a.label = 6;
-                    case 6: return [2 /*return*/, results];
-                    case 7:
-                        error_2 = _a.sent();
-                        if (!transactionStartedByUs) return [3 /*break*/, 11];
-                        _a.label = 8;
-                    case 8:
-                        _a.trys.push([8, 10, , 11]);
-                        return [4 /*yield*/, queryRunner.rollbackTransaction()];
-                    case 9:
-                        _a.sent();
-                        return [3 /*break*/, 11];
-                    case 10:
-                        rollbackError_1 = _a.sent();
-                        return [3 /*break*/, 11];
-                    case 11: throw error_2;
-                    case 12:
-                        if (!(queryRunner !== this.queryRunner)) return [3 /*break*/, 14];
-                        // means we created our own query runner
-                        return [4 /*yield*/, queryRunner.release()];
-                    case 13:
-                        // means we created our own query runner
-                        _a.sent();
-                        _a.label = 14;
-                    case 14: return [7 /*endfinally*/];
-                    case 15: return [2 /*return*/];
+    async getRawMany() {
+        if (this.expressionMap.lockMode === "optimistic")
+            throw new OptimisticLockCanNotBeUsedError_1.OptimisticLockCanNotBeUsedError();
+        this.expressionMap.queryEntity = false;
+        const queryRunner = this.obtainQueryRunner();
+        let transactionStartedByUs = false;
+        try {
+            // start transaction if it was enabled
+            if (this.expressionMap.useTransaction === true &&
+                queryRunner.isTransactionActive === false) {
+                await queryRunner.startTransaction();
+                transactionStartedByUs = true;
+            }
+            const results = await this.loadRawResults(queryRunner);
+            // close transaction if we started it
+            if (transactionStartedByUs) {
+                await queryRunner.commitTransaction();
+            }
+            return results;
+        }
+        catch (error) {
+            // rollback transaction if we started it
+            if (transactionStartedByUs) {
+                try {
+                    await queryRunner.rollbackTransaction();
                 }
-            });
-        });
-    };
+                catch (rollbackError) { }
+            }
+            throw error;
+        }
+        finally {
+            if (queryRunner !== this.queryRunner) {
+                // means we created our own query runner
+                await queryRunner.release();
+            }
+        }
+    }
     /**
      * Executes sql generated by query builder and returns object with raw results and entities created from them.
      */
-    SelectQueryBuilder.prototype.getRawAndEntities = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var queryRunner, transactionStartedByUs, results, error_3, rollbackError_2;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        queryRunner = this.obtainQueryRunner();
-                        transactionStartedByUs = false;
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 7, 12, 15]);
-                        if (!(this.expressionMap.useTransaction === true &&
-                            queryRunner.isTransactionActive === false)) return [3 /*break*/, 3];
-                        return [4 /*yield*/, queryRunner.startTransaction()];
-                    case 2:
-                        _a.sent();
-                        transactionStartedByUs = true;
-                        _a.label = 3;
-                    case 3:
-                        this.expressionMap.queryEntity = true;
-                        return [4 /*yield*/, this.executeEntitiesAndRawResults(queryRunner)
-                            // close transaction if we started it
-                        ];
-                    case 4:
-                        results = _a.sent();
-                        if (!transactionStartedByUs) return [3 /*break*/, 6];
-                        return [4 /*yield*/, queryRunner.commitTransaction()];
-                    case 5:
-                        _a.sent();
-                        _a.label = 6;
-                    case 6: return [2 /*return*/, results];
-                    case 7:
-                        error_3 = _a.sent();
-                        if (!transactionStartedByUs) return [3 /*break*/, 11];
-                        _a.label = 8;
-                    case 8:
-                        _a.trys.push([8, 10, , 11]);
-                        return [4 /*yield*/, queryRunner.rollbackTransaction()];
-                    case 9:
-                        _a.sent();
-                        return [3 /*break*/, 11];
-                    case 10:
-                        rollbackError_2 = _a.sent();
-                        return [3 /*break*/, 11];
-                    case 11: throw error_3;
-                    case 12:
-                        if (!(queryRunner !== this.queryRunner)) return [3 /*break*/, 14];
-                        // means we created our own query runner
-                        return [4 /*yield*/, queryRunner.release()];
-                    case 13:
-                        // means we created our own query runner
-                        _a.sent();
-                        _a.label = 14;
-                    case 14: return [7 /*endfinally*/];
-                    case 15: return [2 /*return*/];
+    async getRawAndEntities() {
+        const queryRunner = this.obtainQueryRunner();
+        let transactionStartedByUs = false;
+        try {
+            // start transaction if it was enabled
+            if (this.expressionMap.useTransaction === true &&
+                queryRunner.isTransactionActive === false) {
+                await queryRunner.startTransaction();
+                transactionStartedByUs = true;
+            }
+            this.expressionMap.queryEntity = true;
+            const results = await this.executeEntitiesAndRawResults(queryRunner);
+            // close transaction if we started it
+            if (transactionStartedByUs) {
+                await queryRunner.commitTransaction();
+            }
+            return results;
+        }
+        catch (error) {
+            // rollback transaction if we started it
+            if (transactionStartedByUs) {
+                try {
+                    await queryRunner.rollbackTransaction();
                 }
-            });
-        });
-    };
+                catch (rollbackError) { }
+            }
+            throw error;
+        }
+        finally {
+            if (queryRunner !== this.queryRunner)
+                // means we created our own query runner
+                await queryRunner.release();
+        }
+    }
     /**
      * Gets single entity returned by execution of generated query builder sql.
      */
-    SelectQueryBuilder.prototype.getOne = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var results, result, metadata, actualVersion, actualVersion;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getRawAndEntities()];
-                    case 1:
-                        results = _a.sent();
-                        result = results.entities[0];
-                        if (result &&
-                            this.expressionMap.lockMode === "optimistic" &&
-                            this.expressionMap.lockVersion) {
-                            metadata = this.expressionMap.mainAlias.metadata;
-                            if (this.expressionMap.lockVersion instanceof Date) {
-                                actualVersion = metadata.updateDateColumn.getEntityValue(result) // what if columns arent set?
-                                ;
-                                if (actualVersion.getTime() !==
-                                    this.expressionMap.lockVersion.getTime())
-                                    throw new OptimisticLockVersionMismatchError_1.OptimisticLockVersionMismatchError(metadata.name, this.expressionMap.lockVersion, actualVersion);
-                            }
-                            else {
-                                actualVersion = metadata.versionColumn.getEntityValue(result) // what if columns arent set?
-                                ;
-                                if (actualVersion !== this.expressionMap.lockVersion)
-                                    throw new OptimisticLockVersionMismatchError_1.OptimisticLockVersionMismatchError(metadata.name, this.expressionMap.lockVersion, actualVersion);
-                            }
-                        }
-                        if (result === undefined) {
-                            return [2 /*return*/, null];
-                        }
-                        return [2 /*return*/, result];
-                }
-            });
-        });
-    };
+    async getOne() {
+        const results = await this.getRawAndEntities();
+        const result = results.entities[0];
+        if (result &&
+            this.expressionMap.lockMode === "optimistic" &&
+            this.expressionMap.lockVersion) {
+            const metadata = this.expressionMap.mainAlias.metadata;
+            if (this.expressionMap.lockVersion instanceof Date) {
+                const actualVersion = metadata.updateDateColumn.getEntityValue(result); // what if columns arent set?
+                if (actualVersion.getTime() !==
+                    this.expressionMap.lockVersion.getTime())
+                    throw new OptimisticLockVersionMismatchError_1.OptimisticLockVersionMismatchError(metadata.name, this.expressionMap.lockVersion, actualVersion);
+            }
+            else {
+                const actualVersion = metadata.versionColumn.getEntityValue(result); // what if columns arent set?
+                if (actualVersion !== this.expressionMap.lockVersion)
+                    throw new OptimisticLockVersionMismatchError_1.OptimisticLockVersionMismatchError(metadata.name, this.expressionMap.lockVersion, actualVersion);
+            }
+        }
+        if (result === undefined) {
+            return null;
+        }
+        return result;
+    }
     /**
      * Gets the first entity returned by execution of generated query builder sql or rejects the returned promise on error.
      */
-    SelectQueryBuilder.prototype.getOneOrFail = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var entity;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getOne()];
-                    case 1:
-                        entity = _a.sent();
-                        if (!entity) {
-                            throw new EntityNotFoundError_1.EntityNotFoundError(this.expressionMap.mainAlias.target, this);
-                        }
-                        return [2 /*return*/, entity];
-                }
-            });
-        });
-    };
+    async getOneOrFail() {
+        const entity = await this.getOne();
+        if (!entity) {
+            throw new EntityNotFoundError_1.EntityNotFoundError(this.expressionMap.mainAlias.target, this);
+        }
+        return entity;
+    }
     /**
      * Gets entities returned by execution of generated query builder sql.
      */
-    SelectQueryBuilder.prototype.getMany = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var results;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (this.expressionMap.lockMode === "optimistic")
-                            throw new OptimisticLockCanNotBeUsedError_1.OptimisticLockCanNotBeUsedError();
-                        return [4 /*yield*/, this.getRawAndEntities()];
-                    case 1:
-                        results = _a.sent();
-                        return [2 /*return*/, results.entities];
-                }
-            });
-        });
-    };
+    async getMany() {
+        if (this.expressionMap.lockMode === "optimistic")
+            throw new OptimisticLockCanNotBeUsedError_1.OptimisticLockCanNotBeUsedError();
+        const results = await this.getRawAndEntities();
+        return results.entities;
+    }
     /**
      * Gets count - number of entities selected by sql generated by this query builder.
      * Count excludes all limitations set by setFirstResult and setMaxResults methods call.
      */
-    SelectQueryBuilder.prototype.getCount = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var queryRunner, transactionStartedByUs, results, error_4, rollbackError_3;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (this.expressionMap.lockMode === "optimistic")
-                            throw new OptimisticLockCanNotBeUsedError_1.OptimisticLockCanNotBeUsedError();
-                        queryRunner = this.obtainQueryRunner();
-                        transactionStartedByUs = false;
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 7, 12, 15]);
-                        if (!(this.expressionMap.useTransaction === true &&
-                            queryRunner.isTransactionActive === false)) return [3 /*break*/, 3];
-                        return [4 /*yield*/, queryRunner.startTransaction()];
-                    case 2:
-                        _a.sent();
-                        transactionStartedByUs = true;
-                        _a.label = 3;
-                    case 3:
-                        this.expressionMap.queryEntity = false;
-                        return [4 /*yield*/, this.executeCountQuery(queryRunner)
-                            // close transaction if we started it
-                        ];
-                    case 4:
-                        results = _a.sent();
-                        if (!transactionStartedByUs) return [3 /*break*/, 6];
-                        return [4 /*yield*/, queryRunner.commitTransaction()];
-                    case 5:
-                        _a.sent();
-                        _a.label = 6;
-                    case 6: return [2 /*return*/, results];
-                    case 7:
-                        error_4 = _a.sent();
-                        if (!transactionStartedByUs) return [3 /*break*/, 11];
-                        _a.label = 8;
-                    case 8:
-                        _a.trys.push([8, 10, , 11]);
-                        return [4 /*yield*/, queryRunner.rollbackTransaction()];
-                    case 9:
-                        _a.sent();
-                        return [3 /*break*/, 11];
-                    case 10:
-                        rollbackError_3 = _a.sent();
-                        return [3 /*break*/, 11];
-                    case 11: throw error_4;
-                    case 12:
-                        if (!(queryRunner !== this.queryRunner)) return [3 /*break*/, 14];
-                        // means we created our own query runner
-                        return [4 /*yield*/, queryRunner.release()];
-                    case 13:
-                        // means we created our own query runner
-                        _a.sent();
-                        _a.label = 14;
-                    case 14: return [7 /*endfinally*/];
-                    case 15: return [2 /*return*/];
+    async getCount() {
+        if (this.expressionMap.lockMode === "optimistic")
+            throw new OptimisticLockCanNotBeUsedError_1.OptimisticLockCanNotBeUsedError();
+        const queryRunner = this.obtainQueryRunner();
+        let transactionStartedByUs = false;
+        try {
+            // start transaction if it was enabled
+            if (this.expressionMap.useTransaction === true &&
+                queryRunner.isTransactionActive === false) {
+                await queryRunner.startTransaction();
+                transactionStartedByUs = true;
+            }
+            this.expressionMap.queryEntity = false;
+            const results = await this.executeCountQuery(queryRunner);
+            // close transaction if we started it
+            if (transactionStartedByUs) {
+                await queryRunner.commitTransaction();
+            }
+            return results;
+        }
+        catch (error) {
+            // rollback transaction if we started it
+            if (transactionStartedByUs) {
+                try {
+                    await queryRunner.rollbackTransaction();
                 }
-            });
-        });
-    };
+                catch (rollbackError) { }
+            }
+            throw error;
+        }
+        finally {
+            if (queryRunner !== this.queryRunner)
+                // means we created our own query runner
+                await queryRunner.release();
+        }
+    }
     /**
      * Executes built SQL query and returns entities and overall entities count (without limitation).
      * This method is useful to build pagination.
      */
-    SelectQueryBuilder.prototype.getManyAndCount = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var queryRunner, transactionStartedByUs, entitiesAndRaw, cacheId, count, results, error_5, rollbackError_4;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (this.expressionMap.lockMode === "optimistic")
-                            throw new OptimisticLockCanNotBeUsedError_1.OptimisticLockCanNotBeUsedError();
-                        queryRunner = this.obtainQueryRunner();
-                        transactionStartedByUs = false;
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 8, 13, 16]);
-                        if (!(this.expressionMap.useTransaction === true &&
-                            queryRunner.isTransactionActive === false)) return [3 /*break*/, 3];
-                        return [4 /*yield*/, queryRunner.startTransaction()];
-                    case 2:
-                        _a.sent();
-                        transactionStartedByUs = true;
-                        _a.label = 3;
-                    case 3:
-                        this.expressionMap.queryEntity = true;
-                        return [4 /*yield*/, this.executeEntitiesAndRawResults(queryRunner)];
-                    case 4:
-                        entitiesAndRaw = _a.sent();
-                        this.expressionMap.queryEntity = false;
-                        cacheId = this.expressionMap.cacheId;
-                        // Creates a new cacheId for the count query, or it will retreive the above query results
-                        // and count will return 0.
-                        this.expressionMap.cacheId = cacheId ? "".concat(cacheId, "-count") : cacheId;
-                        return [4 /*yield*/, this.executeCountQuery(queryRunner)];
-                    case 5:
-                        count = _a.sent();
-                        results = [entitiesAndRaw.entities, count];
-                        if (!transactionStartedByUs) return [3 /*break*/, 7];
-                        return [4 /*yield*/, queryRunner.commitTransaction()];
-                    case 6:
-                        _a.sent();
-                        _a.label = 7;
-                    case 7: return [2 /*return*/, results];
-                    case 8:
-                        error_5 = _a.sent();
-                        if (!transactionStartedByUs) return [3 /*break*/, 12];
-                        _a.label = 9;
-                    case 9:
-                        _a.trys.push([9, 11, , 12]);
-                        return [4 /*yield*/, queryRunner.rollbackTransaction()];
-                    case 10:
-                        _a.sent();
-                        return [3 /*break*/, 12];
-                    case 11:
-                        rollbackError_4 = _a.sent();
-                        return [3 /*break*/, 12];
-                    case 12: throw error_5;
-                    case 13:
-                        if (!(queryRunner !== this.queryRunner)) return [3 /*break*/, 15];
-                        // means we created our own query runner
-                        return [4 /*yield*/, queryRunner.release()];
-                    case 14:
-                        // means we created our own query runner
-                        _a.sent();
-                        _a.label = 15;
-                    case 15: return [7 /*endfinally*/];
-                    case 16: return [2 /*return*/];
+    async getManyAndCount() {
+        if (this.expressionMap.lockMode === "optimistic")
+            throw new OptimisticLockCanNotBeUsedError_1.OptimisticLockCanNotBeUsedError();
+        const queryRunner = this.obtainQueryRunner();
+        let transactionStartedByUs = false;
+        try {
+            // start transaction if it was enabled
+            if (this.expressionMap.useTransaction === true &&
+                queryRunner.isTransactionActive === false) {
+                await queryRunner.startTransaction();
+                transactionStartedByUs = true;
+            }
+            this.expressionMap.queryEntity = true;
+            const entitiesAndRaw = await this.executeEntitiesAndRawResults(queryRunner);
+            this.expressionMap.queryEntity = false;
+            const cacheId = this.expressionMap.cacheId;
+            // Creates a new cacheId for the count query, or it will retreive the above query results
+            // and count will return 0.
+            this.expressionMap.cacheId = cacheId ? `${cacheId}-count` : cacheId;
+            const count = await this.executeCountQuery(queryRunner);
+            const results = [entitiesAndRaw.entities, count];
+            // close transaction if we started it
+            if (transactionStartedByUs) {
+                await queryRunner.commitTransaction();
+            }
+            return results;
+        }
+        catch (error) {
+            // rollback transaction if we started it
+            if (transactionStartedByUs) {
+                try {
+                    await queryRunner.rollbackTransaction();
                 }
-            });
-        });
-    };
+                catch (rollbackError) { }
+            }
+            throw error;
+        }
+        finally {
+            if (queryRunner !== this.queryRunner)
+                // means we created our own query runner
+                await queryRunner.release();
+        }
+    }
     //#region @backend
     /**
      * Executes built SQL query and returns raw data stream.
      */
-    SelectQueryBuilder.prototype.stream = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var _a, sql, parameters, queryRunner, transactionStartedByUs, releaseFn, results, error_6, rollbackError_5;
-            var _this = this;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        this.expressionMap.queryEntity = false;
-                        _a = tslib_1.__read(this.getQueryAndParameters(), 2), sql = _a[0], parameters = _a[1];
-                        queryRunner = this.obtainQueryRunner();
-                        transactionStartedByUs = false;
-                        _b.label = 1;
-                    case 1:
-                        _b.trys.push([1, 6, , 11]);
-                        if (!(this.expressionMap.useTransaction === true &&
-                            queryRunner.isTransactionActive === false)) return [3 /*break*/, 3];
-                        return [4 /*yield*/, queryRunner.startTransaction()];
-                    case 2:
-                        _b.sent();
-                        transactionStartedByUs = true;
-                        _b.label = 3;
-                    case 3:
-                        releaseFn = function () {
-                            if (queryRunner !== _this.queryRunner)
-                                // means we created our own query runner
-                                return queryRunner.release();
-                            return;
-                        };
-                        results = queryRunner.stream(sql, parameters, releaseFn, releaseFn);
-                        if (!transactionStartedByUs) return [3 /*break*/, 5];
-                        return [4 /*yield*/, queryRunner.commitTransaction()];
-                    case 4:
-                        _b.sent();
-                        _b.label = 5;
-                    case 5: return [2 /*return*/, results];
-                    case 6:
-                        error_6 = _b.sent();
-                        if (!transactionStartedByUs) return [3 /*break*/, 10];
-                        _b.label = 7;
-                    case 7:
-                        _b.trys.push([7, 9, , 10]);
-                        return [4 /*yield*/, queryRunner.rollbackTransaction()];
-                    case 8:
-                        _b.sent();
-                        return [3 /*break*/, 10];
-                    case 9:
-                        rollbackError_5 = _b.sent();
-                        return [3 /*break*/, 10];
-                    case 10: throw error_6;
-                    case 11: return [2 /*return*/];
+    async stream() {
+        this.expressionMap.queryEntity = false;
+        const [sql, parameters] = this.getQueryAndParameters();
+        const queryRunner = this.obtainQueryRunner();
+        let transactionStartedByUs = false;
+        try {
+            // start transaction if it was enabled
+            if (this.expressionMap.useTransaction === true &&
+                queryRunner.isTransactionActive === false) {
+                await queryRunner.startTransaction();
+                transactionStartedByUs = true;
+            }
+            const releaseFn = () => {
+                if (queryRunner !== this.queryRunner)
+                    // means we created our own query runner
+                    return queryRunner.release();
+                return;
+            };
+            const results = queryRunner.stream(sql, parameters, releaseFn, releaseFn);
+            // close transaction if we started it
+            if (transactionStartedByUs) {
+                await queryRunner.commitTransaction();
+            }
+            return results;
+        }
+        catch (error) {
+            // rollback transaction if we started it
+            if (transactionStartedByUs) {
+                try {
+                    await queryRunner.rollbackTransaction();
                 }
-            });
-        });
-    };
+                catch (rollbackError) { }
+            }
+            throw error;
+        }
+    }
     /**
      * Enables or disables query result caching.
      */
-    SelectQueryBuilder.prototype.cache = function (enabledOrMillisecondsOrId, maybeMilliseconds) {
+    cache(enabledOrMillisecondsOrId, maybeMilliseconds) {
         if (typeof enabledOrMillisecondsOrId === "boolean") {
             this.expressionMap.cache = enabledOrMillisecondsOrId;
         }
@@ -1023,20 +865,20 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
             this.expressionMap.cacheDuration = maybeMilliseconds;
         }
         return this;
-    };
+    }
     /**
      * Sets extra options that can be used to configure how query builder works.
      */
-    SelectQueryBuilder.prototype.setOption = function (option) {
+    setOption(option) {
         this.expressionMap.options.push(option);
         return this;
-    };
+    }
     // -------------------------------------------------------------------------
     // Protected Methods
     // -------------------------------------------------------------------------
-    SelectQueryBuilder.prototype.join = function (direction, entityOrProperty, aliasName, condition, parameters, mapToProperty, isMappingMany) {
+    join(direction, entityOrProperty, aliasName, condition, parameters, mapToProperty, isMappingMany) {
         this.setParameters(parameters || {});
-        var joinAttribute = new JoinAttribute_1.JoinAttribute(this.connection, this.expressionMap);
+        const joinAttribute = new JoinAttribute_1.JoinAttribute(this.connection, this.expressionMap);
         joinAttribute.direction = direction;
         joinAttribute.mapToProperty = mapToProperty;
         joinAttribute.isMappingMany = isMappingMany;
@@ -1047,10 +889,10 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
         if (joinAttribute.metadata) {
             if (joinAttribute.metadata.deleteDateColumn &&
                 !this.expressionMap.withDeleted) {
-                var conditionDeleteColumn = "".concat(aliasName, ".").concat(joinAttribute.metadata.deleteDateColumn.propertyName, " IS NULL");
+                const conditionDeleteColumn = `${aliasName}.${joinAttribute.metadata.deleteDateColumn.propertyName} IS NULL`;
                 joinAttribute.condition = joinAttribute.condition
-                    ? " ".concat(joinAttribute.condition, " AND ").concat(conditionDeleteColumn)
-                    : "".concat(conditionDeleteColumn);
+                    ? ` ${joinAttribute.condition} AND ${conditionDeleteColumn}`
+                    : `${conditionDeleteColumn}`;
             }
             // todo: find and set metadata right there?
             joinAttribute.alias = this.expressionMap.createAlias({
@@ -1068,16 +910,16 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
             }
         }
         else {
-            var subQuery = "";
+            let subQuery = "";
             if (typeof entityOrProperty === "function") {
-                var subQueryBuilder = entityOrProperty(this.subQuery());
+                const subQueryBuilder = entityOrProperty(this.subQuery());
                 this.setParameters(subQueryBuilder.getParameters());
                 subQuery = subQueryBuilder.getQuery();
             }
             else {
                 subQuery = entityOrProperty;
             }
-            var isSubQuery = typeof entityOrProperty === "function" ||
+            const isSubQuery = typeof entityOrProperty === "function" ||
                 (entityOrProperty.substr(0, 1) === "(" &&
                     entityOrProperty.substr(-1) === ")");
             joinAttribute.alias = this.expressionMap.createAlias({
@@ -1089,79 +931,72 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
                 subQuery: isSubQuery === true ? subQuery : undefined,
             });
         }
-    };
+    }
     /**
      * Creates "SELECT FROM" part of SQL query.
      */
-    SelectQueryBuilder.prototype.createSelectExpression = function () {
-        var _this = this;
+    createSelectExpression() {
         if (!this.expressionMap.mainAlias)
             throw new error_1.TypeORMError("Cannot build query because main alias is not set (call qb#from method)");
         // todo throw exception if selects or from is missing
-        var allSelects = [];
-        var excludedSelects = [];
+        const allSelects = [];
+        const excludedSelects = [];
         if (this.expressionMap.mainAlias.hasMetadata) {
-            var metadata = this.expressionMap.mainAlias.metadata;
-            allSelects.push.apply(allSelects, tslib_1.__spreadArray([], tslib_1.__read(this.buildEscapedEntityColumnSelects(this.expressionMap.mainAlias.name, metadata)), false));
-            excludedSelects.push.apply(excludedSelects, tslib_1.__spreadArray([], tslib_1.__read(this.findEntityColumnSelects(this.expressionMap.mainAlias.name, metadata)), false));
+            const metadata = this.expressionMap.mainAlias.metadata;
+            allSelects.push(...this.buildEscapedEntityColumnSelects(this.expressionMap.mainAlias.name, metadata));
+            excludedSelects.push(...this.findEntityColumnSelects(this.expressionMap.mainAlias.name, metadata));
         }
         // add selects from joins
-        this.expressionMap.joinAttributes.forEach(function (join) {
+        this.expressionMap.joinAttributes.forEach((join) => {
             if (join.metadata) {
-                allSelects.push.apply(allSelects, tslib_1.__spreadArray([], tslib_1.__read(_this.buildEscapedEntityColumnSelects(join.alias.name, join.metadata)), false));
-                excludedSelects.push.apply(excludedSelects, tslib_1.__spreadArray([], tslib_1.__read(_this.findEntityColumnSelects(join.alias.name, join.metadata)), false));
+                allSelects.push(...this.buildEscapedEntityColumnSelects(join.alias.name, join.metadata));
+                excludedSelects.push(...this.findEntityColumnSelects(join.alias.name, join.metadata));
             }
             else {
-                var hasMainAlias = _this.expressionMap.selects.some(function (select) { return select.selection === join.alias.name; });
+                const hasMainAlias = this.expressionMap.selects.some((select) => select.selection === join.alias.name);
                 if (hasMainAlias) {
                     allSelects.push({
-                        selection: _this.escape(join.alias.name) + ".*",
+                        selection: this.escape(join.alias.name) + ".*",
                     });
-                    var excludedSelect = _this.expressionMap.selects.find(function (select) { return select.selection === join.alias.name; });
+                    const excludedSelect = this.expressionMap.selects.find((select) => select.selection === join.alias.name);
                     excludedSelects.push(excludedSelect);
                 }
             }
         });
         // add all other selects
         this.expressionMap.selects
-            .filter(function (select) { return excludedSelects.indexOf(select) === -1; })
-            .forEach(function (select) {
-            return allSelects.push({
-                selection: _this.replacePropertyNames(select.selection),
-                aliasName: select.aliasName,
-            });
-        });
+            .filter((select) => excludedSelects.indexOf(select) === -1)
+            .forEach((select) => allSelects.push({
+            selection: this.replacePropertyNames(select.selection),
+            aliasName: select.aliasName,
+        }));
         // if still selection is empty, then simply set it to all (*)
         if (allSelects.length === 0)
             allSelects.push({ selection: "*" });
         // Use certain index
-        var useIndex = "";
+        let useIndex = "";
         if (this.expressionMap.useIndex) {
             if (DriverUtils_1.DriverUtils.isMySQLFamily(this.connection.driver)) {
-                useIndex = " USE INDEX (".concat(this.expressionMap.useIndex, ")");
+                useIndex = ` USE INDEX (${this.expressionMap.useIndex})`;
             }
         }
         // create a selection query
-        var froms = this.expressionMap.aliases
-            .filter(function (alias) {
-            return alias.type === "from" &&
-                (alias.tablePath || alias.subQuery);
-        })
-            .map(function (alias) {
+        const froms = this.expressionMap.aliases
+            .filter((alias) => alias.type === "from" &&
+            (alias.tablePath || alias.subQuery))
+            .map((alias) => {
             if (alias.subQuery)
-                return alias.subQuery + " " + _this.escape(alias.name);
-            return (_this.getTableName(alias.tablePath) +
+                return alias.subQuery + " " + this.escape(alias.name);
+            return (this.getTableName(alias.tablePath) +
                 " " +
-                _this.escape(alias.name));
+                this.escape(alias.name));
         });
-        var select = this.createSelectDistinctExpression();
-        var selection = allSelects
-            .map(function (select) {
-            return select.selection +
-                (select.aliasName
-                    ? " AS " + _this.escape(select.aliasName)
-                    : "");
-        })
+        const select = this.createSelectDistinctExpression();
+        const selection = allSelects
+            .map((select) => select.selection +
+            (select.aliasName
+                ? " AS " + this.escape(select.aliasName)
+                : ""))
             .join(", ");
         return (select +
             selection +
@@ -1169,36 +1004,35 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
             froms.join(", ") +
             this.createTableLockExpression() +
             useIndex);
-    };
+    }
     /**
      * Creates select | select distinct part of SQL query.
      */
-    SelectQueryBuilder.prototype.createSelectDistinctExpression = function () {
-        var _this = this;
-        var _a = this.expressionMap, selectDistinct = _a.selectDistinct, selectDistinctOn = _a.selectDistinctOn, maxExecutionTime = _a.maxExecutionTime;
-        var driver = this.connection.driver;
-        var select = "SELECT ";
+    createSelectDistinctExpression() {
+        const { selectDistinct, selectDistinctOn, maxExecutionTime } = this.expressionMap;
+        const { driver } = this.connection;
+        let select = "SELECT ";
         if (maxExecutionTime > 0) {
             if (DriverUtils_1.DriverUtils.isMySQLFamily(driver)) {
-                select += "/*+ MAX_EXECUTION_TIME(".concat(this.expressionMap.maxExecutionTime, ") */ ");
+                select += `/*+ MAX_EXECUTION_TIME(${this.expressionMap.maxExecutionTime}) */ `;
             }
         }
         if (DriverUtils_1.DriverUtils.isPostgresFamily(driver) &&
             selectDistinctOn.length > 0) {
-            var selectDistinctOnMap = selectDistinctOn
-                .map(function (on) { return _this.replacePropertyNames(on); })
+            const selectDistinctOnMap = selectDistinctOn
+                .map((on) => this.replacePropertyNames(on))
                 .join(", ");
-            select = "SELECT DISTINCT ON (".concat(selectDistinctOnMap, ") ");
+            select = `SELECT DISTINCT ON (${selectDistinctOnMap}) `;
         }
         else if (selectDistinct) {
             select = "SELECT DISTINCT ";
         }
         return select;
-    };
+    }
     /**
      * Creates "JOIN" part of SQL query.
      */
-    SelectQueryBuilder.prototype.createJoinExpression = function () {
+    createJoinExpression() {
         // examples:
         // select from owning side
         // qb.select("post")
@@ -1206,37 +1040,36 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
         // select from non-owning side
         // qb.select("category")
         //     .leftJoinAndSelect("category.post", "post");
-        var _this = this;
-        var joins = this.expressionMap.joinAttributes.map(function (joinAttr) {
-            var relation = joinAttr.relation;
-            var destinationTableName = joinAttr.tablePath;
-            var destinationTableAlias = joinAttr.alias.name;
-            var appendedCondition = joinAttr.condition
+        const joins = this.expressionMap.joinAttributes.map((joinAttr) => {
+            const relation = joinAttr.relation;
+            const destinationTableName = joinAttr.tablePath;
+            const destinationTableAlias = joinAttr.alias.name;
+            let appendedCondition = joinAttr.condition
                 ? " AND (" + joinAttr.condition + ")"
                 : "";
-            var parentAlias = joinAttr.parentAlias;
+            const parentAlias = joinAttr.parentAlias;
             // if join was build without relation (e.g. without "post.category") then it means that we have direct
             // table to join, without junction table involved. This means we simply join direct table.
             if (!parentAlias || !relation) {
-                var destinationJoin = joinAttr.alias.subQuery
+                const destinationJoin = joinAttr.alias.subQuery
                     ? joinAttr.alias.subQuery
-                    : _this.getTableName(destinationTableName);
+                    : this.getTableName(destinationTableName);
                 return (" " +
                     joinAttr.direction +
                     " JOIN " +
                     destinationJoin +
                     " " +
-                    _this.escape(destinationTableAlias) +
-                    _this.createTableLockExpression() +
+                    this.escape(destinationTableAlias) +
+                    this.createTableLockExpression() +
                     (joinAttr.condition
-                        ? " ON " + _this.replacePropertyNames(joinAttr.condition)
+                        ? " ON " + this.replacePropertyNames(joinAttr.condition)
                         : ""));
             }
             // if real entity relation is involved
             if (relation.isManyToOne || relation.isOneToOneOwner) {
                 // JOIN `category` `category` ON `category`.`id` = `post`.`categoryId`
-                var condition = relation.joinColumns
-                    .map(function (joinColumn) {
+                const condition = relation.joinColumns
+                    .map((joinColumn) => {
                     return (destinationTableAlias +
                         "." +
                         joinColumn.referencedColumn.propertyPath +
@@ -1251,17 +1084,17 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
                 return (" " +
                     joinAttr.direction +
                     " JOIN " +
-                    _this.getTableName(destinationTableName) +
+                    this.getTableName(destinationTableName) +
                     " " +
-                    _this.escape(destinationTableAlias) +
-                    _this.createTableLockExpression() +
+                    this.escape(destinationTableAlias) +
+                    this.createTableLockExpression() +
                     " ON " +
-                    _this.replacePropertyNames(condition + appendedCondition));
+                    this.replacePropertyNames(condition + appendedCondition));
             }
             else if (relation.isOneToMany || relation.isOneToOneNotOwner) {
                 // JOIN `post` `post` ON `post`.`categoryId` = `category`.`id`
-                var condition = relation
-                    .inverseRelation.joinColumns.map(function (joinColumn) {
+                const condition = relation
+                    .inverseRelation.joinColumns.map((joinColumn) => {
                     if (relation.inverseEntityMetadata.tableType ===
                         "entity-child" &&
                         relation.inverseEntityMetadata.discriminatorColumn) {
@@ -1290,23 +1123,23 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
                 return (" " +
                     joinAttr.direction +
                     " JOIN " +
-                    _this.getTableName(destinationTableName) +
+                    this.getTableName(destinationTableName) +
                     " " +
-                    _this.escape(destinationTableAlias) +
-                    _this.createTableLockExpression() +
+                    this.escape(destinationTableAlias) +
+                    this.createTableLockExpression() +
                     " ON " +
-                    _this.replacePropertyNames(condition + appendedCondition));
+                    this.replacePropertyNames(condition + appendedCondition));
             }
             else {
                 // means many-to-many
-                var junctionTableName = relation.junctionEntityMetadata.tablePath;
-                var junctionAlias_1 = joinAttr.junctionAlias;
-                var junctionCondition = "", destinationCondition = "";
+                const junctionTableName = relation.junctionEntityMetadata.tablePath;
+                const junctionAlias = joinAttr.junctionAlias;
+                let junctionCondition = "", destinationCondition = "";
                 if (relation.isOwning) {
                     junctionCondition = relation.joinColumns
-                        .map(function (joinColumn) {
+                        .map((joinColumn) => {
                         // `post_category`.`postId` = `post`.`id`
-                        return (junctionAlias_1 +
+                        return (junctionAlias +
                             "." +
                             joinColumn.propertyPath +
                             "=" +
@@ -1316,13 +1149,13 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
                     })
                         .join(" AND ");
                     destinationCondition = relation.inverseJoinColumns
-                        .map(function (joinColumn) {
+                        .map((joinColumn) => {
                         // `category`.`id` = `post_category`.`categoryId`
                         return (destinationTableAlias +
                             "." +
                             joinColumn.referencedColumn.propertyPath +
                             "=" +
-                            junctionAlias_1 +
+                            junctionAlias +
                             "." +
                             joinColumn.propertyPath);
                     })
@@ -1330,9 +1163,9 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
                 }
                 else {
                     junctionCondition = relation
-                        .inverseRelation.inverseJoinColumns.map(function (joinColumn) {
+                        .inverseRelation.inverseJoinColumns.map((joinColumn) => {
                         // `post_category`.`categoryId` = `category`.`id`
-                        return (junctionAlias_1 +
+                        return (junctionAlias +
                             "." +
                             joinColumn.propertyPath +
                             "=" +
@@ -1342,13 +1175,13 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
                     })
                         .join(" AND ");
                     destinationCondition = relation
-                        .inverseRelation.joinColumns.map(function (joinColumn) {
+                        .inverseRelation.joinColumns.map((joinColumn) => {
                         // `post`.`id` = `post_category`.`postId`
                         return (destinationTableAlias +
                             "." +
                             joinColumn.referencedColumn.propertyPath +
                             "=" +
-                            junctionAlias_1 +
+                            junctionAlias +
                             "." +
                             joinColumn.propertyPath);
                     })
@@ -1357,51 +1190,50 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
                 return (" " +
                     joinAttr.direction +
                     " JOIN " +
-                    _this.getTableName(junctionTableName) +
+                    this.getTableName(junctionTableName) +
                     " " +
-                    _this.escape(junctionAlias_1) +
-                    _this.createTableLockExpression() +
+                    this.escape(junctionAlias) +
+                    this.createTableLockExpression() +
                     " ON " +
-                    _this.replacePropertyNames(junctionCondition) +
+                    this.replacePropertyNames(junctionCondition) +
                     " " +
                     joinAttr.direction +
                     " JOIN " +
-                    _this.getTableName(destinationTableName) +
+                    this.getTableName(destinationTableName) +
                     " " +
-                    _this.escape(destinationTableAlias) +
-                    _this.createTableLockExpression() +
+                    this.escape(destinationTableAlias) +
+                    this.createTableLockExpression() +
                     " ON " +
-                    _this.replacePropertyNames(destinationCondition + appendedCondition));
+                    this.replacePropertyNames(destinationCondition + appendedCondition));
             }
         });
         return joins.join(" ");
-    };
+    }
     /**
      * Creates "GROUP BY" part of SQL query.
      */
-    SelectQueryBuilder.prototype.createGroupByExpression = function () {
+    createGroupByExpression() {
         if (!this.expressionMap.groupBys || !this.expressionMap.groupBys.length)
             return "";
         return (" GROUP BY " +
             this.replacePropertyNames(this.expressionMap.groupBys.join(", ")));
-    };
+    }
     /**
      * Creates "ORDER BY" part of SQL query.
      */
-    SelectQueryBuilder.prototype.createOrderByExpression = function () {
-        var _this = this;
-        var orderBys = this.expressionMap.allOrderBys;
+    createOrderByExpression() {
+        const orderBys = this.expressionMap.allOrderBys;
         if (Object.keys(orderBys).length > 0)
             return (" ORDER BY " +
                 Object.keys(orderBys)
-                    .map(function (columnName) {
+                    .map((columnName) => {
                     if (typeof orderBys[columnName] === "string") {
-                        return (_this.replacePropertyNames(columnName) +
+                        return (this.replacePropertyNames(columnName) +
                             " " +
                             orderBys[columnName]);
                     }
                     else {
-                        return (_this.replacePropertyNames(columnName) +
+                        return (this.replacePropertyNames(columnName) +
                             " " +
                             orderBys[columnName].order +
                             " " +
@@ -1410,14 +1242,14 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
                 })
                     .join(", "));
         return "";
-    };
+    }
     /**
      * Creates "LIMIT" and "OFFSET" parts of SQL query.
      */
-    SelectQueryBuilder.prototype.createLimitOffsetExpression = function () {
+    createLimitOffsetExpression() {
         // in the case if nothing is joined in the query builder we don't need to make two requests to get paginated results
         // we can use regular limit / offset, that's why we add offset and limit construction here based on skip and take values
-        var offset = this.expressionMap.offset, limit = this.expressionMap.limit;
+        let offset = this.expressionMap.offset, limit = this.expressionMap.limit;
         if (!offset &&
             !limit &&
             this.expressionMap.joinAttributes.length === 0) {
@@ -1430,7 +1262,7 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
             // user does not request one we insert a dummy ORDER BY that does nothing and should
             // have no effect on the query planner or on the order of the results returned.
             // https://dba.stackexchange.com/a/193799
-            var prefix = "";
+            let prefix = "";
             if ((limit || offset) &&
                 Object.keys(this.expressionMap.allOrderBys).length <= 0) {
                 prefix = " ORDER BY (SELECT NULL)";
@@ -1487,7 +1319,7 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
                 return " OFFSET " + offset;
         }
         return "";
-    };
+    }
     /**
      * Creates "LOCK" part of SELECT Query after table Clause
      * ex.
@@ -1496,7 +1328,7 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
      *  JOIN ORDER O WITH (NOLOCK)
      *      ON U.ID=O.OrderID
      */
-    SelectQueryBuilder.prototype.createTableLockExpression = function () {
+    createTableLockExpression() {
         if (this.connection.driver.options.type === "mssql") {
             switch (this.expressionMap.lockMode) {
                 case "pessimistic_read":
@@ -1508,13 +1340,13 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
             }
         }
         return "";
-    };
+    }
     /**
      * Creates "LOCK" part of SQL query.
      */
-    SelectQueryBuilder.prototype.createLockExpression = function () {
-        var driver = this.connection.driver;
-        var lockTablesClause = "";
+    createLockExpression() {
+        const driver = this.connection.driver;
+        let lockTablesClause = "";
         if (this.expressionMap.lockTables) {
             if (!(DriverUtils_1.DriverUtils.isPostgresFamily(driver) ||
                 driver.options.type === "cockroachdb")) {
@@ -1525,7 +1357,7 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
             }
             lockTablesClause = " OF " + this.expressionMap.lockTables.join(", ");
         }
-        var onLockExpression = "";
+        let onLockExpression = "";
         if (this.expressionMap.onLocked === "nowait") {
             onLockExpression = " NOWAIT";
         }
@@ -1615,94 +1447,88 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
             default:
                 return "";
         }
-    };
+    }
     /**
      * Creates "HAVING" part of SQL query.
      */
-    SelectQueryBuilder.prototype.createHavingExpression = function () {
-        var _this = this;
+    createHavingExpression() {
         if (!this.expressionMap.havings || !this.expressionMap.havings.length)
             return "";
-        var conditions = this.expressionMap.havings
-            .map(function (having, index) {
+        const conditions = this.expressionMap.havings
+            .map((having, index) => {
             switch (having.type) {
                 case "and":
                     return ((index > 0 ? "AND " : "") +
-                        _this.replacePropertyNames(having.condition));
+                        this.replacePropertyNames(having.condition));
                 case "or":
                     return ((index > 0 ? "OR " : "") +
-                        _this.replacePropertyNames(having.condition));
+                        this.replacePropertyNames(having.condition));
                 default:
-                    return _this.replacePropertyNames(having.condition);
+                    return this.replacePropertyNames(having.condition);
             }
         })
             .join(" ");
         if (!conditions.length)
             return "";
         return " HAVING " + conditions;
-    };
-    SelectQueryBuilder.prototype.buildEscapedEntityColumnSelects = function (aliasName, metadata) {
-        var _this = this;
-        var hasMainAlias = this.expressionMap.selects.some(function (select) { return select.selection === aliasName; });
-        var columns = [];
+    }
+    buildEscapedEntityColumnSelects(aliasName, metadata) {
+        const hasMainAlias = this.expressionMap.selects.some((select) => select.selection === aliasName);
+        const columns = [];
         if (hasMainAlias) {
-            columns.push.apply(columns, tslib_1.__spreadArray([], tslib_1.__read(metadata.columns.filter(function (column) { return column.isSelect === true; })), false));
+            columns.push(...metadata.columns.filter((column) => column.isSelect === true));
         }
-        columns.push.apply(columns, tslib_1.__spreadArray([], tslib_1.__read(metadata.columns.filter(function (column) {
-            return _this.expressionMap.selects.some(function (select) {
-                return select.selection ===
-                    aliasName + "." + column.propertyPath;
-            });
-        })), false));
+        columns.push(...metadata.columns.filter((column) => {
+            return this.expressionMap.selects.some((select) => select.selection ===
+                aliasName + "." + column.propertyPath);
+        }));
         // if user used partial selection and did not select some primary columns which are required to be selected
         // we select those primary columns and mark them as "virtual". Later virtual column values will be removed from final entity
         // to make entity contain exactly what user selected
         if (columns.length === 0)
             // however not in the case when nothing (even partial) was selected from this target (for example joins without selection)
             return [];
-        var nonSelectedPrimaryColumns = this.expressionMap.queryEntity
-            ? metadata.primaryColumns.filter(function (primaryColumn) { return columns.indexOf(primaryColumn) === -1; })
+        const nonSelectedPrimaryColumns = this.expressionMap.queryEntity
+            ? metadata.primaryColumns.filter((primaryColumn) => columns.indexOf(primaryColumn) === -1)
             : [];
-        var allColumns = tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(columns), false), tslib_1.__read(nonSelectedPrimaryColumns), false);
-        var finalSelects = [];
-        var escapedAliasName = this.escape(aliasName);
-        allColumns.forEach(function (column) {
-            var selectionPath = escapedAliasName + "." + _this.escape(column.databaseName);
+        const allColumns = [...columns, ...nonSelectedPrimaryColumns];
+        const finalSelects = [];
+        const escapedAliasName = this.escape(aliasName);
+        allColumns.forEach((column) => {
+            let selectionPath = escapedAliasName + "." + this.escape(column.databaseName);
             if (column.isVirtualProperty && column.query) {
-                selectionPath = "(".concat(column.query(escapedAliasName), ")");
+                selectionPath = `(${column.query(escapedAliasName)})`;
             }
-            if (_this.connection.driver.spatialTypes.indexOf(column.type) !== -1) {
+            if (this.connection.driver.spatialTypes.indexOf(column.type) !== -1) {
                 //#region @backend
-                if (DriverUtils_1.DriverUtils.isMySQLFamily(_this.connection.driver) ||
-                    _this.connection.driver.options.type === "aurora-mysql") {
-                    var useLegacy = _this.connection.driver.options.legacySpatialSupport;
-                    var asText = useLegacy ? "AsText" : "ST_AsText";
-                    selectionPath = "".concat(asText, "(").concat(selectionPath, ")");
+                if (DriverUtils_1.DriverUtils.isMySQLFamily(this.connection.driver) ||
+                    this.connection.driver.options.type === "aurora-mysql") {
+                    const useLegacy = this.connection.driver.options.legacySpatialSupport;
+                    const asText = useLegacy ? "AsText" : "ST_AsText";
+                    selectionPath = `${asText}(${selectionPath})`;
                 }
                 //#endregion
                 //#region @backend
-                if (DriverUtils_1.DriverUtils.isPostgresFamily(_this.connection.driver))
+                if (DriverUtils_1.DriverUtils.isPostgresFamily(this.connection.driver))
                     if (column.precision) {
                         // cast to JSON to trigger parsing in the driver
-                        selectionPath = "ST_AsGeoJSON(".concat(selectionPath, ", ").concat(column.precision, ")::json");
+                        selectionPath = `ST_AsGeoJSON(${selectionPath}, ${column.precision})::json`;
                     }
                     else {
-                        selectionPath = "ST_AsGeoJSON(".concat(selectionPath, ")::json");
+                        selectionPath = `ST_AsGeoJSON(${selectionPath})::json`;
                     }
-                if (_this.connection.driver.options.type === "mssql")
-                    selectionPath = "".concat(selectionPath, ".ToString()");
+                if (this.connection.driver.options.type === "mssql")
+                    selectionPath = `${selectionPath}.ToString()`;
                 //#endregion
             }
-            var selections = _this.expressionMap.selects.filter(function (select) {
-                return select.selection === aliasName + "." + column.propertyPath;
-            });
+            const selections = this.expressionMap.selects.filter((select) => select.selection === aliasName + "." + column.propertyPath);
             if (selections.length) {
-                selections.forEach(function (selection) {
+                selections.forEach((selection) => {
                     finalSelects.push({
                         selection: selectionPath,
                         aliasName: selection.aliasName
                             ? selection.aliasName
-                            : DriverUtils_1.DriverUtils.buildAlias(_this.connection.driver, aliasName, column.databaseName),
+                            : DriverUtils_1.DriverUtils.buildAlias(this.connection.driver, aliasName, column.databaseName),
                         // todo: need to keep in mind that custom selection.aliasName breaks hydrator. fix it later!
                         virtual: selection.virtual,
                     });
@@ -1711,30 +1537,27 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
             else {
                 finalSelects.push({
                     selection: selectionPath,
-                    aliasName: DriverUtils_1.DriverUtils.buildAlias(_this.connection.driver, aliasName, column.databaseName),
+                    aliasName: DriverUtils_1.DriverUtils.buildAlias(this.connection.driver, aliasName, column.databaseName),
                     // todo: need to keep in mind that custom selection.aliasName breaks hydrator. fix it later!
                     virtual: hasMainAlias,
                 });
             }
         });
         return finalSelects;
-    };
-    SelectQueryBuilder.prototype.findEntityColumnSelects = function (aliasName, metadata) {
-        var mainSelect = this.expressionMap.selects.find(function (select) { return select.selection === aliasName; });
+    }
+    findEntityColumnSelects(aliasName, metadata) {
+        const mainSelect = this.expressionMap.selects.find((select) => select.selection === aliasName);
         if (mainSelect)
             return [mainSelect];
-        return this.expressionMap.selects.filter(function (select) {
-            return metadata.columns.some(function (column) {
-                return select.selection === aliasName + "." + column.propertyPath;
-            });
+        return this.expressionMap.selects.filter((select) => {
+            return metadata.columns.some((column) => select.selection === aliasName + "." + column.propertyPath);
         });
-    };
-    SelectQueryBuilder.prototype.computeCountExpression = function () {
-        var _this = this;
-        var mainAlias = this.expressionMap.mainAlias.name; // todo: will this work with "fromTableName"?
-        var metadata = this.expressionMap.mainAlias.metadata;
-        var primaryColumns = metadata.primaryColumns;
-        var distinctAlias = this.escape(mainAlias);
+    }
+    computeCountExpression() {
+        const mainAlias = this.expressionMap.mainAlias.name; // todo: will this work with "fromTableName"?
+        const metadata = this.expressionMap.mainAlias.metadata;
+        const primaryColumns = metadata.primaryColumns;
+        const distinctAlias = this.escape(mainAlias);
         // If we aren't doing anything that will create a join, we can use a simpler `COUNT` instead
         // so we prevent poor query patterns in the most likely cases
         if (this.expressionMap.joinAttributes.length === 0 &&
@@ -1749,9 +1572,7 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
             // https://www.postgresql.org/docs/9.5/sql-select.html#SQL-DISTINCT
             return ("COUNT(DISTINCT(" +
                 primaryColumns
-                    .map(function (c) {
-                    return "".concat(distinctAlias, ".").concat(_this.escape(c.databaseName));
-                })
+                    .map((c) => `${distinctAlias}.${this.escape(c.databaseName)}`)
                     .join(", ") +
                 "))");
         }
@@ -1760,9 +1581,7 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
             // https://mariadb.com/kb/en/count-distinct/
             return ("COUNT(DISTINCT " +
                 primaryColumns
-                    .map(function (c) {
-                    return "".concat(distinctAlias, ".").concat(_this.escape(c.databaseName));
-                })
+                    .map((c) => `${distinctAlias}.${this.escape(c.databaseName)}`)
                     .join(", ") +
                 ")");
         }
@@ -1771,70 +1590,55 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
             // distinct counting multiple columns & they don't have the same operator
             // characteristic for concatenating, so we gotta use the `CONCAT` function.
             // However, If it's exactly 1 column we can omit the `CONCAT` for better performance.
-            var columnsExpression = primaryColumns
-                .map(function (primaryColumn) {
-                return "".concat(distinctAlias, ".").concat(_this.escape(primaryColumn.databaseName));
-            })
+            const columnsExpression = primaryColumns
+                .map((primaryColumn) => `${distinctAlias}.${this.escape(primaryColumn.databaseName)}`)
                 .join(", '|;|', ");
             if (primaryColumns.length === 1) {
-                return "COUNT(DISTINCT(".concat(columnsExpression, "))");
+                return `COUNT(DISTINCT(${columnsExpression}))`;
             }
-            return "COUNT(DISTINCT(CONCAT(".concat(columnsExpression, ")))");
+            return `COUNT(DISTINCT(CONCAT(${columnsExpression})))`;
         }
         if (this.connection.driver.options.type === "spanner") {
             // spanner also has gotta be different from everyone else.
             // they do not support concatenation of different column types without casting them to string
             if (primaryColumns.length === 1) {
-                return "COUNT(DISTINCT(".concat(distinctAlias, ".").concat(this.escape(primaryColumns[0].databaseName), "))");
+                return `COUNT(DISTINCT(${distinctAlias}.${this.escape(primaryColumns[0].databaseName)}))`;
             }
-            var columnsExpression = primaryColumns
-                .map(function (primaryColumn) {
-                return "CAST(".concat(distinctAlias, ".").concat(_this.escape(primaryColumn.databaseName), " AS STRING)");
-            })
+            const columnsExpression = primaryColumns
+                .map((primaryColumn) => `CAST(${distinctAlias}.${this.escape(primaryColumn.databaseName)} AS STRING)`)
                 .join(", '|;|', ");
-            return "COUNT(DISTINCT(CONCAT(".concat(columnsExpression, ")))");
+            return `COUNT(DISTINCT(CONCAT(${columnsExpression})))`;
         }
         // If all else fails, fall back to a `COUNT` and `DISTINCT` across all the primary columns concatenated.
         // Per the SQL spec, this is the canonical string concatenation mechanism which is most
         // likely to work across servers implementing the SQL standard.
         // Please note, if there is only one primary column that the concatenation does not occur in this
         // query and the query is a standard `COUNT DISTINCT` in that case.
-        return ("COUNT(DISTINCT(" +
+        return (`COUNT(DISTINCT(` +
             primaryColumns
-                .map(function (c) { return "".concat(distinctAlias, ".").concat(_this.escape(c.databaseName)); })
+                .map((c) => `${distinctAlias}.${this.escape(c.databaseName)}`)
                 .join(" || '|;|' || ") +
             "))");
-    };
-    SelectQueryBuilder.prototype.executeCountQuery = function (queryRunner) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var countSql, results;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        countSql = this.computeCountExpression();
-                        return [4 /*yield*/, this.clone()
-                                .orderBy()
-                                .groupBy()
-                                .offset(undefined)
-                                .limit(undefined)
-                                .skip(undefined)
-                                .take(undefined)
-                                .select(countSql, "cnt")
-                                .setOption("disable-global-order")
-                                .loadRawResults(queryRunner)];
-                    case 1:
-                        results = _a.sent();
-                        if (!results || !results[0] || !results[0]["cnt"])
-                            return [2 /*return*/, 0];
-                        return [2 /*return*/, parseInt(results[0]["cnt"])];
-                }
-            });
-        });
-    };
-    SelectQueryBuilder.prototype.applyFindOptions = function () {
+    }
+    async executeCountQuery(queryRunner) {
+        const countSql = this.computeCountExpression();
+        const results = await this.clone()
+            .orderBy()
+            .groupBy()
+            .offset(undefined)
+            .limit(undefined)
+            .skip(undefined)
+            .take(undefined)
+            .select(countSql, "cnt")
+            .setOption("disable-global-order")
+            .loadRawResults(queryRunner);
+        if (!results || !results[0] || !results[0]["cnt"])
+            return 0;
+        return parseInt(results[0]["cnt"]);
+    }
+    applyFindOptions() {
         // todo: convert relations: string[] to object map to simplify code
         // todo: same with selects
-        var _this = this;
         if (this.expressionMap.mainAlias.metadata) {
             if (this.findOptions.relationLoadStrategy) {
                 this.expressionMap.relationLoadStrategy =
@@ -1847,7 +1651,7 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
                 this.withDeleted();
             }
             if (this.findOptions.select) {
-                var select = Array.isArray(this.findOptions.select)
+                const select = Array.isArray(this.findOptions.select)
                     ? OrmUtils_1.OrmUtils.propertyPathsToTruthyObject(this.findOptions.select)
                     : this.findOptions.select;
                 this.buildSelect(select, this.expressionMap.mainAlias.metadata, this.expressionMap.mainAlias.name);
@@ -1857,7 +1661,7 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
             }
             this.selects = [];
             if (this.findOptions.relations) {
-                var relations = Array.isArray(this.findOptions.relations)
+                const relations = Array.isArray(this.findOptions.relations)
                     ? OrmUtils_1.OrmUtils.propertyPathsToTruthyObject(this.findOptions.relations)
                     : this.findOptions.relations;
                 this.buildRelations(relations, typeof this.findOptions.select === "object"
@@ -1886,25 +1690,25 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
             }
             // apply joins
             if (this.joins.length) {
-                this.joins.forEach(function (join) {
+                this.joins.forEach((join) => {
                     if (join.select && !join.selection) {
                         // if (join.selection) {
                         //
                         // } else {
                         if (join.type === "inner") {
-                            _this.innerJoinAndSelect("".concat(join.parentAlias, ".").concat(join.relationMetadata.propertyPath), join.alias);
+                            this.innerJoinAndSelect(`${join.parentAlias}.${join.relationMetadata.propertyPath}`, join.alias);
                         }
                         else {
-                            _this.leftJoinAndSelect("".concat(join.parentAlias, ".").concat(join.relationMetadata.propertyPath), join.alias);
+                            this.leftJoinAndSelect(`${join.parentAlias}.${join.relationMetadata.propertyPath}`, join.alias);
                         }
                         // }
                     }
                     else {
                         if (join.type === "inner") {
-                            _this.innerJoin("".concat(join.parentAlias, ".").concat(join.relationMetadata.propertyPath), join.alias);
+                            this.innerJoin(`${join.parentAlias}.${join.relationMetadata.propertyPath}`, join.alias);
                         }
                         else {
-                            _this.leftJoin("".concat(join.parentAlias, ".").concat(join.relationMetadata.propertyPath), join.alias);
+                            this.leftJoin(`${join.parentAlias}.${join.relationMetadata.propertyPath}`, join.alias);
                         }
                     }
                     // if (join.select) {
@@ -1949,20 +1753,20 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
             }
             if (this.findOptions.join) {
                 if (this.findOptions.join.leftJoin)
-                    Object.keys(this.findOptions.join.leftJoin).forEach(function (key) {
-                        _this.leftJoin(_this.findOptions.join.leftJoin[key], key);
+                    Object.keys(this.findOptions.join.leftJoin).forEach((key) => {
+                        this.leftJoin(this.findOptions.join.leftJoin[key], key);
                     });
                 if (this.findOptions.join.innerJoin)
-                    Object.keys(this.findOptions.join.innerJoin).forEach(function (key) {
-                        _this.innerJoin(_this.findOptions.join.innerJoin[key], key);
+                    Object.keys(this.findOptions.join.innerJoin).forEach((key) => {
+                        this.innerJoin(this.findOptions.join.innerJoin[key], key);
                     });
                 if (this.findOptions.join.leftJoinAndSelect)
-                    Object.keys(this.findOptions.join.leftJoinAndSelect).forEach(function (key) {
-                        _this.leftJoinAndSelect(_this.findOptions.join.leftJoinAndSelect[key], key);
+                    Object.keys(this.findOptions.join.leftJoinAndSelect).forEach((key) => {
+                        this.leftJoinAndSelect(this.findOptions.join.leftJoinAndSelect[key], key);
                     });
                 if (this.findOptions.join.innerJoinAndSelect)
-                    Object.keys(this.findOptions.join.innerJoinAndSelect).forEach(function (key) {
-                        _this.innerJoinAndSelect(_this.findOptions.join.innerJoinAndSelect[key], key);
+                    Object.keys(this.findOptions.join.innerJoinAndSelect).forEach((key) => {
+                        this.innerJoinAndSelect(this.findOptions.join.innerJoinAndSelect[key], key);
                     });
             }
             if (this.findOptions.lock) {
@@ -1978,16 +1782,16 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
                         "pessimistic_write_or_fail" ||
                     this.findOptions.lock.mode === "for_no_key_update" ||
                     this.findOptions.lock.mode === "for_key_share") {
-                    var tableNames = this.findOptions.lock.tables
-                        ? this.findOptions.lock.tables.map(function (table) {
-                            var tableAlias = _this.expressionMap.aliases.find(function (alias) {
+                    const tableNames = this.findOptions.lock.tables
+                        ? this.findOptions.lock.tables.map((table) => {
+                            const tableAlias = this.expressionMap.aliases.find((alias) => {
                                 return (alias.metadata
                                     .tableNameWithoutPrefix === table);
                             });
                             if (!tableAlias) {
-                                throw new error_1.TypeORMError("\"".concat(table, "\" is not part of this query"));
+                                throw new error_1.TypeORMError(`"${table}" is not part of this query`);
                             }
-                            return _this.escape(tableAlias.name);
+                            return this.escape(tableAlias.name);
                         })
                         : undefined;
                     this.setLock(this.findOptions.lock.mode, undefined, tableNames);
@@ -2022,236 +1826,207 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
             //     this.callListeners(false);
             // }
         }
-    };
+    }
     /**
      * Executes sql generated by query builder and returns object with raw results and entities created from them.
      */
-    SelectQueryBuilder.prototype.executeEntitiesAndRawResults = function (queryRunner) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var metadata, relationIdLoader, relationCountLoader, relationIdMetadataTransformer, relationCountMetadataTransformer, rawResults, entities, _a, selects, orderBys_1, metadata_1, mainAliasName_1, querySelects, condition, parameters_1, alias_1, ids, areAllNumbers, rawRelationIdResults, rawRelationCountResults, transformer;
-            var _this = this;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!this.expressionMap.mainAlias)
-                            throw new error_1.TypeORMError("Alias is not set. Use \"from\" method to set an alias.");
-                        if ((this.expressionMap.lockMode === "pessimistic_read" ||
-                            this.expressionMap.lockMode === "pessimistic_write" ||
-                            this.expressionMap.lockMode === "pessimistic_partial_write" ||
-                            this.expressionMap.lockMode === "pessimistic_write_or_fail" ||
-                            this.expressionMap.lockMode === "for_no_key_update" ||
-                            this.expressionMap.lockMode === "for_key_share") &&
-                            !queryRunner.isTransactionActive)
-                            throw new PessimisticLockTransactionRequiredError_1.PessimisticLockTransactionRequiredError();
-                        if (this.expressionMap.lockMode === "optimistic") {
-                            metadata = this.expressionMap.mainAlias.metadata;
-                            if (!metadata.versionColumn && !metadata.updateDateColumn)
-                                throw new NoVersionOrUpdateDateColumnError_1.NoVersionOrUpdateDateColumnError(metadata.name);
-                        }
-                        relationIdLoader = new RelationIdLoader_1.RelationIdLoader(this.connection, queryRunner, this.expressionMap.relationIdAttributes);
-                        relationCountLoader = new RelationCountLoader_1.RelationCountLoader(this.connection, queryRunner, this.expressionMap.relationCountAttributes);
-                        relationIdMetadataTransformer = new RelationIdMetadataToAttributeTransformer_1.RelationIdMetadataToAttributeTransformer(this.expressionMap);
-                        relationIdMetadataTransformer.transform();
-                        relationCountMetadataTransformer = new RelationCountMetadataToAttributeTransformer_1.RelationCountMetadataToAttributeTransformer(this.expressionMap);
-                        relationCountMetadataTransformer.transform();
-                        rawResults = [], entities = [];
-                        if (!((this.expressionMap.skip || this.expressionMap.take) &&
-                            this.expressionMap.joinAttributes.length > 0)) return [3 /*break*/, 4];
-                        _a = tslib_1.__read(this.createOrderByCombinedWithSelectExpression("distinctAlias"), 2), selects = _a[0], orderBys_1 = _a[1];
-                        metadata_1 = this.expressionMap.mainAlias.metadata;
-                        mainAliasName_1 = this.expressionMap.mainAlias.name;
-                        querySelects = metadata_1.primaryColumns.map(function (primaryColumn) {
-                            var distinctAlias = _this.escape("distinctAlias");
-                            var columnAlias = _this.escape(DriverUtils_1.DriverUtils.buildAlias(_this.connection.driver, mainAliasName_1, primaryColumn.databaseName));
-                            if (!orderBys_1[columnAlias])
-                                // make sure we aren't overriding user-defined order in inverse direction
-                                orderBys_1[columnAlias] = "ASC";
-                            var alias = DriverUtils_1.DriverUtils.buildAlias(_this.connection.driver, "ids_" + mainAliasName_1, primaryColumn.databaseName);
-                            return "".concat(distinctAlias, ".").concat(columnAlias, " AS ").concat(_this.escape(alias));
-                        });
-                        return [4 /*yield*/, new SelectQueryBuilder_1(this.connection, queryRunner)
-                                .select("DISTINCT ".concat(querySelects.join(", ")))
-                                .addSelect(selects)
-                                .from("(".concat(this.clone().orderBy().getQuery(), ")"), "distinctAlias")
-                                .offset(this.expressionMap.skip)
-                                .limit(this.expressionMap.take)
-                                .orderBy(orderBys_1)
-                                .cache(this.expressionMap.cache
-                                ? this.expressionMap.cache
-                                : this.expressionMap.cacheId, this.expressionMap.cacheDuration)
-                                .setParameters(this.getParameters())
-                                .setNativeParameters(this.expressionMap.nativeParameters)
-                                .getRawMany()];
-                    case 1:
-                        rawResults = _b.sent();
-                        if (!(rawResults.length > 0)) return [3 /*break*/, 3];
-                        condition = "";
-                        parameters_1 = {};
-                        if (metadata_1.hasMultiplePrimaryKeys) {
-                            condition = rawResults
-                                .map(function (result, index) {
-                                return metadata_1.primaryColumns
-                                    .map(function (primaryColumn) {
-                                    var paramKey = "orm_distinct_ids_".concat(index, "_").concat(primaryColumn.databaseName);
-                                    parameters_1[paramKey] =
-                                        result["ids_".concat(mainAliasName_1, "_").concat(primaryColumn.databaseName)];
-                                    return "".concat(mainAliasName_1, ".").concat(primaryColumn.propertyPath, "=:").concat(paramKey);
-                                })
-                                    .join(" AND ");
-                            })
-                                .join(" OR ");
-                        }
-                        else {
-                            alias_1 = DriverUtils_1.DriverUtils.buildAlias(this.connection.driver, "ids_" + mainAliasName_1, metadata_1.primaryColumns[0].databaseName);
-                            ids = rawResults.map(function (result) { return result[alias_1]; });
-                            areAllNumbers = ids.every(function (id) { return typeof id === "number"; });
-                            if (areAllNumbers) {
-                                // fixes #190. if all numbers then its safe to perform query without parameter
-                                condition = "".concat(mainAliasName_1, ".").concat(metadata_1.primaryColumns[0].propertyPath, " IN (").concat(ids.join(", "), ")");
-                            }
-                            else {
-                                parameters_1["orm_distinct_ids"] = ids;
-                                condition =
-                                    mainAliasName_1 +
-                                        "." +
-                                        metadata_1.primaryColumns[0].propertyPath +
-                                        " IN (:...orm_distinct_ids)";
-                            }
+    async executeEntitiesAndRawResults(queryRunner) {
+        if (!this.expressionMap.mainAlias)
+            throw new error_1.TypeORMError(`Alias is not set. Use "from" method to set an alias.`);
+        if ((this.expressionMap.lockMode === "pessimistic_read" ||
+            this.expressionMap.lockMode === "pessimistic_write" ||
+            this.expressionMap.lockMode === "pessimistic_partial_write" ||
+            this.expressionMap.lockMode === "pessimistic_write_or_fail" ||
+            this.expressionMap.lockMode === "for_no_key_update" ||
+            this.expressionMap.lockMode === "for_key_share") &&
+            !queryRunner.isTransactionActive)
+            throw new PessimisticLockTransactionRequiredError_1.PessimisticLockTransactionRequiredError();
+        if (this.expressionMap.lockMode === "optimistic") {
+            const metadata = this.expressionMap.mainAlias.metadata;
+            if (!metadata.versionColumn && !metadata.updateDateColumn)
+                throw new NoVersionOrUpdateDateColumnError_1.NoVersionOrUpdateDateColumnError(metadata.name);
+        }
+        const relationIdLoader = new RelationIdLoader_1.RelationIdLoader(this.connection, queryRunner, this.expressionMap.relationIdAttributes);
+        const relationCountLoader = new RelationCountLoader_1.RelationCountLoader(this.connection, queryRunner, this.expressionMap.relationCountAttributes);
+        const relationIdMetadataTransformer = new RelationIdMetadataToAttributeTransformer_1.RelationIdMetadataToAttributeTransformer(this.expressionMap);
+        relationIdMetadataTransformer.transform();
+        const relationCountMetadataTransformer = new RelationCountMetadataToAttributeTransformer_1.RelationCountMetadataToAttributeTransformer(this.expressionMap);
+        relationCountMetadataTransformer.transform();
+        let rawResults = [], entities = [];
+        // for pagination enabled (e.g. skip and take) its much more complicated - its a special process
+        // where we make two queries to find the data we need
+        // first query find ids in skip and take range
+        // and second query loads the actual data in given ids range
+        if ((this.expressionMap.skip || this.expressionMap.take) &&
+            this.expressionMap.joinAttributes.length > 0) {
+            // we are skipping order by here because its not working in subqueries anyway
+            // to make order by working we need to apply it on a distinct query
+            const [selects, orderBys] = this.createOrderByCombinedWithSelectExpression("distinctAlias");
+            const metadata = this.expressionMap.mainAlias.metadata;
+            const mainAliasName = this.expressionMap.mainAlias.name;
+            const querySelects = metadata.primaryColumns.map((primaryColumn) => {
+                const distinctAlias = this.escape("distinctAlias");
+                const columnAlias = this.escape(DriverUtils_1.DriverUtils.buildAlias(this.connection.driver, mainAliasName, primaryColumn.databaseName));
+                if (!orderBys[columnAlias])
+                    // make sure we aren't overriding user-defined order in inverse direction
+                    orderBys[columnAlias] = "ASC";
+                const alias = DriverUtils_1.DriverUtils.buildAlias(this.connection.driver, "ids_" + mainAliasName, primaryColumn.databaseName);
+                return `${distinctAlias}.${columnAlias} AS ${this.escape(alias)}`;
+            });
+            rawResults = await new SelectQueryBuilder_1(this.connection, queryRunner)
+                .select(`DISTINCT ${querySelects.join(", ")}`)
+                .addSelect(selects)
+                .from(`(${this.clone().orderBy().getQuery()})`, "distinctAlias")
+                .offset(this.expressionMap.skip)
+                .limit(this.expressionMap.take)
+                .orderBy(orderBys)
+                .cache(this.expressionMap.cache
+                ? this.expressionMap.cache
+                : this.expressionMap.cacheId, this.expressionMap.cacheDuration)
+                .setParameters(this.getParameters())
+                .setNativeParameters(this.expressionMap.nativeParameters)
+                .getRawMany();
+            if (rawResults.length > 0) {
+                let condition = "";
+                const parameters = {};
+                if (metadata.hasMultiplePrimaryKeys) {
+                    condition = rawResults
+                        .map((result, index) => {
+                        return metadata.primaryColumns
+                            .map((primaryColumn) => {
+                            const paramKey = `orm_distinct_ids_${index}_${primaryColumn.databaseName}`;
+                            parameters[paramKey] =
+                                result[`ids_${mainAliasName}_${primaryColumn.databaseName}`];
+                            return `${mainAliasName}.${primaryColumn.propertyPath}=:${paramKey}`;
+                        })
+                            .join(" AND ");
+                    })
+                        .join(" OR ");
+                }
+                else {
+                    const alias = DriverUtils_1.DriverUtils.buildAlias(this.connection.driver, "ids_" + mainAliasName, metadata.primaryColumns[0].databaseName);
+                    const ids = rawResults.map((result) => result[alias]);
+                    const areAllNumbers = ids.every((id) => typeof id === "number");
+                    if (areAllNumbers) {
+                        // fixes #190. if all numbers then its safe to perform query without parameter
+                        condition = `${mainAliasName}.${metadata.primaryColumns[0].propertyPath} IN (${ids.join(", ")})`;
+                    }
+                    else {
+                        parameters["orm_distinct_ids"] = ids;
+                        condition =
+                            mainAliasName +
+                                "." +
+                                metadata.primaryColumns[0].propertyPath +
+                                " IN (:...orm_distinct_ids)";
+                    }
+                }
+                rawResults = await this.clone()
+                    .mergeExpressionMap({
+                    extraAppendedAndWhereCondition: condition,
+                })
+                    .setParameters(parameters)
+                    .loadRawResults(queryRunner);
+            }
+        }
+        else {
+            rawResults = await this.loadRawResults(queryRunner);
+        }
+        if (rawResults.length > 0) {
+            // transform raw results into entities
+            const rawRelationIdResults = await relationIdLoader.load(rawResults);
+            const rawRelationCountResults = await relationCountLoader.load(rawResults);
+            const transformer = new RawSqlResultsToEntityTransformer_1.RawSqlResultsToEntityTransformer(this.expressionMap, this.connection.driver, rawRelationIdResults, rawRelationCountResults, this.queryRunner);
+            entities = transformer.transform(rawResults, this.expressionMap.mainAlias);
+            // broadcast all "after load" events
+            if (this.expressionMap.callListeners === true &&
+                this.expressionMap.mainAlias.hasMetadata) {
+                await queryRunner.broadcaster.broadcast("Load", this.expressionMap.mainAlias.metadata, entities);
+            }
+        }
+        if (this.expressionMap.relationLoadStrategy === "query") {
+            await Promise.all(this.relationMetadatas.map(async (relation) => {
+                const relationTarget = relation.inverseEntityMetadata.target;
+                const relationAlias = relation.inverseEntityMetadata.targetName;
+                const select = Array.isArray(this.findOptions.select)
+                    ? OrmUtils_1.OrmUtils.propertyPathsToTruthyObject(this.findOptions.select)
+                    : this.findOptions.select;
+                const relations = Array.isArray(this.findOptions.relations)
+                    ? OrmUtils_1.OrmUtils.propertyPathsToTruthyObject(this.findOptions.relations)
+                    : this.findOptions.relations;
+                const queryBuilder = this.createQueryBuilder()
+                    .select(relationAlias)
+                    .from(relationTarget, relationAlias)
+                    .setFindOptions({
+                    select: select
+                        ? OrmUtils_1.OrmUtils.deepValue(select, relation.propertyPath)
+                        : undefined,
+                    order: this.findOptions.order
+                        ? OrmUtils_1.OrmUtils.deepValue(this.findOptions.order, relation.propertyPath)
+                        : undefined,
+                    relations: relations
+                        ? OrmUtils_1.OrmUtils.deepValue(relations, relation.propertyPath)
+                        : undefined,
+                    withDeleted: this.findOptions.withDeleted,
+                    relationLoadStrategy: this.findOptions.relationLoadStrategy,
+                });
+                if (entities.length > 0) {
+                    const relatedEntityGroups = await this.connection.relationIdLoader.loadManyToManyRelationIdsAndGroup(relation, entities, undefined, queryBuilder);
+                    entities.forEach((entity) => {
+                        const relatedEntityGroup = relatedEntityGroups.find((group) => group.entity === entity);
+                        if (relatedEntityGroup) {
+                            const value = relatedEntityGroup.related === undefined
+                                ? null
+                                : relatedEntityGroup.related;
+                            relation.setEntityValue(entity, value);
                         }
-                        return [4 /*yield*/, this.clone()
-                                .mergeExpressionMap({
-                                extraAppendedAndWhereCondition: condition,
-                            })
-                                .setParameters(parameters_1)
-                                .loadRawResults(queryRunner)];
-                    case 2:
-                        rawResults = _b.sent();
-                        _b.label = 3;
-                    case 3: return [3 /*break*/, 6];
-                    case 4: return [4 /*yield*/, this.loadRawResults(queryRunner)];
-                    case 5:
-                        rawResults = _b.sent();
-                        _b.label = 6;
-                    case 6:
-                        if (!(rawResults.length > 0)) return [3 /*break*/, 10];
-                        return [4 /*yield*/, relationIdLoader.load(rawResults)];
-                    case 7:
-                        rawRelationIdResults = _b.sent();
-                        return [4 /*yield*/, relationCountLoader.load(rawResults)];
-                    case 8:
-                        rawRelationCountResults = _b.sent();
-                        transformer = new RawSqlResultsToEntityTransformer_1.RawSqlResultsToEntityTransformer(this.expressionMap, this.connection.driver, rawRelationIdResults, rawRelationCountResults, this.queryRunner);
-                        entities = transformer.transform(rawResults, this.expressionMap.mainAlias);
-                        if (!(this.expressionMap.callListeners === true &&
-                            this.expressionMap.mainAlias.hasMetadata)) return [3 /*break*/, 10];
-                        return [4 /*yield*/, queryRunner.broadcaster.broadcast("Load", this.expressionMap.mainAlias.metadata, entities)];
-                    case 9:
-                        _b.sent();
-                        _b.label = 10;
-                    case 10:
-                        if (!(this.expressionMap.relationLoadStrategy === "query")) return [3 /*break*/, 12];
-                        return [4 /*yield*/, Promise.all(this.relationMetadatas.map(function (relation) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                var relationTarget, relationAlias, select, relations, queryBuilder, relatedEntityGroups_1;
-                                return tslib_1.__generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0:
-                                            relationTarget = relation.inverseEntityMetadata.target;
-                                            relationAlias = relation.inverseEntityMetadata.targetName;
-                                            select = Array.isArray(this.findOptions.select)
-                                                ? OrmUtils_1.OrmUtils.propertyPathsToTruthyObject(this.findOptions.select)
-                                                : this.findOptions.select;
-                                            relations = Array.isArray(this.findOptions.relations)
-                                                ? OrmUtils_1.OrmUtils.propertyPathsToTruthyObject(this.findOptions.relations)
-                                                : this.findOptions.relations;
-                                            queryBuilder = this.createQueryBuilder()
-                                                .select(relationAlias)
-                                                .from(relationTarget, relationAlias)
-                                                .setFindOptions({
-                                                select: select
-                                                    ? OrmUtils_1.OrmUtils.deepValue(select, relation.propertyPath)
-                                                    : undefined,
-                                                order: this.findOptions.order
-                                                    ? OrmUtils_1.OrmUtils.deepValue(this.findOptions.order, relation.propertyPath)
-                                                    : undefined,
-                                                relations: relations
-                                                    ? OrmUtils_1.OrmUtils.deepValue(relations, relation.propertyPath)
-                                                    : undefined,
-                                                withDeleted: this.findOptions.withDeleted,
-                                                relationLoadStrategy: this.findOptions.relationLoadStrategy,
-                                            });
-                                            if (!(entities.length > 0)) return [3 /*break*/, 2];
-                                            return [4 /*yield*/, this.connection.relationIdLoader.loadManyToManyRelationIdsAndGroup(relation, entities, undefined, queryBuilder)];
-                                        case 1:
-                                            relatedEntityGroups_1 = _a.sent();
-                                            entities.forEach(function (entity) {
-                                                var relatedEntityGroup = relatedEntityGroups_1.find(function (group) { return group.entity === entity; });
-                                                if (relatedEntityGroup) {
-                                                    var value = relatedEntityGroup.related === undefined
-                                                        ? null
-                                                        : relatedEntityGroup.related;
-                                                    relation.setEntityValue(entity, value);
-                                                }
-                                            });
-                                            _a.label = 2;
-                                        case 2: return [2 /*return*/];
-                                    }
-                                });
-                            }); }))];
-                    case 11:
-                        _b.sent();
-                        _b.label = 12;
-                    case 12: return [2 /*return*/, {
-                            raw: rawResults,
-                            entities: entities,
-                        }];
+                    });
                 }
-            });
-        });
-    };
-    SelectQueryBuilder.prototype.createOrderByCombinedWithSelectExpression = function (parentAlias) {
-        var _this = this;
+            }));
+        }
+        return {
+            raw: rawResults,
+            entities: entities,
+        };
+    }
+    createOrderByCombinedWithSelectExpression(parentAlias) {
         // if table has a default order then apply it
-        var orderBys = this.expressionMap.allOrderBys;
-        var selectString = Object.keys(orderBys)
-            .map(function (orderCriteria) {
+        const orderBys = this.expressionMap.allOrderBys;
+        const selectString = Object.keys(orderBys)
+            .map((orderCriteria) => {
             if (orderCriteria.indexOf(".") !== -1) {
-                var criteriaParts = orderCriteria.split(".");
-                var aliasName = criteriaParts[0];
-                var propertyPath = criteriaParts.slice(1).join(".");
-                var alias = _this.expressionMap.findAliasByName(aliasName);
-                var column = alias.metadata.findColumnWithPropertyPath(propertyPath);
-                return (_this.escape(parentAlias) +
+                const criteriaParts = orderCriteria.split(".");
+                const aliasName = criteriaParts[0];
+                const propertyPath = criteriaParts.slice(1).join(".");
+                const alias = this.expressionMap.findAliasByName(aliasName);
+                const column = alias.metadata.findColumnWithPropertyPath(propertyPath);
+                return (this.escape(parentAlias) +
                     "." +
-                    _this.escape(DriverUtils_1.DriverUtils.buildAlias(_this.connection.driver, aliasName, column.databaseName)));
+                    this.escape(DriverUtils_1.DriverUtils.buildAlias(this.connection.driver, aliasName, column.databaseName)));
             }
             else {
-                if (_this.expressionMap.selects.find(function (select) {
-                    return select.selection === orderCriteria ||
-                        select.aliasName === orderCriteria;
-                }))
-                    return _this.escape(parentAlias) + "." + orderCriteria;
+                if (this.expressionMap.selects.find((select) => select.selection === orderCriteria ||
+                    select.aliasName === orderCriteria))
+                    return this.escape(parentAlias) + "." + orderCriteria;
                 return "";
             }
         })
             .join(", ");
-        var orderByObject = {};
-        Object.keys(orderBys).forEach(function (orderCriteria) {
+        const orderByObject = {};
+        Object.keys(orderBys).forEach((orderCriteria) => {
             if (orderCriteria.indexOf(".") !== -1) {
-                var criteriaParts = orderCriteria.split(".");
-                var aliasName = criteriaParts[0];
-                var propertyPath = criteriaParts.slice(1).join(".");
-                var alias = _this.expressionMap.findAliasByName(aliasName);
-                var column = alias.metadata.findColumnWithPropertyPath(propertyPath);
-                orderByObject[_this.escape(parentAlias) +
+                const criteriaParts = orderCriteria.split(".");
+                const aliasName = criteriaParts[0];
+                const propertyPath = criteriaParts.slice(1).join(".");
+                const alias = this.expressionMap.findAliasByName(aliasName);
+                const column = alias.metadata.findColumnWithPropertyPath(propertyPath);
+                orderByObject[this.escape(parentAlias) +
                     "." +
-                    _this.escape(DriverUtils_1.DriverUtils.buildAlias(_this.connection.driver, aliasName, column.databaseName))] = orderBys[orderCriteria];
+                    this.escape(DriverUtils_1.DriverUtils.buildAlias(this.connection.driver, aliasName, column.databaseName))] = orderBys[orderCriteria];
             }
             else {
-                if (_this.expressionMap.selects.find(function (select) {
-                    return select.selection === orderCriteria ||
-                        select.aliasName === orderCriteria;
-                })) {
-                    orderByObject[_this.escape(parentAlias) + "." + orderCriteria] = orderBys[orderCriteria];
+                if (this.expressionMap.selects.find((select) => select.selection === orderCriteria ||
+                    select.aliasName === orderCriteria)) {
+                    orderByObject[this.escape(parentAlias) + "." + orderCriteria] = orderBys[orderCriteria];
                 }
                 else {
                     orderByObject[orderCriteria] = orderBys[orderCriteria];
@@ -2259,111 +2034,93 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
             }
         });
         return [selectString, orderByObject];
-    };
+    }
     /**
      * Loads raw results from the database.
      */
-    SelectQueryBuilder.prototype.loadRawResults = function (queryRunner) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var _a, sql, parameters, queryId, cacheOptions, savedQueryResultCacheOptions, cacheError, error_7, results, error_8;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _a = tslib_1.__read(this.getQueryAndParameters(), 2), sql = _a[0], parameters = _a[1];
-                        queryId = sql + " -- PARAMETERS: " + JSON.stringify(parameters);
-                        cacheOptions = typeof this.connection.options.cache === "object"
-                            ? this.connection.options.cache
-                            : {};
-                        savedQueryResultCacheOptions = undefined;
-                        cacheError = false;
-                        if (!(this.connection.queryResultCache &&
-                            (this.expressionMap.cache || cacheOptions.alwaysEnabled))) return [3 /*break*/, 4];
-                        _b.label = 1;
-                    case 1:
-                        _b.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.connection.queryResultCache.getFromCache({
-                                identifier: this.expressionMap.cacheId,
-                                query: queryId,
-                                duration: this.expressionMap.cacheDuration ||
-                                    cacheOptions.duration ||
-                                    1000,
-                            }, queryRunner)];
-                    case 2:
-                        savedQueryResultCacheOptions =
-                            _b.sent();
-                        if (savedQueryResultCacheOptions &&
-                            !this.connection.queryResultCache.isExpired(savedQueryResultCacheOptions)) {
-                            return [2 /*return*/, JSON.parse(savedQueryResultCacheOptions.result)];
-                        }
-                        return [3 /*break*/, 4];
-                    case 3:
-                        error_7 = _b.sent();
-                        if (!cacheOptions.ignoreErrors) {
-                            throw error_7;
-                        }
-                        cacheError = true;
-                        return [3 /*break*/, 4];
-                    case 4: return [4 /*yield*/, queryRunner.query(sql, parameters, true)];
-                    case 5:
-                        results = _b.sent();
-                        if (!(!cacheError &&
-                            this.connection.queryResultCache &&
-                            (this.expressionMap.cache || cacheOptions.alwaysEnabled))) return [3 /*break*/, 9];
-                        _b.label = 6;
-                    case 6:
-                        _b.trys.push([6, 8, , 9]);
-                        return [4 /*yield*/, this.connection.queryResultCache.storeInCache({
-                                identifier: this.expressionMap.cacheId,
-                                query: queryId,
-                                time: new Date().getTime(),
-                                duration: this.expressionMap.cacheDuration ||
-                                    cacheOptions.duration ||
-                                    1000,
-                                result: JSON.stringify(results.records),
-                            }, savedQueryResultCacheOptions, queryRunner)];
-                    case 7:
-                        _b.sent();
-                        return [3 /*break*/, 9];
-                    case 8:
-                        error_8 = _b.sent();
-                        if (!cacheOptions.ignoreErrors) {
-                            throw error_8;
-                        }
-                        return [3 /*break*/, 9];
-                    case 9: return [2 /*return*/, results.records];
+    async loadRawResults(queryRunner) {
+        const [sql, parameters] = this.getQueryAndParameters();
+        const queryId = sql + " -- PARAMETERS: " + JSON.stringify(parameters);
+        const cacheOptions = typeof this.connection.options.cache === "object"
+            ? this.connection.options.cache
+            : {};
+        let savedQueryResultCacheOptions = undefined;
+        let cacheError = false;
+        if (this.connection.queryResultCache &&
+            (this.expressionMap.cache || cacheOptions.alwaysEnabled)) {
+            try {
+                savedQueryResultCacheOptions =
+                    await this.connection.queryResultCache.getFromCache({
+                        identifier: this.expressionMap.cacheId,
+                        query: queryId,
+                        duration: this.expressionMap.cacheDuration ||
+                            cacheOptions.duration ||
+                            1000,
+                    }, queryRunner);
+                if (savedQueryResultCacheOptions &&
+                    !this.connection.queryResultCache.isExpired(savedQueryResultCacheOptions)) {
+                    return JSON.parse(savedQueryResultCacheOptions.result);
                 }
-            });
-        });
-    };
+            }
+            catch (error) {
+                if (!cacheOptions.ignoreErrors) {
+                    throw error;
+                }
+                cacheError = true;
+            }
+        }
+        const results = await queryRunner.query(sql, parameters, true);
+        if (!cacheError &&
+            this.connection.queryResultCache &&
+            (this.expressionMap.cache || cacheOptions.alwaysEnabled)) {
+            try {
+                await this.connection.queryResultCache.storeInCache({
+                    identifier: this.expressionMap.cacheId,
+                    query: queryId,
+                    time: new Date().getTime(),
+                    duration: this.expressionMap.cacheDuration ||
+                        cacheOptions.duration ||
+                        1000,
+                    result: JSON.stringify(results.records),
+                }, savedQueryResultCacheOptions, queryRunner);
+            }
+            catch (error) {
+                if (!cacheOptions.ignoreErrors) {
+                    throw error;
+                }
+            }
+        }
+        return results.records;
+    }
     /**
      * Merges into expression map given expression map properties.
      */
-    SelectQueryBuilder.prototype.mergeExpressionMap = function (expressionMap) {
+    mergeExpressionMap(expressionMap) {
         ObjectUtils_1.ObjectUtils.assign(this.expressionMap, expressionMap);
         return this;
-    };
+    }
     /**
      * Normalizes a give number - converts to int if possible.
      */
-    SelectQueryBuilder.prototype.normalizeNumber = function (num) {
+    normalizeNumber(num) {
         if (typeof num === "number" || num === undefined || num === null)
             return num;
         return Number(num);
-    };
+    }
     /**
      * Creates a query builder used to execute sql queries inside this query builder.
      */
-    SelectQueryBuilder.prototype.obtainQueryRunner = function () {
+    obtainQueryRunner() {
         return this.queryRunner || this.connection.createQueryRunner("slave");
-    };
-    SelectQueryBuilder.prototype.buildSelect = function (select, metadata, alias, embedPrefix) {
-        for (var key in select) {
+    }
+    buildSelect(select, metadata, alias, embedPrefix) {
+        for (let key in select) {
             if (select[key] === undefined || select[key] === false)
                 continue;
-            var propertyPath = embedPrefix ? embedPrefix + "." + key : key;
-            var column = metadata.findColumnWithPropertyPathStrict(propertyPath);
-            var embed = metadata.findEmbeddedWithPropertyPath(propertyPath);
-            var relation = metadata.findRelationWithPropertyPath(propertyPath);
+            const propertyPath = embedPrefix ? embedPrefix + "." + key : key;
+            const column = metadata.findColumnWithPropertyPathStrict(propertyPath);
+            const embed = metadata.findEmbeddedWithPropertyPath(propertyPath);
+            const relation = metadata.findRelationWithPropertyPath(propertyPath);
             if (!embed && !column && !relation)
                 throw new EntityPropertyNotFoundError_1.EntityPropertyNotFoundError(propertyPath, metadata);
             if (column) {
@@ -2388,36 +2145,35 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
                 //     this.buildOrder(select[key] as FindOptionsOrder<any>, relation.inverseEntityMetadata, joinAlias);
             }
         }
-    };
-    SelectQueryBuilder.prototype.buildRelations = function (relations, selection, metadata, alias, embedPrefix) {
-        var _this = this;
+    }
+    buildRelations(relations, selection, metadata, alias, embedPrefix) {
         if (!relations)
             return;
-        Object.keys(relations).forEach(function (relationName) {
-            var relationValue = relations[relationName];
-            var propertyPath = embedPrefix
+        Object.keys(relations).forEach((relationName) => {
+            const relationValue = relations[relationName];
+            const propertyPath = embedPrefix
                 ? embedPrefix + "." + relationName
                 : relationName;
-            var embed = metadata.findEmbeddedWithPropertyPath(propertyPath);
-            var relation = metadata.findRelationWithPropertyPath(propertyPath);
+            const embed = metadata.findEmbeddedWithPropertyPath(propertyPath);
+            const relation = metadata.findRelationWithPropertyPath(propertyPath);
             if (!embed && !relation)
                 throw new EntityPropertyNotFoundError_1.EntityPropertyNotFoundError(propertyPath, metadata);
             if (embed) {
-                _this.buildRelations(relationValue, typeof selection === "object"
+                this.buildRelations(relationValue, typeof selection === "object"
                     ? OrmUtils_1.OrmUtils.deepValue(selection, embed.propertyPath)
                     : undefined, metadata, alias, propertyPath);
             }
             else if (relation) {
-                var joinAlias = alias + "_" + propertyPath.replace(".", "_");
-                joinAlias = DriverUtils_1.DriverUtils.buildAlias(_this.connection.driver, { joiner: "__" }, alias, joinAlias);
+                let joinAlias = alias + "_" + propertyPath.replace(".", "_");
+                joinAlias = DriverUtils_1.DriverUtils.buildAlias(this.connection.driver, { joiner: "__" }, alias, joinAlias);
                 if (relationValue === true ||
                     typeof relationValue === "object") {
-                    if (_this.expressionMap.relationLoadStrategy === "query") {
-                        _this.relationMetadatas.push(relation);
+                    if (this.expressionMap.relationLoadStrategy === "query") {
+                        this.relationMetadatas.push(relation);
                     }
                     else {
                         // join
-                        _this.joins.push({
+                        this.joins.push({
                             type: "left",
                             select: true,
                             selection: selection &&
@@ -2430,86 +2186,85 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
                         });
                         if (selection &&
                             typeof selection[relationName] === "object") {
-                            _this.buildSelect(// @ts-ignore
+                            this.buildSelect(// @ts-ignore
                             selection[relationName], relation.inverseEntityMetadata, joinAlias);
                         }
                     }
                 }
                 if (typeof relationValue === "object" &&
-                    _this.expressionMap.relationLoadStrategy === "join") {
-                    _this.buildRelations(relationValue, typeof selection === "object"
+                    this.expressionMap.relationLoadStrategy === "join") {
+                    this.buildRelations(relationValue, typeof selection === "object"
                         ? OrmUtils_1.OrmUtils.deepValue(selection, relation.propertyPath)
                         : undefined, relation.inverseEntityMetadata, joinAlias, undefined);
                 }
             }
         });
-    };
-    SelectQueryBuilder.prototype.buildEagerRelations = function (relations, selection, metadata, alias, embedPrefix) {
-        var _this = this;
+    }
+    buildEagerRelations(relations, selection, metadata, alias, embedPrefix) {
         if (!relations)
             return;
-        Object.keys(relations).forEach(function (relationName) {
-            var relationValue = relations[relationName];
-            var propertyPath = embedPrefix
+        Object.keys(relations).forEach((relationName) => {
+            const relationValue = relations[relationName];
+            const propertyPath = embedPrefix
                 ? embedPrefix + "." + relationName
                 : relationName;
-            var embed = metadata.findEmbeddedWithPropertyPath(propertyPath);
-            var relation = metadata.findRelationWithPropertyPath(propertyPath);
+            const embed = metadata.findEmbeddedWithPropertyPath(propertyPath);
+            const relation = metadata.findRelationWithPropertyPath(propertyPath);
             if (!embed && !relation)
                 throw new EntityPropertyNotFoundError_1.EntityPropertyNotFoundError(propertyPath, metadata);
             if (embed) {
-                _this.buildEagerRelations(relationValue, typeof selection === "object"
+                this.buildEagerRelations(relationValue, typeof selection === "object"
                     ? OrmUtils_1.OrmUtils.deepValue(selection, embed.propertyPath)
                     : undefined, metadata, alias, propertyPath);
             }
             else if (relation) {
-                var joinAlias_1 = alias + "_" + propertyPath.replace(".", "_");
-                joinAlias_1 = DriverUtils_1.DriverUtils.buildAlias(_this.connection.driver, { joiner: "__" }, alias, joinAlias_1);
+                let joinAlias = alias + "_" + propertyPath.replace(".", "_");
+                joinAlias = DriverUtils_1.DriverUtils.buildAlias(this.connection.driver, { joiner: "__" }, alias, joinAlias);
                 if (relationValue === true ||
                     typeof relationValue === "object") {
-                    relation.inverseEntityMetadata.eagerRelations.forEach(function (eagerRelation) {
-                        var eagerRelationJoinAlias = joinAlias_1 +
+                    relation.inverseEntityMetadata.eagerRelations.forEach((eagerRelation) => {
+                        let eagerRelationJoinAlias = joinAlias +
                             "_" +
                             eagerRelation.propertyPath.replace(".", "_");
-                        eagerRelationJoinAlias = DriverUtils_1.DriverUtils.buildAlias(_this.connection.driver, { joiner: "__" }, joinAlias_1, eagerRelationJoinAlias);
-                        var existJoin = _this.joins.find(function (join) { return join.alias === eagerRelationJoinAlias; });
+                        eagerRelationJoinAlias = DriverUtils_1.DriverUtils.buildAlias(this.connection.driver, { joiner: "__" }, joinAlias, eagerRelationJoinAlias);
+                        const existJoin = this.joins.find((join) => join.alias === eagerRelationJoinAlias);
                         if (!existJoin) {
-                            _this.joins.push({
+                            this.joins.push({
                                 type: "left",
                                 select: true,
                                 alias: eagerRelationJoinAlias,
-                                parentAlias: joinAlias_1,
+                                parentAlias: joinAlias,
                                 selection: undefined,
                                 relationMetadata: eagerRelation,
                             });
                         }
                         if (selection &&
                             typeof selection[relationName] === "object") {
-                            _this.buildSelect(// @ts-ignore
-                            selection[relationName], relation.inverseEntityMetadata, joinAlias_1);
+                            this.buildSelect(// @ts-ignore
+                            selection[relationName], relation.inverseEntityMetadata, joinAlias);
                         }
                     });
                 }
                 if (typeof relationValue === "object") {
-                    _this.buildEagerRelations(relationValue, typeof selection === "object"
+                    this.buildEagerRelations(relationValue, typeof selection === "object"
                         ? OrmUtils_1.OrmUtils.deepValue(selection, relation.propertyPath)
-                        : undefined, relation.inverseEntityMetadata, joinAlias_1, undefined);
+                        : undefined, relation.inverseEntityMetadata, joinAlias, undefined);
                 }
             }
         });
-    };
-    SelectQueryBuilder.prototype.buildOrder = function (order, metadata, alias, embedPrefix) {
-        var _loop_1 = function (key) {
+    }
+    buildOrder(order, metadata, alias, embedPrefix) {
+        for (let key in order) {
             if (order[key] === undefined)
-                return "continue";
-            var propertyPath = embedPrefix ? embedPrefix + "." + key : key;
-            var column = metadata.findColumnWithPropertyPathStrict(propertyPath);
-            var embed = metadata.findEmbeddedWithPropertyPath(propertyPath);
-            var relation = metadata.findRelationWithPropertyPath(propertyPath);
+                continue;
+            const propertyPath = embedPrefix ? embedPrefix + "." + key : key;
+            const column = metadata.findColumnWithPropertyPathStrict(propertyPath);
+            const embed = metadata.findEmbeddedWithPropertyPath(propertyPath);
+            const relation = metadata.findRelationWithPropertyPath(propertyPath);
             if (!embed && !column && !relation)
                 throw new EntityPropertyNotFoundError_1.EntityPropertyNotFoundError(propertyPath, metadata);
             if (column) {
-                var direction = typeof order[key] === "object"
+                let direction = typeof order[key] === "object"
                     ? order[key].direction
                     : order[key];
                 direction =
@@ -2518,93 +2273,88 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
                         direction === -1
                         ? "DESC"
                         : "ASC";
-                var nulls = typeof order[key] === "object"
+                let nulls = typeof order[key] === "object"
                     ? order[key].nulls
                     : undefined;
                 nulls =
-                    (nulls === null || nulls === void 0 ? void 0 : nulls.toLowerCase()) === "first"
+                    nulls?.toLowerCase() === "first"
                         ? "NULLS FIRST"
-                        : (nulls === null || nulls === void 0 ? void 0 : nulls.toLowerCase()) === "last"
+                        : nulls?.toLowerCase() === "last"
                             ? "NULLS LAST"
                             : undefined;
-                var aliasPath_1 = "".concat(alias, ".").concat(propertyPath);
+                let aliasPath = `${alias}.${propertyPath}`;
                 if (column.isVirtualProperty && column.query) {
-                    var selection = this_1.expressionMap.selects.find(function (s) { return s.selection === aliasPath_1; });
+                    const selection = this.expressionMap.selects.find((s) => s.selection === aliasPath);
                     if (selection) {
                         // this is not building correctly now???
-                        aliasPath_1 = DriverUtils_1.DriverUtils.buildAlias(this_1.connection.driver, alias, column.databaseName);
-                        selection.aliasName = aliasPath_1;
+                        aliasPath = DriverUtils_1.DriverUtils.buildAlias(this.connection.driver, alias, column.databaseName);
+                        selection.aliasName = aliasPath;
                     }
                     else {
-                        aliasPath_1 = "(".concat(column.query(alias), ")");
+                        aliasPath = `(${column.query(alias)})`;
                     }
                 }
-                this_1.addOrderBy(aliasPath_1, direction, nulls);
+                this.addOrderBy(aliasPath, direction, nulls);
                 // this.orderBys.push({ alias: alias + "." + propertyPath, direction, nulls });
             }
             else if (embed) {
-                this_1.buildOrder(order[key], metadata, alias, propertyPath);
+                this.buildOrder(order[key], metadata, alias, propertyPath);
             }
             else if (relation) {
-                var joinAlias_2 = alias + "_" + propertyPath.replace(".", "_");
-                joinAlias_2 = DriverUtils_1.DriverUtils.buildAlias(this_1.connection.driver, { joiner: "__" }, alias, joinAlias_2);
+                let joinAlias = alias + "_" + propertyPath.replace(".", "_");
+                joinAlias = DriverUtils_1.DriverUtils.buildAlias(this.connection.driver, { joiner: "__" }, alias, joinAlias);
                 // console.log("joinAlias", joinAlias, joinAlias.length, this.connection.driver.maxAliasLength)
                 // todo: use expressionMap.joinAttributes, and create a new one using
                 //  const joinAttribute = new JoinAttribute(this.connection, this.expressionMap);
-                var existJoin = this_1.joins.find(function (join) { return join.alias === joinAlias_2; });
+                const existJoin = this.joins.find((join) => join.alias === joinAlias);
                 if (!existJoin) {
-                    this_1.joins.push({
+                    this.joins.push({
                         type: "left",
                         select: false,
-                        alias: joinAlias_2,
+                        alias: joinAlias,
                         parentAlias: alias,
                         selection: undefined,
                         relationMetadata: relation,
                     });
                 }
-                this_1.buildOrder(order[key], relation.inverseEntityMetadata, joinAlias_2);
+                this.buildOrder(order[key], relation.inverseEntityMetadata, joinAlias);
             }
-        };
-        var this_1 = this;
-        for (var key in order) {
-            _loop_1(key);
-        }
-    };
-    SelectQueryBuilder.prototype.buildWhere = function (where, metadata, alias, embedPrefix) {
-        var _this = this;
-        var condition = "";
+        }
+    }
+    buildWhere(where, metadata, alias, embedPrefix) {
+        let condition = "";
         // let parameterIndex = Object.keys(this.expressionMap.nativeParameters).length;
         if (Array.isArray(where)) {
             condition =
                 "(" +
                     where
-                        .map(function (whereItem) {
-                        return _this.buildWhere(whereItem, metadata, alias, embedPrefix);
+                        .map((whereItem) => {
+                        return this.buildWhere(whereItem, metadata, alias, embedPrefix);
                     })
-                        .filter(function (condition) { return !!condition; })
-                        .map(function (condition) { return "(" + condition + ")"; })
+                        .filter((condition) => !!condition)
+                        .map((condition) => "(" + condition + ")")
                         .join(" OR ") +
                     ")";
         }
         else {
-            var andConditions = [];
-            var _loop_2 = function (key) {
+            let andConditions = [];
+            for (let key in where) {
                 if (where[key] === undefined || where[key] === null)
-                    return "continue";
-                var propertyPath = embedPrefix ? embedPrefix + "." + key : key;
-                var column = metadata.findColumnWithPropertyPathStrict(propertyPath);
-                var embed = metadata.findEmbeddedWithPropertyPath(propertyPath);
-                var relation = metadata.findRelationWithPropertyPath(propertyPath);
+                    continue;
+                const propertyPath = embedPrefix ? embedPrefix + "." + key : key;
+                const column = metadata.findColumnWithPropertyPathStrict(propertyPath);
+                const embed = metadata.findEmbeddedWithPropertyPath(propertyPath);
+                const relation = metadata.findRelationWithPropertyPath(propertyPath);
                 if (!embed && !column && !relation)
                     throw new EntityPropertyNotFoundError_1.EntityPropertyNotFoundError(propertyPath, metadata);
                 if (column) {
-                    var aliasPath = "".concat(alias, ".").concat(propertyPath);
+                    let aliasPath = `${alias}.${propertyPath}`;
                     if (column.isVirtualProperty && column.query) {
-                        aliasPath = "(".concat(column.query(alias), ")");
+                        aliasPath = `(${column.query(alias)})`;
                     }
                     // const parameterName = alias + "_" + propertyPath.split(".").join("_") + "_" + parameterIndex;
                     // todo: we need to handle other operators as well?
-                    var parameterValue = where[key];
+                    let parameterValue = where[key];
                     if (InstanceChecker_1.InstanceChecker.isEqualOperator(where[key])) {
                         parameterValue = where[key].value;
                     }
@@ -2642,37 +2392,37 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
                     //     const parameter = this.connection.driver.createParameter(parameterName, parameterIndex - 1);
                     //     andConditions.push(`${aliasPath} = ${parameter}`);
                     // }
-                    andConditions.push(this_2.createWhereConditionExpression(this_2.getWherePredicateCondition(aliasPath, parameterValue)));
+                    andConditions.push(this.createWhereConditionExpression(this.getWherePredicateCondition(aliasPath, parameterValue)));
                     // this.conditions.push(`${alias}.${propertyPath} = :${paramName}`);
                     // this.expressionMap.parameters[paramName] = where[key]; // todo: handle functions and other edge cases
                 }
                 else if (embed) {
-                    var condition_1 = this_2.buildWhere(where[key], metadata, alias, propertyPath);
-                    if (condition_1)
-                        andConditions.push(condition_1);
+                    const condition = this.buildWhere(where[key], metadata, alias, propertyPath);
+                    if (condition)
+                        andConditions.push(condition);
                 }
                 else if (relation) {
                     // if all properties of where are undefined we don't need to join anything
                     // this can happen when user defines map with conditional queries inside
                     if (typeof where[key] === "object") {
-                        var allAllUndefined = Object.keys(where[key]).every(function (k) { return where[key][k] === undefined; });
+                        const allAllUndefined = Object.keys(where[key]).every((k) => where[key][k] === undefined);
                         if (allAllUndefined) {
-                            return "continue";
+                            continue;
                         }
                     }
                     if (InstanceChecker_1.InstanceChecker.isFindOperator(where[key])) {
                         if (where[key].type === "moreThan" ||
                             where[key].type === "lessThan") {
-                            var sqlOperator = where[key].type === "moreThan" ? ">" : "<";
+                            const sqlOperator = where[key].type === "moreThan" ? ">" : "<";
                             // basically relation count functionality
-                            var qb = this_2.subQuery();
+                            const qb = this.subQuery();
                             if (relation.isManyToManyOwner) {
                                 qb.select("COUNT(*)")
                                     .from(relation.joinTableName, relation.joinTableName)
                                     .where(relation.joinColumns
-                                    .map(function (column) {
-                                    return "".concat(relation.joinTableName, ".").concat(column.propertyName, " = ").concat(alias, ".").concat(column.referencedColumn
-                                        .propertyName);
+                                    .map((column) => {
+                                    return `${relation.joinTableName}.${column.propertyName} = ${alias}.${column.referencedColumn
+                                        .propertyName}`;
                                 })
                                     .join(" AND "));
                             }
@@ -2680,10 +2430,10 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
                                 qb.select("COUNT(*)")
                                     .from(relation.inverseRelation.joinTableName, relation.inverseRelation.joinTableName)
                                     .where(relation
-                                    .inverseRelation.inverseJoinColumns.map(function (column) {
-                                    return "".concat(relation.inverseRelation
-                                        .joinTableName, ".").concat(column.propertyName, " = ").concat(alias, ".").concat(column.referencedColumn
-                                        .propertyName);
+                                    .inverseRelation.inverseJoinColumns.map((column) => {
+                                    return `${relation.inverseRelation
+                                        .joinTableName}.${column.propertyName} = ${alias}.${column.referencedColumn
+                                        .propertyName}`;
                                 })
                                     .join(" AND "));
                             }
@@ -2692,21 +2442,21 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
                                     .from(relation.inverseEntityMetadata.target, relation.inverseEntityMetadata
                                     .tableName)
                                     .where(relation
-                                    .inverseRelation.joinColumns.map(function (column) {
-                                    return "".concat(relation
+                                    .inverseRelation.joinColumns.map((column) => {
+                                    return `${relation
                                         .inverseEntityMetadata
-                                        .tableName, ".").concat(column.propertyName, " = ").concat(alias, ".").concat(column.referencedColumn
-                                        .propertyName);
+                                        .tableName}.${column.propertyName} = ${alias}.${column.referencedColumn
+                                        .propertyName}`;
                                 })
                                     .join(" AND "));
                             }
                             else {
-                                throw new Error("This relation isn't supported by given find operator");
+                                throw new Error(`This relation isn't supported by given find operator`);
                             }
                             // this
                             //     .addSelect(qb.getSql(), relation.propertyAliasName + "_cnt")
                             //     .andWhere(this.escape(relation.propertyAliasName + "_cnt") + " " + sqlOperator + " " + parseInt(where[key].value));
-                            this_2.andWhere(qb.getSql() +
+                            this.andWhere(qb.getSql() +
                                 " " +
                                 sqlOperator +
                                 " " +
@@ -2716,27 +2466,27 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
                             if (relation.isManyToOne ||
                                 (relation.isOneToOne &&
                                     relation.isOneToOneOwner)) {
-                                var aliasPath = "".concat(alias, ".").concat(propertyPath);
-                                andConditions.push(this_2.createWhereConditionExpression(this_2.getWherePredicateCondition(aliasPath, where[key])));
+                                const aliasPath = `${alias}.${propertyPath}`;
+                                andConditions.push(this.createWhereConditionExpression(this.getWherePredicateCondition(aliasPath, where[key])));
                             }
                             else {
-                                throw new Error("This relation isn't supported by given find operator");
+                                throw new Error(`This relation isn't supported by given find operator`);
                             }
                         }
                     }
                     else {
                         // const joinAlias = alias + "_" + relation.propertyName;
-                        var joinAlias_3 = alias +
+                        let joinAlias = alias +
                             "_" +
                             relation.propertyPath.replace(".", "_");
-                        joinAlias_3 = DriverUtils_1.DriverUtils.buildAlias(this_2.connection.driver, { joiner: "__" }, alias, joinAlias_3);
-                        var existJoin = this_2.joins.find(function (join) { return join.alias === joinAlias_3; });
+                        joinAlias = DriverUtils_1.DriverUtils.buildAlias(this.connection.driver, { joiner: "__" }, alias, joinAlias);
+                        const existJoin = this.joins.find((join) => join.alias === joinAlias);
                         if (!existJoin) {
-                            this_2.joins.push({
+                            this.joins.push({
                                 type: "inner",
                                 select: false,
                                 selection: undefined,
-                                alias: joinAlias_3,
+                                alias: joinAlias,
                                 parentAlias: alias,
                                 relationMetadata: relation,
                             });
@@ -2745,27 +2495,21 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
                             if (existJoin.type === "left")
                                 existJoin.type = "inner";
                         }
-                        var condition_2 = this_2.buildWhere(where[key], relation.inverseEntityMetadata, joinAlias_3);
-                        if (condition_2) {
-                            andConditions.push(condition_2);
+                        const condition = this.buildWhere(where[key], relation.inverseEntityMetadata, joinAlias);
+                        if (condition) {
+                            andConditions.push(condition);
                             // parameterIndex = Object.keys(this.expressionMap.nativeParameters).length;
                         }
                     }
                 }
-            };
-            var this_2 = this;
-            for (var key in where) {
-                _loop_2(key);
             }
             condition = andConditions.join(" AND ");
         }
         return condition;
-    };
-    var SelectQueryBuilder_1;
-    SelectQueryBuilder = SelectQueryBuilder_1 = tslib_1.__decorate([
-        typescript_class_helpers_1.CLASS.NAME('SelectQueryBuilder')
-    ], SelectQueryBuilder);
-    return SelectQueryBuilder;
-}(QueryBuilder_1.QueryBuilder));
+    }
+};
 exports.SelectQueryBuilder = SelectQueryBuilder;
+exports.SelectQueryBuilder = SelectQueryBuilder = SelectQueryBuilder_1 = __decorate([
+    typescript_class_helpers_1.CLASS.NAME('SelectQueryBuilder')
+], SelectQueryBuilder);
 //# sourceMappingURL=SelectQueryBuilder.js.map