4626431064

Build Type

push

github

Committed by GitHub

Commit Message

Merge pull request #38 from 5-stones/feat/typeorm-upgrade

Run Details

36 of 63 branches covered (57.14%)

Branch coverage included in aggregate %.

21 of 27 new or added lines in 4 files covered. (77.78%)

1 existing line in 1 file now uncovered.

127 of 149 relevant lines covered (85.23%)

4.5 hits per line

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

75.95

/src/polymorphic.repository.ts

import 'reflect-metadata';
import {
  DataSource,
  DeepPartial,
  FindManyOptions,
  FindOneOptions,
  getMetadataArgsStorage,
  ObjectLiteral,
  Repository,
  SaveOptions,
} from 'typeorm';
import { POLYMORPHIC_KEY_SEPARATOR, POLYMORPHIC_OPTIONS } from './constants';
import {
  PolymorphicChildType,
  PolymorphicParentType,
  PolymorphicChildInterface,
  PolymorphicOptionsType,
  PolymorphicMetadataInterface,
  PolymorphicMetadataOptionsInterface,
} from './polymorphic.interface';
import { EntityRepositoryMetadataArgs } from 'typeorm/metadata-args/EntityRepositoryMetadataArgs';
import { RepositoryNotFoundException } from './repository.token.exception';
import { POLYMORPHIC_REPOSITORY } from './constants';

type PolymorphicHydrationType = {
  key: string;
  type: 'children' | 'parent';
  values: PolymorphicChildInterface[] | PolymorphicChildInterface;
};

const entityTypeColumn = (options: PolymorphicMetadataInterface): string =>
  options.entityTypeColumn || 'entityType';
const entityIdColumn = (options: PolymorphicMetadataInterface): string =>
  options.entityTypeId || 'entityId';
const PrimaryColumn = (options: PolymorphicMetadataInterface): string =>
  options.primaryColumn || 'id';

export abstract class AbstractPolymorphicRepository<
  E extends ObjectLiteral,
> extends Repository<E> {
  public static createRepository(
    ds: DataSource,
    repository: new (...args: any[]) => any,
  ) {
    const entity = Reflect.getMetadata(POLYMORPHIC_REPOSITORY, repository);
    const baseRepository = ds.getRepository<any>(entity);
    return new repository(
      baseRepository.target,
      baseRepository.manager,
      baseRepository.queryRunner,
    );
  }

  private getPolymorphicMetadata(): Array<PolymorphicMetadataInterface> {
    const keys = Reflect.getMetadataKeys(
      (this.metadata.target as Function)['prototype'],
    );

    if (!keys) {
      return [];
    }

    return keys.reduce<Array<PolymorphicMetadataInterface>>(
      (keys: PolymorphicMetadataInterface[], key: string) => {
        if (key.split(POLYMORPHIC_KEY_SEPARATOR)[0] === POLYMORPHIC_OPTIONS) {
          const data: PolymorphicMetadataOptionsInterface & {
            propertyKey: string;
          } = Reflect.getMetadata(
            key,
            (this.metadata.target as Function)['prototype'],
          );

          if (data && typeof data === 'object') {
            const classType = data.classType();
            keys.push({
              ...data,
              classType,
            });
          }
        }

        return keys;
      },
      [],
    );
  }

  protected isPolymorph(): boolean {
    return Reflect.hasOwnMetadata(
      POLYMORPHIC_OPTIONS,
      (this.metadata.target as Function)['prototype'],
    );
  }

  protected isChildren(
    options: PolymorphicChildType | PolymorphicParentType,
  ): options is PolymorphicChildType {
    return options.type === 'children';
  }

  protected isParent(
    options: PolymorphicChildType | PolymorphicParentType,
  ): options is PolymorphicParentType {
    return options.type === 'parent';
  }

  public async hydrateMany(entities: E[]): Promise<E[]> {
    return Promise.all(entities.map((ent) => this.hydrateOne(ent)));
  }

  public async hydrateOne(entity: E): Promise<E> {
    const metadata = this.getPolymorphicMetadata();

    return this.hydratePolymorphs(entity, metadata);
  }

  private async hydratePolymorphs(
    entity: E,
    options: PolymorphicMetadataInterface[],
  ): Promise<E> {
    const values = await Promise.all(
      options.map((option: PolymorphicMetadataInterface) =>
        this.hydrateEntities(entity, option),
      ),
    );

    return values.reduce<E>((e: E, vals: PolymorphicHydrationType) => {
      const values =
        vals.type === 'parent' && Array.isArray(vals.values)
          ? vals.values.filter((v) => typeof v !== 'undefined' && v !== null)
          : vals.values;
      const polys =
        vals.type === 'parent' && Array.isArray(values) ? values[0] : values; // TODO should be condition for !hasMany
      type EntityKey = keyof E;
      const key = vals.key as EntityKey;
      e[key] = polys as (typeof e)[typeof key];

      return e;
    }, entity);
  }

  private async hydrateEntities(
    entity: E,
    options: PolymorphicMetadataInterface,
  ): Promise<PolymorphicHydrationType> {
    const entityTypes: (Function | string)[] =
      options.type === 'parent'
        ? [entity[entityTypeColumn(options)]]
        : Array.isArray(options.classType)
        ? options.classType
        : [options.classType];

    // TODO if not hasMany, should I return if one is found?
    const results = await Promise.all(
      entityTypes.map((type: Function) =>
        this.findPolymorphs(entity, type, options),
      ),
    );

    return {
      key: options.propertyKey,
      type: options.type,
      values: (options.hasMany &&
      Array.isArray(results) &&
      results.length > 0 &&
      Array.isArray(results[0])
        ? results.reduce<PolymorphicChildInterface[]>(
            (
              resultEntities: PolymorphicChildInterface[],
              entities: PolymorphicChildInterface[],
            ) => entities.concat(...resultEntities),
            results as PolymorphicChildInterface[],
          )
        : results) as PolymorphicChildInterface | PolymorphicChildInterface[],
    };
  }

  private async findPolymorphs(
    parent: E,
    entityType: Function,
    options: PolymorphicMetadataInterface,
  ): Promise<PolymorphicChildInterface[] | PolymorphicChildInterface | never> {
    const repository = this.findRepository(entityType);

    return repository[options.hasMany ? 'find' : 'findOne'](
      options.type === 'parent'
        ? {
            where: {
              // TODO: Not sure about this change (key was just id before)
              [PrimaryColumn(options)]: parent[entityIdColumn(options)],
            },
          }
        : {
            where: {
              [entityIdColumn(options)]: parent[PrimaryColumn(options)],
              [entityTypeColumn(options)]: entityType,
            },
          },
    );
  }

  private findRepository(
    entityType: Function,
  ): Repository<PolymorphicChildInterface | never> {
    const repositoryToken = this.resolveRepositoryToken(entityType);

    const repository: Repository<PolymorphicChildInterface> =
      repositoryToken !== entityType
        ? this.manager.getCustomRepository(repositoryToken)
        : this.manager.getRepository(repositoryToken);

    if (!repository) {
      throw new RepositoryNotFoundException(repositoryToken);
    }

    return repository;
  }

  private resolveRepositoryToken(token: Function): Function | never {
    const tokens = getMetadataArgsStorage().entityRepositories.filter(
      (value: EntityRepositoryMetadataArgs) => value.entity === token,
    );
    return tokens[0] ? tokens[0].target : token;
  }

  save<T extends DeepPartial<E>>(
    entities: T[],
    options: SaveOptions & {
      reload: false;
    },
  ): Promise<T[]>;

  save<T extends DeepPartial<E>>(
    entities: T[],
    options?: SaveOptions,
  ): Promise<(T & E)[]>;

  save<T extends DeepPartial<E>>(
    entity: T,
    options?: SaveOptions & {
      reload: false;
    },
  ): Promise<T>;

  public async save<T extends DeepPartial<E>>(
    entityOrEntities: T | Array<T>,
    options?: SaveOptions & { reload: false },
  ): Promise<(T & E) | Array<T & E> | T | Array<T>> {
    if (!this.isPolymorph()) {
      return Array.isArray(entityOrEntities)
        ? super.save(entityOrEntities, options)
        : super.save(entityOrEntities, options);
    }

    const metadata = this.getPolymorphicMetadata();

    metadata.map((options: PolymorphicOptionsType) => {
      if (this.isParent(options)) {
        (Array.isArray(entityOrEntities)
          ? entityOrEntities
          : [entityOrEntities]
        ).map((entity: E | DeepPartial<E>) => {
          const parent = entity[options.propertyKey];

          if (!parent || entity[entityIdColumn(options)] !== undefined) {
            return entity;
          }

          /**
           * Add parent's id and type to child's id and type field
           */
          type EntityKey = keyof DeepPartial<E>;
          entity[entityIdColumn(options) as EntityKey] =
            parent[PrimaryColumn(options)];
          entity[entityTypeColumn(options) as EntityKey] =
            parent.constructor.name;
          return entity;
        });
      }
    });

    /**
     * Check deleteBeforeUpdate
     */
    Array.isArray(entityOrEntities)
      ? await Promise.all(
          (entityOrEntities as Array<T>).map((entity) =>
            this.deletePolymorphs(entity, metadata),
          ),
        )
      : await this.deletePolymorphs(entityOrEntities as T, metadata);

    return Array.isArray(entityOrEntities)
      ? super.save(entityOrEntities, options)
      : super.save(entityOrEntities, options);
  }

  private async deletePolymorphs(
    entity: DeepPartial<E>,
    options: PolymorphicMetadataInterface[],
  ): Promise<void | never> {
    await Promise.all(
      options.map(
        (option: PolymorphicMetadataInterface) =>
          new Promise((resolve) => {
            if (!option.deleteBeforeUpdate) {
              resolve(Promise.resolve());
            }

            const entityTypes = Array.isArray(option.classType)
              ? option.classType
              : [option.classType];

            // resolve to singular query?
            resolve(
              Promise.all(
                entityTypes.map((type: () => Function | Function[]) => {
                  const repository = this.findRepository(type);

                  repository.delete({
                    [entityTypeColumn(option)]: type,
                    [entityIdColumn(option)]: entity[PrimaryColumn(option)],
                  });
                }),
              ),
            );
          }),
      ),
    );
  }

  public async find(options?: FindManyOptions<E>): Promise<E[]> {
    const results = await super.find(options);

    if (!this.isPolymorph()) {
      return results;
    }

    const metadata = this.getPolymorphicMetadata();

    return Promise.all(
      results.map((entity) => this.hydratePolymorphs(entity, metadata)),
    );
  }

  public async findOne(options?: FindOneOptions<E>): Promise<E | null> {
    const polymorphicMetadata = this.getPolymorphicMetadata();

    if (Object.keys(polymorphicMetadata).length === 0) {
      return super.findOne(options);
    }

    const entity = await super.findOne(options);

    if (!entity) {
      return entity;
    }

    return this.hydratePolymorphs(entity, polymorphicMetadata);
  }

  create(): E;

  create(entityLikeArray: DeepPartial<E>[]): E[];

  create(entityLike: DeepPartial<E>): E;

  create(
    plainEntityLikeOrPlainEntityLikes?: DeepPartial<E> | DeepPartial<E>[],
  ): E | E[] {
    const metadata = this.getPolymorphicMetadata();
    const entity = super.create(plainEntityLikeOrPlainEntityLikes as any);
    if (!metadata) {
      return entity;
    }
    metadata.forEach((value: PolymorphicOptionsType) => {
      entity[value.propertyKey] =
        plainEntityLikeOrPlainEntityLikes[value.propertyKey];
    });

    return entity;
  }

  /// TODO implement remove and have an option to delete children/parent
}

