@traxionpay/cbsmiddleware 0.0.2 → 0.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@traxionpay/cbsmiddleware",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "This is a cbs middlware for RB Banks",
   "author": "Archer",
   "private": false,

package/src/banking/dto/account-transfer.dto.ts

@@ -53,8 +53,8 @@ export class AccountTransferDto {
     particulars?: string;
 
     @IsOptional()
-    @IsNumber()
-    mobile?: number
+    @IsString()
+    mobile?: string
 
     @IsOptional()
     @IsString()

package/src/banking/dto/account.dto.ts

@@ -29,8 +29,8 @@ export class AccountDto {
     accountType?: string;
 
     @IsOptional()
-    @IsNumber()
-    mobile?: number
+    @IsString()
+    mobile?: string
 
     @IsOptional()
     @IsString()

package/src/banking/dto/fetch-bank-balance.dto.ts

@@ -2,7 +2,8 @@ import {
   IsDefined,
   IsString,
   IsOptional,
-  IsNumber
+  IsNumber,
+  isString
 } from "class-validator";
 
 export class FetchBankBalanceDto {
@@ -32,8 +33,8 @@ export class FetchBankBalanceDto {
     accountType?: string;
 
     @IsOptional()
-    @IsNumber()
-    mobile?: number
+    @IsString()
+    mobile?: string
 
     @IsOptional()
     @IsString()

package/src/banking/dto/transaction-history.dto.ts

@@ -45,8 +45,8 @@ export class TransactionHistoryDto {
     page?: number;
 
     @IsOptional()
-    @IsNumber()
-    mobile?: number
+    @IsString()
+    mobile?: string
 
     @IsOptional()
     @IsString()

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

@@ -20,6 +20,15 @@ export class ASPACService implements BankService {
   ) {
   }
 
+  combineDateTime(date: string, time: string): string {
+    const isoString = `${date}T${time.padEnd(8, '0')}.000Z`; // ensure time is HH:mm:ss
+    const d = new Date(isoString);
+
+    // Format as: 2025-09-26T05:35:36.320+00:00
+    const isoWithOffset = d.toISOString().replace('Z', '+00:00');
+
+    return isoWithOffset;
+  }
   async generateToken(): Promise<any> {
 
     this.logger.log("Generating WelcomeBank Token");
@@ -59,8 +68,8 @@ export class ASPACService implements BankService {
     if (!refreshToken) {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
-        code: 4000, //TBD
-        message: 'Bank token should not be empty.',
+        code: 400010205,
+        message: 'Refresh token is required.',
         data: { refreshToken }
       }, HttpStatus.BAD_REQUEST);
     }
@@ -97,47 +106,48 @@ export class ASPACService implements BankService {
       };
 
     } catch (error) {
+
+      if (error.response.data.message === "Invalid refresh token") {
+        throw new HttpException({
+          statusCode: HttpStatus.BAD_REQUEST,
+          code: 400010206,
+          message: 'Invalid refresh token.',
+          data: { refreshToken }
+        }, HttpStatus.BAD_REQUEST);
+      }
+
       AxiosErrorHelper.handleAxiosError(error);
     }
   }
 
   async linkAccount(accountDto: AccountDto) {
 
-    const { token, account, accountType, mobile } = accountDto;
-
-    if (!token) {
-      throw new HttpException({
-        statusCode: HttpStatus.UNAUTHORIZED,
-        code: 4000, //TBD
-        message: 'Bank token should not be empty.',
-        data: { accountDto }
-      }, HttpStatus.UNAUTHORIZED);
-    }
+    const { account, accountType, mobile } = accountDto;
 
     if (!account) {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
-        code: 4000, //TBD
-        message: 'Bank account number should not be empty.',
-        data: { accountDto }
+        code: 400010306,
+        message: 'Account number is required.',
+        data: { ...accountDto }
       }, HttpStatus.BAD_REQUEST);
     }
 
     if (!accountType) {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
-        code: 4000, //TBD
-        message: 'Bank account type should not be empty.',
-        data: { accountDto }
+        code: 400010308,
+        message: 'Account type is required.',
+        data: { ...accountDto }
       }, HttpStatus.BAD_REQUEST);
     }
 
     if (!mobile) {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
-        code: 4000, //TBD
-        message: 'Mobile Number should not be empty.',
-        data: { accountDto }
+        code: 4000103011,
+        message: 'Mobile number is required.',
+        data: { ...accountDto }
       }, HttpStatus.BAD_REQUEST);
     }
 
