├── .eslintrc.js
├── .gitignore
├── .prettierrc
├── README.md
├── libs
    ├── index.ts
    ├── main.ts
    ├── mocks
    │   ├── constants
    │   │   ├── maximum-random-response.constant.ts
    │   │   └── mock-api-path.constant.ts
    │   ├── decorators
    │   │   ├── custom-request.decorator.ts
    │   │   └── validate-if-or-exclude.decorator.ts
    │   ├── dtos
    │   │   ├── create-mock-api.dto.ts
    │   │   └── create-property.dto.ts
    │   ├── enums
    │   │   ├── request-method.enum.ts
    │   │   └── type-selection.enum.ts
    │   ├── helpers
    │   │   └── check-type.helper.ts
    │   ├── http
    │   │   └── controllers
    │   │   │   ├── mock-api-creator.controller.ts
    │   │   │   └── mock-api.controller.ts
    │   ├── interfaces
    │   │   ├── api-swagger-document.interface.ts
    │   │   ├── column-mete-args.interface.ts
    │   │   ├── faker-type.interface.ts
    │   │   ├── mock-api-options.interface.ts
    │   │   ├── mock-api.interface.ts
    │   │   ├── swagger-spec.interface.ts
    │   │   └── update-mock-api-json.interface.ts
    │   ├── mock.module.ts
    │   ├── services
    │   │   ├── mock-api-creator.service.ts
    │   │   ├── mock-api.service.ts
    │   │   └── swagger.service.ts
    │   └── types
    │   │   └── swagger-spec-response.type.ts
    ├── static
    │   └── index.css
    └── views
    │   └── mock-api-creator.hbs
├── package-lock.json
├── package.json
├── tsconfig.build.json
└── tsconfig.json


/.eslintrc.js:
--------------------------------------------------------------------------------
  1 | module.exports = {
  2 |     parser: '@typescript-eslint/parser',
  3 |     parserOptions: {
  4 |         project: 'tsconfig.json',
  5 |         sourceType: 'module'
  6 |     },
  7 |     plugins: ['@typescript-eslint/eslint-plugin'],
  8 |     extends: [
  9 |         'plugin:prettier/recommended',
 10 |         'plugin:@typescript-eslint/recommended'
 11 |     ],
 12 |     root: true,
 13 |     env: {
 14 |         node: true,
 15 |         jest: true
 16 |     },
 17 |     overrides: [
 18 |         {
 19 |             'files': ['*.e2e-spec.ts', 'country.helper.ts', '*.spec.ts'],
 20 |             'rules': {
 21 |                 'max-lines-per-function': 'off',
 22 |                 'max-lines': 'off',
 23 |             }
 24 |         }
 25 |     ],
 26 |     ignorePatterns: ['.eslintrc.js'],
 27 |     rules: {
 28 |         'max-lines': ['error', {
 29 |             max: 400,
 30 |             skipComments: true
 31 |         }],
 32 |         'max-lines-per-function': ['error', {
 33 |             max: 50,
 34 |             skipComments: true
 35 |         }],
 36 |         '@typescript-eslint/naming-convention': [
 37 |             'error',
 38 |             { 'selector': 'enumMember', 'format': ['UPPER_CASE'] },
 39 |             {
 40 |                 'selector': [
 41 |                     'objectLiteralProperty'
 42 |                 ],
 43 |                 'format': ['camelCase', 'PascalCase', 'UPPER_CASE']
 44 |             },
 45 |             {
 46 |                 'selector': [
 47 |                     'parameter',
 48 |                     'variable',
 49 |                     'function',
 50 |                     'classProperty',
 51 |                     'typeProperty',
 52 |                     'parameterProperty',
 53 |                     'classMethod',
 54 |                     'objectLiteralMethod',
 55 |                     'typeMethod'
 56 |                 ],
 57 |                 'format': ['camelCase']
 58 |             },
 59 |             {
 60 |                 'selector': [
 61 |                     'class',
 62 |                     'interface',
 63 |                     'enum'
 64 |                 ],
 65 |                 'format': ['PascalCase']
 66 |             },
 67 |             {
 68 |                 'selector': [
 69 |                     'variable'
 70 |                 ],
 71 |                 'modifiers': ['exported'],
 72 |                 'format': ['PascalCase', 'camelCase', 'UPPER_CASE']
 73 |             },
 74 |             {
 75 |                 'selector': [
 76 |                     'function'
 77 |                 ],
 78 |                 'modifiers': ['exported'],
 79 |                 'format': ['PascalCase', 'camelCase']
 80 |             }
 81 |         ],
 82 |         '@typescript-eslint/interface-name-prefix': 'off',
 83 |         '@typescript-eslint/no-empty-function': 'off',
 84 |         '@typescript-eslint/explicit-function-return-type': 'off',
 85 |         '@typescript-eslint/explicit-module-boundary-types': 'off',
 86 |         '@typescript-eslint/no-explicit-any': 'off',
 87 |         '@typescript-eslint/no-inferrable-types': 'off',
 88 |         '@typescript-eslint/no-unused-vars': ['error', { 'args': 'none' }],
 89 |         'indent': 'off',
 90 |         'prettier/prettier': [
 91 |             'error',
 92 |             {
 93 |                 'useTabs': false,
 94 |                 'tabWidth': 4,
 95 |                 'printWidth': 120,
 96 |                 'singleQuote': true,
 97 |                 'trailingComma': 'none'
 98 |             }
 99 |         ],
100 |         'prefer-const': 'off'
101 |     }
102 | };
103 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # compiled output
 2 | /dist
 3 | /node_modules
 4 | 
 5 | # Logs
 6 | logs
 7 | *.log
 8 | npm-debug.log*
 9 | yarn-debug.log*
