taon-typeorm 18.0.18 → 18.0.20

package/lib/typeorm/persistence/SubjectExecutor.js

@@ -1,54 +1,68 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SubjectExecutor = void 0;
-var tslib_1 = require("tslib");
-var SubjectTopoligicalSorter_1 = require("./SubjectTopoligicalSorter");
-var SubjectChangedColumnsComputer_1 = require("./SubjectChangedColumnsComputer");
-var SubjectWithoutIdentifierError_1 = require("../error/SubjectWithoutIdentifierError");
-var SubjectRemovedAndUpdatedError_1 = require("../error/SubjectRemovedAndUpdatedError");
-var BroadcasterResult_1 = require("../subscriber/BroadcasterResult");
-var NestedSetSubjectExecutor_1 = require("./tree/NestedSetSubjectExecutor");
-var ClosureSubjectExecutor_1 = require("./tree/ClosureSubjectExecutor");
-var MaterializedPathSubjectExecutor_1 = require("./tree/MaterializedPathSubjectExecutor");
-var OrmUtils_1 = require("../util/OrmUtils");
-var ObjectUtils_1 = require("../util/ObjectUtils");
-var InstanceChecker_1 = require("../util/InstanceChecker");
+const SubjectTopoligicalSorter_1 = require("./SubjectTopoligicalSorter");
+const SubjectChangedColumnsComputer_1 = require("./SubjectChangedColumnsComputer");
+const SubjectWithoutIdentifierError_1 = require("../error/SubjectWithoutIdentifierError");
+const SubjectRemovedAndUpdatedError_1 = require("../error/SubjectRemovedAndUpdatedError");
+const BroadcasterResult_1 = require("../subscriber/BroadcasterResult");
+const NestedSetSubjectExecutor_1 = require("./tree/NestedSetSubjectExecutor");
+const ClosureSubjectExecutor_1 = require("./tree/ClosureSubjectExecutor");
+const MaterializedPathSubjectExecutor_1 = require("./tree/MaterializedPathSubjectExecutor");
+const OrmUtils_1 = require("../util/OrmUtils");
+const ObjectUtils_1 = require("../util/ObjectUtils");
+const InstanceChecker_1 = require("../util/InstanceChecker");
 /**
  * Executes all database operations (inserts, updated, deletes) that must be executed
  * with given persistence subjects.
  */
