@koalarx/nest 3.0.2 → 3.0.4

package/core/validators/file-validator.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileTypeValidator = exports.FileSizeValidator = void 0;
+const common_1 = require("@nestjs/common");
+const runFileValidation = async (args) => {
+    if (args.multiple) {
+        const fileFields = Object.keys(args.file);
+        for (const field of fileFields) {
+            const fieldFile = args.file[field];
+            if (Array.isArray(fieldFile)) {
+                for (const f of fieldFile) {
+                    if (!args.validator(f)) {
+                        return { errorFileName: f.originalname, isValid: false };
+                    }
+                }
+            }
+            else {
+                if (!args.validator(fieldFile)) {
+                    return { errorFileName: fieldFile.originalname, isValid: false };
+                }
+            }
+        }
+        return { isValid: true };
+    }
+    if (Array.isArray(args.file)) {
+        for (const f of args.file) {
+            if (!args.validator(f)) {
+                return { errorFileName: f.originalname, isValid: false };
+            }
+        }
+        return { isValid: true };
+    }
+    if (args.validator(args.file)) {
+        return { errorFileName: args.file.originalname, isValid: false };
+    }
+    return { isValid: true };
+};
+class FileSizeValidator extends common_1.FileValidator {
+    maxSizeBytes;
+    multiple;
+    errorFileName;
+    constructor(args) {
+        super({});
+        this.maxSizeBytes = args.maxSizeBytes;
+        this.multiple = args.multiple;
+    }
+    async isValid(file) {
+        if (!file) {
+            return true;
+        }
+        const result = await runFileValidation({
+            file,
+            multiple: this.multiple,
+            validator: (f) => f.size < this.maxSizeBytes,
+        });
+        this.errorFileName = result.errorFileName ?? '';
+        return result.isValid;
+    }
+    buildErrorMessage(file) {
+        return (`file ${this.errorFileName || ''} exceeded the size limit ` +
+            parseFloat((this.maxSizeBytes / 1024 / 1024).toFixed(2)) +
+            'MB');
+    }
+}
+exports.FileSizeValidator = FileSizeValidator;
+class FileTypeValidator extends common_1.FileValidator {
+    multiple;
+    errorFileName;
+    filetype;
+    constructor(args) {
+        super({});
+        this.multiple = args.multiple;
+        this.filetype = args.filetype;
+    }
+    isMimeTypeValid(file) {
+        return file.mimetype.search(this.filetype) === 0;
+    }
+    async isValid(file) {
+        if (!file) {
+            return true;
+        }
+        const result = await runFileValidation({
+            multiple: this.multiple,
+            file,
+            validator: (f) => this.isMimeTypeValid(f),
+        });
+        this.errorFileName = result.errorFileName ?? '';
+        return result.isValid;
+    }
+    buildErrorMessage(file) {
+        return `file ${this.errorFileName || ''} must be of type ${this.filetype}`;
+    }
+}
+exports.FileTypeValidator = FileTypeValidator;

package/decorators/api-exclude-endpoint-diff-develop.decorator.d.ts

@@ -0,0 +1 @@
+export declare const ApiExcludeEndpointDiffDevelop: () => MethodDecorator;

package/decorators/api-exclude-endpoint-diff-develop.decorator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiExcludeEndpointDiffDevelop = void 0;
+const swagger_1 = require("@nestjs/swagger");
+const env_config_1 = require("../core/utils/env.config");
+const ApiExcludeEndpointDiffDevelop = () => {
+    return (0, swagger_1.ApiExcludeEndpoint)(!env_config_1.EnvConfig.isEnvDevelop);
+};
+exports.ApiExcludeEndpointDiffDevelop = ApiExcludeEndpointDiffDevelop;

package/decorators/api-property-enum.decorator.d.ts

@@ -0,0 +1,8 @@
+import { EnumAllowedTypes } from '@nestjs/swagger/dist/interfaces/schema-object-metadata.interface';
+interface ApiPropertyEnumOptions {
+    enum: EnumAllowedTypes;
+    isArray?: boolean;
+    required?: boolean;
+}
+export declare function ApiPropertyEnum(options: ApiPropertyEnumOptions): (target: any, propertyKey: string) => void;
+export {};

package/decorators/api-property-enum.decorator.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiPropertyEnum = ApiPropertyEnum;
+const swagger_1 = require("@nestjs/swagger");
+function ApiPropertyEnum(options) {
+    return function (target, propertyKey) {
+        const enumValues = Object.values(options.enum)
+            .filter((value) => typeof value === 'number')
+            .map((value) => ({
+            value,
+            description: options.enum[value],
+        }));
+        const description = enumValues
+            .map((enumValue) => `${enumValue.description}: ${enumValue.value}`)
+            .join('\n');
+        (0, swagger_1.ApiProperty)({
+            ...options,
+            description: ['```', description, '```'].join('\n'),
+        })(target, propertyKey);
+    };
+}

