mixpanel-react-native 3.2.0-beta.1 → 3.2.0-beta.3

package/javascript/mixpanel-main.js

@@ -82,6 +82,14 @@ export default class MixpanelMain {
     await this.mixpanelPersistent.reset(token);
   }
 
+  /**
+   * Get the feature flags context that was provided during initialization
+   * @returns {object} The feature flags context object
+   */
+  getFeatureFlagsContext() {
+    return this.featureFlagsContext || {};
+  }
+
   async track(token, eventName, properties) {
     if (this.mixpanelPersistent.getOptedOut(token)) {
       MixpanelLogger.log(

package/javascript/mixpanel-network.js

@@ -15,37 +15,77 @@ export const MixpanelNetwork = (() => {
     serverURL,
     useIPAddressForGeoLocation,
     retryCount = 0,
+    headers = {},
   }) => {
     retryCount = retryCount || 0;
-    const url = `${serverURL}${endpoint}?ip=${+useIPAddressForGeoLocation}`;
+    // Use & if endpoint already has query params, otherwise use ?
+    const separator = endpoint.includes('?') ? '&' : '?';
+    const url = `${serverURL}${endpoint}${separator}ip=${+useIPAddressForGeoLocation}`;
     MixpanelLogger.log(token, `Sending request to: ${url}`);
 
     try {
-      const response = await fetch(url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded",
-        },
-        body: `data=${encodeURIComponent(JSON.stringify(data))}`,
-      });
+      // Determine if this is a GET or POST request based on data presence
+      const isGetRequest = data === null || data === undefined;
 
-      const responseBody = await response.json();
-      if (response.status !== 200) {
-        throw new MixpanelHttpError(
-          `HTTP error! status: ${response.status}`,
-          response.status
-        );
-      }
+      const fetchOptions = isGetRequest
+        ? {
+            method: "GET",
+            headers: headers,
+          }
+        : {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/x-www-form-urlencoded",
+              ...headers,
+            },
+            body: `data=${encodeURIComponent(JSON.stringify(data))}`,
+          };
+
+      const response = await fetch(url, fetchOptions);
+
+      // Handle GET requests differently - they return the data directly
+      if (isGetRequest) {
+        if (response.status === 200) {
+          const responseData = await response.json();
+          MixpanelLogger.log(token, `GET request successful: ${endpoint}`);
+          return responseData;
+        } else {
+          throw new MixpanelHttpError(
+            `HTTP error! status: ${response.status}`,
+            response.status
+          );
+        }
+      } else {
+        // Handle POST requests (existing logic)
+        const responseBody = await response.json();
+        if (response.status !== 200) {
+          throw new MixpanelHttpError(
+            `HTTP error! status: ${response.status}`,
+            response.status
+          );
+        }
 
-      const message =
-        responseBody === 0
-          ? `${url} api rejected some items`
-          : `Mixpanel batch sent successfully, endpoint: ${endpoint}, data: ${JSON.stringify(
-              data
-            )}`;
+        const message =
+          responseBody === 0
+            ? `${url} api rejected some items`
+            : `Mixpanel batch sent successfully, endpoint: ${endpoint}, data: ${JSON.stringify(
+                data
+              )}`;
 
-      MixpanelLogger.log(token, message);
+        MixpanelLogger.log(token, message);
+        return responseBody;
+      }
     } catch (error) {
+      // Determine if this is a GET or POST request
+      const isGetRequest = data === null || data === undefined;
+
+      // For GET requests (like flags), don't retry on 404 or other client errors
+      if (isGetRequest && error.code >= 400 && error.code < 500) {
+        MixpanelLogger.log(token, `GET request failed with status ${error.code}, not retrying`);
+        throw error;
+      }
+
+      // For POST requests or non-client errors, handle retries
       if (error.code === 400) {
         // This indicates that the data was invalid and we should not retry
         throw new MixpanelHttpError(
@@ -53,30 +93,35 @@ export const MixpanelNetwork = (() => {
           error.code
         );
       }
+
       MixpanelLogger.warn(
         token,
         `API request to ${url} has failed with reason: ${error.message}`
       );
-      const maxRetries = 5;
-      const backoff = Math.min(2 ** retryCount * 2000, 60000); // Exponential backoff
-      if (retryCount < maxRetries) {
-        MixpanelLogger.log(token, `Retrying in ${backoff / 1000} seconds...`);
-        await new Promise((resolve) => setTimeout(resolve, backoff));
-        return sendRequest({
-          token,
-          endpoint,
-          data,
-          serverURL,
-          useIPAddressForGeoLocation,
-          retryCount: retryCount + 1,
-        });
-      } else {
-        MixpanelLogger.warn(token, `Max retries reached. Giving up.`);
-        throw new MixpanelHttpError(
-          `HTTP error! status: ${error.code}`,
-          error.code
-        );
+
+      // Only retry for POST requests or server errors
+      if (!isGetRequest || error.code >= 500) {
+        const maxRetries = 5;
+        const backoff = Math.min(2 ** retryCount * 2000, 60000); // Exponential backoff
+        if (retryCount < maxRetries) {
+          MixpanelLogger.log(token, `Retrying in ${backoff / 1000} seconds...`);
+          await new Promise((resolve) => setTimeout(resolve, backoff));
+          return sendRequest({
+            token,
+            endpoint,
+            data,
+            serverURL,
+            useIPAddressForGeoLocation,
+            retryCount: retryCount + 1,
+          });
+        }
       }
+
+      MixpanelLogger.warn(token, `Request failed. Not retrying.`);
+      throw new MixpanelHttpError(
+        `HTTP error! status: ${error.code || 'unknown'}`,
+        error.code
+      );
     }
   };
 

package/javascript/mixpanel-persistent.js

@@ -14,6 +14,38 @@ import { AsyncStorageAdapter } from "./mixpanel-storage";
 import uuid from "uuid";
 import { MixpanelLogger } from "mixpanel-react-native/javascript/mixpanel-logger";
 
+/**
+ * Generate a UUID v4, with cross-platform fallbacks
+ * Tries: uuid package → Web Crypto API → manual generation
+ */
+function generateUUID() {
+  // Try uuid package first (works in React Native with polyfill)
+  try {
+    const result = uuid.v4();
+    if (result) return result;
+  } catch (e) {
+    // Fall through to alternatives
+  }
+
+  // Try Web Crypto API (modern browsers)
+  const cryptoObj =
+    (typeof globalThis !== "undefined" && globalThis.crypto) ||
+    (typeof window !== "undefined" && window.crypto) ||
+    (typeof crypto !== "undefined" && crypto);
+
+  if (cryptoObj && typeof cryptoObj.randomUUID === "function") {
+    return cryptoObj.randomUUID();
+  }
+
+  // Last resort: manual UUID v4 generation using Math.random
+  // Less secure but functional for device IDs
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+    const r = (Math.random() * 16) | 0;
+    const v = c === "x" ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+}
+
 export class MixpanelPersistent {
   static instance;
 
@@ -42,7 +74,7 @@ export class MixpanelPersistent {
   }
 
   async initializationCompletePromise(token) {
-    Promise.all([
+    return Promise.all([
       this.loadIdentity(token),
       this.loadSuperProperties(token),
       this.loadTimeEvents(token),
@@ -67,8 +99,8 @@ export class MixpanelPersistent {
     this._identity[token].deviceId = storageToken;
 
     if (!this._identity[token].deviceId) {
-      // Generate device ID using uuid.v4() with polyfilled crypto.getRandomValues
-      this._identity[token].deviceId = uuid.v4();
+      // Generate device ID with cross-platform UUID generation
+      this._identity[token].deviceId = generateUUID();
       await this.storageAdapter.setItem(
         getDeviceIdKey(token),
         this._identity[token].deviceId

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixpanel-react-native",
-  "version": "3.2.0-beta.1",
+  "version": "3.2.0-beta.3",
   "description": "Official React Native Tracking Library for Mixpanel Analytics",
   "main": "index.js",
   "scripts": {
@@ -38,8 +38,10 @@
     "eslint": "^7.11.0",
     "jest": "^26.6.3",
     "jest-fetch-mock": "^3.0.3",
+    "jsdoc": "^4.0.5",
     "metro-react-native-babel-preset": "^0.63.0",
     "react-native": "^0.63.3",
+    "react-native-dotenv": "^3.4.11",
     "react-test-renderer": "16.13.1"
   },
   "jest": {
@@ -59,7 +61,7 @@
     }
   },
   "dependencies": {
-    "@react-native-async-storage/async-storage": "^1.21.0",
+    "@react-native-async-storage/async-storage": "^1.24.0",
     "react-native-get-random-values": "^1.9.0",
     "uuid": "3.3.2"
   }