typeorm 0.2.38-dev.324f1d8

package/persistence/Subject.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/persistence/Subject.ts"],"names":[],"mappings":"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","file":"Subject.js","sourcesContent":["import {ObjectLiteral} from \"../common/ObjectLiteral\";\nimport {EntityMetadata} from \"../metadata/EntityMetadata\";\nimport {SubjectChangeMap} from \"./SubjectChangeMap\";\nimport {OrmUtils} from \"../util/OrmUtils\";\nimport {RelationMetadata} from \"../metadata/RelationMetadata\";\nimport {ColumnMetadata} from \"../metadata/ColumnMetadata\";\n\n/**\n * Subject is a subject of persistence.\n * It holds information about each entity that needs to be persisted:\n * - what entity should be persisted\n * - what is database representation of the persisted entity\n * - what entity metadata of the persisted entity\n * - what is allowed to with persisted entity (insert/update/remove)\n *\n * Having this collection of subjects we can perform database queries.\n */\nexport class Subject {\n\n    // -------------------------------------------------------------------------\n    // Properties\n    // -------------------------------------------------------------------------\n\n    /**\n     * Entity metadata of the subject entity.\n     */\n    metadata: EntityMetadata;\n\n    /**\n     * Subject identifier.\n     * This identifier is not limited to table entity primary columns.\n     * This can be entity id or ids as well as some unique entity properties, like name or title.\n     * Insert / Update / Remove operation will be executed by a given identifier.\n     */\n    identifier: ObjectLiteral|undefined = undefined;\n\n    /**\n     * Copy of entity but with relational ids fulfilled.\n     */\n    entityWithFulfilledIds: ObjectLiteral|undefined = undefined;\n\n    /**\n     * If subject was created by cascades this property will contain subject\n     * from where this subject was created.\n     */\n    parentSubject?: Subject;\n\n    /**\n     * Gets entity sent to the persistence (e.g. changed entity).\n     * If entity is not set then this subject is created only for the entity loaded from the database,\n     * or this subject is used for the junction operation (junction operations are relying only on identifier).\n     */\n    entity?: ObjectLiteral;\n\n    /**\n     * Database entity.\n     * THIS IS NOT RAW ENTITY DATA, its a real entity.\n     */\n    databaseEntity?: ObjectLiteral;\n\n    /**\n     * Indicates if database entity was loaded.\n     * No matter if it was found or not, it indicates the fact of loading.\n     */\n    databaseEntityLoaded: boolean = false;\n\n    /**\n     * Changes needs to be applied in the database for the given subject.\n     */\n    changeMaps: SubjectChangeMap[] = [];\n\n    /**\n     * Generated values returned by a database (for example generated id or default values).\n     * Used in insert and update operations.\n     * Has entity-like structure (not just column database name and values).\n     */\n    generatedMap?: ObjectLiteral;\n\n    /**\n     * Inserted values with updated values of special and default columns.\n     * Has entity-like structure (not just column database name and values).\n     */\n    insertedValueSet?: ObjectLiteral;\n\n    /**\n     * Indicates if this subject can be inserted into the database.\n     * This means that this subject either is newly persisted, either can be inserted by cascades.\n     */\n    canBeInserted: boolean = false;\n\n    /**\n     * Indicates if this subject can be updated in the database.\n     * This means that this subject either was persisted, either can be updated by cascades.\n     */\n    canBeUpdated: boolean = false;\n\n    /**\n     * Indicates if this subject MUST be removed from the database.\n     * This means that this subject either was removed, either was removed by cascades.\n     */\n    mustBeRemoved: boolean = false;\n\n    /**\n     * Indicates if this subject can be soft-removed from the database.\n     * This means that this subject either was soft-removed, either was soft-removed by cascades.\n     */\n    canBeSoftRemoved: boolean = false;\n\n    /**\n     * Indicates if this subject can be recovered from the database.\n     * This means that this subject either was recovered, either was recovered by cascades.\n     */\n    canBeRecovered: boolean = false;\n\n    /**\n     * Relations updated by the change maps.\n     */\n    updatedRelationMaps: { relation: RelationMetadata, value: ObjectLiteral }[] = [];\n\n    /**\n     * List of updated columns\n     */\n    diffColumns: ColumnMetadata[] = [];\n\n    /**\n     * List of updated relations\n     */\n    diffRelations: RelationMetadata[] = [];\n\n    // -------------------------------------------------------------------------\n    // Constructor\n    // -------------------------------------------------------------------------\n\n    constructor(options: {\n        metadata: EntityMetadata,\n        parentSubject?: Subject,\n        entity?: ObjectLiteral,\n        canBeInserted?: boolean,\n        canBeUpdated?: boolean,\n        mustBeRemoved?: boolean,\n        canBeSoftRemoved?: boolean,\n        canBeRecovered?: boolean,\n        identifier?: ObjectLiteral,\n        changeMaps?: SubjectChangeMap[]\n    }) {\n        this.metadata = options.metadata;\n        this.entity = options.entity;\n        this.parentSubject = options.parentSubject;\n        if (options.canBeInserted !== undefined)\n            this.canBeInserted = options.canBeInserted;\n        if (options.canBeUpdated !== undefined)\n            this.canBeUpdated = options.canBeUpdated;\n        if (options.mustBeRemoved !== undefined)\n            this.mustBeRemoved = options.mustBeRemoved;\n        if (options.canBeSoftRemoved !== undefined)\n            this.canBeSoftRemoved = options.canBeSoftRemoved;\n        if (options.canBeRecovered !== undefined)\n            this.canBeRecovered = options.canBeRecovered;\n        if (options.identifier !== undefined)\n            this.identifier = options.identifier;\n        if (options.changeMaps !== undefined)\n            this.changeMaps.push(...options.changeMaps);\n\n        this.recompute();\n    }\n\n    // -------------------------------------------------------------------------\n    // Accessors\n    // -------------------------------------------------------------------------\n\n    /**\n     * Checks if this subject must be inserted into the database.\n     * Subject can be inserted into the database if it is allowed to be inserted (explicitly persisted or by cascades)\n     * and if it does not have database entity set.\n     */\n    get mustBeInserted() {\n        return this.canBeInserted && !this.databaseEntity;\n    }\n\n    /**\n     * Checks if this subject must be updated into the database.\n     * Subject can be updated in the database if it is allowed to be updated (explicitly persisted or by cascades)\n     * and if it does have differentiated columns or relations.\n     */\n    get mustBeUpdated() {\n        return this.canBeUpdated &&\n            this.identifier &&\n            (this.databaseEntityLoaded === false || (this.databaseEntityLoaded && this.databaseEntity)) &&\n            // ((this.entity && this.databaseEntity) || (!this.entity && !this.databaseEntity)) &&\n            this.changeMaps.length > 0;\n    }\n\n    /**\n     * Checks if this subject must be soft-removed into the database.\n     * Subject can be updated in the database if it is allowed to be soft-removed (explicitly persisted or by cascades)\n     * and if it does have differentiated columns or relations.\n     */\n    get mustBeSoftRemoved() {\n        return this.canBeSoftRemoved &&\n            this.identifier &&\n            (this.databaseEntityLoaded === false || (this.databaseEntityLoaded && this.databaseEntity));\n    }\n\n    /**\n     * Checks if this subject must be recovered into the database.\n     * Subject can be updated in the database if it is allowed to be recovered (explicitly persisted or by cascades)\n     * and if it does have differentiated columns or relations.\n     */\n    get mustBeRecovered() {\n        return this.canBeRecovered &&\n            this.identifier &&\n            (this.databaseEntityLoaded === false || (this.databaseEntityLoaded && this.databaseEntity));\n    }\n\n    // -------------------------------------------------------------------------\n    // Public Methods\n    // -------------------------------------------------------------------------\n\n    /**\n     * Creates a value set needs to be inserted / updated in the database.\n     * Value set is based on the entity and change maps of the subject.\n     * Important note: this method pops data from this subject's change maps.\n     */\n    createValueSetAndPopChangeMap(): ObjectLiteral {\n        const changeMapsWithoutValues: SubjectChangeMap[] = [];\n        const changeSet = this.changeMaps.reduce((updateMap, changeMap) => {\n            let value = changeMap.value;\n            if (value instanceof Subject) {\n\n                // referenced columns can refer on values both which were just inserted and which were present in the model\n                // if entity was just inserted valueSets must contain all values from the entity and values just inserted in the database\n                // so, here we check if we have a value set then we simply use it as value to get our reference column values\n                // otherwise simply use an entity which cannot be just inserted at the moment and have all necessary data\n                value = value.insertedValueSet ? value.insertedValueSet : value.entity;\n            }\n            // value = changeMap.valueFactory ? changeMap.valueFactory(value) : changeMap.column.createValueMap(value);\n\n            let valueMap: ObjectLiteral|undefined;\n            if (this.metadata.isJunction && changeMap.column) {\n                valueMap = changeMap.column.createValueMap(changeMap.column.referencedColumn!.getEntityValue(value));\n\n            } else if (changeMap.column) {\n                valueMap = changeMap.column.createValueMap(value);\n\n            } else if (changeMap.relation) {\n\n                // value can be a related object, for example: post.question = { id: 1 }\n                // or value can be a null or direct relation id, e.g. post.question = 1\n                // if its a direction relation id then we just set it to the valueMap,\n                // however if its an object then we need to extract its relation id map and set it to the valueMap\n                if (value instanceof Object && !(value instanceof Buffer)) {\n\n                    // get relation id, e.g. referenced column name and its value,\n                    // for example: { id: 1 } which then will be set to relation, e.g. post.category = { id: 1 }\n                    const relationId = changeMap.relation!.getRelationIdMap(value);\n\n                    // but relation id can be empty, for example in the case when you insert a new post with category\n                    // and both post and category are newly inserted objects (by cascades) and in this case category will not have id\n                    // this means we need to insert post without question id and update post's questionId once question be inserted\n                    // that's why we create a new changeMap operation for future updation of the post entity\n                    if (relationId === undefined) {\n                        changeMapsWithoutValues.push(changeMap);\n                        this.canBeUpdated = true;\n                        return updateMap;\n                    }\n                    valueMap = changeMap.relation!.createValueMap(relationId);\n                    this.updatedRelationMaps.push({ relation: changeMap.relation, value: relationId });\n\n                } else { // value can be \"null\" or direct relation id here\n                    valueMap = changeMap.relation!.createValueMap(value);\n                    this.updatedRelationMaps.push({ relation: changeMap.relation, value: value });\n                }\n            }\n\n            OrmUtils.mergeDeep(updateMap, valueMap);\n            return updateMap;\n        }, {} as ObjectLiteral);\n        this.changeMaps = changeMapsWithoutValues;\n        return changeSet;\n    }\n\n    /**\n     * Recomputes entityWithFulfilledIds and identifier when entity changes.\n     */\n    recompute(): void {\n\n        if (this.entity) {\n            this.entityWithFulfilledIds = Object.assign({}, this.entity);\n            if (this.parentSubject) {\n                this.metadata.primaryColumns.forEach(primaryColumn => {\n                    if (primaryColumn.relationMetadata && primaryColumn.relationMetadata.inverseEntityMetadata === this.parentSubject!.metadata) {\n                        const value = primaryColumn.referencedColumn!.getEntityValue(this.parentSubject!.entity!);\n                        primaryColumn.setEntityValue(this.entityWithFulfilledIds!, value);\n                    }\n                });\n            }\n            this.identifier = this.metadata.getEntityIdMap(this.entityWithFulfilledIds);\n\n        } else if (this.databaseEntity) {\n            this.identifier = this.metadata.getEntityIdMap(this.databaseEntity);\n        }\n    }\n\n}\n"],"sourceRoot":".."}

