@depup/typeorm 0.3.28-depup.0

package/query-builder/transformer/DocumentToEntityTransformer.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentToEntityTransformer = void 0;
+/**
+ * Transforms raw document into entity object.
+ * Entity is constructed based on its entity metadata.
+ */
+class DocumentToEntityTransformer {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    constructor(
+    // private selectionMap: AliasMap,
+    // private joinMappings: JoinMapping[],
+    // private relationCountMetas: RelationCountAttribute[],
+    enableRelationIdValues = false) {
+        this.enableRelationIdValues = enableRelationIdValues;
+    }
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    transformAll(documents, metadata) {
+        return documents.map((document) => this.transform(document, metadata));
+    }
+    transform(document, metadata) {
+        const entity = metadata.create(undefined, {
+            fromDeserializer: true,
+        });
+        let hasData = false;
+        // handle _id property the special way
+        if (metadata.objectIdColumn) {
+            // todo: we can't use driver in this class
+            // do we really need prepare hydrated value here? If no then no problem. If yes then think maybe prepareHydratedValue process should be extracted out of driver class?
+            // entity[metadata.ObjectIdColumn.propertyName] = this.driver.prepareHydratedValue(document[metadata.ObjectIdColumn.name"], metadata.ObjectIdColumn);
+            const { databaseNameWithoutPrefixes, propertyName } = metadata.objectIdColumn;
+            const documentIdWithoutPrefixes = document[databaseNameWithoutPrefixes];
+            const documentIdWithPropertyName = document[propertyName];
+            if (documentIdWithoutPrefixes) {
+                entity[propertyName] = documentIdWithoutPrefixes;
+                hasData = true;
+            }
+            else if (documentIdWithPropertyName) {
+                entity[propertyName] = documentIdWithPropertyName;
+                hasData = true;
+            }
+        }
+        // add special columns that contains relation ids
+        if (this.enableRelationIdValues) {
+            metadata.columns
+                .filter((column) => !!column.relationMetadata)
+                .forEach((column) => {
+                const valueInObject = document[column.databaseNameWithoutPrefixes];
+                if (valueInObject !== undefined &&
+                    valueInObject !== null &&
+                    column.propertyName) {
+                    // todo: we can't use driver in this class
+                    // const value = this.driver.prepareHydratedValue(valueInObject, column);
+                    entity[column.propertyName] = valueInObject;
+                    hasData = true;
+                }
+            });
+        }
+        /*this.joinMappings
+            .filter(joinMapping => joinMapping.parentName === alias.name && !joinMapping.alias.relationOwnerSelection && joinMapping.alias.target)
+            .map(joinMapping => {
+                const relatedEntities = this.transformRawResultsGroup(rawSqlResults, joinMapping.alias);
+                const isResultArray = joinMapping.isMany;
+                const result = !isResultArray ? relatedEntities[0] : relatedEntities;
+
+                if (result && (!isResultArray || result.length > 0)) {
+                    entity[joinMapping.propertyName] = result;
+                    hasData = true;
+                }
+            });*/
+        // get value from columns selections and put them into object
+        metadata.ownColumns.forEach((column) => {
+            const valueInObject = document[column.databaseNameWithoutPrefixes];
+            if (valueInObject !== undefined &&
+                column.propertyName &&
+                !column.isVirtual) {
+                // const value = this.driver.prepareHydratedValue(valueInObject, column);
+                entity[column.propertyName] = valueInObject;
+                hasData = true;
+            }
+        });
+        const addEmbeddedValuesRecursively = (entity, document, embeddeds) => {
+            embeddeds.forEach((embedded) => {
+                if (!document[embedded.prefix])
+                    return;
+                if (embedded.isArray) {
+                    entity[embedded.propertyName] = document[embedded.prefix].map((subValue, index) => {
+                        const newItem = embedded.create({
+                            fromDeserializer: true,
+                        });
+                        embedded.columns.forEach((column) => {
+                            newItem[column.propertyName] =
+                                subValue[column.databaseNameWithoutPrefixes];
+                        });
+                        addEmbeddedValuesRecursively(newItem, document[embedded.prefix][index], embedded.embeddeds);
+                        return newItem;
+                    });
+                }
+                else {
+                    if (embedded.embeddeds.length &&
+                        !entity[embedded.propertyName])
+                        entity[embedded.propertyName] = embedded.create({
+                            fromDeserializer: true,
+                        });
+                    embedded.columns.forEach((column) => {
+                        const value = document[embedded.prefix][column.databaseNameWithoutPrefixes];
+                        if (value === undefined)
+                            return;
+                        if (!entity[embedded.propertyName])
+                            entity[embedded.propertyName] = embedded.create({
+                                fromDeserializer: true,
+                            });
+                        entity[embedded.propertyName][column.propertyName] =
+                            value;
+                    });
+                    addEmbeddedValuesRecursively(entity[embedded.propertyName], document[embedded.prefix], embedded.embeddeds);
+                }
+            });
+        };
+        addEmbeddedValuesRecursively(entity, document, metadata.embeddeds);
+        // if relation is loaded then go into it recursively and transform its values too
+        /*metadata.relations.forEach(relation => {
+            const relationAlias = this.selectionMap.findSelectionByParent(alias.name, relation.propertyName);
+            if (relationAlias) {
+                const joinMapping = this.joinMappings.find(joinMapping => joinMapping.type === "join" && joinMapping.alias === relationAlias);
+                const relatedEntities = this.transformRawResultsGroup(rawSqlResults, relationAlias);
+                const isResultArray = relation.isManyToMany || relation.isOneToMany;
+                const result = !isResultArray ? relatedEntities[0] : relatedEntities;
+
+                if (result) {
+                    let propertyName = relation.propertyName;
+                    if (joinMapping) {
+                        propertyName = joinMapping.propertyName;
+                    }
+
+                    if (relation.isLazy) {
+                        entity["__" + propertyName + "__"] = result;
+                    } else {
+                        entity[propertyName] = result;
+                    }
+
+                    if (!isResultArray || result.length > 0)
+                        hasData = true;
+                }
+            }
+
+            // if relation has id field then relation id/ids to that field.
+            if (relation.isManyToMany) {
+                if (relationAlias) {
+                    const ids: any[] = [];
+                    const joinMapping = this.joinMappings.find(joinMapping => joinMapping.type === "relationId" && joinMapping.alias === relationAlias);
+
+                    if (relation.idField || joinMapping) {
+                        const propertyName = joinMapping ? joinMapping.propertyName : relation.idField as string;
+                        const junctionMetadata = relation.junctionEntityMetadata;
+                        const columnName = relation.isOwning ? junctionMetadata.columns[1].name : junctionMetadata.columns[0].name;
+
+                        rawSqlResults.forEach(results => {
+                            if (relationAlias) {
+                                const resultsKey = relationAlias.name + "_" + columnName;
+                                const value = this.driver.prepareHydratedValue(results[resultsKey], relation.referencedColumn);
+                                if (value !== undefined && value !== null)
+                                    ids.push(value);
+                            }
+                        });
+
+                        if (ids && ids.length)
+                            entity[propertyName] = ids;
+                    }
+                }
+            } else if (relation.idField) {
+                const relationName = relation.name;
+                entity[relation.idField] = this.driver.prepareHydratedValue(rawSqlResults[0][alias.name + "_" + relationName], relation.referencedColumn);
+            }
+
+            // if relation counter
+            this.relationCountMetas.forEach(joinMeta => {
+                if (joinMeta.alias === relationAlias) {
+                    // console.log("relation count was found for relation: ", relation);
+                    // joinMeta.entity = entity;
+                    joinMeta.entities.push({ entity: entity, metadata: metadata });
+                    // console.log(joinMeta);
+                    // console.log("---------------------");
+                }
+            });
+        });*/
+        return hasData ? entity : null;
+    }
+}
+exports.DocumentToEntityTransformer = DocumentToEntityTransformer;
+
+//# sourceMappingURL=DocumentToEntityTransformer.js.map

