15219332477

Committed 23 May 2025 09:13PM UTC coverage: 17.216% (-59.1%) from 76.346%

Build # 15219332477

Build Type

Pull #11332

github

Committed by

naorpeled

Commit Message

cr comments - move if block

Pull Request Pull Request #11332: feat: add new undefined and null behavior flags

Run Details

1603 of 12759 branches covered (12.56%)

Branch coverage included in aggregate %.

0 of 31 new or added lines in 3 files covered. (0.0%)

14132 existing lines in 166 files now uncovered.

4731 of 24033 relevant lines covered (19.69%)

60.22 hits per line

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

88.57

/src/connection/ConnectionMetadataBuilder.ts

import { importClassesFromDirectories } from "../util/DirectoryExportedClassesLoader"
import { OrmUtils } from "../util/OrmUtils"
import { getFromContainer } from "../container"
import { MigrationInterface } from "../migration/MigrationInterface"
import { getMetadataArgsStorage } from "../globals"
import { EntityMetadataBuilder } from "../metadata-builder/EntityMetadataBuilder"
import { EntitySchemaTransformer } from "../entity-schema/EntitySchemaTransformer"
import { DataSource } from "../data-source/DataSource"
import { EntitySchema } from "../entity-schema/EntitySchema"
import { EntityMetadata } from "../metadata/EntityMetadata"
import { EntitySubscriberInterface } from "../subscriber/EntitySubscriberInterface"
import { InstanceChecker } from "../util/InstanceChecker"

/**
 * Builds migration instances, subscriber instances and entity metadatas for the given classes.
 */
export class ConnectionMetadataBuilder {
    // -------------------------------------------------------------------------
    // Constructor
    // -------------------------------------------------------------------------

    constructor(protected connection: DataSource) {}

    // -------------------------------------------------------------------------
    // Public Methods
    // -------------------------------------------------------------------------

    /**
     * Builds migration instances for the given classes or directories.
     */
    async buildMigrations(
        migrations: (Function | string)[],
    ): Promise<MigrationInterface[]> {
        const [migrationClasses, migrationDirectories] =
            OrmUtils.splitClassesAndStrings(migrations)
        const allMigrationClasses = [
            ...migrationClasses,
            ...(await importClassesFromDirectories(
                this.connection.logger,
                migrationDirectories,
            )),
        ]
        return allMigrationClasses.map((migrationClass) =>
            getFromContainer<MigrationInterface>(migrationClass),
        )
    }

    /**
     * Builds subscriber instances for the given classes or directories.
     */
    async buildSubscribers(
        subscribers: (Function | string)[],
    ): Promise<EntitySubscriberInterface<any>[]> {
        const [subscriberClasses, subscriberDirectories] =
            OrmUtils.splitClassesAndStrings(subscribers || [])
        const allSubscriberClasses = [
            ...subscriberClasses,
            ...(await importClassesFromDirectories(
                this.connection.logger,
                subscriberDirectories,
            )),
        ]
        return getMetadataArgsStorage()
            .filterSubscribers(allSubscriberClasses)
            .map((metadata) =>
                getFromContainer<EntitySubscriberInterface<any>>(
                    metadata.target,
                ),
            )
    }

    /**
     * Builds entity metadatas for the given classes or directories.
     */
    async buildEntityMetadatas(
        entities: (Function | EntitySchema<any> | string)[],
    ): Promise<EntityMetadata[]> {
        // todo: instead we need to merge multiple metadata args storages

        const [entityClassesOrSchemas, entityDirectories] =
            OrmUtils.splitClassesAndStrings(entities || [])
        const entityClasses: Function[] = entityClassesOrSchemas.filter(
            (entityClass) => !InstanceChecker.isEntitySchema(entityClass),
        ) as any
        const entitySchemas: EntitySchema<any>[] =
            entityClassesOrSchemas.filter((entityClass) =>
                InstanceChecker.isEntitySchema(entityClass),
            ) as any

        const allEntityClasses = [
            ...entityClasses,
            ...(await importClassesFromDirectories(
                this.connection.logger,
                entityDirectories,
            )),
        ]
        allEntityClasses.forEach((entityClass) => {
            // if we have entity schemas loaded from directories
            if (InstanceChecker.isEntitySchema(entityClass)) {
                entitySchemas.push(entityClass)
            }
        })
        const decoratorEntityMetadatas = new EntityMetadataBuilder(
            this.connection,
            getMetadataArgsStorage(),
        ).build(allEntityClasses)

        const metadataArgsStorageFromSchema =
            new EntitySchemaTransformer().transform(entitySchemas)
        const schemaEntityMetadatas = new EntityMetadataBuilder(
            this.connection,
            metadataArgsStorageFromSchema,
        ).build()

        return [...decoratorEntityMetadatas, ...schemaEntityMetadatas]
    }
}

