@takentrade/takentrade-libs 0.0.57

package/dist/logger/real/pinoLogger.service.js

@@ -0,0 +1,76 @@
+"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.PinoLoggerService = void 0;
+const common_1 = require("@nestjs/common");
+let PinoLoggerService = class PinoLoggerService extends common_1.ConsoleLogger {
+    logger;
+    contextName;
+    constructor(logger) {
+        super();
+        this.logger = logger;
+        this.contextName = 'context';
+    }
+    setContext(name) {
+        this.logger.setContext(name);
+    }
+    verbose(message, context, ...args) {
+        if (context) {
+            this.logger.trace({ [this.contextName]: context }, this.formatMessage(message), ...args);
+        }
+        else {
+            this.logger.trace(this.formatMessage(message), ...args);
+        }
+    }
+    debug(message, context, ...args) {
+        if (context) {
+            this.logger.debug({ [this.contextName]: context }, this.formatMessage(message), ...args);
+        }
+        else {
+            this.logger.debug(this.formatMessage(message), ...args);
+        }
+    }
+    log(message, context, ...args) {
+        if (context) {
+            this.logger.info({ [this.contextName]: context }, this.formatMessage(message), ...args);
+        }
+        else {
+            this.logger.info(this.formatMessage(message), ...args);
+        }
+    }
+    warn(message, context, ...args) {
+        if (context) {
+            this.logger.warn({ [this.contextName]: context }, this.formatMessage(message), ...args);
+        }
+        else {
+            this.logger.warn(this.formatMessage(message), ...args);
+        }
+    }
+    error(message, trace, context, ...args) {
+        if (context) {
+            this.logger.error({ [this.contextName]: context, trace }, this.formatMessage(message), ...args);
+        }
+        else if (trace) {
+            this.logger.error({ trace }, this.formatMessage(message), ...args);
+        }
+        else {
+            this.logger.error(this.formatMessage(message), ...args);
+        }
+    }
+    formatMessage(message) {
+        if (typeof message === 'string')
+            return message;
+        if (message instanceof Error)
+            return message.message;
+        return JSON.stringify(message);
+    }
+};
+exports.PinoLoggerService = PinoLoggerService;
+exports.PinoLoggerService = PinoLoggerService = __decorate([
+    (0, common_1.Injectable)()
+], PinoLoggerService);

package/dist/nats/constants/nats.constants.d.ts

@@ -0,0 +1,9 @@
+export declare const NATS_OPTIONS = "NATS_OPTIONS";
+export declare const NATS_CLIENT = "NATS_CLIENT";
+export declare const DEFAULT_NATS_CONFIG: {
+    url: string;
+    timeout: number;
+    reconnect: boolean;
+    reconnectTimeWait: number;
+    maxReconnectAttempts: number;
+};

package/dist/nats/constants/nats.constants.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_NATS_CONFIG = exports.NATS_CLIENT = exports.NATS_OPTIONS = void 0;
+exports.NATS_OPTIONS = 'NATS_OPTIONS';
+exports.NATS_CLIENT = 'NATS_CLIENT';
+exports.DEFAULT_NATS_CONFIG = {
+    url: 'nats://localhost:4222',
+    timeout: 5000,
+    reconnect: true,
+    reconnectTimeWait: 2000,
+    maxReconnectAttempts: 10,
+};

package/dist/nats/decorators/nats-event-pattern.decorator.d.ts

