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

73.97

/src/metadata-args/MetadataArgsStorage.ts

import { RelationMetadataArgs } from "./RelationMetadataArgs"
import { ColumnMetadataArgs } from "./ColumnMetadataArgs"
import { RelationCountMetadataArgs } from "./RelationCountMetadataArgs"
import { IndexMetadataArgs } from "./IndexMetadataArgs"
import { EntityListenerMetadataArgs } from "./EntityListenerMetadataArgs"
import { TableMetadataArgs } from "./TableMetadataArgs"
import { NamingStrategyMetadataArgs } from "./NamingStrategyMetadataArgs"
import { JoinTableMetadataArgs } from "./JoinTableMetadataArgs"
import { JoinColumnMetadataArgs } from "./JoinColumnMetadataArgs"
import { EmbeddedMetadataArgs } from "./EmbeddedMetadataArgs"
import { EntitySubscriberMetadataArgs } from "./EntitySubscriberMetadataArgs"
import { RelationIdMetadataArgs } from "./RelationIdMetadataArgs"
import { InheritanceMetadataArgs } from "./InheritanceMetadataArgs"
import { DiscriminatorValueMetadataArgs } from "./DiscriminatorValueMetadataArgs"
import { EntityRepositoryMetadataArgs } from "./EntityRepositoryMetadataArgs"
import { TransactionEntityMetadataArgs } from "./TransactionEntityMetadataArgs"
import { TransactionRepositoryMetadataArgs } from "./TransactionRepositoryMetadataArgs"
import { MetadataUtils } from "../metadata-builder/MetadataUtils"
import { GeneratedMetadataArgs } from "./GeneratedMetadataArgs"
import { TreeMetadataArgs } from "./TreeMetadataArgs"
import { UniqueMetadataArgs } from "./UniqueMetadataArgs"
import { CheckMetadataArgs } from "./CheckMetadataArgs"
import { ExclusionMetadataArgs } from "./ExclusionMetadataArgs"
import { ForeignKeyMetadataArgs } from "./ForeignKeyMetadataArgs"

/**
 * Storage all metadatas args of all available types: tables, columns, subscribers, relations, etc.
 * Each metadata args represents some specifications of what it represents.
 * MetadataArgs used to create a real Metadata objects.
 */
export class MetadataArgsStorage {
    // -------------------------------------------------------------------------
    // Properties
    // -------------------------------------------------------------------------

    readonly tables: TableMetadataArgs[] = []
    readonly trees: TreeMetadataArgs[] = []
    readonly entityRepositories: EntityRepositoryMetadataArgs[] = []
    readonly transactionEntityManagers: TransactionEntityMetadataArgs[] = []
    readonly transactionRepositories: TransactionRepositoryMetadataArgs[] = []
    readonly namingStrategies: NamingStrategyMetadataArgs[] = []
    readonly entitySubscribers: EntitySubscriberMetadataArgs[] = []
    readonly indices: IndexMetadataArgs[] = []
    readonly foreignKeys: ForeignKeyMetadataArgs[] = []
    readonly uniques: UniqueMetadataArgs[] = []
    readonly checks: CheckMetadataArgs[] = []
    readonly exclusions: ExclusionMetadataArgs[] = []
    readonly columns: ColumnMetadataArgs[] = []
    readonly generations: GeneratedMetadataArgs[] = []
    readonly relations: RelationMetadataArgs[] = []
    readonly joinColumns: JoinColumnMetadataArgs[] = []
    readonly joinTables: JoinTableMetadataArgs[] = []
    readonly entityListeners: EntityListenerMetadataArgs[] = []
    readonly relationCounts: RelationCountMetadataArgs[] = []
    readonly relationIds: RelationIdMetadataArgs[] = []
    readonly embeddeds: EmbeddedMetadataArgs[] = []
    readonly inheritances: InheritanceMetadataArgs[] = []
    readonly discriminatorValues: DiscriminatorValueMetadataArgs[] = []

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

    filterTables(target: Function | string): TableMetadataArgs[]
    filterTables(target: (Function | string)[]): TableMetadataArgs[]
    filterTables(
        target: (Function | string) | (Function | string)[],
    ): TableMetadataArgs[] {
        return this.filterByTarget(this.tables, target)
    }

