@lakutata/orm 3.0.0 → 3.1.1

package/dist/vendor/typeorm/persistence/SubjectChangeMap.d.ts

@@ -0,0 +1,23 @@
+import type { ColumnMetadata } from "../metadata/ColumnMetadata";
+import type { RelationMetadata } from "../metadata/RelationMetadata";
+import type { 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/dist/vendor/typeorm/persistence/SubjectChangeMap.js

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

package/dist/vendor/typeorm/persistence/SubjectChangeMap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SubjectChangeMap.js","sourceRoot":"","sources":["../../../../vendor/typeorm/persistence/SubjectChangeMap.ts"],"names":[],"mappings":"","sourcesContent":["import type { ColumnMetadata } from \"../metadata/ColumnMetadata\"\nimport type { RelationMetadata } from \"../metadata/RelationMetadata\"\nimport type { Subject } from \"./Subject\"\n\n/**\n * Change for insertion or updation of the column of the subject.\n */\nexport interface SubjectChangeMap {\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"]}

package/dist/vendor/typeorm/persistence/SubjectChangedColumnsComputer.d.ts

@@ -0,0 +1,25 @@
+import type { 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.
+     *
+     * @param subjects List of subjects for which to compute changed columns.
+     */
+    compute(subjects: Subject[]): void;
+    /**
+     * Differentiate columns from the updated entity and entity stored in the database.
+     *
+     * @param subject Subject for which to compute differentiated columns.
+     */
+    protected computeDiffColumns(subject: Subject): void;
+    /**
+     * Difference columns of the owning one-to-one and many-to-one columns.
+     *
+     * @param allSubjects List of all subjects in the current operation.
+     * @param subject Subject for which to compute differentiated relational columns.
+     */
+    protected computeDiffRelationalColumns(allSubjects: Subject[], subject: Subject): void;
+}

