typeorm 0.3.0-rc.9 → 0.3.0

package/persistence/subject-builder/OneToManySubjectBuilder.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var Subject_1 = require("../Subject");
-var OrmUtils_1 = require("../../util/OrmUtils");
-var EntityMetadata_1 = require("../../metadata/EntityMetadata");
+exports.OneToManySubjectBuilder = void 0;
+const Subject_1 = require("../Subject");
+const OrmUtils_1 = require("../../util/OrmUtils");
+const EntityMetadata_1 = require("../../metadata/EntityMetadata");
 /**
  * Builds operations needs to be executed for one-to-many relations of the given subjects.
  *
@@ -14,11 +15,11 @@ var EntityMetadata_1 = require("../../metadata/EntityMetadata");
  * note: this class shares lot of things with OneToOneInverseSideOperationBuilder, so when you change this class
  *       make sure to reflect changes there as well.
  */
-var OneToManySubjectBuilder = /** @class */ (function () {
+class OneToManySubjectBuilder {
     // ---------------------------------------------------------------------
     // Constructor
     // ---------------------------------------------------------------------
-    function OneToManySubjectBuilder(subjects) {
+    constructor(subjects) {
         this.subjects = subjects;
     }
     // ---------------------------------------------------------------------
@@ -27,17 +28,16 @@ var OneToManySubjectBuilder = /** @class */ (function () {
     /**
      * Builds all required operations.
      */
-    OneToManySubjectBuilder.prototype.build = function () {
-        var _this = this;
-        this.subjects.forEach(function (subject) {
-            subject.metadata.oneToManyRelations.forEach(function (relation) {
+    build() {
+        this.subjects.forEach((subject) => {
+            subject.metadata.oneToManyRelations.forEach((relation) => {
                 // skip relations for which persistence is disabled
                 if (relation.persistenceEnabled === false)
                     return;
-                _this.buildForSubjectRelation(subject, relation);
+                this.buildForSubjectRelation(subject, relation);
             });
         });
-    };
+    }
     // ---------------------------------------------------------------------
     // Protected Methods
     // ---------------------------------------------------------------------
@@ -46,30 +46,40 @@ var OneToManySubjectBuilder = /** @class */ (function () {
      *
      * by example: subject is "post" entity we are saving here and relation is "categories" inside it here.
      */
-    OneToManySubjectBuilder.prototype.buildForSubjectRelation = function (subject, relation) {
-        var _this = this;
+    buildForSubjectRelation(subject, relation) {
         // prepare objects (relation id maps) for the database entity
-        // note: subject.databaseEntity contains relations with loaded relation ids only
         // by example: since subject is a post, we are expecting to get all post's categories saved in the database here,
         //             particularly their relation ids, e.g. category ids stored in the database
-        var relatedEntityDatabaseRelationIds = [];
-        if (subject.databaseEntity) { // related entities in the database can exist only if this entity (post) is saved
-            relatedEntityDatabaseRelationIds = relation.getEntityValue(subject.databaseEntity);
+        // in most cases relatedEntityDatabaseValues will contain only the entity key properties.
+        // this is because subject.databaseEntity contains relations with loaded relation ids only.
+        // however if the entity uses the afterLoad hook to calculate any properties, the fetched "key object" might include ADDITIONAL properties.
+        // to handle such situations, we pass the data to relation.inverseEntityMetadata.getEntityIdMap to extract the key without any other properties.
+        let relatedEntityDatabaseRelationIds = [];
+        if (subject.databaseEntity) {
+            // related entities in the database can exist only if this entity (post) is saved
+            const relatedEntityDatabaseRelation = relation.getEntityValue(subject.databaseEntity);
+            if (relatedEntityDatabaseRelation) {
+                relatedEntityDatabaseRelationIds =
+                    relatedEntityDatabaseRelation.map((entity) => relation.inverseEntityMetadata.getEntityIdMap(entity));
+            }
         }
         // get related entities of persisted entity
         // by example: get categories from the passed to persist post entity
-        var relatedEntities = relation.getEntityValue(subject.entity);
-        if (relatedEntities === null) // we treat relations set to null as removed, so we don't skip it
+        let relatedEntities = relation.getEntityValue(subject.entity);
+        if (relatedEntities === null)
+            // we treat relations set to null as removed, so we don't skip it
             relatedEntities = [];
-        if (relatedEntities === undefined) // if relation is undefined then nothing to update
+        if (relatedEntities === undefined)
+            // if relation is undefined then nothing to update
             return;
-        // extract only relation ids from the related entities, since we only need them for comparision
+        // extract only relation ids from the related entities, since we only need them for comparison
         // by example: extract from categories only relation ids (category id, or let's say category title, depend on join column options)
-        var relatedPersistedEntityRelationIds = [];
-        relatedEntities.forEach(function (relatedEntity) {
-            var relationIdMap = relation.inverseEntityMetadata.getEntityIdMap(relatedEntity); // by example: relationIdMap is category.id map here, e.g. { id: ... }
+        const relatedPersistedEntityRelationIds = [];
+        relatedEntities.forEach((relatedEntity) => {
+            // by example: relatedEntity is a category here
+            let relationIdMap = relation.inverseEntityMetadata.getEntityIdMap(relatedEntity); // by example: relationIdMap is category.id map here, e.g. { id: ... }
             // try to find a subject of this related entity, maybe it was loaded or was marked for persistence
-            var relatedEntitySubject = _this.subjects.find(function (subject) {
+            let relatedEntitySubject = this.subjects.find((subject) => {
                 return subject.entity === relatedEntity;
             });
             // if subject with entity was found take subject identifier as relation id map since it may contain extra properties resolved
@@ -82,7 +92,7 @@ var OneToManySubjectBuilder = /** @class */ (function () {
             if (!relationIdMap) {
                 // we decided to remove this error because it brings complications when saving object with non-saved entities
                 // if (!relatedEntitySubject)
-                //     throw new Error(`One-to-many relation "${relation.entityMetadata.name}.${relation.propertyPath}" contains ` +
+                //     throw new TypeORMError(`One-to-many relation "${relation.entityMetadata.name}.${relation.propertyPath}" contains ` +
                 //         `entities which do not exist in the database yet, thus they cannot be bind in the database. ` +
                 //         `Please setup cascade insertion or save entities before binding it.`);
                 if (!relatedEntitySubject)
@@ -94,14 +104,14 @@ var OneToManySubjectBuilder = /** @class */ (function () {
                 //             subject is Post needs to be inserted into Category
                 relatedEntitySubject.changeMaps.push({
                     relation: relation.inverseRelation,
-                    value: subject
+                    value: subject,
                 });
                 return;
             }
             // check if this binding really exist in the database
             // by example: find our category if its already bind in the database
-            var relationIdInDatabaseSubjectRelation = relatedEntityDatabaseRelationIds.find(function (relatedDatabaseEntityRelationId) {
-                return OrmUtils_1.OrmUtils.deepCompare(relationIdMap, relatedDatabaseEntityRelationId);
+            const relationIdInDatabaseSubjectRelation = relatedEntityDatabaseRelationIds.find((relatedDatabaseEntityRelationId) => {
+                return OrmUtils_1.OrmUtils.compareIds(relationIdMap, relatedDatabaseEntityRelationId);
             });
             // if relationIdMap DOES NOT exist in the subject's relation in the database it means its a new relation and we need to "bind" them
             // by example: this will tell category to insert into its post relation our post we are working with
@@ -117,13 +127,13 @@ var OneToManySubjectBuilder = /** @class */ (function () {
                         metadata: relation.inverseEntityMetadata,
                         parentSubject: subject,
                         canBeUpdated: true,
-                        identifier: relationIdMap
+                        identifier: relationIdMap,
                     });
-                    _this.subjects.push(relatedEntitySubject);
+                    this.subjects.push(relatedEntitySubject);
                 }
                 relatedEntitySubject.changeMaps.push({
                     relation: relation.inverseRelation,
-                    value: subject
+                    value: subject,
                 });
             }
             // if related entity has relation id then we add it to the list of relation ids
@@ -134,27 +144,36 @@ var OneToManySubjectBuilder = /** @class */ (function () {
             relatedPersistedEntityRelationIds.push(relationIdMap);
         });
         // find what related entities were added and what were removed based on difference between what we save and what database has
-        EntityMetadata_1.EntityMetadata
-            .difference(relatedEntityDatabaseRelationIds, relatedPersistedEntityRelationIds)
-            .forEach(function (removedRelatedEntityRelationId) {
+        EntityMetadata_1.EntityMetadata.difference(relatedEntityDatabaseRelationIds, relatedPersistedEntityRelationIds).forEach((removedRelatedEntityRelationId) => {
+            // by example: removedRelatedEntityRelationId is category that was bind in the database before, but now its unbind
             // todo: probably we can improve this in the future by finding entity with column those values,
             // todo: maybe it was already in persistence process. This is possible due to unique requirements of join columns
             // we create a new subject which operations will be executed in subject operation executor
-            var removedRelatedEntitySubject = new Subject_1.Subject({
+            const removedRelatedEntitySubject = new Subject_1.Subject({
                 metadata: relation.inverseEntityMetadata,
                 parentSubject: subject,
-                canBeUpdated: true,
                 identifier: removedRelatedEntityRelationId,
-                changeMaps: [{
-                        relation: relation.inverseRelation,
-                        value: null
-                    }]
             });
-            _this.subjects.push(removedRelatedEntitySubject);
+            if (!relation.inverseRelation ||
+                relation.inverseRelation.orphanedRowAction === "nullify") {
+                removedRelatedEntitySubject.canBeUpdated = true;
+                removedRelatedEntitySubject.changeMaps = [
+                    {
+                        relation: relation.inverseRelation,
+                        value: null,
+                    },
+                ];
+            }
+            else if (relation.inverseRelation.orphanedRowAction === "delete") {
+                removedRelatedEntitySubject.mustBeRemoved = true;
+            }
+            else if (relation.inverseRelation.orphanedRowAction === "soft-delete") {
+                removedRelatedEntitySubject.canBeSoftRemoved = true;
+            }
+            this.subjects.push(removedRelatedEntitySubject);
         });
-    };
-    return OneToManySubjectBuilder;
-}());
+    }
+}
 exports.OneToManySubjectBuilder = OneToManySubjectBuilder;
 
 //# sourceMappingURL=OneToManySubjectBuilder.js.map

package/persistence/subject-builder/OneToManySubjectBuilder.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/persistence/subject-builder/OneToManySubjectBuilder.ts"],"names":[],"mappings":"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","file":"OneToManySubjectBuilder.js","sourcesContent":["import {Subject} from \"../Subject\";\nimport {OrmUtils} from \"../../util/OrmUtils\";\nimport {ObjectLiteral} from \"../../common/ObjectLiteral\";\nimport {EntityMetadata} from \"../../metadata/EntityMetadata\";\nimport {RelationMetadata} from \"../../metadata/RelationMetadata\";\n\n/**\n * Builds operations needs to be executed for one-to-many relations of the given subjects.\n *\n * by example: post contains one-to-many relation with category in the property called \"categories\", e.g.\n *             @OneToMany(type => Category, category => category.post) categories: Category[]\n *             If user adds categories into the post and saves post we need to bind them.\n *             This operation requires updation of category table since its owner of the relation and contains a join column.\n *\n * note: this class shares lot of things with OneToOneInverseSideOperationBuilder, so when you change this class\n *       make sure to reflect changes there as well.\n */\nexport class OneToManySubjectBuilder {\n\n    // ---------------------------------------------------------------------\n    // Constructor\n    // ---------------------------------------------------------------------\n\n    constructor(protected subjects: Subject[]) {\n    }\n\n    // ---------------------------------------------------------------------\n    // Public Methods\n    // ---------------------------------------------------------------------\n\n    /**\n     * Builds all required operations.\n     */\n    build(): void {\n        this.subjects.forEach(subject => {\n            subject.metadata.oneToManyRelations.forEach(relation => {\n\n                // skip relations for which persistence is disabled\n                if (relation.persistenceEnabled === false)\n                    return;\n\n                this.buildForSubjectRelation(subject, relation);\n            });\n        });\n    }\n\n    // ---------------------------------------------------------------------\n    // Protected Methods\n    // ---------------------------------------------------------------------\n\n    /**\n     * Builds operations for a given subject and relation.\n     *\n     * by example: subject is \"post\" entity we are saving here and relation is \"categories\" inside it here.\n     */\n    protected buildForSubjectRelation(subject: Subject, relation: RelationMetadata) {\n\n        // prepare objects (relation id maps) for the database entity\n        // note: subject.databaseEntity contains relations with loaded relation ids only\n        // by example: since subject is a post, we are expecting to get all post's categories saved in the database here,\n        //             particularly their relation ids, e.g. category ids stored in the database\n        let relatedEntityDatabaseRelationIds: ObjectLiteral[] = [];\n        if (subject.databaseEntity) { // related entities in the database can exist only if this entity (post) is saved\n            relatedEntityDatabaseRelationIds = relation.getEntityValue(subject.databaseEntity);\n        }\n\n        // get related entities of persisted entity\n        // by example: get categories from the passed to persist post entity\n        let relatedEntities: ObjectLiteral[] = relation.getEntityValue(subject.entity!);\n        if (relatedEntities === null) // we treat relations set to null as removed, so we don't skip it\n            relatedEntities = [] as ObjectLiteral[];\n        if (relatedEntities === undefined) // if relation is undefined then nothing to update\n            return;\n\n        // extract only relation ids from the related entities, since we only need them for comparision\n        // by example: extract from categories only relation ids (category id, or let's say category title, depend on join column options)\n        const relatedPersistedEntityRelationIds: ObjectLiteral[] = [];\n        relatedEntities.forEach(relatedEntity => { // by example: relatedEntity is a category here\n            let relationIdMap = relation.inverseEntityMetadata!.getEntityIdMap(relatedEntity); // by example: relationIdMap is category.id map here, e.g. { id: ... }\n\n            // try to find a subject of this related entity, maybe it was loaded or was marked for persistence\n            let relatedEntitySubject = this.subjects.find(subject => {\n                return subject.entity === relatedEntity;\n            });\n\n            // if subject with entity was found take subject identifier as relation id map since it may contain extra properties resolved\n            if (relatedEntitySubject)\n                relationIdMap = relatedEntitySubject.identifier;\n\n            // if relationIdMap is undefined then it means user binds object which is not saved in the database yet\n            // by example: if post contains categories which does not have ids yet (because they are new)\n            //             it means they are always newly inserted and relation update operation always must be created for them\n            //             it does not make sense to perform difference operation for them for both add and remove actions\n            if (!relationIdMap) {\n\n                // we decided to remove this error because it brings complications when saving object with non-saved entities\n                // if (!relatedEntitySubject)\n                //     throw new Error(`One-to-many relation \"${relation.entityMetadata.name}.${relation.propertyPath}\" contains ` +\n                //         `entities which do not exist in the database yet, thus they cannot be bind in the database. ` +\n                //         `Please setup cascade insertion or save entities before binding it.`);\n                if (!relatedEntitySubject)\n                    return;\n\n                // okay, so related subject exist and its marked for insertion, then add a new change map\n                // by example: this will tell category to insert into its post relation our post we are working with\n                //             relatedEntitySubject is newly inserted CategorySubject\n                //             relation.inverseRelation is ManyToOne relation inside Category\n                //             subject is Post needs to be inserted into Category\n                relatedEntitySubject.changeMaps.push({\n                    relation: relation.inverseRelation!,\n                    value: subject\n                });\n\n                return;\n            }\n\n            // check if this binding really exist in the database\n            // by example: find our category if its already bind in the database\n            const relationIdInDatabaseSubjectRelation = relatedEntityDatabaseRelationIds.find(relatedDatabaseEntityRelationId => {\n                return OrmUtils.deepCompare(relationIdMap, relatedDatabaseEntityRelationId);\n            });\n\n            // if relationIdMap DOES NOT exist in the subject's relation in the database it means its a new relation and we need to \"bind\" them\n            // by example: this will tell category to insert into its post relation our post we are working with\n            //             relatedEntitySubject is newly inserted CategorySubject\n            //             relation.inverseRelation is ManyToOne relation inside Category\n            //             subject is Post needs to be inserted into Category\n            if (!relationIdInDatabaseSubjectRelation) {\n\n                // if there is no relatedEntitySubject then it means \"category\" wasn't persisted,\n                // but since we are going to update \"category\" table (since its an owning side of relation with join column)\n                // we create a new subject here:\n                if (!relatedEntitySubject) {\n                    relatedEntitySubject = new Subject({\n                        metadata: relation.inverseEntityMetadata,\n                        parentSubject: subject,\n                        canBeUpdated: true,\n                        identifier: relationIdMap\n                    });\n                    this.subjects.push(relatedEntitySubject);\n                }\n\n                relatedEntitySubject.changeMaps.push({\n                    relation: relation.inverseRelation!,\n                    value: subject\n                });\n            }\n\n            // if related entity has relation id then we add it to the list of relation ids\n            // this list will be used later to compare with database relation ids to find a difference\n            // what exist in this array and does not exist in the database are newly inserted relations\n            // what does not exist in this array, but exist in the database are removed relations\n            // removed relations are set to null from inverse side of relation\n            relatedPersistedEntityRelationIds.push(relationIdMap);\n        });\n\n        // find what related entities were added and what were removed based on difference between what we save and what database has\n        EntityMetadata\n            .difference(relatedEntityDatabaseRelationIds, relatedPersistedEntityRelationIds)\n            .forEach(removedRelatedEntityRelationId => { // by example: removedRelatedEntityRelationId is category that was bind in the database before, but now its unbind\n\n                // todo: probably we can improve this in the future by finding entity with column those values,\n                // todo: maybe it was already in persistence process. This is possible due to unique requirements of join columns\n                // we create a new subject which operations will be executed in subject operation executor\n                const removedRelatedEntitySubject = new Subject({\n                    metadata: relation.inverseEntityMetadata,\n                    parentSubject: subject,\n                    canBeUpdated: true,\n                    identifier: removedRelatedEntityRelationId,\n                    changeMaps: [{\n                        relation: relation.inverseRelation!,\n                        value: null\n                    }]\n                });\n                this.subjects.push(removedRelatedEntitySubject);\n            });\n    }\n\n}"],"sourceRoot":"../.."}
+{"version":3,"sources":["../../src/persistence/subject-builder/OneToManySubjectBuilder.ts"],"names":[],"mappings":"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","file":"OneToManySubjectBuilder.js","sourcesContent":["import { Subject } from \"../Subject\"\nimport { OrmUtils } from \"../../util/OrmUtils\"\nimport { ObjectLiteral } from \"../../common/ObjectLiteral\"\nimport { EntityMetadata } from \"../../metadata/EntityMetadata\"\nimport { RelationMetadata } from \"../../metadata/RelationMetadata\"\n\n/**\n * Builds operations needs to be executed for one-to-many relations of the given subjects.\n *\n * by example: post contains one-to-many relation with category in the property called \"categories\", e.g.\n *             @OneToMany(type => Category, category => category.post) categories: Category[]\n *             If user adds categories into the post and saves post we need to bind them.\n *             This operation requires updation of category table since its owner of the relation and contains a join column.\n *\n * note: this class shares lot of things with OneToOneInverseSideOperationBuilder, so when you change this class\n *       make sure to reflect changes there as well.\n */\nexport class OneToManySubjectBuilder {\n    // ---------------------------------------------------------------------\n    // Constructor\n    // ---------------------------------------------------------------------\n\n    constructor(protected subjects: Subject[]) {}\n\n    // ---------------------------------------------------------------------\n    // Public Methods\n    // ---------------------------------------------------------------------\n\n    /**\n     * Builds all required operations.\n     */\n    build(): void {\n        this.subjects.forEach((subject) => {\n            subject.metadata.oneToManyRelations.forEach((relation) => {\n                // skip relations for which persistence is disabled\n                if (relation.persistenceEnabled === false) return\n\n                this.buildForSubjectRelation(subject, relation)\n            })\n        })\n    }\n\n    // ---------------------------------------------------------------------\n    // Protected Methods\n    // ---------------------------------------------------------------------\n\n    /**\n     * Builds operations for a given subject and relation.\n     *\n     * by example: subject is \"post\" entity we are saving here and relation is \"categories\" inside it here.\n     */\n    protected buildForSubjectRelation(\n        subject: Subject,\n        relation: RelationMetadata,\n    ) {\n        // prepare objects (relation id maps) for the database entity\n        // by example: since subject is a post, we are expecting to get all post's categories saved in the database here,\n        //             particularly their relation ids, e.g. category ids stored in the database\n\n        // in most cases relatedEntityDatabaseValues will contain only the entity key properties.\n        // this is because subject.databaseEntity contains relations with loaded relation ids only.\n        // however if the entity uses the afterLoad hook to calculate any properties, the fetched \"key object\" might include ADDITIONAL properties.\n        // to handle such situations, we pass the data to relation.inverseEntityMetadata.getEntityIdMap to extract the key without any other properties.\n\n        let relatedEntityDatabaseRelationIds: ObjectLiteral[] = []\n        if (subject.databaseEntity) {\n            // related entities in the database can exist only if this entity (post) is saved\n            const relatedEntityDatabaseRelation: ObjectLiteral[] | undefined =\n                relation.getEntityValue(subject.databaseEntity)\n            if (relatedEntityDatabaseRelation) {\n                relatedEntityDatabaseRelationIds =\n                    relatedEntityDatabaseRelation.map(\n                        (entity) =>\n                            relation.inverseEntityMetadata.getEntityIdMap(\n                                entity,\n                            )!,\n                    )\n            }\n        }\n\n        // get related entities of persisted entity\n        // by example: get categories from the passed to persist post entity\n        let relatedEntities: ObjectLiteral[] = relation.getEntityValue(\n            subject.entity!,\n        )\n        if (relatedEntities === null)\n            // we treat relations set to null as removed, so we don't skip it\n            relatedEntities = [] as ObjectLiteral[]\n        if (relatedEntities === undefined)\n            // if relation is undefined then nothing to update\n            return\n\n        // extract only relation ids from the related entities, since we only need them for comparison\n        // by example: extract from categories only relation ids (category id, or let's say category title, depend on join column options)\n        const relatedPersistedEntityRelationIds: ObjectLiteral[] = []\n        relatedEntities.forEach((relatedEntity) => {\n            // by example: relatedEntity is a category here\n            let relationIdMap =\n                relation.inverseEntityMetadata!.getEntityIdMap(relatedEntity) // by example: relationIdMap is category.id map here, e.g. { id: ... }\n\n            // try to find a subject of this related entity, maybe it was loaded or was marked for persistence\n            let relatedEntitySubject = this.subjects.find((subject) => {\n                return subject.entity === relatedEntity\n            })\n\n            // if subject with entity was found take subject identifier as relation id map since it may contain extra properties resolved\n            if (relatedEntitySubject)\n                relationIdMap = relatedEntitySubject.identifier\n\n            // if relationIdMap is undefined then it means user binds object which is not saved in the database yet\n            // by example: if post contains categories which does not have ids yet (because they are new)\n            //             it means they are always newly inserted and relation update operation always must be created for them\n            //             it does not make sense to perform difference operation for them for both add and remove actions\n            if (!relationIdMap) {\n                // we decided to remove this error because it brings complications when saving object with non-saved entities\n                // if (!relatedEntitySubject)\n                //     throw new TypeORMError(`One-to-many relation \"${relation.entityMetadata.name}.${relation.propertyPath}\" contains ` +\n                //         `entities which do not exist in the database yet, thus they cannot be bind in the database. ` +\n                //         `Please setup cascade insertion or save entities before binding it.`);\n                if (!relatedEntitySubject) return\n\n                // okay, so related subject exist and its marked for insertion, then add a new change map\n                // by example: this will tell category to insert into its post relation our post we are working with\n                //             relatedEntitySubject is newly inserted CategorySubject\n                //             relation.inverseRelation is ManyToOne relation inside Category\n                //             subject is Post needs to be inserted into Category\n                relatedEntitySubject.changeMaps.push({\n                    relation: relation.inverseRelation!,\n                    value: subject,\n                })\n\n                return\n            }\n\n            // check if this binding really exist in the database\n            // by example: find our category if its already bind in the database\n            const relationIdInDatabaseSubjectRelation =\n                relatedEntityDatabaseRelationIds.find(\n                    (relatedDatabaseEntityRelationId) => {\n                        return OrmUtils.compareIds(\n                            relationIdMap,\n                            relatedDatabaseEntityRelationId,\n                        )\n                    },\n                )\n\n            // if relationIdMap DOES NOT exist in the subject's relation in the database it means its a new relation and we need to \"bind\" them\n            // by example: this will tell category to insert into its post relation our post we are working with\n            //             relatedEntitySubject is newly inserted CategorySubject\n            //             relation.inverseRelation is ManyToOne relation inside Category\n            //             subject is Post needs to be inserted into Category\n            if (!relationIdInDatabaseSubjectRelation) {\n                // if there is no relatedEntitySubject then it means \"category\" wasn't persisted,\n                // but since we are going to update \"category\" table (since its an owning side of relation with join column)\n                // we create a new subject here:\n                if (!relatedEntitySubject) {\n                    relatedEntitySubject = new Subject({\n                        metadata: relation.inverseEntityMetadata,\n                        parentSubject: subject,\n                        canBeUpdated: true,\n                        identifier: relationIdMap,\n                    })\n                    this.subjects.push(relatedEntitySubject)\n                }\n\n                relatedEntitySubject.changeMaps.push({\n                    relation: relation.inverseRelation!,\n                    value: subject,\n                })\n            }\n\n            // if related entity has relation id then we add it to the list of relation ids\n            // this list will be used later to compare with database relation ids to find a difference\n            // what exist in this array and does not exist in the database are newly inserted relations\n            // what does not exist in this array, but exist in the database are removed relations\n            // removed relations are set to null from inverse side of relation\n            relatedPersistedEntityRelationIds.push(relationIdMap)\n        })\n\n        // find what related entities were added and what were removed based on difference between what we save and what database has\n        EntityMetadata.difference(\n            relatedEntityDatabaseRelationIds,\n            relatedPersistedEntityRelationIds,\n        ).forEach((removedRelatedEntityRelationId) => {\n            // by example: removedRelatedEntityRelationId is category that was bind in the database before, but now its unbind\n\n            // todo: probably we can improve this in the future by finding entity with column those values,\n            // todo: maybe it was already in persistence process. This is possible due to unique requirements of join columns\n            // we create a new subject which operations will be executed in subject operation executor\n            const removedRelatedEntitySubject = new Subject({\n                metadata: relation.inverseEntityMetadata,\n                parentSubject: subject,\n                identifier: removedRelatedEntityRelationId,\n            })\n\n            if (\n                !relation.inverseRelation ||\n                relation.inverseRelation.orphanedRowAction === \"nullify\"\n            ) {\n                removedRelatedEntitySubject.canBeUpdated = true\n                removedRelatedEntitySubject.changeMaps = [\n                    {\n                        relation: relation.inverseRelation!,\n                        value: null,\n                    },\n                ]\n            } else if (\n                relation.inverseRelation.orphanedRowAction === \"delete\"\n            ) {\n                removedRelatedEntitySubject.mustBeRemoved = true\n            } else if (\n                relation.inverseRelation.orphanedRowAction === \"soft-delete\"\n            ) {\n                removedRelatedEntitySubject.canBeSoftRemoved = true\n            }\n\n            this.subjects.push(removedRelatedEntitySubject)\n        })\n    }\n}\n"],"sourceRoot":"../.."}

package/persistence/subject-builder/OneToOneInverseSideSubjectBuilder.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var Subject_1 = require("../Subject");
-var OrmUtils_1 = require("../../util/OrmUtils");
+exports.OneToOneInverseSideSubjectBuilder = void 0;
+const Subject_1 = require("../Subject");
+const OrmUtils_1 = require("../../util/OrmUtils");
 /**
  * Builds operations needs to be executed for one-to-one non-owner relations of the given subjects.
  *
@@ -13,11 +14,11 @@ var OrmUtils_1 = require("../../util/OrmUtils");
  * note: this class shares lot of things with OneToManyUpdateBuilder, so when you change this class
  *       make sure to reflect changes there as well.
  */
-var OneToOneInverseSideSubjectBuilder = /** @class */ (function () {
+class OneToOneInverseSideSubjectBuilder {
     // ---------------------------------------------------------------------
     // Constructor
     // ---------------------------------------------------------------------
-    function OneToOneInverseSideSubjectBuilder(subjects) {
+    constructor(subjects) {
         this.subjects = subjects;
     }
     // ---------------------------------------------------------------------
@@ -26,18 +27,17 @@ var OneToOneInverseSideSubjectBuilder = /** @class */ (function () {
     /**
      * Builds all required operations.
      */
-    OneToOneInverseSideSubjectBuilder.prototype.build = function () {
-        var _this = this;
-        this.subjects.forEach(function (subject) {
-            subject.metadata.oneToOneRelations.forEach(function (relation) {
+    build() {
+        this.subjects.forEach((subject) => {
+            subject.metadata.oneToOneRelations.forEach((relation) => {
                 // we don't need owning relations, this operation is only for inverse side of one-to-one relations
                 // skip relations for which persistence is disabled
                 if (relation.isOwning || relation.persistenceEnabled === false)
                     return;
-                _this.buildForSubjectRelation(subject, relation);
+                this.buildForSubjectRelation(subject, relation);
             });
         });
-    };
+    }
     // ---------------------------------------------------------------------
     // Protected Methods
     // ---------------------------------------------------------------------
@@ -46,18 +46,20 @@ var OneToOneInverseSideSubjectBuilder = /** @class */ (function () {
      *
      * by example: subject is "post" entity we are saving here and relation is "category" inside it here.
      */
-    OneToOneInverseSideSubjectBuilder.prototype.buildForSubjectRelation = function (subject, relation) {
+    buildForSubjectRelation(subject, relation) {
         // prepare objects (relation id map) for the database entity
         // note: subject.databaseEntity contains relation with loaded relation id only (id map)
         // by example: since subject is a post, we are expecting to get post's category saved in the database here,
         //             particularly its relation id, e.g. category id stored in the database
-        var relatedEntityDatabaseRelationId = undefined;
-        if (subject.databaseEntity) // related entity in the database can exist only if this entity (post) is saved
+        let relatedEntityDatabaseRelationId = undefined;
+        if (subject.databaseEntity)
+            // related entity in the database can exist only if this entity (post) is saved
             relatedEntityDatabaseRelationId = relation.getEntityValue(subject.databaseEntity);
         // get related entities of persisted entity
         // by example: get category from the passed to persist post entity
-        var relatedEntity = relation.getEntityValue(subject.entity); // by example: relatedEntity is a category here
-        if (relatedEntity === undefined) // if relation is undefined then nothing to update
+        let relatedEntity = relation.getEntityValue(subject.entity); // by example: relatedEntity is a category here
+        if (relatedEntity === undefined)
+            // if relation is undefined then nothing to update
             return;
         // if related entity is null then we need to check if there a bind in the database and unset it
         // if there is no bind in the entity then we don't need to do anything
@@ -68,15 +70,17 @@ var OneToOneInverseSideSubjectBuilder = /** @class */ (function () {
                 // todo: probably we can improve this in the future by finding entity with column those values,
                 // todo: maybe it was already in persistence process. This is possible due to unique requirements of join columns
                 // we create a new subject which operations will be executed in subject operation executor
-                var removedRelatedEntitySubject = new Subject_1.Subject({
+                const removedRelatedEntitySubject = new Subject_1.Subject({
                     metadata: relation.inverseEntityMetadata,
                     parentSubject: subject,
                     canBeUpdated: true,
                     identifier: relatedEntityDatabaseRelationId,
-                    changeMaps: [{
+                    changeMaps: [
+                        {
                             relation: relation.inverseRelation,
-                            value: null
-                        }]
+                            value: null,
+                        },
+                    ],
                 });
                 this.subjects.push(removedRelatedEntitySubject);
             }
@@ -84,10 +88,11 @@ var OneToOneInverseSideSubjectBuilder = /** @class */ (function () {
         } // else means entity is bind in the database
         // extract only relation id from the related entities, since we only need it for comparision
         // by example: extract from category only relation id (category id, or let's say category title, depend on join column options)
-        var relationIdMap = relation.inverseEntityMetadata.getEntityIdMap(relatedEntity); // by example: relationIdMap is category.id map here, e.g. { id: ... }
+        let relationIdMap = relation.inverseEntityMetadata.getEntityIdMap(relatedEntity); // by example: relationIdMap is category.id map here, e.g. { id: ... }
         // try to find a subject of this related entity, maybe it was loaded or was marked for persistence
-        var relatedEntitySubject = this.subjects.find(function (operateSubject) {
-            return !!operateSubject.entity && operateSubject.entity === relatedEntity;
+        let relatedEntitySubject = this.subjects.find((operateSubject) => {
+            return (!!operateSubject.entity &&
+                operateSubject.entity === relatedEntity);
         });
         // if subject with entity was found take subject identifier as relation id map since it may contain extra properties resolved
         if (relatedEntitySubject)
@@ -102,7 +107,7 @@ var OneToOneInverseSideSubjectBuilder = /** @class */ (function () {
             // in this persistence because he didn't pass this entity for save or he did not set cascades
             // but without entity being inserted we cannot bind it in the relation operation, so we throw an exception here
             // if (!relatedEntitySubject)
-            //     throw new Error(`One-to-one inverse relation "${relation.entityMetadata.name}.${relation.propertyPath}" contains ` +
+            //     throw new TypeORMError(`One-to-one inverse relation "${relation.entityMetadata.name}.${relation.propertyPath}" contains ` +
             //         `entity which does not exist in the database yet, thus cannot be bind in the database. ` +
             //         `Please setup cascade insertion or save entity before binding it.`);
             if (!relatedEntitySubject)
@@ -114,12 +119,13 @@ var OneToOneInverseSideSubjectBuilder = /** @class */ (function () {
             //             subject is Post needs to be inserted into Category
             relatedEntitySubject.changeMaps.push({
                 relation: relation.inverseRelation,
-                value: subject
+                value: subject,
             });
         }
         // check if this binding really exist in the database
         // by example: find our post if its already bind to category in the database and its not equal to what user tries to set
-        var areRelatedIdEqualWithDatabase = relatedEntityDatabaseRelationId && OrmUtils_1.OrmUtils.deepCompare(relationIdMap, relatedEntityDatabaseRelationId);
+        const areRelatedIdEqualWithDatabase = relatedEntityDatabaseRelationId &&
+            OrmUtils_1.OrmUtils.compareIds(relationIdMap, relatedEntityDatabaseRelationId);
         // if they aren't equal it means its a new relation and we need to "bind" them
         // by example: this will tell category to insert into its post relation our post we are working with
         //             relatedEntitySubject is newly inserted CategorySubject
@@ -133,18 +139,17 @@ var OneToOneInverseSideSubjectBuilder = /** @class */ (function () {
                 relatedEntitySubject = new Subject_1.Subject({
                     metadata: relation.inverseEntityMetadata,
                     canBeUpdated: true,
-                    identifier: relationIdMap
+                    identifier: relationIdMap,
                 });
                 this.subjects.push(relatedEntitySubject);
             }
             relatedEntitySubject.changeMaps.push({
                 relation: relation.inverseRelation,
-                value: subject
+                value: subject,
             });
         }
-    };
-    return OneToOneInverseSideSubjectBuilder;
-}());
+    }
+}
 exports.OneToOneInverseSideSubjectBuilder = OneToOneInverseSideSubjectBuilder;
 
 //# sourceMappingURL=OneToOneInverseSideSubjectBuilder.js.map

package/persistence/subject-builder/OneToOneInverseSideSubjectBuilder.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/persistence/subject-builder/OneToOneInverseSideSubjectBuilder.ts"],"names":[],"mappings":"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","file":"OneToOneInverseSideSubjectBuilder.js","sourcesContent":["import {Subject} from \"../Subject\";\nimport {OrmUtils} from \"../../util/OrmUtils\";\nimport {ObjectLiteral} from \"../../common/ObjectLiteral\";\nimport {RelationMetadata} from \"../../metadata/RelationMetadata\";\n\n/**\n * Builds operations needs to be executed for one-to-one non-owner relations of the given subjects.\n *\n * by example: post contains one-to-one non-owner relation with category in the property called \"category\", e.g.\n *             @OneToOne(type => Category, category => category.post) category: Category\n *             If user sets a category into the post and saves post we need to bind them.\n *             This operation requires updation of category table since its owner of the relation and contains a join column.\n *\n * note: this class shares lot of things with OneToManyUpdateBuilder, so when you change this class\n *       make sure to reflect changes there as well.\n */\nexport class OneToOneInverseSideSubjectBuilder {\n\n    // ---------------------------------------------------------------------\n    // Constructor\n    // ---------------------------------------------------------------------\n\n    constructor(protected subjects: Subject[]) {\n    }\n\n    // ---------------------------------------------------------------------\n    // Public Methods\n    // ---------------------------------------------------------------------\n\n    /**\n     * Builds all required operations.\n     */\n    build(): void {\n        this.subjects.forEach(subject => {\n            subject.metadata.oneToOneRelations.forEach(relation => {\n\n                // we don't need owning relations, this operation is only for inverse side of one-to-one relations\n                // skip relations for which persistence is disabled\n                if (relation.isOwning || relation.persistenceEnabled === false)\n                    return;\n\n                this.buildForSubjectRelation(subject, relation);\n            });\n        });\n    }\n\n    // ---------------------------------------------------------------------\n    // Protected Methods\n    // ---------------------------------------------------------------------\n\n    /**\n     * Builds operations for a given subject and relation.\n     *\n     * by example: subject is \"post\" entity we are saving here and relation is \"category\" inside it here.\n     */\n    protected buildForSubjectRelation(subject: Subject, relation: RelationMetadata) {\n\n        // prepare objects (relation id map) for the database entity\n        // note: subject.databaseEntity contains relation with loaded relation id only (id map)\n        // by example: since subject is a post, we are expecting to get post's category saved in the database here,\n        //             particularly its relation id, e.g. category id stored in the database\n        let relatedEntityDatabaseRelationId: ObjectLiteral|undefined = undefined;\n        if (subject.databaseEntity) // related entity in the database can exist only if this entity (post) is saved\n            relatedEntityDatabaseRelationId = relation.getEntityValue(subject.databaseEntity);\n\n        // get related entities of persisted entity\n        // by example: get category from the passed to persist post entity\n        let relatedEntity: ObjectLiteral|null = relation.getEntityValue(subject.entity!); // by example: relatedEntity is a category here\n        if (relatedEntity === undefined) // if relation is undefined then nothing to update\n            return;\n\n        // if related entity is null then we need to check if there a bind in the database and unset it\n        // if there is no bind in the entity then we don't need to do anything\n        // by example: if post.category = null and category has this post in the database then we unset it\n        if (relatedEntity === null) {\n\n            // it makes sense to update database only there is a previously set value in the database\n            if (relatedEntityDatabaseRelationId) {\n                // todo: probably we can improve this in the future by finding entity with column those values,\n                // todo: maybe it was already in persistence process. This is possible due to unique requirements of join columns\n                // we create a new subject which operations will be executed in subject operation executor\n\n                const removedRelatedEntitySubject = new Subject({\n                    metadata: relation.inverseEntityMetadata,\n                    parentSubject: subject,\n                    canBeUpdated: true,\n                    identifier: relatedEntityDatabaseRelationId,\n                    changeMaps: [{\n                        relation: relation.inverseRelation!,\n                        value: null\n                    }]\n                });\n                this.subjects.push(removedRelatedEntitySubject);\n            }\n\n            return;\n        } // else means entity is bind in the database\n\n        // extract only relation id from the related entities, since we only need it for comparision\n        // by example: extract from category only relation id (category id, or let's say category title, depend on join column options)\n        let relationIdMap = relation.inverseEntityMetadata!.getEntityIdMap(relatedEntity); // by example: relationIdMap is category.id map here, e.g. { id: ... }\n\n        // try to find a subject of this related entity, maybe it was loaded or was marked for persistence\n        let relatedEntitySubject = this.subjects.find(operateSubject => {\n            return !!operateSubject.entity && operateSubject.entity === relatedEntity;\n        });\n\n        // if subject with entity was found take subject identifier as relation id map since it may contain extra properties resolved\n        if (relatedEntitySubject)\n            relationIdMap = relatedEntitySubject.identifier;\n\n        // if relationIdMap is undefined then it means user binds object which is not saved in the database yet\n        // by example: if post contains category which does not have id(s) yet (because its a new category)\n        //             it means its always newly inserted and relation update operation always must be created for it\n        //             it does not make sense to perform difference operation for it for both add and remove actions\n        if (!relationIdMap) {\n\n            // we decided to remove this error because it brings complications when saving object with non-saved entities\n            // if related entity does not have a subject then it means user tries to bind entity which wasn't saved\n            // in this persistence because he didn't pass this entity for save or he did not set cascades\n            // but without entity being inserted we cannot bind it in the relation operation, so we throw an exception here\n            // if (!relatedEntitySubject)\n            //     throw new Error(`One-to-one inverse relation \"${relation.entityMetadata.name}.${relation.propertyPath}\" contains ` +\n            //         `entity which does not exist in the database yet, thus cannot be bind in the database. ` +\n            //         `Please setup cascade insertion or save entity before binding it.`);\n            if (!relatedEntitySubject)\n                return;\n\n            // okay, so related subject exist and its marked for insertion, then add a new change map\n            // by example: this will tell category to insert into its post relation our post we are working with\n            //             relatedEntitySubject is newly inserted CategorySubject\n            //             relation.inverseRelation is OneToOne owner relation inside Category\n            //             subject is Post needs to be inserted into Category\n            relatedEntitySubject.changeMaps.push({\n                relation: relation.inverseRelation!,\n                value: subject\n            });\n        }\n\n        // check if this binding really exist in the database\n        // by example: find our post if its already bind to category in the database and its not equal to what user tries to set\n        const areRelatedIdEqualWithDatabase = relatedEntityDatabaseRelationId && OrmUtils.deepCompare(relationIdMap, relatedEntityDatabaseRelationId);\n\n        // if they aren't equal it means its a new relation and we need to \"bind\" them\n        // by example: this will tell category to insert into its post relation our post we are working with\n        //             relatedEntitySubject is newly inserted CategorySubject\n        //             relation.inverseRelation is ManyToOne relation inside Category\n        //             subject is Post needs to be inserted into Category\n        if (!areRelatedIdEqualWithDatabase) {\n\n            // if there is no relatedEntitySubject then it means \"category\" wasn't persisted,\n            // but since we are going to update \"category\" table (since its an owning side of relation with join column)\n            // we create a new subject here:\n            if (!relatedEntitySubject) {\n                relatedEntitySubject = new Subject({\n                    metadata: relation.inverseEntityMetadata,\n                    canBeUpdated: true,\n                    identifier: relationIdMap\n                });\n                this.subjects.push(relatedEntitySubject);\n            }\n\n            relatedEntitySubject.changeMaps.push({\n                relation: relation.inverseRelation!,\n                value: subject\n            });\n        }\n    }\n\n}"],"sourceRoot":"../.."}
+{"version":3,"sources":["../../src/persistence/subject-builder/OneToOneInverseSideSubjectBuilder.ts"],"names":[],"mappings":"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","file":"OneToOneInverseSideSubjectBuilder.js","sourcesContent":["import { Subject } from \"../Subject\"\nimport { OrmUtils } from \"../../util/OrmUtils\"\nimport { ObjectLiteral } from \"../../common/ObjectLiteral\"\nimport { RelationMetadata } from \"../../metadata/RelationMetadata\"\n\n/**\n * Builds operations needs to be executed for one-to-one non-owner relations of the given subjects.\n *\n * by example: post contains one-to-one non-owner relation with category in the property called \"category\", e.g.\n *             @OneToOne(type => Category, category => category.post) category: Category\n *             If user sets a category into the post and saves post we need to bind them.\n *             This operation requires updation of category table since its owner of the relation and contains a join column.\n *\n * note: this class shares lot of things with OneToManyUpdateBuilder, so when you change this class\n *       make sure to reflect changes there as well.\n */\nexport class OneToOneInverseSideSubjectBuilder {\n    // ---------------------------------------------------------------------\n    // Constructor\n    // ---------------------------------------------------------------------\n\n    constructor(protected subjects: Subject[]) {}\n\n    // ---------------------------------------------------------------------\n    // Public Methods\n    // ---------------------------------------------------------------------\n\n    /**\n     * Builds all required operations.\n     */\n    build(): void {\n        this.subjects.forEach((subject) => {\n            subject.metadata.oneToOneRelations.forEach((relation) => {\n                // we don't need owning relations, this operation is only for inverse side of one-to-one relations\n                // skip relations for which persistence is disabled\n                if (relation.isOwning || relation.persistenceEnabled === false)\n                    return\n\n                this.buildForSubjectRelation(subject, relation)\n            })\n        })\n    }\n\n    // ---------------------------------------------------------------------\n    // Protected Methods\n    // ---------------------------------------------------------------------\n\n    /**\n     * Builds operations for a given subject and relation.\n     *\n     * by example: subject is \"post\" entity we are saving here and relation is \"category\" inside it here.\n     */\n    protected buildForSubjectRelation(\n        subject: Subject,\n        relation: RelationMetadata,\n    ) {\n        // prepare objects (relation id map) for the database entity\n        // note: subject.databaseEntity contains relation with loaded relation id only (id map)\n        // by example: since subject is a post, we are expecting to get post's category saved in the database here,\n        //             particularly its relation id, e.g. category id stored in the database\n        let relatedEntityDatabaseRelationId: ObjectLiteral | undefined =\n            undefined\n        if (subject.databaseEntity)\n            // related entity in the database can exist only if this entity (post) is saved\n            relatedEntityDatabaseRelationId = relation.getEntityValue(\n                subject.databaseEntity,\n            )\n\n        // get related entities of persisted entity\n        // by example: get category from the passed to persist post entity\n        let relatedEntity: ObjectLiteral | null = relation.getEntityValue(\n            subject.entity!,\n        ) // by example: relatedEntity is a category here\n        if (relatedEntity === undefined)\n            // if relation is undefined then nothing to update\n            return\n\n        // if related entity is null then we need to check if there a bind in the database and unset it\n        // if there is no bind in the entity then we don't need to do anything\n        // by example: if post.category = null and category has this post in the database then we unset it\n        if (relatedEntity === null) {\n            // it makes sense to update database only there is a previously set value in the database\n            if (relatedEntityDatabaseRelationId) {\n                // todo: probably we can improve this in the future by finding entity with column those values,\n                // todo: maybe it was already in persistence process. This is possible due to unique requirements of join columns\n                // we create a new subject which operations will be executed in subject operation executor\n\n                const removedRelatedEntitySubject = new Subject({\n                    metadata: relation.inverseEntityMetadata,\n                    parentSubject: subject,\n                    canBeUpdated: true,\n                    identifier: relatedEntityDatabaseRelationId,\n                    changeMaps: [\n                        {\n                            relation: relation.inverseRelation!,\n                            value: null,\n                        },\n                    ],\n                })\n                this.subjects.push(removedRelatedEntitySubject)\n            }\n\n            return\n        } // else means entity is bind in the database\n\n        // extract only relation id from the related entities, since we only need it for comparision\n        // by example: extract from category only relation id (category id, or let's say category title, depend on join column options)\n        let relationIdMap =\n            relation.inverseEntityMetadata!.getEntityIdMap(relatedEntity) // by example: relationIdMap is category.id map here, e.g. { id: ... }\n\n        // try to find a subject of this related entity, maybe it was loaded or was marked for persistence\n        let relatedEntitySubject = this.subjects.find((operateSubject) => {\n            return (\n                !!operateSubject.entity &&\n                operateSubject.entity === relatedEntity\n            )\n        })\n\n        // if subject with entity was found take subject identifier as relation id map since it may contain extra properties resolved\n        if (relatedEntitySubject)\n            relationIdMap = relatedEntitySubject.identifier\n\n        // if relationIdMap is undefined then it means user binds object which is not saved in the database yet\n        // by example: if post contains category which does not have id(s) yet (because its a new category)\n        //             it means its always newly inserted and relation update operation always must be created for it\n        //             it does not make sense to perform difference operation for it for both add and remove actions\n        if (!relationIdMap) {\n            // we decided to remove this error because it brings complications when saving object with non-saved entities\n            // if related entity does not have a subject then it means user tries to bind entity which wasn't saved\n            // in this persistence because he didn't pass this entity for save or he did not set cascades\n            // but without entity being inserted we cannot bind it in the relation operation, so we throw an exception here\n            // if (!relatedEntitySubject)\n            //     throw new TypeORMError(`One-to-one inverse relation \"${relation.entityMetadata.name}.${relation.propertyPath}\" contains ` +\n            //         `entity which does not exist in the database yet, thus cannot be bind in the database. ` +\n            //         `Please setup cascade insertion or save entity before binding it.`);\n            if (!relatedEntitySubject) return\n\n            // okay, so related subject exist and its marked for insertion, then add a new change map\n            // by example: this will tell category to insert into its post relation our post we are working with\n            //             relatedEntitySubject is newly inserted CategorySubject\n            //             relation.inverseRelation is OneToOne owner relation inside Category\n            //             subject is Post needs to be inserted into Category\n            relatedEntitySubject.changeMaps.push({\n                relation: relation.inverseRelation!,\n                value: subject,\n            })\n        }\n\n        // check if this binding really exist in the database\n        // by example: find our post if its already bind to category in the database and its not equal to what user tries to set\n        const areRelatedIdEqualWithDatabase =\n            relatedEntityDatabaseRelationId &&\n            OrmUtils.compareIds(relationIdMap, relatedEntityDatabaseRelationId)\n\n        // if they aren't equal it means its a new relation and we need to \"bind\" them\n        // by example: this will tell category to insert into its post relation our post we are working with\n        //             relatedEntitySubject is newly inserted CategorySubject\n        //             relation.inverseRelation is ManyToOne relation inside Category\n        //             subject is Post needs to be inserted into Category\n        if (!areRelatedIdEqualWithDatabase) {\n            // if there is no relatedEntitySubject then it means \"category\" wasn't persisted,\n            // but since we are going to update \"category\" table (since its an owning side of relation with join column)\n            // we create a new subject here:\n            if (!relatedEntitySubject) {\n                relatedEntitySubject = new Subject({\n                    metadata: relation.inverseEntityMetadata,\n                    canBeUpdated: true,\n                    identifier: relationIdMap,\n                })\n                this.subjects.push(relatedEntitySubject)\n            }\n\n            relatedEntitySubject.changeMaps.push({\n                relation: relation.inverseRelation!,\n                value: subject,\n            })\n        }\n    }\n}\n"],"sourceRoot":"../.."}

package/persistence/tree/ClosureSubjectExecutor.d.ts

@@ -6,21 +6,18 @@ import { QueryRunner } from "../../query-runner/QueryRunner";
 export declare class ClosureSubjectExecutor {
     protected queryRunner: QueryRunner;
     constructor(queryRunner: QueryRunner);
-    /**
-     * Removes all children of the given subject's entity.
-
-    async deleteChildrenOf(subject: Subject) {
-        // const relationValue = subject.metadata.treeParentRelation.getEntityValue(subject.databaseEntity);
-        // console.log("relationValue: ", relationValue);
-        // this.queryRunner.manager
-        //     .createQueryBuilder()
-        //     .from(subject.metadata.closureJunctionTable.target, "tree")
-        //     .where("tree.");
-    }*/
     /**
      * Executes operations when subject is being inserted.
      */
     insert(subject: Subject): Promise<void>;
+    /**
+     * Executes operations when subject is being updated.
+     */
+    update(subject: Subject): Promise<void>;
+    /**
+     * Executes operations when subject is being removed.
+     */
+    remove(subjects: Subject | Subject[]): Promise<void>;
     /**
      * Gets escaped table name with schema name if SqlServer or Postgres driver used with custom
      * schema name, otherwise returns escaped table name.