@akinon/pz-masterpass-rest 2.0.0-beta.12 → 2.0.0-beta.14

package/src/services/account.ts

@@ -8,102 +8,111 @@ import {
   AddCardResponse
 } from '../types/account.types';
 import { store } from 'redux/store';
+import { createSessionExpiredResponse, withUnhandledRejectionHandler } from '../utils/session-handler';
 
 export class AccountService {
-  private get token(): string {
-    return store.getState().masterpassRest.token || '';
-  }
-
-  private get merchantId(): string {
-    return store.getState().masterpassRest.tokenData?.MerchantId || '';
-  }
+  private _token: string;
+  private _merchantId: string;
 
-  constructor() {
+  constructor(token?: string, merchantId?: string) {
+    this._token = token || store.getState().masterpassRest.token || '';
+    this._merchantId = merchantId || store.getState().masterpassRest.tokenData?.MerchantId || '';
     this.initialize();
   }
 
   private initialize(): void {
     if (!window.Masterpass) {
-      console.error('window.Masterpass not available in AccountService');
       return;
     }
 
     if (window.Masterpass.setToken) {
-      window.Masterpass.setToken(this.token);
+      window.Masterpass.setToken(this._token);
     }
 
     if (window.Masterpass.setMerchantId) {
-      window.Masterpass.setMerchantId(this.merchantId);
+      window.Masterpass.setMerchantId(this._merchantId);
     }
   }
 
   accountAccess(request: AccountAccessRequest): Promise<AccountAccessResponse> {
-    return new Promise((resolve, reject) => {
-      try {
-        this.initialize();
+    return withUnhandledRejectionHandler(
+      () => new Promise((resolve, reject) => {
+        try {
+          this.initialize();
 
-        window.Masterpass.accountService.accountAccess(
-          request,
-          (statusCode: number, response: AccountAccessResponse) => {
-            resolve(response);
-          }
-        );
-      } catch (error) {
-        console.error('AccountAccess error:', error);
-        reject(error);
-      }
-    });
+          window.Masterpass.accountService.accountAccess(
+            request,
+            (statusCode: number, response: AccountAccessResponse) => {
+              resolve(response);
+            }
+          );
+        } catch (error) {
+          console.error('AccountAccess error:', error);
+          reject(error);
+        }
+      }),
+      createSessionExpiredResponse<AccountAccessResponse>()
+    );
   }
 
   linkToMerchant(request: {
     accountKey: string;
   }): Promise<LinkToMerchantResponseType> {
-    return new Promise((resolve, reject) => {
-      try {
-        this.initialize();
+    return withUnhandledRejectionHandler(
+      () => new Promise((resolve, reject) => {
+        try {
+          this.initialize();
 
-        window.Masterpass.accountService.linkToMerchant(
-          request,
-          (statusCode: number, response: LinkToMerchantResponseType) => {
-            resolve(response);
-          }
-        );
-      } catch (error) {
-        reject(error);
-      }
-    });
+          window.Masterpass.accountService.linkToMerchant(
+            request,
+            (statusCode: number, response: LinkToMerchantResponseType) => {
+              resolve(response);
+            }
+          );
+        } catch (error) {
+          reject(error);
+        }
+      }),
+      createSessionExpiredResponse<LinkToMerchantResponseType>()
+    );
   }
 
   removeCard(req: RemoveCardRequest): Promise<RemoveCardServiceResponse> {
-    return new Promise((resolve, reject) => {
-      try {
-        this.initialize();
-        window.Masterpass.accountService.removeCard(
-          req,
-          (statusCode: number, response: RemoveCardServiceResponse) => {
-            resolve(response);
-          }
-        );
-      } catch (error) {
-        reject(error);
-      }
-    });
+    return withUnhandledRejectionHandler(
+      () => new Promise((resolve, reject) => {
+        try {
+          this.initialize();
+          window.Masterpass.accountService.removeCard(
+            req,
+            (statusCode: number, response: RemoveCardServiceResponse) => {
+              resolve(response);
+            }
+          );
+        } catch (error) {
+          reject(error);
+        }
+      }),
+      createSessionExpiredResponse<RemoveCardServiceResponse>()
+    );
   }
 
   addCard(request: AddCardRequest): Promise<AddCardResponse> {
-    return new Promise((resolve, reject) => {
-      try {
-        this.initialize();
+    return withUnhandledRejectionHandler(
+      () => new Promise((resolve, reject) => {
+        try {
+          this.initialize();
 
-        window.Masterpass.accountService.addCard(
-          request,
-          (statusCode: number, response: AddCardResponse) => {
-            resolve(response);
-          }
-        );
-      } catch (error) {
-        reject(error);
-      }
-    });
+          window.Masterpass.accountService.addCard(
+            request,
+            (statusCode: number, response: AddCardResponse) => {
+              resolve(response);
+            }
+          );
+        } catch (error) {
+          reject(error);
+        }
+      }),
+      createSessionExpiredResponse<AddCardResponse>()
+    );
   }
 }

package/src/services/payment.ts

@@ -5,6 +5,7 @@ import {
   MPResponse,
   type PaymentProcessRequest
 } from '../types/payment.types';
+import { withUnhandledRejectionHandler } from '../utils/session-handler';
 
 export interface PaymentResponse {
   success: boolean;
@@ -13,119 +14,156 @@ export interface PaymentResponse {
 }
 
 export class PaymentService {
-  private get token(): string {
-    return store.getState().masterpassRest.token || '';
-  }
-
-  private get merchantId(): string {
-    return store.getState().masterpassRest.tokenData?.MerchantId || '';
-  }
+  private _token: string;
+  private _merchantId: string;
 
-  constructor() {
+  constructor(token?: string, merchantId?: string) {
+    this._token = token || store.getState().masterpassRest.token || '';
+    this._merchantId =
+      merchantId || store.getState().masterpassRest.tokenData?.MerchantId || '';
     this.initialize();
   }
 
   private initialize(): void {
-    window.Masterpass.setToken(this.token);
-    window.Masterpass.setMerchantId(this.merchantId);
+    window.Masterpass.setToken(this._token);
+    window.Masterpass.setMerchantId(this._merchantId);
+  }
+
+  private extractErrorMessage(error: unknown, fallback: string): string {
+    if (error instanceof Error) return error.message;
+    if (typeof error === 'string') return error;
+    return fallback;
   }
 
   async processPayment(
     paymentData: PaymentProcessRequest
   ): Promise<PaymentResponse> {
-    return new Promise((resolve) => {
-      try {
-        this.initialize();
+    return withUnhandledRejectionHandler(
+      () =>
+        new Promise((resolve) => {
+          try {
+            this.initialize();
 
-        window.Masterpass.paymentService.payment(
-          {
-            requestReferenceNo: paymentData.requestReferenceNo,
-            cvc: paymentData.cvc,
-            cardAlias: paymentData.cardAlias,
-            accountKey: paymentData.accountKey,
-            amount: paymentData.amount,
-            orderNo: paymentData.orderNo,
-            currencyCode: paymentData.currencyCode,
-            paymentType: paymentData.paymentType,
-            acquirerIcaNumber: paymentData.acquirerIcaNumber,
-            installmentCount: paymentData.installmentCount,
-            authenticationMethod: paymentData.authenticationMethod,
-            secure3DModel: paymentData.secure3DModel,
-            terminalGroupId: paymentData.terminalGroupId
-          },
-          (statusCode, response) => {
-            if (response && response.statusCode === 200) {
-              resolve({
-                success: true,
-                data: response
-              });
-            } else {
-              resolve({
-                success: false,
-                error: response?.description || 'Payment failed',
-                data: response
-              });
-            }
+            window.Masterpass.paymentService.payment(
+              {
+                requestReferenceNo: paymentData.requestReferenceNo,
+                cvc: paymentData.cvc,
+                cardAlias: paymentData.cardAlias,
+                accountKey: paymentData.accountKey,
+                amount: paymentData.amount,
+                orderNo: paymentData.orderNo,
+                currencyCode: paymentData.currencyCode,
+                paymentType: paymentData.paymentType,
+                acquirerIcaNumber: paymentData.acquirerIcaNumber,
+                installmentCount: paymentData.installmentCount,
+                authenticationMethod: paymentData.authenticationMethod,
+                secure3DModel: paymentData.secure3DModel,
+                terminalGroupId: paymentData.terminalGroupId,
+                ...(paymentData.additionalFields || {})
+              },
+              (statusCode, response) => {
+                if (response && response.statusCode === 200) {
+                  resolve({
+                    success: true,
+                    data: response
+                  });
+                } else {
+                  resolve({
+                    success: false,
+                    error: response?.description || 'Payment failed',
+                    data: response
+                  });
+                }
+              }
+            );
+          } catch (error) {
+            resolve({
+              success: false,
+              error: this.extractErrorMessage(error, 'Payment service initialization failed')
+            });
+          }
+        }),
+      {
+        success: false,
+        error: 'Session has expired',
+        data: {
+          statusCode: 401,
+          exception: {
+            code: 'TOKEN_HAS_EXPIRED',
+            message: 'Session has expired'
           }
-        );
-      } catch (error) {
-        resolve({
-          success: false,
-          error: 'Payment service initialization failed'
-        });
+        }
       }
-    });
+    );
   }
 
   async directPayment(
     paymentData: DirectPaymentRequest
   ): Promise<PaymentResponse> {
-    return new Promise((resolve) => {
-      try {
-        this.initialize();
+    return withUnhandledRejectionHandler(
+      () =>
+        new Promise((resolve) => {
+          try {
+            this.initialize();
 
-        window.Masterpass.paymentService.directPayment(
-          {
-            requestReferenceNo: paymentData.requestReferenceNo,
-            cvc: paymentData.cvc,
-            cardNumber: paymentData.cardNumber,
-            cardHolderName: paymentData.cardHolderName,
-            expiryDate: paymentData.expiryDate,
-            accountKey: paymentData.accountKey,
-            amount: paymentData.amount,
-            orderNo: paymentData.orderNo,
-            currencyCode: paymentData.currencyCode,
-            paymentType: paymentData.paymentType,
-            acquirerIcaNumber: paymentData.acquirerIcaNumber,
-            installmentCount: paymentData.installmentCount,
-            authenticationMethod: paymentData.authenticationMethod,
-            secure3DModel: paymentData.secure3DModel,
-            terminalGroupId: paymentData.terminalGroupId
-          },
-          (statusCode: number, response: MPResponse<DirectPaymentResponse>) => {
-            if (response && response.statusCode === 200) {
-              resolve({
-                success: true,
-                data: response
-              });
-            } else {
-              resolve({
-                success: false,
-                error:
-                  response?.result?.responseDescription ||
-                  response?.exception?.message ||
-                  'Direct payment failed',
-                data: response
-              });
-            }
+            window.Masterpass.paymentService.directPayment(
+              {
+                requestReferenceNo: paymentData.requestReferenceNo,
+                cvc: paymentData.cvc,
+                cardNumber: paymentData.cardNumber,
+                cardHolderName: paymentData.cardHolderName,
+                expiryDate: paymentData.expiryDate,
+                accountKey: paymentData.accountKey,
+                amount: paymentData.amount,
+                orderNo: paymentData.orderNo,
+                currencyCode: paymentData.currencyCode,
+                paymentType: paymentData.paymentType,
+                acquirerIcaNumber: paymentData.acquirerIcaNumber,
+                installmentCount: paymentData.installmentCount,
+                authenticationMethod: paymentData.authenticationMethod,
+                secure3DModel: paymentData.secure3DModel,
+                terminalGroupId: paymentData.terminalGroupId,
+                ...(paymentData.additionalFields || {})
+              },
+              (
+                statusCode: number,
+                response: MPResponse<DirectPaymentResponse>
+              ) => {
+                if (response && response.statusCode === 200) {
+                  resolve({
+                    success: true,
+                    data: response
+                  });
+                } else {
+                  resolve({
+                    success: false,
+                    error:
+                      response?.result?.responseDescription ||
+                      response?.exception?.message ||
+                      'Direct payment failed',
+                    data: response
+                  });
+                }
+              }
+            );
+          } catch (error) {
+            resolve({
+              success: false,
+              error: this.extractErrorMessage(error, 'Direct payment service initialization failed')
+            });
+          }
+        }),
+      {
+        success: false,
+        error: 'Session has expired',
+        data: {
+          statusCode: 401,
+          exception: {
+            code: 'TOKEN_HAS_EXPIRED',
+            message: 'Session has expired'
           }
-        );
-      } catch (error) {
-        resolve({
-          success: false,
-          error: 'Direct payment service initialization failed'
-        });
+        }
       }
-    });
+    );
   }
 }

package/src/services/verify.ts

@@ -1,60 +1,60 @@
 import { MPResponse } from '../types/payment.types';
 import { VerifyRequest, VerifyResponse } from '../types/verify.types';
 import { store } from 'redux/store';
+import { createSessionExpiredResponse, withUnhandledRejectionHandler } from '../utils/session-handler';
 
 export class VerifyService {
-  constructor() {
-    this.initialize();
-  }
+  private _token: string;
+  private _merchantId: string;
 
-  private get token(): string {
-    return store.getState().masterpassRest.token || '';
-  }
-
-  private get decodedToken(): any {
-    return store.getState().masterpassRest.tokenData || '';
-  }
-
-  private get merchantId(): string {
-    return store.getState().masterpassRest.tokenData?.MerchantId || '';
+  constructor(token?: string, merchantId?: string) {
+    this._token = token || store.getState().masterpassRest.token || '';
+    this._merchantId = merchantId || store.getState().masterpassRest.tokenData?.MerchantId || '';
+    this.initialize();
   }
 
   private initialize(): void {
-    window.Masterpass.setToken(this.token);
-    window.Masterpass.setMerchantId(this.merchantId);
+    window.Masterpass.setToken(this._token);
+    window.Masterpass.setMerchantId(this._merchantId);
   }
 
   verifyOtp(request: VerifyRequest): Promise<MPResponse<VerifyResponse>> {
-    return new Promise((resolve, reject) => {
-      try {
-        this.initialize();
-
-        window.Masterpass.verifyService.verifyOtp(
-          request,
-          (statusCode, response) => {
-            resolve(response);
-          }
-        );
-      } catch (error) {
-        reject(error);
-      }
-    });
+    return withUnhandledRejectionHandler(
+      () => new Promise((resolve, reject) => {
+        try {
+          this.initialize();
+
+          window.Masterpass.verifyService.verifyOtp(
+            request,
+            (statusCode, response) => {
+              resolve(response);
+            }
+          );
+        } catch (error) {
+          reject(error);
+        }
+      }),
+      createSessionExpiredResponse<MPResponse<VerifyResponse>>()
+    );
   }
 
-  resendOtp(): Promise<MPResponse<VerifyResponse>> {
-    return new Promise((resolve, reject) => {
-      try {
-        this.initialize();
-
-        window.Masterpass.verifyService.resendOtp(
-          {token: this.token},
-          (statusCode, response) => {
-            resolve(response);
-          }
-        );
-      } catch (error) {
-        reject(error);
-      }
-    });
+  resendOtp(otpToken?: string): Promise<MPResponse<VerifyResponse>> {
+    return withUnhandledRejectionHandler(
+      () => new Promise((resolve, reject) => {
+        try {
+          this.initialize();
+
+          window.Masterpass.verifyService.resendOtp(
+            { token: otpToken || this._token },
+            (statusCode, response) => {
+              resolve(response);
+            }
+          );
+        } catch (error) {
+          reject(error);
+        }
+      }),
+      createSessionExpiredResponse<MPResponse<VerifyResponse>>()
+    );
   }
 }

package/src/types/custom-render.types.ts

@@ -51,8 +51,9 @@ export type LinkModalProps = {
 export type OTPModalProps = {
   open: boolean;
   onClose: () => void;
-  onSubmit: (otp: string) => Promise<{ success: boolean; message?: string }>;
+  onSubmit: (otp: string) => Promise<{ success: boolean; requiresOTP?: boolean; message?: string }>;
   type: 'RTA' | 'OTP' | 'CVV';
+  responseCode?: string;
   description?: string;
   texts: MasterpassRestOptionTexts;
 };
@@ -91,6 +92,7 @@ export type MasterpassRestOptionRenderProps = {
   hasStoredCards: boolean;
   shouldShowDirectForm: boolean;
   cvc: string;
+  error: any;
 
   accountData: any;
   accountStatus: any;
@@ -249,12 +251,30 @@ export type MasterpassRestOptionTexts = {
   whatIsMasterpassLink?: string;
 
   rtaVerificationTitle?: string;
-  cvvVerificationTitle?: string;
   rtaVerificationDescription?: string;
+  rtaVerificationPlaceholder?: string;
+
+  bankOtpVerificationTitle?: string;
+  bankOtpVerificationDescription?: string;
+  bankOtpVerificationPlaceholder?: string;
+
+  phoneVerificationTitle?: string;
+  phoneVerificationDescription?: string;
+  phoneVerificationPlaceholder?: string;
+
+  cvvVerificationTitle?: string;
   cvvVerificationDescription?: string;
+  cvvVerificationPlaceholder?: string;
+  cvvVerificationHelperText?: string;
+
   otpVerificationDescription?: string;
   verifyButton?: string;
   otpModalCancelButton?: string;
   otpModalErrorText?: string;
   otpModalResendOtpButton?: string;
+
+  sessionExpiredTitle?: string;
+  sessionExpiredMessage?: string;
+  sessionExpiredSecondaryMessage?: string;
+  sessionExpiredButton?: string;
 };

package/src/types/payment.types.ts

@@ -28,6 +28,7 @@ export interface PaymentProcessRequest {
   authenticationMethod: string;
   secure3DModel: string;
   terminalGroupId: string;
+  additionalFields?: any;
 }
 
 export interface OrderData {
@@ -79,10 +80,22 @@ export interface PaymentState {
   useThreeD: boolean;
 }
 
+export type InformationModalType = 'warning' | 'error' | 'success' | 'info';
+
+export interface InformationModalData {
+  type: InformationModalType;
+  title: string;
+  message: string;
+  secondaryMessage?: string;
+  buttonText: string;
+}
+
 export interface ModalState {
   showLinkModal: boolean;
   showOTPModal: boolean;
   show3DSecureModal: boolean;
+  showInformationModal: boolean;
+  informationModalData: InformationModalData | null;
   otpType: OTPType;
   verificationData: any | null;
   cardToDelete: any | null;
@@ -105,6 +118,7 @@ export interface DirectPaymentRequest {
   authenticationMethod: string;
   secure3DModel: string;
   terminalGroupId: string;
+  additionalFields?: any;
 }
 
 export interface DirectPaymentResponse {

package/src/utils/payment-constants.ts

@@ -10,11 +10,11 @@ export const PAYMENT_CONSTANTS = {
 
   EXCEPTION_CODES: {
     ACCOUNT_NOT_FOUND: 'ACCOUNT_NOT_FOUND',
-    ACCOUNT_NOT_LINKED_TO_MERCHANT: 'ACCOUNT_NOT_LINKED_TO_MERCHANT'
+    ACCOUNT_NOT_LINKED_TO_MERCHANT: 'ACCOUNT_NOT_LINKED_TO_MERCHANT',
+    TOKEN_HAS_EXPIRED: 'TOKEN_HAS_EXPIRED'
   },
 
   PAYMENT_CONFIG: {
-    ACQUIRER_ICA_NUMBER: '2030',
     PAYMENT_TYPE: 'Sale'
   },
 
@@ -27,5 +27,5 @@ export const PAYMENT_CONSTANTS = {
 } as const;
 
 export const CALLBACK_PATHS = {
-  RETURN: '/orders/masterpass-rest-callback/'
+  RETURN: '/orders/checkout/?page=MasterpassRestCompletePage&three_d_secure=true'
 } as const;