package/query-builder/transformer/DocumentToEntityTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/query-builder/transformer/DocumentToEntityTransformer.ts"],"names":[],"mappings":"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","file":"DocumentToEntityTransformer.js","sourcesContent":["import { EntityMetadata } from \"../../metadata/EntityMetadata\"\nimport { ObjectLiteral } from \"../../common/ObjectLiteral\"\nimport { EmbeddedMetadata } from \"../../metadata/EmbeddedMetadata\"\n\n/**\n * Transforms raw document into entity object.\n * Entity is constructed based on its entity metadata.\n */\nexport class DocumentToEntityTransformer {\n    // -------------------------------------------------------------------------\n    // Constructor\n    // -------------------------------------------------------------------------\n\n    constructor(\n        // private selectionMap: AliasMap,\n        // private joinMappings: JoinMapping[],\n        // private relationCountMetas: RelationCountAttribute[],\n        private enableRelationIdValues: boolean = false,\n    ) {}\n\n    // -------------------------------------------------------------------------\n    // Public Methods\n    // -------------------------------------------------------------------------\n\n    transformAll(documents: ObjectLiteral[], metadata: EntityMetadata) {\n        return documents.map((document) => this.transform(document, metadata))\n    }\n\n    transform(document: any, metadata: EntityMetadata) {\n        const entity: any = metadata.create(undefined, {\n            fromDeserializer: true,\n        })\n        let hasData = false\n\n        // handle _id property the special way\n        if (metadata.objectIdColumn) {\n            // todo: we can't use driver in this class\n            // do we really need prepare hydrated value here? If no then no problem. If yes then think maybe prepareHydratedValue process should be extracted out of driver class?\n            // entity[metadata.ObjectIdColumn.propertyName] = this.driver.prepareHydratedValue(document[metadata.ObjectIdColumn.name\"], metadata.ObjectIdColumn);\n            const { databaseNameWithoutPrefixes, propertyName } =\n                metadata.objectIdColumn\n\n            const documentIdWithoutPrefixes =\n                document[databaseNameWithoutPrefixes]\n            const documentIdWithPropertyName = document[propertyName]\n\n            if (documentIdWithoutPrefixes) {\n                entity[propertyName] = documentIdWithoutPrefixes\n                hasData = true\n            } else if (documentIdWithPropertyName) {\n                entity[propertyName] = documentIdWithPropertyName\n                hasData = true\n            }\n        }\n\n        // add special columns that contains relation ids\n        if (this.enableRelationIdValues) {\n            metadata.columns\n                .filter((column) => !!column.relationMetadata)\n                .forEach((column) => {\n                    const valueInObject =\n                        document[column.databaseNameWithoutPrefixes]\n                    if (\n                        valueInObject !== undefined &&\n                        valueInObject !== null &&\n                        column.propertyName\n                    ) {\n                        // todo: we can't use driver in this class\n                        // const value = this.driver.prepareHydratedValue(valueInObject, column);\n                        entity[column.propertyName] = valueInObject\n                        hasData = true\n                    }\n                })\n        }\n\n        /*this.joinMappings\n            .filter(joinMapping => joinMapping.parentName === alias.name && !joinMapping.alias.relationOwnerSelection && joinMapping.alias.target)\n            .map(joinMapping => {\n                const relatedEntities = this.transformRawResultsGroup(rawSqlResults, joinMapping.alias);\n                const isResultArray = joinMapping.isMany;\n                const result = !isResultArray ? relatedEntities[0] : relatedEntities;\n\n                if (result && (!isResultArray || result.length > 0)) {\n                    entity[joinMapping.propertyName] = result;\n                    hasData = true;\n                }\n            });*/\n\n        // get value from columns selections and put them into object\n        metadata.ownColumns.forEach((column) => {\n            const valueInObject = document[column.databaseNameWithoutPrefixes]\n            if (\n                valueInObject !== undefined &&\n                column.propertyName &&\n                !column.isVirtual\n            ) {\n                // const value = this.driver.prepareHydratedValue(valueInObject, column);\n\n                entity[column.propertyName] = valueInObject\n                hasData = true\n            }\n        })\n\n        const addEmbeddedValuesRecursively = (\n            entity: any,\n            document: any,\n            embeddeds: EmbeddedMetadata[],\n        ) => {\n            embeddeds.forEach((embedded) => {\n                if (!document[embedded.prefix]) return\n\n                if (embedded.isArray) {\n                    entity[embedded.propertyName] = (\n                        document[embedded.prefix] as any[]\n                    ).map((subValue: any, index: number) => {\n                        const newItem = embedded.create({\n                            fromDeserializer: true,\n                        })\n                        embedded.columns.forEach((column) => {\n                            newItem[column.propertyName] =\n                                subValue[column.databaseNameWithoutPrefixes]\n                        })\n                        addEmbeddedValuesRecursively(\n                            newItem,\n                            document[embedded.prefix][index],\n                            embedded.embeddeds,\n                        )\n                        return newItem\n                    })\n                } else {\n                    if (\n                        embedded.embeddeds.length &&\n                        !entity[embedded.propertyName]\n                    )\n                        entity[embedded.propertyName] = embedded.create({\n                            fromDeserializer: true,\n                        })\n\n                    embedded.columns.forEach((column) => {\n                        const value =\n                            document[embedded.prefix][\n                                column.databaseNameWithoutPrefixes\n                            ]\n                        if (value === undefined) return\n\n                        if (!entity[embedded.propertyName])\n                            entity[embedded.propertyName] = embedded.create({\n                                fromDeserializer: true,\n                            })\n\n                        entity[embedded.propertyName][column.propertyName] =\n                            value\n                    })\n\n                    addEmbeddedValuesRecursively(\n                        entity[embedded.propertyName],\n                        document[embedded.prefix],\n                        embedded.embeddeds,\n                    )\n                }\n            })\n        }\n\n        addEmbeddedValuesRecursively(entity, document, metadata.embeddeds)\n\n        // if relation is loaded then go into it recursively and transform its values too\n        /*metadata.relations.forEach(relation => {\n            const relationAlias = this.selectionMap.findSelectionByParent(alias.name, relation.propertyName);\n            if (relationAlias) {\n                const joinMapping = this.joinMappings.find(joinMapping => joinMapping.type === \"join\" && joinMapping.alias === relationAlias);\n                const relatedEntities = this.transformRawResultsGroup(rawSqlResults, relationAlias);\n                const isResultArray = relation.isManyToMany || relation.isOneToMany;\n                const result = !isResultArray ? relatedEntities[0] : relatedEntities;\n\n                if (result) {\n                    let propertyName = relation.propertyName;\n                    if (joinMapping) {\n                        propertyName = joinMapping.propertyName;\n                    }\n\n                    if (relation.isLazy) {\n                        entity[\"__\" + propertyName + \"__\"] = result;\n                    } else {\n                        entity[propertyName] = result;\n                    }\n\n                    if (!isResultArray || result.length > 0)\n                        hasData = true;\n                }\n            }\n\n            // if relation has id field then relation id/ids to that field.\n            if (relation.isManyToMany) {\n                if (relationAlias) {\n                    const ids: any[] = [];\n                    const joinMapping = this.joinMappings.find(joinMapping => joinMapping.type === \"relationId\" && joinMapping.alias === relationAlias);\n\n                    if (relation.idField || joinMapping) {\n                        const propertyName = joinMapping ? joinMapping.propertyName : relation.idField as string;\n                        const junctionMetadata = relation.junctionEntityMetadata;\n                        const columnName = relation.isOwning ? junctionMetadata.columns[1].name : junctionMetadata.columns[0].name;\n\n                        rawSqlResults.forEach(results => {\n                            if (relationAlias) {\n                                const resultsKey = relationAlias.name + \"_\" + columnName;\n                                const value = this.driver.prepareHydratedValue(results[resultsKey], relation.referencedColumn);\n                                if (value !== undefined && value !== null)\n                                    ids.push(value);\n                            }\n                        });\n\n                        if (ids && ids.length)\n                            entity[propertyName] = ids;\n                    }\n                }\n            } else if (relation.idField) {\n                const relationName = relation.name;\n                entity[relation.idField] = this.driver.prepareHydratedValue(rawSqlResults[0][alias.name + \"_\" + relationName], relation.referencedColumn);\n            }\n\n            // if relation counter\n            this.relationCountMetas.forEach(joinMeta => {\n                if (joinMeta.alias === relationAlias) {\n                    // console.log(\"relation count was found for relation: \", relation);\n                    // joinMeta.entity = entity;\n                    joinMeta.entities.push({ entity: entity, metadata: metadata });\n                    // console.log(joinMeta);\n                    // console.log(\"---------------------\");\n                }\n            });\n        });*/\n\n        return hasData ? entity : null\n    }\n}\n"],"sourceRoot":"../.."}

