6447619094

Committed 08 Oct 2023 12:30PM CUT coverage: 96.667%. Remained the same

Build # 6447619094

Build Type

push

github

Committed by

renovate[bot]

Commit Message

chore(deps): update dependency @types/supertest to v2.0.14

Run Details

1796 of 1940 branches covered (0.0%)

Branch coverage included in aggregate %.

4962 of 5051 relevant lines covered (98.24%)

806.77 hits per line

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

84.44

/packages/core/src/common/reflect.utils.ts

import 'reflect-metadata';
import { Class } from './class.type';

export type MetaValue<MetaType> = MetaType | undefined;

type ClassDecoratorDataFunc<Data> = (data: Data) => ClassDecorator;
export const classMetadataDecorator =
  <Data>(key: string): ClassDecoratorDataFunc<Data> =>
  // eslint-disable-next-line @typescript-eslint/ban-types
  (data: Data) =>
  // eslint-disable-next-line @typescript-eslint/ban-types
  (target: Function): void => {
    Reflect.defineMetadata(key, data, target);
  };

export function getClassMetadata<DTO, Data>(
  DTOClass: Class<DTO>,
  key: string,
  includeParents: boolean,
): MetaValue<Data> {
  if (includeParents) {
    return Reflect.getMetadata(key, DTOClass) as MetaValue<Data>;
  }
  return Reflect.getOwnMetadata(key, DTOClass) as MetaValue<Data>;
}

abstract class Reflector {
  constructor(readonly metaKey: string) {}

  // eslint-disable-next-line @typescript-eslint/ban-types
  protected getMetadata<Data>(target: Function, includeParents: boolean): MetaValue<Data> {
    if (includeParents) {
      return Reflect.getMetadata(this.metaKey, target) as MetaValue<Data>;
    }
    return Reflect.getOwnMetadata(this.metaKey, target) as MetaValue<Data>;
  }

  // eslint-disable-next-line @typescript-eslint/ban-types
  protected defineMetadata<Data>(data: Data, target: Function): void {
    Reflect.defineMetadata(this.metaKey, data, target);
  }
}

export class ValueReflector extends Reflector {
  set<DTO, Data>(DTOClass: Class<DTO>, data: Data): void {
    this.defineMetadata(data, DTOClass);
  }

  get<DTO, Data>(DTOClass: Class<DTO>, includeParents = false): MetaValue<Data> {
    return this.getMetadata(DTOClass, includeParents);
  }

  isDefined<DTO>(DTOClass: Class<DTO>): boolean {
    return this.get(DTOClass) !== undefined;
  }

  memoize<DTO, Data>(DTOClass: Class<DTO>, fn: () => Data): Data {
    const existing = this.get<DTO, Data>(DTOClass);
    if (existing) {
      return existing;
    }
    const result = fn();
    this.set(DTOClass, result);
    return result;
  }
}

export class ArrayReflector extends Reflector {
  append<DTO, Data>(DTOClass: Class<DTO>, data: Data): void {
    const metadata = getClassMetadata<DTO, Data[]>(DTOClass, this.metaKey, false) ?? [];
    metadata.push(data);
    this.defineMetadata(metadata, DTOClass);
  }

  get<DTO, Data>(DTOClass: Class<DTO>, includeParents = false): MetaValue<Data[]> {
    return this.getMetadata(DTOClass, includeParents);
  }
}

export class MapReflector<K = string> extends Reflector {
  set<DTO, Data>(DTOClass: Class<DTO>, key: K, value: Data): void {
    const metadata = getClassMetadata<DTO, Map<K, Data>>(DTOClass, this.metaKey, false) ?? new Map<K, Data>();
    metadata.set(key, value);
    this.defineMetadata(metadata, DTOClass);
  }

  get<DTO, Data>(DTOClass: Class<DTO>, includeParents?: boolean): MetaValue<Map<K, Data>>;
  get<DTO, Data>(DTOClass: Class<DTO>, key: K, includeParents?: boolean): MetaValue<Data>;
  get<DTO, Data>(
    DTOClass: Class<DTO>,
    key: K | boolean | undefined,
    includeParents?: boolean,
  ): MetaValue<Data | Map<K, Data>> {
    if (typeof key === 'boolean' || typeof key === 'undefined') {
      return this.getMetadata<Map<K, Data>>(DTOClass, includeParents ?? false);
    }
    return this.getMetadata<Map<K, Data>>(DTOClass, includeParents ?? false)?.get(key);
  }

  getValues<DTO, Data>(DTOClass: Class<DTO>, includeParents = false): MetaValue<Data[]> {
    const values = this.getMetadata<Map<K, Data>>(DTOClass, includeParents)?.values();
    return values ? [...values] : undefined;
  }

  has<DTO>(DTOClass: Class<DTO>, key: K): boolean {
    return this.getMetadata<Map<K, unknown>>(DTOClass, false)?.has(key) ?? false;
  }

  memoize<DTO, Data>(DTOClass: Class<DTO>, key: K, fn: () => Data): Data {
    const existing = this.get<DTO, Data>(DTOClass, key);
    if (existing) {
      return existing;
    }
    const result = fn();
    this.set(DTOClass, key, result);
    return result;
  }
}