@@ -0,0 +1,2 @@
+export declare const NATS_EVENT_METADATA = "nats_event_metadata";
+export declare function NatsEventPattern(pattern: string): <TFunction extends Function, Y>(target: TFunction | object, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

package/dist/nats/decorators/nats-event-pattern.decorator.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NATS_EVENT_METADATA = void 0;
+exports.NatsEventPattern = NatsEventPattern;
+const common_1 = require("@nestjs/common");
+const microservices_1 = require("@nestjs/microservices");
+const nats_logging_interceptor_1 = require("../interceptors/nats-logging.interceptor");
+exports.NATS_EVENT_METADATA = 'nats_event_metadata';
+function NatsEventPattern(pattern) {
+    return (0, common_1.applyDecorators)((0, common_1.SetMetadata)(exports.NATS_EVENT_METADATA, { pattern }), (0, microservices_1.EventPattern)(pattern), (0, common_1.UseInterceptors)(nats_logging_interceptor_1.NatsLoggingInterceptor));
+}

package/dist/nats/dto/nats-message.dto.d.ts

@@ -0,0 +1,5 @@
+export declare class NatsMessageDto {
+    pattern: string;
+    data: any;
+    replyTo?: string;
+}

package/dist/nats/dto/nats-message.dto.js

@@ -0,0 +1,27 @@
+"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.NatsMessageDto = void 0;
+const class_validator_1 = require("class-validator");
+class NatsMessageDto {
+    pattern;
+    data;
+    replyTo;
+}
+exports.NatsMessageDto = NatsMessageDto;
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)()
+], NatsMessageDto.prototype, "pattern", void 0);
+__decorate([
+    (0, class_validator_1.IsNotEmpty)()
+], NatsMessageDto.prototype, "data", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)()
+], NatsMessageDto.prototype, "replyTo", void 0);

package/dist/nats/index.d.ts

@@ -0,0 +1,5 @@
+export * from './constants/nats.constants';
+export * from './interfaces/nats-options.interface';
+export * from './dto/nats-message.dto';
+export * from './decorators/nats-event-pattern.decorator';
+export * from './interceptors/nats-logging.interceptor';

package/dist/nats/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./constants/nats.constants"), exports);
+__exportStar(require("./interfaces/nats-options.interface"), exports);
+__exportStar(require("./dto/nats-message.dto"), exports);
+__exportStar(require("./decorators/nats-event-pattern.decorator"), exports);
+__exportStar(require("./interceptors/nats-logging.interceptor"), exports);

package/dist/nats/interceptors/nats-logging.interceptor.d.ts

@@ -0,0 +1,6 @@
+import { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
+import { Observable } from 'rxjs';
+export declare class NatsLoggingInterceptor implements NestInterceptor {
+    private readonly logger;
+    intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
+}

package/dist/nats/interceptors/nats-logging.interceptor.js

@@ -0,0 +1,33 @@
+"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 NatsLoggingInterceptor_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NatsLoggingInterceptor = void 0;
+const common_1 = require("@nestjs/common");
+const rxjs_1 = require("rxjs");
+let NatsLoggingInterceptor = NatsLoggingInterceptor_1 = class NatsLoggingInterceptor {
+    logger = new common_1.Logger(NatsLoggingInterceptor_1.name);
+    intercept(context, next) {
+        const now = Date.now();
+        const rpcContext = context.switchToRpc();
+        const natsContext = rpcContext.getContext();
+        const pattern = natsContext.getSubject();
+        return next.handle().pipe((0, rxjs_1.tap)({
+            next: (data) => {
+                this.logger.log(`Pattern: ${pattern} | Response time: ${Date.now() - now}ms | Response: ${JSON.stringify(data)}`);
+            },
+            error: (error) => {
+                this.logger.error(`Pattern: ${pattern} | Error: ${error.message}`, error.stack);
+            },
+        }));
+    }
+};
+exports.NatsLoggingInterceptor = NatsLoggingInterceptor;
+exports.NatsLoggingInterceptor = NatsLoggingInterceptor = NatsLoggingInterceptor_1 = __decorate([
+    (0, common_1.Injectable)()
+], NatsLoggingInterceptor);

package/dist/nats/interfaces/nats-options.interface.d.ts

@@ -0,0 +1,23 @@
+import { ModuleMetadata, Type } from '@nestjs/common';
+import { Transport } from '@nestjs/microservices';
+export interface NatsOptions {
+    transport: Transport.NATS;
+    options: {
+        servers: string[];
+        queue?: string;
+        name?: string;
+        timeout?: number;
+        reconnect?: boolean;
+        reconnectTimeWait?: number;
+        maxReconnectAttempts?: number;
+    };
+}
+export interface NatsOptionsFactory {
+    createNatsOptions(): Promise<NatsOptions> | NatsOptions;
+}
+export interface NatsAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    useExisting?: Type<NatsOptionsFactory>;
+    useClass?: Type<NatsOptionsFactory>;
+    useFactory?: (...args: any[]) => Promise<NatsOptions> | NatsOptions;
+    inject?: any[];
+}

