typeorm 0.2.25 → 0.2.29

package/persistence/SubjectExecutor.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
 var SapDriver_1 = require("../driver/sap/SapDriver");
-var PromiseUtils_1 = require("../util/PromiseUtils");
 var SubjectTopoligicalSorter_1 = require("./SubjectTopoligicalSorter");
 var SubjectChangedColumnsComputer_1 = require("./SubjectChangedColumnsComputer");
 var SubjectWithoutIdentifierError_1 = require("../error/SubjectWithoutIdentifierError");
@@ -220,154 +219,201 @@ var SubjectExecutor = /** @class */ (function () {
      */
     SubjectExecutor.prototype.executeInsertOperations = function () {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var _a, groupedInsertSubjects, groupedInsertSubjectKeys;
+            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 (_b) {
-                switch (_b.label) {
+            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];
-                        // then we run insertion in the sequential order which is important since we have an ordered subjects
-                        return [4 /*yield*/, PromiseUtils_1.PromiseUtils.runInSequence(groupedInsertSubjectKeys, function (groupName) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                var subjects, bulkInsertMaps, bulkInsertSubjects, singleInsertSubjects, manager, insertResult_1, insertResult_2;
-                                var _this = this;
-                                return tslib_1.__generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0:
-                                            subjects = groupedInsertSubjects[groupName];
-                                            bulkInsertMaps = [];
-                                            bulkInsertSubjects = [];
-                                            singleInsertSubjects = [];
-                                            if (this.queryRunner.connection.driver instanceof MongoDriver_1.MongoDriver) {
-                                                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.queryRunner.connection.driver instanceof OracleDriver_1.OracleDriver) {
-                                                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 instanceof OracleDriver_1.OracleDriver ||
-                                                        _this.queryRunner.connection.driver instanceof SapDriver_1.SapDriver) {
-                                                        singleInsertSubjects.push(subject);
-                                                    }
-                                                    else {
-                                                        bulkInsertSubjects.push(subject);
-                                                        bulkInsertMaps.push(subject.createValueSetAndPopChangeMap());
-                                                    }
-                                                });
-                                            }
-                                            if (!(this.queryRunner instanceof MongoQueryRunner_1.MongoQueryRunner)) return [3 /*break*/, 2];
-                                            manager = this.queryRunner.manager;
-                                            return [4 /*yield*/, manager.insert(subjects[0].metadata.target, bulkInsertMaps)];
-                                        case 1:
-                                            insertResult_1 = _a.sent();
-                                            subjects.forEach(function (subject, index) {
-                                                subject.identifier = insertResult_1.identifiers[index];
-                                                subject.generatedMap = insertResult_1.generatedMaps[index];
-                                                subject.insertedValueSet = bulkInsertMaps[index];
+                        _loop_1 = function (groupName) {
+                            var subjects, bulkInsertMaps, bulkInsertSubjects, singleInsertSubjects, manager, insertResult_1, insertResult_2, _loop_2, singleInsertSubjects_1, singleInsertSubjects_1_1, subject, e_2_1;
+                            var e_2, _a;
+                            return tslib_1.__generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        subjects = groupedInsertSubjects[groupName];
+                                        bulkInsertMaps = [];
+                                        bulkInsertSubjects = [];
+                                        singleInsertSubjects = [];
+                                        if (this_1.queryRunner.connection.driver instanceof MongoDriver_1.MongoDriver) {
+                                            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);
                                             });
-                                            return [3 /*break*/, 6];
-                                        case 2:
-                                            if (!(bulkInsertMaps.length > 0)) return [3 /*break*/, 4];
-                                            return [4 /*yield*/, this.queryRunner
-                                                    .manager
-                                                    .createQueryBuilder()
-                                                    .insert()
-                                                    .into(subjects[0].metadata.target)
-                                                    .values(bulkInsertMaps)
-                                                    .updateEntity(this.options && this.options.reload === false ? false : true)
-                                                    .callListeners(false)
-                                                    .execute()];
-                                        case 3:
-                                            insertResult_2 = _a.sent();
-                                            bulkInsertSubjects.forEach(function (subject, index) {
-                                                subject.identifier = insertResult_2.identifiers[index];
-                                                subject.generatedMap = insertResult_2.generatedMaps[index];
-                                                subject.insertedValueSet = bulkInsertMaps[index];
+                                        }
+                                        else if (this_1.queryRunner.connection.driver instanceof OracleDriver_1.OracleDriver) {
+                                            subjects.forEach(function (subject) {
+                                                singleInsertSubjects.push(subject);
                                             });
-                                            _a.label = 4;
-                                        case 4:
-                                            if (!(singleInsertSubjects.length > 0)) return [3 /*break*/, 6];
-                                            return [4 /*yield*/, PromiseUtils_1.PromiseUtils.runInSequence(singleInsertSubjects, function (subject) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                                    return tslib_1.__generator(this, function (_a) {
-                                                        switch (_a.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.queryRunner).insert(subject)];
-                                                            case 1:
-                                                                _a.sent();
-                                                                _a.label = 2;
-                                                            case 2: return [4 /*yield*/, 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(function (insertResult) {
-                                                                    subject.identifier = insertResult.identifiers[0];
-                                                                    subject.generatedMap = insertResult.generatedMaps[0];
-                                                                })];
-                                                            case 3:
-                                                                _a.sent();
-                                                                if (!(subject.metadata.treeType === "closure-table")) return [3 /*break*/, 5];
-                                                                return [4 /*yield*/, new ClosureSubjectExecutor_1.ClosureSubjectExecutor(this.queryRunner).insert(subject)];
-                                                            case 4:
-                                                                _a.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.queryRunner).insert(subject)];
-                                                            case 6:
-                                                                _a.sent();
-                                                                _a.label = 7;
-                                                            case 7: return [2 /*return*/];
-                                                        }
-                                                    });
-                                                }); })];
-                                        case 5:
-                                            _a.sent();
-                                            _a.label = 6;
-                                        case 6:
+                                        }
+                                        else {
                                             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);
