mixpanel-react-native 3.0.9 → 3.1.0

package/__tests__/persistent.test.js

@@ -0,0 +1,268 @@
+// We need to test the actual module behavior, not mocked behavior
+// So we'll use jest.isolateModules to get a fresh instance
+describe("MixpanelPersistent - UUID Generation", () => {
+  const token = "test-token";
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should fallback to uuid.v4() when expo-crypto throws", async () => {
+    let mixpanelPersistent;
+    
+    await jest.isolateModules(async () => {
+      // Mock expo-crypto to throw an error
+      jest.doMock("expo-crypto", () => ({
+        randomUUID: jest.fn(() => {
+          throw new Error("Expo crypto not available");
+        }),
+      }));
+
+      // Mock uuid to return a specific value
+      jest.doMock("uuid", () => ({
+        v4: jest.fn(() => "fallback-uuid-1234"),
+      }));
+
+      // Now require the modules
+      const { MixpanelPersistent } = require("mixpanel-react-native/javascript/mixpanel-persistent");
+      const { randomUUID } = require("expo-crypto");
+      const uuid = require("uuid");
+
+      // Create instance
+      MixpanelPersistent.instance = null;
+      mixpanelPersistent = MixpanelPersistent.getInstance(null, token);
+
+      // Load device ID (which triggers UUID generation)
+      await mixpanelPersistent.loadDeviceId(token);
+
+      // Verify randomUUID was called
+      expect(randomUUID).toHaveBeenCalled();
+
+      // Verify uuid.v4 was called as fallback
+      expect(uuid.v4).toHaveBeenCalled();
+
+      // Verify the device ID was set to the fallback value
+      expect(mixpanelPersistent.getDeviceId(token)).toBe("fallback-uuid-1234");
+    });
+  });
+
+  it("should use expo-crypto randomUUID when available", async () => {
+    let mixpanelPersistent;
+    
+    await jest.isolateModules(async () => {
+      // Mock expo-crypto to return a specific value
+      jest.doMock("expo-crypto", () => ({
+        randomUUID: jest.fn(() => "expo-uuid-5678"),
+      }));
+
+      // Mock uuid
+      jest.doMock("uuid", () => ({
+        v4: jest.fn(() => "should-not-be-called"),
+      }));
+
+      // Now require the modules
+      const { MixpanelPersistent } = require("mixpanel-react-native/javascript/mixpanel-persistent");
+      const { randomUUID } = require("expo-crypto");
+      const uuid = require("uuid");
+
+      // Create instance
+      MixpanelPersistent.instance = null;
+      mixpanelPersistent = MixpanelPersistent.getInstance(null, token);
+
+      // Load device ID
+      await mixpanelPersistent.loadDeviceId(token);
+
+      // Verify randomUUID was called
+      expect(randomUUID).toHaveBeenCalled();
+
+      // Verify uuid.v4 was NOT called
+      expect(uuid.v4).not.toHaveBeenCalled();
+
+      // Verify the device ID was set to the expo value
+      expect(mixpanelPersistent.getDeviceId(token)).toBe("expo-uuid-5678");
+    });
+  });
+
+  it("should handle legacy device IDs without expo-crypto format", async () => {
+    let mixpanelPersistent;
+    
+    await jest.isolateModules(async () => {
+      // Create a mock storage with a legacy UUID
+      const legacyUuid = "550e8400-e29b-41d4-a716-446655440000"; // Standard UUID v4 format
+      const mockStorage = {};
+      
+      jest.doMock("mixpanel-react-native/javascript/mixpanel-storage", () => {
+        return {
+          AsyncStorageAdapter: jest.fn().mockImplementation(() => ({
+            getItem: jest.fn((key) => {
+              return Promise.resolve(mockStorage[key] || null);
+            }),
+            setItem: jest.fn((key, value) => {
+              mockStorage[key] = value;
+              return Promise.resolve();
+            }),
+            removeItem: jest.fn((key) => {
+              delete mockStorage[key];
+              return Promise.resolve();
+            }),
+          })),
+        };
+      });
+
+      // Pre-populate storage with legacy device ID
+      const deviceIdKey = `MIXPANEL_${token}_device_id`;
+      mockStorage[deviceIdKey] = legacyUuid;
+
+      const { MixpanelPersistent } = require("mixpanel-react-native/javascript/mixpanel-persistent");
+      
+      // Create instance
+      MixpanelPersistent.instance = null;
+      mixpanelPersistent = MixpanelPersistent.getInstance(null, token);
+
+      // Load device ID from storage
+      await mixpanelPersistent.loadDeviceId(token);
+
+      // Verify the legacy device ID was loaded correctly
+      expect(mixpanelPersistent.getDeviceId(token)).toBe(legacyUuid);
+      
+      // Verify it doesn't try to generate a new one
+      const { randomUUID } = require("expo-crypto");
+      const uuid = require("uuid");
+      expect(randomUUID).not.toHaveBeenCalled();
+      expect(uuid.v4).not.toHaveBeenCalled();
+    });
+  });
+
+  it("should migrate from no device ID to expo-crypto format when available", async () => {
+    let mixpanelPersistent;
+    
+    await jest.isolateModules(async () => {
+      const mockStorage = {};
+      
+      jest.doMock("mixpanel-react-native/javascript/mixpanel-storage", () => {
+        return {
+          AsyncStorageAdapter: jest.fn().mockImplementation(() => ({
+            getItem: jest.fn((key) => Promise.resolve(mockStorage[key] || null)),
+            setItem: jest.fn((key, value) => {
+              mockStorage[key] = value;
+              return Promise.resolve();
+            }),
+            removeItem: jest.fn((key) => {
+              delete mockStorage[key];
+              return Promise.resolve();
+            }),
+          })),
+        };
+      });
+
+      // Mock expo-crypto to return a specific value
+      jest.doMock("expo-crypto", () => ({
+        randomUUID: jest.fn(() => "expo-generated-uuid"),
+      }));
+
+      const { MixpanelPersistent } = require("mixpanel-react-native/javascript/mixpanel-persistent");
+      const { randomUUID } = require("expo-crypto");
+      
+      // Create instance with no existing device ID
+      MixpanelPersistent.instance = null;
+      mixpanelPersistent = MixpanelPersistent.getInstance(null, token);
+
+      // Load device ID (should generate new one)
+      await mixpanelPersistent.loadDeviceId(token);
+
+      // Verify expo-crypto was used for new device ID
+      expect(randomUUID).toHaveBeenCalled();
+      expect(mixpanelPersistent.getDeviceId(token)).toBe("expo-generated-uuid");
+      
+      // Verify it was persisted to storage
+      const deviceIdKey = `MIXPANEL_${token}_device_id`;
+      expect(mockStorage[deviceIdKey]).toBe("expo-generated-uuid");
+    });
+  });
+
+  it("should handle storage failures gracefully during identity persistence", async () => {
+    let mixpanelPersistent;
+    
+    await jest.isolateModules(async () => {
+      let shouldFail = false;
+      
+      jest.doMock("mixpanel-react-native/javascript/mixpanel-storage", () => {
+        return {
+          AsyncStorageAdapter: jest.fn().mockImplementation(() => ({
+            getItem: jest.fn(() => Promise.resolve(null)),
+            setItem: jest.fn((key, value) => {
+              if (shouldFail) {
+                return Promise.reject(new Error("Storage write failed"));
+              }
+              return Promise.resolve();
+            }),
+            removeItem: jest.fn(() => Promise.resolve()),
+          })),
+        };
+      });
+
+      // Mock expo-crypto
+      jest.doMock("expo-crypto", () => ({
+        randomUUID: jest.fn(() => "test-uuid-12345"),
+      }));
+
+      const { MixpanelPersistent } = require("mixpanel-react-native/javascript/mixpanel-persistent");
+      
+      // Create instance
+      MixpanelPersistent.instance = null;
+      mixpanelPersistent = MixpanelPersistent.getInstance(null, token);
+
+      // First load should work (storage not failing yet)
+      await mixpanelPersistent.loadDeviceId(token);
+      expect(mixpanelPersistent.getDeviceId(token)).toBe("test-uuid-12345");
+
+      // Now make storage fail
+      shouldFail = true;
+
+      // Update identity and try to persist - should not throw
+      mixpanelPersistent.updateDistinctId(token, "new-distinct-id");
+      mixpanelPersistent.updateUserId(token, "new-user-id");
+      
+      // This should not throw even if storage fails
+      await expect(mixpanelPersistent.persistIdentity(token)).resolves.not.toThrow();
+      
+      // Identity should still be in memory even if storage failed
+      expect(mixpanelPersistent.getDistinctId(token)).toBe("new-distinct-id");
+      expect(mixpanelPersistent.getUserId(token)).toBe("new-user-id");
+      expect(mixpanelPersistent.getDeviceId(token)).toBe("test-uuid-12345");
+    });
+  });
+
+  it("should continue working if storage read fails", async () => {
+    let mixpanelPersistent;
+    
+    await jest.isolateModules(async () => {
+      jest.doMock("mixpanel-react-native/javascript/mixpanel-storage", () => {
+        return {
+          AsyncStorageAdapter: jest.fn().mockImplementation(() => ({
+            getItem: jest.fn(() => Promise.reject(new Error("Storage read failed"))),
+            setItem: jest.fn(() => Promise.resolve()),
+            removeItem: jest.fn(() => Promise.resolve()),
+          })),
+        };
+      });
+
+      // Mock expo-crypto
+      jest.doMock("expo-crypto", () => ({
+        randomUUID: jest.fn(() => "fallback-uuid"),
+      }));
+
+      const { MixpanelPersistent } = require("mixpanel-react-native/javascript/mixpanel-persistent");
+      
+      // Create instance
+      MixpanelPersistent.instance = null;
+      mixpanelPersistent = MixpanelPersistent.getInstance(null, token);
+
+      // Loading should not throw even if storage fails
+      await expect(mixpanelPersistent.loadDeviceId(token)).resolves.not.toThrow();
+      
+      // Should generate a new device ID since storage failed
+      expect(mixpanelPersistent.getDeviceId(token)).toBe("fallback-uuid");
+    });
+  });
+});