-var SubjectExecutor = /** @class */ (function () {
+class SubjectExecutor {
+    // -------------------------------------------------------------------------
+    // Public Properties
+    // -------------------------------------------------------------------------
+    /**
+     * Indicates if executor has any operations to execute (e.g. has insert / update / delete operations to be executed).
+     */
+    hasExecutableOperations = false;
+    // -------------------------------------------------------------------------
+    // Protected Properties
+    // -------------------------------------------------------------------------
+    /**
+     * QueryRunner used to execute all queries with a given subjects.
+     */
+    queryRunner;
+    /**
+     * Persistence options.
+     */
+    options;
+    /**
+     * All subjects that needs to be operated.
+     */
+    allSubjects;
+    /**
+     * Subjects that must be inserted.
+     */
+    insertSubjects = [];
+    /**
+     * Subjects that must be updated.
+     */
+    updateSubjects = [];
+    /**
+     * Subjects that must be removed.
+     */
+    removeSubjects = [];
+    /**
+     * Subjects that must be soft-removed.
+     */
+    softRemoveSubjects = [];
+    /**
+     * Subjects that must be recovered.
+     */
+    recoverSubjects = [];
     // -------------------------------------------------------------------------
     // Constructor
     // -------------------------------------------------------------------------
-    function SubjectExecutor(queryRunner, subjects, options) {
-        // -------------------------------------------------------------------------
-        // Public Properties
-        // -------------------------------------------------------------------------
-        /**
-         * Indicates if executor has any operations to execute (e.g. has insert / update / delete operations to be executed).
-         */
-        this.hasExecutableOperations = false;
-        /**
-         * Subjects that must be inserted.
-         */
-        this.insertSubjects = [];
-        /**
-         * Subjects that must be updated.
-         */
-        this.updateSubjects = [];
-        /**
-         * Subjects that must be removed.
-         */
-        this.removeSubjects = [];
-        /**
-         * Subjects that must be soft-removed.
-         */
-        this.softRemoveSubjects = [];
-        /**
-         * Subjects that must be recovered.
-         */
-        this.recoverSubjects = [];
+    constructor(queryRunner, subjects, options) {
         this.queryRunner = queryRunner;
         this.allSubjects = subjects;
         this.options = options;
@@ -62,892 +76,636 @@ var SubjectExecutor = /** @class */ (function () {
      * Executes all operations over given array of subjects.
      * Executes queries using given query runner.
      */
-    SubjectExecutor.prototype.execute = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var broadcasterResult;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        broadcasterResult = undefined;
-                        if (!(!this.options || this.options.listeners !== false)) return [3 /*break*/, 2];
-                        // console.time(".broadcastBeforeEventsForAll");
-                        broadcasterResult = this.broadcastBeforeEventsForAll();
-                        if (!(broadcasterResult.promises.length > 0)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, Promise.all(broadcasterResult.promises)
-                            // console.timeEnd(".broadcastBeforeEventsForAll");
-                        ];
-                    case 1:
-                        _a.sent();
-                        _a.label = 2;
-                    case 2:
-                        // since event listeners and subscribers can call save methods and/or trigger entity changes we need to recompute operational subjects
-                        // recompute only in the case if any listener or subscriber was really executed
-                        if (broadcasterResult && broadcasterResult.count > 0) {
-                            // console.time(".recompute");
-                            this.insertSubjects.forEach(function (subject) { return subject.recompute(); });
-                            this.updateSubjects.forEach(function (subject) { return subject.recompute(); });
-                            this.removeSubjects.forEach(function (subject) { return subject.recompute(); });
-                            this.softRemoveSubjects.forEach(function (subject) { return subject.recompute(); });
-                            this.recoverSubjects.forEach(function (subject) { return subject.recompute(); });
-                            this.recompute();
-                            // console.timeEnd(".recompute");
-                        }
-                        // make sure our insert subjects are sorted (using topological sorting) to make cascade inserts work properly
-                        // console.timeEnd("prepare");
-                        // execute all insert operations
-                        // console.time(".insertion");
-                        this.insertSubjects = new SubjectTopoligicalSorter_1.SubjectTopoligicalSorter(this.insertSubjects).sort("insert");
-                        return [4 /*yield*/, this.executeInsertOperations()
-                            // console.timeEnd(".insertion");
-                            // recompute update operations since insertion can create updation operations for the
-                            // properties it wasn't able to handle on its own (referenced columns)
-                        ];
-                    case 3:
-                        _a.sent();
-                        // console.timeEnd(".insertion");
-                        // recompute update operations since insertion can create updation operations for the
-                        // properties it wasn't able to handle on its own (referenced columns)
-                        this.updateSubjects = this.allSubjects.filter(function (subject) { return subject.mustBeUpdated; });
-                        // execute update operations
-                        // console.time(".updation");
-                        return [4 /*yield*/, this.executeUpdateOperations()
-                            // console.timeEnd(".updation");
-                            // make sure our remove subjects are sorted (using topological sorting) when multiple entities are passed for the removal
-                            // console.time(".removal");
-                        ];
-                    case 4:
-                        // execute update operations
-                        // console.time(".updation");
-                        _a.sent();
-                        // console.timeEnd(".updation");
-                        // make sure our remove subjects are sorted (using topological sorting) when multiple entities are passed for the removal
-                        // console.time(".removal");
-                        this.removeSubjects = new SubjectTopoligicalSorter_1.SubjectTopoligicalSorter(this.removeSubjects).sort("delete");
-                        return [4 /*yield*/, this.executeRemoveOperations()
-                            // console.timeEnd(".removal");
-                            // recompute soft-remove operations
-                        ];
-                    case 5:
-                        _a.sent();
-                        // console.timeEnd(".removal");
-                        // recompute soft-remove operations
-                        this.softRemoveSubjects = this.allSubjects.filter(function (subject) { return subject.mustBeSoftRemoved; });
-                        // execute soft-remove operations
-                        return [4 /*yield*/, this.executeSoftRemoveOperations()
-                            // recompute recover operations
-                        ];
-                    case 6:
-                        // execute soft-remove operations
-                        _a.sent();
-                        // recompute recover operations
-                        this.recoverSubjects = this.allSubjects.filter(function (subject) { return subject.mustBeRecovered; });
-                        // execute recover operations
-                        return [4 /*yield*/, this.executeRecoverOperations()
-                            // update all special columns in persisted entities, like inserted id or remove ids from the removed entities
-                            // console.time(".updateSpecialColumnsInPersistedEntities");
-                        ];
-                    case 7:
-                        // execute recover operations
-                        _a.sent();
-                        // update all special columns in persisted entities, like inserted id or remove ids from the removed entities
-                        // console.time(".updateSpecialColumnsInPersistedEntities");
-                        return [4 /*yield*/, this.updateSpecialColumnsInPersistedEntities()
-                            // console.timeEnd(".updateSpecialColumnsInPersistedEntities");
-                            // finally broadcast "after" events after we finish insert / update / remove operations
-                        ];
-                    case 8:
-                        // update all special columns in persisted entities, like inserted id or remove ids from the removed entities
-                        // console.time(".updateSpecialColumnsInPersistedEntities");
-                        _a.sent();
-                        if (!(!this.options || this.options.listeners !== false)) return [3 /*break*/, 10];
-                        // console.time(".broadcastAfterEventsForAll");
-                        broadcasterResult = this.broadcastAfterEventsForAll();
-                        if (!(broadcasterResult.promises.length > 0)) return [3 /*break*/, 10];
-                        return [4 /*yield*/, Promise.all(broadcasterResult.promises)
-                            // console.timeEnd(".broadcastAfterEventsForAll");
-                        ];
-                    case 9:
-                        _a.sent();
-                        _a.label = 10;
-                    case 10: return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async execute() {
+        // console.time("SubjectExecutor.execute");
+        // broadcast "before" events before we start insert / update / remove operations
+        let broadcasterResult = undefined;
+        if (!this.options || this.options.listeners !== false) {
+            // console.time(".broadcastBeforeEventsForAll");
+            broadcasterResult = this.broadcastBeforeEventsForAll();
+            if (broadcasterResult.promises.length > 0)
+                await Promise.all(broadcasterResult.promises);
+            // console.timeEnd(".broadcastBeforeEventsForAll");
+        }
+        // since event listeners and subscribers can call save methods and/or trigger entity changes we need to recompute operational subjects
+        // recompute only in the case if any listener or subscriber was really executed
+        if (broadcasterResult && broadcasterResult.count > 0) {
+            // console.time(".recompute");
+            this.insertSubjects.forEach((subject) => subject.recompute());
+            this.updateSubjects.forEach((subject) => subject.recompute());
+            this.removeSubjects.forEach((subject) => subject.recompute());
+            this.softRemoveSubjects.forEach((subject) => subject.recompute());
+            this.recoverSubjects.forEach((subject) => subject.recompute());
+            this.recompute();
+            // console.timeEnd(".recompute");
+        }
+        // make sure our insert subjects are sorted (using topological sorting) to make cascade inserts work properly
+        // console.timeEnd("prepare");
+        // execute all insert operations
+        // console.time(".insertion");
+        this.insertSubjects = new SubjectTopoligicalSorter_1.SubjectTopoligicalSorter(this.insertSubjects).sort("insert");
+        await this.executeInsertOperations();
+        // console.timeEnd(".insertion");
+        // recompute update operations since insertion can create updation operations for the
+        // properties it wasn't able to handle on its own (referenced columns)
+        this.updateSubjects = this.allSubjects.filter((subject) => subject.mustBeUpdated);
+        // execute update operations
+        // console.time(".updation");
+        await this.executeUpdateOperations();
+        // console.timeEnd(".updation");
+        // make sure our remove subjects are sorted (using topological sorting) when multiple entities are passed for the removal
+        // console.time(".removal");
+        this.removeSubjects = new SubjectTopoligicalSorter_1.SubjectTopoligicalSorter(this.removeSubjects).sort("delete");
+        await this.executeRemoveOperations();
+        // console.timeEnd(".removal");
+        // recompute soft-remove operations
+        this.softRemoveSubjects = this.allSubjects.filter((subject) => subject.mustBeSoftRemoved);
+        // execute soft-remove operations
+        await this.executeSoftRemoveOperations();
+        // recompute recover operations
+        this.recoverSubjects = this.allSubjects.filter((subject) => subject.mustBeRecovered);
+        // execute recover operations
+        await this.executeRecoverOperations();
+        // update all special columns in persisted entities, like inserted id or remove ids from the removed entities
+        // console.time(".updateSpecialColumnsInPersistedEntities");
+        await this.updateSpecialColumnsInPersistedEntities();
+        // console.timeEnd(".updateSpecialColumnsInPersistedEntities");
+        // finally broadcast "after" events after we finish insert / update / remove operations
+        if (!this.options || this.options.listeners !== false) {
+            // console.time(".broadcastAfterEventsForAll");
+            broadcasterResult = this.broadcastAfterEventsForAll();
+            if (broadcasterResult.promises.length > 0)
+                await Promise.all(broadcasterResult.promises);
+            // console.timeEnd(".broadcastAfterEventsForAll");
+        }
+        // console.timeEnd("SubjectExecutor.execute");
+    }
     // -------------------------------------------------------------------------
     // Protected Methods
     // -------------------------------------------------------------------------
     /**
      * Validates all given subjects.
      */
-    SubjectExecutor.prototype.validate = function () {
-        this.allSubjects.forEach(function (subject) {
+    validate() {
+        this.allSubjects.forEach((subject) => {
             if (subject.mustBeUpdated && subject.mustBeRemoved)
                 throw new SubjectRemovedAndUpdatedError_1.SubjectRemovedAndUpdatedError(subject);
         });
-    };
+    }
     /**
      * Performs entity re-computations - finds changed columns, re-builds insert/update/remove subjects.
      */
-    SubjectExecutor.prototype.recompute = function () {
+    recompute() {
         new SubjectChangedColumnsComputer_1.SubjectChangedColumnsComputer().compute(this.allSubjects);
-        this.insertSubjects = this.allSubjects.filter(function (subject) { return subject.mustBeInserted; });
-        this.updateSubjects = this.allSubjects.filter(function (subject) { return subject.mustBeUpdated; });
-        this.removeSubjects = this.allSubjects.filter(function (subject) { return subject.mustBeRemoved; });
-        this.softRemoveSubjects = this.allSubjects.filter(function (subject) { return subject.mustBeSoftRemoved; });
-        this.recoverSubjects = this.allSubjects.filter(function (subject) { return subject.mustBeRecovered; });
+        this.insertSubjects = this.allSubjects.filter((subject) => subject.mustBeInserted);
+        this.updateSubjects = this.allSubjects.filter((subject) => subject.mustBeUpdated);
+        this.removeSubjects = this.allSubjects.filter((subject) => subject.mustBeRemoved);
+        this.softRemoveSubjects = this.allSubjects.filter((subject) => subject.mustBeSoftRemoved);
+        this.recoverSubjects = this.allSubjects.filter((subject) => subject.mustBeRecovered);
         this.hasExecutableOperations =
             this.insertSubjects.length > 0 ||
                 this.updateSubjects.length > 0 ||
                 this.removeSubjects.length > 0 ||
                 this.softRemoveSubjects.length > 0 ||
                 this.recoverSubjects.length > 0;
-    };
+    }
     /**
      * Broadcasts "BEFORE_INSERT", "BEFORE_UPDATE", "BEFORE_REMOVE", "BEFORE_SOFT_REMOVE", "BEFORE_RECOVER" events for all given subjects.
      */
-    SubjectExecutor.prototype.broadcastBeforeEventsForAll = function () {
-        var _this = this;
-        var result = new BroadcasterResult_1.BroadcasterResult();
+    broadcastBeforeEventsForAll() {
+        const result = new BroadcasterResult_1.BroadcasterResult();
         if (this.insertSubjects.length)
-            this.insertSubjects.forEach(function (subject) {
-                return _this.queryRunner.broadcaster.broadcastBeforeInsertEvent(result, subject.metadata, subject.entity);
-            });
+            this.insertSubjects.forEach((subject) => this.queryRunner.broadcaster.broadcastBeforeInsertEvent(result, subject.metadata, subject.entity));
         if (this.updateSubjects.length)
-            this.updateSubjects.forEach(function (subject) {
-                return _this.queryRunner.broadcaster.broadcastBeforeUpdateEvent(result, subject.metadata, subject.entity, subject.databaseEntity, subject.diffColumns, subject.diffRelations);
-            });
+            this.updateSubjects.forEach((subject) => this.queryRunner.broadcaster.broadcastBeforeUpdateEvent(result, subject.metadata, subject.entity, subject.databaseEntity, subject.diffColumns, subject.diffRelations));
         if (this.removeSubjects.length)
-            this.removeSubjects.forEach(function (subject) {
-                return _this.queryRunner.broadcaster.broadcastBeforeRemoveEvent(result, subject.metadata, subject.entity, subject.databaseEntity);
-            });
+            this.removeSubjects.forEach((subject) => this.queryRunner.broadcaster.broadcastBeforeRemoveEvent(result, subject.metadata, subject.entity, subject.databaseEntity));
         if (this.softRemoveSubjects.length)
-            this.softRemoveSubjects.forEach(function (subject) {
-                return _this.queryRunner.broadcaster.broadcastBeforeSoftRemoveEvent(result, subject.metadata, subject.entity, subject.databaseEntity);
-            });
+            this.softRemoveSubjects.forEach((subject) => this.queryRunner.broadcaster.broadcastBeforeSoftRemoveEvent(result, subject.metadata, subject.entity, subject.databaseEntity));
         if (this.recoverSubjects.length)
-            this.recoverSubjects.forEach(function (subject) {
-                return _this.queryRunner.broadcaster.broadcastBeforeRecoverEvent(result, subject.metadata, subject.entity, subject.databaseEntity);
-            });
+            this.recoverSubjects.forEach((subject) => this.queryRunner.broadcaster.broadcastBeforeRecoverEvent(result, subject.metadata, subject.entity, subject.databaseEntity));
         return result;
-    };
+    }
     /**
      * Broadcasts "AFTER_INSERT", "AFTER_UPDATE", "AFTER_REMOVE", "AFTER_SOFT_REMOVE", "AFTER_RECOVER" events for all given subjects.
      * Returns void if there wasn't any listener or subscriber executed.
      * Note: this method has a performance-optimized code organization.
      */
-    SubjectExecutor.prototype.broadcastAfterEventsForAll = function () {
-        var _this = this;
-        var result = new BroadcasterResult_1.BroadcasterResult();
+    broadcastAfterEventsForAll() {
+        const result = new BroadcasterResult_1.BroadcasterResult();
         if (this.insertSubjects.length)
-            this.insertSubjects.forEach(function (subject) {
-                return _this.queryRunner.broadcaster.broadcastAfterInsertEvent(result, subject.metadata, subject.entity);
-            });
+            this.insertSubjects.forEach((subject) => this.queryRunner.broadcaster.broadcastAfterInsertEvent(result, subject.metadata, subject.entity));
         if (this.updateSubjects.length)
-            this.updateSubjects.forEach(function (subject) {
-                return _this.queryRunner.broadcaster.broadcastAfterUpdateEvent(result, subject.metadata, subject.entity, subject.databaseEntity, subject.diffColumns, subject.diffRelations);
-            });
+            this.updateSubjects.forEach((subject) => this.queryRunner.broadcaster.broadcastAfterUpdateEvent(result, subject.metadata, subject.entity, subject.databaseEntity, subject.diffColumns, subject.diffRelations));
         if (this.removeSubjects.length)
-            this.removeSubjects.forEach(function (subject) {
-                return _this.queryRunner.broadcaster.broadcastAfterRemoveEvent(result, subject.metadata, subject.entity, subject.databaseEntity);
-            });
+            this.removeSubjects.forEach((subject) => this.queryRunner.broadcaster.broadcastAfterRemoveEvent(result, subject.metadata, subject.entity, subject.databaseEntity));
         if (this.softRemoveSubjects.length)
-            this.softRemoveSubjects.forEach(function (subject) {
-                return _this.queryRunner.broadcaster.broadcastAfterSoftRemoveEvent(result, subject.metadata, subject.entity, subject.databaseEntity);
-            });
+            this.softRemoveSubjects.forEach((subject) => this.queryRunner.broadcaster.broadcastAfterSoftRemoveEvent(result, subject.metadata, subject.entity, subject.databaseEntity));
         if (this.recoverSubjects.length)
-            this.recoverSubjects.forEach(function (subject) {
-                return _this.queryRunner.broadcaster.broadcastAfterRecoverEvent(result, subject.metadata, subject.entity, subject.databaseEntity);
-            });
+            this.recoverSubjects.forEach((subject) => this.queryRunner.broadcaster.broadcastAfterRecoverEvent(result, subject.metadata, subject.entity, subject.databaseEntity));
         return result;
-    };
+    }
     /**
      * Executes insert operations.
      */
-    SubjectExecutor.prototype.executeInsertOperations = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var _a, groupedInsertSubjects, groupedInsertSubjectKeys, _loop_1, this_1, groupedInsertSubjectKeys_1, groupedInsertSubjectKeys_1_1, groupName, e_1_1;
-            var e_1, _b;
-            var _this = this;
-            return tslib_1.__generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        _a = tslib_1.__read(this.groupBulkSubjects(this.insertSubjects, "insert"), 2), groupedInsertSubjects = _a[0], groupedInsertSubjectKeys = _a[1];
-                        _loop_1 = function (groupName) {
-                            var subjects, bulkInsertMaps, bulkInsertSubjects, singleInsertSubjects, insertResult_1, insertResult_2, _loop_2, singleInsertSubjects_1, singleInsertSubjects_1_1, subject, e_2_1;
-                            var e_2, _d;
-                            return tslib_1.__generator(this, function (_e) {
-                                switch (_e.label) {
-                                    case 0:
-                                        subjects = groupedInsertSubjects[groupName];
-                                        bulkInsertMaps = [];
-                                        bulkInsertSubjects = [];
-                                        singleInsertSubjects = [];
-                                        if (this_1.queryRunner.connection.driver.options.type === "mongodb") {
-                                            subjects.forEach(function (subject) {
-                                                if (subject.metadata.createDateColumn && subject.entity) {
-                                                    subject.entity[subject.metadata.createDateColumn.databaseName] = new Date();
-                                                }
-                                                if (subject.metadata.updateDateColumn && subject.entity) {
-                                                    subject.entity[subject.metadata.updateDateColumn.databaseName] = new Date();
-                                                }
-                                                subject.createValueSetAndPopChangeMap();
-                                                bulkInsertSubjects.push(subject);
-                                                bulkInsertMaps.push(subject.entity);
-                                            });
-                                        }
-                                        else if (this_1.queryRunner.connection.driver.options.type === "oracle") {
-                                            subjects.forEach(function (subject) {
-                                                singleInsertSubjects.push(subject);
-                                            });
-                                        }
-                                        else {
-                                            subjects.forEach(function (subject) {
-                                                // we do not insert in bulk in following cases:
-                                                // - when there is no values in insert (only defaults are inserted), since we cannot use DEFAULT VALUES expression for multiple inserted rows
-                                                // - when entity is a tree table, since tree tables require extra operation per each inserted row
-                                                // - when oracle is used, since oracle's bulk insertion is very bad
-                                                if (subject.changeMaps.length === 0 ||
-                                                    subject.metadata.treeType ||
-                                                    _this.queryRunner.connection.driver.options.type ===
-                                                        "oracle" ||
-                                                    _this.queryRunner.connection.driver.options.type ===
-                                                        "sap") {
-                                                    singleInsertSubjects.push(subject);
-                                                }
-                                                else {
-                                                    bulkInsertSubjects.push(subject);
-                                                    bulkInsertMaps.push(subject.createValueSetAndPopChangeMap());
-                                                }
-                                            });
-                                        }
-                                        if (!
-                                        //#region @backend
-                                        InstanceChecker_1.InstanceChecker.isMongoEntityManager(this_1.queryRunner.manager)) 
-                                        //#region @backend
-                                        return [3 /*break*/, 2];
-                                        return [4 /*yield*/, this_1.queryRunner.manager.insert(subjects[0].metadata.target, bulkInsertMaps)];
-                                    case 1:
-                                        insertResult_1 = _e.sent();
-                                        subjects.forEach(function (subject, index) {
-                                            subject.identifier = insertResult_1.identifiers[index];
-                                            subject.generatedMap = insertResult_1.generatedMaps[index];
-                                            subject.insertedValueSet = bulkInsertMaps[index];
-                                        });
-                                        return [3 /*break*/, 12];
-                                    case 2:
-                                        if (!(bulkInsertMaps.length > 0)) return [3 /*break*/, 4];
-                                        return [4 /*yield*/, this_1.queryRunner.manager
-                                                .createQueryBuilder()
-                                                .insert()
-                                                .into(subjects[0].metadata.target)
-                                                .values(bulkInsertMaps)
-                                                .updateEntity(this_1.options && this_1.options.reload === false
-                                                ? false
-                                                : true)
-                                                .callListeners(false)
-                                                .execute()];
-                                    case 3:
-                                        insertResult_2 = _e.sent();
-                                        bulkInsertSubjects.forEach(function (subject, index) {
-                                            subject.identifier = insertResult_2.identifiers[index];
-                                            subject.generatedMap = insertResult_2.generatedMaps[index];
-                                            subject.insertedValueSet = bulkInsertMaps[index];
-                                        });
-                                        _e.label = 4;
-                                    case 4:
-                                        if (!(singleInsertSubjects.length > 0)) return [3 /*break*/, 12];
-                                        _loop_2 = function (subject) {
-                                            return tslib_1.__generator(this, function (_f) {
-                                                switch (_f.label) {
-                                                    case 0:
-                                                        subject.insertedValueSet =
-                                                            subject.createValueSetAndPopChangeMap(); // important to have because query builder sets inserted values into it
-                                                        if (!(subject.metadata.treeType === "nested-set")) return [3 /*break*/, 2];
-                                                        return [4 /*yield*/, new NestedSetSubjectExecutor_1.NestedSetSubjectExecutor(this_1.queryRunner).insert(subject)];
-                                                    case 1:
-                                                        _f.sent();
-                                                        _f.label = 2;
-                                                    case 2: return [4 /*yield*/, this_1.queryRunner.manager
-                                                            .createQueryBuilder()
-                                                            .insert()
-                                                            .into(subject.metadata.target)
-                                                            .values(subject.insertedValueSet)
-                                                            .updateEntity(this_1.options && this_1.options.reload === false
-                                                            ? false
-                                                            : true)
-                                                            .callListeners(false)
-                                                            .execute()
-                                                            .then(function (insertResult) {
-                                                            subject.identifier = insertResult.identifiers[0];
-                                                            subject.generatedMap =
-                                                                insertResult.generatedMaps[0];
-                                                        })
-                                                        // for tree tables we execute additional queries
-                                                    ];
-                                                    case 3:
-                                                        _f.sent();
-                                                        if (!(subject.metadata.treeType === "closure-table")) return [3 /*break*/, 5];
-                                                        return [4 /*yield*/, new ClosureSubjectExecutor_1.ClosureSubjectExecutor(this_1.queryRunner).insert(subject)];
-                                                    case 4:
-                                                        _f.sent();
-                                                        return [3 /*break*/, 7];
-                                                    case 5:
-                                                        if (!(subject.metadata.treeType === "materialized-path")) return [3 /*break*/, 7];
-                                                        return [4 /*yield*/, new MaterializedPathSubjectExecutor_1.MaterializedPathSubjectExecutor(this_1.queryRunner).insert(subject)];
-                                                    case 6:
-                                                        _f.sent();
-                                                        _f.label = 7;
-                                                    case 7: return [2 /*return*/];
-                                                }
-                                            });
-                                        };
-                                        _e.label = 5;
-                                    case 5:
-                                        _e.trys.push([5, 10, 11, 12]);
-                                        singleInsertSubjects_1 = (e_2 = void 0, tslib_1.__values(singleInsertSubjects)), singleInsertSubjects_1_1 = singleInsertSubjects_1.next();
-                                        _e.label = 6;
-                                    case 6:
-                                        if (!!singleInsertSubjects_1_1.done) return [3 /*break*/, 9];
-                                        subject = singleInsertSubjects_1_1.value;
-                                        return [5 /*yield**/, _loop_2(subject)];
-                                    case 7:
-                                        _e.sent();
-                                        _e.label = 8;
-                                    case 8:
-                                        singleInsertSubjects_1_1 = singleInsertSubjects_1.next();
-                                        return [3 /*break*/, 6];
-                                    case 9: return [3 /*break*/, 12];
-                                    case 10:
-                                        e_2_1 = _e.sent();
-                                        e_2 = { error: e_2_1 };
-                                        return [3 /*break*/, 12];
-                                    case 11:
-                                        try {
-                                            if (singleInsertSubjects_1_1 && !singleInsertSubjects_1_1.done && (_d = singleInsertSubjects_1.return)) _d.call(singleInsertSubjects_1);
-                                        }
-                                        finally { if (e_2) throw e_2.error; }
-                                        return [7 /*endfinally*/];
-                                    case 12:
-                                        subjects.forEach(function (subject) {
-                                            if (subject.generatedMap) {
-                                                subject.metadata.columns.forEach(function (column) {
-                                                    var value = column.getEntityValue(subject.generatedMap);
-                                                    if (value !== undefined && value !== null) {
-                                                        var preparedValue = _this.queryRunner.connection.driver.prepareHydratedValue(value, column);
-                                                        column.setEntityValue(subject.generatedMap, preparedValue);
-                                                    }
-                                                });
-                                            }
-                                        });
-                                        return [2 /*return*/];
-                                }
-                            });
-                        };
-                        this_1 = this;
-                        _c.label = 1;
-                    case 1:
-                        _c.trys.push([1, 6, 7, 8]);
-                        groupedInsertSubjectKeys_1 = tslib_1.__values(groupedInsertSubjectKeys), groupedInsertSubjectKeys_1_1 = groupedInsertSubjectKeys_1.next();
-                        _c.label = 2;
-                    case 2:
-                        if (!!groupedInsertSubjectKeys_1_1.done) return [3 /*break*/, 5];
-                        groupName = groupedInsertSubjectKeys_1_1.value;
-                        return [5 /*yield**/, _loop_1(groupName)];
-                    case 3:
-                        _c.sent();
-                        _c.label = 4;
-                    case 4:
-                        groupedInsertSubjectKeys_1_1 = groupedInsertSubjectKeys_1.next();
-                        return [3 /*break*/, 2];
-                    case 5: return [3 /*break*/, 8];
-                    case 6:
-                        e_1_1 = _c.sent();
-                        e_1 = { error: e_1_1 };
-                        return [3 /*break*/, 8];
-                    case 7:
-                        try {
-                            if (groupedInsertSubjectKeys_1_1 && !groupedInsertSubjectKeys_1_1.done && (_b = groupedInsertSubjectKeys_1.return)) _b.call(groupedInsertSubjectKeys_1);
+    async executeInsertOperations() {
+        // group insertion subjects to make bulk insertions
+        const [groupedInsertSubjects, groupedInsertSubjectKeys] = this.groupBulkSubjects(this.insertSubjects, "insert");
+        // then we run insertion in the sequential order which is important since we have an ordered subjects
+        for (const groupName of groupedInsertSubjectKeys) {
+            const subjects = groupedInsertSubjects[groupName];
+            // we must separately insert entities which does not have any values to insert
+            // because its not possible to insert multiple entities with only default values in bulk
+            const bulkInsertMaps = [];
+            const bulkInsertSubjects = [];
+            const singleInsertSubjects = [];
+            if (this.queryRunner.connection.driver.options.type === "mongodb") {
+                subjects.forEach((subject) => {
+                    if (subject.metadata.createDateColumn && subject.entity) {
+                        subject.entity[subject.metadata.createDateColumn.databaseName] = new Date();
+                    }
+                    if (subject.metadata.updateDateColumn && subject.entity) {
+                        subject.entity[subject.metadata.updateDateColumn.databaseName] = new Date();
+                    }
+                    subject.createValueSetAndPopChangeMap();
+                    bulkInsertSubjects.push(subject);
+                    bulkInsertMaps.push(subject.entity);
+                });
+            }
+            else if (this.queryRunner.connection.driver.options.type === "oracle") {
+                subjects.forEach((subject) => {
+                    singleInsertSubjects.push(subject);
+                });
+            }
+            else {
+                subjects.forEach((subject) => {
+                    // we do not insert in bulk in following cases:
+                    // - when there is no values in insert (only defaults are inserted), since we cannot use DEFAULT VALUES expression for multiple inserted rows
+                    // - when entity is a tree table, since tree tables require extra operation per each inserted row
+                    // - when oracle is used, since oracle's bulk insertion is very bad
+                    if (subject.changeMaps.length === 0 ||
+                        subject.metadata.treeType ||
+                        this.queryRunner.connection.driver.options.type ===
+                            "oracle" ||
+                        this.queryRunner.connection.driver.options.type ===
+                            "sap") {
+                        singleInsertSubjects.push(subject);
+                    }
+                    else {
+                        bulkInsertSubjects.push(subject);
+                        bulkInsertMaps.push(subject.createValueSetAndPopChangeMap());
+                    }
+                });
+            }
+            // for mongodb we have a bit different insertion logic
+            if (
+            //#region @backend
+            InstanceChecker_1.InstanceChecker.isMongoEntityManager(this.queryRunner.manager)
+            //#endregion
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            ) {
+                //#region @backend
+                const insertResult = await this.queryRunner.manager.insert(subjects[0].metadata.target, bulkInsertMaps);
+                subjects.forEach((subject, index) => {
+                    subject.identifier = insertResult.identifiers[index];
+                    subject.generatedMap = insertResult.generatedMaps[index];
+                    subject.insertedValueSet = bulkInsertMaps[index];
+                });
+                //#endregion
+            }
+            else {
+                // here we execute our insertion query
+                // we need to enable entity updation because we DO need to have updated insertedMap
+                // which is not same object as our entity that's why we don't need to worry about our entity to get dirty
+                // also, we disable listeners because we call them on our own in persistence layer
+                if (bulkInsertMaps.length > 0) {
+                    const insertResult = await this.queryRunner.manager
+                        .createQueryBuilder()
+                        .insert()
+                        .into(subjects[0].metadata.target)
+                        .values(bulkInsertMaps)
+                        .updateEntity(this.options && this.options.reload === false
+                        ? false
+                        : true)
+                        .callListeners(false)
+                        .execute();
+                    bulkInsertSubjects.forEach((subject, index) => {
+                        subject.identifier = insertResult.identifiers[index];
+                        subject.generatedMap = insertResult.generatedMaps[index];
+                        subject.insertedValueSet = bulkInsertMaps[index];
+                    });
+                }
+                // insert subjects which must be inserted in separate requests (all default values)
+                if (singleInsertSubjects.length > 0) {
+                    for (const subject of singleInsertSubjects) {
+                        subject.insertedValueSet =
+                            subject.createValueSetAndPopChangeMap(); // important to have because query builder sets inserted values into it
+                        // for nested set we execute additional queries
+                        if (subject.metadata.treeType === "nested-set")
+                            await new NestedSetSubjectExecutor_1.NestedSetSubjectExecutor(this.queryRunner).insert(subject);
+                        await this.queryRunner.manager
+                            .createQueryBuilder()
+                            .insert()
+                            .into(subject.metadata.target)
+                            .values(subject.insertedValueSet)
+                            .updateEntity(this.options && this.options.reload === false
+                            ? false
+                            : true)
+                            .callListeners(false)
+                            .execute()
+                            .then((insertResult) => {
+                            subject.identifier = insertResult.identifiers[0];
+                            subject.generatedMap =
+                                insertResult.generatedMaps[0];
+                        });
+                        // for tree tables we execute additional queries
+                        if (subject.metadata.treeType === "closure-table") {
+                            await new ClosureSubjectExecutor_1.ClosureSubjectExecutor(this.queryRunner).insert(subject);
+                        }
+                        else if (subject.metadata.treeType === "materialized-path") {
+                            await new MaterializedPathSubjectExecutor_1.MaterializedPathSubjectExecutor(this.queryRunner).insert(subject);
+                        }
+                    }
+                }
+            }
+            subjects.forEach((subject) => {
+                if (subject.generatedMap) {
+                    subject.metadata.columns.forEach((column) => {
+                        const value = column.getEntityValue(subject.generatedMap);
+                        if (value !== undefined && value !== null) {
+                            const preparedValue = this.queryRunner.connection.driver.prepareHydratedValue(value, column);
+                            column.setEntityValue(subject.generatedMap, preparedValue);
                         }
-                        finally { if (e_1) throw e_1.error; }
-                        return [7 /*endfinally*/];
-                    case 8: return [2 /*return*/];
+                    });
                 }
             });
-        });
-    };
+        }
+    }
     /**
      * Updates all given subjects in the database.
      */
-    SubjectExecutor.prototype.executeUpdateOperations = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var updateSubject, nestedSetSubjects, remainingSubjects, _a, _b, subject, nestedSetPromise;
-            var e_3, _c;
-            var _this = this;
-            return tslib_1.__generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        updateSubject = function (subject) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                            var partialEntity, manager, updateMap, _a, updateQueryBuilder, updateResult, updateGeneratedMap_1;
-                            var _this = this;
-                            return tslib_1.__generator(this, function (_b) {
-                                switch (_b.label) {
-                                    case 0:
-                                        if (!subject.identifier)
-                                            throw new SubjectWithoutIdentifierError_1.SubjectWithoutIdentifierError(subject);
-                                        if (!
-                                        //#region @backend
-                                        InstanceChecker_1.InstanceChecker.isMongoEntityManager(this.queryRunner.manager)) 
-                                        //#region @backend
-                                        return [3 /*break*/, 2];
-                                        partialEntity = this.cloneMongoSubjectEntity(subject);
-                                        if (subject.metadata.objectIdColumn &&
-                                            subject.metadata.objectIdColumn.propertyName) {
-                                            delete partialEntity[subject.metadata.objectIdColumn.propertyName];
-                                        }
-                                        if (subject.metadata.createDateColumn &&
-                                            subject.metadata.createDateColumn.propertyName) {
-                                            delete partialEntity[subject.metadata.createDateColumn.propertyName];
-                                        }
-                                        if (subject.metadata.updateDateColumn &&
-                                            subject.metadata.updateDateColumn.propertyName) {
-                                            partialEntity[subject.metadata.updateDateColumn.propertyName] = new Date();
-                                        }
-                                        manager = this.queryRunner.manager;
-                                        return [4 /*yield*/, manager.update(subject.metadata.target, subject.identifier, partialEntity)
-                                            //#endregion
-                                        ];
-                                    case 1:
-                                        _b.sent();
-                                        return [3 /*break*/, 11];
-                                    case 2:
-                                        updateMap = subject.createValueSetAndPopChangeMap();
-                                        _a = subject.metadata.treeType;
-                                        switch (_a) {
-                                            case "nested-set": return [3 /*break*/, 3];
-                                            case "closure-table": return [3 /*break*/, 5];
-                                            case "materialized-path": return [3 /*break*/, 7];
-                                        }
-                                        return [3 /*break*/, 9];
-                                    case 3: return [4 /*yield*/, new NestedSetSubjectExecutor_1.NestedSetSubjectExecutor(this.queryRunner).update(subject)];
-                                    case 4:
-                                        _b.sent();
-                                        return [3 /*break*/, 9];
-                                    case 5: return [4 /*yield*/, new ClosureSubjectExecutor_1.ClosureSubjectExecutor(this.queryRunner).update(subject)];
-                                    case 6:
-                                        _b.sent();
-                                        return [3 /*break*/, 9];
-                                    case 7: return [4 /*yield*/, new MaterializedPathSubjectExecutor_1.MaterializedPathSubjectExecutor(this.queryRunner).update(subject)];
-                                    case 8:
-                                        _b.sent();
-                                        return [3 /*break*/, 9];
-                                    case 9:
-                                        updateQueryBuilder = this.queryRunner.manager
-                                            .createQueryBuilder()
-                                            .update(subject.metadata.target)
-                                            .set(updateMap)
-                                            .updateEntity(this.options && this.options.reload === false
-                                            ? false
-                                            : true)
-                                            .callListeners(false);
-                                        if (subject.entity) {
-                                            updateQueryBuilder.whereEntity(subject.identifier);
-                                        }
-                                        else {
-                                            // in this case identifier is just conditions object to update by
-                                            updateQueryBuilder.where(subject.identifier);
-                                        }
-                                        return [4 /*yield*/, updateQueryBuilder.execute()];
-                                    case 10:
-                                        updateResult = _b.sent();
-                                        updateGeneratedMap_1 = updateResult.generatedMaps[0];
-                                        if (updateGeneratedMap_1) {
-                                            subject.metadata.columns.forEach(function (column) {
-                                                var value = column.getEntityValue(updateGeneratedMap_1);
-                                                if (value !== undefined && value !== null) {
-                                                    var preparedValue = _this.queryRunner.connection.driver.prepareHydratedValue(value, column);
-                                                    column.setEntityValue(updateGeneratedMap_1, preparedValue);
-                                                }
-                                            });
-                                            if (!subject.generatedMap) {
-                                                subject.generatedMap = {};
-                                            }
-                                            Object.assign(subject.generatedMap, updateGeneratedMap_1);
-                                        }
-                                        _b.label = 11;
-                                    case 11: return [2 /*return*/];
-                                }
-                            });
-                        }); };
-                        nestedSetSubjects = [];
-                        remainingSubjects = [];
-                        try {
-                            for (_a = tslib_1.__values(this.updateSubjects), _b = _a.next(); !_b.done; _b = _a.next()) {
-                                subject = _b.value;
-                                if (subject.metadata.treeType === "nested-set") {
-                                    nestedSetSubjects.push(subject);
-                                }
-                                else {
-                                    remainingSubjects.push(subject);
-                                }
-                            }
-                        }
-                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                        finally {
-                            try {
-                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
-                            }
-                            finally { if (e_3) throw e_3.error; }
+    async executeUpdateOperations() {
+        const updateSubject = async (subject) => {
+            if (!subject.identifier)
+                throw new SubjectWithoutIdentifierError_1.SubjectWithoutIdentifierError(subject);
+            // for mongodb we have a bit different updation logic
+            if (
+            //#region @backend
+            InstanceChecker_1.InstanceChecker.isMongoEntityManager(this.queryRunner.manager)
+            //#endregion
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            ) {
+                //#region @backend
+                const partialEntity = this.cloneMongoSubjectEntity(subject);
+                if (subject.metadata.objectIdColumn &&
+                    subject.metadata.objectIdColumn.propertyName) {
+                    delete partialEntity[subject.metadata.objectIdColumn.propertyName];
+                }
+                if (subject.metadata.createDateColumn &&
+                    subject.metadata.createDateColumn.propertyName) {
+                    delete partialEntity[subject.metadata.createDateColumn.propertyName];
+                }
+                if (subject.metadata.updateDateColumn &&
+                    subject.metadata.updateDateColumn.propertyName) {
+                    partialEntity[subject.metadata.updateDateColumn.propertyName] = new Date();
+                }
+                const manager = this.queryRunner.manager;
+                await manager.update(subject.metadata.target, subject.identifier, partialEntity);
+                //#endregion
+            }
+            else {
+                const updateMap = subject.createValueSetAndPopChangeMap();
+                // for tree tables we execute additional queries
+                switch (subject.metadata.treeType) {
+                    case "nested-set":
+                        await new NestedSetSubjectExecutor_1.NestedSetSubjectExecutor(this.queryRunner).update(subject);
+                        break;
+                    case "closure-table":
+                        await new ClosureSubjectExecutor_1.ClosureSubjectExecutor(this.queryRunner).update(subject);
+                        break;
+                    case "materialized-path":
+                        await new MaterializedPathSubjectExecutor_1.MaterializedPathSubjectExecutor(this.queryRunner).update(subject);
+                        break;
+                }
+                // here we execute our updation query
+                // we need to enable entity updation because we update a subject identifier
+                // which is not same object as our entity that's why we don't need to worry about our entity to get dirty
+                // also, we disable listeners because we call them on our own in persistence layer
+                const updateQueryBuilder = this.queryRunner.manager
+                    .createQueryBuilder()
+                    .update(subject.metadata.target)
+                    .set(updateMap)
+                    .updateEntity(this.options && this.options.reload === false
+                    ? false
+                    : true)
+                    .callListeners(false);
+                if (subject.entity) {
+                    updateQueryBuilder.whereEntity(subject.identifier);
+                }
+                else {
+                    // in this case identifier is just conditions object to update by
+                    updateQueryBuilder.where(subject.identifier);
+                }
+                const updateResult = await updateQueryBuilder.execute();
+                let updateGeneratedMap = updateResult.generatedMaps[0];
+                if (updateGeneratedMap) {
+                    subject.metadata.columns.forEach((column) => {
+                        const value = column.getEntityValue(updateGeneratedMap);
+                        if (value !== undefined && value !== null) {
+                            const preparedValue = this.queryRunner.connection.driver.prepareHydratedValue(value, column);
+                            column.setEntityValue(updateGeneratedMap, preparedValue);
                         }
-                        nestedSetPromise = new Promise(function (ok, fail) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                            var nestedSetSubjects_1, nestedSetSubjects_1_1, subject, error_1, e_4_1;
-                            var e_4, _a;
-                            return tslib_1.__generator(this, function (_b) {
-                                switch (_b.label) {
-                                    case 0:
-                                        _b.trys.push([0, 7, 8, 9]);
-                                        nestedSetSubjects_1 = tslib_1.__values(nestedSetSubjects), nestedSetSubjects_1_1 = nestedSetSubjects_1.next();
-                                        _b.label = 1;
-                                    case 1:
-                                        if (!!nestedSetSubjects_1_1.done) return [3 /*break*/, 6];
-                                        subject = nestedSetSubjects_1_1.value;
-                                        _b.label = 2;
-                                    case 2:
-                                        _b.trys.push([2, 4, , 5]);
-                                        return [4 /*yield*/, updateSubject(subject)];
-                                    case 3:
-                                        _b.sent();
-                                        return [3 /*break*/, 5];
-                                    case 4:
-                                        error_1 = _b.sent();
-                                        fail(error_1);
-                                        return [3 /*break*/, 5];
-                                    case 5:
-                                        nestedSetSubjects_1_1 = nestedSetSubjects_1.next();
-                                        return [3 /*break*/, 1];
-                                    case 6: return [3 /*break*/, 9];
-                                    case 7:
-                                        e_4_1 = _b.sent();
-                                        e_4 = { error: e_4_1 };
-                                        return [3 /*break*/, 9];
-                                    case 8:
-                                        try {
-                                            if (nestedSetSubjects_1_1 && !nestedSetSubjects_1_1.done && (_a = nestedSetSubjects_1.return)) _a.call(nestedSetSubjects_1);
-                                        }
-                                        finally { if (e_4) throw e_4.error; }
-                                        return [7 /*endfinally*/];
-                                    case 9:
-                                        ok();
-                                        return [2 /*return*/];
-                                }
-                            });
-                        }); });
-                        // Run all remaining subjects in parallel
-                        return [4 /*yield*/, Promise.all(tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(remainingSubjects.map(updateSubject)), false), [
-                                nestedSetPromise,
-                            ], false))];
-                    case 1:
-                        // Run all remaining subjects in parallel
-                        _d.sent();
-                        return [2 /*return*/];
+                    });
+                    if (!subject.generatedMap) {
+                        subject.generatedMap = {};
+                    }
+                    Object.assign(subject.generatedMap, updateGeneratedMap);
                 }
-            });
+            }
+        };
+        // Nested sets need to be updated one by one
+        // Split array in two, one with nested set subjects and the other with the remaining subjects
+        const nestedSetSubjects = [];
+        const remainingSubjects = [];
+        for (const subject of this.updateSubjects) {
+            if (subject.metadata.treeType === "nested-set") {
+                nestedSetSubjects.push(subject);
+            }
+            else {
+                remainingSubjects.push(subject);
+            }
+        }
+        // Run nested set updates one by one
+        const nestedSetPromise = new Promise(async (ok, fail) => {
+            for (const subject of nestedSetSubjects) {
+                try {
+                    await updateSubject(subject);
+                }
+                catch (error) {
+                    fail(error);
+                }
+            }
+            ok();
         });