@@ -145,7 +155,6 @@ export class ASPACService implements BankService {
 
     try {
       const headers = {
-        'Authorization': `Bearer ${token}`,
         'X-API-KEY': `${this.config.ASPAC_API_KEY}`,
         'X-API-VERSION': `${this.config.ASPAC_VERSION_KEY}`
       };
@@ -170,38 +179,66 @@ export class ASPACService implements BankService {
       }
     }
     catch (error) {
+
+      if (error.response.data.message === "Account number must be 14 digits" || error.response.data.message === "Account does not exist or is not active") {
+        throw new HttpException({
+          statusCode: HttpStatus.BAD_REQUEST,
+          code: 400010305,
+          message: 'Account not found',
+          data: { ...accountDto }
+        }, HttpStatus.BAD_REQUEST);
+      }
+
+      if (error.response.data.message === "Invalid account type. Only deposit accounts (01) allowed") {
+        throw new HttpException({
+          statusCode: HttpStatus.BAD_REQUEST,
+          code: 400010307,
+          message: 'Account type is not supported.',
+          data: { ...accountDto }
+        }, HttpStatus.BAD_REQUEST);
+      }
+
+      if (error.response.data.message === "Mobile number does not match registered mobile") {
+        throw new HttpException({
+          statusCode: HttpStatus.BAD_REQUEST,
+          code: 400010309,
+          message: 'Mobile number is not registered in the account.',
+          data: { ...accountDto }
+        }, HttpStatus.BAD_REQUEST);
+      }
+
+      if (error.response.data.message === "Mobile number must be 12 digits (63XXXXXXXXXX)") {
+        throw new HttpException({
+          statusCode: HttpStatus.UNPROCESSABLE_ENTITY,
+          code: 4220103010,
+          message: 'Invalid mobile number format.',
+          data: { ...accountDto }
+        }, HttpStatus.UNPROCESSABLE_ENTITY);
+      }
+
       AxiosErrorHelper.handleAxiosError(error);
     }
   }
 
   async validateOtp(validateOtp: ValidateOtp): Promise<any> {
 
-    const { token, account, otp } = validateOtp;
-
-    if (!token) {
-      throw new HttpException({
-        statusCode: HttpStatus.UNAUTHORIZED,
-        code: 4000, //TBD
-        message: 'Bank token should not be empty.',
-        data: { validateOtp }
-      }, HttpStatus.UNAUTHORIZED);
-    }
+    const { account, otp } = validateOtp;
 
     if (!account) {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
-        code: 4000, //TBD
-        message: 'Bank account number should not be empty.',
-        data: { validateOtp }
+        code: 400010406,
+        message: 'Account number is required.',
+        data: { ...validateOtp }
       }, HttpStatus.BAD_REQUEST);
     }
 
     if (!otp) {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
-        code: 4000, //TBD
-        message: 'Bank account number should not be empty.',
-        data: { validateOtp }
+        code: 400010408,
+        message: 'OTP is required.',
+        data: { ...validateOtp }
       }, HttpStatus.BAD_REQUEST);
     }
 