package/dist/nats/interfaces/nats-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/prisma/index.d.ts

@@ -0,0 +1,2 @@
+export * from './prisma.module';
+export * from './prisma.service';

package/dist/prisma/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./prisma.module"), exports);
+__exportStar(require("./prisma.service"), exports);

package/dist/prisma/prisma.module.d.ts

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

package/dist/prisma/prisma.module.js

@@ -0,0 +1,21 @@
+"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.PrismaModule = void 0;
+const common_1 = require("@nestjs/common");
+const prisma_service_1 = require("./prisma.service");
+let PrismaModule = class PrismaModule {
+};
+exports.PrismaModule = PrismaModule;
+exports.PrismaModule = PrismaModule = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({
+        providers: [prisma_service_1.PrismaService],
+        exports: [prisma_service_1.PrismaService],
+    })
+], PrismaModule);

package/dist/prisma/prisma.service.d.ts

@@ -0,0 +1,6 @@
+import { INestApplication, OnModuleInit } from '@nestjs/common';
+import { PrismaClient } from '@prisma/client';
+export declare class PrismaService extends PrismaClient implements OnModuleInit {
+    onModuleInit(): Promise<void>;
+    enableShutdownHooks(app: INestApplication): void;
+}

package/dist/prisma/prisma.service.js

@@ -0,0 +1,25 @@
+"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.PrismaService = void 0;
+const common_1 = require("@nestjs/common");
+const client_1 = require("@prisma/client");
+let PrismaService = class PrismaService extends client_1.PrismaClient {
+    async onModuleInit() {
+        await this.$connect();
+    }
+    enableShutdownHooks(app) {
+        process.on('beforeExit', () => {
+            app.close().catch(console.error);
+        });
+    }
+};
+exports.PrismaService = PrismaService;
+exports.PrismaService = PrismaService = __decorate([
+    (0, common_1.Injectable)()
+], PrismaService);

package/dist/rpc/index.d.ts

@@ -0,0 +1,50 @@
+import { NatsContext, RpcException } from '@nestjs/microservices';
+import { Observable } from 'rxjs';
+export interface TakeNTradeRPCError {
+    success: boolean;
+    subject: string | null;
+    message: string;
+    statusCode: number;
+    errors: string[];
+    timestamp: string;
+}
+export declare class TakeNTradeRpc {
+    /**
+     * Wraps a promise returned by an RPC request handler.
+     * @param promise - A Promise resolving to the response value.
+     * @param ctx - Optional NatsContext object.
+     */
+    static handleRequest<V>(promise: Promise<V>, ctx?: NatsContext): Promise<V | RpcException>;
+    /**
+     * Handles errors from an RPC request handler and returns a TakeNTradeRPCError wrapped in RpcException.
+     * @param err - Error to be handled.
+     * @param ctx - A NATS Context.
+     */
+    static handleRequestError(err: unknown, ctx: NatsContext): RpcException;
+    private static catch;
+    /**
+     * Handles NATS request response.
+     * @param obs - An instance of an Observable.
+     */
+    static withReply<V>(obs: Observable<V>): Promise<V>;
+}
+export declare class TakeNTradeRpcV2 {
+    /**
+     * Wraps a promise returned by an RPC request handler.
+     * @param promise - A Promise resolving to the response value.
+     * @param ctx - Optional NatsContext object.
+     */
+    static handleRequest<V>(promise: Promise<V>, ctx?: NatsContext): Promise<V | TakeNTradeRPCError>;
+    /**
+     * Handles errors from an RPC request handler and returns a TakeNTradeRPCError.
+     * @param err - Error to be handled.
+     * @param ctx - A NATS Context.
+     */
+    static handleRequestError(err: unknown, ctx: NatsContext): TakeNTradeRPCError;
+    private static catch;
+    /**
+     * Handles NATS request response.
+     * @param obs - An instance of an Observable.
+     */
+    static withReply<V>(obs: Observable<V>): Promise<V>;
+}