package/query-builder/transformer/PlainObjectToDatabaseEntityTransformer.d.ts

@@ -0,0 +1,12 @@
+import { ObjectLiteral } from "../../common/ObjectLiteral";
+import { EntityMetadata } from "../../metadata/EntityMetadata";
+import { EntityManager } from "../../entity-manager/EntityManager";
+/**
+ * Transforms plain old javascript object
+ * Entity is constructed based on its entity metadata.
+ */
+export declare class PlainObjectToDatabaseEntityTransformer {
+    private manager;
+    constructor(manager: EntityManager);
+    transform(plainObject: ObjectLiteral, metadata: EntityMetadata): Promise<ObjectLiteral | undefined>;
+}

package/query-builder/transformer/PlainObjectToDatabaseEntityTransformer.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlainObjectToDatabaseEntityTransformer = void 0;
+/**
+ */
+class LoadMapItem {
+    constructor(plainEntity, metadata, parentLoadMapItem, relation) {
+        this.plainEntity = plainEntity;
+        this.metadata = metadata;
+        this.parentLoadMapItem = parentLoadMapItem;
+        this.relation = relation;
+    }
+    get target() {
+        return this.metadata.target;
+    }
+    get id() {
+        return this.metadata.getEntityIdMixedMap(this.plainEntity);
+    }
+}
+class LoadMap {
+    constructor() {
+        this.loadMapItems = [];
+    }
+    get mainLoadMapItem() {
+        return this.loadMapItems.find((item) => !item.relation && !item.parentLoadMapItem);
+    }
+    addLoadMap(newLoadMap) {
+        const item = this.loadMapItems.find((item) => item.target === newLoadMap.target && item.id === newLoadMap.id);
+        if (!item)
+            this.loadMapItems.push(newLoadMap);
+    }
+    fillEntities(target, entities) {
+        entities.forEach((entity) => {
+            const item = this.loadMapItems.find((loadMapItem) => {
+                return (loadMapItem.target === target &&
+                    loadMapItem.metadata.compareEntities(entity, loadMapItem.plainEntity));
+            });
+            if (item)
+                item.entity = entity;
+        });
+    }
+    groupByTargetIds() {
+        const groups = [];
+        this.loadMapItems.forEach((loadMapItem) => {
+            let group = groups.find((group) => group.target === loadMapItem.target);
+            if (!group) {
+                group = { target: loadMapItem.target, ids: [] };
+                groups.push(group);
+            }
+            group.ids.push(loadMapItem.id);
+        });
+        return groups;
+    }
+}
+/**
+ * Transforms plain old javascript object
+ * Entity is constructed based on its entity metadata.
+ */
+class PlainObjectToDatabaseEntityTransformer {
+    constructor(manager) {
+        this.manager = manager;
+    }
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    async transform(plainObject, metadata) {
+        // if plain object does not have id then nothing to load really
+        if (!metadata.hasAllPrimaryKeys(plainObject))
+            return Promise.reject("Given object does not have a primary column, cannot transform it to database entity.");
+        // create a special load map that will hold all metadata that will be used to operate with entities easily
+        const loadMap = new LoadMap();
+        const fillLoadMap = (entity, entityMetadata, parentLoadMapItem, relation) => {
+            const item = new LoadMapItem(entity, entityMetadata, parentLoadMapItem, relation);
+            loadMap.addLoadMap(item);
+            entityMetadata
+                .extractRelationValuesFromEntity(entity, metadata.relations)
+                .filter((value) => value !== null && value !== undefined)
+                .forEach(([relation, value, inverseEntityMetadata]) => fillLoadMap(value, inverseEntityMetadata, item, relation));
+        };
+        fillLoadMap(plainObject, metadata);
+        // load all entities and store them in the load map
+        await Promise.all(loadMap.groupByTargetIds().map((targetWithIds) => {
+            // todo: fix type hinting
+            return this.manager
+                .findByIds(targetWithIds.target, targetWithIds.ids)
+                .then((entities) => loadMap.fillEntities(targetWithIds.target, entities));
+        }));
+        // go through each item in the load map and set their entity relationship using metadata stored in load map
+        loadMap.loadMapItems.forEach((loadMapItem) => {
+            if (!loadMapItem.relation ||
+                !loadMapItem.entity ||
+                !loadMapItem.parentLoadMapItem ||
+                !loadMapItem.parentLoadMapItem.entity)
+                return;
+            if (loadMapItem.relation.isManyToMany ||
+                loadMapItem.relation.isOneToMany) {
+                if (!loadMapItem.parentLoadMapItem.entity[loadMapItem.relation.propertyName])
+                    loadMapItem.parentLoadMapItem.entity[loadMapItem.relation.propertyName] = [];
+                loadMapItem.parentLoadMapItem.entity[loadMapItem.relation.propertyName].push(loadMapItem.entity);
+            }
+            else {
+                loadMapItem.parentLoadMapItem.entity[loadMapItem.relation.propertyName] = loadMapItem.entity;
+            }
+        });
+        return loadMap.mainLoadMapItem
+            ? loadMap.mainLoadMapItem.entity
+            : undefined;
+    }
+}
+exports.PlainObjectToDatabaseEntityTransformer = PlainObjectToDatabaseEntityTransformer;
+
+//# sourceMappingURL=PlainObjectToDatabaseEntityTransformer.js.map

