14796576772

Committed 02 May 2025 01:52PM UTC coverage: 45.367% (-30.9%) from 76.309%

Build # 14796576772

Build Type

Pull #11434

github

Committed by

web-flow

Commit Message

Merge ec4ce2d00 into fadad1a74

Pull Request Pull Request #11434: feat: release PR releases using pkg.pr.new

Run Details

5216 of 12761 branches covered (40.87%)

Branch coverage included in aggregate %.

11439 of 23951 relevant lines covered (47.76%)

15712.55 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

86.0

/src/query-builder/transformer/PlainObjectToNewEntityTransformer.ts

import { EntityMetadata } from "../../metadata/EntityMetadata"
import { ObjectLiteral } from "../../common/ObjectLiteral"
import { ObjectUtils } from "../../util/ObjectUtils"

/**
 * Transforms plain old javascript object
 * Entity is constructed based on its entity metadata.
 */
export class PlainObjectToNewEntityTransformer {
    // -------------------------------------------------------------------------
    // Public Methods
    // -------------------------------------------------------------------------

    transform<T extends ObjectLiteral>(
        newEntity: T,
        object: ObjectLiteral,
        metadata: EntityMetadata,
        getLazyRelationsPromiseValue: boolean = false,
    ): T {
        // 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)
     */
    private groupAndTransform(
        entity: ObjectLiteral,
        object: ObjectLiteral,
        metadata: EntityMetadata,
        getLazyRelationsPromiseValue: boolean = false,
    ): void {
        // 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 as any[]
                        ).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.isObject(objectRelatedValue)) {
                        if (!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,
                    )
                }
            })
        }
    }
}

1	import { EntityMetadata } from "../../metadata/EntityMetadata"
2	import { ObjectLiteral } from "../../common/ObjectLiteral"
3	import { ObjectUtils } from "../../util/ObjectUtils"	4✔
4
5	/**
6	* Transforms plain old javascript object
7	* Entity is constructed based on its entity metadata.
8	*/
9	export class PlainObjectToNewEntityTransformer {	4✔
10	// -------------------------------------------------------------------------
11	// Public Methods
12	// -------------------------------------------------------------------------
13
14	transform<T extends ObjectLiteral>(
15	newEntity: T,
16	object: ObjectLiteral,
17	metadata: EntityMetadata,
18	getLazyRelationsPromiseValue: boolean = false,	92,302✔
19	): T {
20	// console.log("groupAndTransform entity:", newEntity);
21	// console.log("groupAndTransform object:", object);
22	this.groupAndTransform(	92,602✔
23	newEntity,
24	object,
25	metadata,
26	getLazyRelationsPromiseValue,
27	)
28	// console.log("result:", newEntity);
29	return newEntity	92,602✔
30	}
31
32	// -------------------------------------------------------------------------
33	// Private Methods
34	// -------------------------------------------------------------------------
35
36	/**
37	* Since db returns a duplicated rows of the data where accuracies of the same object can be duplicated
38	* we need to group our result and we must have some unique id (primary key in our case)
39	*/
40	private groupAndTransform(
41	entity: ObjectLiteral,
42	object: ObjectLiteral,
43	metadata: EntityMetadata,
44	getLazyRelationsPromiseValue: boolean = false,	×
45	): void {
46	// console.log("groupAndTransform entity:", entity);
47	// console.log("groupAndTransform object:", object);
48
49	// copy regular column properties from the given object
50	metadata.nonVirtualColumns.forEach((column) => {	92,774✔
51	const objectColumnValue = column.getEntityValue(object)	227,696✔
52	if (objectColumnValue !== undefined)	227,696✔
53	column.setEntityValue(entity, objectColumnValue)	37,878✔
54	})
55
56	// // copy relation properties from the given object
57	if (metadata.relations.length) {	92,774✔
58	metadata.relations.forEach((relation) => {	28,263✔
59	let entityRelatedValue = relation.getEntityValue(entity)	49,609✔
60	const objectRelatedValue = relation.getEntityValue(	49,609✔
61	object,
62	getLazyRelationsPromiseValue,
63	)
64	if (objectRelatedValue === undefined) return	49,609✔
65
66	if (relation.isOneToMany \|\| relation.isManyToMany) {	158✔
67	if (!Array.isArray(objectRelatedValue)) return	30!
68
69	if (!entityRelatedValue) {	30✔
70	entityRelatedValue = []	22✔
71	relation.setEntityValue(entity, entityRelatedValue)	22✔
72	}
73
74	objectRelatedValue.forEach((objectRelatedValueItem) => {	30✔
75	// check if we have this item from the merging object in the original entity we merge into
76	let objectRelatedValueEntity = (
77	entityRelatedValue as any[]	44✔
78	).find((entityRelatedValueItem) => {
79	return relation.inverseEntityMetadata.compareEntities(	34✔
80	objectRelatedValueItem,
81	entityRelatedValueItem,
82	)
83	})
84
85	const inverseEntityMetadata =
86	relation.inverseEntityMetadata.findInheritanceMetadata(	44✔
87	objectRelatedValueItem,
88	)
89
90	// 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
91	if (!objectRelatedValueEntity) {	44✔
92	objectRelatedValueEntity =	32✔
93	inverseEntityMetadata.create(undefined, {
94	fromDeserializer: true,
95	})
96	entityRelatedValue.push(objectRelatedValueEntity)	32✔
97	}
98
99	this.groupAndTransform(	44✔
100	objectRelatedValueEntity,
101	objectRelatedValueItem,
102	inverseEntityMetadata,
103	getLazyRelationsPromiseValue,
104	)
105	})
106	} else {
107	// if related object isn't an object (direct relation id for example)
108	// we just set it to the entity relation, we don't need anything more from it
109	// however we do it only if original entity does not have this relation set to object
110	// to prevent full overriding of objects
111	if (!ObjectUtils.isObject(objectRelatedValue)) {	128!
112	if (!ObjectUtils.isObject(entityRelatedValue))	×
113	relation.setEntityValue(entity, objectRelatedValue)	×
114	return	×
115	}
116
117	const inverseEntityMetadata =
118	relation.inverseEntityMetadata.findInheritanceMetadata(	128✔
119	objectRelatedValue,
120	)
121
122	if (!entityRelatedValue) {	128✔
123	entityRelatedValue = inverseEntityMetadata.create(	128✔
124	undefined,
125	{
126	fromDeserializer: true,
127	},
128	)
129	relation.setEntityValue(entity, entityRelatedValue)	128✔
130	}
131
132	this.groupAndTransform(	128✔
133	entityRelatedValue,
134	objectRelatedValue,
135	inverseEntityMetadata,
136	getLazyRelationsPromiseValue,
137	)
138	}
139	})
140	}
141	}
142	}

typeorm / typeorm / 14796576772

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous