8231701447

Committed 11 Mar 2024 11:02AM UTC coverage: 97.232% (-0.07%) from 97.305%

Build # 8231701447

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #478 from jiho-kr/feature/swagger-body

feat: override swagger body

Run Details

1008 of 1057 branches covered (95.36%)

Branch coverage included in aggregate %.

3 of 3 new or added lines in 1 file covered. (100.0%)

1 existing line in 1 file now uncovered.

994 of 1002 relevant lines covered (99.2%)

585.15 hits per line

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

95.71

/src/lib/crud.route.factory.ts

/* eslint-disable @typescript-eslint/ban-types */
import { ExecutionContext, HttpStatus, Type } from '@nestjs/common';
import {
    CUSTOM_ROUTE_ARGS_METADATA,
    HTTP_CODE_METADATA,
    INTERCEPTORS_METADATA,
    METHOD_METADATA,
    PARAMTYPES_METADATA,
    PATH_METADATA,
    ROUTE_ARGS_METADATA,
} from '@nestjs/common/constants';
import { DECORATORS } from '@nestjs/swagger/dist/constants';
import { getMetadataArgsStorage, DefaultNamingStrategy } from 'typeorm';
import { MetadataUtils } from 'typeorm/metadata-builder/MetadataUtils';

import { capitalizeFirstLetter } from './capitalize-first-letter';
import { CRUD_ROUTE_ARGS } from './constants';
import { CRUD_POLICY } from './crud.policy';
import { RequestSearchDto } from './dto/request-search.dto';
import { CreateRequestDto, getPropertyNamesFromMetadata } from './dto/request.dto';
import {
    Column,
    CrudCreateRequest,
    CrudDeleteOneRequest,
    CrudOptions,
    CrudReadOneRequest,
    CrudRecoverRequest,
    CrudUpdateOneRequest,
    FactoryOption,
    Method,
    PaginationType,
    PAGINATION_SWAGGER_QUERY,
    PrimaryKey,
    EntityType,
} from './interface';
import { CrudLogger } from './provider/crud-logger';
import { CrudReadManyRequest } from './request';

type ParameterDecorators =
    | {
          name?: string;
          description?: string;
          required: boolean;
          in: string;
          items?: { type: string };
          type: unknown;
          isArray?: boolean;
      }
    | {
          name?: any;
          description?: string;
          required: boolean;
          in: string;
          type: unknown;
          schema: {
              [type: string]: unknown;
          };
      };

export class CrudRouteFactory {
    private crudLogger: CrudLogger;
    private entity: {
        tableName: string;
        relations?: string[];
        primaryKeys?: PrimaryKey[];
        columns?: Column[];
    } = {
        tableName: '',
    };
    private paginationType: PaginationType;

    constructor(
        protected target: any,
        protected crudOptions: CrudOptions,
    ) {
        this.entityInformation(crudOptions.entity);

        const paginationType = crudOptions.routes?.readMany?.paginationType ?? CRUD_POLICY[Method.READ_MANY].default.paginationType;
        const isPaginationType = (
            <TEnum extends Record<string, unknown>>(enumType: TEnum) =>
            (nextCursor: unknown): nextCursor is TEnum[keyof TEnum] =>
                Object.values(enumType).includes(nextCursor as TEnum[keyof TEnum])
        )(PaginationType);
        if (!isPaginationType(paginationType)) {
            throw new TypeError(`invalid PaginationType ${paginationType}`);
        }
        this.paginationType = paginationType;
        this.crudLogger = new CrudLogger(crudOptions.logging);
    }

    init() {
        for (const method of Object.values(Method)) {
            if (!this.enabledMethod(method)) {
                continue;
            }
            this.createMethod(method);
        }
    }

