@lakutata/orm 3.0.0 → 3.1.1

package/dist/vendor/typeorm/persistence/subject-builder/CascadesSubjectBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CascadesSubjectBuilder.js","sourceRoot":"","sources":["../../../../../vendor/typeorm/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     *\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                // skip undefined/null values and relations whose cascade flags\n                // don't match the current operation type\n                if (relationEntity === undefined || relationEntity === null)\n                    return\n\n                let shouldCascade: boolean\n                switch (operationType) {\n                    case \"save\":\n                        shouldCascade =\n                            relation.isCascadeInsert || relation.isCascadeUpdate\n                        break\n                    case \"remove\":\n                        shouldCascade = relation.isCascadeRemove\n                        break\n                    case \"soft-remove\":\n                        shouldCascade = relation.isCascadeSoftRemove\n                        break\n                    case \"recover\":\n                        shouldCascade = relation.isCascadeRecover\n                        break\n                    default:\n                        shouldCascade = false\n                }\n\n                if (!shouldCascade) 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                        alreadyExistRelationEntitySubject.canBeInserted =\n                            relation.isCascadeInsert === true &&\n                            operationType === \"save\"\n                    if (\n                        alreadyExistRelationEntitySubject.canBeUpdated === false\n                    )\n                        alreadyExistRelationEntitySubject.canBeUpdated =\n                            relation.isCascadeUpdate === true &&\n                            operationType === \"save\"\n                    if (!alreadyExistRelationEntitySubject.mustBeRemoved)\n                        alreadyExistRelationEntitySubject.mustBeRemoved =\n                            relation.isCascadeRemove === true &&\n                            operationType === \"remove\" &&\n                            !!alreadyExistRelationEntitySubject.identifier\n                    if (\n                        alreadyExistRelationEntitySubject.canBeSoftRemoved ===\n                        false\n                    )\n                        alreadyExistRelationEntitySubject.canBeSoftRemoved =\n                            relation.isCascadeSoftRemove === true &&\n                            operationType === \"soft-remove\"\n                    if (\n                        alreadyExistRelationEntitySubject.canBeRecovered ===\n                        false\n                    )\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\n                // only mark for removal if the subject has an identifier,\n                // otherwise SubjectExecutor will throw SubjectWithoutIdentifierError\n                if (\n                    relation.isCascadeRemove === true &&\n                    operationType === \"remove\" &&\n                    relationEntitySubject.identifier\n                ) {\n                    relationEntitySubject.mustBeRemoved = true\n                }\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     * @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/dist/vendor/typeorm/persistence/subject-builder/ManyToManySubjectBuilder.d.ts