    filterColumns(target: Function | string): ColumnMetadataArgs[]
    filterColumns(target: (Function | string)[]): ColumnMetadataArgs[]
    filterColumns(
        target: (Function | string) | (Function | string)[],
    ): ColumnMetadataArgs[] {
        return this.filterByTargetAndWithoutDuplicateProperties(
            this.columns,
            target,
        )
    }

    findGenerated(
        target: Function | string,
        propertyName: string,
    ): GeneratedMetadataArgs | undefined
    findGenerated(
        target: (Function | string)[],
        propertyName: string,
    ): GeneratedMetadataArgs | undefined
    findGenerated(
        target: (Function | string) | (Function | string)[],
        propertyName: string,
    ): GeneratedMetadataArgs | undefined {
        return this.generations.find((generated) => {
            return (
                (Array.isArray(target)
                    ? target.indexOf(generated.target) !== -1
                    : generated.target === target) &&
                generated.propertyName === propertyName
            )
        })
    }

    findTree(
        target: (Function | string) | (Function | string)[],
    ): TreeMetadataArgs | undefined {
        return this.trees.find((tree) => {
            return Array.isArray(target)
                ? target.indexOf(tree.target) !== -1
                : tree.target === target
        })
    }

    filterRelations(target: Function | string): RelationMetadataArgs[]
    filterRelations(target: (Function | string)[]): RelationMetadataArgs[]
    filterRelations(
        target: (Function | string) | (Function | string)[],
    ): RelationMetadataArgs[] {
        return this.filterByTargetAndWithoutDuplicateRelationProperties(
            this.relations,
            target,
        )
    }

    filterRelationIds(target: Function | string): RelationIdMetadataArgs[]
    filterRelationIds(target: (Function | string)[]): RelationIdMetadataArgs[]
    filterRelationIds(
        target: (Function | string) | (Function | string)[],
    ): RelationIdMetadataArgs[] {
        return this.filterByTargetAndWithoutDuplicateProperties(
            this.relationIds,
            target,
        )
    }

    filterRelationCounts(target: Function | string): RelationCountMetadataArgs[]
    filterRelationCounts(
        target: (Function | string)[],
    ): RelationCountMetadataArgs[]
    filterRelationCounts(
        target: (Function | string) | (Function | string)[],
    ): RelationCountMetadataArgs[] {
        return this.filterByTargetAndWithoutDuplicateProperties(
            this.relationCounts,
            target,
        )
    }

    filterIndices(target: Function | string): IndexMetadataArgs[]
    filterIndices(target: (Function | string)[]): IndexMetadataArgs[]
    filterIndices(
        target: (Function | string) | (Function | string)[],
    ): IndexMetadataArgs[] {
        // todo: implement parent-entity overrides?
        return this.indices.filter((index) => {
            return Array.isArray(target)
                ? target.indexOf(index.target) !== -1
                : index.target === target
        })
    }

    filterForeignKeys(target: Function | string): ForeignKeyMetadataArgs[]
    filterForeignKeys(target: (Function | string)[]): ForeignKeyMetadataArgs[]
    filterForeignKeys(
        target: (Function | string) | (Function | string)[],
    ): ForeignKeyMetadataArgs[] {
        return this.foreignKeys.filter((foreignKey) => {
            return Array.isArray(target)
                ? target.indexOf(foreignKey.target) !== -1
                : foreignKey.target === target
        })
    }

    filterUniques(target: Function | string): UniqueMetadataArgs[]
    filterUniques(target: (Function | string)[]): UniqueMetadataArgs[]
    filterUniques(
        target: (Function | string) | (Function | string)[],
    ): UniqueMetadataArgs[] {
        return this.uniques.filter((unique) => {
            return Array.isArray(target)
                ? target.indexOf(unique.target) !== -1
                : unique.target === target
        })
    }

    filterChecks(target: Function | string): CheckMetadataArgs[]
    filterChecks(target: (Function | string)[]): CheckMetadataArgs[]
    filterChecks(
        target: (Function | string) | (Function | string)[],
    ): CheckMetadataArgs[] {
        return this.checks.filter((check) => {
            return Array.isArray(target)
                ? target.indexOf(check.target) !== -1
                : check.target === target
        })
    }