package/dist/rpc/index.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TakeNTradeRpcV2 = exports.TakeNTradeRpc = void 0;
+const common_1 = require("@nestjs/common");
+const microservices_1 = require("@nestjs/microservices");
+// Shared utility functions
+class TakeNTradeRpcUtils {
+    static getValidationErrors(err) {
+        if (err instanceof common_1.BadRequestException) {
+            const response = err.getResponse();
+            if (typeof response === 'object' &&
+                response !== null &&
+                'errors' in response) {
+                return Array.isArray(response.errors)
+                    ? response.errors
+                    : [];
+            }
+        }
+        return [];
+    }
+    static isErrorResponse(result) {
+        return typeof result === 'object' && result !== null && 'error' in result;
+    }
+}
+class TakeNTradeRpc {
+    /**
+     * Wraps a promise returned by an RPC request handler.
+     * @param promise - A Promise resolving to the response value.
+     * @param ctx - Optional NatsContext object.
+     */
+    static async handleRequest(promise, ctx) {
+        return promise
+            .then((value) => value)
+            .catch((err) => this.catch(err, ctx));
+    }
+    /**
+     * Handles errors from an RPC request handler and returns a TakeNTradeRPCError wrapped in RpcException.
+     * @param err - Error to be handled.
+     * @param ctx - A NATS Context.
+     */
+    static handleRequestError(err, ctx) {
+        return this.catch(err, ctx);
+    }
+    static catch(err, ctx) {
+        const subject = ctx ? ctx.getArgs()[0] : null;
+        const error = err instanceof Error ? err : new Error(String(err));
+        const statusCode = err instanceof common_1.HttpException ? err.getStatus() : 500;
+        const errorDetails = {
+            success: false,
+            subject,
+            message: error.message,
+            statusCode,
+            errors: TakeNTradeRpcUtils.getValidationErrors(err),
+            timestamp: new Date().toLocaleString(),
+        };
+        return new microservices_1.RpcException(errorDetails);
+    }
+    /**
+     * Handles NATS request response.
+     * @param obs - An instance of an Observable.
+     */
+    static async withReply(obs) {
+        const result = await new Promise((resolve, reject) => {
+            obs.subscribe({
+                next: (value) => resolve(value),
+                error: (err) => reject(err instanceof Error ? err : new Error(String(err))),
+            });
+        });
+        if (TakeNTradeRpcUtils.isErrorResponse(result)) {
+            common_1.Logger.error(result.error);
+            throw new common_1.HttpException(result.error, result.error.statusCode, {
+                cause: result.error.errors,
+            });
+        }
+        return result;
+    }
+}
+exports.TakeNTradeRpc = TakeNTradeRpc;
+class TakeNTradeRpcV2 {
+    /**
+     * Wraps a promise returned by an RPC request handler.
+     * @param promise - A Promise resolving to the response value.
+     * @param ctx - Optional NatsContext object.
+     */
+    static async handleRequest(promise, ctx) {
+        return promise
+            .then((value) => value)
+            .catch((err) => this.catch(err, ctx));
+    }
+    /**
+     * Handles errors from an RPC request handler and returns a TakeNTradeRPCError.
+     * @param err - Error to be handled.
+     * @param ctx - A NATS Context.
+     */
+    static handleRequestError(err, ctx) {
+        return this.catch(err, ctx);
+    }
+    static catch(err, ctx) {
+        const subject = ctx ? ctx.getArgs()[0] : null;
+        const error = err instanceof Error ? err : new Error(String(err));
+        const statusCode = err instanceof common_1.HttpException ? err.getStatus() : 500;
+        return {
+            success: false,
+            subject,
+            message: error.message,
+            statusCode,
+            errors: TakeNTradeRpcUtils.getValidationErrors(err),
+            timestamp: new Date().toLocaleString(),
+        };
+    }
+    /**
+     * Handles NATS request response.
+     * @param obs - An instance of an Observable.
+     */
+    static async withReply(obs) {
+        const result = await new Promise((resolve, reject) => {
+            obs.subscribe({
+                next: (value) => resolve(value),
+                error: (err) => reject(err instanceof Error ? err : new Error(String(err))),
+            });
+        });
+        if (TakeNTradeRpcUtils.isErrorResponse(result)) {
+            common_1.Logger.error(result.error);
+            throw new common_1.HttpException(result.error, result.error.statusCode, {
+                cause: result.error.errors,
+            });
+        }
+        return result;
+    }
+}
+exports.TakeNTradeRpcV2 = TakeNTradeRpcV2;