package/decorators/api-property-only-develop.decorator.d.ts

@@ -0,0 +1,2 @@
+import { ApiPropertyOptions } from '@nestjs/swagger';
+export declare const ApiPropertyOnlyDevelop: (propertyOptions: ApiPropertyOptions) => PropertyDecorator;

package/decorators/api-property-only-develop.decorator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiPropertyOnlyDevelop = void 0;
+const swagger_1 = require("@nestjs/swagger");
+const env_config_1 = require("../core/utils/env.config");
+const ApiPropertyOnlyDevelop = (propertyOptions) => {
+    return env_config_1.EnvConfig.isEnvDevelop ? (0, swagger_1.ApiProperty)(propertyOptions) : () => { };
+};
+exports.ApiPropertyOnlyDevelop = ApiPropertyOnlyDevelop;

package/decorators/cookies.decorator.d.ts

@@ -0,0 +1 @@
+export declare const Cookies: (...dataOrPipes: (string | import("@nestjs/common").PipeTransform<any, any> | import("@nestjs/common").Type<import("@nestjs/common").PipeTransform<any, any>>)[]) => ParameterDecorator;

package/decorators/cookies.decorator.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cookies = void 0;
+const common_1 = require("@nestjs/common");
+exports.Cookies = (0, common_1.createParamDecorator)((data, ctx) => {
+    const request = ctx.switchToHttp().getRequest();
+    return data ? request.cookies?.[data] : request.cookies;
+});

package/decorators/is-public.decorator.d.ts

@@ -0,0 +1,2 @@
+export declare const IS_PUBLIC_KEY = "isPublic";
+export declare const IsPublic: () => import("@nestjs/common").CustomDecorator<string>;

package/decorators/is-public.decorator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsPublic = exports.IS_PUBLIC_KEY = void 0;
+const common_1 = require("@nestjs/common");
+exports.IS_PUBLIC_KEY = 'isPublic';
+const IsPublic = () => (0, common_1.SetMetadata)(exports.IS_PUBLIC_KEY, true);
+exports.IsPublic = IsPublic;

package/decorators/upload.decorator.d.ts

@@ -0,0 +1 @@
+export declare function UploadDecorator(maxSizeInKb: number, filetype: RegExp): ParameterDecorator;

package/decorators/upload.decorator.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadDecorator = UploadDecorator;
+const common_1 = require("@nestjs/common");
+const file_validator_1 = require("../core/validators/file-validator");
+function UploadDecorator(maxSizeInKb, filetype) {
+    const maxSizeBytes = maxSizeInKb * 1024;
+    return (0, common_1.UploadedFiles)(new common_1.ParseFilePipe({
+        validators: [
+            new file_validator_1.FileSizeValidator({ maxSizeBytes, multiple: true }),
+            new file_validator_1.FileTypeValidator({
+                filetype,
+                multiple: true,
+            }),
+        ],
+        fileIsRequired: false,
+    }));
+}

package/env/env.d.ts

@@ -0,0 +1,25 @@
+import 'dotenv/config';
+import { z } from 'zod';
+export declare const envSchema: z.ZodObject<{
+    PORT: z.ZodDefault<z.ZodNumber>;
+    NODE_ENV: z.ZodEnum<["test", "develop", "staging", "production"]>;
+    PRISMA_QUERY_LOG: z.ZodOptional<z.ZodEffects<z.ZodString, boolean | undefined, string>>;
+    SWAGGER_USERNAME: z.ZodOptional<z.ZodString>;
+    SWAGGER_PASSWORD: z.ZodOptional<z.ZodString>;
+    REDIS_CONNECTION_STRING: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    PORT: number;
+    NODE_ENV: "test" | "develop" | "staging" | "production";
+    PRISMA_QUERY_LOG?: boolean | undefined;
+    SWAGGER_USERNAME?: string | undefined;
+    SWAGGER_PASSWORD?: string | undefined;
+    REDIS_CONNECTION_STRING?: string | undefined;
+}, {
+    NODE_ENV: "test" | "develop" | "staging" | "production";
+    PORT?: number | undefined;
+    PRISMA_QUERY_LOG?: string | undefined;
+    SWAGGER_USERNAME?: string | undefined;
+    SWAGGER_PASSWORD?: string | undefined;
+    REDIS_CONNECTION_STRING?: string | undefined;
+}>;
+export type Env = z.infer<typeof envSchema>;

