fix: error responses are not propagated in RN eventsource

Author: joker23

packages/sdk/react-native/__tests__/fromExternal/react-native-sse/EventSource.test.ts

@@ -223,4 +223,149 @@ describe('EventSource', () => {
 
     expect(onopen).toHaveBeenCalledTimes(1);
   });
+
+  test('calls retryAndHandleError with parsed response headers on an error response', () => {
+    const retryAndHandleError = jest.fn(() => false);
+
+    mockXhr.getAllResponseHeaders = jest.fn(
+      () => 'X-Ld-Fd-Fallback: true\r\nX-Ld-Fd-Fallback-Ttl: 60\r\nContent-Type: text/event-stream',
+    );
+    mockXhr.responseText = 'error body';
+
+    const es = new EventSource<EventName>(uri, { logger, retryAndHandleError });
+    es.onerror = jest.fn();
+
+    jest.runAllTimers();
+
+    mockXhr.readyState = 4;
+    mockXhr.status = 500;
+    mockXhr.onreadystatechange();
+
+    expect(retryAndHandleError).toHaveBeenCalledTimes(1);
+    expect(retryAndHandleError).toHaveBeenCalledWith(
+      expect.objectContaining({
+        status: 500,
+        message: 'error body',
+        headers: expect.objectContaining({
+          'x-ld-fd-fallback': 'true',
+          'x-ld-fd-fallback-ttl': '60',
+        }),
+      }),
+    );
+  });
+
+  test('dispatches error with status and headers from onprogress mid-stream', () => {
+    const onerror = jest.fn();
+
+    mockXhr.getAllResponseHeaders = jest.fn(
+      () => 'X-Ld-Fd-Fallback: true\r\nX-Ld-Fd-Fallback-Ttl: 60\r\nContent-Type: text/event-stream',
+    );
+    mockXhr.responseText = 'error body';
+
+    eventSource.onerror = onerror;
+
+    jest.runAllTimers();
+
+    // readyState 3 (LOADING), not DONE, so this exercises onprogress's
+    // error branch rather than onreadystatechange's.
+    mockXhr.readyState = 3;
+    mockXhr.status = 500;
+    mockXhr.onprogress();
+
+    expect(onerror).toHaveBeenCalledWith(
+      expect.objectContaining({
+        status: 500,
+        headers: expect.objectContaining({
+          'x-ld-fd-fallback': 'true',
+          'x-ld-fd-fallback-ttl': '60',
+        }),
+      }),
+    );
+  });
+
+  test('dispatches error with status and headers from onreadystatechange before retrying', () => {
+    const onerror = jest.fn();
+
+    mockXhr.getAllResponseHeaders = jest.fn(
+      () => 'X-Ld-Fd-Fallback: true\r\nX-Ld-Fd-Fallback-Ttl: 60\r\nContent-Type: text/event-stream',
+    );
+    mockXhr.responseText = 'error body';
+
+    eventSource.onerror = onerror;
+
+    jest.runAllTimers();
+
+    mockXhr.readyState = 4;
+    mockXhr.status = 500;
+    mockXhr.onreadystatechange();
+
+    expect(onerror).toHaveBeenCalledWith(
+      expect.objectContaining({
+        status: 500,
+        headers: expect.objectContaining({
+          'x-ld-fd-fallback': 'true',
+          'x-ld-fd-fallback-ttl': '60',
+        }),
+      }),
+    );
+  });
+
+  test('invokes retryAndHandleError from onprogress when the connection never reaches DONE', () => {
+    const retryAndHandleError = jest.fn(() => false);
+
+    mockXhr.getAllResponseHeaders = jest.fn(
+      () => 'X-Ld-Fd-Fallback: true\r\nX-Ld-Fd-Fallback-Ttl: 60\r\nContent-Type: text/event-stream',
+    );
+    mockXhr.responseText = 'error body';
+
+    const es = new EventSource<EventName>(uri, { logger, retryAndHandleError });
+    es.onerror = jest.fn();
+
+    jest.runAllTimers();
+
+    // readyState never advances to DONE for this attempt, so
+    // onreadystatechange never fires; onprogress must drive the retry
+    // on its own.
+    mockXhr.readyState = 3;
+    mockXhr.status = 500;
+    mockXhr.onprogress();
+
+    expect(retryAndHandleError).toHaveBeenCalledTimes(1);
+    expect(retryAndHandleError).toHaveBeenCalledWith(
+      expect.objectContaining({
+        status: 500,
+        message: 'error body',
+        headers: expect.objectContaining({
+          'x-ld-fd-fallback': 'true',
+          'x-ld-fd-fallback-ttl': '60',
+        }),
+      }),
+    );
+  });
+
+  test('does not invoke retryAndHandleError twice when onprogress and onreadystatechange observe the same failed attempt', () => {
+    const retryAndHandleError = jest.fn(() => false);
+
+    mockXhr.getAllResponseHeaders = jest.fn(
+      () => 'X-Ld-Fd-Fallback: true\r\nX-Ld-Fd-Fallback-Ttl: 60\r\nContent-Type: text/event-stream',
+    );
+    mockXhr.responseText = 'error body';
+
+    const es = new EventSource<EventName>(uri, { logger, retryAndHandleError });
+    es.onerror = jest.fn();
+
+    jest.runAllTimers();
+
+    // onprogress observes the error first (LOADING), then the same response
+    // reaches DONE via onreadystatechange. retryAndHandleError must fire
+    // exactly once for this attempt despite both handlers seeing the error.
+    mockXhr.readyState = 3;
+    mockXhr.status = 500;
+    mockXhr.onprogress();
+
+    mockXhr.readyState = 4;
+    mockXhr.onreadystatechange();
+
+    expect(retryAndHandleError).toHaveBeenCalledTimes(1);
+  });
 });