    filterExclusions(target: Function | string): ExclusionMetadataArgs[]
    filterExclusions(target: (Function | string)[]): ExclusionMetadataArgs[]
    filterExclusions(
        target: (Function | string) | (Function | string)[],
    ): ExclusionMetadataArgs[] {
        return this.exclusions.filter((exclusion) => {
            return Array.isArray(target)
                ? target.indexOf(exclusion.target) !== -1
                : exclusion.target === target
        })
    }

    filterListeners(target: Function | string): EntityListenerMetadataArgs[]
    filterListeners(target: (Function | string)[]): EntityListenerMetadataArgs[]
    filterListeners(
        target: (Function | string) | (Function | string)[],
    ): EntityListenerMetadataArgs[] {
        return this.filterByTarget(this.entityListeners, target)
    }

    filterEmbeddeds(target: Function | string): EmbeddedMetadataArgs[]
    filterEmbeddeds(target: (Function | string)[]): EmbeddedMetadataArgs[]
    filterEmbeddeds(
        target: (Function | string) | (Function | string)[],
    ): EmbeddedMetadataArgs[] {
        return this.filterByTargetAndWithoutDuplicateEmbeddedProperties(
            this.embeddeds,
            target,
        )
    }

    findJoinTable(
        target: Function | string,
        propertyName: string,
    ): JoinTableMetadataArgs | undefined {
        return this.joinTables.find((joinTable) => {
            return (
                joinTable.target === target &&
                joinTable.propertyName === propertyName
            )
        })
    }

    filterJoinColumns(
        target: Function | string,
        propertyName: string,
    ): JoinColumnMetadataArgs[] {
        // todo: implement parent-entity overrides?
        return this.joinColumns.filter((joinColumn) => {
            return (
                joinColumn.target === target &&
                joinColumn.propertyName === propertyName
            )
        })
    }

    filterSubscribers(target: Function | string): EntitySubscriberMetadataArgs[]
    filterSubscribers(
        target: (Function | string)[],
    ): EntitySubscriberMetadataArgs[]
    filterSubscribers(
        target: (Function | string) | (Function | string)[],
    ): EntitySubscriberMetadataArgs[] {
        return this.filterByTarget(this.entitySubscribers, target)
    }

    filterNamingStrategies(
        target: Function | string,
    ): NamingStrategyMetadataArgs[]
    filterNamingStrategies(
        target: (Function | string)[],
    ): NamingStrategyMetadataArgs[]
    filterNamingStrategies(
        target: (Function | string) | (Function | string)[],
    ): NamingStrategyMetadataArgs[] {
        return this.filterByTarget(this.namingStrategies, target)
    }

    filterTransactionEntityManagers(
        target: Function | string,
        propertyName: string,
    ): TransactionEntityMetadataArgs[] {
        return this.transactionEntityManagers.filter((transactionEm) => {
            return (
                (Array.isArray(target)
                    ? target.indexOf(transactionEm.target) !== -1
                    : transactionEm.target === target) &&
                transactionEm.methodName === propertyName
            )
        })
    }

    filterTransactionRepository(
        target: Function | string,
        propertyName: string,
    ): TransactionRepositoryMetadataArgs[] {
        return this.transactionRepositories.filter((transactionEm) => {
            return (
                (Array.isArray(target)
                    ? target.indexOf(transactionEm.target) !== -1
                    : transactionEm.target === target) &&
                transactionEm.methodName === propertyName
            )
        })
    }

    filterSingleTableChildren(target: Function | string): TableMetadataArgs[] {
        return this.tables.filter((table) => {
            return (
                typeof table.target === "function" &&
                typeof target === "function" &&
                MetadataUtils.isInherited(table.target, target) &&
                table.type === "entity-child"
            )
        })
    }

    findInheritanceType(
        target: Function | string,
    ): InheritanceMetadataArgs | undefined {
        return this.inheritances.find(
            (inheritance) => inheritance.target === target,
        )
    }

    findDiscriminatorValue(
        target: Function | string,
    ): DiscriminatorValueMetadataArgs | undefined {
        return this.discriminatorValues.find(
            (discriminatorValue) => discriminatorValue.target === target,
        )
    }