-                                                        }
-                                                    });
+                                                // 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 instanceof OracleDriver_1.OracleDriver ||
+                                                    _this.queryRunner.connection.driver instanceof SapDriver_1.SapDriver) {
+                                                    singleInsertSubjects.push(subject);
+                                                }
+                                                else {
+                                                    bulkInsertSubjects.push(subject);
+                                                    bulkInsertMaps.push(subject.createValueSetAndPopChangeMap());
                                                 }
                                             });
-                                            return [2 /*return*/];
-                                    }
-                                });
-                            }); })];
+                                        }
+                                        if (!(this_1.queryRunner instanceof MongoQueryRunner_1.MongoQueryRunner)) return [3 /*break*/, 2];
+                                        manager = this_1.queryRunner.manager;
+                                        return [4 /*yield*/, manager.insert(subjects[0].metadata.target, bulkInsertMaps)];
+                                    case 1:
+                                        insertResult_1 = _b.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 = _b.sent();
+                                        bulkInsertSubjects.forEach(function (subject, index) {
+                                            subject.identifier = insertResult_2.identifiers[index];
+                                            subject.generatedMap = insertResult_2.generatedMaps[index];
+                                            subject.insertedValueSet = bulkInsertMaps[index];
+                                        });
+                                        _b.label = 4;
+                                    case 4:
+                                        if (!(singleInsertSubjects.length > 0)) return [3 /*break*/, 12];
+                                        _loop_2 = function (subject) {
+                                            return tslib_1.__generator(this, function (_a) {
+                                                switch (_a.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:
+                                                        _a.sent();
+                                                        _a.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];
+                                                        })];
+                                                    case 3:
+                                                        _a.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:
+                                                        _a.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:
+                                                        _a.sent();
+                                                        _a.label = 7;
+                                                    case 7: return [2 /*return*/];
+                                                }
+                                            });
+                                        };
+                                        _b.label = 5;
+                                    case 5:
+                                        _b.trys.push([5, 10, 11, 12]);
+                                        singleInsertSubjects_1 = (e_2 = void 0, tslib_1.__values(singleInsertSubjects)), singleInsertSubjects_1_1 = singleInsertSubjects_1.next();
+                                        _b.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:
+                                        _b.sent();
+                                        _b.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 = _b.sent();
+                                        e_2 = { error: e_2_1 };
+                                        return [3 /*break*/, 12];
+                                    case 11:
+                                        try {
+                                            if (singleInsertSubjects_1_1 && !singleInsertSubjects_1_1.done && (_a = singleInsertSubjects_1.return)) _a.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:
-                        // then we run insertion in the sequential order which is important since we have an ordered subjects
-                        _b.sent();
-                        return [2 /*return*/];
+                        _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);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 8: return [2 /*return*/];
                 }
             });
         });