packages/sdk/react-native/src/fromExternal/react-native-sse/EventSource.ts

@@ -18,6 +18,12 @@
  *    the stream was actually running. onprogress fires as soon as the response
  *    starts loading, so headers are available as soon as the connection opens
  *    instead of only at teardown.
+ * 3. onprogress now also drives retryAndHandleError/reconnect on an error status,
+ *    guarded exactly-once against onreadystatechange (see isFirstErrorForThisAttempt
+ *    below). Previously only onreadystatechange reaching DONE could trigger a retry,
+ *    so an error response that never reached DONE - the same never-fires-
+ *    readystatechange-while-streaming platforms note 1 above describes - would never
+ *    recover or have its response headers (e.g. an FDv1 fallback directive) read.
  */
 import type { EventSourceEvent, EventSourceListener, EventSourceOptions, EventType } from './types';
 
@@ -177,14 +183,40 @@ export default class EventSource<E extends string = never> {
 
           this._handleEvent(this._xhr.responseText || '');
         } else {
+          const isFirstErrorForThisAttempt = this._status !== this.ERROR;
           this._status = this.ERROR;
+          const headers = this._parseResponseHeaders(this._xhr.getAllResponseHeaders());
 
           this.dispatch('error', {
             type: 'error',
             message: this._xhr.responseText,
             xhrStatus: this._xhr.status,
             xhrState: this._xhr.readyState,
+            status: this._xhr.status,
+            headers,
           });
+
+          // A bad status observed here may never be followed by a DONE
+          // readystatechange: a streaming error response, or a platform
+          // that does not fire readystatechange reliably, leaves
+          // onreadystatechange silent. Retry from onprogress too, guarded
+          // so a later DONE for the same attempt does not trigger a second
+          // retry.
+          if (isFirstErrorForThisAttempt) {
+            if (!this._retryAndHandleError) {
+              this._tryConnect();
+            } else {
+              const shouldRetry = this._retryAndHandleError({
+                status: this._xhr.status,
+                message: this._xhr.responseText,
+                headers,
+              });
+
+              if (shouldRetry) {
+                this._tryConnect();
+              }
+            }
+          }
         }
       };
 
@@ -226,30 +258,46 @@ export default class EventSource<E extends string = never> {
             this._tryConnect();
           }
         } else {
+          // Mirrors onprogress's error-retry guard: if onprogress already
+          // retried for this attempt's error, this DONE for the same attempt
+          // must not trigger a second retry. This also relies on
+          // readystatechange(DONE) firing before the native onerror handler
+          // for the same failed request - onerror sets _status = ERROR
+          // without retrying, so if it ran first this guard would
+          // incorrectly suppress the retry below. XHR fires
+          // readystatechange(DONE) before error, and RN follows that
+          // ordering, so this holds today.
+          const isFirstErrorForThisAttempt = this._status !== this.ERROR;
           this._status = this.ERROR;
+          const headers = this._parseResponseHeaders(this._xhr.getAllResponseHeaders());
 
           this.dispatch('error', {
             type: 'error',
             message: this._xhr.responseText,
             xhrStatus: this._xhr.status,
             xhrState: this._xhr.readyState,
+            status: this._xhr.status,
+            headers,
           });
 
           if (this._xhr.readyState === XMLHttpRequest.DONE) {
             this._logger?.debug('[EventSource][onreadystatechange][ERROR] Response status error.');
 
-            if (!this._retryAndHandleError) {
-              // by default just try and reconnect if there's an error.
-              this._tryConnect();
-            } else {
-              // custom retry logic taking into account status codes.
-              const shouldRetry = this._retryAndHandleError({
-                status: this._xhr.status,
-                message: this._xhr.responseText,
-              });
-
-              if (shouldRetry) {
+            if (isFirstErrorForThisAttempt) {
+              if (!this._retryAndHandleError) {
+                // by default just try and reconnect if there's an error.
                 this._tryConnect();
+              } else {
+                // custom retry logic taking into account status codes.
+                const shouldRetry = this._retryAndHandleError({
+                  status: this._xhr.status,
+                  message: this._xhr.responseText,
+                  headers,
+                });
+
+                if (shouldRetry) {
+                  this._tryConnect();
+                }
               }
             }
           }

packages/sdk/react-native/src/fromExternal/react-native-sse/types.ts

@@ -31,6 +31,15 @@ export interface ErrorEvent {
   message: string;
   xhrState: number;
   xhrStatus: number;
+  /**
+   * Present when the error corresponds to an HTTP response with a numeric
+   * status, as opposed to a network-level failure with no response at all.
+   * Consumers' `errorFilter`/`onerror` handlers rely on this to tell an
+   * HTTP-status error apart from a network error.
+   */
+  status?: number;
+  /** Parsed response headers, present under the same condition as `status`. */
+  headers?: Record<string, string>;
 }
 
 export interface CustomEvent<E extends string> {