@takentrade/takentrade-libs 3.3.2 → 3.3.4

package/dist/logging/logger.service.d.ts

@@ -0,0 +1,48 @@
+import { LoggerService as NestLoggerService } from '@nestjs/common';
+export interface LogContext {
+    correlationId?: string;
+    userId?: string;
+    service?: string;
+    [key: string]: any;
+}
+/**
+ * TNT Logger Service - Pino-based structured JSON logger
+ * Provides consistent logging across all microservices
+ */
+export declare class TntLoggerService implements NestLoggerService {
+    private logger;
+    private context;
+    constructor(context?: LogContext);
+    /**
+     * Set context for all subsequent log messages
+     */
+    setContext(context: LogContext): void;
+    /**
+     * Log info message
+     */
+    log(message: string, context?: LogContext): void;
+    /**
+     * Log error message
+     */
+    error(message: string, trace?: string, context?: LogContext): void;
+    /**
+     * Log warning message
+     */
+    warn(message: string, context?: LogContext): void;
+    /**
+     * Log debug message
+     */
+    debug(message: string, context?: LogContext): void;
+    /**
+     * Log verbose message
+     */
+    verbose(message: string, context?: LogContext): void;
+    /**
+     * Log HTTP request
+     */
+    logRequest(req: any, context?: LogContext): void;
+    /**
+     * Log HTTP response
+     */
+    logResponse(req: any, res: any, responseTime: number, context?: LogContext): void;
+}

package/dist/logging/logger.service.js

@@ -0,0 +1,107 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TntLoggerService = void 0;
+const common_1 = require("@nestjs/common");
+const pino_1 = __importDefault(require("pino"));
+/**
+ * TNT Logger Service - Pino-based structured JSON logger
+ * Provides consistent logging across all microservices
+ */
+let TntLoggerService = class TntLoggerService {
+    logger;
+    context = {};
+    constructor(context) {
+        const isDevelopment = process.env.NODE_ENV !== 'production';
+        this.logger = (0, pino_1.default)({
+            level: process.env.LOG_LEVEL || 'info',
+            ...(isDevelopment && {
+                transport: {
+                    target: 'pino-pretty',
+                    options: {
+                        colorize: true,
+                        translateTime: 'HH:MM:ss Z',
+                        ignore: 'pid,hostname',
+                    },
+                },
+            }),
+        });
+        if (context) {
+            this.context = context;
+        }
+    }
+    /**
+     * Set context for all subsequent log messages
+     */
+    setContext(context) {
+        this.context = { ...this.context, ...context };
+    }
+    /**
+     * Log info message
+     */
+    log(message, context) {
+        this.logger.info({ ...this.context, ...context }, message);
+    }
+    /**
+     * Log error message
+     */
+    error(message, trace, context) {
+        this.logger.error({ ...this.context, ...context, trace }, message);
+    }
+    /**
+     * Log warning message
+     */
+    warn(message, context) {
+        this.logger.warn({ ...this.context, ...context }, message);
+    }
+    /**
+     * Log debug message
+     */
+    debug(message, context) {
+        this.logger.debug({ ...this.context, ...context }, message);
+    }
+    /**
+     * Log verbose message
+     */
+    verbose(message, context) {
+        this.logger.trace({ ...this.context, ...context }, message);
+    }
+    /**
+     * Log HTTP request
+     */
+    logRequest(req, context) {
+        this.logger.info({
+            ...this.context,
+            ...context,
+            method: req.method,
+            url: req.url,
+            userAgent: req.headers?.['user-agent'],
+            ip: req.ip,
+        }, 'HTTP Request');
+    }
+    /**
+     * Log HTTP response
+     */
+    logResponse(req, res, responseTime, context) {
+        this.logger.info({
+            ...this.context,
+            ...context,
+            method: req.method,
+            url: req.url,
+            statusCode: res.statusCode,
+            responseTime: `${responseTime}ms`,
+        }, 'HTTP Response');
+    }
+};
+exports.TntLoggerService = TntLoggerService;
+exports.TntLoggerService = TntLoggerService = __decorate([
+    (0, common_1.Injectable)()
+], TntLoggerService);