package/persistence/SubjectChangeMap.d.ts

@@ -0,0 +1,23 @@
+import { ColumnMetadata } from "../metadata/ColumnMetadata";
+import { RelationMetadata } from "../metadata/RelationMetadata";
+import { Subject } from "./Subject";
+/**
+ * Change for insertion or updation of the column of the subject.
+ */
+export interface SubjectChangeMap {
+    /**
+     * Column that needs to be changed.
+     * Either column, either relation must be set in the change.
+     */
+    column?: ColumnMetadata;
+    /**
+     * Relation that needs to be changed.
+     * Either column, either relation must be set in the change.
+     */
+    relation?: RelationMetadata;
+    /**
+     * Value needs to be inserted into given column.
+     * This value can also be another subject, when this column has a referenced column.
+     */
+    value: Subject | any;
+}

package/persistence/SubjectChangeMap.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+
+//# sourceMappingURL=SubjectChangeMap.js.map

package/persistence/SubjectChangeMap.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/persistence/SubjectChangeMap.ts"],"names":[],"mappings":"","file":"SubjectChangeMap.js","sourcesContent":["import {ColumnMetadata} from \"../metadata/ColumnMetadata\";\nimport {RelationMetadata} from \"../metadata/RelationMetadata\";\nimport {Subject} from \"./Subject\";\n\n/**\n * Change for insertion or updation of the column of the subject.\n */\nexport interface SubjectChangeMap {\n\n    /**\n     * Column that needs to be changed.\n     * Either column, either relation must be set in the change.\n     */\n    column?: ColumnMetadata;\n\n    /**\n     * Relation that needs to be changed.\n     * Either column, either relation must be set in the change.\n     */\n    relation?: RelationMetadata;\n\n    /**\n     * Value needs to be inserted into given column.\n     * This value can also be another subject, when this column has a referenced column.\n     */\n    value: Subject|any;\n\n}"],"sourceRoot":".."}