package/env/env.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.envSchema = void 0;
+require("dotenv/config");
+const zod_1 = require("zod");
+const boolean_schema_1 = require("../core/controllers/schemas/boolean.schema");
+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: (0, boolean_schema_1.booleanSchema)().optional(),
+    SWAGGER_USERNAME: zod_1.z.string().optional(),
+    SWAGGER_PASSWORD: zod_1.z.string().optional(),
+    REDIS_CONNECTION_STRING: zod_1.z.string().optional(),
+});

package/env/env.module.d.ts

@@ -0,0 +1,2 @@
+export declare class EnvModule {
+}

package/env/env.module.js

@@ -0,0 +1,20 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvModule = void 0;
+const common_1 = require("@nestjs/common");
+const env_service_1 = require("./env.service");
+let EnvModule = class EnvModule {
+};
+exports.EnvModule = EnvModule;
+exports.EnvModule = EnvModule = __decorate([
+    (0, common_1.Module)({
+        providers: [env_service_1.EnvService],
+        exports: [env_service_1.EnvService],
+    })
+], EnvModule);

package/env/env.service.d.ts

@@ -0,0 +1,7 @@
+import { ConfigService } from '@nestjs/config';
+import { Env } from './env';
+export declare class EnvService<TEnv extends Env = Env> {
+    private readonly configService;
+    constructor(configService: ConfigService<TEnv, true>);
+    get<T extends keyof TEnv>(key: T): (string extends infer T_1 ? T_1 extends string ? T_1 extends keyof TEnv ? string extends infer T_2 ? T_2 extends string ? T_2 extends import("@nestjs/config").Path<TEnv[T_1]> ? import("@nestjs/config").PathValue<TEnv[T_1], T_2> : never : never : never : never : never : never) | (any extends infer T_3 ? T_3 extends any ? T_3 extends keyof TEnv ? TEnv[T_3] : never : never : never);
+}

package/env/env.service.js

@@ -0,0 +1,28 @@
+"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.EnvService = void 0;
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+let EnvService = class EnvService {
+    configService;
+    constructor(configService) {
+        this.configService = configService;
+    }
+    get(key) {
+        return this.configService.get(key, { infer: true });
+    }
+};
+exports.EnvService = EnvService;
+exports.EnvService = EnvService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [config_1.ConfigService])
+], EnvService);

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

@@ -0,0 +1,18 @@
+import { ArgumentsHost } from '@nestjs/common';
+import { BaseExceptionFilter } from '@nestjs/core';
+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';
+import { ILoggingService } from '../services/logging/ilogging.service';
+type DomainErrors = NotAllowedError | ResourceNotFoundError | UserAlreadyExist | WrongCredentialsError | ConflictError | BadRequestError | NoContentError;
+export declare class DomainErrorsFilter extends BaseExceptionFilter {
+    private readonly loggingService;
+    constructor(loggingService: ILoggingService);
+    catch(exception: DomainErrors, host: ArgumentsHost): import("express").Response<any, Record<string, any>>;
+    private map;
+}
+export {};

package/filters/domain-errors.filter.js

