react-native-timacare 3.3.36 → 3.3.38

package/lib/commonjs/services/api/api.js.flow

@@ -7,6 +7,43 @@ import appStore from '../../AppStore';
 import axios from 'axios';
 import { load } from '../../utils/storage';
 import { getSDKConfig, SDKConfig } from '../../sdkConfig';
+import { Alert } from 'react-native';
+
+/**
+ * Retry tuning for weak / unstable networks.
+ * Only transient failures on idempotent requests are retried.
+ */
+const MAX_RETRIES = 3;
+const RETRY_BASE_DELAY = 1000; // ms, grows exponentially: 1s, 2s, 4s (+ jitter)
+
+/**
+ * Default timeout for idempotent GET requests. Kept short so reads fail fast
+ * on a weak network and let the retry interceptor take over, instead of
+ * hanging for the much longer upload/write timeout. Overridable via
+ * SDKConfig.getTimeout.
+ */
+const DEFAULT_GET_TIMEOUT = 30000; // 30s
+
+/**
+ * A failure is transient (worth retrying) when there is no response
+ * (timeout / connection drop) or the server is overloaded (5xx / 429).
+ */
+const isRetryableError = (error: any): boolean => {
+  if (!error || error.config?.__skipRetry) return false;
+  // No response object => network error or timeout (ECONNABORTED)
+  if (!error.response) return true;
+  const status = error.response.status;
+  return status >= 500 || status === 429;
+};
+
+/**
+ * GET/HEAD/OPTIONS are safe to replay. POST/PUT/etc. are NOT retried
+ * automatically to avoid duplicate side effects (double loan submit, double OTP).
+ */
+const isIdempotent = (method?: string): boolean => {
+  const m = (method || 'get').toLowerCase();
+  return m === 'get' || m === 'head' || m === 'options';
+};
 
 /**
  * Manages all requests to the API.
@@ -16,6 +53,24 @@ export class Api {
   apisauce: ApisauceInstance;
   apisauceFormData: ApisauceInstance;
   config: SDKConfig;
+
+  /**
+   * Flag to prevent multiple 401 logout calls at the same time.
+   * When multiple API calls return 401 simultaneously, only the first
+   * one will trigger logout.
+   */
+  private isLoggingOut: boolean = false;
+
+  /**
+   * Last known network connectivity, driven by the injected NetInfo module.
+   * Defaults to true (optimistic) so requests are never blocked when NetInfo
+   * is not provided or its first event hasn't arrived yet.
+   */
+  private isConnected: boolean = true;
+
+  /** Unsubscribe handle for the NetInfo listener, cleared on re-setup. */
+  private netInfoUnsubscribe?: () => void;
+
   /**
    * Configurable options.
    */
@@ -47,7 +102,53 @@ export class Api {
     return Api.instance;
   }
 