    private entityInformation(entity: EntityType): void {
        const tableName = (() => {
            const table = getMetadataArgsStorage().tables.find(({ target }) => target === entity);

            if (!table) {
                throw new Error('Cannot find Table from TypeORM');
            }

            const namingStrategy = (tableName: string | undefined) => new DefaultNamingStrategy().tableName(entity.name, tableName);

            if (!table.name && table.type === 'entity-child') {
                const discriminatorValue = getMetadataArgsStorage().discriminatorValues.find(({ target }) => target === entity)?.value;
                return namingStrategy(typeof discriminatorValue === 'string' ? discriminatorValue : discriminatorValue?.name);
            }

            return namingStrategy(table?.name);
        })();
        if (!tableName) {
            throw new Error('Cannot find Entity name from TypeORM');
        }
        this.entity.tableName = tableName;

        const inheritanceTree = MetadataUtils.getInheritanceTree(entity as Function);
        const columnList = getMetadataArgsStorage().columns.filter(({ target }) => inheritanceTree.includes(target as Function));

        const entityColumns = columnList.map(({ propertyName, options }) => ({
            name: propertyName,
            type: options.type,
            isPrimary: Boolean(options.primary),
        }));

        this.entity.columns = entityColumns;

        const primaryKeys = entityColumns.filter(({ isPrimary }) => isPrimary);
        if (!(primaryKeys.length === 1 && primaryKeys[0].name === 'id')) {
            this.entity.primaryKeys = primaryKeys;
        }

        this.entity.relations = getMetadataArgsStorage().relations.flatMap(({ target, propertyName }) =>
            inheritanceTree.includes(target as Function) ? [propertyName] : [],
        );
    }

    protected get tableName(): string {
        return this.entity.tableName;
    }

    protected get targetPrototype() {
        return this.target.prototype;
    }

    protected readOne<T>(controllerMethodName: string) {
        this.targetPrototype[controllerMethodName] = function reservedReadOne(crudReadOneRequest: CrudReadOneRequest<T>) {
            return this.crudService.reservedReadOne(crudReadOneRequest);
        };
    }

    protected readMany<T>(controllerMethodName: string) {
        this.targetPrototype[controllerMethodName] = function reservedReadMany(crudReadManyRequest: CrudReadManyRequest<T>) {
            return this.crudService.reservedReadMany(crudReadManyRequest);
        };
    }

    protected search<T>(controllerMethodName: string) {
        this.targetPrototype[controllerMethodName] = function reservedSearch(crudReadManyRequest: CrudReadManyRequest<T>) {
            return this.crudService.reservedReadMany(crudReadManyRequest);
        };
    }

    protected create<T>(controllerMethodName: string) {
        this.targetPrototype[controllerMethodName] = function reservedCreate(crudCreateRequest: CrudCreateRequest<T>) {
            return this.crudService.reservedCreate(crudCreateRequest);
        };
    }

    protected upsert<T>(controllerMethodName: string) {
        this.targetPrototype[controllerMethodName] = function reservedUpsert(crudCreateRequest: CrudCreateRequest<T>) {
            return this.crudService.reservedUpsert(crudCreateRequest);
        };
    }

    protected update<T>(controllerMethodName: string) {
        this.targetPrototype[controllerMethodName] = function reservedUpdate(crudUpdateOneRequest: CrudUpdateOneRequest<T>) {
            return this.crudService.reservedUpdate(crudUpdateOneRequest);
        };
    }

    protected delete<T>(controllerMethodName: string) {
        this.targetPrototype[controllerMethodName] = function reservedDelete(crudDeleteOneRequest: CrudDeleteOneRequest<T>) {
            return this.crudService.reservedDelete(crudDeleteOneRequest);
        };
    }

    protected recover<T>(controllerMethodName: string) {
        this.targetPrototype[controllerMethodName] = function reservedRecover(crudRecoverRequest: CrudRecoverRequest<T>) {
            return this.crudService.reservedRecover(crudRecoverRequest);
        };
    }