@@ -0,0 +1,92 @@
+"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.DomainErrorsFilter = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+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 koala_global_vars_1 = require("../core/koala-global-vars");
+const env_config_1 = require("../core/utils/env.config");
+const filter_request_params_1 = require("../core/utils/filter-request-params");
+const ilogging_service_1 = require("../services/logging/ilogging.service");
+let DomainErrorsFilter = class DomainErrorsFilter extends core_1.BaseExceptionFilter {
+    loggingService;
+    constructor(loggingService) {
+        super();
+        this.loggingService = loggingService;
+    }
+    catch(exception, host) {
+        const mappedException = this.map(exception);
+        const filterRequestParams = filter_request_params_1.FilterRequestParams.get(host);
+        if (mappedException.statusCode !== common_1.HttpStatus.UNAUTHORIZED) {
+            if (!env_config_1.EnvConfig.isEnvTest) {
+                this.loggingService
+                    .report({
+                    error: exception,
+                    packageName: koala_global_vars_1.KoalaGlobalVars.appName,
+                    loggedUsername: filterRequestParams.loggedUserName,
+                    httpRequest: {
+                        ...filterRequestParams.filterParams,
+                        statusCode: mappedException.statusCode,
+                        response: mappedException,
+                    },
+                })
+                    .catch((err) => console.error(err));
+            }
+            else {
+                console.error(exception);
+            }
+        }
+        return filterRequestParams.response
+            .status(mappedException.statusCode)
+            .json(mappedException);
+    }
+    map(exception) {
+        const mappedException = {
+            statusCode: common_1.HttpStatus.INTERNAL_SERVER_ERROR,
+            message: exception.message,
+            data: exception.data,
+        };
+        switch (exception.constructor) {
+            case user_already_exist_error_1.UserAlreadyExist:
+            case not_allowed_error_1.NotAllowedError:
+            case bad_request_error_1.BadRequestError:
+                mappedException.statusCode = common_1.HttpStatus.BAD_REQUEST;
+                break;
+            case resource_not_found_error_1.ResourceNotFoundError:
+                mappedException.statusCode = common_1.HttpStatus.NOT_FOUND;
+                break;
+            case wrong_credentials_error_1.WrongCredentialsError:
+                mappedException.statusCode = common_1.HttpStatus.UNAUTHORIZED;
+                break;
+            case conflict_error_1.ConflictError:
+                mappedException.statusCode = common_1.HttpStatus.CONFLICT;
+                break;
+            case no_content_error_1.NoContentError:
+                mappedException.statusCode = common_1.HttpStatus.NO_CONTENT;
+                break;
+            default:
+                console.error(exception);
+        }
+        return mappedException;
+    }
+};
+exports.DomainErrorsFilter = DomainErrorsFilter;
+exports.DomainErrorsFilter = DomainErrorsFilter = __decorate([
+    (0, common_1.Catch)(not_allowed_error_1.NotAllowedError, resource_not_found_error_1.ResourceNotFoundError, user_already_exist_error_1.UserAlreadyExist, wrong_credentials_error_1.WrongCredentialsError, conflict_error_1.ConflictError, bad_request_error_1.BadRequestError, no_content_error_1.NoContentError),
+    __metadata("design:paramtypes", [ilogging_service_1.ILoggingService])
+], DomainErrorsFilter);

package/filters/global-exception.filter.d.ts

@@ -0,0 +1,8 @@
+import { ArgumentsHost } from '@nestjs/common';
+import { BaseExceptionFilter } from '@nestjs/core';
+import { ILoggingService } from '../services/logging/ilogging.service';
+export declare class GlobalExceptionsFilter extends BaseExceptionFilter {
+    private readonly loggingService;
+    constructor(loggingService: ILoggingService);
+    catch(exception: Error, host: ArgumentsHost): import("express").Response<any, Record<string, any>>;
+}

package/filters/global-exception.filter.js

@@ -0,0 +1,68 @@
+"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.GlobalExceptionsFilter = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const node_http_1 = require("node:http");
+const koala_global_vars_1 = require("../core/koala-global-vars");
+const env_config_1 = require("../core/utils/env.config");
+const filter_request_params_1 = require("../core/utils/filter-request-params");
+const ilogging_service_1 = require("../services/logging/ilogging.service");
+let GlobalExceptionsFilter = class GlobalExceptionsFilter extends core_1.BaseExceptionFilter {
+    loggingService;
+    constructor(loggingService) {
+        super();
+        this.loggingService = loggingService;
+    }
+    catch(exception, host) {
+        const filterRequestParams = filter_request_params_1.FilterRequestParams.get(host);
+        const request = host.getArgs().find((arg) => arg instanceof node_http_1.IncomingMessage) ?? null;
+        const statusCode = exception instanceof common_1.HttpException
+            ? exception.getStatus()
+            : common_1.HttpStatus.INTERNAL_SERVER_ERROR;
+        const responseBody = exception instanceof common_1.HttpException
+            ? exception.getResponse()
+            : {
+                statusCode,
+                timestamp: new Date().toISOString(),
+                path: filterRequestParams.filterParams.endpoint,
+            };
+        if (!exception.message?.includes('Cannot GET /socket.io') &&
+            !exception.message?.includes('Cannot GET /favicon.ico') &&
+            !['/'].includes(request?.url ?? '') &&
+            statusCode !== common_1.HttpStatus.UNAUTHORIZED) {
+            if (!env_config_1.EnvConfig.isEnvTest) {
+                this.loggingService
+                    .report({
+                    error: exception,
+                    packageName: koala_global_vars_1.KoalaGlobalVars.appName,
+                    loggedUsername: filterRequestParams.loggedUserName,
+                    httpRequest: {
+                        ...filterRequestParams.filterParams,
+                        statusCode,
+                        response: responseBody,
+                    },
+                })
+                    .catch((err) => console.error(err));
+            }
+            else {
+                console.error(exception);
+            }
+        }
+        return filterRequestParams.response.status(statusCode).json(responseBody);
+    }
+};
+exports.GlobalExceptionsFilter = GlobalExceptionsFilter;
+exports.GlobalExceptionsFilter = GlobalExceptionsFilter = __decorate([
+    (0, common_1.Catch)(),
+    __metadata("design:paramtypes", [ilogging_service_1.ILoggingService])
+], GlobalExceptionsFilter);

