taon-typeorm 18.0.19 → 18.0.21

package/lib/typeorm/entity-manager/EntityManager.js

@@ -1,49 +1,60 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EntityManager = void 0;
-var tslib_1 = require("tslib");
-var EntityNotFoundError_1 = require("../error/EntityNotFoundError");
-var QueryRunnerProviderAlreadyReleasedError_1 = require("../error/QueryRunnerProviderAlreadyReleasedError");
-var NoNeedToReleaseEntityManagerError_1 = require("../error/NoNeedToReleaseEntityManagerError");
+const EntityNotFoundError_1 = require("../error/EntityNotFoundError");
+const QueryRunnerProviderAlreadyReleasedError_1 = require("../error/QueryRunnerProviderAlreadyReleasedError");
+const NoNeedToReleaseEntityManagerError_1 = require("../error/NoNeedToReleaseEntityManagerError");
 //#region @backend
-var MongoRepository_1 = require("../repository/MongoRepository");
+const MongoRepository_1 = require("../repository/MongoRepository");
 //#endregion
-var TreeRepository_1 = require("../repository/TreeRepository");
-var Repository_1 = require("../repository/Repository");
-var FindOptionsUtils_1 = require("../find-options/FindOptionsUtils");
-var PlainObjectToNewEntityTransformer_1 = require("../query-builder/transformer/PlainObjectToNewEntityTransformer");
-var PlainObjectToDatabaseEntityTransformer_1 = require("../query-builder/transformer/PlainObjectToDatabaseEntityTransformer");
-var error_1 = require("../error");
-var AbstractRepository_1 = require("../repository/AbstractRepository");
-var EntityPersistExecutor_1 = require("../persistence/EntityPersistExecutor");
-var ObjectUtils_1 = require("../util/ObjectUtils");
-var globals_1 = require("../globals");
-var InstanceChecker_1 = require("../util/InstanceChecker");
+const TreeRepository_1 = require("../repository/TreeRepository");
+const Repository_1 = require("../repository/Repository");
+const FindOptionsUtils_1 = require("../find-options/FindOptionsUtils");
+const PlainObjectToNewEntityTransformer_1 = require("../query-builder/transformer/PlainObjectToNewEntityTransformer");
+const PlainObjectToDatabaseEntityTransformer_1 = require("../query-builder/transformer/PlainObjectToDatabaseEntityTransformer");
+const error_1 = require("../error");
+const AbstractRepository_1 = require("../repository/AbstractRepository");
+const EntityPersistExecutor_1 = require("../persistence/EntityPersistExecutor");
+const ObjectUtils_1 = require("../util/ObjectUtils");
+const globals_1 = require("../globals");
+const InstanceChecker_1 = require("../util/InstanceChecker");
 /**
  * Entity manager supposed to work with any entity, automatically find its repository and call its methods,
  * whatever entity type are you passing.
  */
