@traxionpay/cbsmiddleware 0.0.1

package/src/banking/services/sms.service.ts

@@ -0,0 +1,50 @@
+
+import { Injectable } from '@nestjs/common';
+import { Logger } from 'nestjs-pino';
+import axios from 'axios';
+import * as process from 'node:process';
+import { ConfigService } from '@nestjs/config';
+
+@Injectable()
+export class SmsService {
+  constructor(
+    private readonly logger: Logger,
+    private readonly configService: ConfigService
+    ) {}
+
+
+  async sendSms(mobile: string, otp: string, bankName: string) {
+    const url = process.env.SMS_URL || 'https://opensms.traxiontech.net/sms/push/';
+    const message = this.generateSmsMessage(otp, bankName);
+
+    const payload = {
+      number: mobile,
+      message,
+    };
+    const headers = {
+      'Content-Type': 'application/json',
+      'X-TXN-Auth': process.env.SMS_API_KEY || 'myt6tjeZ.wNOZPHckjolKNG4oVn3LGVVAHcZ1NHty',
+    };
+
+    // log without await
+    axios
+      .post(url, payload, { headers })
+      .then((response) => {
+        this.logger.log({ "Send SMS:": response.data });
+      })
+      .catch((error: any) => {
+        this.logger.error({
+          "Error sending SMS:": error.response?.data || error.message,
+        });
+      });
+  }
+
+  private generateSmsMessage(otp: string, BankName: string): string {
+    let template  = this.configService.get<string>('SMS_OTP_MESSAGE') ||
+      'Your {{BankName}} One-Time PIN is {{otp}}. DO NOT SHARE THIS WITH ANYONE.';
+    template = template.replace('{{otp}}', otp);
+    template = template.replace('{{BankName}}', BankName);
+    return template;
+  }
+  
+}

package/src/banking/tokens/bank-service.tokens.ts

@@ -0,0 +1,4 @@
+export const ASPAC_SERVICE_TOKEN = Symbol('ASPAC_SERVICE');
+export const WELCOMEBANK_SERVICE_TOKEN = Symbol('WELCOMEBANK_SERVICE');
+export const MBWIN_SERVICE_TOKEN = Symbol('MBWIN_SERVICE');
+export const BANKING_CONFIG = Symbol('BANKING_CONFIG');

package/src/banking/types.ts

@@ -0,0 +1,10 @@
+import { Type } from '@nestjs/common';
+import { BankService } from './interfaces/bank-service.interface';
+import { BankingConfig } from './interfaces/bank-config.interface';
+
+export interface BankingModuleOptions {
+  ASPACService?: Type<BankService>;
+  WelcomeBankService?: Type<BankService>;
+  MBWINService?: Type<BankService>;
+  config?: BankingConfig;
+}

package/src/decorators/response_message.decorator.ts

@@ -0,0 +1,4 @@
+import { SetMetadata } from '@nestjs/common';
+
+export const ResponseMessage = (message: string) =>
+      SetMetadata('response_message', message);

package/src/helpers/axios-error.helper.ts

@@ -0,0 +1,63 @@
+import { HttpException, HttpStatus, Logger } from '@nestjs/common';
+import { AxiosError } from 'axios';
+import * as moment from 'moment-timezone'; 
+
+export class AxiosErrorHelper {
+  private static readonly logger = new Logger(AxiosErrorHelper.name);
+
+  static handleAxiosError(error: unknown ): never {
+    const timestamp = moment.tz('Asia/Manila').format('YYYY-MM-DD HH:mm:ss');
+    // Check if the error is an AxiosError
+    if (this.isAxiosError(error)) {
+      if (error.response) {
+        // Log the error from the external service
+        this.logger.error(
+          `External service error: ${error.response.status} - ${error.response.statusText}`,
+          JSON.stringify(error.response.data),
+        );
+        throw new HttpException(
+          {
+            statusCode: error.response.status || HttpStatus.INTERNAL_SERVER_ERROR,
+            timestamp,
+            message: 'Internal error',
+            data: error.response.data || 'Service error',
+          },
+          error.response.status || HttpStatus.INTERNAL_SERVER_ERROR,
+        );
+      } else if (error.request) {
+        // Log the case where no response is received
+        this.logger.error(
+          'No response received from external service. The service may be down.',
+        );
+        throw new HttpException(
+          {
+            statusCode: HttpStatus.SERVICE_UNAVAILABLE,
+            timestamp,
+            message: 'Service is unreachable. Please try again later.',
+          },
+          HttpStatus.SERVICE_UNAVAILABLE,
+        );
+      }
+    }
+
+    // Log and handle non-Axios errors
+    const message =
+      error instanceof Error
+        ? error.message
+        : 'An unexpected error occurred';
+    this.logger.error(`Unexpected error: ${message}`, JSON.stringify(error));
+    throw new HttpException(
+      {
+        statusCode: HttpStatus.INTERNAL_SERVER_ERROR,
+        timestamp,
+        message: 'An unexpected error occurred',
+        error: message,
+      },
+      HttpStatus.INTERNAL_SERVER_ERROR,
+    );
+  }
+
+  private static isAxiosError(error: unknown): error is AxiosError {
+    return (error as AxiosError).isAxiosError !== undefined;
+  }
+}

