mimz-react-native-tracker 1.0.0

package/src/index.js

@@ -0,0 +1,47 @@
+/**
+ * Mimz React Native Tracker SDK
+ *
+ * Analytics tracking SDK for React Native apps.
+ * This is the native equivalent of the Mimz web tracking script.
+ *
+ * @module mimz-react-native-tracker
+ *
+ * @example
+ * // 1. Install dependencies:
+ * //    npm install mimz-react-native-tracker @react-native-async-storage/async-storage
+ *
+ * // 2. Initialize in your App.js or entry file:
+ * import AsyncStorage from '@react-native-async-storage/async-storage';
+ * import MimzTracker from 'mimz-react-native-tracker';
+ *
+ * // In your app startup:
+ * await MimzTracker.init({
+ *   clientId: 'YOUR_MIMZ_CLIENT_ID',        // From Mimz dashboard
+ *   backendUrl: 'https://your-mimz-backend.com',
+ *   asyncStorage: AsyncStorage,
+ *   appName: 'MyApp',
+ *   appVersion: '1.0.0',
+ * });
+ *
+ * // 3. Track deep links (for UTM tracking):
+ * MimzTracker.trackDeepLink('myapp://open?utm_source=facebook&utm_campaign=promo');
+ *
+ * // 4. Track screen views:
+ * MimzTracker.trackScreenView('HomeScreen');
+ *
+ * // 5. Track events:
+ * MimzTracker.trackEvent('add_to_cart', { productId: '123', price: 29.99 });
+ *
+ * // 6. Track conversions:
+ * MimzTracker.trackConversion({ productName: 'Premium Plan', value: 49.99 });
+ *
+ * // 7. Track contacts:
+ * MimzTracker.trackContact({ email: 'user@example.com', name: 'John', phone: '+123456' });
+ *
+ * // 8. Flush on app background:
+ * MimzTracker.flush();
+ */
+
+const tracker = require('./tracker');
+
+module.exports = tracker;

package/src/network.js

@@ -0,0 +1,134 @@
+/**
+ * MimzNetwork - Network layer for sending tracking data to the Mimz backend
+ * Replaces browser fetch/sendBeacon with React Native compatible fetch
+ */
+
+const DEFAULT_TIMEOUT_MS = 5000;
+const MAX_RETRY_ATTEMPTS = 2;
+const RETRY_DELAY_MS = 1000;
+
+let backendUrl = '';
+
+/**
+ * Initialize the network layer with the backend URL
+ * @param {string} url - The Mimz backend base URL (e.g., https://mimz-backend.onrender.com)
+ */
+const init = (url) => {
+  // Normalize: remove trailing slash
+  backendUrl = url.replace(/\/+$/, '');
+};
+
+/**
+ * Send data to the Mimz backend with timeout and retry
+ * @param {string} endpoint - API endpoint path (e.g., /api/visitors/add-visitors)
+ * @param {object} data - The payload to send
+ * @param {object} options - Optional configuration
+ * @param {number} options.timeout - Request timeout in ms (default: 5000)
+ * @param {number} options.retries - Number of retry attempts (default: 2)
+ * @returns {Promise<object|null>} - The response data or null on failure
+ */
+const post = async (endpoint, data, options = {}) => {
+  const { timeout = DEFAULT_TIMEOUT_MS, retries = MAX_RETRY_ATTEMPTS } = options;
+
+  if (!backendUrl) {
+    console.warn('[MimzTracker] Backend URL not set. Call MimzTracker.init() first.');
+    return null;
+  }
+
+  const url = `${backendUrl}${endpoint}`;
+  let lastError = null;
+
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      const controller = typeof AbortController !== 'undefined' ? new AbortController() : null;
+      const timeoutId = controller ? setTimeout(() => controller.abort(), timeout) : null;
+
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Accept: 'application/json',
+          'X-Requested-With': 'MimzReactNativeSDK',
+        },
+        body: JSON.stringify(data),
+        signal: controller?.signal,
+      });
+
+      if (timeoutId) clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        throw new Error(`Server responded with status ${response.status}: ${response.statusText}`);
+      }
+
+      const responseData = await response.json();
+      return responseData;
+    } catch (error) {
+      lastError = error;
+
+      if (error.name === 'AbortError') {
+        console.warn(`[MimzTracker] Request to ${endpoint} timed out (attempt ${attempt + 1}/${retries + 1})`);
+      } else {
+        console.warn(`[MimzTracker] Request to ${endpoint} failed (attempt ${attempt + 1}/${retries + 1}):`, error.message);
+      }
+
+      // Wait before retrying (skip delay on last attempt)
+      if (attempt < retries) {
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS * (attempt + 1)));
+      }
+    }
+  }
+
+  console.error(`[MimzTracker] All ${retries + 1} attempts to ${endpoint} failed. Last error:`, lastError?.message);
+  return null;
+};
+
+/**
+ * Get data from the Mimz backend
+ * @param {string} endpoint - API endpoint path
+ * @param {object} params - Query parameters
+ * @returns {Promise<object|null>}
+ */
+const get = async (endpoint, params = {}) => {
+  if (!backendUrl) {
+    console.warn('[MimzTracker] Backend URL not set.');
+    return null;
+  }
+
+  const queryString = Object.entries(params)
+    .filter(([, v]) => v != null)
+    .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+    .join('&');
+
+  const url = `${backendUrl}${endpoint}${queryString ? '?' + queryString : ''}`;
+
+  try {
+    const controller = typeof AbortController !== 'undefined' ? new AbortController() : null;
+    const timeoutId = controller ? setTimeout(() => controller.abort(), DEFAULT_TIMEOUT_MS) : null;
+
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: {
+        Accept: 'application/json',
+        'X-Requested-With': 'MimzReactNativeSDK',
+      },
+      signal: controller?.signal,
+    });
+
+    if (timeoutId) clearTimeout(timeoutId);
+
+    if (!response.ok) {
+      throw new Error(`Server responded with status ${response.status}`);
+    }
+
+    return await response.json();
+  } catch (error) {
+    console.warn(`[MimzTracker] GET ${endpoint} failed:`, error.message);
+    return null;
+  }
+};
+
+module.exports = {
+  init,
+  post,
+  get,
+};