@@ -451,56 +497,67 @@ var SubjectExecutor = /** @class */ (function () {
      */
     SubjectExecutor.prototype.executeRemoveOperations = function () {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var _a, groupedRemoveSubjects, groupedRemoveSubjectKeys;
-            var _this = this;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
+            var _a, groupedRemoveSubjects, groupedRemoveSubjectKeys, groupedRemoveSubjectKeys_1, groupedRemoveSubjectKeys_1_1, groupName, subjects, deleteMaps, manager, e_3_1;
+            var e_3, _b;
+            return tslib_1.__generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
                         _a = tslib_1.__read(this.groupBulkSubjects(this.removeSubjects, "delete"), 2), groupedRemoveSubjects = _a[0], groupedRemoveSubjectKeys = _a[1];
-                        return [4 /*yield*/, PromiseUtils_1.PromiseUtils.runInSequence(groupedRemoveSubjectKeys, function (groupName) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                var subjects, deleteMaps, manager;
-                                return tslib_1.__generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0:
-                                            subjects = groupedRemoveSubjects[groupName];
-                                            deleteMaps = subjects.map(function (subject) {
-                                                if (!subject.identifier)
-                                                    throw new SubjectWithoutIdentifierError_1.SubjectWithoutIdentifierError(subject);
-                                                return subject.identifier;
-                                            });
-                                            if (!(this.queryRunner instanceof MongoQueryRunner_1.MongoQueryRunner)) return [3 /*break*/, 2];
-                                            manager = this.queryRunner.manager;
-                                            return [4 /*yield*/, manager.delete(subjects[0].metadata.target, deleteMaps)];
-                                        case 1:
-                                            _a.sent();
-                                            return [3 /*break*/, 4];
-                                        case 2: 
-                                        // 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 3:
-                                            // 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
-                                            _a.sent();
-                                            _a.label = 4;
-                                        case 4: return [2 /*return*/];
-                                    }
-                                });
-                            }); })];
+                        _c.label = 1;
                     case 1:
-                        _b.sent();
-                        return [2 /*return*/];
+                        _c.trys.push([1, 8, 9, 10]);
+                        groupedRemoveSubjectKeys_1 = tslib_1.__values(groupedRemoveSubjectKeys), groupedRemoveSubjectKeys_1_1 = groupedRemoveSubjectKeys_1.next();
+                        _c.label = 2;
+                    case 2:
+                        if (!!groupedRemoveSubjectKeys_1_1.done) return [3 /*break*/, 7];
+                        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 (!(this.queryRunner instanceof MongoQueryRunner_1.MongoQueryRunner)) return [3 /*break*/, 4];
+                        manager = this.queryRunner.manager;
+                        return [4 /*yield*/, manager.delete(subjects[0].metadata.target, deleteMaps)];
+                    case 3:
+                        _c.sent();
+                        return [3 /*break*/, 6];
+                    case 4: 
+                    // 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 5:
+                        // 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
+                        _c.sent();
+                        _c.label = 6;
+                    case 6:
+                        groupedRemoveSubjectKeys_1_1 = groupedRemoveSubjectKeys_1.next();
+                        return [3 /*break*/, 2];
+                    case 7: return [3 /*break*/, 10];
+                    case 8:
+                        e_3_1 = _c.sent();
+                        e_3 = { error: e_3_1 };
+                        return [3 /*break*/, 10];
+                    case 9:
+                        try {
+                            if (groupedRemoveSubjectKeys_1_1 && !groupedRemoveSubjectKeys_1_1.done && (_b = groupedRemoveSubjectKeys_1.return)) _b.call(groupedRemoveSubjectKeys_1);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                        return [7 /*endfinally*/];
+                    case 10: return [2 /*return*/];
                 }
             });
         });