package/src/helpers/response-format.helper.ts

@@ -0,0 +1,15 @@
+export class ResponseFormatHelper {
+  static createResponse(
+    statusCode: number,
+    timestamp: string = new Date().toISOString(),
+    message: string,
+    data: any,
+  ): any {
+    return {
+      statusCode,
+      timestamp,
+      message,
+      data,
+    };
+  }
+}

package/src/index.ts

@@ -0,0 +1,15 @@
+/* export * from './banking/interfaces/bank-service.interface';
+export * from './banking/tokens/bank-service.tokens';
+export * from './banking/types'; */
+export * from './banking/banking.module';
+export * from './auth/auth.module';
+export * from './banking/banking.controller';
+export * from './banking/factory/bank-strategy.factory';
+export * from './banking/dto/fetch-bank-balance.dto';
+export * from './logger/logger.module'
+export * from './logger/logger-interceptor'
+export * from './interceptors/response.interceptor'
+export * from './banking/services/BankGateway.service'
+/* export * from './auth/services/auth.service';
+export * from './auth/jwt-guard';
+export * from './auth/auth.controller'; */

package/src/interceptors/response.interceptor.ts

@@ -0,0 +1,53 @@
+import {
+  Injectable,
+  NestInterceptor,
+  ExecutionContext,
+  CallHandler,
+} from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import * as moment from 'moment-timezone';
+export interface Response<T> {
+  statusCode: number;
+  timestamp: string;
+  message: string;
+  data: T | null; 
+  customCode?: number; // Custom error 
+}
+
+@Injectable()
+export class TransformInterceptor<T> implements NestInterceptor<T, Response<T>> {
+  constructor(private reflector: Reflector) {}
+
+  intercept(
+    context: ExecutionContext,
+    next: CallHandler,
+  ): Observable<Response<T>> {
+    return next.handle().pipe(
+      map((data) => {
+        // Check if the data has a status of 400 or 500
+        if (data.status && (data.status !== 200 || data.status !== 201)) {
+          // Modify response for error statuses (400 or 500)
+          return {
+            statusCode: context.switchToHttp().getResponse().statusCode,
+            timestamp: moment.tz('Asia/Manila').format('YYYY-MM-DD HH:mm:ss'),
+            message: `An error occurred: ${data.status}`, // Custom error message
+            data: null, // Set data to null for errors
+       //     customCode: data.status === 400 ? 4000 : 5000, // Custom error code (adjust as necessary)
+          };
+        }
+
+        // Default response for normal successful responses
+        return {
+          statusCode: context.switchToHttp().getResponse().statusCode,
+          timestamp: moment.tz('Asia/Manila').format('YYYY-MM-DD HH:mm:ss'),
+          message:
+            this.reflector.get<string>('response_message', context.getHandler()) ||
+            '',
+          data,
+        };
+      }),
+    );
+  }
+}

package/src/logger/logger-interceptor.ts