    // -------------------------------------------------------------------------
    // Protected Methods
    // -------------------------------------------------------------------------

    /**
     * Filters given array by a given target or targets.
     */
    protected filterByTarget<T extends { target: Function | string }>(
        array: T[],
        target: (Function | string) | (Function | string)[],
    ): T[] {
        return array.filter((table) => {
            return Array.isArray(target)
                ? target.indexOf(table.target) !== -1
                : table.target === target
        })
    }

    /**
     * Filters given array by a given target or targets and prevents duplicate property names.
     */
    protected filterByTargetAndWithoutDuplicateProperties<
        T extends { target: Function | string; propertyName: string },
    >(array: T[], target: (Function | string) | (Function | string)[]): T[] {
        const newArray: T[] = []
        array.forEach((item) => {
            const sameTarget = Array.isArray(target)
                ? target.indexOf(item.target) !== -1
                : item.target === target
            if (sameTarget) {
                if (
                    !newArray.find(
                        (newItem) => newItem.propertyName === item.propertyName,
                    )
                )
                    newArray.push(item)
            }
        })
        return newArray
    }

    /**
     * Filters given array by a given target or targets and prevents duplicate relation property names.
     */
    protected filterByTargetAndWithoutDuplicateRelationProperties<
        T extends RelationMetadataArgs,
    >(array: T[], target: (Function | string) | (Function | string)[]): T[] {
        const newArray: T[] = []
        array.forEach((item) => {
            const sameTarget = Array.isArray(target)
                ? target.indexOf(item.target) !== -1
                : item.target === target
            if (sameTarget) {
                const existingIndex = newArray.findIndex(
                    (newItem) => newItem.propertyName === item.propertyName,
                )
                if (
                    Array.isArray(target) &&
                    existingIndex !== -1 &&
                    target.indexOf(item.target) <
                        target.indexOf(newArray[existingIndex].target)
                ) {
                    const clone = Object.create(newArray[existingIndex])
                    clone.type = item.type
                    newArray[existingIndex] = clone
                } else if (existingIndex === -1) {
                    newArray.push(item)
                }
            }
        })
        return newArray
    }

    /**
     * Filters given array by a given target or targets and prevents duplicate embedded property names.
     */
    protected filterByTargetAndWithoutDuplicateEmbeddedProperties<
        T extends EmbeddedMetadataArgs,
    >(array: T[], target: (Function | string) | (Function | string)[]): T[] {
        const newArray: T[] = []
        array.forEach((item) => {
            const sameTarget = Array.isArray(target)
                ? target.indexOf(item.target) !== -1
                : item.target === target
            if (sameTarget) {
                const isDuplicateEmbeddedProperty = newArray.find(
                    (newItem: EmbeddedMetadataArgs): boolean =>
                        newItem.prefix === item.prefix &&
                        newItem.propertyName === item.propertyName,
                )
                if (!isDuplicateEmbeddedProperty) newArray.push(item)
            }
        })
        return newArray
    }
}