    private createMethod(crudMethod: Method): void {
        if (crudMethod === Method.RECOVER) {
            const enableRecover = this.crudOptions.routes?.[Method.DELETE]?.softDelete ?? CRUD_POLICY[Method.DELETE].default.softDeleted;
            if (!enableRecover) {
                return;
            }
        }

        const methodName = this.writeMethodOnController(crudMethod);
        if (!methodName) {
            throw new Error(`Required Method Name of ${crudMethod}`);
        }

        const targetMethod = this.targetPrototype[methodName];
        const { path, params } = CRUD_POLICY[crudMethod].uriParameter(this.crudOptions, this.entity.primaryKeys);
        const methodNameOnController = this.controllerMethodName(crudMethod);
        const factoryOption: FactoryOption = {
            columns: this.entity.columns,
            relations: this.entity.relations ?? [],
            primaryKeys: this.entity.primaryKeys ?? [{ name: 'id', type: 'number' }],
            logger: this.crudLogger,
        };

        Reflect.defineMetadata(
            INTERCEPTORS_METADATA,
            [
                ...(this.crudOptions.routes?.[crudMethod]?.interceptors ?? []),
                CRUD_POLICY[crudMethod].interceptor(this.crudOptions, factoryOption),
            ].filter(Boolean),
            targetMethod,
        );

        this.applySwaggerDecorator(crudMethod, params, targetMethod);

        const requestArg = this.createCrudRouteArg();
        Reflect.defineMetadata(ROUTE_ARGS_METADATA, requestArg, this.target, methodNameOnController);
        Reflect.defineMetadata(PARAMTYPES_METADATA, [Object], this.targetPrototype, methodNameOnController);

        if (crudMethod === Method.SEARCH) {
            Reflect.defineMetadata(HTTP_CODE_METADATA, HttpStatus.OK, targetMethod);
        }

        const customDecorators = this.crudOptions.routes?.[crudMethod]?.decorators ?? [];

        if (customDecorators.length > 0) {
            for (const decorator of customDecorators) {
                const descriptor = Reflect.getOwnPropertyDescriptor(targetMethod, methodNameOnController);
                (decorator as MethodDecorator | PropertyDecorator)(
                    targetMethod,
                    methodNameOnController,
                    descriptor ?? { value: targetMethod },
                );
            }
        }

        Reflect.defineMetadata(PATH_METADATA, path, targetMethod);
        Reflect.defineMetadata(METHOD_METADATA, CRUD_POLICY[crudMethod].method, targetMethod);
    }

    private applySwaggerDecorator(method: Method, params: string[], target: Object) {
        if (this.crudOptions.routes?.[method]?.swagger?.hide) {
            Reflect.defineMetadata(DECORATORS.API_EXCLUDE_ENDPOINT, { disable: true }, target);
            return;
        }

        Reflect.defineMetadata(DECORATORS.API_OPERATION, CRUD_POLICY[method].swagger.operationMetadata(this.tableName), target);
        this.defineParameterSwagger(method, params, target);

        if (this.crudOptions.routes?.[method]?.swagger?.response) {
            const responseDto = this.generalTypeGuard(this.crudOptions.routes?.[method]?.swagger?.response!, method, 'response');
            const extraModels: Array<{ name: string }> = Reflect.getMetadata(DECORATORS.API_EXTRA_MODELS, target) ?? [];
            if (!extraModels.some((model) => model.name === responseDto.name)) {
                Reflect.defineMetadata(DECORATORS.API_EXTRA_MODELS, [...extraModels, responseDto], target);
            }
        }
        const swaggerResponse = this.crudOptions.routes?.[method]?.swagger?.response ?? (this.crudOptions.entity as Type<EntityType>);

        Reflect.defineMetadata(
            DECORATORS.API_RESPONSE,
            CRUD_POLICY[method].swagger.responseMetadata({
                type: swaggerResponse,
                tableName: this.tableName,
                paginationType: this.paginationType,
            }),
            target,
        );

        if (method === Method.READ_MANY) {
            const extraModels: Array<{ name: string }> = Reflect.getMetadata(DECORATORS.API_EXTRA_MODELS, target) ?? [];
            Reflect.defineMetadata(DECORATORS.API_EXTRA_MODELS, [...extraModels, swaggerResponse], target);
        }
    }