@@ -0,0 +1,55 @@
+import {
+  Injectable,
+  NestInterceptor,
+  ExecutionContext,
+  CallHandler,
+} from '@nestjs/common';
+import { Logger } from 'nestjs-pino';
+import { catchError, Observable, tap, throwError } from 'rxjs';
+
+@Injectable()
+export class LoggerInterceptor implements NestInterceptor {
+  constructor(
+    private readonly logger: Logger
+  ) {}
+
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    const req = context.switchToHttp().getRequest();
+    const method = req.method;
+    const url = req.url;
+    const startTime = Date.now();
+    const body = req.body;
+    const safeBody = { ...body };
+    delete safeBody.password;
+    // delete safeBody.otp;
+
+    this.logger.log({ method, url, body: safeBody }, 'Request started');
+
+    return next.handle().pipe(
+      tap(() => {
+        const res = context.switchToHttp().getResponse();
+        const statusCode = res.statusCode;
+        const processTime = Date.now() - startTime;
+
+        this.logger.log(
+          { statusCode, processTime, body: safeBody },
+          'Request processed',
+        );
+      }),
+    );
+  }
+}
+
+@Injectable()
+export class ErrorInterceptor implements NestInterceptor {
+  constructor(private readonly logger: Logger) {}
+
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    return next.handle().pipe(
+      catchError((error) => {
+        this.logger.error({ error: error.stack }, 'Intercept Error occurred');
+        return throwError(() => error);
+      }),
+    );
+  }
+}

package/src/logger/logger-option.ts

@@ -0,0 +1,119 @@
+import pino from 'pino';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+
+// export class LoggerFilename {
+// Ensure log directory and file exist
+export const ensureLogFileExists = (filePath: string) => {
+  const logDir = path.dirname(filePath);
+
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true });
+  }
+
+  if (!fs.existsSync(filePath)) {
+    fs.writeFileSync(filePath, '', { flag: 'w' }); // Create a writable stream for logging
+  }
+  return fs.createWriteStream(filePath, { flags: 'a' }); // Append mode
+};
+
+// Helper function to generate the filename based on the current date
+export const generateLogFilename = () => {
+  const date = new Date();
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0'); // Months are zero-indexed
+  const day = String(date.getDate()).padStart(2, '0');
+  return `./logs/bank-middleware-${year}-${month}-${day}.log`; // Example: ./logs/2024-11-23.log
+};
+
+// Create a custom transport with fallback
+export const createFaultTolerantTransport = (): pino.TransportMultiOptions => {
+  const defaultOpts = {
+    singleLine: true,
+    mkdir: true,
+    prettyPrint: true,
+    translateTime: "yyyy-MM-dd'T'HH:mm:ss.l'Z'",
+    // messageFormat:
+    //   '{req.headers.x-correlation-id} [{context}] {responseTime} {msg}',
+    // ignore: 'pid,hostname,context,req,res,responseTime',
+    errorLikeObjectKeys: ['err', 'error'],
+    frequency: 'daily',
+    zippedArchive: false,
+    maxFiles: '30d', // Keep logs for 30 days
+    colorize: true,
+    datePattern: 'YYYY-MM-DD',
+  };
+  const logFilename = generateLogFilename();
+  const logStream = ensureLogFileExists(logFilename);
+
+  // Periodically check for file existence and handle interruptions
+  setInterval(() => {
+    if (!fs.existsSync(logFilename)) {
+      console.error(`Log file missing: ${logFilename}`);
+      logStream.end();
+      ensureLogFileExists(logFilename);
+      console.error(`Log file recreated: ${logFilename}`);
+    }
+  }, 5000);
+
+  return {
+    targets: [
+      {
+        target: 'pino-pretty', // Console logs for development
+        level: 'debug',
+        options: {
+          ...defaultOpts,
+          errorLikeObjectKeys: ['err', 'error'],
+        },
+      },
+      {
+        target: 'pino/file', // File transport
+        level: 'debug',
+        options: {
+          destination: logFilename,
+          ...defaultOpts, // Ensure directories are created automatically
+        },
+      },
+      // {
+      //   level: 'debug',
+      //   target: 'pino-daily-rotate-file',
+      //   options: {
+      //     destination: logFilename,
+      //     ...defaultOpts,
+      //     maxSize: '10m',
+      //     gzip: true,
+      //   },
+      // },
+      /* {
+        level: 'debug',
+        target: 'pino-postgresql-transport',
+        options: {
+          serviceName: 'TRANSACTION_SERVICE',
+          tableName: 'ApplicationLogs',
+          connection: {
+            host: process.env.LOG_DATABASE_HOST,
+            port: process.env.LOG_DATABASE_PORT,
+            user: process.env.LOG_DATABASE_USER,
+            password: process.env.LOG_DATABASE_PASSWORD,
+            database: process.env.LOG_DATABASE_NAME,
+          }
+        },
+      },
+      {
+        level: 'error',
+        target: 'google-chat-transport',
+        options: {
+          webhookUrl: process.env.GOOGLE_CHAT_SPACES_WEBHOOK_URL,
+          verbose: true,
+        },
+      },
+      {
+        target: 'pino-elastic', // Optional: external log aggregation service
+        level: 'error',
+        options: {
+          url: 'http://your-log-server:9200', // Example for Elasticsearch
+        },
+      },*/
+    ],
+  };
+};