package/query-builder/transformer/PlainObjectToDatabaseEntityTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/query-builder/transformer/PlainObjectToDatabaseEntityTransformer.ts"],"names":[],"mappings":"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","file":"PlainObjectToDatabaseEntityTransformer.js","sourcesContent":["import { ObjectLiteral } from \"../../common/ObjectLiteral\"\nimport { EntityMetadata } from \"../../metadata/EntityMetadata\"\nimport { EntityManager } from \"../../entity-manager/EntityManager\"\nimport { RelationMetadata } from \"../../metadata/RelationMetadata\"\n\n/**\n */\nclass LoadMapItem {\n    entity?: ObjectLiteral\n    plainEntity: ObjectLiteral\n    metadata: EntityMetadata\n    parentLoadMapItem?: LoadMapItem\n    relation?: RelationMetadata\n\n    constructor(\n        plainEntity: ObjectLiteral,\n        metadata: EntityMetadata,\n        parentLoadMapItem?: LoadMapItem,\n        relation?: RelationMetadata,\n    ) {\n        this.plainEntity = plainEntity\n        this.metadata = metadata\n        this.parentLoadMapItem = parentLoadMapItem\n        this.relation = relation\n    }\n\n    get target(): Function | string {\n        return this.metadata.target\n    }\n\n    get id(): any {\n        return this.metadata.getEntityIdMixedMap(this.plainEntity)\n    }\n}\n\nclass LoadMap {\n    loadMapItems: LoadMapItem[] = []\n\n    get mainLoadMapItem(): LoadMapItem | undefined {\n        return this.loadMapItems.find(\n            (item) => !item.relation && !item.parentLoadMapItem,\n        )\n    }\n\n    addLoadMap(newLoadMap: LoadMapItem) {\n        const item = this.loadMapItems.find(\n            (item) =>\n                item.target === newLoadMap.target && item.id === newLoadMap.id,\n        )\n        if (!item) this.loadMapItems.push(newLoadMap)\n    }\n\n    fillEntities(target: Function | string, entities: any[]) {\n        entities.forEach((entity) => {\n            const item = this.loadMapItems.find((loadMapItem) => {\n                return (\n                    loadMapItem.target === target &&\n                    loadMapItem.metadata.compareEntities(\n                        entity,\n                        loadMapItem.plainEntity,\n                    )\n                )\n            })\n            if (item) item.entity = entity\n        })\n    }\n\n    groupByTargetIds(): { target: Function | string; ids: any[] }[] {\n        const groups: { target: Function | string; ids: any[] }[] = []\n        this.loadMapItems.forEach((loadMapItem) => {\n            let group = groups.find(\n                (group) => group.target === loadMapItem.target,\n            )\n            if (!group) {\n                group = { target: loadMapItem.target, ids: [] }\n                groups.push(group)\n            }\n\n            group.ids.push(loadMapItem.id)\n        })\n        return groups\n    }\n}\n\n/**\n * Transforms plain old javascript object\n * Entity is constructed based on its entity metadata.\n */\nexport class PlainObjectToDatabaseEntityTransformer {\n    constructor(private manager: EntityManager) {}\n\n    // -------------------------------------------------------------------------\n    // Public Methods\n    // -------------------------------------------------------------------------\n\n    async transform(\n        plainObject: ObjectLiteral,\n        metadata: EntityMetadata,\n    ): Promise<ObjectLiteral | undefined> {\n        // if plain object does not have id then nothing to load really\n        if (!metadata.hasAllPrimaryKeys(plainObject))\n            return Promise.reject(\n                \"Given object does not have a primary column, cannot transform it to database entity.\",\n            )\n\n        // create a special load map that will hold all metadata that will be used to operate with entities easily\n        const loadMap = new LoadMap()\n        const fillLoadMap = (\n            entity: ObjectLiteral,\n            entityMetadata: EntityMetadata,\n            parentLoadMapItem?: LoadMapItem,\n            relation?: RelationMetadata,\n        ) => {\n            const item = new LoadMapItem(\n                entity,\n                entityMetadata,\n                parentLoadMapItem,\n                relation,\n            )\n            loadMap.addLoadMap(item)\n\n            entityMetadata\n                .extractRelationValuesFromEntity(entity, metadata.relations)\n                .filter((value) => value !== null && value !== undefined)\n                .forEach(([relation, value, inverseEntityMetadata]) =>\n                    fillLoadMap(value, inverseEntityMetadata, item, relation),\n                )\n        }\n        fillLoadMap(plainObject, metadata)\n        // load all entities and store them in the load map\n        await Promise.all(\n            loadMap.groupByTargetIds().map((targetWithIds) => {\n                // todo: fix type hinting\n                return this.manager\n                    .findByIds<ObjectLiteral>(\n                        targetWithIds.target as any,\n                        targetWithIds.ids,\n                    )\n                    .then((entities) =>\n                        loadMap.fillEntities(targetWithIds.target, entities),\n                    )\n            }),\n        )\n\n        // go through each item in the load map and set their entity relationship using metadata stored in load map\n        loadMap.loadMapItems.forEach((loadMapItem) => {\n            if (\n                !loadMapItem.relation ||\n                !loadMapItem.entity ||\n                !loadMapItem.parentLoadMapItem ||\n                !loadMapItem.parentLoadMapItem.entity\n            )\n                return\n\n            if (\n                loadMapItem.relation.isManyToMany ||\n                loadMapItem.relation.isOneToMany\n            ) {\n                if (\n                    !loadMapItem.parentLoadMapItem.entity[\n                        loadMapItem.relation.propertyName\n                    ]\n                )\n                    loadMapItem.parentLoadMapItem.entity[\n                        loadMapItem.relation.propertyName\n                    ] = []\n                loadMapItem.parentLoadMapItem.entity[\n                    loadMapItem.relation.propertyName\n                ].push(loadMapItem.entity)\n            } else {\n                loadMapItem.parentLoadMapItem.entity[\n                    loadMapItem.relation.propertyName\n                ] = loadMapItem.entity\n            }\n        })\n\n        return loadMap.mainLoadMapItem\n            ? loadMap.mainLoadMapItem.entity\n            : undefined\n    }\n}\n"],"sourceRoot":"../.."}