    private defineParameterSwagger(method: Method, params: string[], target: Object) {
        const parameterDecorators: ParameterDecorators[] = params.map((param) => ({
            name: param,
            required: true,
            in: 'path',
            type: String,
            isArray: false,
        }));

        if (method === Method.READ_MANY) {
            parameterDecorators.push(
                ...PAGINATION_SWAGGER_QUERY[this.paginationType].map(({ name, type }) => ({
                    name,
                    type,
                    in: 'query',
                    required: false,
                    description: `Query parameters for ${capitalizeFirstLetter(this.paginationType)} Pagination`,
                })),
                ...getPropertyNamesFromMetadata(this.crudOptions.entity, method).map((property) => ({
                    name: property,
                    type: 'string',
                    in: 'query',
                    required: false,
                    description: `Query string filter by ${this.crudOptions.entity.name}.${property}`,
                })),
            );
        }
        if (method === Method.READ_ONE) {
            parameterDecorators.push({
                name: 'fields',
                type: 'array',
                in: 'query',
                items: {
                    type: 'string',
                },
                required: false,
                description: 'Pick response fields',
            });
        }
        if (CRUD_POLICY[method].useBody) {
            const bodyType = (() => {
                const customBody = this.crudOptions.routes?.[method]?.swagger?.body;
                if (customBody != null) {
                    return customBody;
                }
                if (method === Method.SEARCH) {
                    return RequestSearchDto;
                }
                const routeConfig = this.crudOptions.routes?.[method];
                if (routeConfig?.swagger && 'body' in routeConfig.swagger) {
                    return this.generalTypeGuard(routeConfig.swagger['body']!, method, 'body');
                }

                return CreateRequestDto(this.crudOptions.entity, method);
            })();

            parameterDecorators.push(
                method === Method.CREATE
                    ? {
                          description: [capitalizeFirstLetter(method), capitalizeFirstLetter(this.tableName), 'Dto'].join(''),
                          required: true,
                          in: 'body',
                          type: bodyType,
                          schema: {
                              type: 'object',
                              anyOf: [
                                  {
                                      $ref: `#/components/schemas/${bodyType.name}`,
                                  },
                                  { type: 'array', items: { $ref: `#/components/schemas/${bodyType.name}` } },
                              ],
                          },
                      }
                    : {
                          description: [capitalizeFirstLetter(method), capitalizeFirstLetter(this.tableName), 'Dto'].join(''),
                          required: true,
                          in: 'body',
                          type: bodyType,
                          isArray: false,
                      },
            );
        }
        Reflect.defineMetadata(DECORATORS.API_PARAMETERS, parameterDecorators, target);
    }

    private enabledMethod(crudMethod: Method): boolean {
        if (!Array.isArray(this.crudOptions.only) || this.crudOptions.only.length === 0) {
            return true;
        }
        return this.crudOptions.only.includes(crudMethod);
    }

    private controllerMethodName(crudMethod: Method): string {
        return `reserved${capitalizeFirstLetter(crudMethod)}`;
    }

    private writeMethodOnController(crudMethod: Method): string {
        const entity = this.crudOptions.entity;
        const controllerMethodName: string = this.controllerMethodName(crudMethod);

        if (this.targetPrototype[controllerMethodName]) {
            throw new Error(`${controllerMethodName} is a reserved word. cannot use`);
        }
        this[crudMethod]<typeof entity>(controllerMethodName);
        return controllerMethodName;
    }

    private createCrudRouteArg(
        index = 0,
        /* istanbul ignore next */
        pipes: unknown[] = [],
        data = undefined,
    ) {
        return {
            [`${CRUD_ROUTE_ARGS}${CUSTOM_ROUTE_ARGS_METADATA}:${index}`]: {
                index,
                factory: (_: unknown, ctx: ExecutionContext) => ctx.switchToHttp().getRequest()[CRUD_ROUTE_ARGS],
                data,
                pipes,
            },
        };
    }

    private generalTypeGuard<T extends Type<unknown>>(type: T, method: Method, postFix?: string): T {
        if (['PickTypeClass', 'OmitTypeClass'].includes(type.name)) {
            Object.defineProperty(type, 'name', {
                value: [
                    capitalizeFirstLetter(method),
                    capitalizeFirstLetter(this.tableName),
                    postFix && capitalizeFirstLetter(postFix),
                    'Dto',
                ].join(''),
            });
        }
        return type;
    }
}