package/dist/nats/events/index.d.ts

@@ -0,0 +1,76 @@
+/**
+ * NATS Event Contracts
+ * TypeScript interfaces for inter-service communication via NATS
+ */
+export interface UserCreatedEvent {
+    userId: string;
+    email: string;
+    phone: string;
+    firstname?: string;
+    lastname?: string;
+    referralCode?: string;
+    createdAt: string;
+}
+export interface PaymentSuccessEvent {
+    transactionId: string;
+    userId: string;
+    amount: number;
+    currency: string;
+    provider: 'PROVIDUS' | 'PAYSTACK';
+    reference: string;
+    metadata?: Record<string, any>;
+    timestamp: string;
+}
+export interface PaymentFailedEvent {
+    transactionId: string;
+    userId: string;
+    amount: number;
+    currency: string;
+    provider: 'PROVIDUS' | 'PAYSTACK';
+    reference: string;
+    reason: string;
+    errorCode?: string;
+    timestamp: string;
+}
+export interface TransactionProcessedEvent {
+    transactionId: string;
+    userId: string;
+    type: 'CREDIT' | 'DEBIT';
+    amount: number;
+    balance: number;
+    description: string;
+    metadata?: Record<string, any>;
+    timestamp: string;
+}
+export interface NotificationSentEvent {
+    notificationId: string;
+    userId: string;
+    channel: 'EMAIL' | 'SMS' | 'PUSH';
+    type: string;
+    status: 'SENT' | 'FAILED';
+    timestamp: string;
+}
+export interface SavingsMaturedEvent {
+    savingsId: string;
+    userId: string;
+    amount: number;
+    interest: number;
+    plan: string;
+    maturityDate: string;
+    timestamp: string;
+}
+export interface LoanApprovedEvent {
+    loanId: string;
+    userId: string;
+    amount: number;
+    interestRate: number;
+    repaymentDate: string;
+    timestamp: string;
+}
+export interface LoanRepaidEvent {
+    loanId: string;
+    userId: string;
+    amount: number;
+    remainingBalance: number;
+    timestamp: string;
+}

package/dist/nats/events/index.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * NATS Event Contracts
+ * TypeScript interfaces for inter-service communication via NATS
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/nats/index.d.ts

@@ -3,3 +3,4 @@ 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';
+export * from './events';

package/dist/nats/index.js

@@ -19,3 +19,4 @@ __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);
+__exportStar(require("./events"), exports);

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

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

package/dist/rpc/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("./rpc-exception.filter"), exports);

package/dist/rpc/filters/rpc-exception.filter.d.ts

@@ -0,0 +1,10 @@
+import { RpcExceptionFilter, ArgumentsHost } from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { RpcException } from '@nestjs/microservices';
+/**
+ * TNT RPC Exception Filter
+ * Standardizes error handling and propagation in microservice communication
+ */
+export declare class TntRpcExceptionFilter implements RpcExceptionFilter<RpcException> {
+    catch(exception: any, host: ArgumentsHost): Observable<any>;
+}

package/dist/rpc/filters/rpc-exception.filter.js

@@ -0,0 +1,38 @@
+"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.TntRpcExceptionFilter = void 0;
+const common_1 = require("@nestjs/common");
+const rxjs_1 = require("rxjs");
+const microservices_1 = require("@nestjs/microservices");
+/**
+ * TNT RPC Exception Filter
+ * Standardizes error handling and propagation in microservice communication
+ */
+let TntRpcExceptionFilter = class TntRpcExceptionFilter {
+    catch(exception, host) {
+        // Extract error details
+        const error = exception instanceof microservices_1.RpcException ? exception.getError() : exception;
+        // Format error response
+        const errorResponse = {
+            statusCode: error?.statusCode || 500,
+            message: error?.message || exception.message || 'Internal server error',
+            error: error?.error || 'InternalServerError',
+            timestamp: new Date().toISOString(),
+            path: error?.path,
+            ...(process.env.NODE_ENV !== 'production' && {
+                stack: exception.stack,
+            }),
+        };
+        return (0, rxjs_1.throwError)(() => errorResponse);
+    }
+};
+exports.TntRpcExceptionFilter = TntRpcExceptionFilter;
+exports.TntRpcExceptionFilter = TntRpcExceptionFilter = __decorate([
+    (0, common_1.Catch)()
+], TntRpcExceptionFilter);