package/persistence/SubjectChangedColumnsComputer.d.ts

@@ -0,0 +1,18 @@
+import { Subject } from "./Subject";
+/**
+ * Finds what columns are changed in the subject entities.
+ */
+export declare class SubjectChangedColumnsComputer {
+    /**
+     * Finds what columns are changed in the subject entities.
+     */
+    compute(subjects: Subject[]): void;
+    /**
+     * Differentiate columns from the updated entity and entity stored in the database.
+     */
+    protected computeDiffColumns(subject: Subject): void;
+    /**
+     * Difference columns of the owning one-to-one and many-to-one columns.
+     */
+    protected computeDiffRelationalColumns(allSubjects: Subject[], subject: Subject): void;
+}

package/persistence/SubjectChangedColumnsComputer.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubjectChangedColumnsComputer = void 0;
+var DateUtils_1 = require("../util/DateUtils");
+var OrmUtils_1 = require("../util/OrmUtils");
+var ApplyValueTransformers_1 = require("../util/ApplyValueTransformers");
+/**
+ * Finds what columns are changed in the subject entities.
+ */
+var SubjectChangedColumnsComputer = /** @class */ (function () {
+    function SubjectChangedColumnsComputer() {
+    }
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Finds what columns are changed in the subject entities.
+     */
+    SubjectChangedColumnsComputer.prototype.compute = function (subjects) {
+        var _this = this;
+        subjects.forEach(function (subject) {
+            _this.computeDiffColumns(subject);
+            _this.computeDiffRelationalColumns(subjects, subject);
+        });
+    };
+    // -------------------------------------------------------------------------
+    // Protected Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Differentiate columns from the updated entity and entity stored in the database.
+     */
+    SubjectChangedColumnsComputer.prototype.computeDiffColumns = function (subject) {
+        // if there is no persisted entity then nothing to compute changed in it
+        if (!subject.entity)
+            return;
+        subject.metadata.columns.forEach(function (column) {
+            // ignore special columns
+            if (column.isVirtual ||
+                column.isDiscriminator // ||
+            // column.isUpdateDate ||
+            // column.isVersion ||
+            // column.isCreateDate
+            )
+                return;
+            var changeMap = subject.changeMaps.find(function (changeMap) { return changeMap.column === column; });
+            if (changeMap) {
+                subject.changeMaps.splice(subject.changeMaps.indexOf(changeMap), 1);
+            }
+            // get user provided value - column value from the user provided persisted entity
+            var entityValue = column.getEntityValue(subject.entity);
+            // we don't perform operation over undefined properties (but we DO need null properties!)
+            if (entityValue === undefined)
+                return;
+            // if there is no database entity then all columns are treated as new, e.g. changed
+            if (subject.databaseEntity) {
+                // skip transform database value for json / jsonb for comparison later on
+                var shouldTransformDatabaseEntity = column.type !== "json" && column.type !== "jsonb";
+                // get database value of the column
+                var databaseValue = column.getEntityValue(subject.databaseEntity, shouldTransformDatabaseEntity);
+                // filter out "relational columns" only in the case if there is a relation object in entity
+                if (column.relationMetadata) {
+                    var value = column.relationMetadata.getEntityValue(subject.entity);
+                    if (value !== null && value !== undefined)
+                        return;
+                }
+                var normalizedValue = entityValue;
+                // normalize special values to make proper comparision
+                if (entityValue !== null) {
+                    switch (column.type) {
+                        case "date":
+                            normalizedValue = DateUtils_1.DateUtils.mixedDateToDateString(entityValue);
+                            break;
+                        case "time":
+                        case "time with time zone":
+                        case "time without time zone":
+                        case "timetz":
+                            normalizedValue = DateUtils_1.DateUtils.mixedDateToTimeString(entityValue);
+                            break;
+                        case "datetime":
+                        case "datetime2":
+                        case Date:
+                        case "timestamp":
+                        case "timestamp without time zone":
+                        case "timestamp with time zone":
+                        case "timestamp with local time zone":
+                        case "timestamptz":
+                            normalizedValue = DateUtils_1.DateUtils.mixedDateToUtcDatetimeString(entityValue);
+                            databaseValue = DateUtils_1.DateUtils.mixedDateToUtcDatetimeString(databaseValue);
+                            break;
+                        case "json":
+                        case "jsonb":
+                            // JSON.stringify doesn't work because postgresql sorts jsonb before save.
+                            // If you try to save json '[{"messages": "", "attribute Key": "", "level":""}] ' as jsonb,
+                            // then postgresql will save it as '[{"level": "", "message":"", "attributeKey": ""}]'
+                            if (OrmUtils_1.OrmUtils.deepCompare(entityValue, databaseValue))
+                                return;
+                            break;
+                        case "simple-array":
+                            normalizedValue = DateUtils_1.DateUtils.simpleArrayToString(entityValue);
+                            databaseValue = DateUtils_1.DateUtils.simpleArrayToString(databaseValue);
+                            break;
+                        case "simple-enum":
+                            normalizedValue = DateUtils_1.DateUtils.simpleEnumToString(entityValue);
+                            databaseValue = DateUtils_1.DateUtils.simpleEnumToString(databaseValue);
+                            break;
+                        case "simple-json":
+                            normalizedValue = DateUtils_1.DateUtils.simpleJsonToString(entityValue);
+                            databaseValue = DateUtils_1.DateUtils.simpleJsonToString(databaseValue);
+                            break;
+                    }
+                    if (column.transformer) {
+                        normalizedValue = ApplyValueTransformers_1.ApplyValueTransformers.transformTo(column.transformer, entityValue);
+                    }
+                }
+                // if value is not changed - then do nothing
+                if (normalizedValue instanceof Buffer && databaseValue instanceof Buffer) {
+                    if (normalizedValue.equals(databaseValue)) {
+                        return;
+                    }
+                }
+                else {
+                    if (normalizedValue === databaseValue)
+                        return;
+                }
+            }
+            subject.diffColumns.push(column);
+            subject.changeMaps.push({
+                column: column,
+                value: entityValue
+            });
+        });
+    };
+    /**
+     * Difference columns of the owning one-to-one and many-to-one columns.
+     */
+    SubjectChangedColumnsComputer.prototype.computeDiffRelationalColumns = function (allSubjects, subject) {
+        // if there is no persisted entity then nothing to compute changed in it
+        if (!subject.entity)
+            return;
+        subject.metadata.relationsWithJoinColumns.forEach(function (relation) {
+            // get the related entity from the persisted entity
+            var relatedEntity = relation.getEntityValue(subject.entity);
+            // we don't perform operation over undefined properties (but we DO need null properties!)
+            if (relatedEntity === undefined)
+                return;
+            // if there is no database entity then all relational columns are treated as new, e.g. changed
+            if (subject.databaseEntity) {
+                // here we cover two scenarios:
+                // 1. related entity can be another entity which is natural way
+                // 2. related entity can be just an entity id
+                // if relation entity is just a relation id set (for example post.tag = 1)
+                // then we create an id map from it to make a proper comparision
+                var relatedEntityRelationIdMap = relatedEntity;
+                if (relatedEntityRelationIdMap !== null && relatedEntityRelationIdMap instanceof Object)
+                    relatedEntityRelationIdMap = relation.getRelationIdMap(relatedEntityRelationIdMap);
+                // get database related entity. Since loadRelationIds are used on databaseEntity
+                // related entity will contain only its relation ids
+                var databaseRelatedEntityRelationIdMap = relation.getEntityValue(subject.databaseEntity);
+                // if relation ids are equal then we don't need to update anything
+                var areRelatedIdsEqual = OrmUtils_1.OrmUtils.compareIds(relatedEntityRelationIdMap, databaseRelatedEntityRelationIdMap);
+                if (areRelatedIdsEqual) {
+                    return;
+                }
+                else {
+                    subject.diffRelations.push(relation);
+                }
+            }
+            // if there is an inserted subject for the related entity of the persisted entity then use it as related entity
+            // this code is used for related entities without ids to be properly inserted (and then updated if needed)
+            var valueSubject = allSubjects.find(function (subject) { return subject.mustBeInserted && subject.entity === relatedEntity; });
+            if (valueSubject)
+                relatedEntity = valueSubject;
+            // find if there is already a relation to be changed
+            var changeMap = subject.changeMaps.find(function (changeMap) { return changeMap.relation === relation; });
+            if (changeMap) { // and update its value if it was found
+                changeMap.value = relatedEntity;
+            }
+            else { // if it wasn't found add a new relation for change
+                subject.changeMaps.push({
+                    relation: relation,
+                    value: relatedEntity
+                });
+            }
+        });
+    };
+    return SubjectChangedColumnsComputer;
+}());
+exports.SubjectChangedColumnsComputer = SubjectChangedColumnsComputer;
+
+//# sourceMappingURL=SubjectChangedColumnsComputer.js.map