package/query-builder/transformer/PlainObjectToNewEntityTransformer.d.ts

@@ -0,0 +1,14 @@
+import { EntityMetadata } from "../../metadata/EntityMetadata";
+import { ObjectLiteral } from "../../common/ObjectLiteral";
+/**
+ * Transforms plain old javascript object
+ * Entity is constructed based on its entity metadata.
+ */
+export declare class PlainObjectToNewEntityTransformer {
+    transform<T extends ObjectLiteral>(newEntity: T, object: ObjectLiteral, metadata: EntityMetadata, getLazyRelationsPromiseValue?: boolean): T;
+    /**
+     * Since db returns a duplicated rows of the data where accuracies of the same object can be duplicated
+     * we need to group our result and we must have some unique id (primary key in our case)
+     */
+    private groupAndTransform;
+}

package/query-builder/transformer/PlainObjectToNewEntityTransformer.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlainObjectToNewEntityTransformer = void 0;
+const ObjectUtils_1 = require("../../util/ObjectUtils");
+/**
+ * Transforms plain old javascript object
+ * Entity is constructed based on its entity metadata.
+ */
+class PlainObjectToNewEntityTransformer {
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    transform(newEntity, object, metadata, getLazyRelationsPromiseValue = false) {
+        // console.log("groupAndTransform entity:", newEntity);
+        // console.log("groupAndTransform object:", object);
+        this.groupAndTransform(newEntity, object, metadata, getLazyRelationsPromiseValue);
+        // console.log("result:", newEntity);
+        return newEntity;
+    }
+    // -------------------------------------------------------------------------
+    // Private Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Since db returns a duplicated rows of the data where accuracies of the same object can be duplicated
+     * we need to group our result and we must have some unique id (primary key in our case)
+     */
+    groupAndTransform(entity, object, metadata, getLazyRelationsPromiseValue = false) {
+        // console.log("groupAndTransform entity:", entity);
+        // console.log("groupAndTransform object:", object);
+        // copy regular column properties from the given object
+        metadata.nonVirtualColumns.forEach((column) => {
+            const objectColumnValue = column.getEntityValue(object);
+            if (objectColumnValue !== undefined)
+                column.setEntityValue(entity, objectColumnValue);
+        });
+        // // copy relation properties from the given object
+        if (metadata.relations.length) {
+            metadata.relations.forEach((relation) => {
+                let entityRelatedValue = relation.getEntityValue(entity);
+                const objectRelatedValue = relation.getEntityValue(object, getLazyRelationsPromiseValue);
+                if (objectRelatedValue === undefined)
+                    return;
+                if (relation.isOneToMany || relation.isManyToMany) {
+                    if (!Array.isArray(objectRelatedValue))
+                        return;
+                    if (!entityRelatedValue) {
+                        entityRelatedValue = [];
+                        relation.setEntityValue(entity, entityRelatedValue);
+                    }
+                    objectRelatedValue.forEach((objectRelatedValueItem) => {
+                        // check if we have this item from the merging object in the original entity we merge into
+                        let objectRelatedValueEntity = entityRelatedValue.find((entityRelatedValueItem) => {
+                            return relation.inverseEntityMetadata.compareEntities(objectRelatedValueItem, entityRelatedValueItem);
+                        });
+                        const inverseEntityMetadata = relation.inverseEntityMetadata.findInheritanceMetadata(objectRelatedValueItem);
+                        // if such item already exist then merge new data into it, if its not we create a new entity and merge it into the array
+                        if (!objectRelatedValueEntity) {
+                            objectRelatedValueEntity =
+                                inverseEntityMetadata.create(undefined, {
+                                    fromDeserializer: true,
+                                });
+                            entityRelatedValue.push(objectRelatedValueEntity);
+                        }
+                        this.groupAndTransform(objectRelatedValueEntity, objectRelatedValueItem, inverseEntityMetadata, getLazyRelationsPromiseValue);
+                    });
+                }
+                else {
+                    // if related object isn't an object (direct relation id for example)
+                    // we just set it to the entity relation, we don't need anything more from it
+                    // however we do it only if original entity does not have this relation set to object
+                    // to prevent full overriding of objects
+                    if (!ObjectUtils_1.ObjectUtils.isObject(objectRelatedValue)) {
+                        if (!ObjectUtils_1.ObjectUtils.isObject(entityRelatedValue))
+                            relation.setEntityValue(entity, objectRelatedValue);
+                        return;
+                    }
+                    const inverseEntityMetadata = relation.inverseEntityMetadata.findInheritanceMetadata(objectRelatedValue);
+                    if (!entityRelatedValue) {
+                        entityRelatedValue = inverseEntityMetadata.create(undefined, {
+                            fromDeserializer: true,
+                        });
+                        relation.setEntityValue(entity, entityRelatedValue);
+                    }
+                    this.groupAndTransform(entityRelatedValue, objectRelatedValue, inverseEntityMetadata, getLazyRelationsPromiseValue);
+                }
+            });
+        }
+    }
+}
+exports.PlainObjectToNewEntityTransformer = PlainObjectToNewEntityTransformer;
+
+//# sourceMappingURL=PlainObjectToNewEntityTransformer.js.map

