up

Author: raju-opti

lib/event_processor/batch_event_processor.react_native.ts

@@ -14,10 +14,7 @@
  * limitations under the License.
  */
 
-import {
-  NetInfoState,
-  addEventListener as addConnectionListener,
-} from '@react-native-community/netinfo';
+import { NetInfoState, addEventListener } from '../utils/import.react_native/@react-native-community/netinfo';
 
 import { BatchEventProcessor, BatchEventProcessorConfig } from './batch_event_processor';
 import { Fn } from '../utils/type';
@@ -44,7 +41,9 @@ export class ReactNativeNetInfoEventProcessor extends BatchEventProcessor {
 
   start(): void {
     super.start();
-    this.unsubscribeNetInfo = addConnectionListener(this.connectionListener.bind(this));
+    if (addEventListener) {
+      this.unsubscribeNetInfo = addEventListener(this.connectionListener.bind(this));
+    }
   }
 
   stop(): void {

lib/event_processor/event_processor_factory.react_native.spec.ts

@@ -41,21 +41,48 @@ vi.mock('../utils/cache/cache', () => {
   return { SyncPrefixCache: vi.fn(), AsyncPrefixCache: vi.fn() };
 });
 
+vi.mock('@react-native-community/netinfo', () => {
+  return { NetInfoState: {}, addEventListener: vi.fn() };
+});
+
+let isNetInfoAvailable = false;
+
+await vi.hoisted(async () => {
+  await mockRequireNetInfo();
+});
+
+async function mockRequireNetInfo() {
+  const {Module} = await import('module');
+  const M: any = Module;
+
+  M._load_original = M._load;
+  M._load = (uri: string, parent: string) => {
+    if (uri === '@react-native-community/netinfo') {
+      if (isNetInfoAvailable) return {};
+      throw new Error('Module not found: @react-native-community/netinfo');
+    }
+    return M._load_original(uri, parent);
+  };
+}
+
 import { createForwardingEventProcessor, createBatchEventProcessor } from './event_processor_factory.react_native';
 import { getForwardingEventProcessor } from './forwarding_event_processor';
 import defaultEventDispatcher from './default_dispatcher.browser';
 import { EVENT_STORE_PREFIX, FAILED_EVENT_RETRY_INTERVAL } from './event_processor_factory';
 import { getBatchEventProcessor } from './event_processor_factory';
 import { AsyncCache, AsyncPrefixCache, SyncCache, SyncPrefixCache } from '../utils/cache/cache';
 import { AsyncStorageCache } from '../utils/cache/async_storage_cache.react_native';
+import { ReactNativeNetInfoEventProcessor } from './batch_event_processor.react_native';
+import { BatchEventProcessor } from './batch_event_processor';
 
 describe('createForwardingEventProcessor', () => {
   const mockGetForwardingEventProcessor = vi.mocked(getForwardingEventProcessor);
 
   beforeEach(() => {
     mockGetForwardingEventProcessor.mockClear();
+    isNetInfoAvailable = false;
   });
-    
+
   it('returns forwarding event processor by calling getForwardingEventProcessor with the provided dispatcher', () => {
     const eventDispatcher = {
       dispatchEvent: vi.fn(),
@@ -82,12 +109,26 @@ describe('createBatchEventProcessor', () => {
   const MockAsyncPrefixCache = vi.mocked(AsyncPrefixCache);
 
   beforeEach(() => {
+    isNetInfoAvailable = false;
     mockGetBatchEventProcessor.mockClear();
     MockAsyncStorageCache.mockClear();
     MockSyncPrefixCache.mockClear();
     MockAsyncPrefixCache.mockClear();
   });
 
+  it('returns an instance of ReacNativeNetInfoEventProcessor if netinfo can be required', async () => {
+    isNetInfoAvailable = true;
+    const processor = createBatchEventProcessor({});
+    expect(Object.is(processor, mockGetBatchEventProcessor.mock.results[0].value)).toBe(true);
+    expect(mockGetBatchEventProcessor.mock.calls[0][1]).toBe(ReactNativeNetInfoEventProcessor);
+  });
+
+  it('returns an instance of BatchEventProcessor if netinfo cannot be required', async () => {
+    isNetInfoAvailable = false;
+    const processor = createBatchEventProcessor({});;
+    expect(mockGetBatchEventProcessor.mock.calls[0][1]).toBe(BatchEventProcessor);
+  });
+
   it('uses AsyncStorageCache and AsyncPrefixCache to create eventStore if no eventStore is provided', () => {
     const processor = createBatchEventProcessor({});
 

lib/event_processor/event_processor_factory.react_native.ts

@@ -20,8 +20,10 @@ import defaultEventDispatcher from './default_dispatcher.browser';
 import { BatchEventProcessorOptions, getBatchEventProcessor, getPrefixEventStore } from './event_processor_factory';
 import { EVENT_STORE_PREFIX, FAILED_EVENT_RETRY_INTERVAL } from './event_processor_factory';
 import { AsyncPrefixCache } from '../utils/cache/cache';
-import { EventWithId } from './batch_event_processor';
+import { BatchEventProcessor, EventWithId } from './batch_event_processor';
 import { AsyncStorageCache } from '../utils/cache/async_storage_cache.react_native';
+import { ReactNativeNetInfoEventProcessor } from './batch_event_processor.react_native';
+import { isAvailable as isNetInfoAvailable } from '../utils/import.react_native/@react-native-community/netinfo';
 
 export const createForwardingEventProcessor = (
   eventDispatcher: EventDispatcher = defaultEventDispatcher,
@@ -59,5 +61,5 @@ export const createBatchEventProcessor = (
     },
     failedEventRetryInterval: FAILED_EVENT_RETRY_INTERVAL,
     eventStore,
-  });
+  }, isNetInfoAvailable() ? ReactNativeNetInfoEventProcessor : BatchEventProcessor);
 };

lib/utils/import.react_native/@react-native-community/netinfo.ts

@@ -0,0 +1,38 @@
+/**
+ * Copyright 2024, Optimizely
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { NetInfoSubscription, NetInfoChangeHandler } from '@react-native-community/netinfo';
+import { Maybe } from '../../type';
+
+export { NetInfoState } from '@react-native-community/netinfo';
+export type NetInfoAddEventListerType = (listener: NetInfoChangeHandler) => NetInfoSubscription;
+
+let addEventListener: Maybe<NetInfoAddEventListerType> = undefined;
+
+const requireNetInfo = () => {
+  try {
+    return require('@react-native-community/netinfo');
+  } catch (e) {
+    return undefined;
+  }
+}
+
+export const isAvailable = () => requireNetInfo() !== undefined;
+
+const netinfo = requireNetInfo();
+addEventListener = netinfo?.addEventListener;
+
+export { addEventListener };