package/persistence/SubjectChangedColumnsComputer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/persistence/SubjectChangedColumnsComputer.ts"],"names":[],"mappings":"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","file":"SubjectChangedColumnsComputer.js","sourcesContent":["import {Subject} from \"./Subject\";\nimport {DateUtils} from \"../util/DateUtils\";\nimport {ObjectLiteral} from \"../common/ObjectLiteral\";\nimport {OrmUtils} from \"../util/OrmUtils\";\nimport {ApplyValueTransformers} from \"../util/ApplyValueTransformers\";\n\n/**\n * Finds what columns are changed in the subject entities.\n */\nexport class SubjectChangedColumnsComputer {\n\n    // -------------------------------------------------------------------------\n    // Public Methods\n    // -------------------------------------------------------------------------\n\n    /**\n     * Finds what columns are changed in the subject entities.\n     */\n    compute(subjects: Subject[]) {\n        subjects.forEach(subject => {\n            this.computeDiffColumns(subject);\n            this.computeDiffRelationalColumns(subjects, subject);\n        });\n    }\n\n    // -------------------------------------------------------------------------\n    // Protected Methods\n    // -------------------------------------------------------------------------\n\n    /**\n     * Differentiate columns from the updated entity and entity stored in the database.\n     */\n    protected computeDiffColumns(subject: Subject): void {\n\n        // if there is no persisted entity then nothing to compute changed in it\n        if (!subject.entity)\n            return;\n\n        subject.metadata.columns.forEach(column => {\n\n            // ignore special columns\n            if (column.isVirtual ||\n                column.isDiscriminator // ||\n                // column.isUpdateDate ||\n                // column.isVersion ||\n                // column.isCreateDate\n            )\n                return;\n\n            const changeMap = subject.changeMaps.find(changeMap => changeMap.column === column);\n            if (changeMap) {\n                subject.changeMaps.splice(subject.changeMaps.indexOf(changeMap), 1);\n            }\n\n            // get user provided value - column value from the user provided persisted entity\n            const entityValue = column.getEntityValue(subject.entity!);\n\n            // we don't perform operation over undefined properties (but we DO need null properties!)\n            if (entityValue === undefined)\n                return;\n\n            // if there is no database entity then all columns are treated as new, e.g. changed\n            if (subject.databaseEntity) {\n                // skip transform database value for json / jsonb for comparison later on\n                const shouldTransformDatabaseEntity = column.type !== \"json\" && column.type !== \"jsonb\";\n\n                // get database value of the column\n                let databaseValue = column.getEntityValue(subject.databaseEntity, shouldTransformDatabaseEntity);\n\n                // filter out \"relational columns\" only in the case if there is a relation object in entity\n                if (column.relationMetadata) {\n                    const value = column.relationMetadata.getEntityValue(subject.entity!);\n                    if (value !== null && value !== undefined)\n                        return;\n                }\n                let normalizedValue = entityValue;\n                // normalize special values to make proper comparision\n                if (entityValue !== null) {\n                    switch (column.type) {\n                        case \"date\":\n                            normalizedValue = DateUtils.mixedDateToDateString(entityValue);\n                            break;\n\n                        case \"time\":\n                        case \"time with time zone\":\n                        case \"time without time zone\":\n                        case \"timetz\":\n                            normalizedValue = DateUtils.mixedDateToTimeString(entityValue);\n                            break;\n\n                        case \"datetime\":\n                        case \"datetime2\":\n                        case Date:\n                        case \"timestamp\":\n                        case \"timestamp without time zone\":\n                        case \"timestamp with time zone\":\n                        case \"timestamp with local time zone\":\n                        case \"timestamptz\":\n                            normalizedValue = DateUtils.mixedDateToUtcDatetimeString(entityValue);\n                            databaseValue = DateUtils.mixedDateToUtcDatetimeString(databaseValue);\n                            break;\n\n                        case \"json\":\n                        case \"jsonb\":\n                            // JSON.stringify doesn't work because postgresql sorts jsonb before save.\n                            // If you try to save json '[{\"messages\": \"\", \"attribute Key\": \"\", \"level\":\"\"}] ' as jsonb,\n                            // then postgresql will save it as '[{\"level\": \"\", \"message\":\"\", \"attributeKey\": \"\"}]'\n                            if (OrmUtils.deepCompare(entityValue, databaseValue)) return;\n                            break;\n\n                        case \"simple-array\":\n                            normalizedValue = DateUtils.simpleArrayToString(entityValue);\n                            databaseValue = DateUtils.simpleArrayToString(databaseValue);\n                            break;\n                        case \"simple-enum\":\n                            normalizedValue = DateUtils.simpleEnumToString(entityValue);\n                            databaseValue = DateUtils.simpleEnumToString(databaseValue);\n                            break;\n                        case \"simple-json\":\n                            normalizedValue = DateUtils.simpleJsonToString(entityValue);\n                            databaseValue = DateUtils.simpleJsonToString(databaseValue);\n                            break;\n                    }\n\n                    if (column.transformer) {\n                        normalizedValue = ApplyValueTransformers.transformTo(column.transformer, entityValue);\n                    }\n                }\n\n                // if value is not changed - then do nothing\n                if (normalizedValue instanceof Buffer && databaseValue instanceof Buffer) {\n                    if (normalizedValue.equals(databaseValue)) {\n                        return;\n                    }\n\n                } else {\n                    if (normalizedValue === databaseValue)\n                        return;\n                }\n            }\n            subject.diffColumns.push(column);\n            subject.changeMaps.push({\n                column: column,\n                value: entityValue\n            });\n        });\n    }\n\n    /**\n     * Difference columns of the owning one-to-one and many-to-one columns.\n     */\n    protected computeDiffRelationalColumns(allSubjects: Subject[], subject: Subject): void {\n\n        // if there is no persisted entity then nothing to compute changed in it\n        if (!subject.entity)\n            return;\n\n        subject.metadata.relationsWithJoinColumns.forEach(relation => {\n\n            // get the related entity from the persisted entity\n            let relatedEntity = relation.getEntityValue(subject.entity!);\n\n            // we don't perform operation over undefined properties (but we DO need null properties!)\n            if (relatedEntity === undefined)\n                return;\n\n            // if there is no database entity then all relational columns are treated as new, e.g. changed\n            if (subject.databaseEntity) {\n\n                // here we cover two scenarios:\n                // 1. related entity can be another entity which is natural way\n                // 2. related entity can be just an entity id\n                // if relation entity is just a relation id set (for example post.tag = 1)\n                // then we create an id map from it to make a proper comparision\n                let relatedEntityRelationIdMap: ObjectLiteral = relatedEntity;\n                if (relatedEntityRelationIdMap !== null && relatedEntityRelationIdMap instanceof Object)\n                    relatedEntityRelationIdMap = relation.getRelationIdMap(relatedEntityRelationIdMap)!;\n\n                // get database related entity. Since loadRelationIds are used on databaseEntity\n                // related entity will contain only its relation ids\n                const databaseRelatedEntityRelationIdMap = relation.getEntityValue(subject.databaseEntity);\n\n                // if relation ids are equal then we don't need to update anything\n                const areRelatedIdsEqual = OrmUtils.compareIds(relatedEntityRelationIdMap, databaseRelatedEntityRelationIdMap);\n                if (areRelatedIdsEqual) {\n                    return;\n                } else {\n                    subject.diffRelations.push(relation);\n                }\n            }\n\n            // if there is an inserted subject for the related entity of the persisted entity then use it as related entity\n            // this code is used for related entities without ids to be properly inserted (and then updated if needed)\n            const valueSubject = allSubjects.find(subject => subject.mustBeInserted && subject.entity === relatedEntity);\n            if (valueSubject)\n                relatedEntity = valueSubject;\n\n            // find if there is already a relation to be changed\n            const changeMap = subject.changeMaps.find(changeMap => changeMap.relation === relation);\n            if (changeMap) { // and update its value if it was found\n                changeMap.value = relatedEntity;\n\n            } else { // if it wasn't found add a new relation for change\n                subject.changeMaps.push({\n                    relation: relation,\n                    value: relatedEntity\n                });\n            }\n        });\n    }\n\n}\n"],"sourceRoot":".."}

