typeorm 0.3.29-dev.cc07c90 → 1.0.0-beta.1

package/browser/persistence/SubjectExecutor.js

@@ -1,19 +1,22 @@
-import { SubjectTopologicalSorter } from "./SubjectTopologicalSorter";
-import { SubjectChangedColumnsComputer } from "./SubjectChangedColumnsComputer";
-import { SubjectWithoutIdentifierError } from "../error/SubjectWithoutIdentifierError";
-import { SubjectRemovedAndUpdatedError } from "../error/SubjectRemovedAndUpdatedError";
-import { BroadcasterResult } from "../subscriber/BroadcasterResult";
-import { NestedSetSubjectExecutor } from "./tree/NestedSetSubjectExecutor";
-import { ClosureSubjectExecutor } from "./tree/ClosureSubjectExecutor";
-import { MaterializedPathSubjectExecutor } from "./tree/MaterializedPathSubjectExecutor";
-import { OrmUtils } from "../util/OrmUtils";
-import { ObjectUtils } from "../util/ObjectUtils";
-import { InstanceChecker } from "../util/InstanceChecker";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubjectExecutor = void 0;
+const SubjectTopologicalSorter_1 = require("./SubjectTopologicalSorter");
+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.
  */
-export class SubjectExecutor {
+class SubjectExecutor {
     // -------------------------------------------------------------------------
     // Constructor
     // -------------------------------------------------------------------------
@@ -85,7 +88,7 @@ export class SubjectExecutor {
         // console.timeEnd("prepare");
         // execute all insert operations
         // console.time(".insertion");
-        this.insertSubjects = new SubjectTopologicalSorter(this.insertSubjects).sort("insert");
+        this.insertSubjects = new SubjectTopologicalSorter_1.SubjectTopologicalSorter(this.insertSubjects).sort("insert");
         await this.executeInsertOperations();
         // console.timeEnd(".insertion");
         // recompute update operations since insertion can create updation operations for the
@@ -97,7 +100,7 @@ export class SubjectExecutor {
         // 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 SubjectTopologicalSorter(this.removeSubjects).sort("delete");
+        this.removeSubjects = new SubjectTopologicalSorter_1.SubjectTopologicalSorter(this.removeSubjects).sort("delete");
         await this.executeRemoveOperations();
         // console.timeEnd(".removal");
         // recompute soft-remove operations
@@ -131,14 +134,14 @@ export class SubjectExecutor {
     validate() {
         this.allSubjects.forEach((subject) => {
             if (subject.mustBeUpdated && subject.mustBeRemoved)
-                throw new SubjectRemovedAndUpdatedError(subject);
+                throw new SubjectRemovedAndUpdatedError_1.SubjectRemovedAndUpdatedError(subject);
         });
     }
     /**
      * Performs entity re-computations - finds changed columns, re-builds insert/update/remove subjects.
      */
     recompute() {
-        new SubjectChangedColumnsComputer().compute(this.allSubjects);
+        new SubjectChangedColumnsComputer_1.SubjectChangedColumnsComputer().compute(this.allSubjects);
         this.insertSubjects = this.allSubjects.filter((subject) => subject.mustBeInserted);
         this.updateSubjects = this.allSubjects.filter((subject) => subject.mustBeUpdated);
         this.removeSubjects = this.allSubjects.filter((subject) => subject.mustBeRemoved);
@@ -155,7 +158,7 @@ export class SubjectExecutor {
      * Broadcasts "BEFORE_INSERT", "BEFORE_UPDATE", "BEFORE_REMOVE", "BEFORE_SOFT_REMOVE", "BEFORE_RECOVER" events for all given subjects.
      */
     broadcastBeforeEventsForAll() {
-        const result = new BroadcasterResult();
+        const result = new BroadcasterResult_1.BroadcasterResult();
         if (this.insertSubjects.length)
             this.insertSubjects.forEach((subject) => this.queryRunner.broadcaster.broadcastBeforeInsertEvent(result, subject.metadata, subject.entity));
         if (this.updateSubjects.length)
@@ -174,7 +177,7 @@ export class SubjectExecutor {
      * Note: this method has a performance-optimized code organization.
      */
     broadcastAfterEventsForAll() {
-        const result = new BroadcasterResult();
+        const result = new BroadcasterResult_1.BroadcasterResult();
         if (this.insertSubjects.length)
             this.insertSubjects.forEach((subject) => this.queryRunner.broadcaster.broadcastAfterInsertEvent(result, subject.metadata, subject.entity, subject.identifier));
         if (this.updateSubjects.length)
@@ -201,7 +204,7 @@ export class SubjectExecutor {
             const bulkInsertMaps = [];
             const bulkInsertSubjects = [];
             const singleInsertSubjects = [];
-            if (this.queryRunner.connection.driver.options.type === "mongodb") {
+            if (this.queryRunner.dataSource.driver.options.type === "mongodb") {
                 subjects.forEach((subject) => {
                     if (subject.metadata.createDateColumn && subject.entity) {
                         subject.entity[subject.metadata.createDateColumn.databaseName] = new Date();
@@ -214,7 +217,7 @@ export class SubjectExecutor {
                     bulkInsertMaps.push(subject.entity);
                 });
             }
-            else if (this.queryRunner.connection.driver.options.type === "oracle") {
+            else if (this.queryRunner.dataSource.driver.options.type === "oracle") {
                 subjects.forEach((subject) => {
                     singleInsertSubjects.push(subject);
                 });
@@ -227,9 +230,9 @@ export class SubjectExecutor {
                     // - 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 ===
+                        this.queryRunner.dataSource.driver.options.type ===
                             "oracle" ||
-                        this.queryRunner.connection.driver.options.type ===
+                        this.queryRunner.dataSource.driver.options.type ===
                             "sap") {
                         singleInsertSubjects.push(subject);
                     }
@@ -240,7 +243,7 @@ export class SubjectExecutor {
                 });
             }
             // for mongodb we have a bit different insertion logic
-            if (InstanceChecker.isMongoEntityManager(this.queryRunner.manager)) {
+            if (InstanceChecker_1.InstanceChecker.isMongoEntityManager(this.queryRunner.manager)) {
                 const insertResult = await this.queryRunner.manager.insert(subjects[0].metadata.target, bulkInsertMaps);
                 subjects.forEach((subject, index) => {
                     subject.identifier = insertResult.identifiers[index];
@@ -277,7 +280,7 @@ export class SubjectExecutor {
                             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(this.queryRunner).insert(subject);
+                            await new NestedSetSubjectExecutor_1.NestedSetSubjectExecutor(this.queryRunner).insert(subject);
                         await this.queryRunner.manager
                             .createQueryBuilder()
                             .insert()
@@ -295,10 +298,10 @@ export class SubjectExecutor {
                         });
                         // for tree tables we execute additional queries
                         if (subject.metadata.treeType === "closure-table") {
-                            await new ClosureSubjectExecutor(this.queryRunner).insert(subject);
+                            await new ClosureSubjectExecutor_1.ClosureSubjectExecutor(this.queryRunner).insert(subject);
                         }
                         else if (subject.metadata.treeType === "materialized-path") {
-                            await new MaterializedPathSubjectExecutor(this.queryRunner).insert(subject);
+                            await new MaterializedPathSubjectExecutor_1.MaterializedPathSubjectExecutor(this.queryRunner).insert(subject);
                         }
                     }
                 }
@@ -308,7 +311,7 @@ export class SubjectExecutor {
                     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);
+                            const preparedValue = this.queryRunner.dataSource.driver.prepareHydratedValue(value, column);
                             column.setEntityValue(subject.generatedMap, preparedValue);
                         }
                     });
@@ -322,9 +325,9 @@ export class SubjectExecutor {
     async executeUpdateOperations() {
         const updateSubject = async (subject) => {
             if (!subject.identifier)
-                throw new SubjectWithoutIdentifierError(subject);
+                throw new SubjectWithoutIdentifierError_1.SubjectWithoutIdentifierError(subject);
             // for mongodb we have a bit different updation logic
-            if (InstanceChecker.isMongoEntityManager(this.queryRunner.manager)) {
+            if (InstanceChecker_1.InstanceChecker.isMongoEntityManager(this.queryRunner.manager)) {
                 const partialEntity = this.cloneMongoSubjectEntity(subject);
                 if (subject.metadata.objectIdColumn &&
                     subject.metadata.objectIdColumn.propertyName) {
@@ -346,13 +349,13 @@ export class SubjectExecutor {
                 // for tree tables we execute additional queries
                 switch (subject.metadata.treeType) {
                     case "nested-set":
-                        await new NestedSetSubjectExecutor(this.queryRunner).update(subject);
+                        await new NestedSetSubjectExecutor_1.NestedSetSubjectExecutor(this.queryRunner).update(subject);
                         break;
                     case "closure-table":
-                        await new ClosureSubjectExecutor(this.queryRunner).update(subject);
+                        await new ClosureSubjectExecutor_1.ClosureSubjectExecutor(this.queryRunner).update(subject);
                         break;
                     case "materialized-path":
-                        await new MaterializedPathSubjectExecutor(this.queryRunner).update(subject);
+                        await new MaterializedPathSubjectExecutor_1.MaterializedPathSubjectExecutor(this.queryRunner).update(subject);
                         break;
                 }
                 // here we execute our updation query
@@ -380,7 +383,7 @@ export class SubjectExecutor {
                     subject.metadata.columns.forEach((column) => {
                         const value = column.getEntityValue(updateGeneratedMap);
                         if (value !== undefined && value !== null) {
-                            const preparedValue = this.queryRunner.connection.driver.prepareHydratedValue(value, column);
+                            const preparedValue = this.queryRunner.dataSource.driver.prepareHydratedValue(value, column);
                             column.setEntityValue(updateGeneratedMap, preparedValue);
                         }
                     });
@@ -427,11 +430,11 @@ export class SubjectExecutor {
             const subjects = groupedRemoveSubjects[groupName];
             const deleteMaps = subjects.map((subject) => {
                 if (!subject.identifier)
-                    throw new SubjectWithoutIdentifierError(subject);
+                    throw new SubjectWithoutIdentifierError_1.SubjectWithoutIdentifierError(subject);
                 return subject.identifier;
             });
             // for mongodb we have a bit different updation logic
-            if (InstanceChecker.isMongoEntityManager(this.queryRunner.manager)) {
+            if (InstanceChecker_1.InstanceChecker.isMongoEntityManager(this.queryRunner.manager)) {
                 const manager = this.queryRunner.manager;
                 await manager.delete(subjects[0].metadata.target, deleteMaps);
             }
@@ -439,10 +442,10 @@ export class SubjectExecutor {
                 // for tree tables we execute additional queries
                 switch (subjects[0].metadata.treeType) {
                     case "nested-set":
-                        await new NestedSetSubjectExecutor(this.queryRunner).remove(subjects);
+                        await new NestedSetSubjectExecutor_1.NestedSetSubjectExecutor(this.queryRunner).remove(subjects);
                         break;
                     case "closure-table":
-                        await new ClosureSubjectExecutor(this.queryRunner).remove(subjects);
+                        await new ClosureSubjectExecutor_1.ClosureSubjectExecutor(this.queryRunner).remove(subjects);
                         break;
                 }
                 // here we execute our deletion query
@@ -463,7 +466,7 @@ export class SubjectExecutor {
         const target = {};
         if (subject.entity) {
             for (const column of subject.metadata.columns) {
-                OrmUtils.mergeDeep(target, column.getEntityValueMap(subject.entity));
+                OrmUtils_1.OrmUtils.mergeDeep(target, column.getEntityValueMap(subject.entity));
             }
         }
         return target;
@@ -474,10 +477,10 @@ export class SubjectExecutor {
     async executeSoftRemoveOperations() {
         await Promise.all(this.softRemoveSubjects.map(async (subject) => {
             if (!subject.identifier)
-                throw new SubjectWithoutIdentifierError(subject);
+                throw new SubjectWithoutIdentifierError_1.SubjectWithoutIdentifierError(subject);
             let updateResult;
             // for mongodb we have a bit different updation logic
-            if (InstanceChecker.isMongoEntityManager(this.queryRunner.manager)) {
+            if (InstanceChecker_1.InstanceChecker.isMongoEntityManager(this.queryRunner.manager)) {
                 const partialEntity = this.cloneMongoSubjectEntity(subject);
                 if (subject.metadata.objectIdColumn &&
                     subject.metadata.objectIdColumn.propertyName) {
@@ -526,7 +529,7 @@ export class SubjectExecutor {
                 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);
+                        const preparedValue = this.queryRunner.dataSource.driver.prepareHydratedValue(value, column);
                         column.setEntityValue(subject.generatedMap, preparedValue);
                     }
                 });
@@ -550,10 +553,10 @@ export class SubjectExecutor {
     async executeRecoverOperations() {
         await Promise.all(this.recoverSubjects.map(async (subject) => {
             if (!subject.identifier)
-                throw new SubjectWithoutIdentifierError(subject);
+                throw new SubjectWithoutIdentifierError_1.SubjectWithoutIdentifierError(subject);
             let updateResult;
             // for mongodb we have a bit different updation logic
-            if (InstanceChecker.isMongoEntityManager(this.queryRunner.manager)) {
+            if (InstanceChecker_1.InstanceChecker.isMongoEntityManager(this.queryRunner.manager)) {
                 const partialEntity = this.cloneMongoSubjectEntity(subject);
                 if (subject.metadata.objectIdColumn &&
                     subject.metadata.objectIdColumn.propertyName) {
@@ -602,7 +605,7 @@ export class SubjectExecutor {
                 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);
+                        const preparedValue = this.queryRunner.dataSource.driver.prepareHydratedValue(value, column);
                         column.setEntityValue(subject.generatedMap, preparedValue);
                     }
                 });
@@ -655,7 +658,7 @@ export class SubjectExecutor {
                 relationId.setValue(subject.entity);
             });
             // mongo _id remove
-            if (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 !==
@@ -668,6 +671,7 @@ export class SubjectExecutor {
     /**
      * Updates all special columns of the saving entities (create date, update date, version, etc.).
      * Also updates nullable columns and columns with default values.
+     * @param subjects
      */
     updateSpecialColumnsInInsertedAndUpdatedEntities(subjects) {
         subjects.forEach((subject) => {
@@ -693,13 +697,21 @@ export class SubjectExecutor {
                     if (columnValue === undefined)
                         column.setEntityValue(subject.entity, null);
                 }
+                if (!column.isSelect) {
+                    const target = column.embeddedMetadata
+                        ? OrmUtils_1.OrmUtils.deepValue(subject.entity, column.embeddedMetadata.propertyPath)
+                        : subject.entity;
+                    if (target) {
+                        delete target[column.propertyName];
+                    }
+                }
                 // update relational columns
                 if (subject.updatedRelationMaps.length > 0) {
                     subject.updatedRelationMaps.forEach((updatedRelationMap) => {
                         updatedRelationMap.relation.joinColumns.forEach((column) => {
                             if (column.isVirtual === true)
                                 return;
-                            column.setEntityValue(subject.entity, ObjectUtils.isObject(updatedRelationMap.value)
+                            column.setEntityValue(subject.entity, ObjectUtils_1.ObjectUtils.isObject(updatedRelationMap.value)
                                 ? column.referencedColumn.getEntityValue(updatedRelationMap.value)
                                 : updatedRelationMap.value);
                         });
@@ -721,6 +733,8 @@ export class SubjectExecutor {
      *
      * 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.
+     * @param subjects
+     * @param type
      */
     groupBulkSubjects(subjects, type) {
         const group = {};
@@ -729,7 +743,7 @@ export class SubjectExecutor {
             return subject.metadata.getInsertionReturningColumns().length > 0;
         });
         const groupingAllowed = type === "delete" ||
-            this.queryRunner.connection.driver.isReturningSqlSupported("insert") ||
+            this.queryRunner.dataSource.driver.isReturningSqlSupported("insert") ||
             hasReturningDependColumns === false;
         subjects.forEach((subject, index) => {
             const key = groupingAllowed || subject.metadata.isJunction
@@ -746,5 +760,5 @@ export class SubjectExecutor {
         return [group, keys];
     }
 }
-
-//# sourceMappingURL=SubjectExecutor.js.map
+exports.SubjectExecutor = SubjectExecutor;
+//# sourceMappingURL=SubjectExecutor.js.map