package/filters/prisma-validation-exception.filter.d.ts

@@ -0,0 +1,10 @@
+import { ArgumentsHost } from '@nestjs/common';
+import { BaseExceptionFilter } from '@nestjs/core';
+import { Prisma } from 'prisma/generated/client';
+import { ILoggingService } from '../services/logging/ilogging.service';
+export declare class PrismaValidationExceptionFilter extends BaseExceptionFilter {
+    private readonly loggingService;
+    constructor(loggingService: ILoggingService);
+    catch(exception: Prisma.PrismaClientKnownRequestError, host: ArgumentsHost): import("express").Response<any, Record<string, any>>;
+    private translate;
+}

package/filters/prisma-validation-exception.filter.js

@@ -0,0 +1,82 @@
+"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.PrismaValidationExceptionFilter = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const client_1 = require("../../../../prisma/generated/client");
+const koala_global_vars_1 = require("../core/koala-global-vars");
+const env_config_1 = require("../core/utils/env.config");
+const filter_request_params_1 = require("../core/utils/filter-request-params");
+const ilogging_service_1 = require("../services/logging/ilogging.service");
+let PrismaValidationExceptionFilter = class PrismaValidationExceptionFilter extends core_1.BaseExceptionFilter {
+    loggingService;
+    constructor(loggingService) {
+        super();
+        this.loggingService = loggingService;
+    }
+    catch(exception, host) {
+        const translatedResponse = this.translate(exception);
+        const filterRequestParams = filter_request_params_1.FilterRequestParams.get(host);
+        if (translatedResponse.statusCode !== common_1.HttpStatus.UNAUTHORIZED) {
+            if (!env_config_1.EnvConfig.isEnvTest) {
+                this.loggingService
+                    .report({
+                    error: exception,
+                    packageName: koala_global_vars_1.KoalaGlobalVars.appName,
+                    loggedUsername: filterRequestParams.loggedUserName,
+                    httpRequest: {
+                        ...filterRequestParams.filterParams,
+                        statusCode: translatedResponse.statusCode,
+                        response: translatedResponse,
+                    },
+                })
+                    .catch((err) => console.error(err));
+            }
+            else {
+                console.error(exception);
+            }
+        }
+        return filterRequestParams.response
+            .status(translatedResponse.statusCode)
+            .json(translatedResponse);
+    }
+    translate(exception) {
+        switch (exception.code) {
+            case 'P2002':
+                return {
+                    statusCode: common_1.HttpStatus.CONFLICT,
+                    message: 'Registro já existente.',
+                };
+            case 'P2003':
+                return {
+                    statusCode: common_1.HttpStatus.BAD_REQUEST,
+                    message: 'Falha devido a relacionamento. Verifique se o relacionamento existe ou é valido.',
+                };
+            case 'P2025':
+                return {
+                    statusCode: common_1.HttpStatus.NOT_FOUND,
+                    message: 'Registro não encontrado.',
+                };
+            default:
+                console.error(exception);
+                return {
+                    statusCode: common_1.HttpStatus.BAD_REQUEST,
+                    message: 'Ocorreu um erro desconhecido relacionado aos dados enviados.',
+                };
+        }
+    }
+};
+exports.PrismaValidationExceptionFilter = PrismaValidationExceptionFilter;
+exports.PrismaValidationExceptionFilter = PrismaValidationExceptionFilter = __decorate([
+    (0, common_1.Catch)(client_1.Prisma.PrismaClientKnownRequestError),
+    __metadata("design:paramtypes", [ilogging_service_1.ILoggingService])
+], PrismaValidationExceptionFilter);

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

@@ -0,0 +1,9 @@
+import { ArgumentsHost } from '@nestjs/common';
+import { BaseExceptionFilter } from '@nestjs/core';
+import { ZodError } from 'zod';
+import { ILoggingService } from '../services/logging/ilogging.service';
+export declare class ZodErrorsFilter extends BaseExceptionFilter {
+    private readonly loggingService;
+    constructor(loggingService: ILoggingService);
+    catch(exception: ZodError, host: ArgumentsHost): import("express").Response<any, Record<string, any>>;
+}