-var EntityManager = /** @class */ (function () {
+class EntityManager {
+    "@instanceof" = Symbol.for("EntityManager");
+    // -------------------------------------------------------------------------
+    // Public Properties
+    // -------------------------------------------------------------------------
+    /**
+     * Connection used by this entity manager.
+     */
+    connection;
+    /**
+     * Custom query runner to be used for operations in this entity manager.
+     * Used only in non-global entity manager.
+     */
+    queryRunner;
+    // -------------------------------------------------------------------------
+    // Protected Properties
+    // -------------------------------------------------------------------------
+    /**
+     * Once created and then reused by repositories.
+     */
+    repositories = [];
+    /**
+     * Once created and then reused by repositories.
+     */
+    treeRepositories = [];
+    /**
+     * Plain to object transformer used in create and merge operations.
+     */
+    plainObjectToEntityTransformer = new PlainObjectToNewEntityTransformer_1.PlainObjectToNewEntityTransformer();
     // -------------------------------------------------------------------------
     // Constructor
     // -------------------------------------------------------------------------
-    function EntityManager(connection, queryRunner) {
-        this["@instanceof"] = Symbol.for("EntityManager");
-        // -------------------------------------------------------------------------
-        // Protected Properties
-        // -------------------------------------------------------------------------
-        /**
-         * Once created and then reused by repositories.
-         */
-        this.repositories = [];
-        /**
-         * Once created and then reused by repositories.
-         */
-        this.treeRepositories = [];
-        /**
-         * Plain to object transformer used in create and merge operations.
-         */
-        this.plainObjectToEntityTransformer = new PlainObjectToNewEntityTransformer_1.PlainObjectToNewEntityTransformer();
+    constructor(connection, queryRunner) {
         this.connection = connection;
         if (queryRunner) {
             this.queryRunner = queryRunner;
@@ -55,80 +66,51 @@ var EntityManager = /** @class */ (function () {
      * Wraps given function execution (and all operations made there) in a transaction.
      * All database operations must be executed using provided entity manager.
      */
-    EntityManager.prototype.transaction = function (isolationOrRunInTransaction, runInTransactionParam) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var isolation, runInTransaction, queryRunner, result, err_1, rollbackError_1;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        isolation = typeof isolationOrRunInTransaction === "string"
-                            ? isolationOrRunInTransaction
-                            : undefined;
-                        runInTransaction = typeof isolationOrRunInTransaction === "function"
-                            ? isolationOrRunInTransaction
-                            : runInTransactionParam;
-                        if (!runInTransaction) {
-                            throw new error_1.TypeORMError("Transaction method requires callback in second parameter if isolation level is supplied.");
-                        }
-                        if (this.queryRunner && this.queryRunner.isReleased)
-                            throw new QueryRunnerProviderAlreadyReleasedError_1.QueryRunnerProviderAlreadyReleasedError();
-                        queryRunner = this.queryRunner || this.connection.createQueryRunner();
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 5, 10, 13]);
-                        return [4 /*yield*/, queryRunner.startTransaction(isolation)];
-                    case 2:
-                        _a.sent();
-                        return [4 /*yield*/, runInTransaction(queryRunner.manager)];
-                    case 3:
-                        result = _a.sent();
-                        return [4 /*yield*/, queryRunner.commitTransaction()];
-                    case 4:
-                        _a.sent();
-                        return [2 /*return*/, result];
-                    case 5:
-                        err_1 = _a.sent();
-                        _a.label = 6;
-                    case 6:
-                        _a.trys.push([6, 8, , 9]);
-                        // we throw original error even if rollback thrown an error
-                        return [4 /*yield*/, queryRunner.rollbackTransaction()];
-                    case 7:
-                        // we throw original error even if rollback thrown an error
-                        _a.sent();
-                        return [3 /*break*/, 9];
-                    case 8:
-                        rollbackError_1 = _a.sent();
-                        return [3 /*break*/, 9];
-                    case 9: throw err_1;
-                    case 10:
-                        if (!!this.queryRunner) return [3 /*break*/, 12];
-                        // if we used a new query runner provider then release it
-                        return [4 /*yield*/, queryRunner.release()];
-                    case 11:
-                        // if we used a new query runner provider then release it
-                        _a.sent();
-                        _a.label = 12;
-                    case 12: return [7 /*endfinally*/];
-                    case 13: return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async transaction(isolationOrRunInTransaction, runInTransactionParam) {
+        const isolation = typeof isolationOrRunInTransaction === "string"
+            ? isolationOrRunInTransaction
+            : undefined;
+        const runInTransaction = typeof isolationOrRunInTransaction === "function"
+            ? isolationOrRunInTransaction
+            : runInTransactionParam;
+        if (!runInTransaction) {
+            throw new error_1.TypeORMError(`Transaction method requires callback in second parameter if isolation level is supplied.`);
+        }
+        if (this.queryRunner && this.queryRunner.isReleased)
+            throw new QueryRunnerProviderAlreadyReleasedError_1.QueryRunnerProviderAlreadyReleasedError();
+        // if query runner is already defined in this class, it means this entity manager was already created for a single connection
+        // if its not defined we create a new query runner - single connection where we'll execute all our operations
+        const queryRunner = this.queryRunner || this.connection.createQueryRunner();
+        try {
+            await queryRunner.startTransaction(isolation);
+            const result = await runInTransaction(queryRunner.manager);
+            await queryRunner.commitTransaction();
+            return result;
+        }
+        catch (err) {
+            try {
+                // we throw original error even if rollback thrown an error
+                await queryRunner.rollbackTransaction();
+            }
+            catch (rollbackError) { }
+            throw err;
+        }
+        finally {
+            if (!this.queryRunner)
+                // if we used a new query runner provider then release it
+                await queryRunner.release();
+        }
+    }
     /**
      * Executes raw SQL query and returns raw database results.
      */
-    EntityManager.prototype.query = function (query, parameters) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                return [2 /*return*/, this.connection.query(query, parameters, this.queryRunner)];
-            });
-        });
-    };
+    async query(query, parameters) {
+        return this.connection.query(query, parameters, this.queryRunner);
+    }
     /**
      * Creates a new query builder that can be used to build a SQL query.
      */
-    EntityManager.prototype.createQueryBuilder = function (entityClass, alias, queryRunner) {
+    createQueryBuilder(entityClass, alias, queryRunner) {
         if (alias) {
             return this.connection.createQueryBuilder(entityClass, alias, queryRunner || this.queryRunner);
         }
@@ -137,95 +119,77 @@ var EntityManager = /** @class */ (function () {
                 queryRunner ||
                 this.queryRunner);
         }
-    };
+    }
     /**
      * Checks if entity has an id by its Function type or schema name.
      */
-    EntityManager.prototype.hasId = function (targetOrEntity, maybeEntity) {
-        var target = arguments.length === 2 ? targetOrEntity : targetOrEntity.constructor;
-        var entity = arguments.length === 2 ? maybeEntity : targetOrEntity;
-        var metadata = this.connection.getMetadata(target);
+    hasId(targetOrEntity, maybeEntity) {
+        const target = arguments.length === 2 ? targetOrEntity : targetOrEntity.constructor;
+        const entity = arguments.length === 2 ? maybeEntity : targetOrEntity;
+        const metadata = this.connection.getMetadata(target);
         return metadata.hasId(entity);
-    };
+    }
     /**
      * Gets entity mixed id.
      */
-    EntityManager.prototype.getId = function (targetOrEntity, maybeEntity) {
-        var target = arguments.length === 2 ? targetOrEntity : targetOrEntity.constructor;
-        var entity = arguments.length === 2 ? maybeEntity : targetOrEntity;
-        var metadata = this.connection.getMetadata(target);
+    getId(targetOrEntity, maybeEntity) {
+        const target = arguments.length === 2 ? targetOrEntity : targetOrEntity.constructor;
+        const entity = arguments.length === 2 ? maybeEntity : targetOrEntity;
+        const metadata = this.connection.getMetadata(target);
         return metadata.getEntityIdMixedMap(entity);
-    };
+    }
     /**
      * Creates a new entity instance or instances.
      * Can copy properties from the given object into new entities.
      */
-    EntityManager.prototype.create = function (entityClass, plainObjectOrObjects) {
-        var _this = this;
-        var metadata = this.connection.getMetadata(entityClass);
+    create(entityClass, plainObjectOrObjects) {
+        const metadata = this.connection.getMetadata(entityClass);
         if (!plainObjectOrObjects)
             return metadata.create(this.queryRunner);
         if (Array.isArray(plainObjectOrObjects))
-            return plainObjectOrObjects.map(function (plainEntityLike) { return _this.create(entityClass, plainEntityLike); });
-        var mergeIntoEntity = metadata.create(this.queryRunner);
+            return plainObjectOrObjects.map((plainEntityLike) => this.create(entityClass, plainEntityLike));
+        const mergeIntoEntity = metadata.create(this.queryRunner);
         this.plainObjectToEntityTransformer.transform(mergeIntoEntity, plainObjectOrObjects, metadata, true);
         return mergeIntoEntity;
-    };
+    }
     /**
      * Merges two entities into one new entity.
      */
-    EntityManager.prototype.merge = function (entityClass, mergeIntoEntity) {
-        var _this = this;
-        var entityLikes = [];
-        for (var _i = 2; _i < arguments.length; _i++) {
-            entityLikes[_i - 2] = arguments[_i];
-        }
+    merge(entityClass, mergeIntoEntity, ...entityLikes) {
         // todo: throw exception if entity manager is released
-        var metadata = this.connection.getMetadata(entityClass);
-        entityLikes.forEach(function (object) {
-            return _this.plainObjectToEntityTransformer.transform(mergeIntoEntity, object, metadata);
-        });
+        const metadata = this.connection.getMetadata(entityClass);
+        entityLikes.forEach((object) => this.plainObjectToEntityTransformer.transform(mergeIntoEntity, object, metadata));
         return mergeIntoEntity;
-    };
+    }
     /**
      * Creates a new entity from the given plain javascript object. If entity already exist in the database, then
      * it loads it (and everything related to it), replaces all values with the new ones from the given object
      * and returns this new entity. This new entity is actually a loaded from the db entity with all properties
      * replaced from the new object.
      */
-    EntityManager.prototype.preload = function (entityClass, entityLike) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var metadata, plainObjectToDatabaseEntityTransformer, transformedEntity;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        metadata = this.connection.getMetadata(entityClass);
-                        plainObjectToDatabaseEntityTransformer = new PlainObjectToDatabaseEntityTransformer_1.PlainObjectToDatabaseEntityTransformer(this.connection.manager);
-                        return [4 /*yield*/, plainObjectToDatabaseEntityTransformer.transform(entityLike, metadata)];
-                    case 1:
-                        transformedEntity = _a.sent();
-                        if (transformedEntity)
-                            return [2 /*return*/, this.merge(entityClass, transformedEntity, entityLike)];
-                        return [2 /*return*/, undefined];
-                }
-            });
-        });
-    };
+    async preload(entityClass, entityLike) {
+        const metadata = this.connection.getMetadata(entityClass);
+        const plainObjectToDatabaseEntityTransformer = new PlainObjectToDatabaseEntityTransformer_1.PlainObjectToDatabaseEntityTransformer(this.connection.manager);
+        const transformedEntity = await plainObjectToDatabaseEntityTransformer.transform(entityLike, metadata);
+        if (transformedEntity)
+            return this.merge(entityClass, transformedEntity, entityLike);
+        return undefined;
+    }
     /**
      * Saves a given entity in the database.
      */