1	import 'reflect-metadata';	1✔
2	import {	1✔
3	DataSource,
4	DeepPartial,
5	FindManyOptions,
6	FindOneOptions,
7	getMetadataArgsStorage,
8	ObjectLiteral,
9	Repository,
10	SaveOptions,
11	} from 'typeorm';
12	import { POLYMORPHIC_KEY_SEPARATOR, POLYMORPHIC_OPTIONS } from './constants';	1✔
13	import {
14	PolymorphicChildType,
15	PolymorphicParentType,
16	PolymorphicChildInterface,
17	PolymorphicOptionsType,
18	PolymorphicMetadataInterface,
19	PolymorphicMetadataOptionsInterface,
20	} from './polymorphic.interface';
21	import { EntityRepositoryMetadataArgs } from 'typeorm/metadata-args/EntityRepositoryMetadataArgs';
22	import { RepositoryNotFoundException } from './repository.token.exception';	1✔
23	import { POLYMORPHIC_REPOSITORY } from './constants';	1✔
24
25	type PolymorphicHydrationType = {
26	key: string;
27	type: 'children' \| 'parent';
28	values: PolymorphicChildInterface[] \| PolymorphicChildInterface;
29	};
30
31	const entityTypeColumn = (options: PolymorphicMetadataInterface): string =>	1✔
32	options.entityTypeColumn \|\| 'entityType';	19✔
33	const entityIdColumn = (options: PolymorphicMetadataInterface): string =>	1✔
34	options.entityTypeId \|\| 'entityId';	25✔
35	const PrimaryColumn = (options: PolymorphicMetadataInterface): string =>	1✔
36	options.primaryColumn \|\| 'id';	19✔
37
38	export abstract class AbstractPolymorphicRepository<	1✔
39	E extends ObjectLiteral,
40	> extends Repository<E> {
41	public static createRepository(
42	ds: DataSource,
43	repository: new (...args: any[]) => any,
44	) {
45	const entity = Reflect.getMetadata(POLYMORPHIC_REPOSITORY, repository);	5✔
46	const baseRepository = ds.getRepository<any>(entity);	5✔
47	return new repository(	5✔
48	baseRepository.target,
49	baseRepository.manager,
50	baseRepository.queryRunner,
51	);
52	}
53
54	private getPolymorphicMetadata(): Array<PolymorphicMetadataInterface> {
55	const keys = Reflect.getMetadataKeys(	13✔
56	(this.metadata.target as Function)['prototype'],
57	);
58
59	if (!keys) {	13!
60	return [];	×
61	}
62
63	return keys.reduce<Array<PolymorphicMetadataInterface>>(	13✔
64	(keys: PolymorphicMetadataInterface[], key: string) => {
65	if (key.split(POLYMORPHIC_KEY_SEPARATOR)[0] === POLYMORPHIC_OPTIONS) {	26✔
66	const data: PolymorphicMetadataOptionsInterface & {
67	propertyKey: string;
68	} = Reflect.getMetadata(	26✔
69	key,
70	(this.metadata.target as Function)['prototype'],
71	);
72
73	if (data && typeof data === 'object') {	26✔
74	const classType = data.classType();	13✔
75	keys.push({	13✔
76	...data,
77	classType,
78	});
79	}
80	}
81
82	return keys;	26✔
83	},
84	[],
85	);
86	}
87
88	protected isPolymorph(): boolean {
89	return Reflect.hasOwnMetadata(	5✔
90	POLYMORPHIC_OPTIONS,
91	(this.metadata.target as Function)['prototype'],
92	);
93	}
94
95	protected isChildren(
96	options: PolymorphicChildType \| PolymorphicParentType,
97	): options is PolymorphicChildType {
98	return options.type === 'children';	×
99	}
100
101	protected isParent(
102	options: PolymorphicChildType \| PolymorphicParentType,
103	): options is PolymorphicParentType {
104	return options.type === 'parent';	4✔
105	}
106
107	public async hydrateMany(entities: E[]): Promise<E[]> {
108	return Promise.all(entities.map((ent) => this.hydrateOne(ent)));	×
109	}
110
111	public async hydrateOne(entity: E): Promise<E> {
112	const metadata = this.getPolymorphicMetadata();	×
113
114	return this.hydratePolymorphs(entity, metadata);	×
115	}
116
117	private async hydratePolymorphs(
118	entity: E,
119	options: PolymorphicMetadataInterface[],
120	): Promise<E> {
121	const values = await Promise.all(	7✔
122	options.map((option: PolymorphicMetadataInterface) =>
123	this.hydrateEntities(entity, option),	7✔
124	),
125	);
126
127	return values.reduce<E>((e: E, vals: PolymorphicHydrationType) => {	7✔
128	const values =
129	vals.type === 'parent' && Array.isArray(vals.values)	7!
130	? vals.values.filter((v) => typeof v !== 'undefined' && v !== null)	7✔
131	: vals.values;
132	const polys =
133	vals.type === 'parent' && Array.isArray(values) ? values[0] : values; // TODO should be condition for !hasMany	7!
134	type EntityKey = keyof E;
135	const key = vals.key as EntityKey;	7✔
136	e[key] = polys as (typeof e)[typeof key];	7✔
137
138	return e;	7✔
139	}, entity);
140	}
141
142	private async hydrateEntities(
143	entity: E,
144	options: PolymorphicMetadataInterface,
145	): Promise<PolymorphicHydrationType> {
146	const entityTypes: (Function \| string)[] =
147	options.type === 'parent'	7!
148	? [entity[entityTypeColumn(options)]]
149	: Array.isArray(options.classType)	×
150	? options.classType
151	: [options.classType];
152
153	// TODO if not hasMany, should I return if one is found?
154	const results = await Promise.all(	7✔
155	entityTypes.map((type: Function) =>
156	this.findPolymorphs(entity, type, options),	7✔
157	),
158	);
159
160	return {	7✔
161	key: options.propertyKey,
162	type: options.type,
163	values: (options.hasMany &&	14!
164	Array.isArray(results) &&
165	results.length > 0 &&
166	Array.isArray(results[0])
167	? results.reduce<PolymorphicChildInterface[]>(
168	(
169	resultEntities: PolymorphicChildInterface[],
170	entities: PolymorphicChildInterface[],
171	) => entities.concat(...resultEntities),	×
172	results as PolymorphicChildInterface[],
173	)
174	: results) as PolymorphicChildInterface \| PolymorphicChildInterface[],
175	};
176	}
177
178	private async findPolymorphs(
179	parent: E,
180	entityType: Function,
181	options: PolymorphicMetadataInterface,
182	): Promise<PolymorphicChildInterface[] \| PolymorphicChildInterface \| never> {
183	const repository = this.findRepository(entityType);	7✔
184
185	return repository[options.hasMany ? 'find' : 'findOne'](	7!
186	options.type === 'parent'	7!
187	? {
188	where: {
189	// TODO: Not sure about this change (key was just id before)
190	[PrimaryColumn(options)]: parent[entityIdColumn(options)],
191	},
192	}
193	: {
194	where: {
195	[entityIdColumn(options)]: parent[PrimaryColumn(options)],
196	[entityTypeColumn(options)]: entityType,
197	},
198	},
199	);
200	}
201
202	private findRepository(
203	entityType: Function,
204	): Repository<PolymorphicChildInterface \| never> {
205	const repositoryToken = this.resolveRepositoryToken(entityType);	13✔
206
207	const repository: Repository<PolymorphicChildInterface> =
208	repositoryToken !== entityType	13!
209	? this.manager.getCustomRepository(repositoryToken)
210	: this.manager.getRepository(repositoryToken);
211
212	if (!repository) {	13!
213	throw new RepositoryNotFoundException(repositoryToken);	×
214	}
215
216	return repository;	13✔
217	}
218
219	private resolveRepositoryToken(token: Function): Function \| never {
220	const tokens = getMetadataArgsStorage().entityRepositories.filter(	13✔
UNCOV 221	(value: EntityRepositoryMetadataArgs) => value.entity === token,	×
222	);
223	return tokens[0] ? tokens[0].target : token;	13!
224	}
225
226	save<T extends DeepPartial<E>>(
227	entities: T[],
228	options: SaveOptions & {
229	reload: false;
230	},
231	): Promise<T[]>;
232
233	save<T extends DeepPartial<E>>(
234	entities: T[],
235	options?: SaveOptions,
236	): Promise<(T & E)[]>;
237
238	save<T extends DeepPartial<E>>(
239	entity: T,
240	options?: SaveOptions & {
241	reload: false;
242	},
243	): Promise<T>;
244
245	public async save<T extends DeepPartial<E>>(
246	entityOrEntities: T \| Array<T>,
247	options?: SaveOptions & { reload: false },
248	): Promise<(T & E) \| Array<T & E> \| T \| Array<T>> {
249	if (!this.isPolymorph()) {	4!
250	return Array.isArray(entityOrEntities)	×
251	? super.save(entityOrEntities, options)
252	: super.save(entityOrEntities, options);
253	}
254
255	const metadata = this.getPolymorphicMetadata();	4✔
256
257	metadata.map((options: PolymorphicOptionsType) => {	4✔
258	if (this.isParent(options)) {	4✔
259	(Array.isArray(entityOrEntities)	4✔
260	? entityOrEntities
261	: [entityOrEntities]
262	).map((entity: E \| DeepPartial<E>) => {
263	const parent = entity[options.propertyKey];	6✔
264
265	if (!parent \|\| entity[entityIdColumn(options)] !== undefined) {	6!
266	return entity;	×
267	}
268
269	/**
270	* Add parent's id and type to child's id and type field
271	*/
272	type EntityKey = keyof DeepPartial<E>;
273	entity[entityIdColumn(options) as EntityKey] =	6✔
274	parent[PrimaryColumn(options)];
275	entity[entityTypeColumn(options) as EntityKey] =	6✔
276	parent.constructor.name;
277	return entity;	6✔
278	});
279	}
280	});
281
282	/**
283	* Check deleteBeforeUpdate
284	*/
285	Array.isArray(entityOrEntities)	4✔
286	? await Promise.all(
287	(entityOrEntities as Array<T>).map((entity) =>
288	this.deletePolymorphs(entity, metadata),	4✔
289	),
290	)
291	: await this.deletePolymorphs(entityOrEntities as T, metadata);
292
293	return Array.isArray(entityOrEntities)	4✔
294	? super.save(entityOrEntities, options)
295	: super.save(entityOrEntities, options);
296	}
297
298	private async deletePolymorphs(
299	entity: DeepPartial<E>,
300	options: PolymorphicMetadataInterface[],
301	): Promise<void \| never> {
302	await Promise.all(	6✔
303	options.map(
304	(option: PolymorphicMetadataInterface) =>
305	new Promise((resolve) => {	6✔
306	if (!option.deleteBeforeUpdate) {	6✔
307	resolve(Promise.resolve());	6✔
308	}
309
310	const entityTypes = Array.isArray(option.classType)	6!
311	? option.classType
312	: [option.classType];
313
314	// resolve to singular query?
315	resolve(	6✔
316	Promise.all(
317	entityTypes.map((type: () => Function \| Function[]) => {
318	const repository = this.findRepository(type);	6✔
319
320	repository.delete({	6✔
321	[entityTypeColumn(option)]: type,
322	[entityIdColumn(option)]: entity[PrimaryColumn(option)],
323	});
324	}),
325	),
326	);
327	}),
328	),
329	);
330	}
331
332	public async find(options?: FindManyOptions<E>): Promise<E[]> {
333	const results = await super.find(options);	1✔
334
335	if (!this.isPolymorph()) {	1!
336	return results;	×
337	}
338
339	const metadata = this.getPolymorphicMetadata();	1✔
340
341	return Promise.all(	1✔
342	results.map((entity) => this.hydratePolymorphs(entity, metadata)),	6✔
343	);
344	}
345
346	public async findOne(options?: FindOneOptions<E>): Promise<E \| null> {
347	const polymorphicMetadata = this.getPolymorphicMetadata();	1✔
348
349	if (Object.keys(polymorphicMetadata).length === 0) {	1!
NEW 350	return super.findOne(options);	×
351	}
352
353	const entity = await super.findOne(options);	1✔
354
355	if (!entity) {	1!
356	return entity;	×
357	}
358
359	return this.hydratePolymorphs(entity, polymorphicMetadata);	1✔
360	}
361
362	create(): E;
363
364	create(entityLikeArray: DeepPartial<E>[]): E[];
365
366	create(entityLike: DeepPartial<E>): E;
367
368	create(
369	plainEntityLikeOrPlainEntityLikes?: DeepPartial<E> \| DeepPartial<E>[],
370	): E \| E[] {
371	const metadata = this.getPolymorphicMetadata();	7✔
372	const entity = super.create(plainEntityLikeOrPlainEntityLikes as any);	7✔
373	if (!metadata) {	7!
374	return entity;	×
375	}
376	metadata.forEach((value: PolymorphicOptionsType) => {	7✔
377	entity[value.propertyKey] =	7✔
378	plainEntityLikeOrPlainEntityLikes[value.propertyKey];
379	});
380
381	return entity;	7✔
382	}
383
384	/// TODO implement remove and have an option to delete children/parent
385	}

bashleigh / typeorm-polymorphic / 4626431064

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