-    };
+        // Run all remaining subjects in parallel
+        await Promise.all([
+            ...remainingSubjects.map(updateSubject),
+            nestedSetPromise,
+        ]);
+    }
     /**
      * Removes all given subjects from the database.
      *
      * todo: we need to apply topological sort here as well
      */
-    SubjectExecutor.prototype.executeRemoveOperations = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var _a, groupedRemoveSubjects, groupedRemoveSubjectKeys, groupedRemoveSubjectKeys_1, groupedRemoveSubjectKeys_1_1, groupName, subjects, deleteMaps, manager, _b, e_5_1;
-            var e_5, _c;
-            return tslib_1.__generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        _a = tslib_1.__read(this.groupBulkSubjects(this.removeSubjects, "delete"), 2), groupedRemoveSubjects = _a[0], groupedRemoveSubjectKeys = _a[1];
-                        _d.label = 1;
-                    case 1:
-                        _d.trys.push([1, 13, 14, 15]);
-                        groupedRemoveSubjectKeys_1 = tslib_1.__values(groupedRemoveSubjectKeys), groupedRemoveSubjectKeys_1_1 = groupedRemoveSubjectKeys_1.next();
-                        _d.label = 2;
-                    case 2:
-                        if (!!groupedRemoveSubjectKeys_1_1.done) return [3 /*break*/, 12];
-                        groupName = groupedRemoveSubjectKeys_1_1.value;
-                        subjects = groupedRemoveSubjects[groupName];
-                        deleteMaps = subjects.map(function (subject) {
-                            if (!subject.identifier)
-                                throw new SubjectWithoutIdentifierError_1.SubjectWithoutIdentifierError(subject);
-                            return subject.identifier;
-                        });
-                        if (!
-                        //#region @backend
-                        InstanceChecker_1.InstanceChecker.isMongoEntityManager(this.queryRunner.manager)) 
-                        //#region @backend
-                        return [3 /*break*/, 4];
-                        manager = this.queryRunner.manager;
-                        return [4 /*yield*/, manager.delete(subjects[0].metadata.target, deleteMaps)
-                            //#endregion
-                        ];
-                    case 3:
-                        _d.sent();
-                        return [3 /*break*/, 11];
-                    case 4:
-                        _b = subjects[0].metadata.treeType;
-                        switch (_b) {
-                            case "nested-set": return [3 /*break*/, 5];
-                            case "closure-table": return [3 /*break*/, 7];
-                        }
-                        return [3 /*break*/, 9];
-                    case 5: return [4 /*yield*/, new NestedSetSubjectExecutor_1.NestedSetSubjectExecutor(this.queryRunner).remove(subjects)];
-                    case 6:
-                        _d.sent();
-                        return [3 /*break*/, 9];
-                    case 7: return [4 /*yield*/, new ClosureSubjectExecutor_1.ClosureSubjectExecutor(this.queryRunner).remove(subjects)];
-                    case 8:
-                        _d.sent();
-                        return [3 /*break*/, 9];
-                    case 9: 
-                    // here we execute our deletion query
-                    // we don't need to specify entities and set update entity to true since the only thing query builder
-                    // will do for use is a primary keys deletion which is handled by us later once persistence is finished
-                    // also, we disable listeners because we call them on our own in persistence layer
-                    return [4 /*yield*/, this.queryRunner.manager
-                            .createQueryBuilder()
-                            .delete()
-                            .from(subjects[0].metadata.target)
-                            .where(deleteMaps)
-                            .callListeners(false)
-                            .execute()];
-                    case 10:
-                        // here we execute our deletion query
-                        // we don't need to specify entities and set update entity to true since the only thing query builder
-                        // will do for use is a primary keys deletion which is handled by us later once persistence is finished
-                        // also, we disable listeners because we call them on our own in persistence layer
-                        _d.sent();
-                        _d.label = 11;
-                    case 11:
-                        groupedRemoveSubjectKeys_1_1 = groupedRemoveSubjectKeys_1.next();
-                        return [3 /*break*/, 2];
-                    case 12: return [3 /*break*/, 15];
-                    case 13:
-                        e_5_1 = _d.sent();
-                        e_5 = { error: e_5_1 };
-                        return [3 /*break*/, 15];
-                    case 14:
-                        try {
-                            if (groupedRemoveSubjectKeys_1_1 && !groupedRemoveSubjectKeys_1_1.done && (_c = groupedRemoveSubjectKeys_1.return)) _c.call(groupedRemoveSubjectKeys_1);
-                        }
-                        finally { if (e_5) throw e_5.error; }
-                        return [7 /*endfinally*/];
-                    case 15: return [2 /*return*/];
-                }
+    async executeRemoveOperations() {
+        // group insertion subjects to make bulk insertions
+        const [groupedRemoveSubjects, groupedRemoveSubjectKeys] = this.groupBulkSubjects(this.removeSubjects, "delete");
+        for (const groupName of groupedRemoveSubjectKeys) {
+            const subjects = groupedRemoveSubjects[groupName];
+            const deleteMaps = subjects.map((subject) => {
+                if (!subject.identifier)
+                    throw new SubjectWithoutIdentifierError_1.SubjectWithoutIdentifierError(subject);
+                return subject.identifier;
             });
-        });
-    };
-    SubjectExecutor.prototype.cloneMongoSubjectEntity = function (subject) {
-        var e_6, _a;
-        var target = {};
-        if (subject.entity) {
-            try {
-                for (var _b = tslib_1.__values(subject.metadata.columns), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var column = _c.value;
-                    OrmUtils_1.OrmUtils.mergeDeep(target, column.getEntityValueMap(subject.entity));
-                }
+            // for mongodb we have a bit different updation logic
+            if (
+            //#region @backend
+            InstanceChecker_1.InstanceChecker.isMongoEntityManager(this.queryRunner.manager)
+            //#endregion
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            ) {
+                //#region @backend
+                const manager = this.queryRunner.manager;
+                await manager.delete(subjects[0].metadata.target, deleteMaps);
+                //#endregion
             }
-            catch (e_6_1) { e_6 = { error: e_6_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            else {
+                // for tree tables we execute additional queries
+                switch (subjects[0].metadata.treeType) {
+                    case "nested-set":
+                        await new NestedSetSubjectExecutor_1.NestedSetSubjectExecutor(this.queryRunner).remove(subjects);
+                        break;
+                    case "closure-table":
+                        await new ClosureSubjectExecutor_1.ClosureSubjectExecutor(this.queryRunner).remove(subjects);
+                        break;
                 }
-                finally { if (e_6) throw e_6.error; }
+                // here we execute our deletion query
+                // we don't need to specify entities and set update entity to true since the only thing query builder
+                // will do for use is a primary keys deletion which is handled by us later once persistence is finished
+                // also, we disable listeners because we call them on our own in persistence layer
+                await this.queryRunner.manager
+                    .createQueryBuilder()
+                    .delete()
+                    .from(subjects[0].metadata.target)
+                    .where(deleteMaps)
+                    .callListeners(false)
+                    .execute();
+            }
+        }
+    }
+    cloneMongoSubjectEntity(subject) {
+        const target = {};
+        if (subject.entity) {
+            for (const column of subject.metadata.columns) {
+                OrmUtils_1.OrmUtils.mergeDeep(target, column.getEntityValueMap(subject.entity));
             }
         }
         return target;
-    };
+    }
     /**
      * Soft-removes all given subjects in the database.
      */
-    SubjectExecutor.prototype.executeSoftRemoveOperations = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, Promise.all(this.softRemoveSubjects.map(function (subject) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                            var updateResult, partialEntity, manager, softDeleteQueryBuilder;
-                            var _this = this;
-                            return tslib_1.__generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0:
-                                        if (!subject.identifier)
-                                            throw new SubjectWithoutIdentifierError_1.SubjectWithoutIdentifierError(subject);
-                                        if (!
-                                        //#region @backend
-                                        InstanceChecker_1.InstanceChecker.isMongoEntityManager(this.queryRunner.manager)) 
-                                        //#region @backend
-                                        return [3 /*break*/, 2];
-                                        partialEntity = this.cloneMongoSubjectEntity(subject);
-                                        if (subject.metadata.objectIdColumn &&
-                                            subject.metadata.objectIdColumn.propertyName) {
-                                            delete partialEntity[subject.metadata.objectIdColumn.propertyName];
-                                        }
-                                        if (subject.metadata.createDateColumn &&
-                                            subject.metadata.createDateColumn.propertyName) {
-                                            delete partialEntity[subject.metadata.createDateColumn.propertyName];
-                                        }
-                                        if (subject.metadata.updateDateColumn &&
-                                            subject.metadata.updateDateColumn.propertyName) {
-                                            partialEntity[subject.metadata.updateDateColumn.propertyName] = new Date();
-                                        }
-                                        if (subject.metadata.deleteDateColumn &&
-                                            subject.metadata.deleteDateColumn.propertyName) {
-                                            partialEntity[subject.metadata.deleteDateColumn.propertyName] = new Date();
-                                        }
-                                        manager = this.queryRunner.manager;
-                                        return [4 /*yield*/, manager.update(subject.metadata.target, subject.identifier, partialEntity)];
-                                    case 1:
-                                        //#endregion
-                                        /* */
-                                        /* */
-                                        updateResult = _a.sent();
-                                        return [3 /*break*/, 4];
-                                    case 2:
-                                        softDeleteQueryBuilder = this.queryRunner.manager
-                                            .createQueryBuilder()
-                                            .softDelete()
-                                            .from(subject.metadata.target)
-                                            .updateEntity(this.options && this.options.reload === false
-                                            ? false
-                                            : true)
-                                            .callListeners(false);
-                                        if (subject.entity) {
-                                            softDeleteQueryBuilder.whereEntity(subject.identifier);
-                                        }
-                                        else {
-                                            // in this case identifier is just conditions object to update by
-                                            softDeleteQueryBuilder.where(subject.identifier);
-                                        }
-                                        return [4 /*yield*/, softDeleteQueryBuilder.execute()];
-                                    case 3:
-                                        updateResult = _a.sent();
-                                        _a.label = 4;
-                                    case 4:
-                                        subject.generatedMap = updateResult.generatedMaps[0];
-                                        if (subject.generatedMap) {
-                                            subject.metadata.columns.forEach(function (column) {
-                                                var value = column.getEntityValue(subject.generatedMap);
-                                                if (value !== undefined && value !== null) {
-                                                    var preparedValue = _this.queryRunner.connection.driver.prepareHydratedValue(value, column);
-                                                    column.setEntityValue(subject.generatedMap, preparedValue);
-                                                }
-                                            });
-                                        }
-                                        return [2 /*return*/];
-                                }
-                            });
-                        }); }))];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
+    async executeSoftRemoveOperations() {
+        await Promise.all(this.softRemoveSubjects.map(async (subject) => {
+            if (!subject.identifier)
+                throw new SubjectWithoutIdentifierError_1.SubjectWithoutIdentifierError(subject);
+            let updateResult;
+            // for mongodb we have a bit different updation logic
+            if (
+            //#region @backend
+            InstanceChecker_1.InstanceChecker.isMongoEntityManager(this.queryRunner.manager)
+            //#endregion
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            ) {
+                const partialEntity = this.cloneMongoSubjectEntity(subject);
+                if (subject.metadata.objectIdColumn &&
+                    subject.metadata.objectIdColumn.propertyName) {
+                    delete partialEntity[subject.metadata.objectIdColumn.propertyName];
                 }
-            });
-        });
-    };
+                if (subject.metadata.createDateColumn &&
+                    subject.metadata.createDateColumn.propertyName) {
+                    delete partialEntity[subject.metadata.createDateColumn.propertyName];
+                }
+                if (subject.metadata.updateDateColumn &&
+                    subject.metadata.updateDateColumn.propertyName) {
+                    partialEntity[subject.metadata.updateDateColumn.propertyName] = new Date();
+                }
+                if (subject.metadata.deleteDateColumn &&
+                    subject.metadata.deleteDateColumn.propertyName) {
+                    partialEntity[subject.metadata.deleteDateColumn.propertyName] = new Date();
+                }
+                let manager 
+                //#region @backend
+                = this.queryRunner.manager;
+                //#endregion
+                /* */
+                /* */
+                updateResult = await manager.update(subject.metadata.target, subject.identifier, partialEntity);
+            }
+            else {
+                // here we execute our soft-deletion query
+                // we need to enable entity soft-deletion because we update a subject identifier
+                // which is not same object as our entity that's why we don't need to worry about our entity to get dirty
+                // also, we disable listeners because we call them on our own in persistence layer
+                const softDeleteQueryBuilder = this.queryRunner.manager
+                    .createQueryBuilder()
+                    .softDelete()
+                    .from(subject.metadata.target)
+                    .updateEntity(this.options && this.options.reload === false
+                    ? false
+                    : true)
+                    .callListeners(false);
+                if (subject.entity) {
+                    softDeleteQueryBuilder.whereEntity(subject.identifier);
+                }
+                else {
+                    // in this case identifier is just conditions object to update by
+                    softDeleteQueryBuilder.where(subject.identifier);
+                }
+                updateResult = await softDeleteQueryBuilder.execute();
+            }
+            subject.generatedMap = updateResult.generatedMaps[0];
+            if (subject.generatedMap) {
+                subject.metadata.columns.forEach((column) => {
+                    const value = column.getEntityValue(subject.generatedMap);
+                    if (value !== undefined && value !== null) {
+                        const preparedValue = this.queryRunner.connection.driver.prepareHydratedValue(value, column);
+                        column.setEntityValue(subject.generatedMap, preparedValue);
+                    }
+                });
+            }
+            // experiments, remove probably, need to implement tree tables children removal
+            // if (subject.updatedRelationMaps.length > 0) {
+            //     await Promise.all(subject.updatedRelationMaps.map(async updatedRelation => {
+            //         if (!updatedRelation.relation.isTreeParent) return;
+            //         if (!updatedRelation.value !== null) return;
+            //
+            //         if (subject.metadata.treeType === "closure-table") {
+            //             await new ClosureSubjectExecutor(this.queryRunner).deleteChildrenOf(subject);
+            //         }
+            //     }));
+            // }
+        }));
+    }
     /**
      * Recovers all given subjects in the database.
      */