package/persistence/SubjectDatabaseEntityLoader.d.ts

@@ -0,0 +1,35 @@
+import { Subject } from "./Subject";
+import { ObjectLiteral } from "../common/ObjectLiteral";
+import { QueryRunner } from "../query-runner/QueryRunner";
+/**
+ * Loads database entities for all operate subjects which do not have database entity set.
+ * All entities that we load database entities for are marked as updated or inserted.
+ * To understand which of them really needs to be inserted or updated we need to load
+ * their original representations from the database.
+ */
+export declare class SubjectDatabaseEntityLoader {
+    protected queryRunner: QueryRunner;
+    protected subjects: Subject[];
+    constructor(queryRunner: QueryRunner, subjects: Subject[]);
+    /**
+     * Loads database entities for all subjects.
+     *
+     * loadAllRelations flag is used to load all relation ids of the object, no matter if they present in subject entity or not.
+     * This option is used for deletion.
+     */
+    load(operationType: "save" | "remove" | "soft-remove" | "recover"): Promise<void>;
+    /**
+     * Finds subjects where entity like given subject's entity.
+     * Comparision made by entity id.
+     * Multiple subjects may be returned if duplicates are present in the subject array.
+     * This will likely result in the same row being updated multiple times during a transaction.
+     */
+    protected findByPersistEntityLike(entityTarget: Function | string, entity: ObjectLiteral): Subject[];
+    /**
+     * Groups given Subject objects into groups separated by entity targets.
+     */
+    protected groupByEntityTargets(): {
+        target: Function | string;
+        subjects: Subject[];
+    }[];
+}