@@ -0,0 +1,47 @@
+import { Subject } from "../Subject";
+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.
+ *
+ * @example
+ * // Post owns a many-to-many relation with Category in the property called "categories".
+ * // If the user adds categories into the post and saves post we need to bind them.
+ * // This operation requires updating the junction table.
+ * \@ManyToMany(type => Category, category => category.posts) categories: Category[]
+ *
+ */
+export declare class ManyToManySubjectBuilder {
+    protected subjects: Subject[];
+    constructor(subjects: Subject[]);
+    /**
+     * Builds operations for any changes in the many-to-many relations of the subjects.
+     */
+    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/dist/vendor/typeorm/persistence/subject-builder/ManyToManySubjectBuilder.js

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

package/dist/vendor/typeorm/persistence/subject-builder/ManyToManySubjectBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ManyToManySubjectBuilder.js","sourceRoot":"","sources":["../../../../../vendor/typeorm/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 * // Post owns a many-to-many relation with Category in the property called \"categories\".\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 * \\@ManyToMany(type => Category, category => category.posts) categories: Category[]\n *\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     * @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     *\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 === undefined)\n            // if relation is undefined then it was not loaded - nothing to update\n            return\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     *\n     * @example\n     * { postId: 1, categoryId: 2 }\n     *\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/dist/vendor/typeorm/persistence/subject-builder/OneToManySubjectBuilder.d.ts

@@ -0,0 +1,33 @@
+import { Subject } from "../Subject";
+import type { RelationMetadata } from "../../metadata/RelationMetadata";
+/**
+ * Builds operations needs to be executed for one-to-many relations of the given subjects.
+ *
+ * Note: this class shares lot of things with OneToOneInverseSideOperationBuilder,
+ * so when you change this class make sure to reflect changes there as well.
+ *
+ * @example
+ * // Post contains one-to-many relation with Category in the property called "categories".
+ * // 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.
+ * \@OneToMany(type => Category, category => category.post) categories: Category[]
+ *
+ */
+export declare class OneToManySubjectBuilder {
+    protected subjects: Subject[];
+    constructor(subjects: Subject[]);
+    /**
+     * Builds all required operations.
+     */
+    build(): 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;
+}

package/dist/vendor/typeorm/persistence/subject-builder/OneToManySubjectBuilder.js

@@ -0,0 +1,193 @@
+"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.
+ *
+ * Note: this class shares lot of things with OneToOneInverseSideOperationBuilder,
+ * so when you change this class make sure to reflect changes there as well.
+ *
+ * @example
+ * // Post contains one-to-many relation with Category in the property called "categories".
+ * // 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.
+ * \@OneToMany(type => Category, category => category.post) categories: Category[]
+ *
+ */
+class OneToManySubjectBuilder {
+    // ---------------------------------------------------------------------
+    // Constructor
+    // ---------------------------------------------------------------------
+    constructor(subjects) {
+        this.subjects = subjects;
+    }
+    // ---------------------------------------------------------------------
+    // Public Methods
+    // ---------------------------------------------------------------------
+    /**
+     * Builds all required operations.
+     */
+    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);
+            });
+        });
+    }
+    // ---------------------------------------------------------------------
+    // Protected Methods
+    // ---------------------------------------------------------------------
+    /**
+     * 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
+        // 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
+        // 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
+        let relatedEntities = relation.getEntityValue(subject.entity);
+        if (relatedEntities === undefined)
+            // if relation is undefined then nothing to update
+            return;
+        // we treat relations set to null as removed, so we don't skip it
+        relatedEntities ??= [];
+        // 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)
+        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
+            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
+            if (relatedEntitySubject)
+                relationIdMap = relatedEntitySubject.identifier;
+            // if relationIdMap is undefined then it means user binds object which is not saved in the database yet
+            // by example: if post contains categories which does not have ids yet (because they are new)
+            //             it means they are always newly inserted and relation update operation always must be created for them
+            //             it does not make sense to perform difference operation for them for both add and remove actions
+            if (!relationIdMap) {
+                // we decided to remove this error because it brings complications when saving object with non-saved entities
+                // if (!relatedEntitySubject)
+                //     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)
+                    return;
+                // okay, so related subject exist and its marked for insertion, then add a new change map
+                // by example: this will tell category to insert into its post relation our post we are working with
+                //             relatedEntitySubject is newly inserted CategorySubject
+                //             relation.inverseRelation is ManyToOne relation inside Category
+                //             subject is Post needs to be inserted into Category
+                relatedEntitySubject.changeMaps.push({
+                    relation: relation.inverseRelation,
+                    value: subject,
+                });
+                return;
+            }
+            // 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_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
+            //             relatedEntitySubject is newly inserted CategorySubject
+            //             relation.inverseRelation is ManyToOne relation inside Category
+            //             subject is Post needs to be inserted into Category
+            if (!relationIdInDatabaseSubjectRelation) {
+                // if there is no relatedEntitySubject then it means "category" wasn't persisted,
+                // 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_1.Subject({
+                        metadata: relation.inverseEntityMetadata,
+                        parentSubject: subject,
+                        canBeUpdated: true,
+                        identifier: relationIdMap,
+                    });
+                    this.subjects.push(relatedEntitySubject);
+                }
+                relatedEntitySubject.changeMaps.push({
+                    relation: relation.inverseRelation,
+                    value: subject,
+                });
+            }
+            // if related entity has relation id then we add it to the list of relation ids
+            // this list will be used later to compare with database relation ids to find a difference
+            // what exist in this array and does not exist in the database are newly inserted relations
+            // what does not exist in this array, but exist in the database are removed relations
+            // removed relations are set to null from inverse side of relation
+            relatedPersistedEntityRelationIds.push(relationIdMap);
+        });
+        // 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_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_1.Subject({
+                    metadata: relation.inverseEntityMetadata,
+                    parentSubject: subject,
+                    identifier: removedRelatedEntityRelationId,
+                });
+                const orphanedRowAction = relation.inverseRelation?.orphanedRowAction ?? "nullify";
+                if (orphanedRowAction === "nullify") {
+                    const allColumnsNullable = relation.inverseRelation?.joinColumns.every((column) => column.isNullable) ?? true;
+                    if (allColumnsNullable) {
+                        removedRelatedEntitySubject.canBeUpdated = true;
+                        removedRelatedEntitySubject.changeMaps = [
+                            {
+                                relation: relation.inverseRelation,
+                                value: null,
+                            },
+                        ];
+                    }
+                    else {
+                        // FK is not nullable — cannot set to null, so delete
+                        // the orphaned entity to keep DB consistent
+                        removedRelatedEntitySubject.mustBeRemoved = true;
+                    }
+                }
+                else if (orphanedRowAction === "delete") {
+                    removedRelatedEntitySubject.mustBeRemoved = true;
+                }
+                else if (orphanedRowAction === "soft-delete") {
+                    removedRelatedEntitySubject.canBeSoftRemoved = true;
+                }
+                this.subjects.push(removedRelatedEntitySubject);
+            });
+        }
+    }
+}
+exports.OneToManySubjectBuilder = OneToManySubjectBuilder;
+//# sourceMappingURL=OneToManySubjectBuilder.js.map

package/dist/vendor/typeorm/persistence/subject-builder/OneToManySubjectBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OneToManySubjectBuilder.js","sourceRoot":"","sources":["../../../../../vendor/typeorm/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 * 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 *\n * @example\n * // Post contains one-to-many relation with Category in the property called \"categories\".\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 * \\@OneToMany(type => Category, category => category.post) categories: Category[]\n *\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     * @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((entity) =>\n                        relation.inverseEntityMetadata.getEntityIdMap(entity)!,\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 === undefined)\n            // if relation is undefined then nothing to update\n            return\n        // we treat relations set to null as removed, so we don't skip it\n        relatedEntities ??= [] as ObjectLiteral[]\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                const orphanedRowAction =\n                    relation.inverseRelation?.orphanedRowAction ?? \"nullify\"\n\n                if (orphanedRowAction === \"nullify\") {\n                    const allColumnsNullable =\n                        relation.inverseRelation?.joinColumns.every(\n                            (column) => column.isNullable,\n                        ) ?? true\n\n                    if (allColumnsNullable) {\n                        removedRelatedEntitySubject.canBeUpdated = true\n                        removedRelatedEntitySubject.changeMaps = [\n                            {\n                                relation: relation.inverseRelation!,\n                                value: null,\n                            },\n                        ]\n                    } else {\n                        // FK is not nullable — cannot set to null, so delete\n                        // the orphaned entity to keep DB consistent\n                        removedRelatedEntitySubject.mustBeRemoved = true\n                    }\n                } else if (orphanedRowAction === \"delete\") {\n                    removedRelatedEntitySubject.mustBeRemoved = true\n                } else if (orphanedRowAction === \"soft-delete\") {\n                    removedRelatedEntitySubject.canBeSoftRemoved = true\n                }\n\n                this.subjects.push(removedRelatedEntitySubject)\n            })\n        }\n    }\n}\n"]}