+  /**
+   * Handles 401 Unauthorized responses.
+   * Uses isLoggingOut flag to ensure Alert + logout is only triggered once
+   * even when multiple API calls return 401 simultaneously.
+   */
+  private handleUnauthorized = () => {
+    if (this.isLoggingOut) {
+      myLog('[API] 401 detected but logout already in progress, skipping...');
+      return;
+    }
+
+    this.isLoggingOut = true;
+    myLog('[API] 401 Unauthorized - triggering logout');
+
+    Alert.alert(
+      'Thông báo',
+      'Phiên đăng nhập hết hạn. Vui lòng đăng nhập lại',
+      [
+        {
+          text: 'Đồng ý',
+          onPress: () => {
+            try {
+              if (this.config.logout && typeof this.config.logout === 'function') {
+                this.config.logout();
+              } else {
+                myLog('[API] Warning: logout function not configured in SDKConfig');
+              }
+            } catch (error) {
+              myLog('[API] Error during logout:', error);
+            }
+          },
+        },
+      ]
+    );
+  };
+
+  /**
+   * Resets the logging out flag. Call this when the user logs in again.
+   */
+  public resetLogoutState() {
+    this.isLoggingOut = false;
+  }
+
   async setup() {
+    // Reset logout state on setup (e.g. when token changes after re-login)
+    this.isLoggingOut = false;
+
     // construct the apisauce instance
     // const token = await load("TOKEN_TIMACARE")
     this.apisauce = create({
@@ -71,6 +172,143 @@ export class Api {
         'Authorization': 'Bearer ' + this.config.token,
       },
     });
+
+    // Add 401 response interceptor to both apisauce instances
+    const unauthorizedMonitor = (response: ApiResponse<any>) => {
+      if (response.status === 401 || response.data?.meta?.errorCode === 401) {
+        this.handleUnauthorized();
+      }
+    };
+
+    this.apisauce.addMonitor(unauthorizedMonitor);
+    this.apisauceFormData.addMonitor(unauthorizedMonitor);
+
+    // Subscribe to connectivity changes (no-op if NetInfo isn't injected).
+    this.subscribeNetInfo();
+
+    // Request-side guards: fast-fail when offline + shorten GET timeouts.
+    // GET-timeout splitting only applies to the main instance; the form-data
+    // instance is used for uploads which legitimately need the long timeout.
+    this.attachRequestGuards(this.apisauce, true);
+    this.attachRequestGuards(this.apisauceFormData, false);
+
+    // Auto-retry transient failures on weak networks (timeouts, dropped
+    // connections, 5xx, 429). Applied to the underlying axios instance so
+    // apisauce still sees the final (successful or exhausted) response.
+    this.attachRetryInterceptor(this.apisauce);
+    this.attachRetryInterceptor(this.apisauceFormData);
+  }
+
+  /**
+   * Subscribes to the injected NetInfo module (if any) to track connectivity.
+   * Safe to call repeatedly — the previous listener is torn down first.
+   */
+  private subscribeNetInfo() {
+    if (this.netInfoUnsubscribe) {
+      try {
+        this.netInfoUnsubscribe();
+      } catch (e) {
+        myLog('[API] NetInfo unsubscribe error:', e);
+      }
+      this.netInfoUnsubscribe = undefined;
+    }
+
+    const netInfo = this.config.netInfo;
+    if (!netInfo) {
+      this.isConnected = true; // no NetInfo => never block on connectivity
+      return;
+    }
+
+    // Seed current state, then listen for changes.
+    netInfo
+      .fetch()
+      .then(state => {
+        this.isConnected = state.isConnected !== false;
+      })
+      .catch(() => {
+        this.isConnected = true;
+      });
+
+    this.netInfoUnsubscribe = netInfo.addEventListener(state => {
+      this.isConnected = state.isConnected !== false;
+    });
+  }
+
+  /**
+   * Attaches a request interceptor that:
+   *  1. Fast-fails when the device is known to be offline (avoids waiting for
+   *     a long timeout before the user sees an error).
+   *  2. Shortens the timeout for idempotent GETs on the main instance so reads
+   *     fail fast and hand off to the retry interceptor.
+   */
+  private attachRequestGuards(instance: ApisauceInstance, splitGetTimeout: boolean) {
+    const getTimeout = this.config.getTimeout || DEFAULT_GET_TIMEOUT;
+
+    instance.axiosInstance.interceptors.request.use((config: any) => {
+      // Offline fast-fail. apisauce converts this rejection into a normal
+      // CANNOT_CONNECT / NETWORK_ERROR problem, same as a timeout but instant.
+      if (this.config.netInfo && this.isConnected === false) {
+        myLog(`[API] Offline - skipping request: ${config.url}`);
+        return Promise.reject({
+          config,
+          message: 'Network offline',
+          __offline: true,
+        });
+      }
+
+      // Shorten GET timeouts unless the caller passed an explicit override.
+      if (
+        splitGetTimeout &&
+        isIdempotent(config.method) &&
+        config.timeout === this.config.timeout
+      ) {
+        config.timeout = getTimeout;
+      }
+
+      return config;
+    });
+  }
+
+  /**
+   * Attaches an exponential-backoff retry interceptor to an apisauce
+   * instance's axios layer. Only idempotent requests with transient
+   * errors are replayed, up to MAX_RETRIES times.
+   */
+  private attachRetryInterceptor(instance: ApisauceInstance) {
+    instance.axiosInstance.interceptors.response.use(
+      response => response,
+      async (error: any) => {
+        const config = error?.config;
+
+        if (
+          !config ||
+          !isIdempotent(config.method) ||
+          !isRetryableError(error)
+        ) {
+          return Promise.reject(error);
+        }
+
+        config.__retryCount = config.__retryCount || 0;
+        if (config.__retryCount >= MAX_RETRIES) {
+          myLog(`[API] Retry exhausted (${MAX_RETRIES}) for ${config.url}`);
+          return Promise.reject(error);
+        }
+
+        config.__retryCount += 1;
+
+        // Exponential backoff with jitter: 1s, 2s, 4s (+ up to 300ms)
+        const delay =
+          RETRY_BASE_DELAY * Math.pow(2, config.__retryCount - 1) +
+          Math.floor(Math.random() * 300);
+
+        myLog(
+          `[API] Retry ${config.__retryCount}/${MAX_RETRIES} in ${delay}ms: ${config.url}`
+        );
+
+        await new Promise(resolve => setTimeout(resolve, delay));
+        return instance.axiosInstance(config);
+      }
+    );
   }
 
   /**