package/dist/rpc/index.d.ts

@@ -1,54 +1,4 @@
-import { NatsContext, RpcException } from '@nestjs/microservices';
-import { Observable } from 'rxjs';
-export interface TakeNTradeRPCError {
-    success: boolean;
-    subject: string | null;
-    message: string;
-    statusCode: number;
-    errors: string[];
-}
-export interface TakeNTradeRPCSuccess<T> {
-    data?: T;
-}
-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.
-     * @param successMessage - Optional success message
-     */
-    static handleRequest<V>(promise: Promise<V>, ctx?: NatsContext): Promise<TakeNTradeRPCSuccess<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.
-     * @param successMessage - Optional success message
-     */
-    static withReply<V>(obs: Observable<V>, successMessage?: string): Promise<TakeNTradeRPCSuccess<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<TakeNTradeRPCSuccess<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<TakeNTradeRPCSuccess<V>>;
-}
+export * from './rpc.client';
+export * from './rpc-error';
+export * from './rpc-response';
+export * from './filters';

package/dist/rpc/index.js

@@ -1,135 +1,20 @@
 "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 });
-exports.TakeNTradeRpcV2 = exports.TakeNTradeRpc = void 0;
-const common_1 = require("@nestjs/common");
-const microservices_1 = require("@nestjs/microservices");
-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;
-    }
-    static formatSuccessResponse(data) {
-        return {
-            data,
-        };
-    }
-}
-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.
-     * @param successMessage - Optional success message
-     */
-    static async handleRequest(promise, ctx) {
-        return promise
-            .then((value) => TakeNTradeRpcUtils.formatSuccessResponse(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),
-        };
-        return new microservices_1.RpcException(errorDetails);
-    }
-    /**
-     * Handles NATS request response.
-     * @param obs - An instance of an Observable.
-     * @param successMessage - Optional success message
-     */
-    static async withReply(obs, successMessage = 'Operation successful') {
-        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 TakeNTradeRpcUtils.formatSuccessResponse(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) => TakeNTradeRpcUtils.formatSuccessResponse(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),
-        };
-    }
-    /**
-     * 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 TakeNTradeRpcUtils.formatSuccessResponse(result);
-    }
-}
-exports.TakeNTradeRpcV2 = TakeNTradeRpcV2;
+__exportStar(require("./rpc.client"), exports);
+__exportStar(require("./rpc-error"), exports);
+__exportStar(require("./rpc-response"), exports);
+__exportStar(require("./filters"), exports);

package/dist/rpc/rpc-error.d.ts

@@ -0,0 +1,10 @@
+/**
+ * RPC Error Interface
+ */
+export interface TakeNTradeRPCError {
+    success: boolean;
+    subject: string | null;
+    message: string;
+    statusCode: number;
+    errors: string[];
+}

package/dist/rpc/rpc-error.js

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

package/dist/rpc/rpc-response.d.ts

@@ -0,0 +1,6 @@
+/**
+ * RPC Success Response Interface
+ */
+export interface TakeNTradeRPCSuccess<T> {
+    data?: T;
+}

package/dist/rpc/rpc-response.js

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

package/dist/rpc/rpc.client.d.ts

@@ -0,0 +1,46 @@
+import { NatsContext, RpcException } from '@nestjs/microservices';
+import { Observable } from 'rxjs';
+import { TakeNTradeRPCError } from './rpc-error';
+import { TakeNTradeRPCSuccess } from './rpc-response';
+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.
+     * @param successMessage - Optional success message
+     */
+    static handleRequest<V>(promise: Promise<V>, ctx?: NatsContext): Promise<TakeNTradeRPCSuccess<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.
+     * @param successMessage - Optional success message
+     */
+    static withReply<V>(obs: Observable<V>, successMessage?: string): Promise<TakeNTradeRPCSuccess<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<TakeNTradeRPCSuccess<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<TakeNTradeRPCSuccess<V>>;
+}