fix(SDK-520): scope auth latch per-invocation and raise auth timeout default

- Replace shared authLatchResolver/pendingAuthResult with a per-invocation
  FIFO queue so overlapping handleAuthCalled invocations no longer drop
  successCallback/failureCallback
- Route native success/failure events to the oldest pending invocation and
  shift the queue synchronously on resolve
- Raise IterableConfig.authCallbackTimeoutMs default 1000 -> 6000 with
  rationale in TSDoc
- Remove dead AUTH_CALLBACK_TIMEOUT_DEFAULT_MS / ANDROID_WAKE_DELAY_DEFAULT_MS
  fallbacks; IterableConfig is the single source of truth
- Update Iterable.test.ts default assertions (1000 -> 6000), rework
  safety-net test to use a custom short timeout
- Add regression test: two back-to-back handleAuthCalled invocations assert
  both successCallbacks fire with no 'No callback received' warning
- Update CHANGELOG default

Author: jferrao-itrbl

CHANGELOG.md

@@ -17,8 +17,10 @@
   - Added `IterableConfig.androidWakeDelayMs` (default `1000`) to tune the
     Android deep-link wake delay before the SDK invokes `urlHandler`. Set to
     `0` to dispatch synchronously.
-  - Added `IterableConfig.authCallbackTimeoutMs` (default `1000`) to tune the
-    safety-net timeout for the auth callback latch.
+  - Added `IterableConfig.authCallbackTimeoutMs` (default `6000`) to tune the
+    safety-net timeout for the auth callback latch. The default is chosen to
+    comfortably exceed typical mobile auth round-trips while staying well
+    below the native 30s auth latch ceiling on both iOS and Android.
   - The auth callback gate is now event-driven: the native
     `handleAuthSuccessCalled` / `handleAuthFailureCalled` events resolve the
     latch immediately. The timer survives only as a fallback when no native

src/core/classes/Iterable.test.ts

@@ -24,6 +24,7 @@ import {
   IterableLogLevel,
 } from '../..';
 import { TestHelper } from '../../__tests__/TestHelper';