-    SubjectExecutor.prototype.executeRecoverOperations = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, Promise.all(this.recoverSubjects.map(function (subject) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                            var updateResult, partialEntity, manager, softDeleteQueryBuilder;
-                            var _this = this;
-                            return tslib_1.__generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0:
-                                        if (!subject.identifier)
-                                            throw new SubjectWithoutIdentifierError_1.SubjectWithoutIdentifierError(subject);
-                                        if (!
-                                        //#region @backend
-                                        InstanceChecker_1.InstanceChecker.isMongoEntityManager(this.queryRunner.manager)) 
-                                        //#region @backend
-                                        return [3 /*break*/, 2];
-                                        partialEntity = this.cloneMongoSubjectEntity(subject);
-                                        if (subject.metadata.objectIdColumn &&
-                                            subject.metadata.objectIdColumn.propertyName) {
-                                            delete partialEntity[subject.metadata.objectIdColumn.propertyName];
-                                        }
-                                        if (subject.metadata.createDateColumn &&
-                                            subject.metadata.createDateColumn.propertyName) {
-                                            delete partialEntity[subject.metadata.createDateColumn.propertyName];
-                                        }
-                                        if (subject.metadata.updateDateColumn &&
-                                            subject.metadata.updateDateColumn.propertyName) {
-                                            partialEntity[subject.metadata.updateDateColumn.propertyName] = new Date();
-                                        }
-                                        if (subject.metadata.deleteDateColumn &&
-                                            subject.metadata.deleteDateColumn.propertyName) {
-                                            partialEntity[subject.metadata.deleteDateColumn.propertyName] = null;
-                                        }
-                                        manager = this.queryRunner
-                                            .manager;
-                                        return [4 /*yield*/, manager.update(subject.metadata.target, subject.identifier, partialEntity)
-                                            //#endregion
-                                        ];
-                                    case 1:
-                                        updateResult = _a.sent();
-                                        return [3 /*break*/, 4];
-                                    case 2:
-                                        softDeleteQueryBuilder = this.queryRunner.manager
-                                            .createQueryBuilder()
-                                            .restore()
-                                            .from(subject.metadata.target)
-                                            .updateEntity(this.options && this.options.reload === false
-                                            ? false
-                                            : true)
-                                            .callListeners(false);
-                                        if (subject.entity) {
-                                            softDeleteQueryBuilder.whereEntity(subject.identifier);
-                                        }
-                                        else {
-                                            // in this case identifier is just conditions object to update by
-                                            softDeleteQueryBuilder.where(subject.identifier);
-                                        }
-                                        return [4 /*yield*/, softDeleteQueryBuilder.execute()];
-                                    case 3:
-                                        updateResult = _a.sent();
-                                        _a.label = 4;
-                                    case 4:
-                                        subject.generatedMap = updateResult.generatedMaps[0];
-                                        if (subject.generatedMap) {
-                                            subject.metadata.columns.forEach(function (column) {
-                                                var value = column.getEntityValue(subject.generatedMap);
-                                                if (value !== undefined && value !== null) {
-                                                    var preparedValue = _this.queryRunner.connection.driver.prepareHydratedValue(value, column);
-                                                    column.setEntityValue(subject.generatedMap, preparedValue);
-                                                }
-                                            });
-                                        }
-                                        return [2 /*return*/];
-                                }
-                            });
-                        }); }))];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
+    async executeRecoverOperations() {
+        await Promise.all(this.recoverSubjects.map(async (subject) => {
+            if (!subject.identifier)
+                throw new SubjectWithoutIdentifierError_1.SubjectWithoutIdentifierError(subject);
+            let updateResult;
+            // for mongodb we have a bit different updation logic
+            if (
+            //#region @backend
+            InstanceChecker_1.InstanceChecker.isMongoEntityManager(this.queryRunner.manager)
+            //#endregion
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            ) {
+                //#region @backend
+                const partialEntity = this.cloneMongoSubjectEntity(subject);
+                if (subject.metadata.objectIdColumn &&
+                    subject.metadata.objectIdColumn.propertyName) {
+                    delete partialEntity[subject.metadata.objectIdColumn.propertyName];
                 }
-            });
-        });
-    };
+                if (subject.metadata.createDateColumn &&
+                    subject.metadata.createDateColumn.propertyName) {
+                    delete partialEntity[subject.metadata.createDateColumn.propertyName];
+                }
+                if (subject.metadata.updateDateColumn &&
+                    subject.metadata.updateDateColumn.propertyName) {
+                    partialEntity[subject.metadata.updateDateColumn.propertyName] = new Date();
+                }
+                if (subject.metadata.deleteDateColumn &&
+                    subject.metadata.deleteDateColumn.propertyName) {
+                    partialEntity[subject.metadata.deleteDateColumn.propertyName] = null;
+                }
+                const manager = this.queryRunner
+                    .manager;
+                updateResult = await manager.update(subject.metadata.target, subject.identifier, partialEntity);
+                //#endregion
+            }
+            else {
+                // here we execute our restory query
+                // we need to enable entity restory because we update a subject identifier
+                // which is not same object as our entity that's why we don't need to worry about our entity to get dirty
+                // also, we disable listeners because we call them on our own in persistence layer
+                const softDeleteQueryBuilder = this.queryRunner.manager
+                    .createQueryBuilder()
+                    .restore()
+                    .from(subject.metadata.target)
+                    .updateEntity(this.options && this.options.reload === false
+                    ? false
+                    : true)
+                    .callListeners(false);
+                if (subject.entity) {
+                    softDeleteQueryBuilder.whereEntity(subject.identifier);
+                }
+                else {
+                    // in this case identifier is just conditions object to update by
+                    softDeleteQueryBuilder.where(subject.identifier);
+                }
+                updateResult = await softDeleteQueryBuilder.execute();
+            }
+            subject.generatedMap = updateResult.generatedMaps[0];
+            if (subject.generatedMap) {
+                subject.metadata.columns.forEach((column) => {
+                    const value = column.getEntityValue(subject.generatedMap);
+                    if (value !== undefined && value !== null) {
+                        const preparedValue = this.queryRunner.connection.driver.prepareHydratedValue(value, column);
+                        column.setEntityValue(subject.generatedMap, preparedValue);
+                    }
+                });
+            }
+            // experiments, remove probably, need to implement tree tables children removal
+            // if (subject.updatedRelationMaps.length > 0) {
+            //     await Promise.all(subject.updatedRelationMaps.map(async updatedRelation => {
+            //         if (!updatedRelation.relation.isTreeParent) return;
+            //         if (!updatedRelation.value !== null) return;
+            //
+            //         if (subject.metadata.treeType === "closure-table") {
+            //             await new ClosureSubjectExecutor(this.queryRunner).deleteChildrenOf(subject);
+            //         }
+            //     }));
+            // }
+        }));
+    }
     /**
      * Updates all special columns of the saving entities (create date, update date, version, etc.).
      * Also updates nullable columns and columns with default values.
      */
