react-amwal-pay 0.1.16 → 0.1.18

package/src/AmwalPaySDK.ts

@@ -5,17 +5,21 @@ import {
   type AmwalPayConfig,
 } from './index';
 import NetworkClient from './network/NetworkClient';
+import Logger from './utils/Logger';
 import { type EventSubscription } from 'react-native';
 
 class AmwalPaySDK {
   private static instance: AmwalPaySDK;
+  private logger: Logger;
 
   private onResponseSubscription: EventSubscription | null = null;
 
   private onCustomerIdSubscription: EventSubscription | null = null;
 
   private constructor() {
-    // Initialize the event emitter
+    // Initialize the logger
+    this.logger = Logger.getInstance();
+    this.logger.info('AmwalPaySDK', 'SDK instance created');
   }
 
   static getInstance(): AmwalPaySDK {
@@ -25,6 +29,32 @@ class AmwalPaySDK {
     return AmwalPaySDK.instance;
   }
 
+  /**
+   * Enable or disable debug logging
+   */
+  setDebugEnabled(enabled: boolean): void {
+    this.logger.setDebugEnabled(enabled);
+    this.logger.info(
+      'AmwalPaySDK',
+      `Debug logging ${enabled ? 'enabled' : 'disabled'}`
+    );
+  }
+
+  /**
+   * Get SDK logs for debugging purposes
+   */
+  getLogs(): string {
+    return this.logger.exportLogs();
+  }
+
+  /**
+   * Clear all SDK logs
+   */
+  clearLogs(): void {
+    this.logger.clearLogs();
+    this.logger.info('AmwalPaySDK', 'Logs cleared');
+  }
+
   /**
    * Initiates the payment process by first fetching a session token and then starting the payment flow
    * @param config The payment configuration
@@ -33,6 +63,12 @@ class AmwalPaySDK {
     config: Omit<AmwalPayConfig, 'sessionToken'>
   ): Promise<void> {
     try {
+      this.logger.info('AmwalPaySDK', 'Starting payment process', {
+        merchantId: config.merchantId,
+        customerId: config.customerId,
+        environment: config.environment,
+      });
+
       // Set up event listeners before starting the payment process
       this.setupEventListeners(config);
 
@@ -40,10 +76,11 @@ class AmwalPaySDK {
       const networkClient = NetworkClient.getInstance();
 
       // Fetch session token
-      console.log(
-        'Fetching session token for environment:',
-        config.environment
-      );
+      this.logger.debug('AmwalPaySDK', 'Fetching session token', {
+        environment: config.environment,
+        merchantId: config.merchantId,
+      });
+
       const sessionToken = await networkClient.fetchSessionToken(
         config.environment,
         config.merchantId,
@@ -51,13 +88,13 @@ class AmwalPaySDK {
         config.secureHash
       );
 
-      console.log('Session token result:', sessionToken ? 'Success' : 'Failed');
-
       if (!sessionToken) {
-        // If session token is null, the error has already been shown by NetworkClient
+        this.logger.error('AmwalPaySDK', 'Failed to fetch session token');
         return;
       }
 
+      this.logger.info('AmwalPaySDK', 'Session token fetched successfully');
+
       // Create complete config with session token
       const completeConfig: AmwalPayConfig = {
         ...config,
@@ -65,17 +102,21 @@ class AmwalPaySDK {
       };
 
       // Initiate the payment process
-      console.log(
-        'Initiating native payment with config:',
-        JSON.stringify(completeConfig)
+      this.logger.debug(
+        'AmwalPaySDK',
+        'Initiating native payment',
+        completeConfig
       );
       initiate(completeConfig);
+
+      this.logger.info('AmwalPaySDK', 'Payment process initiated successfully');
     } catch (error) {
-      console.error('Error starting payment:', error);
+      this.logger.error('AmwalPaySDK', 'Error starting payment', error);
     }
   }
 
   dispose(): void {
+    this.logger.info('AmwalPaySDK', 'Disposing SDK instance');
     // Remove all event listeners
     this.removeEventListeners();
   }
@@ -90,43 +131,46 @@ class AmwalPaySDK {
     // Remove any existing listeners
     this.removeEventListeners();
 
-    console.log('🟢 Setting up event listeners...');
-    console.log(
-      '🟢 onResponse callback exists?',
-      typeof config.onResponse === 'function'
-    );
-    console.log(
-      '🟢 onCustomerId callback exists?',
-      typeof config.onCustomerId === 'function'
-    );
+    this.logger.debug('AmwalPaySDK', 'Setting up event listeners', {
+      hasOnResponse: typeof config.onResponse === 'function',
+      hasOnCustomerId: typeof config.onCustomerId === 'function',
+    });
 
     this.onResponseSubscription = onResponse((response) => {
-      console.log('🟢 SDK onResponse listener triggered with:', response);
-      console.log('Received AmwalPayResponse:', response);
+      this.logger.info('AmwalPaySDK', 'Received payment response', response);
       if (config.onResponse) {
         config.onResponse(response);
       } else {
-        console.error('❌ config.onResponse is not a function!');
+        this.logger.error(
+          'AmwalPaySDK',
+          'onResponse callback is not a function'
+        );
       }
     });
 
     this.onCustomerIdSubscription = onCustomerId((customerId) => {
-      console.log('🟢 SDK onCustomerId listener triggered with:', customerId);
-      console.log('Received customerId:', customerId);
+      this.logger.info('AmwalPaySDK', 'Received customer ID', { customerId });
       if (config.onCustomerId) {
         config.onCustomerId(customerId);
       } else {
-        console.error('❌ config.onCustomerId is not a function!');
+        this.logger.error(
+          'AmwalPaySDK',
+          'onCustomerId callback is not a function'
+        );
       }
     });
 
-    console.log('🟢 Event listeners set up complete');
+    this.logger.debug('AmwalPaySDK', 'Event listeners setup completed');
   }
 
   /**
    * Removes all event listeners
    */
   private removeEventListeners(): void {
+    if (this.onResponseSubscription || this.onCustomerIdSubscription) {
+      this.logger.debug('AmwalPaySDK', 'Removing event listeners');
+    }
+
     this.onResponseSubscription?.remove();
     this.onCustomerIdSubscription?.remove();
     this.onResponseSubscription = null;

package/src/index.tsx

@@ -8,6 +8,7 @@ import ReactAmwalPay, {
 } from './NativeReactAmwalPay';
 import AmwalPaySDK from './AmwalPaySDK';
 import { UuidUtil } from './utils/UuidUtil';
+import Logger, { LogLevel, type LogEntry } from './utils/Logger';
 import { NativeEventEmitter, type EventSubscription } from 'react-native';
 
 // Create an event emitter for the native module
@@ -63,4 +64,7 @@ export {
   type AmwalPayConfig,
   AmwalPaySDK,
   UuidUtil,
+  Logger,
+  LogLevel,
+  type LogEntry,
 };

package/src/network/NetworkClient.ts

@@ -1,11 +1,15 @@
 import { Alert } from 'react-native';
 import { Environment } from '../NativeReactAmwalPay';
 import SecureHashUtil from '../utils/SecureHashUtil';
+import Logger from '../utils/Logger';
 
 class NetworkClient {
   private static instance: NetworkClient;
+  private logger: Logger;
 
-  private constructor() {}
+  private constructor() {
+    this.logger = Logger.getInstance();
+  }
 
   static getInstance(): NetworkClient {
     if (!NetworkClient.instance) {
@@ -15,16 +19,19 @@ class NetworkClient {
   }
 
   private getWebhookUrl(env: Environment): string {
-    switch (env) {
-      case Environment.SIT:
-        return 'https://test.amwalpg.com:24443/';
-      case Environment.UAT:
-        return 'https://test.amwalpg.com:14443/';
-      case Environment.PROD:
-        return 'https://webhook.amwalpg.com/';
-      default:
-        return 'https://test.amwalpg.com:24443/';
-    }
+    const urls = {
+      [Environment.SIT]: 'https://test.amwalpg.com:24443/',
+      [Environment.UAT]: 'https://test.amwalpg.com:14443/',
+      [Environment.PROD]: 'https://webhook.amwalpg.com/',
+    };
+
+    const url = urls[env] || urls[Environment.SIT];
+    this.logger.debug(
+      'NetworkClient',
+      `Using webhook URL for ${Environment[env]}`,
+      { url }
+    );
+    return url;
   }
 
   async fetchSessionToken(
@@ -34,6 +41,12 @@ class NetworkClient {
     secureHashValue: string
   ): Promise<string | null> {
     try {
+      this.logger.info('NetworkClient', 'Fetching session token', {
+        environment: Environment[env],
+        merchantId,
+        hasCustomerId: !!customerId,
+      });
+
       const webhookUrl = this.getWebhookUrl(env);
 
       const dataMap = {
@@ -46,6 +59,11 @@ class NetworkClient {
         dataMap
       );
 
+      this.logger.debug('NetworkClient', 'Making API request', {
+        url: `${webhookUrl}Membership/GetSDKSessionToken`,
+        method: 'POST',
+      });
+
       const response = await fetch(
         `${webhookUrl}Membership/GetSDKSessionToken`,
         {
@@ -65,21 +83,35 @@ class NetworkClient {
 
       const responseData = await response.json();
 
+      this.logger.debug('NetworkClient', 'API response received', {
+        status: response.status,
+        ok: response.ok,
+        success: responseData.success,
+      });
+
       if (response.ok && responseData.success) {
+        this.logger.info('NetworkClient', 'Session token fetched successfully');
         return responseData.data.sessionToken;
       } else {
         const errorMessage =
           responseData.errorList?.join(',') || 'Unknown error';
+        this.logger.error('NetworkClient', 'API request failed', {
+          status: response.status,
+          errorMessage,
+          responseData,
+        });
         this.showErrorDialog(errorMessage);
         return null;
       }
     } catch (error) {
+      this.logger.error('NetworkClient', 'Network request failed', error);
       this.showErrorDialog('Something Went Wrong');
       return null;
     }
   }
 
   private showErrorDialog(message: string): void {
+    this.logger.warn('NetworkClient', 'Showing error dialog', { message });
     Alert.alert('Error', message, [{ text: 'OK' }]);
   }
 }

package/src/utils/Logger.ts

@@ -0,0 +1,162 @@
+/**
+ * Logger utility for AmwalPay SDK
+ * Provides structured logging with different levels and optional debug mode
+ */
+
+export enum LogLevel {
+  DEBUG = 0,
+  INFO = 1,
+  WARN = 2,
+  ERROR = 3,
+}
+
+export interface LogEntry {
+  timestamp: string;
+  level: LogLevel;
+  tag: string;
+  message: string;
+  data?: any;
+}
+
+class Logger {
+  private static instance: Logger;
+  private isDebugEnabled: boolean = __DEV__;
+  private logLevel: LogLevel = LogLevel.INFO;
+  private logs: LogEntry[] = [];
+  private maxLogEntries: number = 1000;
+
+  private constructor() {}
+
+  static getInstance(): Logger {
+    if (!Logger.instance) {
+      Logger.instance = new Logger();
+    }
+    return Logger.instance;
+  }
+
+  /**
+   * Enable or disable debug logging
+   */
+  setDebugEnabled(enabled: boolean): void {
+    this.isDebugEnabled = enabled;
+  }
+
+  /**
+   * Set minimum log level
+   */
+  setLogLevel(level: LogLevel): void {
+    this.logLevel = level;
+  }
+
+  /**
+   * Log debug message
+   */
+  debug(tag: string, message: string, data?: any): void {
+    this.log(LogLevel.DEBUG, tag, message, data);
+  }
+
+  /**
+   * Log info message
+   */
+  info(tag: string, message: string, data?: any): void {
+    this.log(LogLevel.INFO, tag, message, data);
+  }
+
+  /**
+   * Log warning message
+   */
+  warn(tag: string, message: string, data?: any): void {
+    this.log(LogLevel.WARN, tag, message, data);
+  }
+
+  /**
+   * Log error message
+   */
+  error(tag: string, message: string, data?: any): void {
+    this.log(LogLevel.ERROR, tag, message, data);
+  }
+
+  /**
+   * Internal logging method
+   */
+  private log(level: LogLevel, tag: string, message: string, data?: any): void {
+    if (level < this.logLevel) {
+      return;
+    }
+
+    const timestamp = new Date().toISOString();
+    const logEntry: LogEntry = {
+      timestamp,
+      level,
+      tag,
+      message,
+      data,
+    };
+
+    // Store log entry
+    this.logs.push(logEntry);
+
+    // Maintain max log entries
+    if (this.logs.length > this.maxLogEntries) {
+      this.logs.shift();
+    }
+
+    // Console output
+    if (this.isDebugEnabled || level >= LogLevel.WARN) {
+      const levelStr = LogLevel[level];
+      const prefix = `[AmwalPay][${levelStr}][${tag}]`;
+
+      switch (level) {
+        case LogLevel.DEBUG:
+          console.debug(prefix, message, data || '');
+          break;
+        case LogLevel.INFO:
+          console.info(prefix, message, data || '');
+          break;
+        case LogLevel.WARN:
+          console.warn(prefix, message, data || '');
+          break;
+        case LogLevel.ERROR:
+          console.error(prefix, message, data || '');
+          break;
+      }
+    }
+  }
+
+  /**
+   * Get all stored logs
+   */
+  getLogs(): LogEntry[] {
+    return [...this.logs];
+  }
+
+  /**
+   * Get logs filtered by level
+   */
+  getLogsByLevel(level: LogLevel): LogEntry[] {
+    return this.logs.filter((log) => log.level === level);
+  }
+
+  /**
+   * Get logs filtered by tag
+   */
+  getLogsByTag(tag: string): LogEntry[] {
+    return this.logs.filter((log) => log.tag === tag);
+  }
+
+  /**
+   * Clear all stored logs
+   */
+  clearLogs(): void {
+    this.logs = [];
+  }
+
+  /**
+   * Export logs as JSON string
+   */
+  exportLogs(): string {
+    return JSON.stringify(this.logs, null, 2);
+  }
+}
+
+export default Logger;