package/dist/vendor/typeorm/persistence/SubjectChangedColumnsComputer.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubjectChangedColumnsComputer = void 0;
+const ApplyValueTransformers_1 = require("../util/ApplyValueTransformers");
+const DateUtils_1 = require("../util/DateUtils");
+const ObjectUtils_1 = require("../util/ObjectUtils");
+const OrmUtils_1 = require("../util/OrmUtils");
+const Uint8ArrayUtils_1 = require("../util/Uint8ArrayUtils");
+/**
+ * Finds what columns are changed in the subject entities.
+ */
+class SubjectChangedColumnsComputer {
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Finds what columns are changed in the subject entities.
+     *
+     * @param subjects List of subjects for which to compute changed columns.
+     */
+    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.
+     *
+     * @param subject Subject for which to compute differentiated columns.
+     */
+    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);
+                // Defer to computeDiffRelationalColumns only for auto-created
+                // join columns (propertyName matches the owning relation).
+                // User-defined columns that double as join columns must stay
+                // in the diff so their explicit entity value is never lost.
+                if (column.propertyName ===
+                    column.relationMetadata?.propertyName) {
+                    const value = column.relationMetadata.getEntityValue(subject.entity);
+                    if (value !== null && value !== undefined)
+                        return;
+                }
+                let normalizedValue = entityValue;
+                if (column.transformer &&
+                    shouldTransformDatabaseEntity &&
+                    entityValue !== null) {
+                    normalizedValue = ApplyValueTransformers_1.ApplyValueTransformers.transformTo(column.transformer, entityValue);
+                }
+                // if both values are not null, normalize special values to make proper comparision
+                if (normalizedValue !== null && databaseValue !== null) {
+                    switch (column.type) {
+                        case "date":
+                            normalizedValue = column.isArray
+                                ? normalizedValue.map((date) => DateUtils_1.DateUtils.mixedDateToDateString(date))
+                                : DateUtils_1.DateUtils.mixedDateToDateString(normalizedValue);
+                            databaseValue = column.isArray
+                                ? databaseValue.map((date) => DateUtils_1.DateUtils.mixedDateToDateString(date))
+                                : DateUtils_1.DateUtils.mixedDateToDateString(databaseValue);
+                            break;
+                        case "time":
+                        case "time with time zone":
+                        case "time without time zone":
+                        case "timetz":
+                            normalizedValue = column.isArray
+                                ? normalizedValue.map((date) => DateUtils_1.DateUtils.mixedDateToTimeString(date))
+                                : DateUtils_1.DateUtils.mixedDateToTimeString(normalizedValue);
+                            databaseValue = column.isArray
+                                ? databaseValue.map((date) => DateUtils_1.DateUtils.mixedDateToTimeString(date))
+                                : DateUtils_1.DateUtils.mixedDateToTimeString(databaseValue);
+                            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 = column.isArray
+                                ? normalizedValue.map((date) => DateUtils_1.DateUtils.mixedDateToUtcDatetimeString(date))
+                                : DateUtils_1.DateUtils.mixedDateToUtcDatetimeString(normalizedValue);
+                            databaseValue = column.isArray
+                                ? databaseValue.map((date) => DateUtils_1.DateUtils.mixedDateToUtcDatetimeString(date))
+                                : 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(normalizedValue, databaseValue))
+                                return;
+                            break;
+                        case "simple-array":
+                            normalizedValue =
+                                DateUtils_1.DateUtils.simpleArrayToString(normalizedValue);
+                            databaseValue =
+                                DateUtils_1.DateUtils.simpleArrayToString(databaseValue);
+                            break;
+                        case "simple-enum":
+                            normalizedValue =
+                                DateUtils_1.DateUtils.simpleEnumToString(normalizedValue);
+                            databaseValue =
+                                DateUtils_1.DateUtils.simpleEnumToString(databaseValue);
+                            break;
+                        case "simple-json":
+                            normalizedValue =
+                                DateUtils_1.DateUtils.simpleJsonToString(normalizedValue);
+                            databaseValue =
+                                DateUtils_1.DateUtils.simpleJsonToString(databaseValue);
+                            break;
+                    }
+                }
+                // if value is not changed - then do nothing
+                if (column.isArray) {
+                    if (OrmUtils_1.OrmUtils.deepCompare(normalizedValue, databaseValue))
+                        return;
+                }
+                else if ((0, Uint8ArrayUtils_1.isUint8Array)(normalizedValue) &&
+                    (0, Uint8ArrayUtils_1.isUint8Array)(databaseValue)) {
+                    if ((0, Uint8ArrayUtils_1.areUint8ArraysEqual)(normalizedValue, databaseValue)) {
+                        return;
+                    }
+                }
+                else {
+                    if (normalizedValue === databaseValue)
+                        return;
+                }
+            }
+            if (!subject.diffColumns.includes(column))
+                subject.diffColumns.push(column);
+            subject.changeMaps.push({
+                column: column,
+                value: entityValue,
+            });
+        });
+    }
+    /**
+     * Difference columns of the owning one-to-one and many-to-one columns.
+     *
+     * @param allSubjects List of all subjects in the current operation.
+     * @param subject Subject for which to compute differentiated relational 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) => {
+            if (relation.persistenceEnabled === false)
+                return;
+            // 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/dist/vendor/typeorm/persistence/SubjectChangedColumnsComputer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SubjectChangedColumnsComputer.js","sourceRoot":"","sources":["../../../../vendor/typeorm/persistence/SubjectChangedColumnsComputer.ts"],"names":[],"mappings":"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","sourcesContent":["import type { ObjectLiteral } from \"../common/ObjectLiteral\"\nimport { ApplyValueTransformers } from \"../util/ApplyValueTransformers\"\nimport { DateUtils } from \"../util/DateUtils\"\nimport { ObjectUtils } from \"../util/ObjectUtils\"\nimport { OrmUtils } from \"../util/OrmUtils\"\nimport type { Subject } from \"./Subject\"\nimport { areUint8ArraysEqual, isUint8Array } from \"../util/Uint8ArrayUtils\"\n\n/**\n * Finds what columns are changed in the subject entities.\n */\nexport class SubjectChangedColumnsComputer {\n    // -------------------------------------------------------------------------\n    // Public Methods\n    // -------------------------------------------------------------------------\n\n    /**\n     * Finds what columns are changed in the subject entities.\n     *\n     * @param subjects List of subjects for which to compute changed columns.\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     * @param subject Subject for which to compute differentiated columns.\n     */\n    protected computeDiffColumns(subject: Subject): void {\n        // if there is no persisted entity then nothing to compute changed in it\n        if (!subject.entity) return\n\n        subject.metadata.columns.forEach((column) => {\n            // ignore special columns\n            if (\n                column.isVirtual ||\n                column.isDiscriminator // ||\n                // column.isUpdateDate ||\n                // column.isVersion ||\n                // column.isCreateDate\n            )\n                return\n\n            const changeMap = subject.changeMaps.find(\n                (changeMap) => changeMap.column === column,\n            )\n            if (changeMap) {\n                subject.changeMaps.splice(\n                    subject.changeMaps.indexOf(changeMap),\n                    1,\n                )\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) 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 =\n                    column.type !== \"json\" && column.type !== \"jsonb\"\n\n                // get database value of the column\n                let databaseValue = column.getEntityValue(\n                    subject.databaseEntity,\n                    shouldTransformDatabaseEntity,\n                )\n\n                // Defer to computeDiffRelationalColumns only for auto-created\n                // join columns (propertyName matches the owning relation).\n                // User-defined columns that double as join columns must stay\n                // in the diff so their explicit entity value is never lost.\n                if (\n                    column.propertyName ===\n                    column.relationMetadata?.propertyName\n                ) {\n                    const value = column.relationMetadata.getEntityValue(\n                        subject.entity!,\n                    )\n                    if (value !== null && value !== undefined) return\n                }\n                let normalizedValue = entityValue\n\n                if (\n                    column.transformer &&\n                    shouldTransformDatabaseEntity &&\n                    entityValue !== null\n                ) {\n                    normalizedValue = ApplyValueTransformers.transformTo(\n                        column.transformer,\n                        entityValue,\n                    )\n                }\n\n                // if both values are not null, normalize special values to make proper comparision\n                if (normalizedValue !== null && databaseValue !== null) {\n                    switch (column.type) {\n                        case \"date\":\n                            normalizedValue = column.isArray\n                                ? normalizedValue.map((date: Date) =>\n                                      DateUtils.mixedDateToDateString(date),\n                                  )\n                                : DateUtils.mixedDateToDateString(\n                                      normalizedValue,\n                                  )\n                            databaseValue = column.isArray\n                                ? databaseValue.map((date: Date) =>\n                                      DateUtils.mixedDateToDateString(date),\n                                  )\n                                : DateUtils.mixedDateToDateString(databaseValue)\n                            break\n\n                        case \"time\":\n                        case \"time with time zone\":\n                        case \"time without time zone\":\n                        case \"timetz\":\n                            normalizedValue = column.isArray\n                                ? normalizedValue.map((date: Date) =>\n                                      DateUtils.mixedDateToTimeString(date),\n                                  )\n                                : DateUtils.mixedDateToTimeString(\n                                      normalizedValue,\n                                  )\n                            databaseValue = column.isArray\n                                ? databaseValue.map((date: Date) =>\n                                      DateUtils.mixedDateToTimeString(date),\n                                  )\n                                : DateUtils.mixedDateToTimeString(databaseValue)\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 = column.isArray\n                                ? normalizedValue.map((date: Date) =>\n                                      DateUtils.mixedDateToUtcDatetimeString(\n                                          date,\n                                      ),\n                                  )\n                                : DateUtils.mixedDateToUtcDatetimeString(\n                                      normalizedValue,\n                                  )\n\n                            databaseValue = column.isArray\n                                ? databaseValue.map((date: Date) =>\n                                      DateUtils.mixedDateToUtcDatetimeString(\n                                          date,\n                                      ),\n                                  )\n                                : DateUtils.mixedDateToUtcDatetimeString(\n                                      databaseValue,\n                                  )\n\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 (\n                                OrmUtils.deepCompare(\n                                    normalizedValue,\n                                    databaseValue,\n                                )\n                            )\n                                return\n                            break\n\n                        case \"simple-array\":\n                            normalizedValue =\n                                DateUtils.simpleArrayToString(normalizedValue)\n                            databaseValue =\n                                DateUtils.simpleArrayToString(databaseValue)\n                            break\n                        case \"simple-enum\":\n                            normalizedValue =\n                                DateUtils.simpleEnumToString(normalizedValue)\n                            databaseValue =\n                                DateUtils.simpleEnumToString(databaseValue)\n                            break\n                        case \"simple-json\":\n                            normalizedValue =\n                                DateUtils.simpleJsonToString(normalizedValue)\n                            databaseValue =\n                                DateUtils.simpleJsonToString(databaseValue)\n                            break\n                    }\n                }\n\n                // if value is not changed - then do nothing\n                if (column.isArray) {\n                    if (OrmUtils.deepCompare(normalizedValue, databaseValue))\n                        return\n                } else if (\n                    isUint8Array(normalizedValue) &&\n                    isUint8Array(databaseValue)\n                ) {\n                    if (areUint8ArraysEqual(normalizedValue, databaseValue)) {\n                        return\n                    }\n                } else {\n                    if (normalizedValue === databaseValue) return\n                }\n            }\n\n            if (!subject.diffColumns.includes(column))\n                subject.diffColumns.push(column)\n\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     * @param allSubjects List of all subjects in the current operation.\n     * @param subject Subject for which to compute differentiated relational columns.\n     */\n    protected computeDiffRelationalColumns(\n        allSubjects: Subject[],\n        subject: Subject,\n    ): void {\n        // if there is no persisted entity then nothing to compute changed in it\n        if (!subject.entity) return\n\n        subject.metadata.relationsWithJoinColumns.forEach((relation) => {\n            if (relation.persistenceEnabled === false) return\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) 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                // 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 (\n                    relatedEntityRelationIdMap !== null &&\n                    ObjectUtils.isObject(relatedEntityRelationIdMap)\n                )\n                    relatedEntityRelationIdMap = relation.getRelationIdMap(\n                        relatedEntityRelationIdMap,\n                    )!\n\n                // get database related entity. Since loadRelationIds are used on databaseEntity\n                // related entity will contain only its relation ids\n                const databaseRelatedEntityRelationIdMap =\n                    relation.getEntityValue(subject.databaseEntity)\n\n                // if relation ids are equal then we don't need to update anything\n                const areRelatedIdsEqual = OrmUtils.compareIds(\n                    relatedEntityRelationIdMap,\n                    databaseRelatedEntityRelationIdMap,\n                )\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(\n                (subject) =>\n                    subject.mustBeInserted && subject.entity === relatedEntity,\n            )\n            if (valueSubject) relatedEntity = valueSubject\n\n            // find if there is already a relation to be changed\n            const changeMap = subject.changeMaps.find(\n                (changeMap) => changeMap.relation === relation,\n            )\n            if (changeMap) {\n                // and update its value if it was found\n                changeMap.value = relatedEntity\n            } else {\n                // 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"]}

package/dist/vendor/typeorm/persistence/SubjectDatabaseEntityLoader.d.ts

@@ -0,0 +1,29 @@
+import type { Subject } from "./Subject";
+import type { 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.
+     *
+     * @param operationType
+     */
+    load(operationType: "save" | "remove" | "soft-remove" | "recover"): Promise<void>;
+    /**
+     * Groups given Subject objects into groups separated by entity targets.
+     */
+    protected groupByEntityTargets(): {
+        target: Function | string;
+        subjects: Subject[];
+    }[];
+}

package/dist/vendor/typeorm/persistence/SubjectDatabaseEntityLoader.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubjectDatabaseEntityLoader = void 0;
+const OrmUtils_1 = require("../util/OrmUtils");
+/**
+ * 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 {
+    // ---------------------------------------------------------------------
+    // 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.
+     *
+     * @param operationType
+     */
+    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 loadSubjectGroup = 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,
+                },
+                // include soft-deleted entities so save, soft-remove, recover,
+                // and remove can find them by PK and load their relation IDs
+                withDeleted: true,
+            };
+            // load database entities for all given ids
+            let entities;
+            if ((this.queryRunner.dataSource.driver.options.type === "mongodb" || this.queryRunner.dataSource.driver.options.type === "mongo-embedded")) { // lakutata: mongo-embedded, a MongoDB driver
+                const mongoRepo = this.queryRunner.manager.getRepository(subjectGroup.target);
+                entities = await mongoRepo.findByIds(allIds, findOptions);
+            }
+            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.
+            // A single entity can be applied to many subjects as there might be duplicates.
+            // This will likely result in the same row being updated multiple times during a transaction.
+            entities.forEach((entity) => {
+                const entityId = allSubjects[0].metadata.getEntityIdMap(entity);
+                allSubjects.forEach((subject) => {
+                    if (subject.databaseEntity)
+                        return;
+                    if (OrmUtils_1.OrmUtils.compareIds(subject.identifier, entityId))
+                        subject.databaseEntity = entity;
+                });
+            });
+            // this way we tell what subjects we tried to load database entities of
+            for (const subject of allSubjects) {
+                subject.databaseEntityLoaded = true;
+            }
+        };
+        const subjectGroups = this.groupByEntityTargets();
+        // Avoid concurrent queries on the same pg client; see #12238.
+        // CockroachDB uses the pg package over a single connection too.
+        const driverType = this.queryRunner.dataSource.options.type;
+        if (driverType === "postgres" || driverType === "cockroachdb") {
+            for (const subjectGroup of subjectGroups) {
+                await loadSubjectGroup(subjectGroup);
+            }
+        }
+        else {
+            await Promise.all(subjectGroups.map(loadSubjectGroup));
+        }
+    }
+    // ---------------------------------------------------------------------
+    // Protected Methods
+    // ---------------------------------------------------------------------
+    /**
+     * 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/dist/vendor/typeorm/persistence/SubjectDatabaseEntityLoader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SubjectDatabaseEntityLoader.js","sourceRoot":"","sources":["../../../../vendor/typeorm/persistence/SubjectDatabaseEntityLoader.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Subject } from \"./Subject\"\nimport type { ObjectLiteral } from \"../common/ObjectLiteral\"\nimport type { QueryRunner } from \"../query-runner/QueryRunner\"\nimport type { FindManyOptions } from \"../find-options/FindManyOptions\"\nimport type { MongoRepository } from \"../repository/MongoRepository\"\nimport { OrmUtils } from \"../util/OrmUtils\"\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    // Constructor\n    // ---------------------------------------------------------------------\n\n    constructor(\n        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     * @param operationType\n     */\n    async load(\n        operationType: \"save\" | \"remove\" | \"soft-remove\" | \"recover\",\n    ): Promise<void> {\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 loadSubjectGroup = async (subjectGroup: {\n            target: Function | string\n            subjects: Subject[]\n        }): Promise<void> => {\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                // we don't load if subject already has a database entity loaded\n                if (subject.databaseEntity || !subject.identifier) 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) 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 (\n                operationType === \"save\" ||\n                operationType === \"soft-remove\" ||\n                operationType === \"recover\"\n            ) {\n                subjectGroup.subjects.forEach((subject) => {\n                    // gets all relation property paths that exist in the persisted entity.\n                    subject.metadata.relations.forEach((relation) => {\n                        const value = relation.getEntityValue(\n                            subject.entityWithFulfilledIds!,\n                        )\n                        if (value === undefined) return\n\n                        if (\n                            loadRelationPropertyPaths.indexOf(\n                                relation.propertyPath,\n                            ) === -1\n                        )\n                            loadRelationPropertyPaths.push(\n                                relation.propertyPath,\n                            )\n                    })\n                })\n            } else {\n                // 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(\n                    ...subjectGroup.subjects[0].metadata.manyToManyRelations.map(\n                        (relation) => relation.propertyPath,\n                    ),\n                )\n            }\n\n            const findOptions: FindManyOptions<any> = {\n                loadEagerRelations: false,\n                loadRelationIds: {\n                    relations: loadRelationPropertyPaths,\n                    disableMixedMap: true,\n                },\n                // include soft-deleted entities so save, soft-remove, recover,\n                // and remove can find them by PK and load their relation IDs\n                withDeleted: true,\n            }\n\n            // load database entities for all given ids\n            let entities: any[]\n            if ((this.queryRunner.dataSource.driver.options.type === \"mongodb\" || this.queryRunner.dataSource.driver.options.type === \"mongo-embedded\")) { // lakutata: mongo-embedded, a MongoDB driver\n                const mongoRepo =\n                    this.queryRunner.manager.getRepository<ObjectLiteral>(\n                        subjectGroup.target,\n                    ) as MongoRepository<ObjectLiteral>\n                entities = await mongoRepo.findByIds(allIds, findOptions)\n            } else {\n                entities = await this.queryRunner.manager\n                    .getRepository<ObjectLiteral>(subjectGroup.target)\n                    .createQueryBuilder()\n                    .setFindOptions(findOptions)\n                    .whereInIds(allIds)\n                    .getMany()\n            }\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            // A single entity can be applied to many subjects as there might be duplicates.\n            // This will likely result in the same row being updated multiple times during a transaction.\n            entities.forEach((entity) => {\n                const entityId = allSubjects[0].metadata.getEntityIdMap(entity)\n                allSubjects.forEach((subject) => {\n                    if (subject.databaseEntity) return\n                    if (OrmUtils.compareIds(subject.identifier, entityId))\n                        subject.databaseEntity = entity\n                })\n            })\n\n            // this way we tell what subjects we tried to load database entities of\n            for (const subject of allSubjects) {\n                subject.databaseEntityLoaded = true\n            }\n        }\n\n        const subjectGroups = this.groupByEntityTargets()\n\n        // Avoid concurrent queries on the same pg client; see #12238.\n        // CockroachDB uses the pg package over a single connection too.\n        const driverType = this.queryRunner.dataSource.options.type\n        if (driverType === \"postgres\" || driverType === \"cockroachdb\") {\n            for (const subjectGroup of subjectGroups) {\n                await loadSubjectGroup(subjectGroup)\n            }\n        } else {\n            await Promise.all(subjectGroups.map(loadSubjectGroup))\n        }\n    }\n\n    // ---------------------------------------------------------------------\n    // Protected Methods\n    // ---------------------------------------------------------------------\n\n    /**\n     * Groups given Subject objects into groups separated by entity targets.\n     */\n    protected groupByEntityTargets(): {\n        target: Function | string\n        subjects: Subject[]\n    }[] {\n        return this.subjects.reduce(\n            (groups, operatedEntity) => {\n                let group = groups.find(\n                    (group) => group.target === operatedEntity.metadata.target,\n                )\n                if (!group) {\n                    group = {\n                        target: operatedEntity.metadata.target,\n                        subjects: [],\n                    }\n                    groups.push(group)\n                }\n                group.subjects.push(operatedEntity)\n                return groups\n            },\n            [] as { target: Function | string; subjects: Subject[] }[],\n        )\n    }\n}\n"]}