@@ -210,7 +247,6 @@ export class ASPACService implements BankService {
 
     try {
       const headers = {
-        'Authorization': `Bearer ${token}`,
         'X-API-KEY': `${this.config.ASPAC_API_KEY}`,
         'X-API-VERSION': `${this.config.ASPAC_VERSION_KEY}`
       };
@@ -242,6 +278,25 @@ export class ASPACService implements BankService {
 
     }
     catch (error) {
+
+      if (error.response.data.message === "Account number must be 14 digits" || error.response.data.message === "Account does not exist or is not active") {
+        throw new HttpException({
+          statusCode: HttpStatus.BAD_REQUEST,
+          code: 400010405,
+          message: 'Account not found.',
+          data: { ...validateOtp }
+        }, HttpStatus.BAD_REQUEST);
+      }
+
+      if (error.response.data.message === "Invalid OTP format. OTP must be exactly 6 digits" || error.response.data.message === "Invalid OTP code") {
+        throw new HttpException({
+          statusCode: HttpStatus.BAD_REQUEST,
+          code: 400010407,
+          message: 'Invalid or expired OTP.',
+          data: { ...validateOtp }
+        }, HttpStatus.BAD_REQUEST);
+      }
+
       AxiosErrorHelper.handleAxiosError(error);
     }
   }
@@ -253,18 +308,18 @@ export class ASPACService implements BankService {
     if (!token) {
       throw new HttpException({
         statusCode: HttpStatus.UNAUTHORIZED,
-        code: 4000, //TBD
+        code: 401010506,
         message: 'Bank token should not be empty.',
-        data: { fetchBalanceDto }
+        data: { ...fetchBalanceDto }
       }, HttpStatus.UNAUTHORIZED);
     }
 
     if (!account) {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
-        code: 4000, //TBD
-        message: 'Bank account number should not be empty.',
-        data: { fetchBalanceDto }
+        code: 400010508,
+        message: 'Account number is required.',
+        data: { ...fetchBalanceDto }
       }, HttpStatus.BAD_REQUEST);
     }
 
@@ -302,7 +357,18 @@ export class ASPACService implements BankService {
       }
     }
     catch (error) {
+
+      if (error.response.data.message === "Account number must be 14 digits" || error.response.data.message === "Account does not exist or is not active") {
+        throw new HttpException({
+          statusCode: HttpStatus.BAD_REQUEST,
+          code: 400010507,
+          message: 'Account not found.',
+          data: { fetchBalanceDto }
+        }, HttpStatus.BAD_REQUEST);
+      }
+
       AxiosErrorHelper.handleAxiosError(error);
+
     }
   }
 
@@ -313,36 +379,36 @@ export class ASPACService implements BankService {
     if (!token) {
       throw new HttpException({
         statusCode: HttpStatus.UNAUTHORIZED,
-        code: 4000, //TBD
+        code: 401010606,
         message: 'Bank token should not be empty.',
-        data: { accountTransferDto }
+        data: { ...accountTransferDto }
       }, HttpStatus.UNAUTHORIZED);
     }
 
     if (!sourceAccount) {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
-        code: 4000, //TBD
-        message: 'Bank source account number should not be empty.',
-        data: { accountTransferDto }
+        code: 400010608,
+        message: 'Account number is required',
+        data: { ...accountTransferDto }
       }, HttpStatus.BAD_REQUEST);
     }
 
     if (!amount) {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
-        code: 4000, //TBD
-        message: 'Amount should not be empty.',
-        data: { accountTransferDto }
+        code: 400010609,
+        message: 'Transaction amount is required.',
+        data: { ...accountTransferDto }
       }, HttpStatus.BAD_REQUEST);
     }
 
     if (!particulars) {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
-        code: 4000, //TBD
-        message: 'Particulars should not be empty.',
-        data: { accountTransferDto }
+        code: 400010611,
+        message: 'Transaction particulars is required.',
+        data: { ...accountTransferDto }
       }, HttpStatus.BAD_REQUEST);
     }
 
