@koalarx/nest 0.0.9 → 1.0.0

package/core/mapping/auto-mapping.service.js

@@ -0,0 +1,93 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoMappingService = void 0;
+const common_1 = require("@nestjs/common");
+const list_1 = require("../utils/list");
+const auto_mapping_list_1 = require("./auto-mapping-list");
+const auto_mapping_profile_1 = require("./auto-mapping-profile");
+let AutoMappingService = exports.AutoMappingService = class AutoMappingService {
+    _contextList = auto_mapping_list_1.AutoMappingList;
+    constructor(automappingProfile) {
+        automappingProfile.profile();
+    }
+    map(data, source, target) {
+        const { mapContext, propSourceContext, propTargetContext } = this._contextList.get(source, target);
+        if (!mapContext) {
+            throw new Error(`No mapping context found for ${source.name} to ${target.name}`);
+        }
+        const mappedTarget = new target.prototype.constructor();
+        propSourceContext?.props.forEach((propSource) => {
+            const value = data[propSource.name];
+            const compositionType = propSource.compositionType;
+            const compositionAction = propSource.compositionAction;
+            if (value) {
+                const targetProp = propTargetContext?.props.find((tp) => tp.name === propSource.name);
+                if (targetProp) {
+                    const listToArray = propSource.type === list_1.List.name &&
+                        targetProp.type === Array.name &&
+                        value instanceof list_1.List;
+                    const arrayToList = propSource.type === Array.name &&
+                        targetProp.type === list_1.List.name &&
+                        value instanceof Array &&
+                        !!compositionType;
+                    let mappedValue = value;
+                    if (listToArray) {
+                        mappedValue = this.mapListToArray(value);
+                    }
+                    else if (arrayToList) {
+                        mappedValue = this.mapArrayToList(value, compositionType, compositionAction === 'onlySet');
+                    }
+                    mappedTarget[targetProp.name] = mappedValue;
+                }
+            }
+        });
+        Object.keys(mappedTarget).forEach((key) => {
+            const formMemberDefinition = mapContext.forMemberDifinitions?.find((def) => def[key])?.[key];
+            if (formMemberDefinition) {
+                mappedTarget[key] = formMemberDefinition(data);
+            }
+        });
+        return mappedTarget;
+    }
+    mapNestedProp(data, source) {
+        const targets = this._contextList.getTargets(source.prototype.constructor);
+        if (targets.length >= 1) {
+            return this.map(data, source.prototype.constructor, targets[0]);
+        }
+    }
+    mapListToArray(value) {
+        return value
+            .toArray()
+            .map((item) => {
+            const entityOnList = value.entityType?.prototype.constructor;
+            if (entityOnList) {
+                return this.mapNestedProp(item, entityOnList) ?? {};
+            }
+            return {};
+        });
+    }
+    mapArrayToList(value, compositionType, onlySet = true) {
+        const list = new list_1.List(compositionType.prototype.constructor);
+        const mappedValue = value.map((item) => this.mapNestedProp(item, compositionType.prototype.constructor) ?? {});
+        if (onlySet) {
+            list.setList(mappedValue);
+        }
+        else {
+            list.update(mappedValue);
+        }
+        return list;
+    }
+};
+exports.AutoMappingService = AutoMappingService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [auto_mapping_profile_1.AutoMappingProfile])
+], AutoMappingService);

package/core/mapping/create-map.d.ts

@@ -0,0 +1,3 @@
+import { Type } from '@nestjs/common';
+import { ForMemberDefinition } from './for-member';
+export declare function createMap<TSource, TTarget>(source: Type<TSource>, target: Type<TTarget>, ...formMember: ForMemberDefinition<TTarget, TSource>): void;

package/core/mapping/create-map.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMap = void 0;
+const auto_mapping_list_1 = require("./auto-mapping-list");
+function createMap(source, target, ...formMember) {
+    auto_mapping_list_1.AutoMappingList.add(source, target, ...formMember);
+}
+exports.createMap = createMap;