+import { IterableLogger } from './IterableLogger';
 
 describe('Iterable', () => {
   beforeEach(() => {
@@ -335,7 +336,7 @@ describe('Iterable', () => {
       expect(config.urlHandler).toBe(undefined);
       expect(config.useInMemoryStorageForInApps).toBe(false);
       expect(config.androidWakeDelayMs).toBe(1000);
-      expect(config.authCallbackTimeoutMs).toBe(1000);
+      expect(config.authCallbackTimeoutMs).toBe(6000);
       const configDict = config.toDict();
       expect(configDict.allowedProtocols).toEqual([]);
       expect(configDict.androidSdkUseInMemoryStorageForInApps).toBe(false);
@@ -353,7 +354,7 @@ describe('Iterable', () => {
       expect(configDict.urlHandlerPresent).toBe(false);
       expect(configDict.useInMemoryStorageForInApps).toBe(false);
       expect(configDict.androidWakeDelayMs).toBe(1000);
-      expect(configDict.authCallbackTimeoutMs).toBe(1000);
+      expect(configDict.authCallbackTimeoutMs).toBe(6000);
     });
 
     it('should allow overriding androidWakeDelayMs and authCallbackTimeoutMs', () => {
@@ -1801,9 +1802,12 @@ describe('Iterable', () => {
         IterableEventName.handleAuthFailureCalled
       );
 
-      // sets up config with authHandler that returns an AuthResponse
+      // sets up config with authHandler that returns an AuthResponse and a
+      // short safety-net timeout (default is 6000ms; we use 200ms here so
+      // the safety-net fires within the test window).
       const config = new IterableConfig();
       config.logReactNativeSdkCalls = false;
+      config.authCallbackTimeoutMs = 200;
       const successCallback = jest.fn();
       const failureCallback = jest.fn();
       const authResponse = new IterableAuthResponse();
@@ -1819,7 +1823,7 @@ describe('Iterable', () => {
       nativeEmitter.emit(IterableEventName.handleAuthCalled);
 
       // THEN the token is forwarded and neither callback fires
-      return await TestHelper.delayed(1100, () => {
+      return await TestHelper.delayed(300, () => {
         expect(MockRNIterableAPI.passAlongAuthToken).toBeCalledWith(
           'timeout-token'
         );
@@ -1905,5 +1909,94 @@ describe('Iterable', () => {
         expect(failureCallback).not.toBeCalled();
       });
     });
+
+    it('should resolve both callbacks when two handleAuthCalled invocations overlap (SDK-520 regression)', async () => {
+      // Regression for the shared-latch-state bug: when a second
+      // handleAuthCalled event arrives while the first invocation's race is
+      // still pending, the original code wiped the first invocation's
+      // resolver, so the first successCallback was silently dropped. With
+      // per-invocation latch state, both invocations must resolve.
+      const nativeEmitter = new NativeEventEmitter();
+      nativeEmitter.removeAllListeners(IterableEventName.handleAuthCalled);
+      nativeEmitter.removeAllListeners(
+        IterableEventName.handleAuthSuccessCalled
+      );
+      nativeEmitter.removeAllListeners(
+        IterableEventName.handleAuthFailureCalled
+      );
+
+      const config = new IterableConfig();
+      config.logReactNativeSdkCalls = false;
+      config.authCallbackTimeoutMs = 2000;
+
+      const successCallback1 = jest.fn();
+      const failureCallback1 = jest.fn();
+      const authResponse1 = new IterableAuthResponse();
+      authResponse1.authToken = 'overlap-token-1';
+      authResponse1.successCallback = successCallback1;
+      authResponse1.failureCallback = failureCallback1;
+
+      const successCallback2 = jest.fn();
+      const failureCallback2 = jest.fn();
+      const authResponse2 = new IterableAuthResponse();
+      authResponse2.authToken = 'overlap-token-2';
+      authResponse2.successCallback = successCallback2;
+      authResponse2.failureCallback = failureCallback2;
+
+      // Use controllable promises so we can wire both latches before any
+      // native success event arrives. This is the realistic overlap shape:
+      // the SDK is awaiting native auth round-trips for two back-to-back
+      // handleAuthCalled events.
+      let resolveAuth1: (value: IterableAuthResponse) => void = () => {};
+      let resolveAuth2: (value: IterableAuthResponse) => void = () => {};
+      let callCount = 0;
+      config.authHandler = jest.fn(() => {
+        callCount += 1;
+        return new Promise<IterableAuthResponse>((resolve) => {
+          if (callCount === 1) {
+            resolveAuth1 = resolve;
+          } else {
+            resolveAuth2 = resolve;
+          }
+        });
+      });
+
+      const logSpy = jest.spyOn(IterableLogger, 'log');
+
+      Iterable.initialize('apiKey', config);
+
+      // WHEN two handleAuthCalled events fire back-to-back (both invocations
+      // are now pending and awaiting their authHandler promises).
+      nativeEmitter.emit(IterableEventName.handleAuthCalled);
+      nativeEmitter.emit(IterableEventName.handleAuthCalled);
+
+      // Resolve both authHandler promises. After the microtask queue
+      // flushes, both invocations' latches are wired and racing their
+      // safety-net timers. We defer the native success emissions to the
+      // next tick so the latch executors have run.
+      resolveAuth1(authResponse1);
+      resolveAuth2(authResponse2);
+
+      // Then the corresponding native success events arrive in FIFO order.
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      nativeEmitter.emit(IterableEventName.handleAuthSuccessCalled);
+      nativeEmitter.emit(IterableEventName.handleAuthSuccessCalled);
+
+      // THEN both successCallbacks fire and no "No callback received"
+      // warning is logged.
+      return await TestHelper.delayed(100, () => {
+        expect(successCallback1).toBeCalled();
+        expect(successCallback2).toBeCalled();
+        expect(failureCallback1).not.toBeCalled();
+        expect(failureCallback2).not.toBeCalled();
+        const noCallbackCalls = logSpy.mock.calls.filter(
+          (args) =>
+            typeof args[0] === 'string' &&
+            args[0].includes('No callback received from native layer')
+        );
+        expect(noCallbackCalls).toHaveLength(0);
+        logSpy.mockRestore();
+      });
+    });
   });
 });

src/core/classes/Iterable.ts

@@ -27,20 +27,6 @@ const RNEventEmitter = new NativeEventEmitter(RNIterableAPI);
 
 const defaultConfig = new IterableConfig();
 
-/**
- * Fallback safety-net timeout for the auth callback latch when no native
- * auth success/failure event arrives. Overridable via
- * {@link IterableConfig.authCallbackTimeoutMs}.
- */
-const AUTH_CALLBACK_TIMEOUT_DEFAULT_MS = 1000;
-
-/**
- * Default delay (ms) the SDK waits on Android before invoking the URL handler
- * so the host Activity can wake from the background. Overridable via
- * {@link IterableConfig.androidWakeDelayMs}.
- */
-const ANDROID_WAKE_DELAY_DEFAULT_MS = 1000;
-
 /**
  * Checks if the response is an IterableAuthResponse
  */
@@ -1027,9 +1013,7 @@ export class Iterable {
           // dispatching the URL to the handler. Without this delay the
           // handler can race the activity lifecycle and drop the link on
           // cold start. Tunable via IterableConfig.androidWakeDelayMs.
-          const wakeDelayMs =
-            Iterable.savedConfig.androidWakeDelayMs ??
-            ANDROID_WAKE_DELAY_DEFAULT_MS;
+          const wakeDelayMs = Iterable.savedConfig.androidWakeDelayMs;
           if (wakeDelayMs > 0) {
             setTimeout(() => {
               callUrlHandler(Iterable.savedConfig, url, context);
@@ -1074,26 +1058,42 @@ export class Iterable {
         | IterableAuthResponseResult
         | typeof AUTH_RESULT_NO_CALLBACK;
 
-      // Event-driven auth latch. The native success/failure listeners
-      // resolve the latch when their event arrives; the safety-net timer
-      // resolves it only if no native event arrives within the configured
-      // window. The timer is a fallback — the latch resolves immediately
-      // when the native event fires.
+      // Per-invocation auth latch state. The native success/failure events
+      // resolve the latch when they arrive; the safety-net timer resolves it
+      // only if no native event arrives within the configured window. The
+      // timer is a fallback — the latch resolves immediately when the native
+      // event fires.
       //
-      // `pendingAuthResult` buffers a native result that arrives before the
+      // `pendingResult` buffers a native result that arrives before the
       // latch is created (e.g. the authHandler promise hasn't settled yet).
       // It is consumed when the latch is created, so out-of-order events
       // are not lost.
-      let authLatchResolver:
-        | ((result: IterableAuthResponseResult) => void)
-        | null = null;
-      let pendingAuthResult: IterableAuthResponseResult | null = null;
+      //
+      // State is scoped per `handleAuthCalled` invocation so overlapping
+      // invocations cannot wipe each other's resolver or buffered result
+      // (the bug with the original shared `authLatchResolver` /
+      // `pendingAuthResult` declarations). The bridge events carry no
+      // correlation id, so native success/failure events are routed to the
+      // oldest still-pending invocation in FIFO order — matching the
+      // original single-flight assumption that native processes auth
+      // requests in the order the SDK issues them.
+      type AuthInvocation = {
+        resolver:
+          | ((result: IterableAuthResponseResult) => void)
+          | null;
+        pendingResult: IterableAuthResponseResult | null;
+      };
+      const pendingAuthInvocations: AuthInvocation[] = [];
 
       RNEventEmitter.addListener(IterableEventName.handleAuthCalled, () => {
-        // Reset per-invocation state so a stale buffered result from a
-        // previous invocation cannot bleed into this one.
-        authLatchResolver = null;
-        pendingAuthResult = null;
+        // Start a fresh per-invocation state object so a stale buffered
+        // result or resolver from a previous invocation cannot bleed into
+        // this one.
+        const invocation: AuthInvocation = {
+          resolver: null,
+          pendingResult: null,
+        };
+        pendingAuthInvocations.push(invocation);
 
         // MOB-10423: Check if we can use chain operator (?.) here instead
         // Asks frontend of the client/app to pass authToken
@@ -1109,23 +1109,27 @@ export class Iterable {
             if (isIterableAuthResponse(promiseResult)) {
               Iterable.authManager.passAlongAuthToken(promiseResult.authToken);
 
+              // If this invocation was already removed (e.g. a buffered
+              // native result already resolved it via another path), do not
+              // wire a latch for it.
+              if (!pendingAuthInvocations.includes(invocation)) {
+                return;
+              }
+
               const nativeLatch = new Promise<IterableAuthResponseResult>(
                 (resolve) => {
-                  if (pendingAuthResult !== null) {
+                  if (invocation.pendingResult !== null) {
                     // A native event arrived before the latch was created;
                     // resolve immediately with the buffered result.
-                    const buffered = pendingAuthResult;
-                    pendingAuthResult = null;
-                    resolve(buffered);
+                    resolve(invocation.pendingResult);
+                    invocation.pendingResult = null;
                   } else {
-                    authLatchResolver = resolve;
+                    invocation.resolver = resolve;
                   }
                 }
               );
 
-              const timeoutMs =
-                Iterable.savedConfig.authCallbackTimeoutMs ??
-                AUTH_CALLBACK_TIMEOUT_DEFAULT_MS;
+              const timeoutMs = Iterable.savedConfig.authCallbackTimeoutMs;
               const timeoutLatch = new Promise<AuthLatchResult>((resolve) => {
                 setTimeout(
                   () => resolve(AUTH_RESULT_NO_CALLBACK),
@@ -1135,10 +1139,19 @@ export class Iterable {
 
               Promise.race<AuthLatchResult>([nativeLatch, timeoutLatch]).then(
                 (result) => {
-                  // Clear the resolver so a late native event after the timeout
-                  // is a no-op.
-                  authLatchResolver = null;
-                  pendingAuthResult = null;
+                  // Clear this invocation's resolver so a late native event
+                  // after the timeout is a no-op. Only touch this
+                  // invocation's state — other invocations own their own.
+                  invocation.resolver = null;
+                  invocation.pendingResult = null;
+                  // Defensive cleanup: if the native event did not remove
+                  // this invocation from the queue (e.g. the safety-net
+                  // timer won the race), remove it now so future native
+                  // events route to the next pending invocation.
+                  const index = pendingAuthInvocations.indexOf(invocation);
+                  if (index !== -1) {
+                    pendingAuthInvocations.splice(index, 1);
+                  }
                   if (result === IterableAuthResponseResult.SUCCESS) {
                     promiseResult.successCallback?.();
                   } else if (result === IterableAuthResponseResult.FAILURE) {
@@ -1170,32 +1183,46 @@ export class Iterable {
       RNEventEmitter.addListener(
         IterableEventName.handleAuthSuccessCalled,
         () => {
+          // Route to the oldest still-pending invocation (FIFO). The bridge
+          // events carry no correlation id; this matches the assumption
+          // that native processes auth requests in issuance order.
+          const invocation = pendingAuthInvocations[0];
+          if (!invocation) {
+            return;
+          }
           // Resolve the pending auth latch immediately; the timer becomes a
           // no-op for this invocation.
-          if (authLatchResolver) {
-            const resolve = authLatchResolver;
-            authLatchResolver = null;
-            pendingAuthResult = null;
+          if (invocation.resolver) {
+            const resolve = invocation.resolver;
+            invocation.resolver = null;
+            invocation.pendingResult = null;
+            // Remove synchronously so the next native event routes to the
+            // following pending invocation, not back to this one.
+            pendingAuthInvocations.shift();
             resolve(IterableAuthResponseResult.SUCCESS);
           } else {
             // Latch not created yet — buffer the result for the latch.
-            pendingAuthResult = IterableAuthResponseResult.SUCCESS;
+            invocation.pendingResult = IterableAuthResponseResult.SUCCESS;
           }
         }
       );
       RNEventEmitter.addListener(
         IterableEventName.handleAuthFailureCalled,
         (authFailureResponse: IterableAuthFailure) => {
-          // Resolve the pending auth latch immediately; the timer becomes a
-          // no-op for this invocation.
-          if (authLatchResolver) {
-            const resolve = authLatchResolver;
-            authLatchResolver = null;
-            pendingAuthResult = null;
-            resolve(IterableAuthResponseResult.FAILURE);
-          } else {
-            // Latch not created yet — buffer the result for the latch.
-            pendingAuthResult = IterableAuthResponseResult.FAILURE;
+          const invocation = pendingAuthInvocations[0];
+          if (invocation) {
+            // Resolve the pending auth latch immediately; the timer becomes a
+            // no-op for this invocation.
+            if (invocation.resolver) {
+              const resolve = invocation.resolver;
+              invocation.resolver = null;
+              invocation.pendingResult = null;
+              pendingAuthInvocations.shift();
+              resolve(IterableAuthResponseResult.FAILURE);
+            } else {
+              // Latch not created yet — buffer the result for the latch.
+              invocation.pendingResult = IterableAuthResponseResult.FAILURE;
+            }
           }
 
           // Call the actual JWT error with `authFailure` object.

src/core/classes/IterableConfig.ts

@@ -372,19 +372,24 @@ export class IterableConfig {
    * resolves immediately when the native event arrives.
    *
    * @remarks
-   * Increase this value on networks or devices where native auth round-trips
-   * are slow. Setting it too low can cause premature "no callback received"
-   * warnings. Setting it too high increases perceived auth latency only when
-   * the native layer fails to respond.
+   * The default (`6000`) is chosen to comfortably exceed a typical mobile
+   * auth round-trip (the native layer performs `passAlongAuthToken` plus a
+   * full HTTP round-trip to the Iterable backend, which routinely exceeds
+   * 1 s on real networks) while staying well below the native auth latch
+   * ceiling of 30 s on both iOS and Android. Setting it below typical
+   * round-trip latency causes the safety net to win the race and drop the
+   * late native `successCallback` / `failureCallback`; setting it too high
+   * increases perceived auth latency only when the native layer fails to
+   * respond.
    *
    * @example
    * ```typescript
    * const config = new IterableConfig();
-   * config.authCallbackTimeoutMs = 2000; // wait up to 2s for native auth events
+   * config.authCallbackTimeoutMs = 10000; // allow up to 10s for slow networks
    * Iterable.initialize('<YOUR_API_KEY>', config);
    * ```
    */
-  authCallbackTimeoutMs = 1000;
+  authCallbackTimeoutMs = 6000;
 
   /**
    * Should the SDK enable and use embedded messaging?