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

package/browser/persistence/subject-builder/CascadesSubjectBuilder.js

@@ -1,10 +1,13 @@
-import { Subject } from "../Subject";
-import { ObjectUtils } from "../../util/ObjectUtils";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CascadesSubjectBuilder = void 0;
+const Subject_1 = require("../Subject");
+const ObjectUtils_1 = require("../../util/ObjectUtils");
 /**
  * Finds all cascade operations of the given subject and cascade operations of the found cascaded subjects,
  * e.g. builds a cascade tree and creates a subjects for them.
  */
-export class CascadesSubjectBuilder {
+class CascadesSubjectBuilder {
     // ---------------------------------------------------------------------
     // Constructor
     // ---------------------------------------------------------------------
@@ -16,6 +19,8 @@ export class CascadesSubjectBuilder {
     // ---------------------------------------------------------------------
     /**
      * Builds a cascade subjects tree and pushes them in into the given array of subjects.
+     * @param subject
+     * @param operationType
      */
     build(subject, operationType) {
         subject.metadata
@@ -31,7 +36,7 @@ export class CascadesSubjectBuilder {
                 return;
             // if relation entity is just a relation id set (for example post.tag = 1)
             // then we don't really need to check cascades since there is no object to insert or update
-            if (!ObjectUtils.isObject(relationEntity))
+            if (!ObjectUtils_1.ObjectUtils.isObject(relationEntity))
                 return;
             // if we already has this entity in list of operated subjects then skip it to avoid recursion
             const alreadyExistRelationEntitySubject = this.findByPersistEntityLike(relationEntityMetadata.target, relationEntity);
@@ -63,7 +68,7 @@ export class CascadesSubjectBuilder {
             }
             // mark subject with what we can do with it
             // and add to the array of subjects to load only if there is no same entity there already
-            const relationEntitySubject = new Subject({
+            const relationEntitySubject = new Subject_1.Subject({
                 metadata: relationEntityMetadata,
                 parentSubject: subject,
                 entity: relationEntity,
@@ -87,6 +92,8 @@ export class CascadesSubjectBuilder {
     /**
      * Finds subject where entity like given subject's entity.
      * Comparison made by entity id.
+     * @param entityTarget
+     * @param entity
      */
     findByPersistEntityLike(entityTarget, entity) {
         return this.allSubjects.find((subject) => {
@@ -99,5 +106,5 @@ export class CascadesSubjectBuilder {
         });
     }
 }
-
-//# sourceMappingURL=CascadesSubjectBuilder.js.map
+exports.CascadesSubjectBuilder = CascadesSubjectBuilder;
+//# sourceMappingURL=CascadesSubjectBuilder.js.map

package/browser/persistence/subject-builder/CascadesSubjectBuilder.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../browser/src/persistence/subject-builder/CascadesSubjectBuilder.ts"],"names":[],"mappings":"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","file":"CascadesSubjectBuilder.js","sourcesContent":["import { Subject } from \"../Subject\"\nimport { ObjectLiteral } from \"../../common/ObjectLiteral\"\nimport { ObjectUtils } from \"../../util/ObjectUtils\"\n\n/**\n * Finds all cascade operations of the given subject and cascade operations of the found cascaded subjects,\n * e.g. builds a cascade tree and creates a subjects for them.\n */\nexport class CascadesSubjectBuilder {\n    // ---------------------------------------------------------------------\n    // Constructor\n    // ---------------------------------------------------------------------\n\n    constructor(protected allSubjects: Subject[]) {}\n\n    // ---------------------------------------------------------------------\n    // Public Methods\n    // ---------------------------------------------------------------------\n\n    /**\n     * Builds a cascade subjects tree and pushes them in into the given array of subjects.\n     */\n    build(\n        subject: Subject,\n        operationType: \"save\" | \"remove\" | \"soft-remove\" | \"recover\",\n    ) {\n        subject.metadata\n            .extractRelationValuesFromEntity(\n                subject.entity!,\n                subject.metadata.relations,\n            ) // todo: we can create EntityMetadata.cascadeRelations\n            .forEach(([relation, relationEntity, relationEntityMetadata]) => {\n                // we need only defined values and insert, update, soft-remove or recover cascades of the relation should be set\n                if (\n                    relationEntity === undefined ||\n                    relationEntity === null ||\n                    (!relation.isCascadeInsert &&\n                        !relation.isCascadeUpdate &&\n                        !relation.isCascadeSoftRemove &&\n                        !relation.isCascadeRecover)\n                )\n                    return\n\n                // if relation entity is just a relation id set (for example post.tag = 1)\n                // then we don't really need to check cascades since there is no object to insert or update\n                if (!ObjectUtils.isObject(relationEntity)) return\n\n                // if we already has this entity in list of operated subjects then skip it to avoid recursion\n                const alreadyExistRelationEntitySubject =\n                    this.findByPersistEntityLike(\n                        relationEntityMetadata.target,\n                        relationEntity,\n                    )\n                if (alreadyExistRelationEntitySubject) {\n                    if (\n                        alreadyExistRelationEntitySubject.canBeInserted ===\n                        false\n                    )\n                        // if its not marked for insertion yet\n                        alreadyExistRelationEntitySubject.canBeInserted =\n                            relation.isCascadeInsert === true &&\n                            operationType === \"save\"\n                    if (\n                        alreadyExistRelationEntitySubject.canBeUpdated === false\n                    )\n                        // if its not marked for update yet\n                        alreadyExistRelationEntitySubject.canBeUpdated =\n                            relation.isCascadeUpdate === true &&\n                            operationType === \"save\"\n                    if (\n                        alreadyExistRelationEntitySubject.canBeSoftRemoved ===\n                        false\n                    )\n                        // if its not marked for removal yet\n                        alreadyExistRelationEntitySubject.canBeSoftRemoved =\n                            relation.isCascadeSoftRemove === true &&\n                            operationType === \"soft-remove\"\n                    if (\n                        alreadyExistRelationEntitySubject.canBeRecovered ===\n                        false\n                    )\n                        // if its not marked for recovery yet\n                        alreadyExistRelationEntitySubject.canBeRecovered =\n                            relation.isCascadeRecover === true &&\n                            operationType === \"recover\"\n                    return\n                }\n\n                // mark subject with what we can do with it\n                // and add to the array of subjects to load only if there is no same entity there already\n                const relationEntitySubject = new Subject({\n                    metadata: relationEntityMetadata,\n                    parentSubject: subject,\n                    entity: relationEntity,\n                    canBeInserted:\n                        relation.isCascadeInsert === true &&\n                        operationType === \"save\",\n                    canBeUpdated:\n                        relation.isCascadeUpdate === true &&\n                        operationType === \"save\",\n                    canBeSoftRemoved:\n                        relation.isCascadeSoftRemove === true &&\n                        operationType === \"soft-remove\",\n                    canBeRecovered:\n                        relation.isCascadeRecover === true &&\n                        operationType === \"recover\",\n                })\n                this.allSubjects.push(relationEntitySubject)\n\n                // go recursively and find other entities we need to insert/update\n                this.build(relationEntitySubject, operationType)\n            })\n    }\n\n    // ---------------------------------------------------------------------\n    // Protected Methods\n    // ---------------------------------------------------------------------\n\n    /**\n     * Finds subject where entity like given subject's entity.\n     * Comparison made by entity id.\n     */\n    protected findByPersistEntityLike(\n        entityTarget: Function | string,\n        entity: ObjectLiteral,\n    ): Subject | undefined {\n        return this.allSubjects.find((subject) => {\n            if (!subject.entity) return false\n\n            if (subject.entity === entity) return true\n\n            return (\n                subject.metadata.target === entityTarget &&\n                subject.metadata.compareEntities(\n                    subject.entityWithFulfilledIds!,\n                    entity,\n                )\n            )\n        })\n    }\n}\n"],"sourceRoot":"../.."}
+{"version":3,"file":"CascadesSubjectBuilder.js","sourceRoot":"../build/browser/src/","sources":["persistence/subject-builder/CascadesSubjectBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { Subject } from \"../Subject\"\nimport type { ObjectLiteral } from \"../../common/ObjectLiteral\"\nimport { ObjectUtils } from \"../../util/ObjectUtils\"\n\n/**\n * Finds all cascade operations of the given subject and cascade operations of the found cascaded subjects,\n * e.g. builds a cascade tree and creates a subjects for them.\n */\nexport class CascadesSubjectBuilder {\n    // ---------------------------------------------------------------------\n    // Constructor\n    // ---------------------------------------------------------------------\n\n    constructor(protected allSubjects: Subject[]) {}\n\n    // ---------------------------------------------------------------------\n    // Public Methods\n    // ---------------------------------------------------------------------\n\n    /**\n     * Builds a cascade subjects tree and pushes them in into the given array of subjects.\n     * @param subject\n     * @param operationType\n     */\n    build(\n        subject: Subject,\n        operationType: \"save\" | \"remove\" | \"soft-remove\" | \"recover\",\n    ) {\n        subject.metadata\n            .extractRelationValuesFromEntity(\n                subject.entity!,\n                subject.metadata.relations,\n            ) // todo: we can create EntityMetadata.cascadeRelations\n            .forEach(([relation, relationEntity, relationEntityMetadata]) => {\n                // we need only defined values and insert, update, soft-remove or recover cascades of the relation should be set\n                if (\n                    relationEntity === undefined ||\n                    relationEntity === null ||\n                    (!relation.isCascadeInsert &&\n                        !relation.isCascadeUpdate &&\n                        !relation.isCascadeSoftRemove &&\n                        !relation.isCascadeRecover)\n                )\n                    return\n\n                // if relation entity is just a relation id set (for example post.tag = 1)\n                // then we don't really need to check cascades since there is no object to insert or update\n                if (!ObjectUtils.isObject(relationEntity)) return\n\n                // if we already has this entity in list of operated subjects then skip it to avoid recursion\n                const alreadyExistRelationEntitySubject =\n                    this.findByPersistEntityLike(\n                        relationEntityMetadata.target,\n                        relationEntity,\n                    )\n                if (alreadyExistRelationEntitySubject) {\n                    if (\n                        alreadyExistRelationEntitySubject.canBeInserted ===\n                        false\n                    )\n                        // if its not marked for insertion yet\n                        alreadyExistRelationEntitySubject.canBeInserted =\n                            relation.isCascadeInsert === true &&\n                            operationType === \"save\"\n                    if (\n                        alreadyExistRelationEntitySubject.canBeUpdated === false\n                    )\n                        // if its not marked for update yet\n                        alreadyExistRelationEntitySubject.canBeUpdated =\n                            relation.isCascadeUpdate === true &&\n                            operationType === \"save\"\n                    if (\n                        alreadyExistRelationEntitySubject.canBeSoftRemoved ===\n                        false\n                    )\n                        // if its not marked for removal yet\n                        alreadyExistRelationEntitySubject.canBeSoftRemoved =\n                            relation.isCascadeSoftRemove === true &&\n                            operationType === \"soft-remove\"\n                    if (\n                        alreadyExistRelationEntitySubject.canBeRecovered ===\n                        false\n                    )\n                        // if its not marked for recovery yet\n                        alreadyExistRelationEntitySubject.canBeRecovered =\n                            relation.isCascadeRecover === true &&\n                            operationType === \"recover\"\n                    return\n                }\n\n                // mark subject with what we can do with it\n                // and add to the array of subjects to load only if there is no same entity there already\n                const relationEntitySubject = new Subject({\n                    metadata: relationEntityMetadata,\n                    parentSubject: subject,\n                    entity: relationEntity,\n                    canBeInserted:\n                        relation.isCascadeInsert === true &&\n                        operationType === \"save\",\n                    canBeUpdated:\n                        relation.isCascadeUpdate === true &&\n                        operationType === \"save\",\n                    canBeSoftRemoved:\n                        relation.isCascadeSoftRemove === true &&\n                        operationType === \"soft-remove\",\n                    canBeRecovered:\n                        relation.isCascadeRecover === true &&\n                        operationType === \"recover\",\n                })\n                this.allSubjects.push(relationEntitySubject)\n\n                // go recursively and find other entities we need to insert/update\n                this.build(relationEntitySubject, operationType)\n            })\n    }\n\n    // ---------------------------------------------------------------------\n    // Protected Methods\n    // ---------------------------------------------------------------------\n\n    /**\n     * Finds subject where entity like given subject's entity.\n     * Comparison made by entity id.\n     * @param entityTarget\n     * @param entity\n     */\n    protected findByPersistEntityLike(\n        entityTarget: Function | string,\n        entity: ObjectLiteral,\n    ): Subject | undefined {\n        return this.allSubjects.find((subject) => {\n            if (!subject.entity) return false\n\n            if (subject.entity === entity) return true\n\n            return (\n                subject.metadata.target === entityTarget &&\n                subject.metadata.compareEntities(\n                    subject.entityWithFulfilledIds!,\n                    entity,\n                )\n            )\n        })\n    }\n}\n"]}

package/browser/persistence/subject-builder/ManyToManySubjectBuilder.d.ts

@@ -1,13 +1,17 @@
 import { Subject } from "../Subject";
-import { ObjectLiteral } from "../../common/ObjectLiteral";
-import { RelationMetadata } from "../../metadata/RelationMetadata";
+import type { ObjectLiteral } from "../../common/ObjectLiteral";
+import type { RelationMetadata } from "../../metadata/RelationMetadata";
 /**
  * Builds operations needs to be executed for many-to-many relations of the given subjects.
  *
- * by example: post contains owner many-to-many relation with categories in the property called "categories", e.g.
- *             @ManyToMany(type => Category, category => category.posts) categories: Category[]
- *             If user adds categories into the post and saves post we need to bind them.
- *             This operation requires updation of junction table.
+ * Example:
+ *
+ * `Post` owns a many-to-many relation with `Category` in the property called `categories`, e.g.:
+ *
+ * `@ManyToMany(type => Category, category => category.posts) categories: Category[]`
+ *
+ *  If the user adds categories into the post and saves post we need to bind them.
+ *  This operation requires updating the junction table.
  */
 export declare class ManyToManySubjectBuilder {
     protected subjects: Subject[];
@@ -18,17 +22,23 @@ export declare class ManyToManySubjectBuilder {
     build(): void;
     /**
      * Builds operations for removal of all many-to-many records of all many-to-many relations of the given subject.
+     * @param subject
      */
     buildForAllRemoval(subject: Subject): void;
     /**
      * Builds operations for a given subject and relation.
      *
      * by example: subject is "post" entity we are saving here and relation is "categories" inside it here.
+     * @param subject
+     * @param relation
      */
     protected buildForSubjectRelation(subject: Subject, relation: RelationMetadata): void;
     /**
      * Creates identifiers for junction table.
      * Example: { postId: 1, categoryId: 2 }
+     * @param subject
+     * @param relation
+     * @param relationId
      */
     protected buildJunctionIdentifier(subject: Subject, relation: RelationMetadata, relationId: ObjectLiteral): ObjectLiteral;
 }

package/browser/persistence/subject-builder/ManyToManySubjectBuilder.js

@@ -1,14 +1,21 @@
-import { Subject } from "../Subject";
-import { OrmUtils } from "../../util/OrmUtils";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManyToManySubjectBuilder = void 0;
+const Subject_1 = require("../Subject");
+const OrmUtils_1 = require("../../util/OrmUtils");
 /**
  * Builds operations needs to be executed for many-to-many relations of the given subjects.
  *
- * by example: post contains owner many-to-many relation with categories in the property called "categories", e.g.
- *             @ManyToMany(type => Category, category => category.posts) categories: Category[]
- *             If user adds categories into the post and saves post we need to bind them.
- *             This operation requires updation of junction table.
+ * Example:
+ *
+ * `Post` owns a many-to-many relation with `Category` in the property called `categories`, e.g.:
+ *
+ * `@ManyToMany(type => Category, category => category.posts) categories: Category[]`
+ *
+ *  If the user adds categories into the post and saves post we need to bind them.
+ *  This operation requires updating the junction table.
  */
-export class ManyToManySubjectBuilder {
+class ManyToManySubjectBuilder {
     // ---------------------------------------------------------------------
     // Constructor
     // ---------------------------------------------------------------------
@@ -37,6 +44,7 @@ export class ManyToManySubjectBuilder {
     }
     /**
      * Builds operations for removal of all many-to-many records of all many-to-many relations of the given subject.
+     * @param subject
      */
     buildForAllRemoval(subject) {
         // if subject does not have a database entity then it means it does not exist in the database
@@ -53,7 +61,7 @@ export class ManyToManySubjectBuilder {
             const relatedEntityRelationIdsInDatabase = relation.getEntityValue(subject.databaseEntity);
             // go through all related entities and create a new junction subject for each row in junction table
             relatedEntityRelationIdsInDatabase.forEach((relationId) => {
-                const junctionSubject = new Subject({
+                const junctionSubject = new Subject_1.Subject({
                     metadata: relation.junctionEntityMetadata,
                     parentSubject: subject,
                     mustBeRemoved: true,
@@ -73,6 +81,8 @@ export class ManyToManySubjectBuilder {
      * Builds operations for a given subject and relation.
      *
      * by example: subject is "post" entity we are saving here and relation is "categories" inside it here.
+     * @param subject
+     * @param relation
      */
     buildForSubjectRelation(subject, relation) {
         // load from db all relation ids of inverse entities that are "bind" to the subject's entity
@@ -125,7 +135,7 @@ export class ManyToManySubjectBuilder {
             // try to find related entity in the database
             // by example: find post's category in the database post's categories
             const relatedEntityExistInDatabase = databaseRelatedEntityIds.find((databaseRelatedEntityRelationId) => {
-                return OrmUtils.compareIds(databaseRelatedEntityRelationId, relatedEntityRelationIdMap);
+                return OrmUtils_1.OrmUtils.compareIds(databaseRelatedEntityRelationId, relatedEntityRelationIdMap);
             });
             // if entity is found then don't do anything - it means binding in junction table already exist, we don't need to add anything
             if (relatedEntityExistInDatabase)
@@ -137,7 +147,7 @@ export class ManyToManySubjectBuilder {
                 ? relatedEntitySubject || relatedEntity
                 : subject; // by example: inverseEntityMap is category from categories array here
             // create a new subject for insert operation of junction rows
-            const junctionSubject = new Subject({
+            const junctionSubject = new Subject_1.Subject({
                 metadata: relation.junctionEntityMetadata,
                 parentSubject: subject,
                 canBeInserted: true,
@@ -177,12 +187,12 @@ export class ManyToManySubjectBuilder {
         // now from all entities in the persisted entity find only those which aren't found in the db
         const removedJunctionEntityIds = databaseRelatedEntityIds.filter((existRelationId) => {
             return !changedInverseEntityRelationIds.find((changedRelationId) => {
-                return OrmUtils.compareIds(changedRelationId, existRelationId);
+                return OrmUtils_1.OrmUtils.compareIds(changedRelationId, existRelationId);
             });
         });
         // finally create a new junction remove operations for missing related entities
         removedJunctionEntityIds.forEach((removedEntityRelationId) => {
-            const junctionSubject = new Subject({
+            const junctionSubject = new Subject_1.Subject({
                 metadata: relation.junctionEntityMetadata,
                 parentSubject: subject,
                 mustBeRemoved: true,
@@ -194,6 +204,9 @@ export class ManyToManySubjectBuilder {
     /**
      * Creates identifiers for junction table.
      * Example: { postId: 1, categoryId: 2 }
+     * @param subject
+     * @param relation
+     * @param relationId
      */
     buildJunctionIdentifier(subject, relation, relationId) {
         const ownerEntityMap = relation.isOwning ? subject.entity : relationId;
@@ -202,13 +215,13 @@ export class ManyToManySubjectBuilder {
             : subject.entity;
         const identifier = {};
         relation.junctionEntityMetadata.ownerColumns.forEach((column) => {
-            OrmUtils.mergeDeep(identifier, column.createValueMap(column.referencedColumn.getEntityValue(ownerEntityMap)));
+            OrmUtils_1.OrmUtils.mergeDeep(identifier, column.createValueMap(column.referencedColumn.getEntityValue(ownerEntityMap)));
         });
         relation.junctionEntityMetadata.inverseColumns.forEach((column) => {
-            OrmUtils.mergeDeep(identifier, column.createValueMap(column.referencedColumn.getEntityValue(inverseEntityMap)));
+            OrmUtils_1.OrmUtils.mergeDeep(identifier, column.createValueMap(column.referencedColumn.getEntityValue(inverseEntityMap)));
         });
         return identifier;
     }
 }
-
-//# sourceMappingURL=ManyToManySubjectBuilder.js.map
+exports.ManyToManySubjectBuilder = ManyToManySubjectBuilder;
+//# sourceMappingURL=ManyToManySubjectBuilder.js.map

package/browser/persistence/subject-builder/ManyToManySubjectBuilder.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../browser/src/persistence/subject-builder/ManyToManySubjectBuilder.ts"],"names":[],"mappings":"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","file":"ManyToManySubjectBuilder.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 many-to-many relations of the given subjects.\n *\n * by example: post contains owner many-to-many relation with categories in the property called \"categories\", e.g.\n *             @ManyToMany(type => Category, category => category.posts) categories: Category[]\n *             If user adds categories into the post and saves post we need to bind them.\n *             This operation requires updation of junction table.\n */\nexport class ManyToManySubjectBuilder {\n    // ---------------------------------------------------------------------\n    // Constructor\n    // ---------------------------------------------------------------------\n\n    constructor(protected subjects: Subject[]) {}\n\n    // ---------------------------------------------------------------------\n    // Public Methods\n    // ---------------------------------------------------------------------\n\n    /**\n     * Builds operations for any changes in the many-to-many relations of the subjects.\n     */\n    build(): void {\n        this.subjects.forEach((subject) => {\n            // if subject doesn't have entity then no need to find something that should be inserted or removed\n            if (!subject.entity) return\n\n            // go through all persistence enabled many-to-many relations and build subject operations for them\n            subject.metadata.manyToManyRelations.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     * Builds operations for removal of all many-to-many records of all many-to-many relations of the given subject.\n     */\n    buildForAllRemoval(subject: Subject) {\n        // if subject does not have a database entity then it means it does not exist in the database\n        // if it does not exist in the database then we don't have anything for deletion\n        if (!subject.databaseEntity) return\n\n        // go through all persistence enabled many-to-many relations and build subject operations for them\n        subject.metadata.manyToManyRelations.forEach((relation) => {\n            // skip relations for which persistence is disabled\n            if (relation.persistenceEnabled === false) return\n\n            // get all related entities (actually related entity relation ids) bind to this subject entity\n            // by example: returns category ids of the post we are currently working with (subject.entity is post)\n            const relatedEntityRelationIdsInDatabase: ObjectLiteral[] =\n                relation.getEntityValue(subject.databaseEntity!)\n\n            // go through all related entities and create a new junction subject for each row in junction table\n            relatedEntityRelationIdsInDatabase.forEach((relationId) => {\n                const junctionSubject = new Subject({\n                    metadata: relation.junctionEntityMetadata!,\n                    parentSubject: subject,\n                    mustBeRemoved: true,\n                    identifier: this.buildJunctionIdentifier(\n                        subject,\n                        relation,\n                        relationId,\n                    ),\n                })\n\n                // we use unshift because we need to perform those operations before post deletion is performed\n                // but post deletion was already added as an subject\n                // this is temporary solution, later we need to implement proper sorting of subjects before their removal\n                this.subjects.push(junctionSubject)\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        // load from db all relation ids of inverse entities that are \"bind\" to the subject's entity\n        // this way we gonna check which relation ids are missing and which are new (e.g. inserted or removed)\n        let databaseRelatedEntityIds: ObjectLiteral[] = []\n\n        // if subject don't have database entity it means all related entities in persisted subject are new and must be bind\n        // and we don't need to remove something that is not exist\n        if (subject.databaseEntity) {\n            const databaseRelatedEntityValue = relation.getEntityValue(\n                subject.databaseEntity,\n            )\n            if (databaseRelatedEntityValue) {\n                databaseRelatedEntityIds = databaseRelatedEntityValue.map(\n                    (e: any) =>\n                        relation.inverseEntityMetadata.getEntityIdMap(e),\n                )\n            }\n        }\n\n        // extract entity's relation value\n        // by example: categories inside our post (subject.entity is post)\n        let relatedEntities: ObjectLiteral[] = relation.getEntityValue(\n            subject.entity!,\n        )\n        if (relatedEntities === null)\n            // if value set to null its equal if we set it to empty array - all items must be removed from the database\n            relatedEntities = []\n        if (!Array.isArray(relatedEntities)) return\n\n        // from all related entities find only those which aren't found in the db - for them we will create operation subjects\n        relatedEntities.forEach((relatedEntity) => {\n            // by example: relatedEntity is category from categories saved with post\n\n            // todo: check how it will work for entities which are saved by cascades, but aren't saved in the database yet\n\n            // extract only relation id from the related entities, since we only need it for comparison\n            // by example: extract from category only relation id (category id, or let's say category title, depend on join column options)\n            let relatedEntityRelationIdMap =\n                relation.inverseEntityMetadata!.getEntityIdMap(relatedEntity)\n\n            // try to find a subject of this related entity, maybe it was loaded or was marked for persistence\n            const 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                relatedEntityRelationIdMap = relatedEntitySubject.identifier\n\n            // if related entity relation id map is empty it means related entity is newly persisted\n            if (!relatedEntityRelationIdMap) {\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                // we decided to remove this error because it brings complications when saving object with non-saved entities\n                // if (!relatedEntitySubject)\n                //     throw new TypeORMError(`Many-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\n            // try to find related entity in the database\n            // by example: find post's category in the database post's categories\n            const relatedEntityExistInDatabase = databaseRelatedEntityIds.find(\n                (databaseRelatedEntityRelationId) => {\n                    return OrmUtils.compareIds(\n                        databaseRelatedEntityRelationId,\n                        relatedEntityRelationIdMap,\n                    )\n                },\n            )\n\n            // if entity is found then don't do anything - it means binding in junction table already exist, we don't need to add anything\n            if (relatedEntityExistInDatabase) return\n\n            const ownerValue = relation.isOwning\n                ? subject\n                : relatedEntitySubject || relatedEntity // by example: ownerEntityMap is post from subject here\n            const inverseValue = relation.isOwning\n                ? relatedEntitySubject || relatedEntity\n                : subject // by example: inverseEntityMap is category from categories array here\n\n            // create a new subject for insert operation of junction rows\n            const junctionSubject = new Subject({\n                metadata: relation.junctionEntityMetadata!,\n                parentSubject: subject,\n                canBeInserted: true,\n            })\n            this.subjects.push(junctionSubject)\n\n            relation.junctionEntityMetadata!.ownerColumns.forEach((column) => {\n                junctionSubject.changeMaps.push({\n                    column: column,\n                    value: ownerValue,\n                    // valueFactory: (value) => column.referencedColumn!.getEntityValue(value) // column.referencedColumn!.getEntityValue(ownerEntityMap),\n                })\n            })\n\n            relation.junctionEntityMetadata!.inverseColumns.forEach(\n                (column) => {\n                    junctionSubject.changeMaps.push({\n                        column: column,\n                        value: inverseValue,\n                        // valueFactory: (value) => column.referencedColumn!.getEntityValue(value) // column.referencedColumn!.getEntityValue(inverseEntityMap),\n                    })\n                },\n            )\n        })\n\n        // get all inverse entities relation ids that are \"bind\" to the currently persisted entity\n        const changedInverseEntityRelationIds: ObjectLiteral[] = []\n        relatedEntities.forEach((relatedEntity) => {\n            // relation.inverseEntityMetadata!.getEntityIdMap(relatedEntity)\n            let relatedEntityRelationIdMap =\n                relation.inverseEntityMetadata!.getEntityIdMap(relatedEntity)\n\n            // try to find a subject of this related entity, maybe it was loaded or was marked for persistence\n            const 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                relatedEntityRelationIdMap = relatedEntitySubject.identifier\n\n            if (\n                relatedEntityRelationIdMap !== undefined &&\n                relatedEntityRelationIdMap !== null\n            )\n                changedInverseEntityRelationIds.push(relatedEntityRelationIdMap)\n        })\n\n        // now from all entities in the persisted entity find only those which aren't found in the db\n        const removedJunctionEntityIds = databaseRelatedEntityIds.filter(\n            (existRelationId) => {\n                return !changedInverseEntityRelationIds.find(\n                    (changedRelationId) => {\n                        return OrmUtils.compareIds(\n                            changedRelationId,\n                            existRelationId,\n                        )\n                    },\n                )\n            },\n        )\n\n        // finally create a new junction remove operations for missing related entities\n        removedJunctionEntityIds.forEach((removedEntityRelationId) => {\n            const junctionSubject = new Subject({\n                metadata: relation.junctionEntityMetadata!,\n                parentSubject: subject,\n                mustBeRemoved: true,\n                identifier: this.buildJunctionIdentifier(\n                    subject,\n                    relation,\n                    removedEntityRelationId,\n                ),\n            })\n            this.subjects.push(junctionSubject)\n        })\n    }\n\n    /**\n     * Creates identifiers for junction table.\n     * Example: { postId: 1, categoryId: 2 }\n     */\n    protected buildJunctionIdentifier(\n        subject: Subject,\n        relation: RelationMetadata,\n        relationId: ObjectLiteral,\n    ) {\n        const ownerEntityMap = relation.isOwning ? subject.entity! : relationId\n        const inverseEntityMap = relation.isOwning\n            ? relationId\n            : subject.entity!\n\n        const identifier: ObjectLiteral = {}\n        relation.junctionEntityMetadata!.ownerColumns.forEach((column) => {\n            OrmUtils.mergeDeep(\n                identifier,\n                column.createValueMap(\n                    column.referencedColumn!.getEntityValue(ownerEntityMap),\n                ),\n            )\n        })\n        relation.junctionEntityMetadata!.inverseColumns.forEach((column) => {\n            OrmUtils.mergeDeep(\n                identifier,\n                column.createValueMap(\n                    column.referencedColumn!.getEntityValue(inverseEntityMap),\n                ),\n            )\n        })\n        return identifier\n    }\n}\n"],"sourceRoot":"../.."}
+{"version":3,"file":"ManyToManySubjectBuilder.js","sourceRoot":"../build/browser/src/","sources":["persistence/subject-builder/ManyToManySubjectBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { Subject } from \"../Subject\"\nimport { OrmUtils } from \"../../util/OrmUtils\"\nimport type { ObjectLiteral } from \"../../common/ObjectLiteral\"\nimport type { RelationMetadata } from \"../../metadata/RelationMetadata\"\n\n/**\n * Builds operations needs to be executed for many-to-many relations of the given subjects.\n *\n * Example:\n *\n * `Post` owns a many-to-many relation with `Category` in the property called `categories`, e.g.:\n *\n * `@ManyToMany(type => Category, category => category.posts) categories: Category[]`\n *\n *  If the user adds categories into the post and saves post we need to bind them.\n *  This operation requires updating the junction table.\n */\nexport class ManyToManySubjectBuilder {\n    // ---------------------------------------------------------------------\n    // Constructor\n    // ---------------------------------------------------------------------\n\n    constructor(protected subjects: Subject[]) {}\n\n    // ---------------------------------------------------------------------\n    // Public Methods\n    // ---------------------------------------------------------------------\n\n    /**\n     * Builds operations for any changes in the many-to-many relations of the subjects.\n     */\n    build(): void {\n        this.subjects.forEach((subject) => {\n            // if subject doesn't have entity then no need to find something that should be inserted or removed\n            if (!subject.entity) return\n\n            // go through all persistence enabled many-to-many relations and build subject operations for them\n            subject.metadata.manyToManyRelations.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     * Builds operations for removal of all many-to-many records of all many-to-many relations of the given subject.\n     * @param subject\n     */\n    buildForAllRemoval(subject: Subject) {\n        // if subject does not have a database entity then it means it does not exist in the database\n        // if it does not exist in the database then we don't have anything for deletion\n        if (!subject.databaseEntity) return\n\n        // go through all persistence enabled many-to-many relations and build subject operations for them\n        subject.metadata.manyToManyRelations.forEach((relation) => {\n            // skip relations for which persistence is disabled\n            if (relation.persistenceEnabled === false) return\n\n            // get all related entities (actually related entity relation ids) bind to this subject entity\n            // by example: returns category ids of the post we are currently working with (subject.entity is post)\n            const relatedEntityRelationIdsInDatabase: ObjectLiteral[] =\n                relation.getEntityValue(subject.databaseEntity!)\n\n            // go through all related entities and create a new junction subject for each row in junction table\n            relatedEntityRelationIdsInDatabase.forEach((relationId) => {\n                const junctionSubject = new Subject({\n                    metadata: relation.junctionEntityMetadata!,\n                    parentSubject: subject,\n                    mustBeRemoved: true,\n                    identifier: this.buildJunctionIdentifier(\n                        subject,\n                        relation,\n                        relationId,\n                    ),\n                })\n\n                // we use unshift because we need to perform those operations before post deletion is performed\n                // but post deletion was already added as an subject\n                // this is temporary solution, later we need to implement proper sorting of subjects before their removal\n                this.subjects.push(junctionSubject)\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     * @param subject\n     * @param relation\n     */\n    protected buildForSubjectRelation(\n        subject: Subject,\n        relation: RelationMetadata,\n    ) {\n        // load from db all relation ids of inverse entities that are \"bind\" to the subject's entity\n        // this way we gonna check which relation ids are missing and which are new (e.g. inserted or removed)\n        let databaseRelatedEntityIds: ObjectLiteral[] = []\n\n        // if subject don't have database entity it means all related entities in persisted subject are new and must be bind\n        // and we don't need to remove something that is not exist\n        if (subject.databaseEntity) {\n            const databaseRelatedEntityValue = relation.getEntityValue(\n                subject.databaseEntity,\n            )\n            if (databaseRelatedEntityValue) {\n                databaseRelatedEntityIds = databaseRelatedEntityValue.map(\n                    (e: any) =>\n                        relation.inverseEntityMetadata.getEntityIdMap(e),\n                )\n            }\n        }\n\n        // extract entity's relation value\n        // by example: categories inside our post (subject.entity is post)\n        let relatedEntities: ObjectLiteral[] = relation.getEntityValue(\n            subject.entity!,\n        )\n        if (relatedEntities === null)\n            // if value set to null its equal if we set it to empty array - all items must be removed from the database\n            relatedEntities = []\n        if (!Array.isArray(relatedEntities)) return\n\n        // from all related entities find only those which aren't found in the db - for them we will create operation subjects\n        relatedEntities.forEach((relatedEntity) => {\n            // by example: relatedEntity is category from categories saved with post\n\n            // todo: check how it will work for entities which are saved by cascades, but aren't saved in the database yet\n\n            // extract only relation id from the related entities, since we only need it for comparison\n            // by example: extract from category only relation id (category id, or let's say category title, depend on join column options)\n            let relatedEntityRelationIdMap =\n                relation.inverseEntityMetadata!.getEntityIdMap(relatedEntity)\n\n            // try to find a subject of this related entity, maybe it was loaded or was marked for persistence\n            const 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                relatedEntityRelationIdMap = relatedEntitySubject.identifier\n\n            // if related entity relation id map is empty it means related entity is newly persisted\n            if (!relatedEntityRelationIdMap) {\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                // we decided to remove this error because it brings complications when saving object with non-saved entities\n                // if (!relatedEntitySubject)\n                //     throw new TypeORMError(`Many-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\n            // try to find related entity in the database\n            // by example: find post's category in the database post's categories\n            const relatedEntityExistInDatabase = databaseRelatedEntityIds.find(\n                (databaseRelatedEntityRelationId) => {\n                    return OrmUtils.compareIds(\n                        databaseRelatedEntityRelationId,\n                        relatedEntityRelationIdMap,\n                    )\n                },\n            )\n\n            // if entity is found then don't do anything - it means binding in junction table already exist, we don't need to add anything\n            if (relatedEntityExistInDatabase) return\n\n            const ownerValue = relation.isOwning\n                ? subject\n                : relatedEntitySubject || relatedEntity // by example: ownerEntityMap is post from subject here\n            const inverseValue = relation.isOwning\n                ? relatedEntitySubject || relatedEntity\n                : subject // by example: inverseEntityMap is category from categories array here\n\n            // create a new subject for insert operation of junction rows\n            const junctionSubject = new Subject({\n                metadata: relation.junctionEntityMetadata!,\n                parentSubject: subject,\n                canBeInserted: true,\n            })\n            this.subjects.push(junctionSubject)\n\n            relation.junctionEntityMetadata!.ownerColumns.forEach((column) => {\n                junctionSubject.changeMaps.push({\n                    column: column,\n                    value: ownerValue,\n                    // valueFactory: (value) => column.referencedColumn!.getEntityValue(value) // column.referencedColumn!.getEntityValue(ownerEntityMap),\n                })\n            })\n\n            relation.junctionEntityMetadata!.inverseColumns.forEach(\n                (column) => {\n                    junctionSubject.changeMaps.push({\n                        column: column,\n                        value: inverseValue,\n                        // valueFactory: (value) => column.referencedColumn!.getEntityValue(value) // column.referencedColumn!.getEntityValue(inverseEntityMap),\n                    })\n                },\n            )\n        })\n\n        // get all inverse entities relation ids that are \"bind\" to the currently persisted entity\n        const changedInverseEntityRelationIds: ObjectLiteral[] = []\n        relatedEntities.forEach((relatedEntity) => {\n            // relation.inverseEntityMetadata!.getEntityIdMap(relatedEntity)\n            let relatedEntityRelationIdMap =\n                relation.inverseEntityMetadata!.getEntityIdMap(relatedEntity)\n\n            // try to find a subject of this related entity, maybe it was loaded or was marked for persistence\n            const 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                relatedEntityRelationIdMap = relatedEntitySubject.identifier\n\n            if (\n                relatedEntityRelationIdMap !== undefined &&\n                relatedEntityRelationIdMap !== null\n            )\n                changedInverseEntityRelationIds.push(relatedEntityRelationIdMap)\n        })\n\n        // now from all entities in the persisted entity find only those which aren't found in the db\n        const removedJunctionEntityIds = databaseRelatedEntityIds.filter(\n            (existRelationId) => {\n                return !changedInverseEntityRelationIds.find(\n                    (changedRelationId) => {\n                        return OrmUtils.compareIds(\n                            changedRelationId,\n                            existRelationId,\n                        )\n                    },\n                )\n            },\n        )\n\n        // finally create a new junction remove operations for missing related entities\n        removedJunctionEntityIds.forEach((removedEntityRelationId) => {\n            const junctionSubject = new Subject({\n                metadata: relation.junctionEntityMetadata!,\n                parentSubject: subject,\n                mustBeRemoved: true,\n                identifier: this.buildJunctionIdentifier(\n                    subject,\n                    relation,\n                    removedEntityRelationId,\n                ),\n            })\n            this.subjects.push(junctionSubject)\n        })\n    }\n\n    /**\n     * Creates identifiers for junction table.\n     * Example: { postId: 1, categoryId: 2 }\n     * @param subject\n     * @param relation\n     * @param relationId\n     */\n    protected buildJunctionIdentifier(\n        subject: Subject,\n        relation: RelationMetadata,\n        relationId: ObjectLiteral,\n    ) {\n        const ownerEntityMap = relation.isOwning ? subject.entity! : relationId\n        const inverseEntityMap = relation.isOwning\n            ? relationId\n            : subject.entity!\n\n        const identifier: ObjectLiteral = {}\n        relation.junctionEntityMetadata!.ownerColumns.forEach((column) => {\n            OrmUtils.mergeDeep(\n                identifier,\n                column.createValueMap(\n                    column.referencedColumn!.getEntityValue(ownerEntityMap),\n                ),\n            )\n        })\n        relation.junctionEntityMetadata!.inverseColumns.forEach((column) => {\n            OrmUtils.mergeDeep(\n                identifier,\n                column.createValueMap(\n                    column.referencedColumn!.getEntityValue(inverseEntityMap),\n                ),\n            )\n        })\n        return identifier\n    }\n}\n"]}

package/browser/persistence/subject-builder/OneToManySubjectBuilder.d.ts

@@ -1,15 +1,20 @@
 import { Subject } from "../Subject";
-import { RelationMetadata } from "../../metadata/RelationMetadata";
+import type { RelationMetadata } from "../../metadata/RelationMetadata";
 /**
  * Builds operations needs to be executed for one-to-many relations of the given subjects.
  *
- * by example: post contains one-to-many relation with category in the property called "categories", e.g.
- *             @OneToMany(type => Category, category => category.post) categories: Category[]
- *             If user adds categories into the post and saves post we need to bind them.
- *             This operation requires updation of category table since its owner of the relation and contains a join column.
+ * Example:
  *
- * note: this class shares lot of things with OneToOneInverseSideOperationBuilder, so when you change this class
- *       make sure to reflect changes there as well.
+ * `Post` contains one-to-many relation with `Category` in the property called `categories`, e.g.:
+ *
+ * `@OneToMany(type => Category, category => category.post) categories: Category[]`
+ *
+ * If user adds categories into the post and saves post we need to bind them.
+ * This operation requires updating the category table since it's the owner of
+ * the relation and contains a join column.
+ *
+ * Note: this class shares lot of things with OneToOneInverseSideOperationBuilder,
+ * so when you change this class make sure to reflect changes there as well.
  */
 export declare class OneToManySubjectBuilder {
     protected subjects: Subject[];
@@ -22,6 +27,8 @@ export declare class OneToManySubjectBuilder {
      * Builds operations for a given subject and relation.
      *
      * by example: subject is "post" entity we are saving here and relation is "categories" inside it here.
+     * @param subject
+     * @param relation
      */
     protected buildForSubjectRelation(subject: Subject, relation: RelationMetadata): void;
 }

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

@@ -1,18 +1,26 @@
-import { Subject } from "../Subject";
-import { OrmUtils } from "../../util/OrmUtils";
-import { EntityMetadata } from "../../metadata/EntityMetadata";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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.
  *
- * by example: post contains one-to-many relation with category in the property called "categories", e.g.
- *             @OneToMany(type => Category, category => category.post) categories: Category[]
- *             If user adds categories into the post and saves post we need to bind them.
- *             This operation requires updation of category table since its owner of the relation and contains a join column.
+ * Example:
  *
- * note: this class shares lot of things with OneToOneInverseSideOperationBuilder, so when you change this class
- *       make sure to reflect changes there as well.
+ * `Post` contains one-to-many relation with `Category` in the property called `categories`, e.g.:
+ *
+ * `@OneToMany(type => Category, category => category.post) categories: Category[]`
+ *
+ * If user adds categories into the post and saves post we need to bind them.
+ * This operation requires updating the category table since it's the owner of
+ * the relation and contains a join column.
+ *
+ * Note: this class shares lot of things with OneToOneInverseSideOperationBuilder,
+ * so when you change this class make sure to reflect changes there as well.
  */
-export class OneToManySubjectBuilder {
+class OneToManySubjectBuilder {
     // ---------------------------------------------------------------------
     // Constructor
     // ---------------------------------------------------------------------
@@ -42,6 +50,8 @@ export class OneToManySubjectBuilder {
      * Builds operations for a given subject and relation.
      *
      * by example: subject is "post" entity we are saving here and relation is "categories" inside it here.
+     * @param subject
+     * @param relation
      */
     buildForSubjectRelation(subject, relation) {
         // prepare objects (relation id maps) for the database entity
@@ -108,7 +118,7 @@ export class OneToManySubjectBuilder {
             // check if this binding really exist in the database
             // by example: find our category if its already bind in the database
             const relationIdInDatabaseSubjectRelation = relatedEntityDatabaseRelationIds.find((relatedDatabaseEntityRelationId) => {
-                return OrmUtils.compareIds(relationIdMap, 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
@@ -120,7 +130,7 @@ export class OneToManySubjectBuilder {
                 // but since we are going to update "category" table (since its an owning side of relation with join column)
                 // we create a new subject here:
                 if (!relatedEntitySubject) {
-                    relatedEntitySubject = new Subject({
+                    relatedEntitySubject = new Subject_1.Subject({
                         metadata: relation.inverseEntityMetadata,
                         parentSubject: subject,
                         canBeUpdated: true,
@@ -142,12 +152,12 @@ export class OneToManySubjectBuilder {
         });
         // find what related entities were added and what were removed based on difference between what we save and what database has
         if (relation.inverseRelation?.orphanedRowAction !== "disable") {
-            EntityMetadata.difference(relatedEntityDatabaseRelationIds, relatedPersistedEntityRelationIds).forEach((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
-                const removedRelatedEntitySubject = new Subject({
+                const removedRelatedEntitySubject = new Subject_1.Subject({
                     metadata: relation.inverseEntityMetadata,
                     parentSubject: subject,
                     identifier: removedRelatedEntityRelationId,
@@ -173,5 +183,5 @@ export class OneToManySubjectBuilder {
         }
     }
 }
-
-//# sourceMappingURL=OneToManySubjectBuilder.js.map
+exports.OneToManySubjectBuilder = OneToManySubjectBuilder;
+//# sourceMappingURL=OneToManySubjectBuilder.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../browser/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        if (relation.inverseRelation?.orphanedRowAction !== \"disable\") {\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}\n"],"sourceRoot":"../.."}
+{"version":3,"file":"OneToManySubjectBuilder.js","sourceRoot":"../build/browser/src/","sources":["persistence/subject-builder/OneToManySubjectBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { Subject } from \"../Subject\"\nimport { OrmUtils } from \"../../util/OrmUtils\"\nimport type { ObjectLiteral } from \"../../common/ObjectLiteral\"\nimport { EntityMetadata } from \"../../metadata/EntityMetadata\"\nimport type { RelationMetadata } from \"../../metadata/RelationMetadata\"\n\n/**\n * Builds operations needs to be executed for one-to-many relations of the given subjects.\n *\n * Example:\n *\n * `Post` contains one-to-many relation with `Category` in the property called `categories`, e.g.:\n *\n * `@OneToMany(type => Category, category => category.post) categories: Category[]`\n *\n * If user adds categories into the post and saves post we need to bind them.\n * This operation requires updating the category table since it's the owner of\n * the relation and contains a join column.\n *\n * Note: this class shares lot of things with OneToOneInverseSideOperationBuilder,\n * so when you change this class 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     * @param subject\n     * @param relation\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        if (relation.inverseRelation?.orphanedRowAction !== \"disable\") {\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}\n"]}

package/browser/persistence/subject-builder/OneToOneInverseSideSubjectBuilder.d.ts

@@ -1,15 +1,20 @@
 import { Subject } from "../Subject";
-import { RelationMetadata } from "../../metadata/RelationMetadata";
+import type { RelationMetadata } from "../../metadata/RelationMetadata";
 /**
  * Builds operations needs to be executed for one-to-one non-owner relations of the given subjects.
  *
- * by example: post contains one-to-one non-owner relation with category in the property called "category", e.g.
- *             @OneToOne(type => Category, category => category.post) category: Category
- *             If user sets a category into the post and saves post we need to bind them.
- *             This operation requires updation of category table since its owner of the relation and contains a join column.
+ * Example:
  *
- * note: this class shares lot of things with OneToManyUpdateBuilder, so when you change this class
- *       make sure to reflect changes there as well.
+ * `Post` contains one-to-one non-owner relation with `Category` in the property called `category`, e.g.:
+ *
+ * `@OneToOne(type => Category, category => category.post) category: Category`
+ *
+ * If user sets a category into the post and saves post we need to bind them.
+ * This operation requires updating the category table since it's the owner of
+ * the relation and contains a join column.
+ *
+ * Note: this class shares lot of things with `OneToManyUpdateBuilder`, so when
+ * you change this class make sure to reflect changes there as well.
  */
 export declare class OneToOneInverseSideSubjectBuilder {
     protected subjects: Subject[];
@@ -22,6 +27,8 @@ export declare class OneToOneInverseSideSubjectBuilder {
      * Builds operations for a given subject and relation.
      *
      * by example: subject is "post" entity we are saving here and relation is "category" inside it here.
+     * @param subject
+     * @param relation
      */
     protected buildForSubjectRelation(subject: Subject, relation: RelationMetadata): void;
 }