taon-typeorm 21.0.13 → 21.0.18

package/lib-prod/typeorm/persistence/SubjectChangedColumnsComputer.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubjectChangedColumnsComputer = void 0;
+const DateUtils_1 = require("../util/DateUtils");
+const OrmUtils_1 = require("../util/OrmUtils");
+const ApplyValueTransformers_1 = require("../util/ApplyValueTransformers");
+const ObjectUtils_1 = require("../util/ObjectUtils");
+/**
+ * Finds what columns are changed in the subject entities.
+ */
+class SubjectChangedColumnsComputer {
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Finds what columns are changed in the subject entities.
+     */
+    compute(subjects) {
+        subjects.forEach((subject) => {
+            this.computeDiffColumns(subject);
+            this.computeDiffRelationalColumns(subjects, subject);
+        });
+    }
+    // -------------------------------------------------------------------------
+    // Protected Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Differentiate columns from the updated entity and entity stored in the database.
+     */
+    computeDiffColumns(subject) {
+        // if there is no persisted entity then nothing to compute changed in it
+        if (!subject.entity)
+            return;
+        subject.metadata.columns.forEach((column) => {
+            // ignore special columns
+            if (column.isVirtual ||
+                column.isDiscriminator // ||
+            // column.isUpdateDate ||
+            // column.isVersion ||
+            // column.isCreateDate
+            )
+                return;
+            const changeMap = subject.changeMaps.find((changeMap) => 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
+            const 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
+                const shouldTransformDatabaseEntity = column.type !== "json" && column.type !== "jsonb";
+                // get database value of the column
+                let 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) {
+                    const value = column.relationMetadata.getEntityValue(subject.entity);
+                    if (value !== null && value !== undefined)
+                        return;
+                }
+                let 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 (
+                //#region @backend
+                Buffer.isBuffer(normalizedValue) &&
+                    Buffer.isBuffer(databaseValue)
+                //#endregion
+                /* */
+                /* */
+                /* */
+                /* */
+                /* */
+                ) {
+                    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.
+     */
+    computeDiffRelationalColumns(allSubjects, subject) {
+        // if there is no persisted entity then nothing to compute changed in it
+        if (!subject.entity)
+            return;
+        subject.metadata.relationsWithJoinColumns.forEach((relation) => {
+            // get the related entity from the persisted entity
+            let 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
+                let relatedEntityRelationIdMap = relatedEntity;
+                if (relatedEntityRelationIdMap !== null &&
+                    ObjectUtils_1.ObjectUtils.isObject(relatedEntityRelationIdMap))
+                    relatedEntityRelationIdMap = relation.getRelationIdMap(relatedEntityRelationIdMap);
+                // get database related entity. Since loadRelationIds are used on databaseEntity
+                // related entity will contain only its relation ids
+                const databaseRelatedEntityRelationIdMap = relation.getEntityValue(subject.databaseEntity);
+                // if relation ids are equal then we don't need to update anything
+                const 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)
+            const valueSubject = allSubjects.find((subject) => subject.mustBeInserted && subject.entity === relatedEntity);
+            if (valueSubject)
+                relatedEntity = valueSubject;
+            // find if there is already a relation to be changed
+            const changeMap = subject.changeMaps.find((changeMap) => 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,
+                });
+            }
+        });
+    }
+}
+exports.SubjectChangedColumnsComputer = SubjectChangedColumnsComputer;
+//# sourceMappingURL=SubjectChangedColumnsComputer.js.map

package/lib-prod/typeorm/persistence/SubjectChangedColumnsComputer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SubjectChangedColumnsComputer.js","sourceRoot":"","sources":[""],"names":[],"mappings":"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"}

package/lib-prod/typeorm/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.
+     * Comparison 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/lib-prod/typeorm/persistence/SubjectDatabaseEntityLoader.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubjectDatabaseEntityLoader = void 0;
+//#endregion
+/**
+ * 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.
+ */
+class SubjectDatabaseEntityLoader {
+    queryRunner;
+    subjects;
+    // ---------------------------------------------------------------------
+    // Constructor
+    // ---------------------------------------------------------------------
+    constructor(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.
+     */
+    async load(operationType) {
+        // we are grouping subjects by target to perform more optimized queries using WHERE IN operator
+        // go through the groups and perform loading of database entities of each subject in the group
+        const promises = this.groupByEntityTargets().map(async (subjectGroup) => {
+            // prepare entity ids of the subjects we need to load
+            const allIds = [];
+            const allSubjects = [];
+            subjectGroup.subjects.forEach((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;
+            const 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((subject) => {
+                    // gets all relation property paths that exist in the persisted entity.
+                    subject.metadata.relations.forEach((relation) => {
+                        const 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(...subjectGroup.subjects[0].metadata.manyToManyRelations.map((relation) => relation.propertyPath));
+            }
+            const findOptions = {
+                loadEagerRelations: false,
+                loadRelationIds: {
+                    relations: loadRelationPropertyPaths,
+                    disableMixedMap: true,
+                },
+                // the soft-deleted entities should be included in the loaded entities for recover operation
+                withDeleted: true,
+            };
+            // load database entities for all given ids
+            let entities = [];
+            if (this.queryRunner.connection.driver.options.type ===
+                "mongodb") {
+                //#region @backend
+                const mongoRepo = this.queryRunner.manager.getRepository(subjectGroup.target);
+                entities = await mongoRepo.findByIds(allIds, findOptions);
+                //#endregion
+            }
+            else {
+                entities = await this.queryRunner.manager
+                    .getRepository(subjectGroup.target)
+                    .createQueryBuilder()
+                    .setFindOptions(findOptions)
+                    .whereInIds(allIds)
+                    .getMany();
+            }
+            // 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((entity) => {
+                const subjects = this.findByPersistEntityLike(subjectGroup.target, entity);
+                subjects.forEach((subject) => {
+                    subject.databaseEntity = entity;
+                    if (!subject.identifier)
+                        subject.identifier =
+                            subject.metadata.hasAllPrimaryKeys(entity)
+                                ? subject.metadata.getEntityIdMap(entity)
+                                : undefined;
+                });
+            });
+            // this way we tell what subjects we tried to load database entities of
+            for (let subject of allSubjects) {
+                subject.databaseEntityLoaded = true;
+            }
+        });
+        await Promise.all(promises);
+    }
+    // ---------------------------------------------------------------------
+    // Protected Methods
+    // ---------------------------------------------------------------------
+    /**
+     * Finds subjects where entity like given subject's entity.
+     * Comparison 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.
+     */
+    findByPersistEntityLike(entityTarget, entity) {
+        return this.subjects.filter((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.
+     */
+    groupByEntityTargets() {
+        return this.subjects.reduce((groups, operatedEntity) => {
+            let group = groups.find((group) => group.target === operatedEntity.metadata.target);
+            if (!group) {
+                group = { target: operatedEntity.metadata.target, subjects: [] };
+                groups.push(group);
+            }
+            group.subjects.push(operatedEntity);
+            return groups;
+        }, []);
+    }
+}
+exports.SubjectDatabaseEntityLoader = SubjectDatabaseEntityLoader;
+//# sourceMappingURL=SubjectDatabaseEntityLoader.js.map

package/lib-prod/typeorm/persistence/SubjectDatabaseEntityLoader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SubjectDatabaseEntityLoader.js","sourceRoot":"","sources":[""],"names":[],"mappings":"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"}

package/lib-prod/typeorm/persistence/SubjectExecutor.d.ts

@@ -0,0 +1,118 @@
+import { QueryRunner } from "../query-runner/QueryRunner";
+import { Subject } from "./Subject";
+import { SaveOptions } from "../repository/SaveOptions";
+import { RemoveOptions } from "../repository/RemoveOptions";
+import { BroadcasterResult } from "../subscriber/BroadcasterResult";
+/**
+ * Executes all database operations (inserts, updated, deletes) that must be executed
+ * with given persistence subjects.
+ */
+export declare class SubjectExecutor {
+    /**
+     * Indicates if executor has any operations to execute (e.g. has insert / update / delete operations to be executed).
+     */
+    hasExecutableOperations: boolean;
+    /**
+     * QueryRunner used to execute all queries with a given subjects.
+     */
+    protected queryRunner: QueryRunner;
+    /**
+     * Persistence options.
+     */
+    protected options?: SaveOptions & RemoveOptions;
+    /**
+     * All subjects that needs to be operated.
+     */
+    protected allSubjects: Subject[];
+    /**
+     * Subjects that must be inserted.
+     */
+    protected insertSubjects: Subject[];
+    /**
+     * Subjects that must be updated.
+     */
+    protected updateSubjects: Subject[];
+    /**
+     * Subjects that must be removed.
+     */
+    protected removeSubjects: Subject[];
+    /**
+     * Subjects that must be soft-removed.
+     */
+    protected softRemoveSubjects: Subject[];
+    /**
+     * Subjects that must be recovered.
+     */
+    protected recoverSubjects: Subject[];
+    constructor(queryRunner: QueryRunner, subjects: Subject[], options?: SaveOptions & RemoveOptions);
+    /**
+     * Executes all operations over given array of subjects.
+     * Executes queries using given query runner.
+     */
+    execute(): Promise<void>;
+    /**
+     * Validates all given subjects.
+     */
+    protected validate(): void;
+    /**
+     * Performs entity re-computations - finds changed columns, re-builds insert/update/remove subjects.
+     */
+    protected recompute(): void;
+    /**
+     * Broadcasts "BEFORE_INSERT", "BEFORE_UPDATE", "BEFORE_REMOVE", "BEFORE_SOFT_REMOVE", "BEFORE_RECOVER" events for all given subjects.
+     */
+    protected broadcastBeforeEventsForAll(): BroadcasterResult;
+    /**
+     * Broadcasts "AFTER_INSERT", "AFTER_UPDATE", "AFTER_REMOVE", "AFTER_SOFT_REMOVE", "AFTER_RECOVER" events for all given subjects.
+     * Returns void if there wasn't any listener or subscriber executed.
+     * Note: this method has a performance-optimized code organization.
+     */
+    protected broadcastAfterEventsForAll(): BroadcasterResult;
+    /**
+     * Executes insert operations.
+     */
+    protected executeInsertOperations(): Promise<void>;
+    /**
+     * Updates all given subjects in the database.
+     */
+    protected executeUpdateOperations(): Promise<void>;
+    /**
+     * Removes all given subjects from the database.
+     *
+     * todo: we need to apply topological sort here as well
+     */
+    protected executeRemoveOperations(): Promise<void>;
+    private cloneMongoSubjectEntity;
+    /**
+     * Soft-removes all given subjects in the database.
+     */
+    protected executeSoftRemoveOperations(): Promise<void>;
+    /**
+     * Recovers all given subjects in the database.
+     */
+    protected executeRecoverOperations(): Promise<void>;
+    /**
+     * Updates all special columns of the saving entities (create date, update date, version, etc.).
+     * Also updates nullable columns and columns with default values.
+     */
+    protected updateSpecialColumnsInPersistedEntities(): void;
+    /**
+     * Updates all special columns of the saving entities (create date, update date, version, etc.).
+     * Also updates nullable columns and columns with default values.
+     */
+    protected updateSpecialColumnsInInsertedAndUpdatedEntities(subjects: Subject[]): void;
+    /**
+     * Groups subjects by metadata names (by tables) to make bulk insertions and deletions possible.
+     * However there are some limitations with bulk insertions of data into tables with generated (increment) columns
+     * in some drivers. Some drivers like mysql and sqlite does not support returning multiple generated columns
+     * after insertion and can only return a single generated column value, that's why its not possible to do bulk insertion,
+     * because it breaks insertion result's generatedMap and leads to problems when this subject is used in other subjects saves.
+     * That's why we only support bulking in junction tables for those drivers.
+     *
+     * Other drivers like postgres and sql server support RETURNING / OUTPUT statement which allows to return generated
+     * id for each inserted row, that's why bulk insertion is not limited to junction tables in there.
+     */
+    protected groupBulkSubjects(subjects: Subject[], type: "insert" | "delete"): [{
+        [key: string]: Subject[];
+    }, string[]];
+}