package/core/mapping/for-member.d.ts

@@ -0,0 +1,5 @@
+export type ForMemberResult<TTarget, TSource> = {
+    [Key in keyof TTarget]: (source: TSource) => TTarget[Key];
+};
+export type ForMemberDefinition<TTarget, TSource> = Array<Partial<ForMemberResult<TTarget, TSource>>>;
+export declare function forMember<TTarget, TSource>(targetProp: keyof TTarget, map: (source: TSource) => TTarget[keyof TTarget]): Partial<ForMemberResult<TTarget, TSource>>;

package/core/mapping/for-member.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forMember = void 0;
+function forMember(targetProp, map) {
+    return {
+        [targetProp]: map,
+    };
+}
+exports.forMember = forMember;

package/{common → core}/models/pagination-params.d.ts

@@ -4,6 +4,9 @@ export declare const QueryFilterParams: {
     page: number;
     limit: number;
 };
+export type PaginatedRequestProps<T extends PaginationParams> = Omit<{
+    [K in keyof T as T[K] extends Function ? never : K]: T[K];
+}, '_id'>;
 export declare class PaginationParams {
     page?: number;
     limit?: number;

package/{common → core}/models/pagination-params.js

@@ -5,6 +5,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PaginationParams = exports.QueryFilterParams = void 0;
 const swagger_1 = require("@nestjs/swagger");
@@ -37,24 +40,28 @@ __decorate([
         required: false,
         format: 'int32',
         default: exports.QueryFilterParams.page,
-    })
+    }),
+    __metadata("design:type", Number)
 ], PaginationParams.prototype, "page", void 0);
 __decorate([
     (0, swagger_1.ApiProperty)({
         required: false,
         format: 'int32',
         default: exports.QueryFilterParams.limit,
-    })
+    }),
+    __metadata("design:type", Number)
 ], PaginationParams.prototype, "limit", void 0);
 __decorate([
     (0, swagger_1.ApiProperty)({
         required: false,
-    })
+    }),
+    __metadata("design:type", String)
 ], PaginationParams.prototype, "orderBy", void 0);
 __decorate([
     (0, swagger_1.ApiProperty)({
         required: false,
         enum: ['asc', 'desc'],
         default: exports.QueryFilterParams.direction,
-    })
+    }),
+    __metadata("design:type", String)
 ], PaginationParams.prototype, "direction", void 0);

package/{common/mediator → core/request-overflow}/request-handler.base.d.ts

@@ -1,4 +1,4 @@
-import { RequestResult } from '../../common/mediator/request-result';
+import { RequestResult } from './request-result';
 export declare abstract class RequestHandlerBase<TRequest, TResponse extends RequestResult<Error, any>> {
     abstract handle(req: TRequest): Promise<TResponse>;
 }

package/core/request-overflow/request-result.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/core/request-overflow/request-result.spec.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const request_result_1 = require("./request-result");
+function doSometing(shouldSuccess) {
+    if (shouldSuccess) {
+        return (0, request_result_1.ok)(10);
+    }
+    else {
+        return (0, request_result_1.failure)('error');
+    }
+}
+test('success result', () => {
+    const result = doSometing(true);
+    expect(result.isOk()).toBe(true);
+    expect(result.isFailure()).toBe(false);
+});
+test('error result', () => {
+    const result = doSometing(false);
+    expect(result.isFailure()).toBe(true);
+    expect(result.isOk()).toBe(false);
+});

package/{common/mediator → core/request-overflow}/request-validator.base.d.ts

@@ -2,6 +2,6 @@ import { ZodType } from 'zod';
 export declare abstract class RequestValidatorBase<TRequest> {
     private _request;
     constructor(_request: TRequest);
-    validate(): any;
+    validate(): TRequest;
     protected abstract get schema(): ZodType;
 }