-    EntityManager.prototype.save = function (targetOrEntity, maybeEntityOrOptions, maybeOptions) {
+    save(targetOrEntity, maybeEntityOrOptions, maybeOptions) {
         // normalize mixed parameters
-        var target = arguments.length > 1 &&
+        let target = arguments.length > 1 &&
             (typeof targetOrEntity === "function" ||
                 InstanceChecker_1.InstanceChecker.isEntitySchema(targetOrEntity) ||
                 typeof targetOrEntity === "string")
             ? targetOrEntity
             : undefined;
-        var entity = target
+        const entity = target
             ? maybeEntityOrOptions
             : targetOrEntity;
-        var options = target
+        const options = target
             ? maybeOptions
             : maybeEntityOrOptions;
         if (InstanceChecker_1.InstanceChecker.isEntitySchema(target))
@@ -236,23 +200,23 @@ var EntityManager = /** @class */ (function () {
         // execute save operation
         return new EntityPersistExecutor_1.EntityPersistExecutor(this.connection, this.queryRunner, "save", target, entity, options)
             .execute()
-            .then(function () { return entity; });
-    };
+            .then(() => entity);
+    }
     /**
      * Removes a given entity from the database.
      */
-    EntityManager.prototype.remove = function (targetOrEntity, maybeEntityOrOptions, maybeOptions) {
+    remove(targetOrEntity, maybeEntityOrOptions, maybeOptions) {
         // normalize mixed parameters
-        var target = arguments.length > 1 &&
+        const target = arguments.length > 1 &&
             (typeof targetOrEntity === "function" ||
                 InstanceChecker_1.InstanceChecker.isEntitySchema(targetOrEntity) ||
                 typeof targetOrEntity === "string")
             ? targetOrEntity
             : undefined;
-        var entity = target
+        const entity = target
             ? maybeEntityOrOptions
             : targetOrEntity;
-        var options = target
+        const options = target
             ? maybeOptions
             : maybeEntityOrOptions;
         // if user passed empty array of entities then we don't need to do anything
@@ -261,23 +225,23 @@ var EntityManager = /** @class */ (function () {
         // execute save operation
         return new EntityPersistExecutor_1.EntityPersistExecutor(this.connection, this.queryRunner, "remove", target, entity, options)
             .execute()
-            .then(function () { return entity; });
-    };
+            .then(() => entity);
+    }
     /**
      * Records the delete date of one or many given entities.
      */
-    EntityManager.prototype.softRemove = function (targetOrEntity, maybeEntityOrOptions, maybeOptions) {
+    softRemove(targetOrEntity, maybeEntityOrOptions, maybeOptions) {
         // normalize mixed parameters
-        var target = arguments.length > 1 &&
+        let target = arguments.length > 1 &&
             (typeof targetOrEntity === "function" ||
                 InstanceChecker_1.InstanceChecker.isEntitySchema(targetOrEntity) ||
                 typeof targetOrEntity === "string")
             ? targetOrEntity
             : undefined;
-        var entity = target
+        const entity = target
             ? maybeEntityOrOptions
             : targetOrEntity;
-        var options = target
+        const options = target
             ? maybeOptions
             : maybeEntityOrOptions;
         if (InstanceChecker_1.InstanceChecker.isEntitySchema(target))
@@ -288,23 +252,23 @@ var EntityManager = /** @class */ (function () {
         // execute soft-remove operation
         return new EntityPersistExecutor_1.EntityPersistExecutor(this.connection, this.queryRunner, "soft-remove", target, entity, options)
             .execute()
-            .then(function () { return entity; });
-    };
+            .then(() => entity);
+    }
     /**
      * Recovers one or many given entities.
      */
-    EntityManager.prototype.recover = function (targetOrEntity, maybeEntityOrOptions, maybeOptions) {
+    recover(targetOrEntity, maybeEntityOrOptions, maybeOptions) {
         // normalize mixed parameters
-        var target = arguments.length > 1 &&
+        let target = arguments.length > 1 &&
             (typeof targetOrEntity === "function" ||
                 InstanceChecker_1.InstanceChecker.isEntitySchema(targetOrEntity) ||
                 typeof targetOrEntity === "string")
             ? targetOrEntity
             : undefined;
-        var entity = target
+        const entity = target
             ? maybeEntityOrOptions
             : targetOrEntity;
-        var options = target
+        const options = target
             ? maybeOptions
             : maybeEntityOrOptions;
         if (InstanceChecker_1.InstanceChecker.isEntitySchema(target))
@@ -315,8 +279,8 @@ var EntityManager = /** @class */ (function () {
         // execute recover operation
         return new EntityPersistExecutor_1.EntityPersistExecutor(this.connection, this.queryRunner, "recover", target, entity, options)
             .execute()
-            .then(function () { return entity; });
-    };
+            .then(() => entity);
+    }
     /**
      * Inserts a given entity into the database.
      * Unlike save method executes a primitive operation without cascades, relations and other operations included.
@@ -324,54 +288,43 @@ var EntityManager = /** @class */ (function () {
      * Does not check if entity exist in the database, so query will fail if duplicate entity is being inserted.
      * You can execute bulk inserts using this method.
      */
-    EntityManager.prototype.insert = function (target, entity) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                return [2 /*return*/, this.createQueryBuilder()
-                        .insert()
-                        .into(target)
-                        .values(entity)
-                        .execute()];
-            });
-        });
-    };
-    EntityManager.prototype.upsert = function (target, entityOrEntities, conflictPathsOrOptions) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var metadata, options, entities, conflictColumns, overwriteColumns;
-            return tslib_1.__generator(this, function (_a) {
-                metadata = this.connection.getMetadata(target);
-                if (Array.isArray(conflictPathsOrOptions)) {
-                    options = {
-                        conflictPaths: conflictPathsOrOptions,
-                    };
-                }
-                else {
-                    options = conflictPathsOrOptions;
-                }
-                if (!Array.isArray(entityOrEntities)) {
-                    entities = [entityOrEntities];
-                }
-                else {
-                    entities = entityOrEntities;
-                }
-                conflictColumns = metadata.mapPropertyPathsToColumns(options.conflictPaths);
-                overwriteColumns = metadata.columns.filter(function (col) {
-                    return !conflictColumns.includes(col) &&
-                        entities.some(function (entity) {
-                            return typeof col.getEntityValue(entity) !== "undefined";
-                        });
-                });
-                return [2 /*return*/, this.createQueryBuilder()
-                        .insert()
-                        .into(target)
-                        .values(entities)
-                        .orUpdate(tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(conflictColumns), false), tslib_1.__read(overwriteColumns), false).map(function (col) { return col.databaseName; }), conflictColumns.map(function (col) { return col.databaseName; }), {
-                        skipUpdateIfNoValuesChanged: options.skipUpdateIfNoValuesChanged,
-                    })
-                        .execute()];
-            });
-        });
-    };
+    async insert(target, entity) {
+        return this.createQueryBuilder()
+            .insert()
+            .into(target)
+            .values(entity)
+            .execute();
+    }
+    async upsert(target, entityOrEntities, conflictPathsOrOptions) {
+        const metadata = this.connection.getMetadata(target);
+        let options;
+        if (Array.isArray(conflictPathsOrOptions)) {
+            options = {
+                conflictPaths: conflictPathsOrOptions,
+            };
+        }
+        else {
+            options = conflictPathsOrOptions;
+        }
+        let entities;
+        if (!Array.isArray(entityOrEntities)) {
+            entities = [entityOrEntities];
+        }
+        else {
+            entities = entityOrEntities;
+        }
+        const conflictColumns = metadata.mapPropertyPathsToColumns(options.conflictPaths);
+        const overwriteColumns = metadata.columns.filter((col) => !conflictColumns.includes(col) &&
+            entities.some((entity) => typeof col.getEntityValue(entity) !== "undefined"));
+        return this.createQueryBuilder()
+            .insert()
+            .into(target)
+            .values(entities)
+            .orUpdate([...conflictColumns, ...overwriteColumns].map((col) => col.databaseName), conflictColumns.map((col) => col.databaseName), {
+            skipUpdateIfNoValuesChanged: options.skipUpdateIfNoValuesChanged,
+        })
+            .execute();
+    }
     /**
      * Updates entity partially. Entity can be found by a given condition(s).
      * Unlike save method executes a primitive operation without cascades, relations and other operations included.
@@ -379,13 +332,13 @@ var EntityManager = /** @class */ (function () {
      * Does not check if entity exist in the database.
      * Condition(s) cannot be empty.
      */
-    EntityManager.prototype.update = function (target, criteria, partialEntity) {
+    update(target, criteria, partialEntity) {
         // if user passed empty criteria or empty list of criterias, then throw an error
         if (criteria === undefined ||
             criteria === null ||
             criteria === "" ||
             (Array.isArray(criteria) && criteria.length === 0)) {
-            return Promise.reject(new error_1.TypeORMError("Empty criteria(s) are not allowed for the update method."));
+            return Promise.reject(new error_1.TypeORMError(`Empty criteria(s) are not allowed for the update method.`));
         }
         if (typeof criteria === "string" ||
             typeof criteria === "number" ||
@@ -404,7 +357,7 @@ var EntityManager = /** @class */ (function () {
                 .where(criteria)
                 .execute();
         }
-    };
+    }
     /**
      * Deletes entities by a given condition(s).
      * Unlike save method executes a primitive operation without cascades, relations and other operations included.
@@ -412,13 +365,13 @@ var EntityManager = /** @class */ (function () {
      * Does not check if entity exist in the database.
      * Condition(s) cannot be empty.
      */
-    EntityManager.prototype.delete = function (targetOrEntity, criteria) {
+    delete(targetOrEntity, criteria) {
         // if user passed empty criteria or empty list of criterias, then throw an error
         if (criteria === undefined ||
             criteria === null ||
             criteria === "" ||
             (Array.isArray(criteria) && criteria.length === 0)) {
-            return Promise.reject(new error_1.TypeORMError("Empty criteria(s) are not allowed for the delete method."));
+            return Promise.reject(new error_1.TypeORMError(`Empty criteria(s) are not allowed for the delete method.`));
         }
         if (typeof criteria === "string" ||
             typeof criteria === "number" ||
@@ -437,7 +390,7 @@ var EntityManager = /** @class */ (function () {
                 .where(criteria)
                 .execute();
         }
-    };
+    }
     /**
      * Records the delete date of entities by a given condition(s).
      * Unlike save method executes a primitive operation without cascades, relations and other operations included.
@@ -445,13 +398,13 @@ var EntityManager = /** @class */ (function () {
      * Does not check if entity exist in the database.
      * Condition(s) cannot be empty.
      */
-    EntityManager.prototype.softDelete = function (targetOrEntity, criteria) {
+    softDelete(targetOrEntity, criteria) {
         // if user passed empty criteria or empty list of criterias, then throw an error
         if (criteria === undefined ||
             criteria === null ||
             criteria === "" ||
             (Array.isArray(criteria) && criteria.length === 0)) {
-            return Promise.reject(new error_1.TypeORMError("Empty criteria(s) are not allowed for the delete method."));
+            return Promise.reject(new error_1.TypeORMError(`Empty criteria(s) are not allowed for the delete method.`));
         }
         if (typeof criteria === "string" ||
             typeof criteria === "number" ||
@@ -470,7 +423,7 @@ var EntityManager = /** @class */ (function () {
                 .where(criteria)
                 .execute();
         }
-    };
+    }
     /**
      * Restores entities by a given condition(s).
      * Unlike save method executes a primitive operation without cascades, relations and other operations included.
@@ -478,13 +431,13 @@ var EntityManager = /** @class */ (function () {
      * Does not check if entity exist in the database.
      * Condition(s) cannot be empty.
      */
-    EntityManager.prototype.restore = function (targetOrEntity, criteria) {
+    restore(targetOrEntity, criteria) {
         // if user passed empty criteria or empty list of criterias, then throw an error
         if (criteria === undefined ||
             criteria === null ||
             criteria === "" ||
             (Array.isArray(criteria) && criteria.length === 0)) {
-            return Promise.reject(new error_1.TypeORMError("Empty criteria(s) are not allowed for the delete method."));
+            return Promise.reject(new error_1.TypeORMError(`Empty criteria(s) are not allowed for the delete method.`));
         }
         if (typeof criteria === "string" ||
             typeof criteria === "number" ||
@@ -503,80 +456,70 @@ var EntityManager = /** @class */ (function () {
                 .where(criteria)
                 .execute();
         }
-    };
+    }
     /**
      * Counts entities that match given options.
      * Useful for pagination.
      */
-    EntityManager.prototype.count = function (entityClass, options) {
-        var metadata = this.connection.getMetadata(entityClass);
+    count(entityClass, options) {
+        const metadata = this.connection.getMetadata(entityClass);
         return this.createQueryBuilder(entityClass, FindOptionsUtils_1.FindOptionsUtils.extractFindManyOptionsAlias(options) ||
             metadata.name)
             .setFindOptions(options || {})
             .getCount();
-    };
+    }
     /**
      * Counts entities that match given conditions.
      * Useful for pagination.
      */
-    EntityManager.prototype.countBy = function (entityClass, where) {
-        var metadata = this.connection.getMetadata(entityClass);
+    countBy(entityClass, where) {
+        const metadata = this.connection.getMetadata(entityClass);
         return this.createQueryBuilder(entityClass, metadata.name)
-            .setFindOptions({ where: where })
+            .setFindOptions({ where })
             .getCount();
-    };
+    }
     /**
      * Finds entities that match given find options.
      */
-    EntityManager.prototype.find = function (entityClass, options) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var metadata;
-            return tslib_1.__generator(this, function (_a) {
-                metadata = this.connection.getMetadata(entityClass);
-                return [2 /*return*/, this.createQueryBuilder(entityClass, FindOptionsUtils_1.FindOptionsUtils.extractFindManyOptionsAlias(options) ||
-                        metadata.name)
-                        .setFindOptions(options || {})
-                        .getMany()];
-            });
-        });
-    };
+    async find(entityClass, options) {
+        const metadata = this.connection.getMetadata(entityClass);
+        return this.createQueryBuilder(entityClass, FindOptionsUtils_1.FindOptionsUtils.extractFindManyOptionsAlias(options) ||
+            metadata.name)
+            .setFindOptions(options || {})
+            .getMany();
+    }
     /**
      * Finds entities that match given find options.
      */
-    EntityManager.prototype.findBy = function (entityClass, where) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var metadata;
-            return tslib_1.__generator(this, function (_a) {
-                metadata = this.connection.getMetadata(entityClass);
-                return [2 /*return*/, this.createQueryBuilder(entityClass, metadata.name)
-                        .setFindOptions({ where: where })
-                        .getMany()];
-            });
-        });
-    };
+    async findBy(entityClass, where) {
+        const metadata = this.connection.getMetadata(entityClass);
+        return this.createQueryBuilder(entityClass, metadata.name)
+            .setFindOptions({ where: where })
+            .getMany();
+    }
     /**
      * Finds entities that match given find options.
      * Also counts all entities that match given conditions,
      * but ignores pagination settings (from and take options).
      */
-    EntityManager.prototype.findAndCount = function (entityClass, options) {
-        var metadata = this.connection.getMetadata(entityClass);
+    findAndCount(entityClass, options) {
+        const metadata = this.connection.getMetadata(entityClass);
         return this.createQueryBuilder(entityClass, FindOptionsUtils_1.FindOptionsUtils.extractFindManyOptionsAlias(options) ||
             metadata.name)
             .setFindOptions(options || {})
             .getManyAndCount();
-    };
+    }
     /**
      * Finds entities that match given WHERE conditions.
      * Also counts all entities that match given conditions,
      * but ignores pagination settings (from and take options).
      */
-    EntityManager.prototype.findAndCountBy = function (entityClass, where) {
-        var metadata = this.connection.getMetadata(entityClass);
+    findAndCountBy(entityClass, where) {
+        const metadata = this.connection.getMetadata(entityClass);
         return this.createQueryBuilder(entityClass, metadata.name)
-            .setFindOptions({ where: where })
+            .setFindOptions({ where })
             .getManyAndCount();
-    };
+    }
     /**
      * Finds entities with ids.
      * Optionally find options or conditions can be applied.
@@ -587,62 +530,51 @@ var EntityManager = /** @class */ (function () {
      *     id: In([1, 2, 3])
      * })
      */
-    EntityManager.prototype.findByIds = function (entityClass, ids) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var metadata;
-            return tslib_1.__generator(this, function (_a) {
-                // if no ids passed, no need to execute a query - just return an empty array of values
-                if (!ids.length)
-                    return [2 /*return*/, Promise.resolve([])];
-                metadata = this.connection.getMetadata(entityClass);
-                return [2 /*return*/, this.createQueryBuilder(entityClass, metadata.name)
-                        .andWhereInIds(ids)
-                        .getMany()];
-            });
-        });
-    };
+    async findByIds(entityClass, ids) {
+        // if no ids passed, no need to execute a query - just return an empty array of values
+        if (!ids.length)
+            return Promise.resolve([]);
+        const metadata = this.connection.getMetadata(entityClass);
+        return this.createQueryBuilder(entityClass, metadata.name)
+            .andWhereInIds(ids)
+            .getMany();
+    }
     /**
      * Finds first entity by a given find options.
      * If entity was not found in the database - returns null.
      */
-    EntityManager.prototype.findOne = function (entityClass, options) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var metadata, alias;
-            return tslib_1.__generator(this, function (_a) {
-                metadata = this.connection.getMetadata(entityClass);
-                alias = metadata.name;
-                if (options && options.join) {
-                    alias = options.join.alias;
-                }
-                if (!options.where) {
-                    throw new Error("You must provide selection conditions in order to find a single row.");
-                }
-                // create query builder and apply find options
-                return [2 /*return*/, this.createQueryBuilder(entityClass, alias)
-                        .setFindOptions(tslib_1.__assign(tslib_1.__assign({}, options), { take: 1 }))
-                        .getOne()];
-            });
-        });
-    };
+    async findOne(entityClass, options) {
+        const metadata = this.connection.getMetadata(entityClass);
+        // prepare alias for built query
+        let alias = metadata.name;
+        if (options && options.join) {
+            alias = options.join.alias;
+        }
+        if (!options.where) {
+            throw new Error(`You must provide selection conditions in order to find a single row.`);
+        }
+        // create query builder and apply find options
+        return this.createQueryBuilder(entityClass, alias)
+            .setFindOptions({
+            ...options,
+            take: 1,
+        })
+            .getOne();
+    }
     /**
      * Finds first entity that matches given where condition.
      * If entity was not found in the database - returns null.
      */
-    EntityManager.prototype.findOneBy = function (entityClass, where) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var metadata;
-            return tslib_1.__generator(this, function (_a) {
-                metadata = this.connection.getMetadata(entityClass);
-                // create query builder and apply find options
-                return [2 /*return*/, this.createQueryBuilder(entityClass, metadata.name)
-                        .setFindOptions({
-                        where: where,
-                        take: 1,
-                    })
-                        .getOne()];
-            });
-        });
-    };
+    async findOneBy(entityClass, where) {
+        const metadata = this.connection.getMetadata(entityClass);
+        // create query builder and apply find options
+        return this.createQueryBuilder(entityClass, metadata.name)
+            .setFindOptions({
+            where,
+            take: 1,
+        })
+            .getOne();
+    }
     /**
      * Finds first entity that matches given id.
      * If entity was not found in the database - returns null.
@@ -653,217 +585,172 @@ var EntityManager = /** @class */ (function () {
      *     id: 1 // where "id" is your primary column name
      * })
      */
-    EntityManager.prototype.findOneById = function (entityClass, id) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var metadata;
-            return tslib_1.__generator(this, function (_a) {
-                metadata = this.connection.getMetadata(entityClass);
-                // create query builder and apply find options
-                return [2 /*return*/, this.createQueryBuilder(entityClass, metadata.name)
-                        .setFindOptions({
-                        take: 1,
-                    })
-                        .whereInIds(metadata.ensureEntityIdMap(id))
-                        .getOne()];
-            });
-        });
-    };
+    async findOneById(entityClass, id) {
+        const metadata = this.connection.getMetadata(entityClass);
+        // create query builder and apply find options
+        return this.createQueryBuilder(entityClass, metadata.name)
+            .setFindOptions({
+            take: 1,
+        })
+            .whereInIds(metadata.ensureEntityIdMap(id))
+            .getOne();
+    }
     /**
      * Finds first entity by a given find options.
      * If entity was not found in the database - rejects with error.
      */