package/dist/utils/dto/index.d.ts

@@ -0,0 +1,4 @@
+export declare class PaginationDto {
+    page: number;
+    limit: number;
+}

package/dist/utils/dto/index.js

@@ -0,0 +1,31 @@
+"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.PaginationDto = void 0;
+const swagger_1 = require("@nestjs/swagger");
+const class_validator_1 = require("class-validator");
+const class_transformer_1 = require("class-transformer");
+class PaginationDto {
+    page = 1;
+    limit = 10;
+}
+exports.PaginationDto = PaginationDto;
+__decorate([
+    (0, swagger_1.ApiProperty)({ minimum: 1, default: 1 }),
+    (0, class_validator_1.IsInt)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_transformer_1.Transform)(({ value }) => (value ? parseInt(value) : 10))
+], PaginationDto.prototype, "page", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ minimum: 1, maximum: 100, default: 10 }),
+    (0, class_validator_1.IsInt)(),
+    (0, class_validator_1.Min)(1),
+    (0, class_validator_1.Max)(100),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_transformer_1.Transform)(({ value }) => (value ? parseInt(value) : 10))
+], PaginationDto.prototype, "limit", void 0);

package/dist/utils/filters/http-exception.filter.d.ts

@@ -0,0 +1,6 @@
+import { ExceptionFilter, ArgumentsHost } from '@nestjs/common';
+export declare class HttpExceptionFilter implements ExceptionFilter {
+    catch(exception: unknown, host: ArgumentsHost): void;
+    getValidationErrors(exception: unknown): any;
+    logError(errResponse: any, request: any, exception: unknown): string;
+}

package/dist/utils/filters/http-exception.filter.js

@@ -0,0 +1,56 @@
+"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.HttpExceptionFilter = void 0;
+const common_1 = require("@nestjs/common");
+let HttpExceptionFilter = class HttpExceptionFilter {
+    catch(exception, host) {
+        const ctx = host.switchToHttp();
+        const response = ctx.getResponse();
+        const request = ctx.getRequest();
+        const status = exception instanceof common_1.HttpException
+            ? exception.getStatus()
+            : common_1.HttpStatus.INTERNAL_SERVER_ERROR;
+        const message = exception instanceof common_1.HttpException
+            ? exception.message
+            : 'Sorry, something went wrong. Please try again later';
+        const responseObj = {
+            success: false,
+            message,
+            statusCode: status,
+            errors: this.getValidationErrors(exception) || [],
+            timestamp: new Date().toLocaleString(),
+            path: request.url,
+            method: request.method,
+        };
+        common_1.Logger.error(exception);
+        common_1.Logger.verbose(this.logError(responseObj, request, exception));
+        response.status(status).send(responseObj);
+    }
+    getValidationErrors(exception) {
+        if (exception instanceof common_1.BadRequestException) {
+            const message = exception?.getResponse();
+            if (typeof message === 'object') {
+                return message.errors;
+            }
+        }
+        return [];
+    }
+    logError(errResponse, request, exception) {
+        const { statusCode, error } = errResponse;
+        const { method, url } = request;
+        const errorLog = `Response Code: ${statusCode} - Method: ${method} URL - ${url} \n
+    ${JSON.stringify(exception)} \n
+    ${exception instanceof common_1.HttpException ? exception.stack : error} `;
+        return errorLog;
+    }
+};
+exports.HttpExceptionFilter = HttpExceptionFilter;
+exports.HttpExceptionFilter = HttpExceptionFilter = __decorate([
+    (0, common_1.Catch)()
+], HttpExceptionFilter);

package/dist/utils/filters/index.d.ts

@@ -0,0 +1 @@
+export * from './http-exception.filter';

package/dist/utils/filters/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./http-exception.filter"), exports);