1	import { RelationMetadataArgs } from "./RelationMetadataArgs"
2	import { ColumnMetadataArgs } from "./ColumnMetadataArgs"
3	import { RelationCountMetadataArgs } from "./RelationCountMetadataArgs"
4	import { IndexMetadataArgs } from "./IndexMetadataArgs"
5	import { EntityListenerMetadataArgs } from "./EntityListenerMetadataArgs"
6	import { TableMetadataArgs } from "./TableMetadataArgs"
7	import { NamingStrategyMetadataArgs } from "./NamingStrategyMetadataArgs"
8	import { JoinTableMetadataArgs } from "./JoinTableMetadataArgs"
9	import { JoinColumnMetadataArgs } from "./JoinColumnMetadataArgs"
10	import { EmbeddedMetadataArgs } from "./EmbeddedMetadataArgs"
11	import { EntitySubscriberMetadataArgs } from "./EntitySubscriberMetadataArgs"
12	import { RelationIdMetadataArgs } from "./RelationIdMetadataArgs"
13	import { InheritanceMetadataArgs } from "./InheritanceMetadataArgs"
14	import { DiscriminatorValueMetadataArgs } from "./DiscriminatorValueMetadataArgs"
15	import { EntityRepositoryMetadataArgs } from "./EntityRepositoryMetadataArgs"
16	import { TransactionEntityMetadataArgs } from "./TransactionEntityMetadataArgs"
17	import { TransactionRepositoryMetadataArgs } from "./TransactionRepositoryMetadataArgs"
18	import { MetadataUtils } from "../metadata-builder/MetadataUtils"	1✔
19	import { GeneratedMetadataArgs } from "./GeneratedMetadataArgs"
20	import { TreeMetadataArgs } from "./TreeMetadataArgs"
21	import { UniqueMetadataArgs } from "./UniqueMetadataArgs"
22	import { CheckMetadataArgs } from "./CheckMetadataArgs"
23	import { ExclusionMetadataArgs } from "./ExclusionMetadataArgs"
24	import { ForeignKeyMetadataArgs } from "./ForeignKeyMetadataArgs"
25
26	/**
27	* Storage all metadatas args of all available types: tables, columns, subscribers, relations, etc.
28	* Each metadata args represents some specifications of what it represents.
29	* MetadataArgs used to create a real Metadata objects.
30	*/
31	export class MetadataArgsStorage {	1✔
32	// -------------------------------------------------------------------------
33	// Properties
34	// -------------------------------------------------------------------------
35
36	readonly tables: TableMetadataArgs[] = []	44✔
37	readonly trees: TreeMetadataArgs[] = []	44✔
38	readonly entityRepositories: EntityRepositoryMetadataArgs[] = []	44✔
39	readonly transactionEntityManagers: TransactionEntityMetadataArgs[] = []	44✔
40	readonly transactionRepositories: TransactionRepositoryMetadataArgs[] = []	44✔
41	readonly namingStrategies: NamingStrategyMetadataArgs[] = []	44✔
42	readonly entitySubscribers: EntitySubscriberMetadataArgs[] = []	44✔
43	readonly indices: IndexMetadataArgs[] = []	44✔
44	readonly foreignKeys: ForeignKeyMetadataArgs[] = []	44✔
45	readonly uniques: UniqueMetadataArgs[] = []	44✔
46	readonly checks: CheckMetadataArgs[] = []	44✔
47	readonly exclusions: ExclusionMetadataArgs[] = []	44✔
48	readonly columns: ColumnMetadataArgs[] = []	44✔
49	readonly generations: GeneratedMetadataArgs[] = []	44✔
50	readonly relations: RelationMetadataArgs[] = []	44✔
51	readonly joinColumns: JoinColumnMetadataArgs[] = []	44✔
52	readonly joinTables: JoinTableMetadataArgs[] = []	44✔
53	readonly entityListeners: EntityListenerMetadataArgs[] = []	44✔
54	readonly relationCounts: RelationCountMetadataArgs[] = []	44✔
55	readonly relationIds: RelationIdMetadataArgs[] = []	44✔
56	readonly embeddeds: EmbeddedMetadataArgs[] = []	44✔
57	readonly inheritances: InheritanceMetadataArgs[] = []	44✔
58	readonly discriminatorValues: DiscriminatorValueMetadataArgs[] = []	44✔
59
60	// -------------------------------------------------------------------------
61	// Public Methods
62	// -------------------------------------------------------------------------
63
64	filterTables(target: Function \| string): TableMetadataArgs[]
65	filterTables(target: (Function \| string)[]): TableMetadataArgs[]
66	filterTables(
67	target: (Function \| string) \| (Function \| string)[],
68	): TableMetadataArgs[] {
69	return this.filterByTarget(this.tables, target)	42✔
70	}
71
72	filterColumns(target: Function \| string): ColumnMetadataArgs[]
73	filterColumns(target: (Function \| string)[]): ColumnMetadataArgs[]
74	filterColumns(
75	target: (Function \| string) \| (Function \| string)[],
76	): ColumnMetadataArgs[] {
77	return this.filterByTargetAndWithoutDuplicateProperties(	67✔
78	this.columns,
79	target,
80	)
81	}
82
83	findGenerated(
84	target: Function \| string,
85	propertyName: string,
86	): GeneratedMetadataArgs \| undefined
87	findGenerated(
88	target: (Function \| string)[],
89	propertyName: string,
90	): GeneratedMetadataArgs \| undefined
91	findGenerated(
92	target: (Function \| string) \| (Function \| string)[],
93	propertyName: string,
94	): GeneratedMetadataArgs \| undefined {
95	return this.generations.find((generated) => {	180✔
96	return (	161,163✔
97	(Array.isArray(target)	322,363!
98	? target.indexOf(generated.target) !== -1
99	: generated.target === target) &&
100	generated.propertyName === propertyName
101	)
102	})
103	}
104
105	findTree(
106	target: (Function \| string) \| (Function \| string)[],
107	): TreeMetadataArgs \| undefined {
108	return this.trees.find((tree) => {	49✔
109	return Array.isArray(target)	1,692!
110	? target.indexOf(tree.target) !== -1
111	: tree.target === target
112	})
113	}
114
115	filterRelations(target: Function \| string): RelationMetadataArgs[]
116	filterRelations(target: (Function \| string)[]): RelationMetadataArgs[]
117	filterRelations(
118	target: (Function \| string) \| (Function \| string)[],
119	): RelationMetadataArgs[] {
120	return this.filterByTargetAndWithoutDuplicateRelationProperties(	67✔
121	this.relations,
122	target,
123	)
124	}
125
126	filterRelationIds(target: Function \| string): RelationIdMetadataArgs[]
127	filterRelationIds(target: (Function \| string)[]): RelationIdMetadataArgs[]
128	filterRelationIds(
129	target: (Function \| string) \| (Function \| string)[],
130	): RelationIdMetadataArgs[] {
131	return this.filterByTargetAndWithoutDuplicateProperties(	67✔
132	this.relationIds,
133	target,
134	)
135	}
136
137	filterRelationCounts(target: Function \| string): RelationCountMetadataArgs[]
138	filterRelationCounts(
139	target: (Function \| string)[],
140	): RelationCountMetadataArgs[]
141	filterRelationCounts(
142	target: (Function \| string) \| (Function \| string)[],
143	): RelationCountMetadataArgs[] {
144	return this.filterByTargetAndWithoutDuplicateProperties(	67✔
145	this.relationCounts,
146	target,
147	)
148	}
149
150	filterIndices(target: Function \| string): IndexMetadataArgs[]
151	filterIndices(target: (Function \| string)[]): IndexMetadataArgs[]
152	filterIndices(
153	target: (Function \| string) \| (Function \| string)[],
154	): IndexMetadataArgs[] {
155	// todo: implement parent-entity overrides?
156	return this.indices.filter((index) => {	67✔
157	return Array.isArray(target)	6,175!
158	? target.indexOf(index.target) !== -1
159	: index.target === target
160	})
161	}
162
163	filterForeignKeys(target: Function \| string): ForeignKeyMetadataArgs[]
164	filterForeignKeys(target: (Function \| string)[]): ForeignKeyMetadataArgs[]
165	filterForeignKeys(
166	target: (Function \| string) \| (Function \| string)[],
167	): ForeignKeyMetadataArgs[] {
168	return this.foreignKeys.filter((foreignKey) => {	51✔
169	return Array.isArray(target)	294!
170	? target.indexOf(foreignKey.target) !== -1
171	: foreignKey.target === target
172	})
173	}
174
175	filterUniques(target: Function \| string): UniqueMetadataArgs[]
176	filterUniques(target: (Function \| string)[]): UniqueMetadataArgs[]
177	filterUniques(
178	target: (Function \| string) \| (Function \| string)[],
179	): UniqueMetadataArgs[] {
180	return this.uniques.filter((unique) => {	67✔
181	return Array.isArray(target)	3,835!
182	? target.indexOf(unique.target) !== -1
183	: unique.target === target
184	})
185	}
186
187	filterChecks(target: Function \| string): CheckMetadataArgs[]
188	filterChecks(target: (Function \| string)[]): CheckMetadataArgs[]
189	filterChecks(
190	target: (Function \| string) \| (Function \| string)[],
191	): CheckMetadataArgs[] {
192	return this.checks.filter((check) => {	49✔
193	return Array.isArray(target)	188!
194	? target.indexOf(check.target) !== -1
195	: check.target === target
196	})
197	}
198
199	filterExclusions(target: Function \| string): ExclusionMetadataArgs[]
200	filterExclusions(target: (Function \| string)[]): ExclusionMetadataArgs[]
201	filterExclusions(
202	target: (Function \| string) \| (Function \| string)[],
203	): ExclusionMetadataArgs[] {
UNCOV 204	return this.exclusions.filter((exclusion) => {	×
UNCOV 205	return Array.isArray(target)	×
206	? target.indexOf(exclusion.target) !== -1
207	: exclusion.target === target
208	})
209	}
210
211	filterListeners(target: Function \| string): EntityListenerMetadataArgs[]
212	filterListeners(target: (Function \| string)[]): EntityListenerMetadataArgs[]
213	filterListeners(
214	target: (Function \| string) \| (Function \| string)[],
215	): EntityListenerMetadataArgs[] {
216	return this.filterByTarget(this.entityListeners, target)	67✔
217	}
218
219	filterEmbeddeds(target: Function \| string): EmbeddedMetadataArgs[]
220	filterEmbeddeds(target: (Function \| string)[]): EmbeddedMetadataArgs[]
221	filterEmbeddeds(
222	target: (Function \| string) \| (Function \| string)[],
223	): EmbeddedMetadataArgs[] {
224	return this.filterByTargetAndWithoutDuplicateEmbeddedProperties(	67✔
225	this.embeddeds,
226	target,
227	)
228	}
229
230	findJoinTable(
231	target: Function \| string,
232	propertyName: string,
233	): JoinTableMetadataArgs \| undefined {
234	return this.joinTables.find((joinTable) => {	3✔
235	return (	171✔
236	joinTable.target === target &&	173✔
237	joinTable.propertyName === propertyName
238	)
239	})
240	}
241
242	filterJoinColumns(
243	target: Function \| string,
244	propertyName: string,
245	): JoinColumnMetadataArgs[] {
246	// todo: implement parent-entity overrides?
247	return this.joinColumns.filter((joinColumn) => {	15✔
248	return (	3,285✔
249	joinColumn.target === target &&	3,301✔
250	joinColumn.propertyName === propertyName
251	)
252	})
253	}
254
255	filterSubscribers(target: Function \| string): EntitySubscriberMetadataArgs[]
256	filterSubscribers(
257	target: (Function \| string)[],
258	): EntitySubscriberMetadataArgs[]
259	filterSubscribers(
260	target: (Function \| string) \| (Function \| string)[],
261	): EntitySubscriberMetadataArgs[] {
262	return this.filterByTarget(this.entitySubscribers, target)	29✔
263	}
264
265	filterNamingStrategies(
266	target: Function \| string,
267	): NamingStrategyMetadataArgs[]
268	filterNamingStrategies(
269	target: (Function \| string)[],
270	): NamingStrategyMetadataArgs[]
271	filterNamingStrategies(
272	target: (Function \| string) \| (Function \| string)[],
273	): NamingStrategyMetadataArgs[] {
274	return this.filterByTarget(this.namingStrategies, target)	×
275	}
276
277	filterTransactionEntityManagers(
278	target: Function \| string,
279	propertyName: string,
280	): TransactionEntityMetadataArgs[] {
281	return this.transactionEntityManagers.filter((transactionEm) => {	×
282	return (	×
283	(Array.isArray(target)	×
284	? target.indexOf(transactionEm.target) !== -1
285	: transactionEm.target === target) &&
286	transactionEm.methodName === propertyName
287	)
288	})
289	}
290
291	filterTransactionRepository(
292	target: Function \| string,
293	propertyName: string,
294	): TransactionRepositoryMetadataArgs[] {
295	return this.transactionRepositories.filter((transactionEm) => {	×
296	return (	×
297	(Array.isArray(target)	×
298	? target.indexOf(transactionEm.target) !== -1
299	: transactionEm.target === target) &&
300	transactionEm.methodName === propertyName
301	)
302	})
303	}
304
305	filterSingleTableChildren(target: Function \| string): TableMetadataArgs[] {
UNCOV 306	return this.tables.filter((table) => {	×
UNCOV 307	return (	×
308	typeof table.target === "function" &&	×
309	typeof target === "function" &&
310	MetadataUtils.isInherited(table.target, target) &&
311	table.type === "entity-child"
312	)
313	})
314	}
315
316	findInheritanceType(
317	target: Function \| string,
318	): InheritanceMetadataArgs \| undefined {
319	return this.inheritances.find(	98✔
320	(inheritance) => inheritance.target === target,	2,914✔
321	)
322	}
323
324	findDiscriminatorValue(
325	target: Function \| string,
326	): DiscriminatorValueMetadataArgs \| undefined {
327	return this.discriminatorValues.find(	49✔
328	(discriminatorValue) => discriminatorValue.target === target,	1,222✔
329	)
330	}
331
332	// -------------------------------------------------------------------------
333	// Protected Methods
334	// -------------------------------------------------------------------------
335
336	/**
337	* Filters given array by a given target or targets.
338	*/
339	protected filterByTarget<T extends { target: Function \| string }>(
340	array: T[],
341	target: (Function \| string) \| (Function \| string)[],
342	): T[] {
343	return array.filter((table) => {	138✔
344	return Array.isArray(target)	62,750!
345	? target.indexOf(table.target) !== -1
346	: table.target === target
347	})
348	}
349
350	/**
351	* Filters given array by a given target or targets and prevents duplicate property names.
352	*/
353	protected filterByTargetAndWithoutDuplicateProperties<
354	T extends { target: Function \| string; propertyName: string },
355	>(array: T[], target: (Function \| string) \| (Function \| string)[]): T[] {
356	const newArray: T[] = []	201✔
357	array.forEach((item) => {	201✔
358	const sameTarget = Array.isArray(target)	292,265!
359	? target.indexOf(item.target) !== -1
360	: item.target === target
361	if (sameTarget) {	292,265✔
362	if (	171✔
363	!newArray.find(
364	(newItem) => newItem.propertyName === item.propertyName,	172✔
365	)
366	)
367	newArray.push(item)	169✔
368	}
369	})
370	return newArray	201✔
371	}
372
373	/**
374	* Filters given array by a given target or targets and prevents duplicate relation property names.
375	*/
376	protected filterByTargetAndWithoutDuplicateRelationProperties<
377	T extends RelationMetadataArgs,
378	>(array: T[], target: (Function \| string) \| (Function \| string)[]): T[] {
379	const newArray: T[] = []	67✔
380	array.forEach((item) => {	67✔
381	const sameTarget = Array.isArray(target)	61,685!
382	? target.indexOf(item.target) !== -1
383	: item.target === target
384	if (sameTarget) {	61,685✔
385	const existingIndex = newArray.findIndex(	19✔
386	(newItem) => newItem.propertyName === item.propertyName,	9✔
387	)
388	if (	19!
389	Array.isArray(target) &&	38!
390	existingIndex !== -1 &&
391	target.indexOf(item.target) <
392	target.indexOf(newArray[existingIndex].target)
393	) {
UNCOV 394	const clone = Object.create(newArray[existingIndex])	×
UNCOV 395	clone.type = item.type	×
UNCOV 396	newArray[existingIndex] = clone	×
397	} else if (existingIndex === -1) {	19✔
398	newArray.push(item)	19✔
399	}
400	}
401	})
402	return newArray	67✔
403	}
404
405	/**
406	* Filters given array by a given target or targets and prevents duplicate embedded property names.
407	*/
408	protected filterByTargetAndWithoutDuplicateEmbeddedProperties<
409	T extends EmbeddedMetadataArgs,
410	>(array: T[], target: (Function \| string) \| (Function \| string)[]): T[] {
411	const newArray: T[] = []	67✔
412	array.forEach((item) => {	67✔
413	const sameTarget = Array.isArray(target)	7,735!
414	? target.indexOf(item.target) !== -1
415	: item.target === target
416	if (sameTarget) {	7,735✔
417	const isDuplicateEmbeddedProperty = newArray.find(	18✔
418	(newItem: EmbeddedMetadataArgs): boolean =>
419	newItem.prefix === item.prefix &&	5✔
420	newItem.propertyName === item.propertyName,
421	)
422	if (!isDuplicateEmbeddedProperty) newArray.push(item)	18✔
423	}
424	})
425	return newArray	67✔
426	}
427	}

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