-    SubjectExecutor.prototype.updateSpecialColumnsInPersistedEntities = function () {
-        var _this = this;
+    updateSpecialColumnsInPersistedEntities() {
         // update inserted entity properties
         if (this.insertSubjects.length)
             this.updateSpecialColumnsInInsertedAndUpdatedEntities(this.insertSubjects);
@@ -962,24 +720,24 @@ var SubjectExecutor = /** @class */ (function () {
             this.updateSpecialColumnsInInsertedAndUpdatedEntities(this.recoverSubjects);
         // remove ids from the entities that were removed
         if (this.removeSubjects.length) {
-            this.removeSubjects.forEach(function (subject) {
+            this.removeSubjects.forEach((subject) => {
                 if (!subject.entity)
                     return;
-                subject.metadata.primaryColumns.forEach(function (primaryColumn) {
+                subject.metadata.primaryColumns.forEach((primaryColumn) => {
                     primaryColumn.setEntityValue(subject.entity, undefined);
                 });
             });
         }
         // other post-persist updations
-        this.allSubjects.forEach(function (subject) {
+        this.allSubjects.forEach((subject) => {
             if (!subject.entity)
                 return;
-            subject.metadata.relationIds.forEach(function (relationId) {
+            subject.metadata.relationIds.forEach((relationId) => {
                 relationId.setValue(subject.entity);
             });
             //#region @backend
             // mongo _id remove
-            if (InstanceChecker_1.InstanceChecker.isMongoEntityManager(_this.queryRunner.manager)) {
+            if (InstanceChecker_1.InstanceChecker.isMongoEntityManager(this.queryRunner.manager)) {
                 if (subject.metadata.objectIdColumn &&
                     subject.metadata.objectIdColumn.databaseName &&
                     subject.metadata.objectIdColumn.databaseName !==
@@ -989,22 +747,21 @@ var SubjectExecutor = /** @class */ (function () {
             }
             //#endregion
         });
-    };
+    }
     /**
      * Updates all special columns of the saving entities (create date, update date, version, etc.).
      * Also updates nullable columns and columns with default values.
      */
-    SubjectExecutor.prototype.updateSpecialColumnsInInsertedAndUpdatedEntities = function (subjects) {
-        var _this = this;
-        subjects.forEach(function (subject) {
+    updateSpecialColumnsInInsertedAndUpdatedEntities(subjects) {
+        subjects.forEach((subject) => {
             if (!subject.entity)
                 return;
             // set values to "null" for nullable columns that did not have values
-            subject.metadata.columns.forEach(function (column) {
+            subject.metadata.columns.forEach((column) => {
                 // if table inheritance is used make sure this column is not child's column
                 if (subject.metadata.childEntityMetadatas.length > 0 &&
                     subject.metadata.childEntityMetadatas
-                        .map(function (metadata) { return metadata.target; })
+                        .map((metadata) => metadata.target)
                         .indexOf(column.target) !== -1)
                     return;
                 // entities does not have virtual columns
@@ -1012,14 +769,14 @@ var SubjectExecutor = /** @class */ (function () {
                     return;
                 // update nullable columns
                 if (column.isNullable) {
-                    var columnValue = column.getEntityValue(subject.entity);
+                    const columnValue = column.getEntityValue(subject.entity);
                     if (columnValue === undefined)
                         column.setEntityValue(subject.entity, null);
                 }
                 // update relational columns
                 if (subject.updatedRelationMaps.length > 0) {
-                    subject.updatedRelationMaps.forEach(function (updatedRelationMap) {
-                        updatedRelationMap.relation.joinColumns.forEach(function (column) {
+                    subject.updatedRelationMaps.forEach((updatedRelationMap) => {
+                        updatedRelationMap.relation.joinColumns.forEach((column) => {
                             if (column.isVirtual === true)
                                 return;
                             column.setEntityValue(subject.entity, ObjectUtils_1.ObjectUtils.isObject(updatedRelationMap.value)
@@ -1031,9 +788,9 @@ var SubjectExecutor = /** @class */ (function () {
             });
             // merge into entity all generated values returned by a database
             if (subject.generatedMap)
-                _this.queryRunner.manager.merge(subject.metadata.target, subject.entity, subject.generatedMap);
+                this.queryRunner.manager.merge(subject.metadata.target, subject.entity, subject.generatedMap);
         });
-    };
+    }
     /**
      * Groups subjects by metadata names (by tables) to make bulk insertions and deletions possible.
      * However there are some limitations with bulk insertions of data into tables with generated (increment) columns
@@ -1045,17 +802,17 @@ var SubjectExecutor = /** @class */ (function () {
      * Other drivers like postgres and sql server support RETURNING / OUTPUT statement which allows to return generated
      * id for each inserted row, that's why bulk insertion is not limited to junction tables in there.
      */
-    SubjectExecutor.prototype.groupBulkSubjects = function (subjects, type) {
-        var group = {};
-        var keys = [];
-        var hasReturningDependColumns = subjects.some(function (subject) {
+    groupBulkSubjects(subjects, type) {
+        const group = {};
+        const keys = [];
+        const hasReturningDependColumns = subjects.some((subject) => {
             return subject.metadata.getInsertionReturningColumns().length > 0;
         });
-        var groupingAllowed = type === "delete" ||
+        const groupingAllowed = type === "delete" ||
             this.queryRunner.connection.driver.isReturningSqlSupported("insert") ||
             hasReturningDependColumns === false;
-        subjects.forEach(function (subject, index) {
-            var key = groupingAllowed || subject.metadata.isJunction
+        subjects.forEach((subject, index) => {
+            const key = groupingAllowed || subject.metadata.isJunction
                 ? subject.metadata.name
                 : subject.metadata.name + "_" + index;
             if (!group[key]) {
@@ -1067,8 +824,7 @@ var SubjectExecutor = /** @class */ (function () {
             }
         });
         return [group, keys];
-    };
-    return SubjectExecutor;
-}());
+    }
+}
 exports.SubjectExecutor = SubjectExecutor;
 //# sourceMappingURL=SubjectExecutor.js.map