package/__tests__/queue.test.js

@@ -5,6 +5,10 @@ jest.mock("mixpanel-react-native/javascript/mixpanel-persistent", () => ({
     getInstance: jest.fn().mockReturnValue({
       loadQueue: jest.fn().mockResolvedValue([]),
       saveQueue: jest.fn(),
+      isIdentified: jest.fn(),
+      getDistinctId: jest.fn(),
+      getDeviceId: jest.fn(),
+      getUserId: jest.fn(),
     }),
   },
 }));
@@ -13,7 +17,7 @@ describe("MixpanelQueueManager", () => {
   let MixpanelQueueManager;
   let mixpanelPersistent;
   let token = "testToken";
-  let type = MixpanelType.EVENTS;
+  let eventsType = MixpanelType.EVENTS;
 
   beforeEach(() => {
     jest.isolateModules(async () => {
@@ -22,44 +26,191 @@ describe("MixpanelQueueManager", () => {
       const MixpanelPersistent = require("mixpanel-react-native/javascript/mixpanel-persistent")
         .MixpanelPersistent;
       mixpanelPersistent = MixpanelPersistent.getInstance();
-      await MixpanelQueueManager.clearQueue(token, type);
+      await MixpanelQueueManager.clearQueue(token, eventsType);
     });
   });
 
   it("initializes the queue correctly", async () => {
-    await MixpanelQueueManager.initialize(token, type);
-    expect(MixpanelQueueManager.getQueue(token, type)).toEqual([]);
+    await MixpanelQueueManager.initialize(token, eventsType);
+    expect(MixpanelQueueManager.getQueue(token, eventsType)).toEqual([]);
   });
 
   it("enqueue adds data to the queue and updates storage", async () => {
     const data = { test: "data" };
 
-    await MixpanelQueueManager.initialize(token, type);
-    await MixpanelQueueManager.enqueue(token, type, data);
+    await MixpanelQueueManager.initialize(token, eventsType);
+    await MixpanelQueueManager.enqueue(token, eventsType, data);
 
     expect(mixpanelPersistent.saveQueue).toHaveBeenCalledWith(
       token,
-      type,
+      eventsType,
       expect.any(Array)
     );
   });
 
   it("splices the queue correctly", async () => {
-    await MixpanelQueueManager.enqueue(token, type, { data: "sample1" });
-    await MixpanelQueueManager.enqueue(token, type, { data: "sample2" });
+    await MixpanelQueueManager.enqueue(token, eventsType, { data: "sample1" });
+    await MixpanelQueueManager.enqueue(token, eventsType, { data: "sample2" });
 
-    await MixpanelQueueManager.spliceQueue(token, type, 0, 1);
+    await MixpanelQueueManager.spliceQueue(token, eventsType, 0, 1);
 
-    const queue = MixpanelQueueManager.getQueue(token, type);
+    const queue = MixpanelQueueManager.getQueue(token, eventsType);
     expect(queue.length).toBe(1);
     expect(queue).toEqual([{ data: "sample2" }]);
   });
 
   it("clears the queue correctly", async () => {
-    await MixpanelQueueManager.enqueue(token, type, { data: "sample" });
-    await MixpanelQueueManager.clearQueue(token, type);
+    await MixpanelQueueManager.enqueue(token, eventsType, { data: "sample" });
+    await MixpanelQueueManager.clearQueue(token, eventsType);
 
-    const queue = MixpanelQueueManager.getQueue(token, type);
+    const queue = MixpanelQueueManager.getQueue(token, eventsType);
     expect(queue).toEqual([]);
   });
 });
+
+describe("MixpanelQueueManager - extended", () => {
+  let MixpanelQueueManager;
+  let mixpanelPersistent;
+  let token = "testToken";
+  let userType = MixpanelType.USER;
+
+  beforeEach(async () => {
+    jest.isolateModules(() => {
+      MixpanelQueueManager = require("mixpanel-react-native/javascript/mixpanel-queue").MixpanelQueueManager;
+      mixpanelPersistent = require("mixpanel-react-native/javascript/mixpanel-persistent").MixpanelPersistent.getInstance();
+    });
+    // Reset internal queues
+    await MixpanelQueueManager.clearQueue(token, userType);
+  });
+
+  describe("getQueue", () => {
+    it("returns empty array if no queue exists", () => {
+      expect(MixpanelQueueManager.getQueue(token, userType)).toEqual([]);
+    });
+
+    it("returns queue if present and identified", async () => {
+      mixpanelPersistent.isIdentified.mockReturnValue(true);
+      await MixpanelQueueManager.enqueue(token, userType, { foo: "bar" });
+      const queue = MixpanelQueueManager.getQueue(token, userType);
+      expect(queue).toEqual([{ foo: "bar" }]);
+    });
+
+    it("returns empty array for USER type if not identified", async () => {
+      mixpanelPersistent.isIdentified.mockReturnValue(false);
+      // Manually set internal queue
+      await MixpanelQueueManager.enqueue(token, userType, { foo: "bar" });
+      const queue = MixpanelQueueManager.getQueue(token, userType);
+      expect(queue).toEqual([]);
+    });
+
+    it("returns queue for non-USER type regardless of identification", async () => {
+      mixpanelPersistent.isIdentified.mockReturnValue(false);
+      const nonUserType = MixpanelType.EVENTS;
+      await MixpanelQueueManager.enqueue(token, nonUserType, { foo: "baz" });
+      const queue = MixpanelQueueManager.getQueue(token, nonUserType);
+      expect(queue).toEqual([{ foo: "baz" }]);
+    });
+  });
+
+  describe("identifyUserQueue", () => {
+    it("returns empty array if USER queue does not exist", async () => {
+      const result = await MixpanelQueueManager.identifyUserQueue(token);
+      expect(result).toEqual([]);
+    });
+
+    it("updates identity fields if they are missing or null", async () => {
+      // Setup persistent mocks
+      mixpanelPersistent.getDistinctId.mockReturnValue("did");
+      mixpanelPersistent.getDeviceId.mockReturnValue("devid");
+      mixpanelPersistent.getUserId.mockReturnValue("uid");
+      // Insert a record missing identity fields
+      await MixpanelQueueManager.enqueue(token, userType, { foo: 1, $distinct_id: null, $device_id: null, $user_id: null });
+
+      const result = await MixpanelQueueManager.identifyUserQueue(token);
+      expect(result[0]).toEqual({ foo: 1, $distinct_id: "did", $device_id: "devid", $user_id: "uid" });
+      expect(mixpanelPersistent.saveQueue).toHaveBeenCalledWith(
+        token,
+        MixpanelType.USER,
+        expect.any(Array)
+      );
+    });
+
+    it("does not update queue if identity fields already match", async () => {
+      mixpanelPersistent.getDistinctId.mockReturnValue("did");
+      mixpanelPersistent.getDeviceId.mockReturnValue("devid");
+      mixpanelPersistent.getUserId.mockReturnValue("uid");
+      await MixpanelQueueManager.enqueue(token, userType, {
+        foo: 1,
+        $distinct_id: "did",
+        $device_id: "devid",
+        $user_id: "uid"
+      });
+
+      mixpanelPersistent.saveQueue.mockClear();
+      const result = await MixpanelQueueManager.identifyUserQueue(token);
+      expect(result[0]).toEqual({
+        foo: 1,
+        $distinct_id: "did",
+        $device_id: "devid",
+        $user_id: "uid"
+      });
+      expect(mixpanelPersistent.saveQueue).not.toHaveBeenCalled();
+    });
+
+    it("should preserve user queue data integrity during identity updates", async () => {
+      // Add multiple items to user queue with different profile operations
+      const queueItems = [
+        { $set: { name: "John" }, $distinct_id: "old-id", $device_id: "old-device", $user_id: "old-user" },
+        { $set_once: { created: "2024-01-01" }, $distinct_id: "old-id", $device_id: "old-device", $user_id: "old-user" },
+        { $add: { points: 10 }, $distinct_id: "old-id", $device_id: "old-device", $user_id: "old-user" },
+        { $union: { tags: ["premium"] }, $distinct_id: "old-id", $device_id: "old-device", $user_id: "old-user" }
+      ];
+
+      for (const item of queueItems) {
+        await MixpanelQueueManager.enqueue(token, userType, item);
+      }
+
+      // Update identity
+      mixpanelPersistent.getDistinctId.mockReturnValue("new-id");
+      mixpanelPersistent.getDeviceId.mockReturnValue("new-device");
+      mixpanelPersistent.getUserId.mockReturnValue("new-user");
+
+      // Call identifyUserQueue
+      const result = await MixpanelQueueManager.identifyUserQueue(token);
+
+      // Verify all items preserved their data but updated identity fields
+      expect(result).toHaveLength(4);
+      expect(result[0]).toEqual({
+        $set: { name: "John" },
+        $distinct_id: "new-id",
+        $device_id: "new-device",
+        $user_id: "new-user"
+      });
+      expect(result[1]).toEqual({
+        $set_once: { created: "2024-01-01" },
+        $distinct_id: "new-id",
+        $device_id: "new-device",
+        $user_id: "new-user"
+      });
+      expect(result[2]).toEqual({
+        $add: { points: 10 },
+        $distinct_id: "new-id",
+        $device_id: "new-device",
+        $user_id: "new-user"
+      });
+      expect(result[3]).toEqual({
+        $union: { tags: ["premium"] },
+        $distinct_id: "new-id",
+        $device_id: "new-device",
+        $user_id: "new-user"
+      });
+
+      // Verify queue was saved
+      expect(mixpanelPersistent.saveQueue).toHaveBeenCalledWith(
+        token,
+        MixpanelType.USER,
+        expect.any(Array)
+      );
+    });
+  });
+});

package/android/build.gradle

@@ -41,5 +41,5 @@ repositories {
 
 dependencies {
     implementation 'com.facebook.react:react-native:+'
-    implementation 'com.mixpanel.android:mixpanel-android:8.0.3'
+    implementation 'com.mixpanel.android:mixpanel-android:8.2.0'
 }

package/android/src/main/java/com/mixpanel/reactnative/MixpanelReactNativeModule.java

@@ -33,11 +33,14 @@ public class MixpanelReactNativeModule extends ReactContextBaseJavaModule {
 
 
     @ReactMethod
-    public void initialize(String token, boolean trackAutomaticEvents, boolean optOutTrackingDefault, ReadableMap metadata, String serverURL, Promise promise) throws JSONException {
+    public void initialize(String token, boolean trackAutomaticEvents, boolean optOutTrackingDefault, ReadableMap metadata, String serverURL, boolean useGzipCompression, Promise promise) throws JSONException {
         JSONObject mixpanelProperties = ReactNativeHelper.reactToJSON(metadata);
         AutomaticProperties.setAutomaticProperties(mixpanelProperties);
         MixpanelAPI instance = MixpanelAPI.getInstance(this.mReactContext, token, optOutTrackingDefault, mixpanelProperties, null, trackAutomaticEvents);
         instance.setServerURL(serverURL);
+        if (useGzipCompression) {
+            instance.setShouldGzipRequestPayload(true);
+        }
         promise.resolve(null);
     }