@@ -382,7 +448,27 @@ export class ASPACService implements BankService {
       }
     }
     catch (error) {
+
+      if (error.response.data.message === "Account number must be 14 digits" || error.response.data.message === "Account does not exist or is not active") {
+        throw new HttpException({
+          statusCode: HttpStatus.BAD_REQUEST,
+          code: 400010607,
+          message: 'Account not found.',
+          data: { ...accountTransferDto }
+        }, HttpStatus.UNAUTHORIZED);
+      }
+
+      if (error.response.data.message === "Amount must be between 0.01 and 500,000.00" || error.response.data.message === "Invalid amount format") {
+        throw new HttpException({
+          statusCode: HttpStatus.UNPROCESSABLE_ENTITY,
+          code: 422010610,
+          message: 'Invalid transaction amount value.',
+          data: { ...accountTransferDto }
+        }, HttpStatus.UNPROCESSABLE_ENTITY);
+      }
+
       AxiosErrorHelper.handleAxiosError(error);
+
     }
   }
 
@@ -393,36 +479,36 @@ export class ASPACService implements BankService {
     if (!token) {
       throw new HttpException({
         statusCode: HttpStatus.UNAUTHORIZED,
-        code: 4000, //TBD
+        code: 401010706,
         message: 'Bank token should not be empty.',
-        data: { accountTransferDto }
+        data: { ...accountTransferDto }
       }, HttpStatus.UNAUTHORIZED);
     }
 
     if (!destinationAccount) {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
-        code: 4000, //TBD
-        message: 'Bank destination account number should not be empty.',
-        data: { accountTransferDto }
+        code: 400010708,
+        message: 'Account number is required.',
+        data: { ...accountTransferDto }
       }, HttpStatus.BAD_REQUEST);
     }
 
     if (!amount) {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
-        code: 4000, //TBD
-        message: 'amount should not be empty.',
-        data: { accountTransferDto }
+        code: 400010709,
+        message: 'Transaction amount is required.',
+        data: { ...accountTransferDto }
       }, HttpStatus.BAD_REQUEST);
     }
 
     if (!particulars) {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
-        code: 4000, //TBD
-        message: 'Particulars should not be empty.',
-        data: { accountTransferDto }
+        code: 400010711,
+        message: 'Transaction particulars is required.',
+        data: { ...accountTransferDto }
       }, HttpStatus.BAD_REQUEST);
     }
 
@@ -462,50 +548,105 @@ export class ASPACService implements BankService {
       }
     }
     catch (error) {
+
+      if (error.response.data.message === "Account number must be 14 digits" || error.response.data.message === "Account does not exist or is not active") {
+        throw new HttpException({
+          statusCode: HttpStatus.BAD_REQUEST,
+          code: 400010707,
+          message: 'Account not found.',
+          data: { ...accountTransferDto }
+        }, HttpStatus.BAD_REQUEST);
+      }
+
+      if (error.response.data.message === "Amount must be between 0.01 and 500,000.00" || error.response.data.message === "Invalid amount format") {
+        throw new HttpException({
+          statusCode: HttpStatus.UNPROCESSABLE_ENTITY,
+          code: 422010710,
+          message: 'Invalid transaction amount value.',
+          data: { ...accountTransferDto }
+        }, HttpStatus.UNPROCESSABLE_ENTITY);
+      }
+
       AxiosErrorHelper.handleAxiosError(error);
     }
   }
 