-    EntityManager.prototype.findOneOrFail = function (entityClass, options) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                return [2 /*return*/, this.findOne(entityClass, options).then(function (value) {
-                        if (value === null) {
-                            return Promise.reject(new EntityNotFoundError_1.EntityNotFoundError(entityClass, options));
-                        }
-                        return Promise.resolve(value);
-                    })];
-            });
+    async findOneOrFail(entityClass, options) {
+        return this.findOne(entityClass, options).then((value) => {
+            if (value === null) {
+                return Promise.reject(new EntityNotFoundError_1.EntityNotFoundError(entityClass, options));
+            }
+            return Promise.resolve(value);
         });
-    };
+    }
     /**
      * Finds first entity that matches given where condition.
      * If entity was not found in the database - rejects with error.
      */
-    EntityManager.prototype.findOneByOrFail = function (entityClass, where) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                return [2 /*return*/, this.findOneBy(entityClass, where).then(function (value) {
-                        if (value === null) {
-                            return Promise.reject(new EntityNotFoundError_1.EntityNotFoundError(entityClass, where));
-                        }
-                        return Promise.resolve(value);
-                    })];
-            });
+    async findOneByOrFail(entityClass, where) {
+        return this.findOneBy(entityClass, where).then((value) => {
+            if (value === null) {
+                return Promise.reject(new EntityNotFoundError_1.EntityNotFoundError(entityClass, where));
+            }
+            return Promise.resolve(value);
         });
-    };
+    }
     /**
      * Clears all the data from the given table (truncates/drops it).
      *
      * Note: this method uses TRUNCATE and may not work as you expect in transactions on some platforms.
      * @see https://stackoverflow.com/a/5972738/925151
      */