1	import 'reflect-metadata';	532✔
2	import { Class } from './class.type';
3
4	export type MetaValue<MetaType> = MetaType \| undefined;
5
6	type ClassDecoratorDataFunc<Data> = (data: Data) => ClassDecorator;
7	export const classMetadataDecorator =	532✔
8	<Data>(key: string): ClassDecoratorDataFunc<Data> =>	532✔
9	// eslint-disable-next-line @typescript-eslint/ban-types
10	(data: Data) =>	×
11	// eslint-disable-next-line @typescript-eslint/ban-types
12	(target: Function): void => {	×
13	Reflect.defineMetadata(key, data, target);	×
14	};
15
16	export function getClassMetadata<DTO, Data>(	532✔
17	DTOClass: Class<DTO>,
18	key: string,
19	includeParents: boolean,
20	): MetaValue<Data> {
21	if (includeParents) {	20,288✔
22	return Reflect.getMetadata(key, DTOClass) as MetaValue<Data>;	11,260✔
23	}
24	return Reflect.getOwnMetadata(key, DTOClass) as MetaValue<Data>;	9,028✔
25	}
26
27	abstract class Reflector {
28	constructor(readonly metaKey: string) {}	7,448✔
29
30	// eslint-disable-next-line @typescript-eslint/ban-types
31	protected getMetadata<Data>(target: Function, includeParents: boolean): MetaValue<Data> {
32	if (includeParents) {	62,156✔
33	return Reflect.getMetadata(this.metaKey, target) as MetaValue<Data>;	23,084✔
34	}
35	return Reflect.getOwnMetadata(this.metaKey, target) as MetaValue<Data>;	39,072✔
36	}
37
38	// eslint-disable-next-line @typescript-eslint/ban-types
39	protected defineMetadata<Data>(data: Data, target: Function): void {
40	Reflect.defineMetadata(this.metaKey, data, target);	11,336✔
41	}
42	}
43
44	export class ValueReflector extends Reflector {	532✔
45	set<DTO, Data>(DTOClass: Class<DTO>, data: Data): void {
46	this.defineMetadata(data, DTOClass);	2,308✔
47	}
48
49	get<DTO, Data>(DTOClass: Class<DTO>, includeParents = false): MetaValue<Data> {	10,416✔
50	return this.getMetadata(DTOClass, includeParents);	33,500✔
51	}
52
53	isDefined<DTO>(DTOClass: Class<DTO>): boolean {
54	return this.get(DTOClass) !== undefined;	348✔
55	}
56
57	memoize<DTO, Data>(DTOClass: Class<DTO>, fn: () => Data): Data {
58	const existing = this.get<DTO, Data>(DTOClass);	1,996✔
59	if (existing) {	1,996✔
60	return existing;	1,020✔
61	}
62	const result = fn();	976✔
63	this.set(DTOClass, result);	968✔
64	return result;	968✔
65	}
66	}
67
68	export class ArrayReflector extends Reflector {	532✔
69	append<DTO, Data>(DTOClass: Class<DTO>, data: Data): void {
70	const metadata = getClassMetadata<DTO, Data[]>(DTOClass, this.metaKey, false) ?? [];	4,924✔
71	metadata.push(data);	4,924✔
72	this.defineMetadata(metadata, DTOClass);	4,924✔
73	}
74
75	get<DTO, Data>(DTOClass: Class<DTO>, includeParents = false): MetaValue<Data[]> {	19,816✔
76	return this.getMetadata(DTOClass, includeParents);	19,816✔
77	}
78	}
79
80	export class MapReflector<K = string> extends Reflector {	532✔
81	set<DTO, Data>(DTOClass: Class<DTO>, key: K, value: Data): void {
82	const metadata = getClassMetadata<DTO, Map<K, Data>>(DTOClass, this.metaKey, false) ?? new Map<K, Data>();	4,104✔
83	metadata.set(key, value);	4,104✔
84	this.defineMetadata(metadata, DTOClass);	4,104✔
85	}
86
87	get<DTO, Data>(DTOClass: Class<DTO>, includeParents?: boolean): MetaValue<Map<K, Data>>;
88	get<DTO, Data>(DTOClass: Class<DTO>, key: K, includeParents?: boolean): MetaValue<Data>;
89	get<DTO, Data>(
90	DTOClass: Class<DTO>,
91	key: K \| boolean \| undefined,
92	includeParents?: boolean,
93	): MetaValue<Data \| Map<K, Data>> {
94	if (typeof key === 'boolean' \|\| typeof key === 'undefined') {	8,752✔
95	return this.getMetadata<Map<K, Data>>(DTOClass, includeParents ?? false);	1,972!
96	}
97	return this.getMetadata<Map<K, Data>>(DTOClass, includeParents ?? false)?.get(key);	6,780!
98	}
99
100	getValues<DTO, Data>(DTOClass: Class<DTO>, includeParents = false): MetaValue<Data[]> {	×
101	const values = this.getMetadata<Map<K, Data>>(DTOClass, includeParents)?.values();	×
102	return values ? [...values] : undefined;	×
103	}
104
105	has<DTO>(DTOClass: Class<DTO>, key: K): boolean {
106	return this.getMetadata<Map<K, unknown>>(DTOClass, false)?.has(key) ?? false;	88✔
107	}
108
109	memoize<DTO, Data>(DTOClass: Class<DTO>, key: K, fn: () => Data): Data {
110	const existing = this.get<DTO, Data>(DTOClass, key);	6,780✔
111	if (existing) {	6,780✔
112	return existing;	2,724✔
113	}
114	const result = fn();	4,056✔
115	this.set(DTOClass, key, result);	4,020✔
116	return result;	4,020✔
117	}
118	}

doug-martin / nestjs-query / 6447619094

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