10 | yarn-error.log*
11 | lerna-debug.log*
12 | 
13 | # OS
14 | .DS_Store
15 | 
16 | # Tests
17 | /coverage
18 | /.nyc_output
19 | 
20 | # IDEs and editors
21 | /.idea
22 | .project
23 | .classpath
24 | .c9/
25 | *.launch
26 | .settings/
27 | *.sublime-workspace
28 | 
29 | # IDE - VSCode
30 | .vscode/*
31 | !.vscode/settings.json
32 | !.vscode/tasks.json
33 | !.vscode/launch.json
34 | !.vscode/extensions.json
35 | 
36 | .env


--------------------------------------------------------------------------------
/.prettierrc:
--------------------------------------------------------------------------------
 1 | {
 2 |   "singleQuote": true,
 3 |   "printWidth": 120,
 4 |   "proseWrap": "always",
 5 |   "tabWidth": 4,
 6 |   "useTabs": false,
 7 |   "trailingComma": "none",
 8 |   "bracketSpacing": true,
 9 |   "jsxBracketSameLine": false,
10 |   "semi": true,
11 |   "endOfLine": "auto"
12 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | <p align="center">
2 |   <a href="http://nestjs.com/" target="blank"><img src="https://nestjs.com/img/logo_text.svg" width="320" alt="Nest Logo" /></a>
3 | </p>
4 | 
5 | # nestjs-mocker
6 | 
7 | ## Description
8 | 


--------------------------------------------------------------------------------
/libs/index.ts:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hodfords-solutions/nestjs-mocker/df081ed7e3d7dd2bfc28fbc1b8d014930d7b6f53/libs/index.ts


--------------------------------------------------------------------------------
/libs/main.ts:
--------------------------------------------------------------------------------
 1 | import hbs from 'hbs';
 2 | import { join } from 'path';
 3 | import { NestFactory } from '@nestjs/core';
 4 | import { MockApiModule } from '~mocks/mock.module';
 5 | import { NestExpressApplication } from '@nestjs/platform-express';
 6 | 
 7 | async function boostrap() {
 8 |     const app = await NestFactory.create<NestExpressApplication>(MockApiModule);
 9 |     app.useStaticAssets(join(__dirname, 'static'));
10 |     app.setBaseViewsDir(join(__dirname, 'views'));
11 |     app.setViewEngine('hbs');
12 |     hbs.registerHelper('json', function (obj) {
13 |         return new hbs.SafeString(JSON.stringify(obj));
14 |     });
15 | }
16 | 
17 | boostrap();
18 | 


--------------------------------------------------------------------------------
/libs/mocks/constants/maximum-random-response.constant.ts:
--------------------------------------------------------------------------------
1 | export const MAXIMUM_RANDOM_RESPONSE = 'MAXIMUM_RANDOM_RESPONSE';
2 | 


--------------------------------------------------------------------------------
/libs/mocks/constants/mock-api-path.constant.ts:
--------------------------------------------------------------------------------
1 | export const MOCK_API_PATH = 'MOCK_API_PATH';
2 | 


--------------------------------------------------------------------------------
/libs/mocks/decorators/custom-request.decorator.ts:
--------------------------------------------------------------------------------
 1 | import { createParamDecorator, ExecutionContext } from '@nestjs/common';
 2 | import { RequestMethodEnum } from '~mocks/enums/request-method.enum';
 3 | 
 4 | export const CustomRequest = createParamDecorator((pathParams, ctx: ExecutionContext) => {
 5 |     const request = ctx.switchToHttp().getRequest();
 6 |     return {
 7 |         endpoint: request.url,
 8 |         method: request.method.toLowerCase()
 9 |     };
10 | });
11 | 
12 | export interface CustomRequest {
13 |     endpoint: string;
14 |     method: RequestMethodEnum;
15 | }
16 | 


--------------------------------------------------------------------------------
/libs/mocks/decorators/validate-if-or-exclude.decorator.ts:
--------------------------------------------------------------------------------
 1 | import { ValidateIf, ValidationOptions } from 'class-validator';
 2 | 
 3 | export const TRANSFORMER_EXCLUDE_KEY = 'transformer:exclude';
 4 | 
 5 | export function ValidateIfOrExclude(
 6 |     condition: (object: any, value: any) => boolean,
 7 |     validationOptions?: ValidationOptions
 8 | ): PropertyDecorator {
 9 |     return function (object, propertyName: string): void {
10 |         const metadatas = Reflect.getMetadata(TRANSFORMER_EXCLUDE_KEY, object.constructor) || [];
11 |         Reflect.defineMetadata(
12 |             TRANSFORMER_EXCLUDE_KEY,
13 |             [...metadatas, { propertyName, condition }],
14 |             object.constructor
15 |         );
16 | 
17 |         ValidateIf(condition, validationOptions)(object, propertyName);
18 |     };
19 | }
20 | 


--------------------------------------------------------------------------------
/libs/mocks/dtos/create-mock-api.dto.ts:
--------------------------------------------------------------------------------
 1 | import { RequestMethodEnum } from '~mocks/enums/request-method.enum';
 2 | import { ApiProperty } from '@nestjs/swagger';
 3 | import { IsEnum, IsNotEmpty, IsNumber, IsOptional } from 'class-validator';
 4 | import { CreatePropertyDto } from '~mocks/dtos/create-property.dto';
 5 | 
 6 | export class CreateMockApiDto {
 7 |     @ApiProperty({
 8 |         enum: RequestMethodEnum,
 9 |         default: RequestMethodEnum.GET
10 |     })
11 |     @IsNotEmpty()
12 |     @IsEnum(RequestMethodEnum)
13 |     method: RequestMethodEnum;
14 | 
15 |     @ApiProperty()
16 |     @IsNotEmpty()
17 |     endpoint: string;
18 | 
19 |     @ApiProperty()
20 |     @IsOptional()
21 |     @IsNumber()
22 |     delay?: number;
23 | 
24 |     @ApiProperty()
25 |     @IsOptional()
26 |     body?: CreatePropertyDto[];
27 | 
28 |     @ApiProperty()
29 |     @IsNotEmpty()
30 |     response: CreatePropertyDto[];
31 | }
32 | 


--------------------------------------------------------------------------------
/libs/mocks/dtos/create-property.dto.ts:
--------------------------------------------------------------------------------
 1 | import { ApiProperty } from '@nestjs/swagger';
 2 | import { IsBoolean, IsNotEmpty, IsOptional } from 'class-validator';
 3 | import { TypeSelectionEnum } from '~mocks/enums/type-selection.enum';
 4 | import { FakerType } from '~mocks/interfaces/faker-type.interface';
 5 | import { ValidateIfOrExclude } from '~mocks/decorators/validate-if-or-exclude.decorator';
 6 | 
 7 | export class CreatePropertyDto {
 8 |     @ApiProperty()
 9 |     @IsNotEmpty()
10 |     key?: string;
11 | 
12 |     @ApiProperty({
13 |         enum: TypeSelectionEnum,
14 |         default: TypeSelectionEnum.UUID
15 |     })
16 |     @IsNotEmpty()
17 |     type: TypeSelectionEnum;
18 | 
19 |     @ApiProperty({ required: false })
20 |     @IsOptional()
21 |     @ValidateIfOrExclude(({ type }) => type === TypeSelectionEnum.FAKER)
22 |     fakerType?: FakerType;
23 | 
24 |     @ApiProperty({ required: false })
25 |     @IsOptional()
26 |     overrideValue?: string | number;
27 | 
28 |     @ApiProperty({ required: false })
29 |     @IsOptional()
30 |     defaultValue?: string | number;
31 | 
32 |     @ApiProperty({ default: true })
33 |     @IsBoolean()
34 |     isRequired: boolean;
35 | 
36 |     @ApiProperty({ required: false })
37 |     @IsOptional()
38 |     items: CreatePropertyDto[];
39 | }
40 | 


--------------------------------------------------------------------------------
/libs/mocks/enums/request-method.enum.ts:
--------------------------------------------------------------------------------
1 | export enum RequestMethodEnum {
2 |     GET = 'GET',
3 |     POST = 'POST',
4 |     PUT = 'PUT',
5 |     PATCH = 'PATCH',
6 |     DELETE = 'DELETE'
7 | }
8 | 


--------------------------------------------------------------------------------
/libs/mocks/enums/type-selection.enum.ts:
--------------------------------------------------------------------------------
 1 | export enum TypeSelectionEnum {
 2 |     UUID = 'UUID',
 3 |     STRING = 'STRING',
 4 |     NUMBER = 'NUMBER',
 5 |     BOOLEAN = 'BOOLEAN',
 6 |     DATE = 'DATE',
 7 |     FAKER = 'FAKER',
 8 |     OBJECT = 'OBJECT',
 9 |     ARRAY_OBJECT = 'ARRAY_OBJECT',
10 |     ARRAY_STRING = 'ARRAY_STRING',
11 |     ARRAY_NUMBER = 'ARRAY_NUMBER',
12 |     ENUM = 'ENUM',
13 |     ENTITIES = 'ENTITIES'
14 | }
15 | 


--------------------------------------------------------------------------------
/libs/mocks/helpers/check-type.helper.ts:
--------------------------------------------------------------------------------
 1 | import { TypeSelectionEnum } from '~mocks/enums/type-selection.enum';
 2 | 
 3 | export const isArrayOfObjectType = (type) => type === TypeSelectionEnum.ARRAY_OBJECT;
 4 | export const isArrayOfPrimitiveType = (type) =>
 5 |     type === TypeSelectionEnum.ARRAY_STRING || type === TypeSelectionEnum.ARRAY_NUMBER;
 6 | 
 7 | export const isObjectType = (type) => type === TypeSelectionEnum.OBJECT;
 8 | export const isUUIDType = (type) => type === TypeSelectionEnum.UUID;
 9 | export const isFakerType = (type) => type === TypeSelectionEnum.FAKER;
10 | export const isEnumType = (type) => type === TypeSelectionEnum.ENUM;
11 | export const isEntitiesType = (type) => type === TypeSelectionEnum.ENTITIES;
12 | export const isPrimitive = (type) =>
13 |     type === TypeSelectionEnum.UUID ||
14 |     type === TypeSelectionEnum.STRING ||
15 |     type === TypeSelectionEnum.NUMBER ||
16 |     type === TypeSelectionEnum.BOOLEAN ||
17 |     type === TypeSelectionEnum.FAKER;
18 | 


--------------------------------------------------------------------------------
/libs/mocks/http/controllers/mock-api-creator.controller.ts:
--------------------------------------------------------------------------------
 1 | import { Body, Controller, Get, Post, Render } from '@nestjs/common';
 2 | import { ApiOperation } from '@nestjs/swagger';
 3 | import { MockApiCreatorService } from '~mocks/services/mock-api-creator.service';
 4 | import { CreateMockApiDto } from '~mocks/dtos/create-mock-api.dto';
 5 | import { RequestMethodEnum } from '~mocks/enums/request-method.enum';
 6 | import { TypeSelectionEnum } from '~mocks/enums/type-selection.enum';
 7 | 
 8 | @Controller('mock-api-creator')
 9 | export class MockApiCreatorController {
10 |     constructor(private mockApiCreatorService: MockApiCreatorService) {}
11 | 
12 |     @Post()
13 |     @ApiOperation({
14 |         description: 'Create a new mocking api endpoint'
15 |     })
16 |     create(@Body() dto: CreateMockApiDto) {
17 |         return this.mockApiCreatorService.createMockApi(dto);
18 |     }
19 | 
20 |     @Get('')
21 |     @ApiOperation({
22 |         description: 'Create mock api page'
23 |     })
24 |     @Render('mock-api-creator')
25 |     loadMockApiCreatePage() {
26 |         const fakerMethods = MockApiCreatorService.listFakerMethods();
27 |         const entities = MockApiCreatorService.getCurrentEntities(['File', 'User', 'Otp']);
28 |         const requestMethods = Object.keys(RequestMethodEnum);
29 |         const typeSelection = Object.keys(TypeSelectionEnum);
30 |         const delaySelection = ['0', '1', '3', '5', '8'];
31 | 
32 |         return {
33 |             entities,
34 |             fakerMethods,
35 |             requestMethods,
36 |             typeSelection,
37 |             delaySelection
38 |         };
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/libs/mocks/http/controllers/mock-api.controller.ts:
--------------------------------------------------------------------------------
 1 | import { Controller, Delete, Get, Patch, Post, Put } from '@nestjs/common';
 2 | import { ApiOperation, ApiTags } from '@nestjs/swagger';
 3 | import { MockApiService } from '~mocks/services/mock-api.service';
 4 | import { CustomRequest } from '~mocks/decorators/custom-request.decorator';
 5 | 
 6 | @Controller('mocks')
 7 | @ApiTags('Mocks')
 8 | export class MockApiController {
 9 |     constructor(private readonly mockApiService: MockApiService) {}
10 | 
11 |     @Get('*')
12 |     @ApiOperation({
13 |         description: 'Get response of mock api for GET method'
14 |     })
15 |     getResponseForGetMethod(@CustomRequest() customRequest: CustomRequest) {
16 |         return this.mockApiService.getMockApiResponse(customRequest);
17 |     }
18 | 
19 |     @Put('*')
20 |     @ApiOperation({
21 |         description: 'Get response of mock api for POST method'
22 |     })
23 |     getResponseForPutMethod(@CustomRequest() customRequest: CustomRequest) {
24 |         return this.mockApiService.getMockApiResponse(customRequest);
25 |     }
26 | 
27 |     @Patch('*')
28 |     @ApiOperation({
29 |         description: 'Get response of mock api for PATCH method'
30 |     })
31 |     getResponseForPatchMethod(@CustomRequest() customRequest: CustomRequest) {
32 |         return this.mockApiService.getMockApiResponse(customRequest);
33 |     }
34 | 
35 |     @Post('*')
36 |     @ApiOperation({
37 |         description: 'Get response of mock api for POST method'
38 |     })
39 |     getResponseForPostMethod(@CustomRequest() customRequest: CustomRequest) {
40 |         return this.mockApiService.getMockApiResponse(customRequest);
41 |     }
42 | 
43 |     @Delete('*')
44 |     @ApiOperation({
45 |         description: 'Get response of mock api for DELETE method'
46 |     })
47 |     getResponseForDeleteMethod(@CustomRequest() customRequest: CustomRequest) {
48 |         return this.mockApiService.getMockApiResponse(customRequest);
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/libs/mocks/interfaces/api-swagger-document.interface.ts:
--------------------------------------------------------------------------------
 1 | interface Endpoint {
 2 |     operationId: string;
 3 |     summary?: string;
 4 |     description?: string;
 5 |     tags: string[];
 6 | }
 7 | 
 8 | interface Endpoints {
 9 |     [method: string]: Endpoint;
10 | }
11 | 
12 | export interface ApiSwaggerDocumentInterface {
13 |     [endpoint: string]: Endpoints;
14 | }
15 | 


--------------------------------------------------------------------------------
/libs/mocks/interfaces/column-mete-args.interface.ts:
--------------------------------------------------------------------------------
1 | import { ColumnType } from 'typeorm';
2 | 
3 | export interface ColumnMeteArgs {
4 |     key: string;
5 |     type: ColumnType;
6 |     isRequired: boolean;
7 | }
8 | 


--------------------------------------------------------------------------------
/libs/mocks/interfaces/faker-type.interface.ts:
--------------------------------------------------------------------------------
1 | export interface FakerType {
2 |     category: string;
3 |     method: string;
4 | }
5 | 


--------------------------------------------------------------------------------
/libs/mocks/interfaces/mock-api-options.interface.ts:
--------------------------------------------------------------------------------
1 | export interface MockApiOptions {
2 |     path: string;
3 |     maximumRandomResponse: number;
4 | }
5 | 


--------------------------------------------------------------------------------
/libs/mocks/interfaces/mock-api.interface.ts:
--------------------------------------------------------------------------------
1 | import { RequestMethodEnum } from '~mocks/enums/request-method.enum';
2 | 
3 | export interface MockApi {
4 |     method: RequestMethodEnum;
5 |     response: any[];
6 | }
7 | 


--------------------------------------------------------------------------------
/libs/mocks/interfaces/swagger-spec.interface.ts:
--------------------------------------------------------------------------------
 1 | import { PathsObject, SchemaObject } from '@nestjs/swagger/dist/interfaces/open-api-spec.interface';
 2 | 
 3 | export interface SwaggerSpec {
 4 |     pathObject: PathsObject;
 5 |     schemaObject: {
 6 |         key: string;
 7 |         value: SchemaObject;
 8 |     };
 9 | }
10 | 


--------------------------------------------------------------------------------
/libs/mocks/interfaces/update-mock-api-json.interface.ts:
--------------------------------------------------------------------------------
 1 | import { RequestMethodEnum } from '~mocks/enums/request-method.enum';
 2 | import { PathsObject, SchemaObject } from '@nestjs/swagger/dist/interfaces/open-api-spec.interface';
 3 | 
 4 | export interface UpdateMockApiJson {
 5 |     method: RequestMethodEnum;
 6 |     endpoint: string;
 7 |     pathObject: PathsObject;
 8 |     schemaObject?: {
 9 |         key: string;
10 |         value: SchemaObject;
11 |     };
12 |     responses?: any[];
13 | }
14 | 


--------------------------------------------------------------------------------
/libs/mocks/mock.module.ts:
--------------------------------------------------------------------------------
 1 | import { DynamicModule, Module, ValueProvider } from '@nestjs/common';
 2 | import { MockApiCreatorController } from '~mocks/http/controllers/mock-api-creator.controller';
 3 | import { MockApiController } from '~mocks/http/controllers/mock-api.controller';
 4 | import { MockApiCreatorService } from '~mocks/services/mock-api-creator.service';
 5 | import { SwaggerService } from '~mocks/services/swagger.service';
 6 | import { MockApiService } from '~mocks/services/mock-api.service';
 7 | import { MOCK_API_PATH } from '~mocks/constants/mock-api-path.constant';
 8 | import { MockApiOptions } from '~mocks/interfaces/mock-api-options.interface';
 9 | import { MAXIMUM_RANDOM_RESPONSE } from '~mocks/constants/maximum-random-response.constant';
10 | 
11 | @Module({
12 |     providers: [MockApiCreatorService, MockApiService, SwaggerService],
13 |     controllers: [MockApiCreatorController, MockApiController],
14 |     imports: [],
15 |     exports: []
16 | })
17 | export class MockApiModule {
18 |     static forRoot(options: MockApiOptions): DynamicModule {
19 |         const mockApiPathProvider: ValueProvider<string> = {
20 |             provide: MOCK_API_PATH,
21 |             useValue: options.path
22 |         };
23 | 
24 |         const maximumRandomResponse: ValueProvider<number> = {
25 |             provide: MAXIMUM_RANDOM_RESPONSE,
26 |             useValue: options.maximumRandomResponse || 10
27 |         };
28 | 
29 |         return {
30 |             module: MockApiModule,
31 |             providers: [mockApiPathProvider, maximumRandomResponse],
32 |             exports: []
33 |         };
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/libs/mocks/services/mock-api-creator.service.ts:
--------------------------------------------------------------------------------
  1 | import { Inject, Injectable } from '@nestjs/common';
  2 | import { CreateMockApiDto } from '~mocks/dtos/create-mock-api.dto';
  3 | import * as faker from 'faker';
  4 | import { v4 as uuidv4 } from 'uuid';
  5 | import { CreatePropertyDto } from '~mocks/dtos/create-property.dto';
  6 | import { TypeSelectionEnum } from '~mocks/enums/type-selection.enum';
  7 | import { FakerType } from '~mocks/interfaces/faker-type.interface';
  8 | import { SwaggerService } from '~mocks/services/swagger.service';
  9 | import {
 10 |     isArrayOfObjectType,
 11 |     isArrayOfPrimitiveType,
 12 |     isEnumType,
 13 |     isObjectType,
 14 |     isPrimitive
 15 | } from '~mocks/helpers/check-type.helper';
 16 | import { readFileSync, writeFileSync } from 'fs';
 17 | import { UpdateMockApiJson } from '~mocks/interfaces/update-mock-api-json.interface';
 18 | import { map } from 'lodash';
 19 | import { getMetadataArgsStorage } from 'typeorm';
 20 | import { ColumnMeteArgs } from '~mocks/interfaces/column-mete-args.interface';
 21 | import { MOCK_API_PATH } from '~mocks/constants/mock-api-path.constant';
 22 | import { MAXIMUM_RANDOM_RESPONSE } from '~mocks/constants/maximum-random-response.constant';
 23 | 
 24 | @Injectable()
 25 | export class MockApiCreatorService {
 26 |     constructor(
 27 |         @Inject(MOCK_API_PATH) private mockApiPath,
 28 |         @Inject(MAXIMUM_RANDOM_RESPONSE) private randomDataCount,
 29 |         private swaggerService: SwaggerService
 30 |     ) {}
 31 | 
 32 |     static listFakerMethods() {
 33 |         const fakerMethods = [
 34 |             'address',
 35 |             'commerce',
 36 |             'company',
 37 |             'database',
 38 |             'datatype',
 39 |             'date',
 40 |             'finance',
 41 |             'git',
 42 |             'hacker',
 43 |             'helpers',
 44 |             'image',
 45 |             'internet',
 46 |             'lorem',
 47 |             'name',
 48 |             'music',
 49 |             'phone',
 50 |             'random',
 51 |             'system',
 52 |             'time',
 53 |             'vehicle'
 54 |         ];
 55 |         return fakerMethods.map((category) => ({
 56 |             category,
 57 |             methods: Object.keys(faker[category])
 58 |         }));
 59 |     }
 60 | 
 61 |     static getCurrentEntities(excludes: string[] = []): Record<string, ColumnMeteArgs[]> {
 62 |         const tables = getMetadataArgsStorage().tables;
 63 |         const columns = getMetadataArgsStorage().columns;
 64 |         const mapColumnsToTable = tables.reduce((acc, table) => {
 65 |             if (!excludes.includes(table.name)) {
 66 |                 acc[table.name] = [];
 67 |             }
 68 |             return acc;
 69 |         }, {});
 70 | 
 71 |         for (const {
 72 |             target,
 73 |             propertyName,
 74 |             options: { type, nullable }
 75 |         } of columns) {
 76 |             const columnData = {
 77 |                 key: propertyName,
 78 |                 type,
 79 |                 isRequired: !nullable
 80 |             };
 81 | 
 82 |             const table = Object.getOwnPropertyDescriptor(target, 'name').value.replace('Entity', '');
 83 |             if (!excludes.includes(table)) {
 84 |                 mapColumnsToTable[table]?.push(columnData);
 85 |             }
 86 |         }
 87 |         return mapColumnsToTable;
 88 |     }
 89 | 
 90 |     static generateValueByType(
 91 |         type: TypeSelectionEnum,
 92 |         fakerType?: FakerType,
 93 |         overrideValue?: string | number
 94 |     ): string | number | boolean | Date {
 95 |         if (overrideValue) {
 96 |             return overrideValue;
 97 |         }
 98 |         switch (type) {
 99 |             case TypeSelectionEnum.UUID:
100 |                 return uuidv4();
101 |             case TypeSelectionEnum.STRING:
102 |                 return faker.name.title();
103 |             case TypeSelectionEnum.NUMBER:
104 |                 return faker.datatype.number();
105 |             case TypeSelectionEnum.BOOLEAN:
106 |                 return Math.floor(Math.random() * 3) > 1;
107 |             case TypeSelectionEnum.DATE:
108 |                 return faker.date.future().getTime();
109 |             case TypeSelectionEnum.FAKER:
110 |                 const { category, method } = fakerType;
111 |                 return faker[category][method]();
112 |         }
113 |     }
114 | 
115 |     static generateNestedProperty(nestedProperty: CreatePropertyDto) {
116 |         const { key, type, fakerType, overrideValue } = nestedProperty;
117 |         return key
118 |             ? { [key]: MockApiCreatorService.generateValueByType(type, fakerType, overrideValue) }
119 |             : MockApiCreatorService.generateValueByType(type, fakerType, overrideValue);
120 |     }
121 | 
122 |     static initSchemaIfNotExist(mockApiJSON: any, endpoint: string) {
123 |         if (!mockApiJSON.paths[endpoint]) {
124 |             mockApiJSON.paths[endpoint] = {};
125 |         }
126 |         if (!mockApiJSON.responses[endpoint]) {
127 |             mockApiJSON.responses[endpoint] = {};
128 |         }
129 |     }
130 | 
131 |     public createMockApi(dto: CreateMockApiDto) {
132 |         const { method, body, endpoint, response } = dto;
133 |         const mockEndpoint = `/mocks${endpoint}`;
134 |         const { pathObject, schemaObject } = this.swaggerService.buildSwaggerSpec({
135 |             method,
136 |             endpoint: mockEndpoint,
137 |             body
138 |         });
139 | 
140 |         const data: UpdateMockApiJson = {
141 |             method,
142 |             endpoint: mockEndpoint,
143 |             pathObject,
144 |             schemaObject
145 |         };
146 |         if (response.length) {
147 |             data.responses = this.generateResponse(dto.response);
148 |         }
149 |         return this.updateMockApiJSON(data);
150 |     }
151 | 
152 |     private generateData(properties: CreatePropertyDto[]) {
153 |         const responses: any = {};
154 |         for (const property of properties) {
155 |             const { key, type, fakerType, overrideValue, items } = property;
156 | 
157 |             if (isArrayOfObjectType(type)) {
158 |                 responses[key] = this.generateData(items);
159 |             }
160 | 
161 |             if (isArrayOfPrimitiveType(type)) {
162 |                 responses[key] = items.map((nestedProperty) =>
163 |                     MockApiCreatorService.generateNestedProperty(nestedProperty)
164 |                 );
165 |             }
166 | 
167 |             if (isObjectType(type)) {
168 |                 responses[key] = this.generateData(items);
169 |             }
170 | 
171 |             if (isPrimitive(type)) {
172 |                 responses[key] = MockApiCreatorService.generateValueByType(type, fakerType, overrideValue);
173 |             }
174 | 
175 |             if (isEnumType(type)) {
176 |                 const enumValues = map(items, 'key');
177 |                 const randomEnumValue = enumValues[Math.floor(Math.random() * enumValues.length)];
178 |                 responses[key] = randomEnumValue;
179 |             }
180 |         }
181 |         return responses;
182 |     }
183 | 
184 |     private generateResponse(properties: CreatePropertyDto[], times: number = this.randomDataCount) {
185 |         const responses = [];
186 |         for (let i = 0; i <= times; i++) {
187 |             responses.push(this.generateData(properties));
188 |         }
189 |         return responses;
190 |     }
191 | 
192 |     private parseMockApiJsonFile() {
193 |         return JSON.parse(readFileSync(this.mockApiPath, { encoding: 'utf-8' }));
194 |     }
195 | 
196 |     private saveMockApiJSON(mockApiJSON) {
197 |         writeFileSync(this.mockApiPath, JSON.stringify(mockApiJSON));
198 |     }
199 | 
200 |     private updateMockApiJSON({ method, endpoint, pathObject, schemaObject, responses }: UpdateMockApiJson) {
201 |         const mockApiJSON = this.parseMockApiJsonFile();
202 |         MockApiCreatorService.initSchemaIfNotExist(mockApiJSON, endpoint);
203 | 
204 |         const lowerMethod = method.toLowerCase();
205 |         mockApiJSON.paths[endpoint][lowerMethod] = pathObject[endpoint][lowerMethod];
206 |         if (schemaObject) {
207 |             mockApiJSON.components.schemas[schemaObject.key] = schemaObject.value;
208 |         }
209 |         if (responses) {
210 |             mockApiJSON.responses[endpoint][lowerMethod] = responses;
211 |         }
212 |         this.saveMockApiJSON(mockApiJSON);
213 |         return 1;
214 |     }
215 | }
216 | 


--------------------------------------------------------------------------------
/libs/mocks/services/mock-api.service.ts:
--------------------------------------------------------------------------------
 1 | import { Inject, Injectable } from '@nestjs/common';
 2 | import { readFileSync } from 'fs';
 3 | import { resolve } from 'path';
 4 | import { CustomRequest } from '~mocks/decorators/custom-request.decorator';
 5 | import { MOCK_API_PATH } from '~mocks/constants/mock-api-path.constant';
 6 | 
 7 | @Injectable()
 8 | export class MockApiService {
 9 |     constructor(@Inject(MOCK_API_PATH) private mockApiPath) {}
10 | 
11 |     private parseMockApiResponseData() {
12 |         return JSON.parse(readFileSync(resolve(this.mockApiPath), { encoding: 'utf-8' }));
13 |     }
14 | 
15 |     public getMockApiResponse(request: CustomRequest) {
16 |         const { endpoint, method } = request;
17 |         const data = this.parseMockApiResponseData();
18 |         return data.responses[endpoint]?.[method];
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/libs/mocks/services/swagger.service.ts:
--------------------------------------------------------------------------------
  1 | import { Injectable } from '@nestjs/common';
  2 | import { CreatePropertyDto } from '~mocks/dtos/create-property.dto';
  3 | import { PathsObject, SchemaObject } from '@nestjs/swagger/dist/interfaces/open-api-spec.interface';
  4 | import { TypeSelectionEnum } from '~mocks/enums/type-selection.enum';
  5 | import { RequestMethodEnum } from '~mocks/enums/request-method.enum';
  6 | import { v4 as uuidv4 } from 'uuid';
  7 | import {
  8 |     isArrayOfObjectType,
  9 |     isArrayOfPrimitiveType,
 10 |     isEnumType,
 11 |     isFakerType,
 12 |     isObjectType,
 13 |     isUUIDType
 14 | } from '~mocks/helpers/check-type.helper';
 15 | import { FakerType } from '~mocks/interfaces/faker-type.interface';
 16 | import { map } from 'lodash';
 17 | import { SwaggerSpecResponse } from '~mocks/types/swagger-spec-response.type';
 18 | 
 19 | @Injectable()
 20 | export class SwaggerService {
 21 |     static mapResponseByMethod(method: RequestMethodEnum) {
 22 |         switch (method) {
 23 |             case RequestMethodEnum.POST:
 24 |                 return { '201': { description: '' } };
 25 |             case RequestMethodEnum.GET:
 26 |             case RequestMethodEnum.PATCH:
 27 |             case RequestMethodEnum.PUT:
 28 |             case RequestMethodEnum.DELETE:
 29 |                 return { '200': { description: '' } };
 30 |         }
 31 |     }
 32 | 
 33 |     static splitEndpoint(endpoint: string): { prefix: string; resource: string } {
 34 |         const splitEndpoint = endpoint.split('/');
 35 |         return {
 36 |             prefix: splitEndpoint[1],
 37 |             resource: splitEndpoint[2]
 38 |         };
 39 |     }
 40 | 
 41 |     static capitalizeFirstLetter(prefix) {
 42 |         return prefix.charAt(0).toUpperCase() + prefix.slice(1);
 43 |     }
 44 | 
 45 |     static buildDtoObject(method: RequestMethodEnum, resource: string) {
 46 |         const requestMethodDtoMapper = {
 47 |             [RequestMethodEnum.PUT]: 'Update',
 48 |             [RequestMethodEnum.PATCH]: 'Modifies',
 49 |             [RequestMethodEnum.POST]: 'Create',
 50 |             [RequestMethodEnum.DELETE]: 'Delete'
 51 |         };
 52 |         const capitalizedResource = SwaggerService.capitalizeFirstLetter(resource);
 53 |         const standardizedResource = capitalizedResource.slice(0, capitalizedResource.length - 1);
 54 |         return `${requestMethodDtoMapper[method]}${standardizedResource}Dto`;
 55 |     }
 56 | 
 57 |     static maybeHavingRequestBody(method) {
 58 |         return (
 59 |             method === RequestMethodEnum.POST ||
 60 |             method === RequestMethodEnum.PUT ||
 61 |             method === RequestMethodEnum.PATCH ||
 62 |             method === RequestMethodEnum.DELETE
 63 |         );
 64 |     }
 65 | 
 66 |     static buildPathObject(endpoint: string, method: RequestMethodEnum, body?: CreatePropertyDto[]): PathsObject {
 67 |         const { prefix, resource } = SwaggerService.splitEndpoint(endpoint);
 68 |         const pathObject: PathsObject = {
 69 |             [endpoint]: {
 70 |                 [method.toLowerCase()]: {
 71 |                     operationId: uuidv4(),
 72 |                     summary: '',
 73 |                     description: '',
 74 |                     tags: [SwaggerService.capitalizeFirstLetter(prefix)],
 75 |                     responses: SwaggerService.mapResponseByMethod(method)
 76 |                 }
 77 |             }
 78 |         };
 79 |         const operationObject = pathObject[endpoint][method.toLowerCase()];
 80 |         if (SwaggerService.maybeHavingRequestBody(method)) {
 81 |             operationObject.requestBody = body
 82 |                 ? {
 83 |                       require: true,
 84 |                       content: {
 85 |                           'application/json': {
 86 |                               schema: {
 87 |                                   $ref: `#/components/schemas/${SwaggerService.buildDtoObject(method, resource)}`
 88 |                               }
 89 |                           }
 90 |                       }
 91 |                   }
 92 |                 : {};
 93 |         }
 94 | 
 95 |         return pathObject;
 96 |     }
 97 | 
 98 |     public buildSwaggerSpec(data: {
 99 |         method: RequestMethodEnum;
100 |         endpoint: string;
101 |         body?: CreatePropertyDto[];
102 |     }): SwaggerSpecResponse {
103 |         const { method, endpoint, body } = data;
104 |         const { resource } = SwaggerService.splitEndpoint(endpoint);
105 | 
106 |         const pathObject = SwaggerService.buildPathObject(endpoint, method, body);
107 |         if (SwaggerService.maybeHavingRequestBody(method) && body) {
108 |             const schemaObject = {
109 |                 key: SwaggerService.buildDtoObject(method, resource),
110 |                 value: this.buildSchemeObject(body)
111 |             };
112 | 
113 |             return {
114 |                 pathObject,
115 |                 schemaObject
116 |             };
117 |         }
118 | 
119 |         return {
120 |             pathObject
121 |         };
122 |     }
123 | 
124 |     private mapSchemaFakerType(schema: SchemaObject, fakerType: FakerType): SchemaObject {
125 |         const { category, method } = fakerType;
126 |         schema.type = TypeSelectionEnum.STRING.toLowerCase();
127 |         schema.example = `${category.toUpperCase()}_${method}`;
128 |         return schema;
129 |     }
130 | 
131 |     private mapSchemaEnumType(schema: SchemaObject, items: CreatePropertyDto[]): SchemaObject {
132 |         schema.type = TypeSelectionEnum.STRING.toLowerCase();
133 |         schema.enum = map(items, 'key');
134 |         return schema;
135 |     }
136 | 
137 |     private mapSchemaUUIDType(schema: SchemaObject): SchemaObject {
138 |         schema.type = TypeSelectionEnum.STRING.toLowerCase();
139 |         schema.example = uuidv4();
140 |         return schema;
141 |     }
142 | 
143 |     private mapSchemaObjectType(schema: SchemaObject, items: CreatePropertyDto[]): SchemaObject {
144 |         schema.type = TypeSelectionEnum.OBJECT.toLowerCase();
145 |         for (const nestedProperty of items) {
146 |             if (!schema.properties) {
147 |                 schema.properties = {};
148 |             }
149 |             schema.properties[nestedProperty.key] = this.buildSchema(nestedProperty);
150 |         }
151 |         return schema;
152 |     }
153 | 
154 |     private mapSchemaArrayOfObjectType(schema: SchemaObject, items: CreatePropertyDto[]): SchemaObject {
155 |         schema.type = 'array';
156 |         for (const nestedProperty of items) {
157 |             if (!schema.items) {
158 |                 schema.items = {};
159 |             }
160 |             schema.items[nestedProperty.key] = this.buildSchema(nestedProperty);
161 |         }
162 |         return schema;
163 |     }
164 | 
165 |     private mapSchemaArrayOfPrimitiveType(schema: SchemaObject, items: CreatePropertyDto[]): SchemaObject {
166 |         schema.type = 'array';
167 |         for (const nestedProperty of items) {
168 |             if (!schema.items) {
169 |                 schema.items = {};
170 |             }
171 |             schema.items = { type: nestedProperty.type };
172 |         }
173 |         return schema;
174 |     }
175 | 
176 |     private buildSchema(property: CreatePropertyDto) {
177 |         const { type, fakerType, overrideValue, defaultValue, items } = property;
178 | 
179 |         let schema: SchemaObject = { type: type.toLowerCase() };
180 |         if (overrideValue) {
181 |             schema.example = overrideValue;
182 |         }
183 |         if (defaultValue) {
184 |             schema.default = defaultValue;
185 |         }
186 |         if (isArrayOfObjectType(type)) {
187 |             schema = this.mapSchemaArrayOfObjectType(schema, items);
188 |         }
189 |         if (isArrayOfPrimitiveType(type)) {
190 |             schema = this.mapSchemaArrayOfPrimitiveType(schema, items);
191 |         }
192 |         if (isObjectType(type)) {
193 |             schema = this.mapSchemaObjectType(schema, items);
194 |         }
195 |         if (isUUIDType(type)) {
196 |             schema = this.mapSchemaUUIDType(schema);
197 |         }
198 |         if (isFakerType(type)) {
199 |             schema = this.mapSchemaFakerType(schema, fakerType);
200 |         }
201 |         if (isEnumType(type)) {
202 |             schema = this.mapSchemaEnumType(schema, items);
203 |         }
204 |         return schema;
205 |     }
206 | 
207 |     private buildSchemeObject(properties: CreatePropertyDto[]): SchemaObject {
208 |         const schemas: SchemaObject = {
209 |             type: 'object',
210 |             required: [],
211 |             properties: {}
212 |         };
213 |         for (const property of properties) {
214 |             if (property.isRequired) {
215 |                 schemas.required.push(property.key);
216 |             }
217 |             schemas.properties[property.key] = this.buildSchema(property);
218 |         }
219 |         return schemas;
220 |     }
221 | }
222 | 


--------------------------------------------------------------------------------
/libs/mocks/types/swagger-spec-response.type.ts:
--------------------------------------------------------------------------------
1 | import { SwaggerSpec } from '~mocks/interfaces/swagger-spec.interface';
2 | 
3 | export type SwaggerSpecResponse = Partial<SwaggerSpec>;
4 | 


--------------------------------------------------------------------------------
/libs/static/index.css:
--------------------------------------------------------------------------------
 1 | .toast {
 2 |     position: fixed;
 3 |     top: 10px;
 4 |     right: 10px;
 5 | }
 6 | 
 7 | .form-wrapper {
 8 |     margin: 30px 450px;
 9 | }
10 | 
11 | .action-container {
12 |     display: flex;
13 |     padding: 0 !important;
14 |     height: 40px;
15 | }
16 | 
17 | .action-container > div {
18 |     padding-right: 10px;
19 | }
20 | 
21 | .request-methods-wrapper {
22 |     width: 16%;
23 | }
24 | 
25 | #endpoint-wrapper {
26 |     width: 75%;
27 | }
28 | 
29 | .delay-wrapper {
30 |     width: 15%;
31 | }
32 | 
33 | .form-select-property {
34 |     width: 20% !important;
35 |     margin: 0
36 | }
37 | 
38 | .faker-methods-select {
39 |     width: 250px !important;
40 | }
41 | 
42 | .form-control-key {
43 |     width: 25% !important;
44 | }
45 | 
46 | .override-value-input {
47 |     width: 250px !important;
48 | }
49 | 
50 | .add-nested-property-btn {
51 |     width: 35px;
52 | }
53 | 
54 | .endpoint-group {
55 |     height: 30px !important;
56 | }
57 | 
58 | .remove-property-btn {
59 |     opacity: 0 !important;
60 | }
61 | 
62 | .remove-property-btn:hover {
63 |     opacity: 100 !important;
64 |     transition: opacity 0.7s;
65 | }
66 | 
67 | .is-required-checkbox {
68 |     width: 28px;
69 |     height: 16px;
70 |     margin: 12px 2px 0px 10px;
71 | }
72 | 


--------------------------------------------------------------------------------
/libs/views/mock-api-creator.hbs:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html>
  3 | <head>
  4 |     <meta charset="utf-8">
  5 |     <title>Mock Api Creat page</title>
  6 |     <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>
  7 |     <link rel='stylesheet' href='/index.css'>
  8 |     <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.0/dist/css/bootstrap.min.css" rel="stylesheet"
  9 |           integrity="sha384-KyZXEAg3QhqLMpG8r+8fhAXLRk2vvoC2f3B09zVXn8CA5QIVfZOJ3BCsw2P0p/We" crossorigin="anonymous">
 10 |     <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.1.0/dist/js/bootstrap.bundle.min.js"
 11 |             integrity="sha384-U1DAWAznBHeqEIlVSCgzq+c9gqGAJn5c/t99JyeKa9xxaYpSvHU5awsuZVVFIhvj"
 12 |             crossorigin="anonymous"></script>
 13 | </head>
 14 | <body>
 15 | <div class="toast toast-success">
 16 |     <div class="toast-header bg-success">
 17 |         <strong class="mr-auto text-white">Success</strong>
 18 |     </div>
 19 |     <div class="toast-body text-success">
 20 |         Add mock API successfully!
 21 |     </div>
 22 | </div>
 23 | <div class="toast toast-failed">
 24 |     <div class="toast-header bg-danger">
 25 |         <strong class="mr-auto text-white">Failed!</strong>
 26 |     </div>
 27 |     <div class="toast-body text-danger">
 28 |         Please check your input again!
 29 |     </div>
 30 | </div>
 31 | <div class='form-wrapper d-flex flex-column justify-content-center'>
 32 |     <form class='needs-validation' novalidate>
 33 |         <div class='form-row'>
 34 |             <div class='action-container container-lg'>
 35 |                 <div class='request-methods-wrapper'>
 36 |                     <select class='form-select form-select-sm request-method-select'>
 37 |                         {{#each requestMethods}}
 38 |                             <option value={{this}}>{{this}}</option>
 39 |                         {{/each}}
 40 |                     </select>
 41 |                 </div>
 42 |                 <div id='endpoint-wrapper' class="input-group">
 43 |                     <span class="input-group-text endpoint-group">Endpoint</span>
 44 |                     <input
 45 |                         type="text" class="form-control endpoint endpoint-group" placeholder="/users/:id"
 46 |                         aria-label="/users/:id"
 47 |                         aria-describedby="basic-addon2"
 48 |                         required
 49 |                     >
 50 |                 </div>
 51 |                 <div class='delay-wrapper'>
 52 |                     <select class='form-select form-select-sm delay-select'>
 53 |                         {{#each delaySelection}}
 54 |                             <option value={{this}}>{{this}}s</option>
 55 |                         {{/each}}
 56 |                     </select>
 57 | 
 58 |                 </div>
 59 |             </div>
 60 |             <div class='body-container mt-4 py-4 px-4 border border-dark rounded'>
 61 |                 <div class='body d-flex justify-content-between'>
 62 |                     <span class='h4'>Body</span>
 63 |                     <div>
 64 |                         <div class="form-check">
 65 |                             <input class="has-body-checkbox form-check-input" type="checkbox" value=""
 66 |                                    id="hasBodyCheckbox"
 67 |                                    onchange='toggleAddBodyCheckBox()' checked>
 68 |                             <label class="form-check-label" for="flexCheckChecked">
 69 |                                 Has body
 70 |                             </label>
 71 |                         </div>
 72 |                     </div>
 73 |                 </div>
 74 |                 <div class='body-properties-wrapper d-flex flex-center flex-column mb-2 mt-3'></div>
 75 |                 <button class='add-body-property-btn add-btn btn btn-primary rounded-circle'
 76 |                         onclick='handleCLickAddProperty(event)'>+
 77 |                 </button>
 78 |             </div>
 79 |             <div class='response-container mt-5 py-4 px-4 border border-dark rounded'>
 80 |                 <span class='h4'>Response</span>
 81 |                 <div class='response-properties-wrapper d-flex flex-center flex-column mb-2 mt-4'></div>
 82 |                 <button class='add-response-property-btn add-btn btn btn-primary rounded-circle mt-1'
 83 |                         onclick='handleCLickAddProperty(event)'>
 84 |                     +
 85 |                 </button>
 86 |             </div>
 87 |             <div class="d-flex align-items-end flex-column bd-highlight mt-3">
 88 |                 <button
 89 |                     class='add-response-property-btn add-btn btn btn-primary mt-1'
 90 |                     type='submit'
 91 |                 >
 92 |                     Add API
 93 |                 </button>
 94 |             </div>
 95 |         </div>
 96 |     </form>
 97 | </div>
 98 | </body>
 99 | </html>
100 | <script>
101 |     const BACKEND_API = '/mock-api-creator';
102 |     const TYPES_SELECTION = ['', ...{{json typeSelection}}];
103 |     const ENTITIES_SELECTION = { ['']: [], ...{{json entities}} };
104 |     const FAKER_METHODS_SELECTION = {{json fakerMethods}}
105 | 
106 |     const isFakerType = (type => type === 'FAKER');
107 |     const isPrimitiveType = (type => type === 'NUMBER' || type === 'STRING');
108 |     const isObjectType = (type => type === 'OBJECT' || type === 'ARRAY_OBJECT');
109 |     const isArrayOfPrimitiveType = (type => type === 'ARRAY_STRING' || type === 'ARRAY_NUMBER');
110 |     const isEnumType = (type => type === 'ENUM');
111 |     const isEntitiesType = (type => type === 'ENTITIES');
112 | 
113 |     /* HANDLE SUBMIT*/
114 | 
115 |     window.addEventListener('load', function() {
116 |         const forms = $('.needs-validation');
117 |         Array.prototype.filter.call(forms, function(form) {
118 |             form.addEventListener('submit', function(event) {
119 |                 if (form.checkValidity() === false) {
120 |                     event.preventDefault();
121 |                     event.stopPropagation();
122 |                     $('.toast-failed').toast('show');
123 |                 } else {
124 |                     handleClickSubmit(event);
125 |                     form.reset();
126 |                 }
127 |                 form.classList.add('was-validated');
128 |             }, false);
129 |         });
130 |     }, false);
131 | 
132 |     function isValidEndpoint(endpoint) {
133 |         const [_, resource] = endpoint.split('/');
134 |         return endpoint[0] === '/' && !!resource;
135 |     }
136 | 
137 |     function getProperty(property) {
138 |         const propertyData = {};
139 |         const children = $(property).children();
140 |         const key = children.filter(ele => children[ele].className.includes('key')).val();
141 |         const type = children.filter(ele => children[ele].className.includes('type')).val();
142 |         const isRequired = children.filter(ele => children[ele].className.includes('is-required-checkbox')).is(':checked');
143 |         const overrideValue = children.filter(ele => children[ele].className.includes('override-value-input')).val();
144 |         const defaultValue = children.filter(ele => children[ele].className.includes('default-value-input')).val();
145 | 
146 |         if (overrideValue) {
147 |             propertyData.overrideValue = overrideValue;
148 |         }
149 |         if (defaultValue) {
150 |             propertyData.defaultValue = defaultValue;
151 |         }
152 |         if (isFakerType(type)) {
153 |             const fakerMethod = children.filter(ele => children[ele].className.includes('faker-methods-select')).val();
154 |             const [category, method] = fakerMethod.split('-');
155 |             propertyData.fakerType = { category, method };
156 |         }
157 | 
158 |         if (isObjectType(type) || isArrayOfPrimitiveType(type) || isEnumType(type)) {
159 |             const items = [];
160 |             const nestedPropertiesWrapper = $(property).next().children().filter('.wrapper-property');
161 |             for (const nestedProperty of nestedPropertiesWrapper) {
162 |                 const nestedPropertyData = getProperty($(nestedProperty).children().filter(ele => children[ele].className.includes('key')));
163 |                 items.push(...nestedPropertyData);
164 |             }
165 |             propertyData.items = items;
166 | 
167 |         }
168 | 
169 |         if (isEntitiesType(type)) {
170 |             const properties = [];
171 |             const nestedPropertiesWrapper = $(property).next().children().filter('.wrapper-property');
172 |             for (const nestedProperty of nestedPropertiesWrapper) {
173 |                 const nestedPropertyData = getProperty($(nestedProperty).children().filter(ele => children[ele].className.includes('key')));
174 |                 properties.push(...nestedPropertyData);
175 |             }
176 |             return properties;
177 |         }
178 | 
179 |         propertyData.key = key;
180 |         propertyData.type = type;
181 |         propertyData.isRequired = isRequired;
182 | 
183 |         return [propertyData];
184 |     }
185 | 
186 |     function getData(where) {
187 |         const data = [];
188 |         for (const property of $(where)) {
189 |             data.push(...getProperty(property));
190 |         }
191 |         return data;
192 |     }
193 | 
194 |     function handleClickSubmit(event) {
195 |         event.preventDefault();
196 | 
197 |         const body = getData('.body-property');
198 |         const response = getData('.response-property');
199 |         const method = $('.request-method-select').val();
200 |         const endpoint = $('.endpoint').val();
201 |         const delay = Number($('.delay-select').val());
202 | 
203 |         if (!isValidEndpoint(endpoint)) {
204 |             return $('.toast-failed').toast('show');
205 |         }
206 | 
207 |         const data = {
208 |             method,
209 |             endpoint,
210 |             delay,
211 |             body,
212 |             response
213 |         };
214 | 
215 |         $.ajax({
216 |             type: 'POST',
217 |             url: BACKEND_API,
218 |             data: JSON.stringify(data),
219 |             dataType: 'json',
220 |             contentType: 'application/json',
221 |             success: function() {
222 |                 $('.toast-success').toast('show');
223 |                 setTimeout(() => {
224 |                     location.reload();
225 |                 }, 3000);
226 |             },
227 |             error: function(xhr, type, thrownError) {
228 |             }
229 |         });
230 |     }
231 | 
232 |     /* COMPONENTS */
233 |     function createComponentFactory({
234 |                                         id,
235 |                                         tag,
236 |                                         className,
237 |                                         value,
238 |                                         text,
239 |                                         type,
240 |                                         innerHTML,
241 |                                         onClick,
242 |                                         onChange,
243 |                                         placeholder,
244 |                                         labelFor,
245 |                                         name,
246 |                                         isRequired,
247 |                                         isSelected,
248 |                                         isChecked
249 |                                     }) {
250 |         const element = document.createElement(tag);
251 |         if (id) {
252 |             element.id = id;
253 |         }
254 |         if (className) {
255 |             element.className = className;
256 |         }
257 |         if (value) {
258 |             element.value = value;
259 |         }
260 |         if (text) {
261 |             element.text = text;
262 |         }
263 |         if (type) {
264 |             element.type = type;
265 |         }
266 |         if (innerHTML) {
267 |             element.innerHTML = innerHTML;
268 |         }
269 |         if (placeholder) {
270 |             element.placeholder = placeholder;
271 |         }
272 |         if (labelFor) {
273 |             element.name = name;
274 |         }
275 |         if (labelFor) {
276 |             element.for = labelFor;
277 |         }
278 |         if (isRequired) {
279 |             element.required = 'required';
280 |         }
281 |         if (isSelected) {
282 |             element.selected = true;
283 |         }
284 |         if (isChecked) {
285 |             element.checked = true;
286 |         }
287 |         if (onClick) {
288 |             element.onclick = (event) => onClick(event, element);
289 |         }
290 |         if (onChange) {
291 |             element.onchange = (event) => onChange(event, element);
292 |         }
293 | 
294 |         return element;
295 |     }
296 | 
297 |     const RemoveBtnComponent = ({ onClick }) => {
298 |         return createComponentFactory({
299 |             tag: 'button', className: 'remove-property-btn btn btn-close mt-2 ms-1 ',
300 |             onClick
301 |         });
302 |     };
303 | 
304 |     const InputKeyComponent = ({ value = '' }) => {
305 |         return createComponentFactory({
306 |             tag: 'input',
307 |             value,
308 |             className: 'key rounded border border-1 me-1 p-2 bg-light form-control form-control-key',
309 |             type: 'text',
310 |             placeholder: 'Field name',
311 |             isRequired: true
312 |         });
313 |     };
314 | 
315 |     const CheckboxComponent = ({ className = '' }) => {
316 |         return createComponentFactory({
317 |             tag: 'input',
318 |             className,
319 |             type: 'checkbox',
320 |             isChecked: true
321 |         });
322 |     };
323 | 
324 |     const CustomSelectTypesComponent = ({ value = '', options }) => {
325 |         const selectTypes = createComponentFactory({
326 |             tag: 'select',
327 |             className: 'type form-select form-select-sm form-select-property me-1 bg-light',
328 |             isRequired: true,
329 |             onChange: (event, element) => handleOnchangeTypeSelection(element)
330 |         });
331 |         for (const item of options) {
332 |             const option = createComponentFactory({
333 |                 tag: 'option',
334 |                 value: item,
335 |                 text: item,
336 |                 isSelected: value === item
337 |             });
338 |             selectTypes.appendChild(option);
339 |         }
340 |         return selectTypes;
341 |     };
342 | 
343 |     const CustomWrapperPropertyComponent = ({ className }) => {
344 |         return createComponentFactory({
345 |             tag: 'div',
346 |             className
347 |         });
348 |     };
349 | 
350 |     const OverrideValueInputComponent = (placeholder) => {
351 |         return createComponentFactory({
352 |             tag: 'input', className: 'override-value-input rounded border border-1 p-2 me-1 bg-light',
353 |             placeholder: placeholder || 'Set value instead of random'
354 |         });
355 |     };
356 | 
357 |     const DefaultValueInputComponent = (placeholder) => {
358 |         return createComponentFactory({
359 |             tag: 'input', className: 'default-value-input rounded border border-1 p-2 me-1 bg-light',
360 |             placeholder: placeholder || 'Default value'
361 |         });
362 |     };
363 | 
364 |     const SelectFakerMethodsComponent = () => {
365 |         const selectFakerMethods = createComponentFactory({
366 |             tag: 'select',
367 |             className: 'form-select form-select-sm form-select-property faker-methods-select me-1 bg-light'
368 |         });
369 |         for (const { category, methods } of FAKER_METHODS_SELECTION) {
370 |             for (const method of methods) {
371 |                 const option = createComponentFactory({
372 |                     tag: 'option',
373 |                     value: `${category}-${method}`,
374 |                     text: `${category.toUpperCase()} ${method}`
375 |                 });
376 |                 selectFakerMethods.appendChild(option);
377 |             }
378 |         }
379 |         return selectFakerMethods;
380 |     };
381 | 
382 |     const SelectEntitiesComponent = () => {
383 |         const selectFakerMethods = createComponentFactory({
384 |             tag: 'select',
385 |             className: 'form-select form-select-sm form-select-property entities-select me-1 bg-light',
386 |             isRequired: true,
387 |             onChange: (event, element) => handleOnchangeEntitiesSelection({
388 |                 element,
389 |                 properties: ENTITIES_SELECTION[$(element).val()]
390 |             })
391 |         });
392 | 
393 |         for (const key of Object.keys(ENTITIES_SELECTION)) {
394 |             const option = createComponentFactory({
395 |                 tag: 'option',
396 |                 value: key,
397 |                 text: key
398 |             });
399 |             selectFakerMethods.appendChild(option);
400 |         }
401 |         return selectFakerMethods;
402 |     };
403 | 
404 |     const AddNestedPropertyButtonComponent = ({ className, nestedPropertyType }) => {
405 |         return createComponentFactory({
406 |             className: 'add-nested-property-btn btn btn-success ms-4 mb-2 rounded-circle',
407 |             tag: 'button',
408 |             innerHTML: '+',
409 |             onClick: (event, element) => {
410 |                 event.preventDefault();
411 |                 $(element).before(createNestedPropertyByType({ className, nestedPropertyType }));
412 |             }
413 |         });
414 |     };
415 | 
416 |     const ObjectOrArrayOfObjectComponent = ({ className = '' }) => {
417 |         const addNestedPropertyBtn = AddNestedPropertyButtonComponent({
418 |             className,
419 |             nestedPropertyType: 'objectOrArrayOfObject'
420 |         });
421 |         const nestedProperty = createPropertyComponent({ className });
422 |         return createNestedProperty({ nestedProperty, addNestedPropertyBtn });
423 |     };
424 | 
425 |     const EntityPropertyComponent = ({ keyValue, typeValue, className = '' }) => {
426 |         const typeSelections = TYPES_SELECTION.filter((type) => type !== 'ENTITIES');
427 |         return createPropertyComponent({
428 |             keyValue,
429 |             typeValue: mapEntityPropertyType(typeValue),
430 |             typeSelections,
431 |             requiredCheckbox: true,
432 |             className
433 |         });
434 |     };
435 | 
436 |     const ArrayOfNumericTypeComponent = ({ className = '' }) => {
437 |         const addNestedPropertyBtn = AddNestedPropertyButtonComponent({
438 |             className,
439 |             nestedPropertyType: 'arrayOfNumeric'
440 |         });
441 |         const nestedProperty = createArrayOfNumericTypeProperty({ className });
442 |         return createNestedProperty({ nestedProperty, addNestedPropertyBtn });
443 |     };
444 | 
445 |     const ArrayOfEnumPropertyComponent = ({ className = '' }) => {
446 |         const addNestedPropertyBtn = AddNestedPropertyButtonComponent({
447 |             className,
448 |             nestedPropertyType: 'enum'
449 |         });
450 | 
451 |         const nestedProperty = createEnumPropertyComponent({ className });
452 |         return createNestedProperty({ nestedProperty, addNestedPropertyBtn });
453 |     };
454 | 
455 |     const LabelComponent = ({ className = '', labelFor, text = '' }) => {
456 |         return createComponentFactory({
457 |             tag: 'label',
458 |             innerHTML: text,
459 |             className: `${className} checkbox-label mt-2 ml-2`,
460 |             for: labelFor
461 |         });
462 |     };
463 | 
464 |     /* METHODS */
465 |     function mapEntityPropertyType(type) {
466 |         switch (type) {
467 |             case 'decimal':
468 |                 return 'NUMBER';
469 |             case 'timestamp':
470 |                 return 'DATE';
471 |             default:
472 |                 return '';
473 |         }
474 |     }
475 | 
476 |     function createNestedPropertyByType({ nestedPropertyType, className }) {
477 |         switch (nestedPropertyType) {
478 |             case 'arrayOfNumeric':
479 |                 return createArrayOfNumericTypeProperty({ className });
480 |             case 'objectOrArrayOfObject':
481 |                 return createPropertyComponent({ className });
482 |             case 'enum':
483 |                 return createEnumPropertyComponent({ className });
484 |             case 'entity':
485 |                 const typeSelections = TYPES_SELECTION.filter(type => type !== 'ENTITIES');
486 |                 return createPropertyComponent({ className, requiredCheckbox: true, typeSelections });
487 |         }
488 |     }
489 | 
490 |     function createNestedProperty({ nestedProperty, addNestedPropertyBtn }) {
491 |         const wrapperProperty = CustomWrapperPropertyComponent({ className: 'wrapper-nested-property d-flex flex-column mb-1 ms-5' });
492 |         wrapperProperty.appendChild(nestedProperty);
493 | 
494 |         if (addNestedPropertyBtn) {
495 |             wrapperProperty.appendChild(addNestedPropertyBtn);
496 |         }
497 |         return wrapperProperty;
498 |     }
499 | 
500 |     function toggleAddBodyCheckBox() {
501 |         $('.add-body-property-btn').toggle();
502 |         $('.body-properties-wrapper').children().remove();
503 |     }
504 | 
505 |     function showAddBodyProperty(isParentComponentBody) {
506 |         if (isParentComponentBody) {
507 |             $('.add-body-property-btn').show();
508 |         } else {
509 |             $('.add-response-property-btn').show();
510 |         }
511 |     }
512 | 
513 |     function hideAddBodyProperty(isParentComponentBody) {
514 |         if (isParentComponentBody) {
515 |             $('.add-body-property-btn').hide();
516 |         } else {
517 |             $('.add-response-property-btn').hide();
518 |         }
519 |     }
520 | 
521 |     function createPropertyComponent({
522 |                                          keyValue,
523 |                                          typeValue,
524 |                                          className = '',
525 |                                          typeSelections = TYPES_SELECTION,
526 |                                          requiredCheckbox = false
527 |                                      }) {
528 |         const divProperty = createComponentFactory({ tag: 'div', className: `property d-flex me-1 mb-2 ${className}` });
529 |         const inputKey = InputKeyComponent({ value: keyValue });
530 |         divProperty.appendChild(inputKey);
531 | 
532 |         const selectTypes = CustomSelectTypesComponent({ value: typeValue, options: typeSelections });
533 |         divProperty.appendChild(selectTypes);
534 | 
535 |         if (requiredCheckbox) {
536 |             const checkbox = CheckboxComponent({ className: 'is-required-checkbox' });
537 |             const label = LabelComponent({ labelFor: '', text: 'Is required?' });
538 | 
539 |             divProperty.appendChild(checkbox);
540 |             divProperty.appendChild(label);
541 |         }
542 | 
543 |         const removeBtn = RemoveBtnComponent({
544 |             onClick: (event, element) => {
545 |                 event.preventDefault();
546 |                 $(element).parent().next().remove();
547 |                 $(element).parent().parent().remove();
548 |             }
549 |         });
550 |         divProperty.appendChild(removeBtn);
551 | 
552 |         const wrapperProperty = CustomWrapperPropertyComponent({ className: 'wrapper-property d-flex flex-column mb-1' });
553 |         wrapperProperty.appendChild(divProperty);
554 |         return wrapperProperty;
555 |     }
556 | 
557 |     function createEnumPropertyComponent({ className = '' }) {
558 |         const divProperty = createComponentFactory({ tag: 'div', className: `property d-flex me-1 mb-2 ${className}` });
559 | 
560 |         const inputKey = InputKeyComponent({ value: '' });
561 |         divProperty.appendChild(inputKey);
562 | 
563 |         const removeBtn = RemoveBtnComponent({
564 |             onClick: (event, element) => {
565 |                 event.preventDefault();
566 |                 $(element).parent().next().remove();
567 |                 $(element).parent().remove();
568 |             }
569 |         });
570 |         divProperty.appendChild(removeBtn);
571 | 
572 |         const wrapperProperty = CustomWrapperPropertyComponent({ className: 'wrapper-property d-flex flex-column mb-1' });
573 |         wrapperProperty.appendChild(divProperty);
574 |         return wrapperProperty;
575 |     }
576 | 
577 |     function createArrayOfNumericTypeProperty({ className = '' }) {
578 |         const divProperty = createComponentFactory({ tag: 'div', className: `property d-flex me-1 mb-2 ${className}` });
579 |         const overrideValueInput = OverrideValueInputComponent();
580 |         divProperty.appendChild(overrideValueInput);
581 | 
582 |         const selectTypes = CustomSelectTypesComponent({ options: ['FAKER'] });
583 |         divProperty.appendChild(selectTypes);
584 | 
585 |         const selectFakerMethods = SelectFakerMethodsComponent();
586 |         divProperty.appendChild(selectFakerMethods);
587 | 
588 |         const removeBtn = RemoveBtnComponent({ onClick: (element) => $(element).parent().remove() });
589 |         divProperty.appendChild(removeBtn);
590 | 
591 |         const wrapperProperty = CustomWrapperPropertyComponent({ className: 'wrapper-property d-flex flex-column mb-1' });
592 |         wrapperProperty.appendChild(divProperty);
593 |         return wrapperProperty;
594 |     }
595 | 
596 |     function handleCLickAddProperty(event) {
597 |         event.preventDefault();
598 |         const className = $(event.target).parent()[0].className.includes('body-container') ? 'body-property' : 'response-property';
599 |         const propertyComponent = createPropertyComponent({
600 |             className,
601 |             requiredCheckbox: className === 'body-property'
602 |         });
603 |         $(event.target).prev().append(propertyComponent);
604 |     }
605 | 
606 |     function createCheckBoxAndLabelComponents(element) {
607 |         const checkbox = CheckboxComponent({ className: 'is-required-checkbox' });
608 |         const label = LabelComponent({ labelFor: '', text: 'Is required?' });
609 |         $(element).after(checkbox);
610 |         $(checkbox).after(label);
611 |     }
612 | 
613 |     function resetNestedProperties({ element, type, existedOverrideValueInput, isParentComponentBody }) {
614 |         const existedFakerSelection = $(element).next()[0].className.includes('faker-methods-select');
615 |         const existedNestPropertyHasKey = $($(element).parent().next()?.children()[0]).children()[0]?.className?.includes('nested-property-has-key');
616 |         const existedAddNestedBtn = $(element).parent().next()?.children('.add-nested-property-btn')[0]?.className.includes('add-nested-property-btn');
617 |         const existedNestPropertyNoKey = $($(element).parent().next()?.children()[0]).children()[0]?.className?.includes('nested-property-no-key');
618 |         const existedDefaultValueInput = $(element).next()[0].className.includes('default-value-input');
619 |         const existedEntitiesSelect = $(element).next()[0].className.includes('entities-select');
620 |         const resetFieldName = () => {
621 |             $(element).prev().val('');
622 |             $(element).prev().attr('disabled', false);
623 |             $(element).prev().attr('placeholder', 'Field name');
624 |         };
625 | 
626 |         resetFieldName();
627 |         showAddBodyProperty(isParentComponentBody);
628 | 
629 |         if (!isPrimitiveType(type) && existedOverrideValueInput) {
630 |             $(element).next().remove();
631 |         }
632 |         if (!isFakerType(type) && existedFakerSelection) {
633 |             $(element).next().remove();
634 |         }
635 |         if (!isEnumType(type) && existedDefaultValueInput) {
636 |             $(element).next().remove();
637 |         }
638 |         if ((!isObjectType(type) && existedNestPropertyHasKey) || (!isArrayOfPrimitiveType(type) && existedNestPropertyNoKey) || (!isEnumType(type) && existedNestPropertyNoKey)) {
639 |             const className = isParentComponentBody ? '.body-nested-property' : '.response-nested-property';
640 |             const nestedProperties = $(className);
641 |             for (const property of nestedProperties) {
642 |                 $(property).parent().parent().remove();
643 |             }
644 |             $(element).parent().next().remove();
645 |         }
646 |         if (!isObjectType(type) && !isArrayOfPrimitiveType(type) && !isEnumType(type) && existedAddNestedBtn) {
647 |             $(element).parent().next().remove();
648 |         }
649 |         if (!isEntitiesType(type) && existedEntitiesSelect) {
650 |             $(element).next().remove();
651 |             resetNestedEntityProperties({ element, isParentComponentBody });
652 |             createCheckBoxAndLabelComponents(element);
653 |         }
654 |     }
655 | 
656 |     function removeAddNestedPropertyBtnIfExist(event) {
657 |         return $(event).parent().next()?.remove();
658 |     }
659 | 
660 |     function removeCheckBoxAndLabel(element) {
661 |         const nestedProperties = $(element).parent().children();
662 |         for (const property of nestedProperties) {
663 |             if (property.className.includes('checkbox') || property.className.includes('checkbox-label')) {
664 |                 $(property).remove();
665 |             }
666 |         }
667 |     }
668 | 
669 |     function prepareSelectEntity(element) {
670 |         removeCheckBoxAndLabel(element);
671 | 
672 |         $(element).prev().attr('disabled', true);
673 |         $(element).prev().val('___________________________');
674 |         $(element).prev().attr('placeholder', '___________________________');
675 | 
676 |         $(element).next().before(SelectEntitiesComponent());
677 |     }
678 | 
679 |     function handleOnchangeTypeSelection(element) {
680 |         const type = $(element).val();
681 |         const existedOverrideValueInput = $(element).next()[0].className.includes('override-value-input');
682 |         const isParentComponentBody = $(element).parent()[0].className.includes('body-property');
683 | 
684 |         resetNestedProperties({
685 |             element,
686 |             type,
687 |             existedOverrideValueInput,
688 |             isParentComponentBody
689 |         });
690 | 
691 |         if (isPrimitiveType(type) && !existedOverrideValueInput) {
692 |             $(element).next().before(OverrideValueInputComponent());
693 |         }
694 |         if (isFakerType(type)) {
695 |             $(element).next().before(SelectFakerMethodsComponent());
696 |         }
697 |         if (isObjectType(type)) {
698 |             removeAddNestedPropertyIfExist(element);
699 |             const nestedPropertyClassName = isParentComponentBody ? 'body-nested-property key' : 'response-nested-property';
700 |             const nestedProperty = ObjectOrArrayOfObjectComponent({ className: `${nestedPropertyClassName} nested-property nested-property-has-key d-flex me-1 mb-2 ms-4` });
701 |             $(element).parent().parent().append(nestedProperty);
702 |         }
703 |         if (isArrayOfPrimitiveType(type)) {
704 |             removeAddNestedPropertyIfExist(element);
705 |             const nestedPropertyClassName = isParentComponentBody ? 'body-nested-property key' : 'response-nested-property';
706 |             const nestedProperty = ArrayOfNumericTypeComponent({ className: `${nestedPropertyClassName} nested-property nested-property-no-key d-flex me-1 mb-2 ms-4` });
707 |             $(element).parent().parent().append(nestedProperty);
708 |         }
709 |         if (isEnumType(type)) {
710 |             removeAddNestedPropertyIfExist(element);
711 |             $(element).next().before(DefaultValueInputComponent());
712 |             const nestedPropertyClassName = isParentComponentBody ? 'body-nested-property key' : 'response-nested-property';
713 |             const nestedProperty = ArrayOfEnumPropertyComponent({ className: `${nestedPropertyClassName} nested-property nested-property-no-key d-flex me-1 mb-2 ms-4` });
714 |             $(element).parent().parent().append(nestedProperty);
715 |         }
716 |         if (isEntitiesType(type)) {
717 |             prepareSelectEntity(element);
718 |             hideAddBodyProperty(isParentComponentBody);
719 |         }
720 |     }
721 | 
722 |     function resetNestedEntityProperties({ element, isParentComponentBody }) {
723 |         const existedNestPropertyHasKey = $($(element).parent().next()?.children()[0]).children()[0]?.className?.includes('nested-property-has-key');
724 |         if (existedNestPropertyHasKey) {
725 |             const className = isParentComponentBody ? '.body-nested-property' : '.response-nested-property';
726 |             const nestedProperties = $(className);
727 |             for (const property of nestedProperties) {
728 |                 $(element).parent().next().remove();
729 |             }
730 |             $(element).next().remove();
731 |         }
732 |         removeAddNestedPropertyBtnIfExist(element);
733 |     }
734 | 
735 |     function handleOnchangeEntitiesSelection({ element, properties }) {
736 |         const isParentComponentBody = $(element).parent()[0].className.includes('body-property');
737 |         resetNestedEntityProperties({
738 |             element,
739 |             isParentComponentBody
740 |         });
741 | 
742 |         const wrapperNestedProperty = CustomWrapperPropertyComponent({ className: 'wrapper-nested-property d-flex flex-column mb-1 ms-5' });
743 |         const nestedPropertyClassName = isParentComponentBody ? 'body-nested-property key' : 'response-nested-property';
744 |         const className = `${nestedPropertyClassName} nested-property nested-property-has-key d-flex me-1 mb-2 ms-4`;
745 |         for (const property of properties) {
746 |             const nestedProperty = EntityPropertyComponent({
747 |                 keyValue: property.key,
748 |                 typeValue: property.type,
749 |                 className
750 |             });
751 |             wrapperNestedProperty.appendChild(nestedProperty);
752 |         }
753 |         const addNestedPropertyBtn = AddNestedPropertyButtonComponent({
754 |             className,
755 |             nestedPropertyType: 'entity'
756 |         });
757 |         wrapperNestedProperty.appendChild(addNestedPropertyBtn);
758 | 
759 |         $(element).parent().parent().append(wrapperNestedProperty);
760 |     }
761 | </script>
762 | 