package/{common/mediator → core/request-overflow}/request-validator.base.js

@@ -9,7 +9,7 @@ class RequestValidatorBase {
     validate() {
         const requestParsed = this.schema.safeParse(this._request);
         if (requestParsed.success) {
-            return requestParsed.data;
+            return Object.assign(this._request, requestParsed.data);
         }
         throw requestParsed.error;
     }

package/core/utils/assing-object.d.ts

@@ -0,0 +1,2 @@
+import { Type } from "@nestjs/common";
+export declare function assignObject<T>(target: Type<T>, source: T): T;

package/core/utils/assing-object.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assignObject = void 0;
+function assignObject(target, source) {
+    return Object.assign(new target(), source);
+}
+exports.assignObject = assignObject;

package/core/utils/interfaces/icomparable.d.ts

@@ -1,5 +1,5 @@
 export type IComparableId = string | number;
 export declare abstract class IComparable<T = any> {
-    abstract id: IComparableId;
+    abstract _id: IComparableId;
     abstract equals(obj: IComparable<T>): boolean;
 }

package/core/utils/list.d.ts

@@ -1,24 +1,35 @@
+import { Type } from '@nestjs/common';
+import 'reflect-metadata';
 import { IComparableId } from './interfaces/icomparable';
 export type ListActionType = 'added' | 'updated' | 'removed';
+export interface ListProps<T> {
+    list?: T[];
+    entityType?: Type<T>;
+}
 export declare class List<T> {
+    readonly entityType?: Type<T> | undefined;
     private _list;
     private _addedItemsList;
     private _updatedItemsList;
     private _removedItemsList;
-    constructor(list?: T[]);
+    constructor(entityType?: Type<T> | undefined);
     get length(): number;
     findById(id: IComparableId): T | null;
     findByValue(value: any): T | null;
-    add(item: T): void;
-    remove(item: T): void;
-    clear(): void;
-    forEach(callback: (item: T, index: number) => void): void;
-    forEachAsync(callback: (item: T, index: number) => Promise<void>): Promise<void[]>;
+    setList(list: T[]): this;
+    add(item: T): this | undefined;
+    remove(item: T): this;
+    update(items: T[]): this;
+    clear(): this;
+    forEach(callback: (item: T, index: number) => void): this;
+    forEachAsync(callback: (item: T, index: number) => Promise<void>): Promise<this>;
     map<U>(callback: (item: T, index: number) => U): List<U>;
     mapAsync<U>(callback: (item: T, index: number) => Promise<U>): Promise<List<U>>;
     filter(callback: (item: T, index: number) => boolean): List<T>;
     filterAsync(callback: (item: T, index: number) => Promise<boolean>): Promise<List<T>>;
+    find(callback: (item: T, index: number) => boolean): T | null;
     toArray(type?: ListActionType): T[];
     private indexOf;
     private contains;
+    private mapInternalIdIfIsEmpty;
 }

package/core/utils/list.js

@@ -1,26 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.List = void 0;
-const entity_1 = require("../database/entity");
+require("reflect-metadata");
+const entity_base_1 = require("../database/entity.base");
 class List {
+    entityType;
     _list = [];
     _addedItemsList = [];
     _updatedItemsList = [];
     _removedItemsList = [];
-    constructor(list = []) {
-        this._list = list;
+    constructor(entityType) {
+        this.entityType = entityType;
     }
     get length() {
         return this._list.length;
     }
     findById(id) {
         return (this._list
-            .filter((item) => item instanceof entity_1.Entity)
-            .find((item) => item.id === id) ?? null);
+            .filter((item) => item instanceof entity_base_1.EntityBase)
+            .find((item) => item._id === id || item.id === id) ??
+            null);
     }
     findByValue(value) {
         return this._list.find((item) => item === value) ?? null;
     }
+    setList(list) {
+        this._list = this.mapInternalIdIfIsEmpty(list);
+        return this;
+    }
     add(item) {
         if (this.contains(item)) {
             this._list[this.indexOf(item)] = item;
@@ -31,6 +38,7 @@ class List {
         }
         this._list.push(item);
         this._addedItemsList.push(item);
+        return this;
     }
     remove(item) {
         const index = this.indexOf(item);
@@ -40,30 +48,60 @@ class List {
                 this._removedItemsList.push(item);
             }
         }
+        return this;
+    }
+    update(items) {
+        items = this.mapInternalIdIfIsEmpty(items);
+        items.forEach((item) => this.add(item));
+        this._list
+            .filter((item) => !this.contains(item, items))
+            .forEach((item) => this.remove(item));
+        return this;
     }
     clear() {
+        this._addedItemsList = [];
+        this._updatedItemsList = [];
         this._removedItemsList = this._list;
         this._list = [];
+        return this;
     }
     forEach(callback) {
         this._list.forEach(callback);
+        return this;
     }
-    forEachAsync(callback) {
-        return Promise.all(this._list.map(callback));
+    async forEachAsync(callback) {
+        return Promise.all(this._list.map(callback)).then(() => this);
     }
     map(callback) {
-        return new List(this._list.map(callback));
+        const mappedItems = this._list.map(callback);
+        const list = new List();
+        list.setList(mappedItems);
+        return list;
     }
     async mapAsync(callback) {
-        return Promise.all(this._list.map(callback)).then((list) => new List(list));
+        return Promise.all(this._list.map(callback)).then((mappedItems) => {
+            const mappedList = new List();
+            mappedList.setList(mappedItems);
+            return mappedList;
+        });
     }
     filter(callback) {
-        return new List(this._list.filter(callback));
+        const filteredItems = this._list.filter(callback);
+        const list = new List();
+        list.setList(filteredItems);
+        return list;
     }
     async filterAsync(callback) {
         return Promise.all(this._list.filter(callback))
             .then((list) => list.filter((item) => item))
-            .then((list) => new List(list));
+            .then((filteredItems) => {
+            const list = new List();
+            list.setList(filteredItems);
+            return list;
+        });
+    }
+    find(callback) {
+        return this._list.find(callback) ?? null;
     }
     toArray(type) {
         switch (type) {
@@ -78,17 +116,26 @@ class List {
         }
     }
     indexOf(item, list = this._list) {
-        if (item instanceof entity_1.Entity) {
+        if (item instanceof entity_base_1.EntityBase) {
             return list
-                .filter((i) => i instanceof entity_1.Entity)
-                .findIndex((i) => item.id === i.id);
+                .filter((i) => i instanceof entity_base_1.EntityBase)
+                .findIndex((i) => item._id === i._id ||
+                item.id === i.id);
         }
         return list
-            .filter((i) => !(i instanceof entity_1.Entity))
+            .filter((i) => !(i instanceof entity_base_1.EntityBase))
             .findIndex((i) => item === i);
     }
     contains(item, list = this._list) {
         return this.indexOf(item, list) > -1;
     }
+    mapInternalIdIfIsEmpty(list) {
+        return list.map((item) => {
+            if (item instanceof entity_base_1.EntityBase && !item._id) {
+                item._id = item.id;
+            }
+            return item;
+        });
+    }
 }
 exports.List = List;

package/core/utils/list.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/core/utils/list.spec.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const entity_base_1 = require("../database/entity.base");
+const list_1 = require("./list");
+class EntityTest extends entity_base_1.EntityBase {
+    id;
+    value;
+    constructor(props) {
+        super();
+        this.automap(props);
+    }
+}
+describe('List test', () => {
+    let entity;
+    beforeEach(() => {
+        entity = new EntityTest({ id: 1, value: 1 });
+    });
+    it('should add item on list', () => {
+        const list = new list_1.List();
+        list.add(1);
+        expect(list.toArray('added').length).toBe(1);
+        expect(list.toArray('added')[0]).toEqual(1);
+    });
+    it('should update item on list', () => {
+        const list = new list_1.List(EntityTest).setList([entity]);
+        entity.value = 2;
+        list.add(entity);
+        expect(list.toArray('updated').length).toBe(1);
+        expect(list.toArray('updated')[0].value).toEqual(2);
+    });
+    it('should remove item on list', () => {
+        const list = new list_1.List(EntityTest).setList([entity]);
+        list.remove(entity);
+        expect(list.toArray().length).toBe(0);
+        expect(list.toArray('removed').length).toBe(1);
+        expect(list.toArray('removed')[0].value).toEqual(1);
+    });
+    it('should get item by id', () => {
+        const list = new list_1.List(EntityTest).setList([entity]);
+        expect(list.findById(entity.id)).toEqual(entity);
+    });
+});

package/{services/env → env}/env.d.ts

@@ -4,22 +4,22 @@ export declare const envSchema: z.ZodObject<{
     PORT: z.ZodDefault<z.ZodNumber>;
     NODE_ENV: z.ZodEnum<["test", "develop", "staging", "production"]>;
     PRISMA_QUERY_LOG: z.ZodBoolean;
-    SWAGGER_USERNAME: z.ZodString;
-    SWAGGER_PASSWORD: z.ZodString;
+    SWAGGER_USERNAME: z.ZodOptional<z.ZodString>;
+    SWAGGER_PASSWORD: z.ZodOptional<z.ZodString>;
     REDIS_CONNECTION_STRING: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     NODE_ENV: "test" | "develop" | "staging" | "production";
     PORT: number;
     PRISMA_QUERY_LOG: boolean;
-    SWAGGER_USERNAME: string;
-    SWAGGER_PASSWORD: string;
     REDIS_CONNECTION_STRING: string;
+    SWAGGER_USERNAME?: string | undefined;
+    SWAGGER_PASSWORD?: string | undefined;
 }, {
     NODE_ENV: "test" | "develop" | "staging" | "production";
     PRISMA_QUERY_LOG: boolean;
-    SWAGGER_USERNAME: string;
-    SWAGGER_PASSWORD: string;
     REDIS_CONNECTION_STRING: string;
     PORT?: number | undefined;
+    SWAGGER_USERNAME?: string | undefined;
+    SWAGGER_PASSWORD?: string | undefined;
 }>;
 export type Env = z.infer<typeof envSchema>;

package/{services/env → env}/env.js

@@ -7,7 +7,7 @@ exports.envSchema = zod_1.z.object({
     PORT: zod_1.z.coerce.number().default(3000),
     NODE_ENV: zod_1.z.enum(['test', 'develop', 'staging', 'production']),
     PRISMA_QUERY_LOG: zod_1.z.coerce.boolean(),
-    SWAGGER_USERNAME: zod_1.z.string(),
-    SWAGGER_PASSWORD: zod_1.z.string(),
+    SWAGGER_USERNAME: zod_1.z.string().optional(),
+    SWAGGER_PASSWORD: zod_1.z.string().optional(),
     REDIS_CONNECTION_STRING: zod_1.z.string(),
 });

package/{services/env → env}/env.service.d.ts

@@ -7,8 +7,8 @@ export declare class EnvService {
         NODE_ENV: "test" | "develop" | "staging" | "production";
         PORT: number;
         PRISMA_QUERY_LOG: boolean;
-        SWAGGER_USERNAME: string;
-        SWAGGER_PASSWORD: string;
         REDIS_CONNECTION_STRING: string;
+        SWAGGER_USERNAME?: string | undefined;
+        SWAGGER_PASSWORD?: string | undefined;
     }, T>;
 }

package/{services/env → env}/env.service.js

@@ -5,9 +5,13 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EnvService = void 0;
 const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
 let EnvService = exports.EnvService = class EnvService {
     configService;
     constructor(configService) {
@@ -18,5 +22,6 @@ let EnvService = exports.EnvService = class EnvService {
     }
 };
 exports.EnvService = EnvService = __decorate([
-    (0, common_1.Injectable)()
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [config_1.ConfigService])
 ], EnvService);

package/filters/domain-errors.filter.d.ts

@@ -1,13 +1,13 @@
 /// <reference types="express" />
 import { ArgumentsHost } from '@nestjs/common';
 import { BaseExceptionFilter } from '@nestjs/core';
-import { BadRequestError } from '../common/errors/bad-request.error';
-import { ConflictError } from '../common/errors/conflict.error';
-import { NoContentError } from '../common/errors/no-content.error';
-import { NotAllowedError } from '../common/errors/not-allowed.error';
-import { ResourceNotFoundError } from '../common/errors/resource-not-found.error';
-import { UserAlreadyExist } from '../common/errors/user-already-exist.error';
-import { WrongCredentialsError } from '../common/errors/wrong-credentials.error';
+import { BadRequestError } from '../core/errors/bad-request.error';
+import { ConflictError } from '../core/errors/conflict.error';
+import { NoContentError } from '../core/errors/no-content.error';
+import { NotAllowedError } from '../core/errors/not-allowed.error';
+import { ResourceNotFoundError } from '../core/errors/resource-not-found.error';
+import { UserAlreadyExist } from '../core/errors/user-already-exist.error';
+import { WrongCredentialsError } from '../core/errors/wrong-credentials.error';
 type DomainErrors = NotAllowedError | ResourceNotFoundError | UserAlreadyExist | WrongCredentialsError | ConflictError | BadRequestError | NoContentError;
 export declare class DomainErrorsFilter extends BaseExceptionFilter {
     catch(exception: DomainErrors, host: ArgumentsHost): import("express").Response<any, Record<string, any>>;

package/filters/domain-errors.filter.js

@@ -9,13 +9,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DomainErrorsFilter = void 0;
 const common_1 = require("@nestjs/common");
 const core_1 = require("@nestjs/core");
-const bad_request_error_1 = require("../common/errors/bad-request.error");
-const conflict_error_1 = require("../common/errors/conflict.error");
-const no_content_error_1 = require("../common/errors/no-content.error");
-const not_allowed_error_1 = require("../common/errors/not-allowed.error");
-const resource_not_found_error_1 = require("../common/errors/resource-not-found.error");
-const user_already_exist_error_1 = require("../common/errors/user-already-exist.error");
-const wrong_credentials_error_1 = require("../common/errors/wrong-credentials.error");
+const bad_request_error_1 = require("../core/errors/bad-request.error");
+const conflict_error_1 = require("../core/errors/conflict.error");
+const no_content_error_1 = require("../core/errors/no-content.error");
+const not_allowed_error_1 = require("../core/errors/not-allowed.error");
+const resource_not_found_error_1 = require("../core/errors/resource-not-found.error");
+const user_already_exist_error_1 = require("../core/errors/user-already-exist.error");
+const wrong_credentials_error_1 = require("../core/errors/wrong-credentials.error");
 const filter_request_params_1 = require("../core/utils/filter-request-params");
 let DomainErrorsFilter = exports.DomainErrorsFilter = class DomainErrorsFilter extends core_1.BaseExceptionFilter {
     catch(exception, host) {

package/filters/global-exception.filter.js

@@ -5,6 +5,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GlobalExceptionsFilter = void 0;
 const common_1 = require("@nestjs/common");
@@ -35,5 +38,6 @@ let GlobalExceptionsFilter = exports.GlobalExceptionsFilter = class GlobalExcept
     }
 };
 exports.GlobalExceptionsFilter = GlobalExceptionsFilter = __decorate([
-    (0, common_1.Catch)()
+    (0, common_1.Catch)(),
+    __metadata("design:paramtypes", [core_1.AbstractHttpAdapter])
 ], GlobalExceptionsFilter);