refactor: added warning if async storage is not found

packages/sdk/react-native/__tests__/ReactNativeLDClient.storage.test.ts

@@ -1,31 +1,84 @@
 import { AutoEnvAttributes, LDLogger } from '@launchdarkly/js-client-sdk-common';
 
+import PlatformStorage from '../src/platform/PlatformStorage';
 import ReactNativeLDClient from '../src/ReactNativeLDClient';
 
-it('uses custom storage', async () => {
-  // This test just validates that the custom storage instance is being called.
-  // Other tests validate how the SDK interacts with storage generally.
-  const logger: LDLogger = {
-    error: jest.fn(),
-    warn: jest.fn(),
-    info: jest.fn(),
-    debug: jest.fn(),
-  };
-  const myStorage = {
-    get: jest.fn(),
-    set: jest.fn(),
-    clear: jest.fn(),
-  };
-  const client = new ReactNativeLDClient('mobile-key', AutoEnvAttributes.Enabled, {
-    sendEvents: false,
-    initialConnectionMode: 'offline',
-    logger,
-    storage: myStorage,
+jest.mock('../src/platform/PlatformStorage', () => ({
+  __esModule: true,
+  default: jest.fn().mockImplementation((logger: LDLogger) => {
+    const ActualPlatformStorage = jest.requireActual('../src/platform/PlatformStorage').default;
+    return new ActualPlatformStorage(logger);
+  }),
+}));
+
+describe('ReactNativeLDClient storage', () => {
+  beforeEach(() => {
+    (PlatformStorage as jest.MockedClass<typeof PlatformStorage>).mockClear();
+  });
+
+  it('uses custom storage', async () => {
+    // This test just validates that the custom storage instance is being called.
+    // Other tests validate how the SDK interacts with storage generally.
+    const logger: LDLogger = {
+      error: jest.fn(),
+      warn: jest.fn(),
+      info: jest.fn(),
+      debug: jest.fn(),
+    };
+    const myStorage = {
+      get: jest.fn(),
+      set: jest.fn(),
+      clear: jest.fn(),
+    };
+    const client = new ReactNativeLDClient('mobile-key', AutoEnvAttributes.Enabled, {
+      sendEvents: false,
+      initialConnectionMode: 'offline',
+      logger,
+      storage: myStorage,
+    });
+
+    await client.identify({ key: 'potato', kind: 'user' }, { timeout: 15 });
+    expect(myStorage.get).toHaveBeenCalled();
+    expect(myStorage.clear).not.toHaveBeenCalled();
+    // Ensure the base client is not emitting a warning for this.
+    expect(logger.warn).not.toHaveBeenCalled();
+    // Ensure the default platform storage is not instantiated when custom storage is provided.
+    expect(PlatformStorage).not.toHaveBeenCalled();
   });
 
-  await client.identify({ key: 'potato', kind: 'user' }, { timeout: 15 });
-  expect(myStorage.get).toHaveBeenCalled();
-  expect(myStorage.clear).not.toHaveBeenCalled();
-  // Ensure the base client is not emitting a warning for this.
-  expect(logger.warn).not.toHaveBeenCalled();
+  it('uses default platform storage when no custom storage is provided', async () => {
+    const logger: LDLogger = {
+      error: jest.fn(),
+      warn: jest.fn(),
+      info: jest.fn(),
+      debug: jest.fn(),
+    };
+    const client = new ReactNativeLDClient('mobile-key', AutoEnvAttributes.Enabled, {
+      sendEvents: false,
+      initialConnectionMode: 'offline',
+      logger,
+    });
+
+    // Verify that PlatformStorage was instantiated
+    expect(PlatformStorage).toHaveBeenCalledWith(logger);
+    expect(PlatformStorage).toHaveBeenCalledTimes(1);
+
+    // Get the storage instance and spy on its methods
+    const mockResults = (PlatformStorage as jest.MockedClass<typeof PlatformStorage>).mock.results;
+    expect(mockResults.length).toBeGreaterThan(0);
+    const storageInstance = mockResults[0].value;
+    expect(storageInstance).toBeDefined();
+
+    const getSpy = jest.spyOn(storageInstance, 'get');
+    const setSpy = jest.spyOn(storageInstance, 'set');
+
+    await client.identify({ key: 'potato', kind: 'user' }, { timeout: 15 });
+
+    // Verify that storage methods are being called
+    expect(getSpy).toHaveBeenCalled();
+    expect(setSpy).toHaveBeenCalled();
+
+    getSpy.mockRestore();
+    setSpy.mockRestore();
+  });
 });

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

@@ -5,7 +5,7 @@
  * 2. added onopen, onclose, onerror, onretrying functions.
  * 3. modified dispatch to work with functions added in 2.
  * 4. replaced all for of loops with foreach
- * 
+ *
  * Additional changes:
  * 1. separated event handling to use onprogress for data changes
  *    and onreadystatechange for status changes. This is to address

packages/sdk/react-native/src/platform/ConditionalAsyncStorage.ts

@@ -1,4 +1,4 @@
-/* eslint-disable import/no-mutable-exports,global-require */
+/* eslint-disable global-require */
 
 /**
  * The LaunchDarkly React-Native SDK uses
@@ -15,17 +15,18 @@
  * https://github.com/react-native-community/cli/issues/1347
  *
  */
-let ConditionalAsyncStorage: any;
+import type { LDLogger } from '@launchdarkly/js-client-sdk-common';
 
-try {
-  ConditionalAsyncStorage = require('@react-native-async-storage/async-storage').default;
-} catch (e) {
-  // Use a mock if async-storage is unavailable
-  ConditionalAsyncStorage = {
-    getItem: (_key: string) => Promise.resolve(null),
-    setItem: (_key: string, _value: string) => Promise.resolve(),
-    removeItem: (_key: string) => Promise.resolve(),
-  };
+export default function getAsyncStorage(logger: LDLogger): any {
+  try {
+    return require('@react-native-async-storage/async-storage').default;
+  } catch (e) {
+    // Use a mock if async-storage is unavailable
+    logger.warn('AsyncStorage is not available, using a mock implementation.');
+    return {
+      getItem: (_key: string) => Promise.resolve(null),
+      setItem: (_key: string, _value: string) => Promise.resolve(),
+      removeItem: (_key: string) => Promise.resolve(),
+    };
+  }
 }
-
-export default ConditionalAsyncStorage;

packages/sdk/react-native/src/platform/PlatformStorage.ts

@@ -1,16 +1,20 @@
 import type { LDLogger, Storage } from '@launchdarkly/js-client-sdk-common';
 
-import AsyncStorage from './ConditionalAsyncStorage';
+import getAsyncStorage from './ConditionalAsyncStorage';
 
 export default class PlatformStorage implements Storage {
-  constructor(private readonly _logger: LDLogger) {}
+  private _asyncStorage: any;
+  constructor(private readonly _logger: LDLogger) {
+    this._asyncStorage = getAsyncStorage(_logger);
+  }
+
   async clear(key: string): Promise<void> {
-    await AsyncStorage.removeItem(key);
+    await this._asyncStorage.removeItem(key);
   }
 
   async get(key: string): Promise<string | null> {
     try {
-      const value = await AsyncStorage.getItem(key);
+      const value = await this._asyncStorage.getItem(key);
       return value ?? null;
     } catch (error) {
       this._logger.debug(`Error getting AsyncStorage key: ${key}, error: ${error}`);
@@ -20,7 +24,7 @@ export default class PlatformStorage implements Storage {
 
   async set(key: string, value: string): Promise<void> {
     try {
-      await AsyncStorage.setItem(key, value);
+      await this._asyncStorage.setItem(key, value);
     } catch (error) {
       this._logger.debug(`Error saving AsyncStorage key: ${key}, value: ${value}, error: ${error}`);
     }