react-native-timacare 3.3.37 → 3.3.39

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

@@ -9,6 +9,42 @@ 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.
  */
@@ -25,6 +61,16 @@ export class Api {
    */
   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.
    */
@@ -136,6 +182,133 @@ export class Api {
 
     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);
+      }
+    );
   }
 
   /**