--------------------------------------------------------------------------------
/package-lock.json:
--------------------------------------------------------------------------------
   1 | {
   2 |   "name": "nestjs-mocker",
   3 |   "version": "1.0.0",
   4 |   "lockfileVersion": 1,
   5 |   "requires": true,
   6 |   "dependencies": {
   7 |     "@nestjs/common": {
   8 |       "version": "8.0.6",
   9 |       "resolved": "https://registry.npmjs.org/@nestjs/common/-/common-8.0.6.tgz",
  10 |       "integrity": "sha512-mSD000iYJDN2wjL2hbygCVNVvzvi3VW5EDc25gK1Bj3wUU2HR8m1qOAUBqcCaGIuvBb2cD/pnVkKklnsY0rKhw==",
  11 |       "dev": true,
  12 |       "requires": {
  13 |         "axios": "0.21.1",
  14 |         "iterare": "1.2.1",
  15 |         "tslib": "2.3.0",
  16 |         "uuid": "8.3.2"
  17 |       }
  18 |     },
  19 |     "@nestjs/core": {
  20 |       "version": "8.0.6",
  21 |       "resolved": "https://registry.npmjs.org/@nestjs/core/-/core-8.0.6.tgz",
  22 |       "integrity": "sha512-PIGL4TMjVkAsiv5hJinaTx3WdoftYh7pJDwIUQPvRZPLhboGbOJlVapN0Cw5SL7XgNWojQiAsbgLmnGJVDO3Sw==",
  23 |       "dev": true,
  24 |       "requires": {
  25 |         "@nuxtjs/opencollective": "0.3.2",
  26 |         "fast-safe-stringify": "2.0.8",
  27 |         "iterare": "1.2.1",
  28 |         "object-hash": "2.2.0",
  29 |         "path-to-regexp": "3.2.0",
  30 |         "tslib": "2.3.0",
  31 |         "uuid": "8.3.2"
  32 |       }
  33 |     },
  34 |     "@nestjs/mapped-types": {
  35 |       "version": "1.0.0",
  36 |       "resolved": "https://registry.npmjs.org/@nestjs/mapped-types/-/mapped-types-1.0.0.tgz",
  37 |       "integrity": "sha512-26AW5jHadLXtvHs+M+Agd9KZ92dDlBrmD0rORlBlvn2KvsWs4JRaKl2mUsrW7YsdZeAu3Hc4ukqyYyDdyCmMWQ==",
  38 |       "dev": true
  39 |     },
  40 |     "@nestjs/platform-express": {
  41 |       "version": "8.0.6",
  42 |       "resolved": "https://registry.npmjs.org/@nestjs/platform-express/-/platform-express-8.0.6.tgz",
  43 |       "integrity": "sha512-1nIWd2w3aq3k0UNThDI6VWLqurc0Fvw3FO6BHWHK+Y7H/z9KFHZ0W/HdD9IJH05m4Smp/2neZoMkKdlXeh9wpQ==",
  44 |       "requires": {
  45 |         "body-parser": "1.19.0",
  46 |         "cors": "2.8.5",
  47 |         "express": "4.17.1",
  48 |         "multer": "1.4.2",
  49 |         "tslib": "2.3.0"
  50 |       }
  51 |     },
  52 |     "@nestjs/swagger": {
  53 |       "version": "5.0.9",
  54 |       "resolved": "https://registry.npmjs.org/@nestjs/swagger/-/swagger-5.0.9.tgz",
  55 |       "integrity": "sha512-KivZeDgn/VeDn81Rnd/0Cbv7M4kuHRb+Rlri+YsUrw3h9or4bxxRiUg7Yjjt368KxfJgR7C3lc6kltvoI7ucQg==",
  56 |       "dev": true,
  57 |       "requires": {
  58 |         "@nestjs/mapped-types": "1.0.0",
  59 |         "lodash": "4.17.21",
  60 |         "path-to-regexp": "3.2.0"
  61 |       }
  62 |     },
  63 |     "@nestjs/typeorm": {
  64 |       "version": "github:nestjs/typeorm#fb1158edf1b82cdf080df583cd7f1c4636d56f64",
  65 |       "from": "github:nestjs/typeorm",
  66 |       "requires": {
  67 |         "uuid": "8.3.2"
  68 |       }
  69 |     },
  70 |     "@nuxtjs/opencollective": {
  71 |       "version": "0.3.2",
  72 |       "resolved": "https://registry.npmjs.org/@nuxtjs/opencollective/-/opencollective-0.3.2.tgz",
  73 |       "integrity": "sha512-um0xL3fO7Mf4fDxcqx9KryrB7zgRM5JSlvGN5AGkP6JLM5XEKyjeAiPbNxdXVXQ16isuAhYpvP88NgL2BGd6aA==",
  74 |       "dev": true,
  75 |       "requires": {
  76 |         "chalk": "^4.1.0",
  77 |         "consola": "^2.15.0",
  78 |         "node-fetch": "^2.6.1"
  79 |       }
  80 |     },
  81 |     "@sqltools/formatter": {
  82 |       "version": "1.2.3",
  83 |       "resolved": "https://registry.npmjs.org/@sqltools/formatter/-/formatter-1.2.3.tgz",
  84 |       "integrity": "sha512-O3uyB/JbkAEMZaP3YqyHH7TMnex7tWyCbCI4EfJdOCoN6HIhqdJBWTM6aCCiWQ/5f5wxjgU735QAIpJbjDvmzg=="
  85 |     },
  86 |     "@types/node": {
  87 |       "version": "16.9.1",
  88 |       "resolved": "https://registry.npmjs.org/@types/node/-/node-16.9.1.tgz",
  89 |       "integrity": "sha512-QpLcX9ZSsq3YYUUnD3nFDY8H7wctAhQj/TFKL8Ya8v5fMm3CFXxo8zStsLAl780ltoYoo1WvKUVGBQK+1ifr7g==",
  90 |       "dev": true
  91 |     },
  92 |     "@types/validator": {
  93 |       "version": "13.6.3",
  94 |       "resolved": "https://registry.npmjs.org/@types/validator/-/validator-13.6.3.tgz",
  95 |       "integrity": "sha512-fWG42pMJOL4jKsDDZZREnXLjc3UE0R8LOJfARWYg6U966rxDT7TYejYzLnUF5cvSObGg34nd0+H2wHHU5Omdfw=="
  96 |     },
  97 |     "@types/zen-observable": {
  98 |       "version": "0.8.3",
  99 |       "resolved": "https://registry.npmjs.org/@types/zen-observable/-/zen-observable-0.8.3.tgz",
 100 |       "integrity": "sha512-fbF6oTd4sGGy0xjHPKAt+eS2CrxJ3+6gQ3FGcBoIJR2TLAyCkCyI8JqZNy+FeON0AhVgNJoUumVoZQjBFUqHkw=="
 101 |     },
 102 |     "accepts": {
 103 |       "version": "1.3.7",
 104 |       "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.7.tgz",
 105 |       "integrity": "sha512-Il80Qs2WjYlJIBNzNkK6KYqlVMTbZLXgHx2oT0pU/fjRHyEp+PEfEPY0R3WCwAGVOtauxh1hOxNgIf5bv7dQpA==",
 106 |       "requires": {
 107 |         "mime-types": "~2.1.24",
 108 |         "negotiator": "0.6.2"
 109 |       }
 110 |     },
 111 |     "ansi-regex": {
 112 |       "version": "5.0.0",
 113 |       "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.0.tgz",
 114 |       "integrity": "sha512-bY6fj56OUQ0hU1KjFNDQuJFezqKdrAyFdIevADiqrWHwSlbmBNMHp5ak2f40Pm8JTFyM2mqxkG6ngkHO11f/lg=="
 115 |     },
 116 |     "ansi-styles": {
 117 |       "version": "4.3.0",
 118 |       "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
 119 |       "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
 120 |       "requires": {
 121 |         "color-convert": "^2.0.1"
 122 |       }
 123 |     },
 124 |     "any-promise": {
 125 |       "version": "1.3.0",
 126 |       "resolved": "https://registry.npmjs.org/any-promise/-/any-promise-1.3.0.tgz",
 127 |       "integrity": "sha1-q8av7tzqUugJzcA3au0845Y10X8="
 128 |     },
 129 |     "app-root-path": {
 130 |       "version": "3.0.0",
 131 |       "resolved": "https://registry.npmjs.org/app-root-path/-/app-root-path-3.0.0.tgz",
 132 |       "integrity": "sha512-qMcx+Gy2UZynHjOHOIXPNvpf+9cjvk3cWrBBK7zg4gH9+clobJRb9NGzcT7mQTcV/6Gm/1WelUtqxVXnNlrwcw=="
 133 |     },
 134 |     "append-field": {
 135 |       "version": "1.0.0",
 136 |       "resolved": "https://registry.npmjs.org/append-field/-/append-field-1.0.0.tgz",
 137 |       "integrity": "sha1-HjRA6RXwsSA9I3SOeO3XubW0PlY="
 138 |     },
 139 |     "argparse": {
 140 |       "version": "2.0.1",
 141 |       "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
 142 |       "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="
 143 |     },
 144 |     "array-flatten": {
 145 |       "version": "1.1.1",
 146 |       "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz",
 147 |       "integrity": "sha1-ml9pkFGx5wczKPKgCJaLZOopVdI="
 148 |     },
 149 |     "axios": {
 150 |       "version": "0.21.1",
 151 |       "resolved": "https://registry.npmjs.org/axios/-/axios-0.21.1.tgz",
 152 |       "integrity": "sha512-dKQiRHxGD9PPRIUNIWvZhPTPpl1rf/OxTYKsqKUDjBwYylTvV7SjSHJb9ratfyzM6wCdLCOYLzs73qpg5c4iGA==",
 153 |       "dev": true,
 154 |       "requires": {
 155 |         "follow-redirects": "^1.10.0"
 156 |       }
 157 |     },
 158 |     "balanced-match": {
 159 |       "version": "1.0.2",
 160 |       "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
 161 |       "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="
 162 |     },
 163 |     "base64-js": {
 164 |       "version": "1.5.1",
 165 |       "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
 166 |       "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA=="
 167 |     },
 168 |     "body-parser": {
 169 |       "version": "1.19.0",
 170 |       "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.19.0.tgz",
 171 |       "integrity": "sha512-dhEPs72UPbDnAQJ9ZKMNTP6ptJaionhP5cBb541nXPlW60Jepo9RV/a4fX4XWW9CuFNK22krhrj1+rgzifNCsw==",
 172 |       "requires": {
 173 |         "bytes": "3.1.0",
 174 |         "content-type": "~1.0.4",
 175 |         "debug": "2.6.9",
 176 |         "depd": "~1.1.2",
 177 |         "http-errors": "1.7.2",
 178 |         "iconv-lite": "0.4.24",
 179 |         "on-finished": "~2.3.0",
 180 |         "qs": "6.7.0",
 181 |         "raw-body": "2.4.0",
 182 |         "type-is": "~1.6.17"
 183 |       }
 184 |     },
 185 |     "brace-expansion": {
 186 |       "version": "1.1.11",
 187 |       "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
 188 |       "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
 189 |       "requires": {
 190 |         "balanced-match": "^1.0.0",
 191 |         "concat-map": "0.0.1"
 192 |       }
 193 |     },
 194 |     "buffer": {
 195 |       "version": "6.0.3",
 196 |       "resolved": "https://registry.npmjs.org/buffer/-/buffer-6.0.3.tgz",
 197 |       "integrity": "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==",
 198 |       "requires": {
 199 |         "base64-js": "^1.3.1",
 200 |         "ieee754": "^1.2.1"
 201 |       }
 202 |     },
 203 |     "buffer-from": {
 204 |       "version": "1.1.2",
 205 |       "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
 206 |       "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ=="
 207 |     },
 208 |     "busboy": {
 209 |       "version": "0.2.14",
 210 |       "resolved": "https://registry.npmjs.org/busboy/-/busboy-0.2.14.tgz",
 211 |       "integrity": "sha1-bCpiLvz0fFe7vh4qnDetNseSVFM=",
 212 |       "requires": {
 213 |         "dicer": "0.2.5",
 214 |         "readable-stream": "1.1.x"
 215 |       }
 216 |     },
 217 |     "bytes": {
 218 |       "version": "3.1.0",
 219 |       "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.0.tgz",
 220 |       "integrity": "sha512-zauLjrfCG+xvoyaqLoV8bLVXXNGC4JqlxFCutSDWA6fJrTo2ZuvLYTqZ7aHBLZSMOopbzwv8f+wZcVzfVTI2Dg=="
 221 |     },
 222 |     "chalk": {
 223 |       "version": "4.1.2",
 224 |       "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
 225 |       "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
 226 |       "requires": {
 227 |         "ansi-styles": "^4.1.0",
 228 |         "supports-color": "^7.1.0"
 229 |       }
 230 |     },
 231 |     "class-validator": {
 232 |       "version": "0.13.1",
 233 |       "resolved": "https://registry.npmjs.org/class-validator/-/class-validator-0.13.1.tgz",
 234 |       "integrity": "sha512-zWIeYFhUitvAHBwNhDdCRK09hWx+P0HUwFE8US8/CxFpMVzkUK8RJl7yOIE+BVu2lxyPNgeOaFv78tLE47jBIg==",
 235 |       "requires": {
 236 |         "@types/validator": "^13.1.3",
 237 |         "libphonenumber-js": "^1.9.7",
 238 |         "validator": "^13.5.2"
 239 |       }
 240 |     },
 241 |     "cli-highlight": {
 242 |       "version": "2.1.11",
 243 |       "resolved": "https://registry.npmjs.org/cli-highlight/-/cli-highlight-2.1.11.tgz",
 244 |       "integrity": "sha512-9KDcoEVwyUXrjcJNvHD0NFc/hiwe/WPVYIleQh2O1N2Zro5gWJZ/K+3DGn8w8P/F6FxOgzyC5bxDyHIgCSPhGg==",
 245 |       "requires": {
 246 |         "chalk": "^4.0.0",
 247 |         "highlight.js": "^10.7.1",
 248 |         "mz": "^2.4.0",
 249 |         "parse5": "^5.1.1",
 250 |         "parse5-htmlparser2-tree-adapter": "^6.0.0",
 251 |         "yargs": "^16.0.0"
 252 |       },
 253 |       "dependencies": {
 254 |         "yargs": {
 255 |           "version": "16.2.0",
 256 |           "resolved": "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz",
 257 |           "integrity": "sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==",
 258 |           "requires": {
 259 |             "cliui": "^7.0.2",
 260 |             "escalade": "^3.1.1",
 261 |             "get-caller-file": "^2.0.5",
 262 |             "require-directory": "^2.1.1",
 263 |             "string-width": "^4.2.0",
 264 |             "y18n": "^5.0.5",
 265 |             "yargs-parser": "^20.2.2"
 266 |           }
 267 |         }
 268 |       }
 269 |     },
 270 |     "cliui": {
 271 |       "version": "7.0.4",
 272 |       "resolved": "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz",
 273 |       "integrity": "sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==",
 274 |       "requires": {
 275 |         "string-width": "^4.2.0",
 276 |         "strip-ansi": "^6.0.0",
 277 |         "wrap-ansi": "^7.0.0"
 278 |       }
 279 |     },
 280 |     "color-convert": {
 281 |       "version": "2.0.1",
 282 |       "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
 283 |       "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
 284 |       "requires": {
 285 |         "color-name": "~1.1.4"
 286 |       }
 287 |     },
 288 |     "color-name": {
 289 |       "version": "1.1.4",
 290 |       "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
 291 |       "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="
 292 |     },
 293 |     "concat-map": {
 294 |       "version": "0.0.1",
 295 |       "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
 296 |       "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s="
 297 |     },
 298 |     "concat-stream": {
 299 |       "version": "1.6.2",
 300 |       "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.2.tgz",
 301 |       "integrity": "sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==",
 302 |       "requires": {
 303 |         "buffer-from": "^1.0.0",
 304 |         "inherits": "^2.0.3",
 305 |         "readable-stream": "^2.2.2",
 306 |         "typedarray": "^0.0.6"
 307 |       },
 308 |       "dependencies": {
 309 |         "isarray": {
 310 |           "version": "1.0.0",
 311 |           "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
 312 |           "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE="
 313 |         },
 314 |         "readable-stream": {
 315 |           "version": "2.3.7",
 316 |           "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.7.tgz",
 317 |           "integrity": "sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==",
 318 |           "requires": {
 319 |             "core-util-is": "~1.0.0",
 320 |             "inherits": "~2.0.3",
 321 |             "isarray": "~1.0.0",
 322 |             "process-nextick-args": "~2.0.0",
 323 |             "safe-buffer": "~5.1.1",
 324 |             "string_decoder": "~1.1.1",
 325 |             "util-deprecate": "~1.0.1"
 326 |           }
 327 |         },
 328 |         "string_decoder": {
 329 |           "version": "1.1.1",
 330 |           "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
 331 |           "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
 332 |           "requires": {
 333 |             "safe-buffer": "~5.1.0"
 334 |           }
 335 |         }
 336 |       }
 337 |     },
 338 |     "consola": {
 339 |       "version": "2.15.3",
 340 |       "resolved": "https://registry.npmjs.org/consola/-/consola-2.15.3.tgz",
 341 |       "integrity": "sha512-9vAdYbHj6x2fLKC4+oPH0kFzY/orMZyG2Aj+kNylHxKGJ/Ed4dpNyAQYwJOdqO4zdM7XpVHmyejQDcQHrnuXbw==",
 342 |       "dev": true
 343 |     },
 344 |     "content-disposition": {
 345 |       "version": "0.5.3",
 346 |       "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.3.tgz",
 347 |       "integrity": "sha512-ExO0774ikEObIAEV9kDo50o+79VCUdEB6n6lzKgGwupcVeRlhrj3qGAfwq8G6uBJjkqLrhT0qEYFcWng8z1z0g==",
 348 |       "requires": {
 349 |         "safe-buffer": "5.1.2"
 350 |       }
 351 |     },
 352 |     "content-type": {
 353 |       "version": "1.0.4",
 354 |       "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.4.tgz",
 355 |       "integrity": "sha512-hIP3EEPs8tB9AT1L+NUqtwOAps4mk2Zob89MWXMHjHWg9milF/j4osnnQLXBCBFBk/tvIG/tUc9mOUJiPBhPXA=="
 356 |     },
 357 |     "cookie": {
 358 |       "version": "0.4.0",
 359 |       "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.4.0.tgz",
 360 |       "integrity": "sha512-+Hp8fLp57wnUSt0tY0tHEXh4voZRDnoIrZPqlo3DPiI4y9lwg/jqx+1Om94/W6ZaPDOUbnjOt/99w66zk+l1Xg=="
 361 |     },
 362 |     "cookie-signature": {
 363 |       "version": "1.0.6",
 364 |       "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz",
 365 |       "integrity": "sha1-4wOogrNCzD7oylE6eZmXNNqzriw="
 366 |     },
 367 |     "core-util-is": {
 368 |       "version": "1.0.3",
 369 |       "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz",
 370 |       "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ=="
 371 |     },
 372 |     "cors": {
 373 |       "version": "2.8.5",
 374 |       "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.5.tgz",
 375 |       "integrity": "sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==",
 376 |       "requires": {
 377 |         "object-assign": "^4",
 378 |         "vary": "^1"
 379 |       }
 380 |     },
 381 |     "debug": {
 382 |       "version": "2.6.9",
 383 |       "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
 384 |       "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
 385 |       "requires": {
 386 |         "ms": "2.0.0"
 387 |       }
 388 |     },
 389 |     "depd": {
 390 |       "version": "1.1.2",
 391 |       "resolved": "https://registry.npmjs.org/depd/-/depd-1.1.2.tgz",
 392 |       "integrity": "sha1-m81S4UwJd2PnSbJ0xDRu0uVgtak="
 393 |     },
 394 |     "destroy": {
 395 |       "version": "1.0.4",
 396 |       "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.0.4.tgz",
 397 |       "integrity": "sha1-l4hXRCxEdJ5CBmE+N5RiBYJqvYA="
 398 |     },
 399 |     "dicer": {
 400 |       "version": "0.2.5",
 401 |       "resolved": "https://registry.npmjs.org/dicer/-/dicer-0.2.5.tgz",
 402 |       "integrity": "sha1-WZbAhrszIYyBLAkL3cCc0S+stw8=",
 403 |       "requires": {
 404 |         "readable-stream": "1.1.x",
 405 |         "streamsearch": "0.1.2"
 406 |       }
 407 |     },
 408 |     "dotenv": {
 409 |       "version": "8.6.0",
 410 |       "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-8.6.0.tgz",
 411 |       "integrity": "sha512-IrPdXQsk2BbzvCBGBOTmmSH5SodmqZNt4ERAZDmW4CT+tL8VtvinqywuANaFu4bOMWki16nqf0e4oC0QIaDr/g=="
 412 |     },
 413 |     "ee-first": {
 414 |       "version": "1.1.1",
 415 |       "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
 416 |       "integrity": "sha1-WQxhFWsK4vTwJVcyoViyZrxWsh0="
 417 |     },
 418 |     "emoji-regex": {
 419 |       "version": "8.0.0",
 420 |       "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
 421 |       "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="
 422 |     },
 423 |     "encodeurl": {
 424 |       "version": "1.0.2",
 425 |       "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz",
 426 |       "integrity": "sha1-rT/0yG7C0CkyL1oCw6mmBslbP1k="
 427 |     },
 428 |     "escalade": {
 429 |       "version": "3.1.1",
 430 |       "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz",
 431 |       "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw=="
 432 |     },
 433 |     "escape-html": {
 434 |       "version": "1.0.3",
 435 |       "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
 436 |       "integrity": "sha1-Aljq5NPQwJdN4cFpGI7wBR0dGYg="
 437 |     },
 438 |     "escape-string-regexp": {
 439 |       "version": "1.0.5",
 440 |       "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
 441 |       "integrity": "sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ="
 442 |     },
 443 |     "etag": {
 444 |       "version": "1.8.1",
 445 |       "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
 446 |       "integrity": "sha1-Qa4u62XvpiJorr/qg6x9eSmbCIc="
 447 |     },
 448 |     "express": {
 449 |       "version": "4.17.1",
 450 |       "resolved": "https://registry.npmjs.org/express/-/express-4.17.1.tgz",
 451 |       "integrity": "sha512-mHJ9O79RqluphRrcw2X/GTh3k9tVv8YcoyY4Kkh4WDMUYKRZUq0h1o0w2rrrxBqM7VoeUVqgb27xlEMXTnYt4g==",
 452 |       "requires": {
 453 |         "accepts": "~1.3.7",
 454 |         "array-flatten": "1.1.1",
 455 |         "body-parser": "1.19.0",
 456 |         "content-disposition": "0.5.3",
 457 |         "content-type": "~1.0.4",
 458 |         "cookie": "0.4.0",
 459 |         "cookie-signature": "1.0.6",
 460 |         "debug": "2.6.9",
 461 |         "depd": "~1.1.2",
 462 |         "encodeurl": "~1.0.2",
 463 |         "escape-html": "~1.0.3",
 464 |         "etag": "~1.8.1",
 465 |         "finalhandler": "~1.1.2",
 466 |         "fresh": "0.5.2",
 467 |         "merge-descriptors": "1.0.1",
 468 |         "methods": "~1.1.2",
 469 |         "on-finished": "~2.3.0",
 470 |         "parseurl": "~1.3.3",
 471 |         "path-to-regexp": "0.1.7",
 472 |         "proxy-addr": "~2.0.5",
 473 |         "qs": "6.7.0",
 474 |         "range-parser": "~1.2.1",
 475 |         "safe-buffer": "5.1.2",
 476 |         "send": "0.17.1",
 477 |         "serve-static": "1.14.1",
 478 |         "setprototypeof": "1.1.1",
 479 |         "statuses": "~1.5.0",
 480 |         "type-is": "~1.6.18",
 481 |         "utils-merge": "1.0.1",
 482 |         "vary": "~1.1.2"
 483 |       },
 484 |       "dependencies": {
 485 |         "path-to-regexp": {
 486 |           "version": "0.1.7",
 487 |           "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.7.tgz",
 488 |           "integrity": "sha1-32BBeABfUi8V60SQ5yR6G/qmf4w="
 489 |         }
 490 |       }
 491 |     },
 492 |     "faker": {
 493 |       "version": "5.5.3",
 494 |       "resolved": "https://registry.npmjs.org/faker/-/faker-5.5.3.tgz",
 495 |       "integrity": "sha512-wLTv2a28wjUyWkbnX7u/ABZBkUkIF2fCd73V6P2oFqEGEktDfzWx4UxrSqtPRw0xPRAcjeAOIiJWqZm3pP4u3g=="
 496 |     },
 497 |     "fast-safe-stringify": {
 498 |       "version": "2.0.8",
 499 |       "resolved": "https://registry.npmjs.org/fast-safe-stringify/-/fast-safe-stringify-2.0.8.tgz",
 500 |       "integrity": "sha512-lXatBjf3WPjmWD6DpIZxkeSsCOwqI0maYMpgDlx8g4U2qi4lbjA9oH/HD2a87G+KfsUmo5WbJFmqBZlPxtptag==",
 501 |       "dev": true
 502 |     },
 503 |     "figlet": {
 504 |       "version": "1.5.2",
 505 |       "resolved": "https://registry.npmjs.org/figlet/-/figlet-1.5.2.tgz",
 506 |       "integrity": "sha512-WOn21V8AhyE1QqVfPIVxe3tupJacq1xGkPTB4iagT6o+P2cAgEOOwIxMftr4+ZCTI6d551ij9j61DFr0nsP2uQ=="
 507 |     },
 508 |     "finalhandler": {
 509 |       "version": "1.1.2",
 510 |       "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.1.2.tgz",
 511 |       "integrity": "sha512-aAWcW57uxVNrQZqFXjITpW3sIUQmHGG3qSb9mUah9MgMC4NeWhNOlNjXEYq3HjRAvL6arUviZGGJsBg6z0zsWA==",
 512 |       "requires": {
 513 |         "debug": "2.6.9",
 514 |         "encodeurl": "~1.0.2",
 515 |         "escape-html": "~1.0.3",
 516 |         "on-finished": "~2.3.0",
 517 |         "parseurl": "~1.3.3",
 518 |         "statuses": "~1.5.0",
 519 |         "unpipe": "~1.0.0"
 520 |       }
 521 |     },
 522 |     "follow-redirects": {
 523 |       "version": "1.14.3",
 524 |       "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.14.3.tgz",
 525 |       "integrity": "sha512-3MkHxknWMUtb23apkgz/83fDoe+y+qr0TdgacGIA7bew+QLBo3vdgEN2xEsuXNivpFy4CyDhBBZnNZOtalmenw==",
 526 |       "dev": true
 527 |     },
 528 |     "foreachasync": {
 529 |       "version": "3.0.0",
 530 |       "resolved": "https://registry.npmjs.org/foreachasync/-/foreachasync-3.0.0.tgz",
 531 |       "integrity": "sha1-VQKYfchxS+M5IJfzLgBxyd7gfPY="
 532 |     },
 533 |     "forwarded": {
 534 |       "version": "0.2.0",
 535 |       "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
 536 |       "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow=="
 537 |     },
 538 |     "fresh": {
 539 |       "version": "0.5.2",
 540 |       "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz",
 541 |       "integrity": "sha1-PYyt2Q2XZWn6g1qx+OSyOhBWBac="
 542 |     },
 543 |     "fs.realpath": {
 544 |       "version": "1.0.0",
 545 |       "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
 546 |       "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8="
 547 |     },
 548 |     "get-caller-file": {
 549 |       "version": "2.0.5",
 550 |       "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
 551 |       "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg=="
 552 |     },
 553 |     "glob": {
 554 |       "version": "7.1.7",
 555 |       "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.7.tgz",
 556 |       "integrity": "sha512-OvD9ENzPLbegENnYP5UUfJIirTg4+XwMWGaQfQTY0JenxNvvIKP3U3/tAQSPIu/lHxXYSZmpXlUHeqAIdKzBLQ==",
 557 |       "requires": {
 558 |         "fs.realpath": "^1.0.0",
 559 |         "inflight": "^1.0.4",
 560 |         "inherits": "2",
 561 |         "minimatch": "^3.0.4",
 562 |         "once": "^1.3.0",
 563 |         "path-is-absolute": "^1.0.0"
 564 |       }
 565 |     },
 566 |     "handlebars": {
 567 |       "version": "4.7.7",
 568 |       "resolved": "https://registry.npmjs.org/handlebars/-/handlebars-4.7.7.tgz",
 569 |       "integrity": "sha512-aAcXm5OAfE/8IXkcZvCepKU3VzW1/39Fb5ZuqMtgI/hT8X2YgoMvBY5dLhq/cpOvw7Lk1nK/UF71aLG/ZnVYRA==",
 570 |       "requires": {
 571 |         "minimist": "^1.2.5",
 572 |         "neo-async": "^2.6.0",
 573 |         "source-map": "^0.6.1",
 574 |         "uglify-js": "^3.1.4",
 575 |         "wordwrap": "^1.0.0"
 576 |       }
 577 |     },
 578 |     "has-ansi": {
 579 |       "version": "2.0.0",
 580 |       "resolved": "https://registry.npmjs.org/has-ansi/-/has-ansi-2.0.0.tgz",
 581 |       "integrity": "sha1-NPUEnOHs3ysGSa8+8k5F7TVBbZE=",
 582 |       "requires": {
 583 |         "ansi-regex": "^2.0.0"
 584 |       },
 585 |       "dependencies": {
 586 |         "ansi-regex": {
 587 |           "version": "2.1.1",
 588 |           "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz",
 589 |           "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8="
 590 |         }
 591 |       }
 592 |     },
 593 |     "has-flag": {
 594 |       "version": "4.0.0",
 595 |       "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
 596 |       "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ=="
 597 |     },
 598 |     "hbs": {
 599 |       "version": "4.1.2",
 600 |       "resolved": "https://registry.npmjs.org/hbs/-/hbs-4.1.2.tgz",
 601 |       "integrity": "sha512-WfBnQbozbdiTLjJu6P6Wturgvy0FN8xtRmIjmP0ebX9OGQrt+2S6UC7xX0IebHTCS1sXe20zfTzQ7yhjrEvrfQ==",
 602 |       "requires": {
 603 |         "handlebars": "4.7.7",
 604 |         "walk": "2.3.14"
 605 |       }
 606 |     },
 607 |     "highlight.js": {
 608 |       "version": "10.7.3",
 609 |       "resolved": "https://registry.npmjs.org/highlight.js/-/highlight.js-10.7.3.tgz",
 610 |       "integrity": "sha512-tzcUFauisWKNHaRkN4Wjl/ZA07gENAjFl3J/c480dprkGTg5EQstgaNFqBfUqCq54kZRIEcreTsAgF/m2quD7A=="
 611 |     },
 612 |     "http-errors": {
 613 |       "version": "1.7.2",
 614 |       "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.7.2.tgz",
 615 |       "integrity": "sha512-uUQBt3H/cSIVfch6i1EuPNy/YsRSOUBXTVfZ+yR7Zjez3qjBz6i9+i4zjNaoqcoFVI4lQJ5plg63TvGfRSDCRg==",
 616 |       "requires": {
 617 |         "depd": "~1.1.2",
 618 |         "inherits": "2.0.3",
 619 |         "setprototypeof": "1.1.1",
 620 |         "statuses": ">= 1.5.0 < 2",
 621 |         "toidentifier": "1.0.0"
 622 |       },
 623 |       "dependencies": {
 624 |         "inherits": {
 625 |           "version": "2.0.3",
 626 |           "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
 627 |           "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4="
 628 |         }
 629 |       }
 630 |     },
 631 |     "iconv-lite": {
 632 |       "version": "0.4.24",
 633 |       "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
 634 |       "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
 635 |       "requires": {
 636 |         "safer-buffer": ">= 2.1.2 < 3"
 637 |       }
 638 |     },
 639 |     "ieee754": {
 640 |       "version": "1.2.1",
 641 |       "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
 642 |       "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA=="
 643 |     },
 644 |     "inflight": {
 645 |       "version": "1.0.6",
 646 |       "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
 647 |       "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=",
 648 |       "requires": {
 649 |         "once": "^1.3.0",
 650 |         "wrappy": "1"
 651 |       }
 652 |     },
 653 |     "inherits": {
 654 |       "version": "2.0.4",
 655 |       "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
 656 |       "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
 657 |     },
 658 |     "ipaddr.js": {
 659 |       "version": "1.9.1",
 660 |       "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
 661 |       "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g=="
 662 |     },
 663 |     "is-fullwidth-code-point": {
 664 |       "version": "3.0.0",
 665 |       "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
 666 |       "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg=="
 667 |     },
 668 |     "isarray": {
 669 |       "version": "0.0.1",
 670 |       "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz",
 671 |       "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8="
 672 |     },
 673 |     "iterare": {
 674 |       "version": "1.2.1",
 675 |       "resolved": "https://registry.npmjs.org/iterare/-/iterare-1.2.1.tgz",
 676 |       "integrity": "sha512-RKYVTCjAnRthyJes037NX/IiqeidgN1xc3j1RjFfECFp28A1GVwK9nA+i0rJPaHqSZwygLzRnFlzUuHFoWWy+Q==",
 677 |       "dev": true
 678 |     },
 679 |     "js-yaml": {
 680 |       "version": "4.1.0",
 681 |       "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
 682 |       "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
 683 |       "requires": {
 684 |         "argparse": "^2.0.1"
 685 |       }
 686 |     },
 687 |     "libphonenumber-js": {
 688 |       "version": "1.9.32",
 689 |       "resolved": "https://registry.npmjs.org/libphonenumber-js/-/libphonenumber-js-1.9.32.tgz",
 690 |       "integrity": "sha512-sXuNLzTU/lNUZ78eWUi5JvqaHAhwBMuMT17613EjLZl/ejIoDe0EV225Xhw4vuZ6FcqkiwsF8qHcOyyn1dBEWQ=="
 691 |     },
 692 |     "lodash": {
 693 |       "version": "4.17.21",
 694 |       "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
 695 |       "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==",
 696 |       "dev": true
 697 |     },
 698 |     "media-typer": {
 699 |       "version": "0.3.0",
 700 |       "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz",
 701 |       "integrity": "sha1-hxDXrwqmJvj/+hzgAWhUUmMlV0g="
 702 |     },
 703 |     "merge-descriptors": {
 704 |       "version": "1.0.1",
 705 |       "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.1.tgz",
 706 |       "integrity": "sha1-sAqqVW3YtEVoFQ7J0blT8/kMu2E="
 707 |     },
 708 |     "methods": {
 709 |       "version": "1.1.2",
 710 |       "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz",
 711 |       "integrity": "sha1-VSmk1nZUE07cxSZmVoNbD4Ua/O4="
 712 |     },
 713 |     "mime": {
 714 |       "version": "1.6.0",
 715 |       "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz",
 716 |       "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg=="
 717 |     },
 718 |     "mime-db": {
 719 |       "version": "1.49.0",
 720 |       "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.49.0.tgz",
 721 |       "integrity": "sha512-CIc8j9URtOVApSFCQIF+VBkX1RwXp/oMMOrqdyXSBXq5RWNEsRfyj1kiRnQgmNXmHxPoFIxOroKA3zcU9P+nAA=="
 722 |     },
 723 |     "mime-types": {
 724 |       "version": "2.1.32",
 725 |       "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.32.tgz",
 726 |       "integrity": "sha512-hJGaVS4G4c9TSMYh2n6SQAGrC4RnfU+daP8G7cSCmaqNjiOoUY0VHCMS42pxnQmVF1GWwFhbHWn3RIxCqTmZ9A==",
 727 |       "requires": {
 728 |         "mime-db": "1.49.0"
 729 |       }
 730 |     },
 731 |     "minimatch": {
 732 |       "version": "3.0.4",
 733 |       "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
 734 |       "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
 735 |       "requires": {
 736 |         "brace-expansion": "^1.1.7"
 737 |       }
 738 |     },
 739 |     "minimist": {
 740 |       "version": "1.2.5",
 741 |       "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.5.tgz",
 742 |       "integrity": "sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw=="
 743 |     },
 744 |     "mkdirp": {
 745 |       "version": "0.5.5",
 746 |       "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.5.tgz",
 747 |       "integrity": "sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ==",
 748 |       "requires": {
 749 |         "minimist": "^1.2.5"
 750 |       }
 751 |     },
 752 |     "ms": {
 753 |       "version": "2.0.0",
 754 |       "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
 755 |       "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g="
 756 |     },
 757 |     "multer": {
 758 |       "version": "1.4.2",
 759 |       "resolved": "https://registry.npmjs.org/multer/-/multer-1.4.2.tgz",
 760 |       "integrity": "sha512-xY8pX7V+ybyUpbYMxtjM9KAiD9ixtg5/JkeKUTD6xilfDv0vzzOFcCp4Ljb1UU3tSOM3VTZtKo63OmzOrGi3Cg==",
 761 |       "requires": {
 762 |         "append-field": "^1.0.0",
 763 |         "busboy": "^0.2.11",
 764 |         "concat-stream": "^1.5.2",
 765 |         "mkdirp": "^0.5.1",
 766 |         "object-assign": "^4.1.1",
 767 |         "on-finished": "^2.3.0",
 768 |         "type-is": "^1.6.4",
 769 |         "xtend": "^4.0.0"
 770 |       }
 771 |     },
 772 |     "mz": {
 773 |       "version": "2.7.0",
 774 |       "resolved": "https://registry.npmjs.org/mz/-/mz-2.7.0.tgz",
 775 |       "integrity": "sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==",
 776 |       "requires": {
 777 |         "any-promise": "^1.0.0",
 778 |         "object-assign": "^4.0.1",
 779 |         "thenify-all": "^1.0.0"
 780 |       }
 781 |     },
 782 |     "negotiator": {
 783 |       "version": "0.6.2",
 784 |       "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.2.tgz",
 785 |       "integrity": "sha512-hZXc7K2e+PgeI1eDBe/10Ard4ekbfrrqG8Ep+8Jmf4JID2bNg7NvCPOZN+kfF574pFQI7mum2AUqDidoKqcTOw=="
 786 |     },
 787 |     "neo-async": {
 788 |       "version": "2.6.2",
 789 |       "resolved": "https://registry.npmjs.org/neo-async/-/neo-async-2.6.2.tgz",
 790 |       "integrity": "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw=="
 791 |     },
 792 |     "node-fetch": {
 793 |       "version": "2.6.2",
 794 |       "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.2.tgz",
 795 |       "integrity": "sha512-aLoxToI6RfZ+0NOjmWAgn9+LEd30YCkJKFSyWacNZdEKTit/ZMcKjGkTRo8uWEsnIb/hfKecNPEbln02PdWbcA==",
 796 |       "dev": true
 797 |     },
 798 |     "object-assign": {
 799 |       "version": "4.1.1",
 800 |       "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
 801 |       "integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM="
 802 |     },
 803 |     "object-hash": {
 804 |       "version": "2.2.0",
 805 |       "resolved": "https://registry.npmjs.org/object-hash/-/object-hash-2.2.0.tgz",
 806 |       "integrity": "sha512-gScRMn0bS5fH+IuwyIFgnh9zBdo4DV+6GhygmWM9HyNJSgS0hScp1f5vjtm7oIIOiT9trXrShAkLFSc2IqKNgw==",
 807 |       "dev": true
 808 |     },
 809 |     "on-finished": {
 810 |       "version": "2.3.0",
 811 |       "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.3.0.tgz",
 812 |       "integrity": "sha1-IPEzZIGwg811M3mSoWlxqi2QaUc=",
 813 |       "requires": {
 814 |         "ee-first": "1.1.1"
 815 |       }
 816 |     },
 817 |     "once": {
 818 |       "version": "1.4.0",
 819 |       "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
 820 |       "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
 821 |       "requires": {
 822 |         "wrappy": "1"
 823 |       }
 824 |     },
 825 |     "parent-require": {
 826 |       "version": "1.0.0",
 827 |       "resolved": "https://registry.npmjs.org/parent-require/-/parent-require-1.0.0.tgz",
 828 |       "integrity": "sha1-dGoWdjgIOoYLDu9nMssn7UbDKXc="
 829 |     },
 830 |     "parse5": {
 831 |       "version": "5.1.1",
 832 |       "resolved": "https://registry.npmjs.org/parse5/-/parse5-5.1.1.tgz",
 833 |       "integrity": "sha512-ugq4DFI0Ptb+WWjAdOK16+u/nHfiIrcE+sh8kZMaM0WllQKLI9rOUq6c2b7cwPkXdzfQESqvoqK6ug7U/Yyzug=="
 834 |     },
 835 |     "parse5-htmlparser2-tree-adapter": {
 836 |       "version": "6.0.1",
 837 |       "resolved": "https://registry.npmjs.org/parse5-htmlparser2-tree-adapter/-/parse5-htmlparser2-tree-adapter-6.0.1.tgz",
 838 |       "integrity": "sha512-qPuWvbLgvDGilKc5BoicRovlT4MtYT6JfJyBOMDsKoiT+GiuP5qyrPCnR9HcPECIJJmZh5jRndyNThnhhb/vlA==",
 839 |       "requires": {
 840 |         "parse5": "^6.0.1"
 841 |       },
 842 |       "dependencies": {
 843 |         "parse5": {
 844 |           "version": "6.0.1",
 845 |           "resolved": "https://registry.npmjs.org/parse5/-/parse5-6.0.1.tgz",
 846 |           "integrity": "sha512-Ofn/CTFzRGTTxwpNEs9PP93gXShHcTq255nzRYSKe8AkVpZY7e1fpmTfOyoIvjP5HG7Z2ZM7VS9PPhQGW2pOpw=="
 847 |         }
 848 |       }
 849 |     },
 850 |     "parseurl": {
 851 |       "version": "1.3.3",
 852 |       "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
 853 |       "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ=="
 854 |     },
 855 |     "path-is-absolute": {
 856 |       "version": "1.0.1",
 857 |       "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
 858 |       "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18="
 859 |     },
 860 |     "path-to-regexp": {
 861 |       "version": "3.2.0",
 862 |       "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-3.2.0.tgz",
 863 |       "integrity": "sha512-jczvQbCUS7XmS7o+y1aEO9OBVFeZBQ1MDSEqmO7xSoPgOPoowY/SxLpZ6Vh97/8qHZOteiCKb7gkG9gA2ZUxJA==",
 864 |       "dev": true
 865 |     },
 866 |     "prettier": {
 867 |       "version": "2.4.0",
 868 |       "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.4.0.tgz",
 869 |       "integrity": "sha512-DsEPLY1dE5HF3BxCRBmD4uYZ+5DCbvatnolqTqcxEgKVZnL2kUfyu7b8pPQ5+hTBkdhU9SLUmK0/pHb07RE4WQ==",
 870 |       "dev": true
 871 |     },
 872 |     "process-nextick-args": {
 873 |       "version": "2.0.1",
 874 |       "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
 875 |       "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag=="
 876 |     },
 877 |     "proxy-addr": {
 878 |       "version": "2.0.7",
 879 |       "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
 880 |       "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
 881 |       "requires": {
 882 |         "forwarded": "0.2.0",
 883 |         "ipaddr.js": "1.9.1"
 884 |       }
 885 |     },
 886 |     "qs": {
 887 |       "version": "6.7.0",
 888 |       "resolved": "https://registry.npmjs.org/qs/-/qs-6.7.0.tgz",
 889 |       "integrity": "sha512-VCdBRNFTX1fyE7Nb6FYoURo/SPe62QCaAyzJvUjwRaIsc+NePBEniHlvxFmmX56+HZphIGtV0XeCirBtpDrTyQ=="
 890 |     },
 891 |     "range-parser": {
 892 |       "version": "1.2.1",
 893 |       "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
 894 |       "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg=="
 895 |     },
 896 |     "raw-body": {
 897 |       "version": "2.4.0",
 898 |       "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.4.0.tgz",
 899 |       "integrity": "sha512-4Oz8DUIwdvoa5qMJelxipzi/iJIi40O5cGV1wNYp5hvZP8ZN0T+jiNkL0QepXs+EsQ9XJ8ipEDoiH70ySUJP3Q==",
 900 |       "requires": {
 901 |         "bytes": "3.1.0",
 902 |         "http-errors": "1.7.2",
 903 |         "iconv-lite": "0.4.24",
 904 |         "unpipe": "1.0.0"
 905 |       }
 906 |     },
 907 |     "readable-stream": {
 908 |       "version": "1.1.14",
 909 |       "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz",
 910 |       "integrity": "sha1-fPTFTvZI44EwhMY23SB54WbAgdk=",
 911 |       "requires": {
 912 |         "core-util-is": "~1.0.0",
 913 |         "inherits": "~2.0.1",
 914 |         "isarray": "0.0.1",
 915 |         "string_decoder": "~0.10.x"
 916 |       }
 917 |     },
 918 |     "reflect-metadata": {
 919 |       "version": "0.1.13",
 920 |       "resolved": "https://registry.npmjs.org/reflect-metadata/-/reflect-metadata-0.1.13.tgz",
 921 |       "integrity": "sha512-Ts1Y/anZELhSsjMcU605fU9RE4Oi3p5ORujwbIKXfWa+0Zxs510Qrmrce5/Jowq3cHSZSJqBjypxmHarc+vEWg=="
 922 |     },
 923 |     "require-directory": {
 924 |       "version": "2.1.1",
 925 |       "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
 926 |       "integrity": "sha1-jGStX9MNqxyXbiNE/+f3kqam30I="
 927 |     },
 928 |     "rimraf": {
 929 |       "version": "3.0.2",
 930 |       "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz",
 931 |       "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==",
 932 |       "dev": true,
 933 |       "requires": {
 934 |         "glob": "^7.1.3"
 935 |       }
 936 |     },
 937 |     "rxjs": {
 938 |       "version": "7.3.0",
 939 |       "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-7.3.0.tgz",
 940 |       "integrity": "sha512-p2yuGIg9S1epc3vrjKf6iVb3RCaAYjYskkO+jHIaV0IjOPlJop4UnodOoFb2xeNwlguqLYvGw1b1McillYb5Gw==",
 941 |       "dev": true,
 942 |       "requires": {
 943 |         "tslib": "~2.1.0"
 944 |       },
 945 |       "dependencies": {
 946 |         "tslib": {
 947 |           "version": "2.1.0",
 948 |           "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.1.0.tgz",
 949 |           "integrity": "sha512-hcVC3wYEziELGGmEEXue7D75zbwIIVUMWAVbHItGPx0ziyXxrOMQx4rQEVEV45Ut/1IotuEvwqPopzIOkDMf0A==",
 950 |           "dev": true
 951 |         }
 952 |       }
 953 |     },
 954 |     "safe-buffer": {
 955 |       "version": "5.1.2",
 956 |       "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
 957 |       "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g=="
 958 |     },
 959 |     "safer-buffer": {
 960 |       "version": "2.1.2",
 961 |       "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
 962 |       "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="
 963 |     },
 964 |     "sax": {
 965 |       "version": "1.2.4",
 966 |       "resolved": "https://registry.npmjs.org/sax/-/sax-1.2.4.tgz",
 967 |       "integrity": "sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw=="
 968 |     },
 969 |     "send": {
 970 |       "version": "0.17.1",
 971 |       "resolved": "https://registry.npmjs.org/send/-/send-0.17.1.tgz",
 972 |       "integrity": "sha512-BsVKsiGcQMFwT8UxypobUKyv7irCNRHk1T0G680vk88yf6LBByGcZJOTJCrTP2xVN6yI+XjPJcNuE3V4fT9sAg==",
 973 |       "requires": {
 974 |         "debug": "2.6.9",
 975 |         "depd": "~1.1.2",
 976 |         "destroy": "~1.0.4",
 977 |         "encodeurl": "~1.0.2",
 978 |         "escape-html": "~1.0.3",
 979 |         "etag": "~1.8.1",
 980 |         "fresh": "0.5.2",
 981 |         "http-errors": "~1.7.2",
 982 |         "mime": "1.6.0",
 983 |         "ms": "2.1.1",
 984 |         "on-finished": "~2.3.0",
 985 |         "range-parser": "~1.2.1",
 986 |         "statuses": "~1.5.0"
 987 |       },
 988 |       "dependencies": {
 989 |         "ms": {
 990 |           "version": "2.1.1",
 991 |           "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.1.tgz",
 992 |           "integrity": "sha512-tgp+dl5cGk28utYktBsrFqA7HKgrhgPsg6Z/EfhWI4gl1Hwq8B/GmY/0oXZ6nF8hDVesS/FpnYaD/kOWhYQvyg=="
 993 |         }
 994 |       }
 995 |     },
 996 |     "serve-static": {
 997 |       "version": "1.14.1",
 998 |       "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.14.1.tgz",
 999 |       "integrity": "sha512-JMrvUwE54emCYWlTI+hGrGv5I8dEwmco/00EvkzIIsR7MqrHonbD9pO2MOfFnpFntl7ecpZs+3mW+XbQZu9QCg==",
1000 |       "requires": {
1001 |         "encodeurl": "~1.0.2",
1002 |         "escape-html": "~1.0.3",
1003 |         "parseurl": "~1.3.3",
1004 |         "send": "0.17.1"
1005 |       }
1006 |     },
1007 |     "setprototypeof": {
1008 |       "version": "1.1.1",
1009 |       "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.1.1.tgz",
1010 |       "integrity": "sha512-JvdAWfbXeIGaZ9cILp38HntZSFSo3mWg6xGcJJsd+d4aRMOqauag1C63dJfDw7OaMYwEbHMOxEZ1lqVRYP2OAw=="
1011 |     },
1012 |     "sha.js": {
1013 |       "version": "2.4.11",
1014 |       "resolved": "https://registry.npmjs.org/sha.js/-/sha.js-2.4.11.tgz",
1015 |       "integrity": "sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==",
1016 |       "requires": {
1017 |         "inherits": "^2.0.1",
1018 |         "safe-buffer": "^5.0.1"
1019 |       }
1020 |     },
1021 |     "source-map": {
1022 |       "version": "0.6.1",
1023 |       "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
1024 |       "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g=="
1025 |     },
1026 |     "statuses": {
1027 |       "version": "1.5.0",
1028 |       "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.5.0.tgz",
1029 |       "integrity": "sha1-Fhx9rBd2Wf2YEfQ3cfqZOBR4Yow="
1030 |     },
1031 |     "streamsearch": {
1032 |       "version": "0.1.2",
1033 |       "resolved": "https://registry.npmjs.org/streamsearch/-/streamsearch-0.1.2.tgz",
1034 |       "integrity": "sha1-gIudDlb8Jz2Am6VzOOkpkZoanxo="
1035 |     },
1036 |     "string-width": {
1037 |       "version": "4.2.2",
1038 |       "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.2.tgz",
1039 |       "integrity": "sha512-XBJbT3N4JhVumXE0eoLU9DCjcaF92KLNqTmFCnG1pf8duUxFGwtP6AD6nkjw9a3IdiRtL3E2w3JDiE/xi3vOeA==",
1040 |       "requires": {
1041 |         "emoji-regex": "^8.0.0",
1042 |         "is-fullwidth-code-point": "^3.0.0",
1043 |         "strip-ansi": "^6.0.0"
1044 |       }
1045 |     },
1046 |     "string_decoder": {
1047 |       "version": "0.10.31",
1048 |       "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz",
1049 |       "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ="
1050 |     },
1051 |     "strip-ansi": {
1052 |       "version": "6.0.0",
1053 |       "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.0.tgz",
1054 |       "integrity": "sha512-AuvKTrTfQNYNIctbR1K/YGTR1756GycPsg7b9bdV9Duqur4gv6aKqHXah67Z8ImS7WEz5QVcOtlfW2rZEugt6w==",
1055 |       "requires": {
1056 |         "ansi-regex": "^5.0.0"
1057 |       }
1058 |     },
1059 |     "supports-color": {
1060 |       "version": "7.2.0",
1061 |       "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
1062 |       "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
1063 |       "requires": {
1064 |         "has-flag": "^4.0.0"
1065 |       }
1066 |     },
1067 |     "thenify": {
1068 |       "version": "3.3.1",
1069 |       "resolved": "https://registry.npmjs.org/thenify/-/thenify-3.3.1.tgz",
1070 |       "integrity": "sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==",
1071 |       "requires": {
1072 |         "any-promise": "^1.0.0"
1073 |       }
1074 |     },
1075 |     "thenify-all": {
1076 |       "version": "1.6.0",
1077 |       "resolved": "https://registry.npmjs.org/thenify-all/-/thenify-all-1.6.0.tgz",
1078 |       "integrity": "sha1-GhkY1ALY/D+Y+/I02wvMjMEOlyY=",
1079 |       "requires": {
1080 |         "thenify": ">= 3.1.0 < 4"
1081 |       }
1082 |     },
1083 |     "toidentifier": {
1084 |       "version": "1.0.0",
1085 |       "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.0.tgz",
1086 |       "integrity": "sha512-yaOH/Pk/VEhBWWTlhI+qXxDFXlejDGcQipMlyxda9nthulaxLZUNcUqFxokp0vcYnvteJln5FNQDRrxj3YcbVw=="
1087 |     },
1088 |     "tslib": {
1089 |       "version": "2.3.0",
1090 |       "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.3.0.tgz",
1091 |       "integrity": "sha512-N82ooyxVNm6h1riLCoyS9e3fuJ3AMG2zIZs2Gd1ATcSFjSA23Q0fzjjZeh0jbJvWVDZ0cJT8yaNNaaXHzueNjg=="
1092 |     },
1093 |     "type-is": {
1094 |       "version": "1.6.18",
1095 |       "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz",
1096 |       "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==",
1097 |       "requires": {
1098 |         "media-typer": "0.3.0",
1099 |         "mime-types": "~2.1.24"
1100 |       }
1101 |     },
1102 |     "typedarray": {
1103 |       "version": "0.0.6",
1104 |       "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz",
1105 |       "integrity": "sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c="
1106 |     },
1107 |     "typeorm": {
1108 |       "version": "0.2.37",
1109 |       "resolved": "https://registry.npmjs.org/typeorm/-/typeorm-0.2.37.tgz",
1110 |       "integrity": "sha512-7rkW0yCgFC24I5T0f3S/twmLSuccPh1SQmxET/oDWn2sSDVzbyWdnItSdKy27CdJGTlKHYtUVeOcMYw5LRsXVw==",
1111 |       "requires": {
1112 |         "@sqltools/formatter": "^1.2.2",
1113 |         "app-root-path": "^3.0.0",
1114 |         "buffer": "^6.0.3",
1115 |         "chalk": "^4.1.0",
1116 |         "cli-highlight": "^2.1.11",
1117 |         "debug": "^4.3.1",
1118 |         "dotenv": "^8.2.0",
1119 |         "glob": "^7.1.6",
1120 |         "js-yaml": "^4.0.0",
1121 |         "mkdirp": "^1.0.4",
1122 |         "reflect-metadata": "^0.1.13",
1123 |         "sha.js": "^2.4.11",
1124 |         "tslib": "^2.1.0",
1125 |         "xml2js": "^0.4.23",
1126 |         "yargonaut": "^1.1.4",
1127 |         "yargs": "^17.0.1",
1128 |         "zen-observable-ts": "^1.0.0"
1129 |       },
1130 |       "dependencies": {
1131 |         "debug": {
1132 |           "version": "4.3.2",
1133 |           "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.2.tgz",
1134 |           "integrity": "sha512-mOp8wKcvj7XxC78zLgw/ZA+6TSgkoE2C/ienthhRD298T7UNwAg9diBpLRxC0mOezLl4B0xV7M0cCO6P/O0Xhw==",
1135 |           "requires": {
1136 |             "ms": "2.1.2"
1137 |           }
1138 |         },
1139 |         "mkdirp": {
1140 |           "version": "1.0.4",
1141 |           "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz",
1142 |           "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw=="
1143 |         },
1144 |         "ms": {
1145 |           "version": "2.1.2",
1146 |           "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
1147 |           "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w=="
1148 |         }
1149 |       }
1150 |     },
1151 |     "typescript": {
1152 |       "version": "4.4.3",
1153 |       "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.4.3.tgz",
1154 |       "integrity": "sha512-4xfscpisVgqqDfPaJo5vkd+Qd/ItkoagnHpufr+i2QCHBsNYp+G7UAoyFl8aPtx879u38wPV65rZ8qbGZijalA==",
1155 |       "dev": true
1156 |     },
1157 |     "uglify-js": {
1158 |       "version": "3.14.2",
1159 |       "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.14.2.tgz",
1160 |       "integrity": "sha512-rtPMlmcO4agTUfz10CbgJ1k6UAoXM2gWb3GoMPPZB/+/Ackf8lNWk11K4rYi2D0apgoFRLtQOZhb+/iGNJq26A==",
1161 |       "optional": true
1162 |     },
1163 |     "unpipe": {
1164 |       "version": "1.0.0",
1165 |       "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
1166 |       "integrity": "sha1-sr9O6FFKrmFltIF4KdIbLvSZBOw="
1167 |     },
1168 |     "util-deprecate": {
1169 |       "version": "1.0.2",
1170 |       "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
1171 |       "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8="
1172 |     },
1173 |     "utils-merge": {
1174 |       "version": "1.0.1",
1175 |       "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz",
1176 |       "integrity": "sha1-n5VxD1CiZ5R7LMwSR0HBAoQn5xM="
1177 |     },
1178 |     "uuid": {
1179 |       "version": "8.3.2",
1180 |       "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
1181 |       "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg=="
1182 |     },
1183 |     "validator": {
1184 |       "version": "13.6.0",
1185 |       "resolved": "https://registry.npmjs.org/validator/-/validator-13.6.0.tgz",
1186 |       "integrity": "sha512-gVgKbdbHgtxpRyR8K0O6oFZPhhB5tT1jeEHZR0Znr9Svg03U0+r9DXWMrnRAB+HtCStDQKlaIZm42tVsVjqtjg=="
1187 |     },
1188 |     "vary": {
1189 |       "version": "1.1.2",
1190 |       "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
1191 |       "integrity": "sha1-IpnwLG3tMNSllhsLn3RSShj2NPw="
1192 |     },
1193 |     "walk": {
1194 |       "version": "2.3.14",
1195 |       "resolved": "https://registry.npmjs.org/walk/-/walk-2.3.14.tgz",
1196 |       "integrity": "sha512-5skcWAUmySj6hkBdH6B6+3ddMjVQYH5Qy9QGbPmN8kVmLteXk+yVXg+yfk1nbX30EYakahLrr8iPcCxJQSCBeg==",
1197 |       "requires": {
1198 |         "foreachasync": "^3.0.0"
1199 |       }
1200 |     },
1201 |     "wordwrap": {
1202 |       "version": "1.0.0",
1203 |       "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz",
1204 |       "integrity": "sha1-J1hIEIkUVqQXHI0CJkQa3pDLyus="
1205 |     },
1206 |     "wrap-ansi": {
1207 |       "version": "7.0.0",
1208 |       "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
1209 |       "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
1210 |       "requires": {
1211 |         "ansi-styles": "^4.0.0",
1212 |         "string-width": "^4.1.0",
1213 |         "strip-ansi": "^6.0.0"
1214 |       }
1215 |     },
1216 |     "wrappy": {
1217 |       "version": "1.0.2",
1218 |       "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
1219 |       "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8="
1220 |     },
1221 |     "xml2js": {
1222 |       "version": "0.4.23",
1223 |       "resolved": "https://registry.npmjs.org/xml2js/-/xml2js-0.4.23.tgz",
1224 |       "integrity": "sha512-ySPiMjM0+pLDftHgXY4By0uswI3SPKLDw/i3UXbnO8M/p28zqexCUoPmQFrYD+/1BzhGJSs2i1ERWKJAtiLrug==",
1225 |       "requires": {
1226 |         "sax": ">=0.6.0",
1227 |         "xmlbuilder": "~11.0.0"
1228 |       }
1229 |     },
1230 |     "xmlbuilder": {
1231 |       "version": "11.0.1",
1232 |       "resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-11.0.1.tgz",
1233 |       "integrity": "sha512-fDlsI/kFEx7gLvbecc0/ohLG50fugQp8ryHzMTuW9vSa1GJ0XYWKnhsUx7oie3G98+r56aTQIUB4kht42R3JvA=="
1234 |     },
1235 |     "xtend": {
1236 |       "version": "4.0.2",
1237 |       "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
1238 |       "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ=="
1239 |     },
1240 |     "y18n": {
1241 |       "version": "5.0.8",
1242 |       "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
1243 |       "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA=="
1244 |     },
1245 |     "yargonaut": {
1246 |       "version": "1.1.4",
1247 |       "resolved": "https://registry.npmjs.org/yargonaut/-/yargonaut-1.1.4.tgz",
1248 |       "integrity": "sha512-rHgFmbgXAAzl+1nngqOcwEljqHGG9uUZoPjsdZEs1w5JW9RXYzrSvH/u70C1JE5qFi0qjsdhnUX/dJRpWqitSA==",
1249 |       "requires": {
1250 |         "chalk": "^1.1.1",
1251 |         "figlet": "^1.1.1",
1252 |         "parent-require": "^1.0.0"
1253 |       },
1254 |       "dependencies": {
1255 |         "ansi-regex": {
1256 |           "version": "2.1.1",
1257 |           "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz",
1258 |           "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8="
1259 |         },
1260 |         "ansi-styles": {
1261 |           "version": "2.2.1",
1262 |           "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-2.2.1.tgz",
1263 |           "integrity": "sha1-tDLdM1i2NM914eRmQ2gkBTPB3b4="
1264 |         },
1265 |         "chalk": {
1266 |           "version": "1.1.3",
1267 |           "resolved": "https://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz",
1268 |           "integrity": "sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=",
1269 |           "requires": {
1270 |             "ansi-styles": "^2.2.1",
1271 |             "escape-string-regexp": "^1.0.2",
1272 |             "has-ansi": "^2.0.0",
1273 |             "strip-ansi": "^3.0.0",
1274 |             "supports-color": "^2.0.0"
1275 |           }
1276 |         },
1277 |         "strip-ansi": {
1278 |           "version": "3.0.1",
1279 |           "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz",
1280 |           "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=",
1281 |           "requires": {
1282 |             "ansi-regex": "^2.0.0"
1283 |           }
1284 |         },
1285 |         "supports-color": {
1286 |           "version": "2.0.0",
1287 |           "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-2.0.0.tgz",
1288 |           "integrity": "sha1-U10EXOa2Nj+kARcIRimZXp3zJMc="
1289 |         }
1290 |       }
1291 |     },
1292 |     "yargs": {
1293 |       "version": "17.1.1",
1294 |       "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.1.1.tgz",
1295 |       "integrity": "sha512-c2k48R0PwKIqKhPMWjeiF6y2xY/gPMUlro0sgxqXpbOIohWiLNXWslsootttv7E1e73QPAMQSg5FeySbVcpsPQ==",
1296 |       "requires": {
1297 |         "cliui": "^7.0.2",
1298 |         "escalade": "^3.1.1",
1299 |         "get-caller-file": "^2.0.5",
1300 |         "require-directory": "^2.1.1",
1301 |         "string-width": "^4.2.0",
1302 |         "y18n": "^5.0.5",
1303 |         "yargs-parser": "^20.2.2"
1304 |       }
1305 |     },
1306 |     "yargs-parser": {
1307 |       "version": "20.2.9",
1308 |       "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.9.tgz",
1309 |       "integrity": "sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w=="
1310 |     },
1311 |     "zen-observable": {
1312 |       "version": "0.8.15",
1313 |       "resolved": "https://registry.npmjs.org/zen-observable/-/zen-observable-0.8.15.tgz",
1314 |       "integrity": "sha512-PQ2PC7R9rslx84ndNBZB/Dkv8V8fZEpk83RLgXtYd0fwUgEjseMn1Dgajh2x6S8QbZAFa9p2qVCEuYZNgve0dQ=="
1315 |     },
1316 |     "zen-observable-ts": {
1317 |       "version": "1.1.0",
1318 |       "resolved": "https://registry.npmjs.org/zen-observable-ts/-/zen-observable-ts-1.1.0.tgz",
1319 |       "integrity": "sha512-1h4zlLSqI2cRLPJUHJFL8bCWHhkpuXkF+dbGkRaWjgDIG26DmzyshUMrdV/rL3UnR+mhaX4fRq8LPouq0MYYIA==",
1320 |       "requires": {
1321 |         "@types/zen-observable": "0.8.3",
1322 |         "zen-observable": "0.8.15"
1323 |       }
1324 |     }
1325 |   }
1326 | }
1327 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "nestjs-mocker",
 3 |   "version": "1.0.0",
 4 |   "description": "",
 5 |   "main": ".eslintrc.js",
 6 |   "scripts": {
 7 |     "format": "prettier --write \"libs/**/*.ts\"",
 8 |     "prebuild": "rimraf dist",
 9 |     "build": "tsc",
10 |     "start:dev": "npm run prebuild && nest start --watch"
11 |   },
12 |   "repository": {
13 |     "type": "git",
14 |     "url": "git+https://github.com/hodford/nestjs-mocker.git"
15 |   },
16 |   "author": "",
17 |   "license": "ISC",
18 |   "bugs": {
19 |     "url": "https://github.com/hodford/nestjs-mocker/issues"
20 |   },
21 |   "homepage": "https://github.com/hodford/nestjs-mocker#readme",
22 |   "devDependencies": {
23 |     "@nestjs/common": "^8.0.6",
24 |     "@nestjs/core": "^8.0.6",
25 |     "@nestjs/swagger": "^5.0.9",
26 |     "@types/node": "^16.9.1",
27 |     "prettier": "^2.4.0",
28 |     "rimraf": "^3.0.2",
29 |     "rxjs": "^7.3.0",
30 |     "typescript": "^4.4.3"
31 |   },
32 |   "dependencies": {
33 |     "@nestjs/platform-express": "^8.0.6",
34 |     "@nestjs/typeorm": "github:nestjs/typeorm",
35 |     "class-validator": "^0.13.1",
36 |     "faker": "^5.5.3",
37 |     "hbs": "^4.1.2",
38 |     "typeorm": "^0.2.37",
39 |     "uuid": "^8.3.2"
40 |   }
41 | }
42 | 


--------------------------------------------------------------------------------
/tsconfig.build.json:
--------------------------------------------------------------------------------
1 | {
2 |   "extends": "./tsconfig.json",
3 |   "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
4 | }
5 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "module": "commonjs",
 4 |     "moduleResolution": "node",
 5 |     "esModuleInterop": true,
 6 |     "declaration": true,
 7 |     "removeComments": true,
 8 |     "emitDecoratorMetadata": true,
 9 |     "experimentalDecorators": true,
10 |     "allowSyntheticDefaultImports": true,
11 |     "target": "es2017",
12 |     "sourceMap": true,
13 |     "outDir": "dist",
14 |     "baseUrl": "./",
15 |     "incremental": true,
16 |     "paths": {
17 |       "~*": ["libs/*"]
18 |     }
19 |   },
20 |   "include": [
21 |     "libs"
22 |   ],
23 |   "exclude": [
24 |     "tests",
25 |     "src",
26 |     "dist",
27 |     "node_modules"
28 |   ]
29 | }
30 | 


--------------------------------------------------------------------------------