package/persistence/SubjectDatabaseEntityLoader.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubjectDatabaseEntityLoader = void 0;
+var tslib_1 = require("tslib");
+/**
+ * Loads database entities for all operate subjects which do not have database entity set.
+ * All entities that we load database entities for are marked as updated or inserted.
+ * To understand which of them really needs to be inserted or updated we need to load
+ * their original representations from the database.
+ */
+var SubjectDatabaseEntityLoader = /** @class */ (function () {
+    // ---------------------------------------------------------------------
+    // Constructor
+    // ---------------------------------------------------------------------
+    function SubjectDatabaseEntityLoader(queryRunner, subjects) {
+        this.queryRunner = queryRunner;
+        this.subjects = subjects;
+    }
+    // ---------------------------------------------------------------------
+    // Public Methods
+    // ---------------------------------------------------------------------
+    /**
+     * Loads database entities for all subjects.
+     *
+     * loadAllRelations flag is used to load all relation ids of the object, no matter if they present in subject entity or not.
+     * This option is used for deletion.
+     */
+    SubjectDatabaseEntityLoader.prototype.load = function (operationType) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var promises;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        promises = this.groupByEntityTargets().map(function (subjectGroup) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            var allIds, allSubjects, loadRelationPropertyPaths, findOptions, entities, allSubjects_1, allSubjects_1_1, subject;
+                            var e_1, _a;
+                            var _this = this;
+                            return tslib_1.__generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        allIds = [];
+                                        allSubjects = [];
+                                        subjectGroup.subjects.forEach(function (subject) {
+                                            // we don't load if subject already has a database entity loaded
+                                            if (subject.databaseEntity || !subject.identifier)
+                                                return;
+                                            allIds.push(subject.identifier);
+                                            allSubjects.push(subject);
+                                        });
+                                        // if there no ids found (means all entities are new and have generated ids) - then nothing to load there
+                                        if (!allIds.length)
+                                            return [2 /*return*/];
+                                        loadRelationPropertyPaths = [];
+                                        // for the save, soft-remove and recover operation
+                                        // extract all property paths of the relations we need to load relation ids for
+                                        // this is for optimization purpose - this way we don't load relation ids for entities
+                                        // whose relations are undefined, and since they are undefined its really pointless to
+                                        // load something for them, since undefined properties are skipped by the orm
+                                        if (operationType === "save" || operationType === "soft-remove" || operationType === "recover") {
+                                            subjectGroup.subjects.forEach(function (subject) {
+                                                // gets all relation property paths that exist in the persisted entity.
+                                                subject.metadata.relations.forEach(function (relation) {
+                                                    var value = relation.getEntityValue(subject.entityWithFulfilledIds);
+                                                    if (value === undefined)
+                                                        return;
+                                                    if (loadRelationPropertyPaths.indexOf(relation.propertyPath) === -1)
+                                                        loadRelationPropertyPaths.push(relation.propertyPath);
+                                                });
+                                            });
+                                        }
+                                        else { // remove
+                                            // for remove operation
+                                            // we only need to load junction relation ids since only they are removed by cascades
+                                            loadRelationPropertyPaths.push.apply(// remove
+                                            loadRelationPropertyPaths, tslib_1.__spreadArray([], tslib_1.__read(subjectGroup.subjects[0].metadata.manyToManyRelations.map(function (relation) { return relation.propertyPath; }))));
+                                        }
+                                        findOptions = {
+                                            loadEagerRelations: false,
+                                            loadRelationIds: {
+                                                relations: loadRelationPropertyPaths,
+                                                disableMixedMap: true
+                                            },
+                                            // the soft-deleted entities should be included in the loaded entities for recover operation
+                                            withDeleted: true
+                                        };
+                                        return [4 /*yield*/, this.queryRunner.manager
+                                                .getRepository(subjectGroup.target)
+                                                .findByIds(allIds, findOptions)];
+                                    case 1:
+                                        entities = _b.sent();
+                                        // now when we have entities we need to find subject of each entity
+                                        // and insert that entity into database entity of the found subjects
+                                        entities.forEach(function (entity) {
+                                            var subjects = _this.findByPersistEntityLike(subjectGroup.target, entity);
+                                            subjects.forEach(function (subject) {
+                                                subject.databaseEntity = entity;
+                                                if (!subject.identifier)
+                                                    subject.identifier = subject.metadata.hasAllPrimaryKeys(entity) ? subject.metadata.getEntityIdMap(entity) : undefined;
+                                            });
+                                        });
+                                        try {
+                                            // this way we tell what subjects we tried to load database entities of
+                                            for (allSubjects_1 = tslib_1.__values(allSubjects), allSubjects_1_1 = allSubjects_1.next(); !allSubjects_1_1.done; allSubjects_1_1 = allSubjects_1.next()) {
+                                                subject = allSubjects_1_1.value;
+                                                subject.databaseEntityLoaded = true;
+                                            }
+                                        }
+                                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                                        finally {
+                                            try {
+                                                if (allSubjects_1_1 && !allSubjects_1_1.done && (_a = allSubjects_1.return)) _a.call(allSubjects_1);
+                                            }
+                                            finally { if (e_1) throw e_1.error; }
+                                        }
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        return [4 /*yield*/, Promise.all(promises)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // ---------------------------------------------------------------------
+    // Protected Methods
+    // ---------------------------------------------------------------------
+    /**
+     * Finds subjects where entity like given subject's entity.
+     * Comparision made by entity id.
+     * Multiple subjects may be returned if duplicates are present in the subject array.
+     * This will likely result in the same row being updated multiple times during a transaction.
+     */
+    SubjectDatabaseEntityLoader.prototype.findByPersistEntityLike = function (entityTarget, entity) {
+        return this.subjects.filter(function (subject) {
+            if (!subject.entity)
+                return false;
+            if (subject.entity === entity)
+                return true;
+            return subject.metadata.target === entityTarget && subject.metadata.compareEntities(subject.entityWithFulfilledIds, entity);
+        });
+    };
+    /**
+     * Groups given Subject objects into groups separated by entity targets.
+     */
+    SubjectDatabaseEntityLoader.prototype.groupByEntityTargets = function () {
+        return this.subjects.reduce(function (groups, operatedEntity) {
+            var group = groups.find(function (group) { return group.target === operatedEntity.metadata.target; });
+            if (!group) {
+                group = { target: operatedEntity.metadata.target, subjects: [] };
+                groups.push(group);
+            }
+            group.subjects.push(operatedEntity);
+            return groups;
+        }, []);
+    };
+    return SubjectDatabaseEntityLoader;
+}());
+exports.SubjectDatabaseEntityLoader = SubjectDatabaseEntityLoader;
+
+//# sourceMappingURL=SubjectDatabaseEntityLoader.js.map

package/persistence/SubjectDatabaseEntityLoader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/persistence/SubjectDatabaseEntityLoader.ts"],"names":[],"mappings":"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","file":"SubjectDatabaseEntityLoader.js","sourcesContent":["import {Subject} from \"./Subject\";\nimport {ObjectLiteral} from \"../common/ObjectLiteral\";\nimport {QueryRunner} from \"../query-runner/QueryRunner\";\nimport {FindManyOptions} from \"../find-options/FindManyOptions\";\n\n/**\n * Loads database entities for all operate subjects which do not have database entity set.\n * All entities that we load database entities for are marked as updated or inserted.\n * To understand which of them really needs to be inserted or updated we need to load\n * their original representations from the database.\n */\nexport class SubjectDatabaseEntityLoader {\n\n    // ---------------------------------------------------------------------\n    // Constructor\n    // ---------------------------------------------------------------------\n\n    constructor(protected queryRunner: QueryRunner,\n                protected subjects: Subject[]) {\n    }\n\n    // ---------------------------------------------------------------------\n    // Public Methods\n    // ---------------------------------------------------------------------\n\n    /**\n     * Loads database entities for all subjects.\n     *\n     * loadAllRelations flag is used to load all relation ids of the object, no matter if they present in subject entity or not.\n     * This option is used for deletion.\n     */\n    async load(operationType: \"save\"|\"remove\"|\"soft-remove\"|\"recover\"): Promise<void> {\n\n        // we are grouping subjects by target to perform more optimized queries using WHERE IN operator\n        // go through the groups and perform loading of database entities of each subject in the group\n        const promises = this.groupByEntityTargets().map(async subjectGroup => {\n\n            // prepare entity ids of the subjects we need to load\n            const allIds: ObjectLiteral[] = [];\n            const allSubjects: Subject[] = [];\n            subjectGroup.subjects.forEach(subject => {\n\n                // we don't load if subject already has a database entity loaded\n                if (subject.databaseEntity || !subject.identifier)\n                    return;\n\n                allIds.push(subject.identifier);\n                allSubjects.push(subject);\n            });\n\n            // if there no ids found (means all entities are new and have generated ids) - then nothing to load there\n            if (!allIds.length)\n                return;\n\n            const loadRelationPropertyPaths: string[] = [];\n\n            // for the save, soft-remove and recover operation\n            // extract all property paths of the relations we need to load relation ids for\n            // this is for optimization purpose - this way we don't load relation ids for entities\n            // whose relations are undefined, and since they are undefined its really pointless to\n            // load something for them, since undefined properties are skipped by the orm\n            if (operationType === \"save\" || operationType === \"soft-remove\" || operationType === \"recover\") {\n                subjectGroup.subjects.forEach(subject => {\n\n                    // gets all relation property paths that exist in the persisted entity.\n                    subject.metadata.relations.forEach(relation => {\n                        const value = relation.getEntityValue(subject.entityWithFulfilledIds!);\n                        if (value === undefined)\n                            return;\n\n                        if (loadRelationPropertyPaths.indexOf(relation.propertyPath) === -1)\n                            loadRelationPropertyPaths.push(relation.propertyPath);\n                    });\n                });\n            } else { // remove\n\n                // for remove operation\n                // we only need to load junction relation ids since only they are removed by cascades\n                loadRelationPropertyPaths.push(...subjectGroup.subjects[0].metadata.manyToManyRelations.map(relation => relation.propertyPath));\n            }\n\n            const findOptions: FindManyOptions<any> = {\n                loadEagerRelations: false,\n                loadRelationIds: {\n                    relations: loadRelationPropertyPaths,\n                    disableMixedMap: true\n                },\n                // the soft-deleted entities should be included in the loaded entities for recover operation\n                withDeleted: true\n            };\n\n            // load database entities for all given ids\n            const entities = await this.queryRunner.manager\n                .getRepository<ObjectLiteral>(subjectGroup.target)\n                .findByIds(allIds, findOptions);\n\n            // now when we have entities we need to find subject of each entity\n            // and insert that entity into database entity of the found subjects\n            entities.forEach(entity => {\n                const subjects = this.findByPersistEntityLike(subjectGroup.target, entity);\n                subjects.forEach(subject => {\n                  subject.databaseEntity = entity;\n                  if (!subject.identifier)\n                      subject.identifier = subject.metadata.hasAllPrimaryKeys(entity) ? subject.metadata.getEntityIdMap(entity) : undefined;\n                });\n            });\n\n            // this way we tell what subjects we tried to load database entities of\n            for (let subject of allSubjects) {\n                subject.databaseEntityLoaded = true;\n            }\n        });\n\n        await Promise.all(promises);\n    }\n\n    // ---------------------------------------------------------------------\n    // Protected Methods\n    // ---------------------------------------------------------------------\n\n    /**\n     * Finds subjects where entity like given subject's entity.\n     * Comparision made by entity id.\n     * Multiple subjects may be returned if duplicates are present in the subject array.\n     * This will likely result in the same row being updated multiple times during a transaction.\n     */\n    protected findByPersistEntityLike(entityTarget: Function|string, entity: ObjectLiteral): Subject[] {\n        return this.subjects.filter(subject => {\n            if (!subject.entity)\n                return false;\n\n            if (subject.entity === entity)\n                return true;\n\n            return subject.metadata.target === entityTarget && subject.metadata.compareEntities(subject.entityWithFulfilledIds!, entity);\n        });\n    }\n\n    /**\n     * Groups given Subject objects into groups separated by entity targets.\n     */\n    protected groupByEntityTargets(): { target: Function|string, subjects: Subject[] }[] {\n        return this.subjects.reduce((groups, operatedEntity) => {\n            let group = groups.find(group => group.target === operatedEntity.metadata.target);\n            if (!group) {\n                group = { target: operatedEntity.metadata.target, subjects: [] };\n                groups.push(group);\n            }\n            group.subjects.push(operatedEntity);\n            return groups;\n        }, [] as { target: Function|string, subjects: Subject[] }[]);\n    }\n\n}\n"],"sourceRoot":".."}