package/src/logger/logger.config.ts

@@ -0,0 +1,31 @@
+import { LoggerOptions } from 'pino';
+import PinoDailyRotateFile from 'pino-daily-rotate-file';
+import { format } from 'date-fns-tz';  // Import date-fns-tz for timezone handling
+
+export function createLoggerOptions(): LoggerOptions {
+  // Function to generate a UTC-based log filename with date
+  const generateLogFilename = (): string => {
+    const now = new Date();
+    const utcDate = format(now, 'yyyy-MM-dd', { timeZone: 'UTC' }); // Format date in UTC
+    return `./logs/application-${utcDate}.log`; // Return log file with UTC date
+  };
+
+  // Create the transport using PinoDailyRotateFile constructor
+  const transport = new PinoDailyRotateFile({
+    filename: generateLogFilename(), // Dynamically use UTC date
+    datePattern: 'yyyy-MM-dd', // Daily rotation pattern
+    maxSize: '20m', // Max size of a log file (20MB)
+    maxFiles: '14d', // Retain logs for 14 days
+    gzip: true, // Compress old logs
+    utc: true, // Ensure UTC-based rotation
+  });
+
+  // Return the logger options
+  return {
+    level: 'info',
+    transport: {
+      target: 'pino/file', // Specify transport target
+      options: { stream: transport }, // Pass the created stream
+    },
+  };
+}

package/src/logger/logger.module.ts

@@ -0,0 +1,31 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { LoggerModule } from 'nestjs-pino';
+import { v4 as uuidv4 } from 'uuid';
+import { createFaultTolerantTransport } from './logger-option';
+import * as moment from 'moment-timezone';
+
+@Module({
+  imports: [
+    ConfigModule, 
+    LoggerModule.forRootAsync({
+      imports: [ConfigModule],
+      inject: [ConfigService],
+      useFactory: async () => {
+        return {
+          pinoHttp: {
+            level: 'debug',
+            // timestamp: pino.stdTimeFunctions.isoTime,
+            timestamp: () => `,"time":"${moment.tz('Asia/Manila').format('YYYY-MM-DD HH:mm:ss')}"`,
+            genReqId: (request) => request.id || uuidv4(),
+            redact: ['request.headers.authorization'],
+            quietReqLogger: true,
+            autoLogging: true,
+            transport: createFaultTolerantTransport(),
+          },
+        };
+      },
+    }),
+  ],
+})
+export class AppLoggerModule {}

package/src/main.ts

@@ -0,0 +1,10 @@
+import { NestFactory } from '@nestjs/core';
+import { AppModule } from './app.module';
+import { Logger } from 'nestjs-pino';
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+    const logger = app.get(Logger);
+  app.useLogger(logger);
+  await app.listen(process.env.PORT ?? 5002);
+}
+bootstrap();

package/src/types/pino-daily-rotate-file.d.ts

@@ -0,0 +1,31 @@
+declare module 'pino-daily-rotate-file' {
+  import { Writable } from 'stream';
+
+  // interface PinoDailyRotateOptions {
+  //   filename: string; // Path pattern for log files (e.g., './logs/log-%DATE%.log')
+  //   datePattern?: string; // Date format in filenames (e.g., 'YYYY-MM-DD')
+  //   maxSize?: string; // Max size of a log file (e.g., '10m')
+  //   maxFiles?: string | number; // Max number of files to keep (e.g., '14d')
+  //   utc?: boolean; // Use UTC time in log file names
+  //   auditFile?: string; // Path to audit JSON file
+  //   gzip?: boolean; // Compress old log files
+  //   extension?: string; // Extension for log files (e.g., '.log')
+  //   level?: string;
+  // }
+
+  class PinoDailyRotateFile extends Writable {
+    constructor(options: {
+      filename: string;
+      datePattern: string;
+      maxSize: string;
+      maxFiles: string;
+      level?: string;
+      gzip?: boolean; // Compress old log files
+      utc?: boolean; // Use UTC time in log file names
+      auditFile?: string; // Path to audit JSON file
+      extension?: string; // Extension for log files (e.g., '.log')
+    });
+  }
+
+  export = PinoDailyRotateFile;
+}

package/tsconfig.build.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "removeComments": true
+  },
+  "include": ["src/**/*.ts"]
+}