-  async getTransactionHistory(transactionHistoryDto: TransactionHistoryDto) {
+  async getTransactionHistory(transactionHistoryDto: TransactionHistoryDto):
+    Promise<{
+      success: boolean;
+      message: any;
+      correlationId: any;
+      timestamp: any;
+      transactions: any;
+    }> {
 
     const { token, account, dateFrom, dateTo, page } = transactionHistoryDto;
+    const dateRegex = /^\d{4}-\d{2}-\d{2}$/;
+
+    interface ReformattedTransaction {
+      dateTime: string;
+      amount: number;
+      type: string;
+      description: string;
+      transactionReference: string;
+    }
+
+    const reformattedTransactions: Record<string, ReformattedTransaction> = {};
 
     if (!token) {
       throw new HttpException({
         statusCode: HttpStatus.UNAUTHORIZED,
-        code: 4000, //TBD
+        code: 401010806,
         message: 'Bank token should not be empty.',
-        data: { transactionHistoryDto }
+        data: { ...transactionHistoryDto }
       }, HttpStatus.UNAUTHORIZED);
     }
 
     if (!account) {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
-        code: 4000, //TBD
-        message: 'Bank account number should not be empty.',
-        data: { transactionHistoryDto }
+        code: 400010808,
+        message: 'Account number is required.',
+        data: { ...transactionHistoryDto }
       }, HttpStatus.BAD_REQUEST);
     }
 
     if (!dateFrom) {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
-        code: 4000, //TBD
-        message: 'Date From should not be empty.',
-        data: { transactionHistoryDto }
+        code: 400010810,
+        message: 'Starting date is required.',
+        data: { ...transactionHistoryDto }
       }, HttpStatus.BAD_REQUEST);
     }
 
+    if (!dateRegex.test(dateFrom)) {
+      throw new HttpException({
+        statusCode: HttpStatus.UNPROCESSABLE_ENTITY,
+        code: 422010809,
+        message: 'Invalid starting date format. Format should be in YYYY-MM-DD.',
+        data: { ...transactionHistoryDto }
+      }, HttpStatus.UNPROCESSABLE_ENTITY);
+    }
+
     if (!dateTo) {
       throw new HttpException({
         statusCode: HttpStatus.BAD_REQUEST,
-        code: 4000, //TBD
-        message: 'Date From should not be empty.',
-        data: { transactionHistoryDto }
+        code: 400010812,
+        message: 'Ending date is required.',
+        data: { ...transactionHistoryDto }
       }, HttpStatus.BAD_REQUEST);
     }
 
+    if (!dateRegex.test(dateTo)) {
+      throw new HttpException({
+        statusCode: HttpStatus.UNPROCESSABLE_ENTITY,
+        code: 422010811,
+        message: 'Invalid starting date format. Format should be in YYYY-MM-DD.',
+        data: { ...transactionHistoryDto }
+      }, HttpStatus.UNPROCESSABLE_ENTITY);
+    }
+
 
     this.logger.log("Welcome Bank transaction history");
 
@@ -538,13 +679,49 @@ export class ASPACService implements BankService {
 
       this.logger.log({ responseData: response.data }, 'Welcome Bank Transaction History Successful');
 
+      response.data.data.transactions.forEach((txn, index) => {
+        const key = `${index + 1}`;
+        const dateTime = this.combineDateTime(txn.tranDate, txn.tranTime);
+
+        reformattedTransactions[key] = {
+          dateTime,
+          amount: txn.tranAmount,
+          type: txn.tranType,
+          description: txn.description,
+          transactionReference: txn.tranReference
+        };
+      });
+
       return {
         success: true,
-        ...response.data,
+        message: response.data.data.message,
+        correlationId: response.data.correlationId,
+        timestamp: response.data.timestamp,
+        transactions: reformattedTransactions,
       }
     }
     catch (error) {
+
+      if (error.response.data.message === "Account number must be 14 digits" || error.response.data.message === "Account does not exist or is not active") {
+        throw new HttpException({
+          statusCode: HttpStatus.BAD_REQUEST,
+          code: 400010807,
+          message: 'Account not found.',
+          data: { ...transactionHistoryDto }
+        }, HttpStatus.BAD_REQUEST);
+      }
+
+      if (error.response.data.message === "Invalid page number format") {
+        throw new HttpException({
+          statusCode: HttpStatus.UNPROCESSABLE_ENTITY,
+          code: 422010813,
+          message: 'Invalid page number format.',
+          data: { ...transactionHistoryDto }
+        }, HttpStatus.UNPROCESSABLE_ENTITY);
+      }
+
       AxiosErrorHelper.handleAxiosError(error);
+
     }
   }