1	/* eslint-disable @typescript-eslint/ban-types */
2	import { ExecutionContext, HttpStatus, Type } from '@nestjs/common';	296✔
3	import {	296✔
4	CUSTOM_ROUTE_ARGS_METADATA,
5	HTTP_CODE_METADATA,
6	INTERCEPTORS_METADATA,
7	METHOD_METADATA,
8	PARAMTYPES_METADATA,
9	PATH_METADATA,
10	ROUTE_ARGS_METADATA,
11	} from '@nestjs/common/constants';
12	import { DECORATORS } from '@nestjs/swagger/dist/constants';	296✔
13	import { getMetadataArgsStorage, DefaultNamingStrategy } from 'typeorm';	296✔
14	import { MetadataUtils } from 'typeorm/metadata-builder/MetadataUtils';	296✔
15
16	import { capitalizeFirstLetter } from './capitalize-first-letter';	296✔
17	import { CRUD_ROUTE_ARGS } from './constants';	296✔
18	import { CRUD_POLICY } from './crud.policy';	296✔
19	import { RequestSearchDto } from './dto/request-search.dto';	296✔
20	import { CreateRequestDto, getPropertyNamesFromMetadata } from './dto/request.dto';	296✔
21	import {	296✔
22	Column,
23	CrudCreateRequest,
24	CrudDeleteOneRequest,
25	CrudOptions,
26	CrudReadOneRequest,
27	CrudRecoverRequest,
28	CrudUpdateOneRequest,
29	FactoryOption,
30	Method,
31	PaginationType,
32	PAGINATION_SWAGGER_QUERY,
33	PrimaryKey,
34	EntityType,
35	} from './interface';
36	import { CrudLogger } from './provider/crud-logger';	296✔
37	import { CrudReadManyRequest } from './request';
38
39	type ParameterDecorators =
40	\| {
41	name?: string;
42	description?: string;
43	required: boolean;
44	in: string;
45	items?: { type: string };
46	type: unknown;
47	isArray?: boolean;
48	}
49	\| {
50	name?: any;
51	description?: string;
52	required: boolean;
53	in: string;
54	type: unknown;
55	schema: {
56	[type: string]: unknown;
57	};
58	};
59
60	export class CrudRouteFactory {	296✔
61	private crudLogger: CrudLogger;
62	private entity: {	440✔
63	tableName: string;
64	relations?: string[];
65	primaryKeys?: PrimaryKey[];
66	columns?: Column[];
67	} = {
68	tableName: '',
69	};
70	private paginationType: PaginationType;
71
72	constructor(
73	protected target: any,	440✔
74	protected crudOptions: CrudOptions,	440✔
75	) {
76	this.entityInformation(crudOptions.entity);	440✔
77
78	const paginationType = crudOptions.routes?.readMany?.paginationType ?? CRUD_POLICY[Method.READ_MANY].default.paginationType;	436✔
79	const isPaginationType = (	436✔
80	<TEnum extends Record<string, unknown>>(enumType: TEnum) =>
81	(nextCursor: unknown): nextCursor is TEnum[keyof TEnum] =>	436✔
82	Object.values(enumType).includes(nextCursor as TEnum[keyof TEnum])	436✔
83	)(PaginationType);
84	if (!isPaginationType(paginationType)) {	436✔
85	throw new TypeError(`invalid PaginationType ${paginationType}`);	4✔
86	}
87	this.paginationType = paginationType;	432✔
88	this.crudLogger = new CrudLogger(crudOptions.logging);	432✔
89	}
90
91	init() {
92	for (const method of Object.values(Method)) {	432✔
93	if (!this.enabledMethod(method)) {	3,428✔
94	continue;	24✔
95	}
96	this.createMethod(method);	3,404✔
97	}
98	}
99
100	private entityInformation(entity: EntityType): void {
101	const tableName = (() => {	440✔
102	const table = getMetadataArgsStorage().tables.find(({ target }) => target === entity);	640✔
103
104	if (!table) {	440✔
105	throw new Error('Cannot find Table from TypeORM');	4✔
106	}
107
108	const namingStrategy = (tableName: string \| undefined) => new DefaultNamingStrategy().tableName(entity.name, tableName);	436✔
109
110	if (!table.name && table.type === 'entity-child') {	436✔
111	const discriminatorValue = getMetadataArgsStorage().discriminatorValues.find(({ target }) => target === entity)?.value;	24✔
112	return namingStrategy(typeof discriminatorValue === 'string' ? discriminatorValue : discriminatorValue?.name);	24✔
113	}
114
115	return namingStrategy(table?.name);	412!
116	})();
117	if (!tableName) {	436!
118	throw new Error('Cannot find Entity name from TypeORM');	×
119	}
120	this.entity.tableName = tableName;	436✔
121
122	const inheritanceTree = MetadataUtils.getInheritanceTree(entity as Function);	436✔
123	const columnList = getMetadataArgsStorage().columns.filter(({ target }) => inheritanceTree.includes(target as Function));	3,256✔
124
125	const entityColumns = columnList.map(({ propertyName, options }) => ({	2,488✔
126	name: propertyName,
127	type: options.type,
128	isPrimary: Boolean(options.primary),
129	}));
130
131	this.entity.columns = entityColumns;	436✔
132
133	const primaryKeys = entityColumns.filter(({ isPrimary }) => isPrimary);	2,488✔
134	if (!(primaryKeys.length === 1 && primaryKeys[0].name === 'id')) {	436✔
135	this.entity.primaryKeys = primaryKeys;	104✔
136	}
137
138	this.entity.relations = getMetadataArgsStorage().relations.flatMap(({ target, propertyName }) =>	436✔
139	inheritanceTree.includes(target as Function) ? [propertyName] : [],	480✔
140	);
141	}
142
143	protected get tableName(): string {
144	return this.entity.tableName;	8,432✔
145	}
146
147	protected get targetPrototype() {
148	return this.target.prototype;	13,476✔
149	}
150
151	protected readOne<T>(controllerMethodName: string) {
152	this.targetPrototype[controllerMethodName] = function reservedReadOne(crudReadOneRequest: CrudReadOneRequest<T>) {	424✔
153	return this.crudService.reservedReadOne(crudReadOneRequest);	396✔
154	};
155	}
156
157	protected readMany<T>(controllerMethodName: string) {
158	this.targetPrototype[controllerMethodName] = function reservedReadMany(crudReadManyRequest: CrudReadManyRequest<T>) {	428✔
159	return this.crudService.reservedReadMany(crudReadManyRequest);	396✔
160	};
161	}
162
163	protected search<T>(controllerMethodName: string) {
164	this.targetPrototype[controllerMethodName] = function reservedSearch(crudReadManyRequest: CrudReadManyRequest<T>) {	424✔
165	return this.crudService.reservedReadMany(crudReadManyRequest);	336✔
166	};
167	}
168
169	protected create<T>(controllerMethodName: string) {
170	this.targetPrototype[controllerMethodName] = function reservedCreate(crudCreateRequest: CrudCreateRequest<T>) {	428✔
171	return this.crudService.reservedCreate(crudCreateRequest);	1,436✔
172	};
173	}
174
175	protected upsert<T>(controllerMethodName: string) {
176	this.targetPrototype[controllerMethodName] = function reservedUpsert(crudCreateRequest: CrudCreateRequest<T>) {	424✔
177	return this.crudService.reservedUpsert(crudCreateRequest);	116✔
178	};
179	}
180
181	protected update<T>(controllerMethodName: string) {
182	this.targetPrototype[controllerMethodName] = function reservedUpdate(crudUpdateOneRequest: CrudUpdateOneRequest<T>) {	424✔
183	return this.crudService.reservedUpdate(crudUpdateOneRequest);	124✔
184	};
185	}
186
187	protected delete<T>(controllerMethodName: string) {
188	this.targetPrototype[controllerMethodName] = function reservedDelete(crudDeleteOneRequest: CrudDeleteOneRequest<T>) {	424✔
189	return this.crudService.reservedDelete(crudDeleteOneRequest);	412✔
190	};
191	}
192
193	protected recover<T>(controllerMethodName: string) {
194	this.targetPrototype[controllerMethodName] = function reservedRecover(crudRecoverRequest: CrudRecoverRequest<T>) {	392✔
195	return this.crudService.reservedRecover(crudRecoverRequest);	68✔
196	};
197	}
198
199	private createMethod(crudMethod: Method): void {
200	if (crudMethod === Method.RECOVER) {	3,404✔
201	const enableRecover = this.crudOptions.routes?.[Method.DELETE]?.softDelete ?? CRUD_POLICY[Method.DELETE].default.softDeleted;	424✔
202	if (!enableRecover) {	424✔
203	return;	32✔
204	}
205	}
206
207	const methodName = this.writeMethodOnController(crudMethod);	3,372✔
208	if (!methodName) {	3,368!
209	throw new Error(`Required Method Name of ${crudMethod}`);	×
210	}
211
212	const targetMethod = this.targetPrototype[methodName];	3,368✔
213	const { path, params } = CRUD_POLICY[crudMethod].uriParameter(this.crudOptions, this.entity.primaryKeys);	3,368✔
214	const methodNameOnController = this.controllerMethodName(crudMethod);	3,368✔
215	const factoryOption: FactoryOption = {	3,368✔
216	columns: this.entity.columns,
217	relations: this.entity.relations ?? [],	5,052!
218	primaryKeys: this.entity.primaryKeys ?? [{ name: 'id', type: 'number' }],	5,052✔
219	logger: this.crudLogger,
220	};
221
222	Reflect.defineMetadata(	3,368✔
223	INTERCEPTORS_METADATA,
224	[
225	...(this.crudOptions.routes?.[crudMethod]?.interceptors ?? []),	15,156✔
226	CRUD_POLICY[crudMethod].interceptor(this.crudOptions, factoryOption),
227	].filter(Boolean),
228	targetMethod,
229	);
230
231	this.applySwaggerDecorator(crudMethod, params, targetMethod);	3,368✔
232
233	const requestArg = this.createCrudRouteArg();	3,368✔
234	Reflect.defineMetadata(ROUTE_ARGS_METADATA, requestArg, this.target, methodNameOnController);	3,368✔
235	Reflect.defineMetadata(PARAMTYPES_METADATA, [Object], this.targetPrototype, methodNameOnController);	3,368✔
236
237	if (crudMethod === Method.SEARCH) {	3,368✔
238	Reflect.defineMetadata(HTTP_CODE_METADATA, HttpStatus.OK, targetMethod);	424✔
239	}
240
241	const customDecorators = this.crudOptions.routes?.[crudMethod]?.decorators ?? [];	3,368✔
242
243	if (customDecorators.length > 0) {	3,368✔
244	for (const decorator of customDecorators) {	52✔
245	const descriptor = Reflect.getOwnPropertyDescriptor(targetMethod, methodNameOnController);	52✔
246	(decorator as MethodDecorator \| PropertyDecorator)(	52✔
247	targetMethod,
248	methodNameOnController,
249	descriptor ?? { value: targetMethod },	78!
250	);
251	}
252	}
253
254	Reflect.defineMetadata(PATH_METADATA, path, targetMethod);	3,368✔
255	Reflect.defineMetadata(METHOD_METADATA, CRUD_POLICY[crudMethod].method, targetMethod);	3,368✔
256	}
257
258	private applySwaggerDecorator(method: Method, params: string[], target: Object) {
259	if (this.crudOptions.routes?.[method]?.swagger?.hide) {	3,368✔
260	Reflect.defineMetadata(DECORATORS.API_EXCLUDE_ENDPOINT, { disable: true }, target);	4✔
261	return;	4✔
262	}
263
264	Reflect.defineMetadata(DECORATORS.API_OPERATION, CRUD_POLICY[method].swagger.operationMetadata(this.tableName), target);	3,364✔
265	this.defineParameterSwagger(method, params, target);	3,364✔
266
267	if (this.crudOptions.routes?.[method]?.swagger?.response) {	3,364✔
268	const responseDto = this.generalTypeGuard(this.crudOptions.routes?.[method]?.swagger?.response!, method, 'response');	8!
269	const extraModels: Array<{ name: string }> = Reflect.getMetadata(DECORATORS.API_EXTRA_MODELS, target) ?? [];	8!
270	if (!extraModels.some((model) => model.name === responseDto.name)) {	8✔
271	Reflect.defineMetadata(DECORATORS.API_EXTRA_MODELS, [...extraModels, responseDto], target);	8✔
272	}
273	}
274	const swaggerResponse = this.crudOptions.routes?.[method]?.swagger?.response ?? (this.crudOptions.entity as Type<EntityType>);	3,364✔
275
276	Reflect.defineMetadata(	3,364✔
277	DECORATORS.API_RESPONSE,
278	CRUD_POLICY[method].swagger.responseMetadata({
279	type: swaggerResponse,
280	tableName: this.tableName,
281	paginationType: this.paginationType,
282	}),
283	target,
284	);
285
286	if (method === Method.READ_MANY) {	3,364✔
287	const extraModels: Array<{ name: string }> = Reflect.getMetadata(DECORATORS.API_EXTRA_MODELS, target) ?? [];	428!
288	Reflect.defineMetadata(DECORATORS.API_EXTRA_MODELS, [...extraModels, swaggerResponse], target);	428✔
289	}
290	}
291
292	private defineParameterSwagger(method: Method, params: string[], target: Object) {
293	const parameterDecorators: ParameterDecorators[] = params.map((param) => ({	3,364✔
294	name: param,
295	required: true,
296	in: 'path',
297	type: String,
298	isArray: false,
299	}));
300
301	if (method === Method.READ_MANY) {	3,364✔
302	parameterDecorators.push(	428✔
303	...PAGINATION_SWAGGER_QUERY[this.paginationType].map(({ name, type }) => ({	452✔
304	name,
305	type,
306	in: 'query',
307	required: false,
308	description: `Query parameters for ${capitalizeFirstLetter(this.paginationType)} Pagination`,
309	})),
310	...getPropertyNamesFromMetadata(this.crudOptions.entity, method).map((property) => ({	924✔
311	name: property,
312	type: 'string',
313	in: 'query',
314	required: false,
315	description: `Query string filter by ${this.crudOptions.entity.name}.${property}`,
316	})),
317	);
318	}
319	if (method === Method.READ_ONE) {	3,364✔
320	parameterDecorators.push({	424✔
321	name: 'fields',
322	type: 'array',
323	in: 'query',
324	items: {
325	type: 'string',
326	},
327	required: false,
328	description: 'Pick response fields',
329	});
330	}
331	if (CRUD_POLICY[method].useBody) {	3,364✔
332	const bodyType = (() => {	1,700✔
333	const customBody = this.crudOptions.routes?.[method]?.swagger?.body;	1,700✔
334	if (customBody != null) {	1,700✔
335	return customBody;	8✔
336	}
337	if (method === Method.SEARCH) {	1,692✔
338	return RequestSearchDto;	424✔
339	}
340	const routeConfig = this.crudOptions.routes?.[method];	1,268✔
341	if (routeConfig?.swagger && 'body' in routeConfig.swagger) {	1,268!
UNCOV 342	return this.generalTypeGuard(routeConfig.swagger['body']!, method, 'body');	×
343	}
344
345	return CreateRequestDto(this.crudOptions.entity, method);	1,268✔
346	})();
347
348	parameterDecorators.push(	1,700✔
349	method === Method.CREATE	850✔
350	? {
351	description: [capitalizeFirstLetter(method), capitalizeFirstLetter(this.tableName), 'Dto'].join(''),
352	required: true,
353	in: 'body',
354	type: bodyType,
355	schema: {
356	type: 'object',
357	anyOf: [
358	{
359	$ref: `#/components/schemas/${bodyType.name}`,
360	},
361	{ type: 'array', items: { $ref: `#/components/schemas/${bodyType.name}` } },
362	],
363	},
364	}
365	: {
366	description: [capitalizeFirstLetter(method), capitalizeFirstLetter(this.tableName), 'Dto'].join(''),
367	required: true,
368	in: 'body',
369	type: bodyType,
370	isArray: false,
371	},
372	);
373	}
374	Reflect.defineMetadata(DECORATORS.API_PARAMETERS, parameterDecorators, target);	3,364✔
375	}
376
377	private enabledMethod(crudMethod: Method): boolean {
378	if (!Array.isArray(this.crudOptions.only) \|\| this.crudOptions.only.length === 0) {	3,428✔
379	return true;	3,396✔
380	}
381	return this.crudOptions.only.includes(crudMethod);	32✔
382	}
383
384	private controllerMethodName(crudMethod: Method): string {
385	return `reserved${capitalizeFirstLetter(crudMethod)}`;	6,740✔
386	}
387
388	private writeMethodOnController(crudMethod: Method): string {
389	const entity = this.crudOptions.entity;	3,372✔
390	const controllerMethodName: string = this.controllerMethodName(crudMethod);	3,372✔
391
392	if (this.targetPrototype[controllerMethodName]) {	3,372✔
393	throw new Error(`${controllerMethodName} is a reserved word. cannot use`);	4✔
394	}
395	this[crudMethod]<typeof entity>(controllerMethodName);	3,368✔
396	return controllerMethodName;	3,368✔
397	}
398
399	private createCrudRouteArg(
400	index = 0,	1,684✔
401	/* istanbul ignore next */
402	pipes: unknown[] = [],
403	data = undefined,	1,684✔
404	) {
405	return {	3,368✔
406	[`${CRUD_ROUTE_ARGS}${CUSTOM_ROUTE_ARGS_METADATA}:${index}`]: {
407	index,
408	factory: (_: unknown, ctx: ExecutionContext) => ctx.switchToHttp().getRequest()[CRUD_ROUTE_ARGS],	3,284✔
409	data,
410	pipes,
411	},
412	};
413	}
414
415	private generalTypeGuard<T extends Type<unknown>>(type: T, method: Method, postFix?: string): T {
416	if (['PickTypeClass', 'OmitTypeClass'].includes(type.name)) {	8✔
417	Object.defineProperty(type, 'name', {	4✔
418	value: [
419	capitalizeFirstLetter(method),
420	capitalizeFirstLetter(this.tableName),
421	postFix && capitalizeFirstLetter(postFix),	4✔
422	'Dto',
423	].join(''),
424	});
425	}
426	return type;	8✔
427	}
428	}

woowabros / nestjs-library-crud / 8231701447

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