package/query-builder/transformer/PlainObjectToNewEntityTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/query-builder/transformer/PlainObjectToNewEntityTransformer.ts"],"names":[],"mappings":";;;AAEA,wDAAoD;AAEpD;;;GAGG;AACH,MAAa,iCAAiC;IAC1C,4EAA4E;IAC5E,iBAAiB;IACjB,4EAA4E;IAE5E,SAAS,CACL,SAAY,EACZ,MAAqB,EACrB,QAAwB,EACxB,+BAAwC,KAAK;QAE7C,uDAAuD;QACvD,oDAAoD;QACpD,IAAI,CAAC,iBAAiB,CAClB,SAAS,EACT,MAAM,EACN,QAAQ,EACR,4BAA4B,CAC/B,CAAA;QACD,qCAAqC;QACrC,OAAO,SAAS,CAAA;IACpB,CAAC;IAED,4EAA4E;IAC5E,kBAAkB;IAClB,4EAA4E;IAE5E;;;OAGG;IACK,iBAAiB,CACrB,MAAqB,EACrB,MAAqB,EACrB,QAAwB,EACxB,+BAAwC,KAAK;QAE7C,oDAAoD;QACpD,oDAAoD;QAEpD,uDAAuD;QACvD,QAAQ,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE;YAC1C,MAAM,iBAAiB,GAAG,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,CAAA;YACvD,IAAI,iBAAiB,KAAK,SAAS;gBAC/B,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;QACxD,CAAC,CAAC,CAAA;QAEF,oDAAoD;QACpD,IAAI,QAAQ,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC;YAC5B,QAAQ,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE;gBACpC,IAAI,kBAAkB,GAAG,QAAQ,CAAC,cAAc,CAAC,MAAM,CAAC,CAAA;gBACxD,MAAM,kBAAkB,GAAG,QAAQ,CAAC,cAAc,CAC9C,MAAM,EACN,4BAA4B,CAC/B,CAAA;gBACD,IAAI,kBAAkB,KAAK,SAAS;oBAAE,OAAM;gBAE5C,IAAI,QAAQ,CAAC,WAAW,IAAI,QAAQ,CAAC,YAAY,EAAE,CAAC;oBAChD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,kBAAkB,CAAC;wBAAE,OAAM;oBAE9C,IAAI,CAAC,kBAAkB,EAAE,CAAC;wBACtB,kBAAkB,GAAG,EAAE,CAAA;wBACvB,QAAQ,CAAC,cAAc,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAA;oBACvD,CAAC;oBAED,kBAAkB,CAAC,OAAO,CAAC,CAAC,sBAAsB,EAAE,EAAE;wBAClD,0FAA0F;wBAC1F,IAAI,wBAAwB,GACxB,kBACH,CAAC,IAAI,CAAC,CAAC,sBAAsB,EAAE,EAAE;4BAC9B,OAAO,QAAQ,CAAC,qBAAqB,CAAC,eAAe,CACjD,sBAAsB,EACtB,sBAAsB,CACzB,CAAA;wBACL,CAAC,CAAC,CAAA;wBAEF,MAAM,qBAAqB,GACvB,QAAQ,CAAC,qBAAqB,CAAC,uBAAuB,CAClD,sBAAsB,CACzB,CAAA;wBAEL,wHAAwH;wBACxH,IAAI,CAAC,wBAAwB,EAAE,CAAC;4BAC5B,wBAAwB;gCACpB,qBAAqB,CAAC,MAAM,CAAC,SAAS,EAAE;oCACpC,gBAAgB,EAAE,IAAI;iCACzB,CAAC,CAAA;4BACN,kBAAkB,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAA;wBACrD,CAAC;wBAED,IAAI,CAAC,iBAAiB,CAClB,wBAAwB,EACxB,sBAAsB,EACtB,qBAAqB,EACrB,4BAA4B,CAC/B,CAAA;oBACL,CAAC,CAAC,CAAA;gBACN,CAAC;qBAAM,CAAC;oBACJ,qEAAqE;oBACrE,6EAA6E;oBAC7E,qFAAqF;oBACrF,wCAAwC;oBACxC,IAAI,CAAC,yBAAW,CAAC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,CAAC;wBAC5C,IAAI,CAAC,yBAAW,CAAC,QAAQ,CAAC,kBAAkB,CAAC;4BACzC,QAAQ,CAAC,cAAc,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAA;wBACvD,OAAM;oBACV,CAAC;oBAED,MAAM,qBAAqB,GACvB,QAAQ,CAAC,qBAAqB,CAAC,uBAAuB,CAClD,kBAAkB,CACrB,CAAA;oBAEL,IAAI,CAAC,kBAAkB,EAAE,CAAC;wBACtB,kBAAkB,GAAG,qBAAqB,CAAC,MAAM,CAC7C,SAAS,EACT;4BACI,gBAAgB,EAAE,IAAI;yBACzB,CACJ,CAAA;wBACD,QAAQ,CAAC,cAAc,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAA;oBACvD,CAAC;oBAED,IAAI,CAAC,iBAAiB,CAClB,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,EACrB,4BAA4B,CAC/B,CAAA;gBACL,CAAC;YACL,CAAC,CAAC,CAAA;QACN,CAAC;IACL,CAAC;CACJ;AArID,8EAqIC","file":"PlainObjectToNewEntityTransformer.js","sourcesContent":["import { EntityMetadata } from \"../../metadata/EntityMetadata\"\nimport { ObjectLiteral } from \"../../common/ObjectLiteral\"\nimport { ObjectUtils } from \"../../util/ObjectUtils\"\n\n/**\n * Transforms plain old javascript object\n * Entity is constructed based on its entity metadata.\n */\nexport class PlainObjectToNewEntityTransformer {\n    // -------------------------------------------------------------------------\n    // Public Methods\n    // -------------------------------------------------------------------------\n\n    transform<T extends ObjectLiteral>(\n        newEntity: T,\n        object: ObjectLiteral,\n        metadata: EntityMetadata,\n        getLazyRelationsPromiseValue: boolean = false,\n    ): T {\n        // console.log(\"groupAndTransform entity:\", newEntity);\n        // console.log(\"groupAndTransform object:\", object);\n        this.groupAndTransform(\n            newEntity,\n            object,\n            metadata,\n            getLazyRelationsPromiseValue,\n        )\n        // console.log(\"result:\", newEntity);\n        return newEntity\n    }\n\n    // -------------------------------------------------------------------------\n    // Private Methods\n    // -------------------------------------------------------------------------\n\n    /**\n     * Since db returns a duplicated rows of the data where accuracies of the same object can be duplicated\n     * we need to group our result and we must have some unique id (primary key in our case)\n     */\n    private groupAndTransform(\n        entity: ObjectLiteral,\n        object: ObjectLiteral,\n        metadata: EntityMetadata,\n        getLazyRelationsPromiseValue: boolean = false,\n    ): void {\n        // console.log(\"groupAndTransform entity:\", entity);\n        // console.log(\"groupAndTransform object:\", object);\n\n        // copy regular column properties from the given object\n        metadata.nonVirtualColumns.forEach((column) => {\n            const objectColumnValue = column.getEntityValue(object)\n            if (objectColumnValue !== undefined)\n                column.setEntityValue(entity, objectColumnValue)\n        })\n\n        // // copy relation properties from the given object\n        if (metadata.relations.length) {\n            metadata.relations.forEach((relation) => {\n                let entityRelatedValue = relation.getEntityValue(entity)\n                const objectRelatedValue = relation.getEntityValue(\n                    object,\n                    getLazyRelationsPromiseValue,\n                )\n                if (objectRelatedValue === undefined) return\n\n                if (relation.isOneToMany || relation.isManyToMany) {\n                    if (!Array.isArray(objectRelatedValue)) return\n\n                    if (!entityRelatedValue) {\n                        entityRelatedValue = []\n                        relation.setEntityValue(entity, entityRelatedValue)\n                    }\n\n                    objectRelatedValue.forEach((objectRelatedValueItem) => {\n                        // check if we have this item from the merging object in the original entity we merge into\n                        let objectRelatedValueEntity = (\n                            entityRelatedValue as any[]\n                        ).find((entityRelatedValueItem) => {\n                            return relation.inverseEntityMetadata.compareEntities(\n                                objectRelatedValueItem,\n                                entityRelatedValueItem,\n                            )\n                        })\n\n                        const inverseEntityMetadata =\n                            relation.inverseEntityMetadata.findInheritanceMetadata(\n                                objectRelatedValueItem,\n                            )\n\n                        // if such item already exist then merge new data into it, if its not we create a new entity and merge it into the array\n                        if (!objectRelatedValueEntity) {\n                            objectRelatedValueEntity =\n                                inverseEntityMetadata.create(undefined, {\n                                    fromDeserializer: true,\n                                })\n                            entityRelatedValue.push(objectRelatedValueEntity)\n                        }\n\n                        this.groupAndTransform(\n                            objectRelatedValueEntity,\n                            objectRelatedValueItem,\n                            inverseEntityMetadata,\n                            getLazyRelationsPromiseValue,\n                        )\n                    })\n                } else {\n                    // if related object isn't an object (direct relation id for example)\n                    // we just set it to the entity relation, we don't need anything more from it\n                    // however we do it only if original entity does not have this relation set to object\n                    // to prevent full overriding of objects\n                    if (!ObjectUtils.isObject(objectRelatedValue)) {\n                        if (!ObjectUtils.isObject(entityRelatedValue))\n                            relation.setEntityValue(entity, objectRelatedValue)\n                        return\n                    }\n\n                    const inverseEntityMetadata =\n                        relation.inverseEntityMetadata.findInheritanceMetadata(\n                            objectRelatedValue,\n                        )\n\n                    if (!entityRelatedValue) {\n                        entityRelatedValue = inverseEntityMetadata.create(\n                            undefined,\n                            {\n                                fromDeserializer: true,\n                            },\n                        )\n                        relation.setEntityValue(entity, entityRelatedValue)\n                    }\n\n                    this.groupAndTransform(\n                        entityRelatedValue,\n                        objectRelatedValue,\n                        inverseEntityMetadata,\n                        getLazyRelationsPromiseValue,\n                    )\n                }\n            })\n        }\n    }\n}\n"],"sourceRoot":"../.."}