1	import { importClassesFromDirectories } from "../util/DirectoryExportedClassesLoader"	1✔
2	import { OrmUtils } from "../util/OrmUtils"	1✔
3	import { getFromContainer } from "../container"	1✔
4	import { MigrationInterface } from "../migration/MigrationInterface"
5	import { getMetadataArgsStorage } from "../globals"	1✔
6	import { EntityMetadataBuilder } from "../metadata-builder/EntityMetadataBuilder"	1✔
7	import { EntitySchemaTransformer } from "../entity-schema/EntitySchemaTransformer"	1✔
8	import { DataSource } from "../data-source/DataSource"
9	import { EntitySchema } from "../entity-schema/EntitySchema"
10	import { EntityMetadata } from "../metadata/EntityMetadata"
11	import { EntitySubscriberInterface } from "../subscriber/EntitySubscriberInterface"
12	import { InstanceChecker } from "../util/InstanceChecker"	1✔
13
14	/**
15	* Builds migration instances, subscriber instances and entity metadatas for the given classes.
16	*/
17	export class ConnectionMetadataBuilder {	1✔
18	// -------------------------------------------------------------------------
19	// Constructor
20	// -------------------------------------------------------------------------
21
22	constructor(protected connection: DataSource) {}	42✔
23
24	// -------------------------------------------------------------------------
25	// Public Methods
26	// -------------------------------------------------------------------------
27
28	/**
29	* Builds migration instances for the given classes or directories.
30	*/
31	async buildMigrations(
32	migrations: (Function \| string)[],
33	): Promise<MigrationInterface[]> {
34	const [migrationClasses, migrationDirectories] =
35	OrmUtils.splitClassesAndStrings(migrations)	29✔
36	const allMigrationClasses = [	29✔
37	...migrationClasses,
38	...(await importClassesFromDirectories(
39	this.connection.logger,
40	migrationDirectories,
41	)),
42	]
43	return allMigrationClasses.map((migrationClass) =>	29✔
44	getFromContainer<MigrationInterface>(migrationClass),	2✔
45	)
46	}
47
48	/**
49	* Builds subscriber instances for the given classes or directories.
50	*/
51	async buildSubscribers(
52	subscribers: (Function \| string)[],
53	): Promise<EntitySubscriberInterface<any>[]> {
54	const [subscriberClasses, subscriberDirectories] =
55	OrmUtils.splitClassesAndStrings(subscribers \|\| [])	29!
56	const allSubscriberClasses = [	29✔
57	...subscriberClasses,
58	...(await importClassesFromDirectories(
59	this.connection.logger,
60	subscriberDirectories,
61	)),
62	]
63	return getMetadataArgsStorage()	29✔
64	.filterSubscribers(allSubscriberClasses)
65	.map((metadata) =>
66	getFromContainer<EntitySubscriberInterface<any>>(	1✔
67	metadata.target,
68	),
69	)
70	}
71
72	/**
73	* Builds entity metadatas for the given classes or directories.
74	*/
75	async buildEntityMetadatas(
76	entities: (Function \| EntitySchema<any> \| string)[],
77	): Promise<EntityMetadata[]> {
78	// todo: instead we need to merge multiple metadata args storages
79
80	const [entityClassesOrSchemas, entityDirectories] =
81	OrmUtils.splitClassesAndStrings(entities \|\| [])	42!
82	const entityClasses: Function[] = entityClassesOrSchemas.filter(	42✔
83	(entityClass) => !InstanceChecker.isEntitySchema(entityClass),	33✔
84	) as any
85	const entitySchemas: EntitySchema<any>[] =
86	entityClassesOrSchemas.filter((entityClass) =>	42✔
87	InstanceChecker.isEntitySchema(entityClass),	33✔
88	) as any
89
90	const allEntityClasses = [	42✔
91	...entityClasses,
92	...(await importClassesFromDirectories(
93	this.connection.logger,
94	entityDirectories,
95	)),
96	]
97	allEntityClasses.forEach((entityClass) => {	42✔
98	// if we have entity schemas loaded from directories
99	if (InstanceChecker.isEntitySchema(entityClass)) {	56!
UNCOV 100	entitySchemas.push(entityClass)	×
101	}
102	})
103	const decoratorEntityMetadatas = new EntityMetadataBuilder(	42✔
104	this.connection,
105	getMetadataArgsStorage(),
106	).build(allEntityClasses)
107
108	const metadataArgsStorageFromSchema =
109	new EntitySchemaTransformer().transform(entitySchemas)	42✔
110	const schemaEntityMetadatas = new EntityMetadataBuilder(	42✔
111	this.connection,
112	metadataArgsStorageFromSchema,
113	).build()
114
115	return [...decoratorEntityMetadatas, ...schemaEntityMetadatas]	42✔
116	}
117	}

typeorm / typeorm / 15219332477

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