-    EntityManager.prototype.clear = function (entityClass) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var metadata, queryRunner;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        metadata = this.connection.getMetadata(entityClass);
-                        queryRunner = this.queryRunner || this.connection.createQueryRunner();
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, , 3, 6]);
-                        return [4 /*yield*/, queryRunner.clearTable(metadata.tablePath)]; // await is needed here because we are using finally
-                    case 2: return [2 /*return*/, _a.sent()]; // await is needed here because we are using finally
-                    case 3:
-                        if (!!this.queryRunner) return [3 /*break*/, 5];
-                        return [4 /*yield*/, queryRunner.release()];
-                    case 4:
-                        _a.sent();
-                        _a.label = 5;
-                    case 5: return [7 /*endfinally*/];
-                    case 6: return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async clear(entityClass) {
+        const metadata = this.connection.getMetadata(entityClass);
+        const queryRunner = this.queryRunner || this.connection.createQueryRunner();
+        try {
+            return await queryRunner.clearTable(metadata.tablePath); // await is needed here because we are using finally
+        }
+        finally {
+            if (!this.queryRunner)
+                await queryRunner.release();
+        }
+    }
     /**
      * Increments some column by provided value of the entities matched given conditions.
      */
-    EntityManager.prototype.increment = function (entityClass, conditions, propertyPath, value) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var metadata, column, values;
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                metadata = this.connection.getMetadata(entityClass);
-                column = metadata.findColumnWithPropertyPath(propertyPath);
-                if (!column)
-                    throw new error_1.TypeORMError("Column ".concat(propertyPath, " was not found in ").concat(metadata.targetName, " entity."));
-                if (isNaN(Number(value)))
-                    throw new error_1.TypeORMError("Value \"".concat(value, "\" is not a number."));
-                values = propertyPath
-                    .split(".")
-                    .reduceRight(function (value, key) {
-                    var _a;
-                    return (_a = {}, _a[key] = value, _a);
-                }, function () {
-                    return _this.connection.driver.escape(column.databaseName) +
-                        " + " +
-                        value;
-                });
-                return [2 /*return*/, this.createQueryBuilder(entityClass, "entity")
-                        .update(entityClass)
-                        .set(values)
-                        .where(conditions)
-                        .execute()];
-            });
-        });
-    };
+    async increment(entityClass, conditions, propertyPath, value) {
+        const metadata = this.connection.getMetadata(entityClass);
+        const column = metadata.findColumnWithPropertyPath(propertyPath);
+        if (!column)
+            throw new error_1.TypeORMError(`Column ${propertyPath} was not found in ${metadata.targetName} entity.`);
+        if (isNaN(Number(value)))
+            throw new error_1.TypeORMError(`Value "${value}" is not a number.`);
+        // convert possible embeded path "social.likes" into object { social: { like: () => value } }
+        const values = propertyPath
+            .split(".")
+            .reduceRight((value, key) => ({ [key]: value }), () => this.connection.driver.escape(column.databaseName) +
+            " + " +
+            value);
+        return this.createQueryBuilder(entityClass, "entity")
+            .update(entityClass)
+            .set(values)
+            .where(conditions)
+            .execute();
+    }
     /**
      * Decrements some column by provided value of the entities matched given conditions.
      */
-    EntityManager.prototype.decrement = function (entityClass, conditions, propertyPath, value) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var metadata, column, values;
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                metadata = this.connection.getMetadata(entityClass);
-                column = metadata.findColumnWithPropertyPath(propertyPath);
-                if (!column)
-                    throw new error_1.TypeORMError("Column ".concat(propertyPath, " was not found in ").concat(metadata.targetName, " entity."));
-                if (isNaN(Number(value)))
-                    throw new error_1.TypeORMError("Value \"".concat(value, "\" is not a number."));
-                values = propertyPath
-                    .split(".")
-                    .reduceRight(function (value, key) {
-                    var _a;
-                    return (_a = {}, _a[key] = value, _a);
-                }, function () {
-                    return _this.connection.driver.escape(column.databaseName) +
-                        " - " +
-                        value;
-                });
-                return [2 /*return*/, this.createQueryBuilder(entityClass, "entity")
-                        .update(entityClass)
-                        .set(values)
-                        .where(conditions)
-                        .execute()];
-            });
-        });
-    };
+    async decrement(entityClass, conditions, propertyPath, value) {
+        const metadata = this.connection.getMetadata(entityClass);
+        const column = metadata.findColumnWithPropertyPath(propertyPath);
+        if (!column)
+            throw new error_1.TypeORMError(`Column ${propertyPath} was not found in ${metadata.targetName} entity.`);
+        if (isNaN(Number(value)))
+            throw new error_1.TypeORMError(`Value "${value}" is not a number.`);
+        // convert possible embeded path "social.likes" into object { social: { like: () => value } }
+        const values = propertyPath
+            .split(".")
+            .reduceRight((value, key) => ({ [key]: value }), () => this.connection.driver.escape(column.databaseName) +
+            " - " +
+            value);
+        return this.createQueryBuilder(entityClass, "entity")
+            .update(entityClass)
+            .set(values)
+            .where(conditions)
+            .execute();
+    }
     /**
      * Gets repository for the given entity class or name.
      * If single database connection mode is used, then repository is obtained from the
      * repository aggregator, where each repository is individually created for this entity manager.
      * When single database connection is not used, repository is being obtained from the connection.
      */