package/query-builder/transformer/RawSqlResultsToEntityTransformer.d.ts

@@ -0,0 +1,64 @@
+import { Driver } from "../../driver/Driver";
+import { RelationIdLoadResult } from "../relation-id/RelationIdLoadResult";
+import { ObjectLiteral } from "../../common/ObjectLiteral";
+import { Alias } from "../Alias";
+import { RelationCountLoadResult } from "../relation-count/RelationCountLoadResult";
+import { QueryExpressionMap } from "../QueryExpressionMap";
+import { EntityMetadata } from "../../metadata/EntityMetadata";
+import { QueryRunner } from "../..";
+/**
+ * Transforms raw sql results returned from the database into entity object.
+ * Entity is constructed based on its entity metadata.
+ */
+export declare class RawSqlResultsToEntityTransformer {
+    protected expressionMap: QueryExpressionMap;
+    protected driver: Driver;
+    protected rawRelationIdResults: RelationIdLoadResult[];
+    protected rawRelationCountResults: RelationCountLoadResult[];
+    protected queryRunner?: QueryRunner | undefined;
+    /**
+     * Contains a hashmap for every rawRelationIdResults given.
+     * In the hashmap you will find the idMaps of a result under the hash of this.hashEntityIds for the result.
+     */
+    private relationIdMaps;
+    private pojo;
+    private selections;
+    private aliasCache;
+    private columnsCache;
+    constructor(expressionMap: QueryExpressionMap, driver: Driver, rawRelationIdResults: RelationIdLoadResult[], rawRelationCountResults: RelationCountLoadResult[], queryRunner?: QueryRunner | undefined);
+    /**
+     * Since db returns a duplicated rows of the data where accuracies of the same object can be duplicated
+     * we need to group our result and we must have some unique id (primary key in our case)
+     */
+    transform(rawResults: any[], alias: Alias): any[];
+    /**
+     * Build an alias from a name and column name.
+     */
+    protected buildAlias(aliasName: string, columnName: string): string;
+    /**
+     * Groups given raw results by ids of given alias.
+     */
+    protected group(rawResults: any[], alias: Alias): Map<string, any[]>;
+    /**
+     * Transforms set of data results into single entity.
+     */
+    protected transformRawResultsGroup(rawResults: any[], alias: Alias): ObjectLiteral | undefined;
+    protected transformColumns(rawResults: any[], alias: Alias, entity: ObjectLiteral, metadata: EntityMetadata): boolean;
+    /**
+     * Transforms joined entities in the given raw results by a given alias and stores to the given (parent) entity
+     */
+    protected transformJoins(rawResults: any[], entity: ObjectLiteral, alias: Alias, metadata: EntityMetadata): boolean;
+    protected transformRelationIds(rawSqlResults: any[], alias: Alias, entity: ObjectLiteral, metadata: EntityMetadata): boolean;
+    protected transformRelationCounts(rawSqlResults: any[], alias: Alias, entity: ObjectLiteral): boolean;
+    private getColumnsToProcess;
+    private createValueMapFromJoinColumns;
+    private extractEntityPrimaryIds;
+    /** Prepare data to run #transformRelationIds, as a lot of result independent data is needed in every call */
+    private prepareDataForTransformRelationIds;
+    /**
+     * Use a simple JSON.stringify to create a simple hash of the primary ids of an entity.
+     * As this.extractEntityPrimaryIds always creates the primary id object in the same order, if the same relation is
+     * given, a simple JSON.stringify should be enough to get a unique hash per entity!
+     */
+    private hashEntityIds;
+}