package/src/storage.js

@@ -0,0 +1,117 @@
+/**
+ * MimzStorage - Persistent storage adapter for React Native
+ * Replaces browser cookies/localStorage with AsyncStorage
+ */
+
+let AsyncStorage = null;
+
+/**
+ * Initialize the storage adapter with AsyncStorage instance
+ * @param {object} asyncStorageInstance - The AsyncStorage module from @react-native-async-storage/async-storage
+ */
+const init = (asyncStorageInstance) => {
+  AsyncStorage = asyncStorageInstance;
+};
+
+/**
+ * Get a value from persistent storage
+ * @param {string} key
+ * @returns {Promise<string|null>}
+ */
+const get = async (key) => {
+  if (!AsyncStorage) {
+    console.warn('[MimzTracker] AsyncStorage not initialized. Call MimzTracker.init() first.');
+    return null;
+  }
+  try {
+    const value = await AsyncStorage.getItem(`@mimz_${key}`);
+    return value;
+  } catch (error) {
+    console.warn(`[MimzTracker] Error reading "${key}" from storage:`, error.message);
+    return null;
+  }
+};
+
+/**
+ * Set a value in persistent storage
+ * @param {string} key
+ * @param {string} value
+ * @returns {Promise<void>}
+ */
+const set = async (key, value) => {
+  if (!AsyncStorage) {
+    console.warn('[MimzTracker] AsyncStorage not initialized. Call MimzTracker.init() first.');
+    return;
+  }
+  try {
+    await AsyncStorage.setItem(`@mimz_${key}`, String(value));
+  } catch (error) {
+    console.warn(`[MimzTracker] Error writing "${key}" to storage:`, error.message);
+  }
+};
+
+/**
+ * Remove a value from persistent storage
+ * @param {string} key
+ * @returns {Promise<void>}
+ */
+const remove = async (key) => {
+  if (!AsyncStorage) return;
+  try {
+    await AsyncStorage.removeItem(`@mimz_${key}`);
+  } catch (error) {
+    console.warn(`[MimzTracker] Error removing "${key}" from storage:`, error.message);
+  }
+};
+
+/**
+ * Get a JSON object from storage
+ * @param {string} key
+ * @returns {Promise<object|null>}
+ */
+const getJSON = async (key) => {
+  const raw = await get(key);
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * Set a JSON object in storage
+ * @param {string} key
+ * @param {object} value
+ * @returns {Promise<void>}
+ */
+const setJSON = async (key, value) => {
+  await set(key, JSON.stringify(value));
+};
+
+/**
+ * Clear all Mimz-related storage keys
+ * @returns {Promise<void>}
+ */
+const clearAll = async () => {
+  if (!AsyncStorage) return;
+  try {
+    const allKeys = await AsyncStorage.getAllKeys();
+    const mimzKeys = allKeys.filter((key) => key.startsWith('@mimz_'));
+    if (mimzKeys.length > 0) {
+      await AsyncStorage.multiRemove(mimzKeys);
+    }
+  } catch (error) {
+    console.warn('[MimzTracker] Error clearing storage:', error.message);
+  }
+};
+
+module.exports = {
+  init,
+  get,
+  set,
+  remove,
+  getJSON,
+  setJSON,
+  clearAll,
+};