-    EntityManager.prototype.getRepository = function (target) {
+    getRepository(target) {
         // find already created repository instance and return it if found
-        var repository = this.repositories.find(function (repository) { return repository.target === target; });
+        const repository = this.repositories.find((repository) => repository.target === target);
         if (repository)
             return repository;
         // if repository was not found then create it, store its instance and return it
         if (this.connection.driver.options.type === "mongodb") {
             //#region @backendFunc
-            var newRepository = new MongoRepository_1.MongoRepository(target, this, this.queryRunner);
+            const newRepository = new MongoRepository_1.MongoRepository(target, this, this.queryRunner);
             this.repositories.push(newRepository);
             return newRepository;
             //#endregion
         }
         else {
-            var newRepository = new Repository_1.Repository(target, this, this.queryRunner);
+            const newRepository = new Repository_1.Repository(target, this, this.queryRunner);
             this.repositories.push(newRepository);
             return newRepository;
         }
-    };
+    }
     /**
      * Gets tree repository for the given entity class or name.
      * If single database connection mode is used, then repository is obtained from the
      * repository aggregator, where each repository is individually created for this entity manager.
      * When single database connection is not used, repository is being obtained from the connection.
      */
-    EntityManager.prototype.getTreeRepository = function (target) {
+    getTreeRepository(target) {
         // tree tables aren't supported by some drivers (mongodb)
         if (this.connection.driver.treeSupport === false)
             throw new error_1.TreeRepositoryNotSupportedError(this.connection.driver);
         // find already created repository instance and return it if found
-        var repository = this.treeRepositories.find(function (repository) { return repository.target === target; });
+        const repository = this.treeRepositories.find((repository) => repository.target === target);
         if (repository)
             return repository;
         // check if repository is real tree repository
-        var newRepository = new TreeRepository_1.TreeRepository(target, this, this.queryRunner);
+        const newRepository = new TreeRepository_1.TreeRepository(target, this, this.queryRunner);
         this.treeRepositories.push(newRepository);
         return newRepository;
-    };
+    }
     //#region @backend
     /**
      * Gets mongodb repository for the given entity class.
      */
-    EntityManager.prototype.getMongoRepository = function (target) {
+    getMongoRepository(target) {
         return this.connection.getMongoRepository(target);
-    };
+    }
     //#endregion
     /**
      * Creates a new repository instance out of a given Repository and
      * sets current EntityManager instance to it. Used to work with custom repositories
      * in transactions.
      */
-    EntityManager.prototype.withRepository = function (repository) {
-        var repositoryConstructor = repository.constructor;
-        var target = repository.target, manager = repository.manager, queryRunner = repository.queryRunner, otherRepositoryProperties = tslib_1.__rest(repository, ["target", "manager", "queryRunner"]);
-        return Object.assign(new repositoryConstructor(repository.target, this), tslib_1.__assign({}, otherRepositoryProperties));
-    };
+    withRepository(repository) {
+        const repositoryConstructor = repository.constructor;
+        const { target, manager, queryRunner, ...otherRepositoryProperties } = repository;
+        return Object.assign(new repositoryConstructor(repository.target, this), {
+            ...otherRepositoryProperties,
+        });
+    }
     /**
      * Gets custom entity repository marked with @EntityRepository decorator.
      *
      * @deprecated use Repository.extend to create custom repositories
      */
-    EntityManager.prototype.getCustomRepository = function (customRepository) {
-        var entityRepositoryMetadataArgs = (0, globals_1.getMetadataArgsStorage)().entityRepositories.find(function (repository) {
+    getCustomRepository(customRepository) {
+        const entityRepositoryMetadataArgs = (0, globals_1.getMetadataArgsStorage)().entityRepositories.find((repository) => {
             return (repository.target ===
                 (typeof customRepository === "function"
                     ? customRepository
@@ -871,10 +758,10 @@ var EntityManager = /** @class */ (function () {
         });
         if (!entityRepositoryMetadataArgs)
             throw new error_1.CustomRepositoryNotFoundError(customRepository);
-        var entityMetadata = entityRepositoryMetadataArgs.entity
+        const entityMetadata = entityRepositoryMetadataArgs.entity
             ? this.connection.getMetadata(entityRepositoryMetadataArgs.entity)
             : undefined;
-        var entityRepositoryInstance = new entityRepositoryMetadataArgs.target(this, entityMetadata);
+        const entityRepositoryInstance = new entityRepositoryMetadataArgs.target(this, entityMetadata);
         // NOTE: dynamic access to protected properties. We need this to prevent unwanted properties in those classes to be exposed,
         // however we need these properties for internal work of the class
         if (entityRepositoryInstance instanceof AbstractRepository_1.AbstractRepository) {
@@ -888,22 +775,17 @@ var EntityManager = /** @class */ (function () {
             entityRepositoryInstance["metadata"] = entityMetadata;
         }
         return entityRepositoryInstance;
-    };
+    }
     /**
      * Releases all resources used by entity manager.
      * This is used when entity manager is created with a single query runner,
      * and this single query runner needs to be released after job with entity manager is done.
      */
-    EntityManager.prototype.release = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                if (!this.queryRunner)
-                    throw new NoNeedToReleaseEntityManagerError_1.NoNeedToReleaseEntityManagerError();
-                return [2 /*return*/, this.queryRunner.release()];
-            });
-        });
-    };
-    return EntityManager;
-}());
+    async release() {
+        if (!this.queryRunner)
+            throw new NoNeedToReleaseEntityManagerError_1.NoNeedToReleaseEntityManagerError();
+        return this.queryRunner.release();
+    }
+}
 exports.EntityManager = EntityManager;
 //# sourceMappingURL=EntityManager.js.map