@magicpixel/rn-mp-client-sdk 1.13.0 → 1.13.21

package/src/common/event-bus.ts

@@ -16,6 +16,45 @@ export class EventBus {
     }
   }
 
+  /**
+   * Remove a specific callback for an event
+   * @param eventName Event name to remove callback from
+   * @param callback The callback function to remove
+   */
+  static off(eventName: string, callback: EventBusCallback): void {
+    if (this.eventRegister.has(eventName)) {
+      const callbacks = this.eventRegister.get(eventName);
+      const index = callbacks.indexOf(callback);
+      if (index > -1) {
+        callbacks.splice(index, 1);
+        Logger.logDbg(`Removed listener for event: ${eventName}`);
+      }
+      // Clean up empty arrays
+      if (callbacks.length === 0) {
+        this.eventRegister.delete(eventName);
+      }
+    }
+  }
+
+  /**
+   * Remove all callbacks for a specific event
+   * @param eventName Event name to clear all listeners for
+   */
+  static clearEvent(eventName: string): void {
+    if (this.eventRegister.has(eventName)) {
+      this.eventRegister.delete(eventName);
+      Logger.logDbg(`Cleared all listeners for event: ${eventName}`);
+    }
+  }
+
+  /**
+   * Remove all event listeners (used during SDK shutdown)
+   */
+  static clearAll(): void {
+    this.eventRegister.clear();
+    Logger.logDbg('Cleared all event listeners');
+  }
+
   static triggerEvent(eventName: string, payload: any): void {
     if (this.eventRegister.has(eventName)) {
       for (const cb of this.eventRegister.get(eventName)) {

package/src/common/network-service.ts

@@ -1,40 +1,173 @@
 import { Logger } from './logger';
 import type { MapLike, SdkInitOptions, VisitorInfo } from './app-types';
 import { DataStore } from './data-store';
-import { Reporter } from './reporter';
 import type { MpClientSdk } from '../models/mp-client-sdk';
 
+const DEFAULT_RETRY_COUNT = 3;
+const DEFAULT_RETRY_DELAY_MS = 1000;
+const DEFAULT_TIMEOUT_MS = 10000;
+
 export class NetworkService {
-  public static async fetchIdlInfo(url: string): Promise<VisitorInfo> {
-    const response = await NetworkService.sendNetworkRequest('get', url);
-    if (response) {
-      return response.json();
-    } else {
+  /**
+   * Sleep for a specified duration
+   */
+  private static sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  /**
+   * Fetch with timeout wrapper
+   */
+  private static async fetchWithTimeout(
+    url: string,
+    options: RequestInit,
+    timeoutMs: number = DEFAULT_TIMEOUT_MS
+  ): Promise<Response> {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+
+    try {
+      const response = await fetch(url, {
+        ...options,
+        signal: controller.signal,
+      });
+      return response;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Fetch visitor/identity info from server
+   * Returns null if fetch fails (caller should handle retry logic)
+   */
+  public static async fetchIdlInfo(url: string): Promise<VisitorInfo | null> {
+    try {
+      const response = await this.fetchWithTimeout(
+        url,
+        {
+          method: 'GET',
+          headers: {
+            'Content-Type': 'text/plain',
+            'cache-control': 'no-store',
+            ...DataStore.getCommonCookies(),
+          },
+        },
+        DEFAULT_TIMEOUT_MS
+      );
+
+      if (response && response.ok) {
+        return response.json();
+      } else {
+        Logger.logError(
+          `Failed to fetch IDL info: ${response?.status} ${response?.statusText}`
+        );
+        return null;
+      }
+    } catch (err) {
+      Logger.logError('Error fetching IDL info:', err);
       return null;
     }
   }
 
+  /**
+   * Fetch visitor/identity info with retry logic
+   * @param url The IDL URL
+   * @param retries Number of retries (default: 3)
+   * @returns VisitorInfo or null if all retries fail
+   */
+  public static async fetchIdlInfoWithRetry(
+    url: string,
+    retries: number = DEFAULT_RETRY_COUNT
+  ): Promise<VisitorInfo | null> {
+    let lastError: Error | null = null;
+
+    for (let attempt = 1; attempt <= retries; attempt++) {
+      try {
+        Logger.logDbg(`Fetching IDL info (attempt ${attempt}/${retries})`);
+        const result = await this.fetchIdlInfo(url);
+
+        if (result) {
+          Logger.logDbg('IDL info fetched successfully');
+          return result;
+        }
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        Logger.logError(`IDL fetch attempt ${attempt} failed:`, err);
+      }
+
+      // Wait before retry (exponential backoff)
+      if (attempt < retries) {
+        const delay = DEFAULT_RETRY_DELAY_MS * Math.pow(2, attempt - 1);
+        Logger.logDbg(`Retrying IDL fetch in ${delay}ms...`);
+        await this.sleep(delay);
+      }
+    }
+
+    Logger.logError(`All ${retries} IDL fetch attempts failed`, lastError);
+    return null;
+  }
+
+  /**
+   * Refresh client SDK JSON configuration with retry logic
+   * @param sdkInitOptions SDK initialization options
+   * @returns true if successful, throws Error if all retries fail
+   */
   public static async refreshClientSdkJson(
     sdkInitOptions: SdkInitOptions
   ): Promise<void> {
-    try {
-      const response = await this.sendNetworkRequest(
-        'get',
-        `${sdkInitOptions.baseUrl}/${sdkInitOptions.projectId}${
-          sdkInitOptions.env === 'staging' ? '-staging' : ''
-        }.json`
-      );
+    const url = `${sdkInitOptions.baseUrl}/${sdkInitOptions.projectId}${
+      sdkInitOptions.env === 'staging' ? '-staging' : ''
+    }.json`;
+
+    let lastError: Error | null = null;
 
-      if (response) {
-        const sdkJson: MpClientSdk = await response.json();
-        Logger.logDbg('Client Sdk:: ', sdkJson);
-        // sdkJson.s.c_url = 'http://localhost:3003';
-        await DataStore.init(sdkJson);
+    for (let attempt = 1; attempt <= DEFAULT_RETRY_COUNT; attempt++) {
+      try {
+        Logger.logDbg(
+          `Fetching SDK config (attempt ${attempt}/${DEFAULT_RETRY_COUNT}): ${url}`
+        );
+
+        const response = await this.fetchWithTimeout(
+          url,
+          {
+            method: 'GET',
+            headers: {
+              'Content-Type': 'text/plain',
+              'cache-control': 'no-store',
+            },
+          },
+          DEFAULT_TIMEOUT_MS
+        );
+
+        if (response && response.ok) {
+          const sdkJson: MpClientSdk = await response.json();
+          Logger.logDbg('Client SDK config fetched successfully');
+          await DataStore.init(sdkJson);
+          return; // Success - exit the retry loop
+        } else {
+          throw new Error(
+            `HTTP ${response?.status}: ${
+              response?.statusText || 'Unknown error'
+            }`
+          );
+        }
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        Logger.logError(`SDK config fetch attempt ${attempt} failed:`, err);
+
+        // Wait before retry (exponential backoff)
+        if (attempt < DEFAULT_RETRY_COUNT) {
+          const delay = DEFAULT_RETRY_DELAY_MS * Math.pow(2, attempt - 1);
+          Logger.logDbg(`Retrying SDK config fetch in ${delay}ms...`);
+          await this.sleep(delay);
+        }
       }
-    } catch (err) {
-      Reporter.reportError('refreshClientSdk', err);
-      // throw new Error('Unable to fetch MagicPixel SDK at this time.');
     }
+
+    // All retries failed - throw error so caller can handle it
+    throw new Error(
+      `Failed to fetch SDK configuration after ${DEFAULT_RETRY_COUNT} attempts: ${lastError?.message}`
+    );
   }
 
   public static sendPostRequest(url: string, body: MapLike): void {

package/src/common/reporter.ts

@@ -4,6 +4,9 @@ import { DataStore } from './data-store';
 import { Utils } from './utils';
 import { NetworkService } from './network-service';
 
+// Maximum number of reports to keep in memory
+const MAX_REPORTS = 500;
+
 export class Reporter {
   static reportMap: MapLike<Report> = {};
 
@@ -20,6 +23,20 @@ export class Reporter {
     clientSdkVersion: string,
     initialItems: ReportTagItem[] = []
   ): void {
+    // Evict oldest reports if at capacity
+    const reportKeys = Object.keys(this.reportMap);
+    if (reportKeys.length >= MAX_REPORTS) {
+      // Remove oldest report (first key in object)
+      const oldestKey = reportKeys[0];
+      if (oldestKey) {
+        delete this.reportMap[oldestKey];
+        Logger.logDbg(
+          `Report map at capacity (${MAX_REPORTS}), evicted oldest report:`,
+          oldestKey
+        );
+      }
+    }
+
     this.reportMap[evtId] = {
       envName,
       envId,
@@ -44,6 +61,16 @@ export class Reporter {
     }
   }
 
+  static reportDevPayload(
+    devPayload: Record<string, any>,
+    evtId: string
+  ): void {
+    const reportParent = this.reportMap[evtId];
+    if (reportParent) {
+      reportParent.devPayload = Utils.encodeToBase64(devPayload);
+    }
+  }
+
   static reportItem(item: ReportTagItem, evtId: string): void {
     const reportParent = this.reportMap[evtId];
     if (reportParent) {
@@ -59,13 +86,44 @@ export class Reporter {
   }
 
   static publishReport(evtId: string): void {
-    const data = (this.reportMap[evtId] || {}) as MapLike;
+    const report = this.reportMap[evtId];
+    if (!report) {
+      Logger.logError(`No report found for evtId: ${evtId}`);
+      return;
+    }
+
+    const data = report as MapLike;
+    data.debugId = DataStore.getDebugId();
+
+    // Include base64 encoded developer payload
+    if (report.devPayload) {
+      data.devPayload = report.devPayload;
+    }
+
+    // Check payload size to prevent DoS attacks (max 250KB)
+    if (Utils.isPayloadOversized(data)) {
+      Logger.logError('Report payload exceeds 250KB limit, dropping event');
+      this.reportError(
+        'm::publishReport',
+        new Error('Payload size exceeds 250KB limit')
+      );
+      delete this.reportMap[evtId];
+      return;
+    }
+
+    // Build URL with event tracking params
+    const eventParams = `eid=${encodeURIComponent(
+      evtId
+    )}&enm=${encodeURIComponent(data.evt ?? '')}`;
     const postUrl = `${DataStore.getUrlInfo().rptUrl}/${
       data.dws ?? 'n'
-    }/${Utils.getUniqueID()}`;
+    }/${Utils.getUniqueID()}?${eventParams}`;
     Logger.logDbg('Posting Info: ', postUrl);
-    data.debugId = DataStore.getDebugId();
+
     NetworkService.sendPostRequest(postUrl, data);
+
+    // Clean up report from memory after publishing
+    delete this.reportMap[evtId];
   }
 
   static reportError(methodMetaData: string, err: any): void {
@@ -88,20 +146,43 @@ export class Reporter {
     envId: string,
     serverTagDownStream: 'j' | 'n',
     eventName: string,
-    evtId: string
+    evtId: string,
+    eventData?: Record<string, any>
   ): Promise<void> {
-    data.env = envName;
-    data.envId = envId;
-    data.evtName = eventName;
-    data.dws = serverTagDownStream;
-    data.debugId = DataStore.getDebugId();
-    data.dm = 'n/a';
-    data.v = DataStore.getCoreVersion();
-    // return postHttp(`${getUrlInfo().tfUrl}/${getUniqueID()}`, 'POST', data);
-    NetworkService.sendPostRequest(
-      `${DataStore.getSSTUrl()}/${data.dws ?? 'n'}/${evtId}`,
-      data
-    );
+    // Clone data to avoid mutating the shared dataElements object
+    const payload: MapLike = { ...data };
+    payload.env = envName;
+    payload.envId = envId;
+    payload.evtName = eventName;
+    payload.dws = serverTagDownStream;
+    payload.debugId = DataStore.getDebugId();
+    payload.dm = 'n/a';
+    payload.v = DataStore.getCoreVersion();
+
+    // Add base64 encoded developer payload
+    if (eventData) {
+      payload.devPayload = Utils.encodeToBase64(eventData);
+    }
+
+    // Check payload size to prevent DoS attacks (max 250KB)
+    if (Utils.isPayloadOversized(payload)) {
+      Logger.logError('SST payload exceeds 250KB limit, dropping event');
+      this.reportError(
+        'm::postSST',
+        new Error('Payload size exceeds 250KB limit')
+      );
+      return;
+    }
+
+    // Build URL with event tracking params
+    const eventParams = `eid=${encodeURIComponent(
+      evtId
+    )}&enm=${encodeURIComponent(eventName)}`;
+    const postPath = `${DataStore.getSSTUrl()}/${
+      payload.dws ?? 'n'
+    }/${Utils.getUniqueID()}?${eventParams}`;
+
+    NetworkService.sendPostRequest(postPath, payload);
   }
 
   static postAttrInfo(payload: MapLike): void {

package/src/common/storage-helper.ts

@@ -0,0 +1,260 @@
+/**
+ * Storage helper for data element storage duration
+ * Handles SESSION (in-memory) and VISITOR (AsyncStorage with 30-day expiry) storage
+ */
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { DeStorageDuration } from '../models/mp-client-sdk';
+import { Logger } from './logger';
+
+// AsyncStorage key for visitor-scoped data elements
+const VISITOR_STORE_KEY = '_mp_de_visitor_store';
+
+// 30 days in milliseconds
+const VISITOR_EXPIRY_MS = 30 * 24 * 60 * 60 * 1000;
+
+// Interface for stored visitor values (includes timestamp for expiry check)
+interface StoredVisitorValue {
+  value: any;
+  timestamp: number;
+}
+
+export class StorageHelper {
+  // In-memory store for SESSION-scoped values (cleared on app restart)
+  private static sessionStore: Record<string, any> = {};
+
+  // In-memory cache of visitor store (loaded from AsyncStorage on init)
+  private static visitorStoreCache: Record<string, StoredVisitorValue> = {};
+
+  // Flag to track if initialized
+  private static isInitialized = false;
+
+  /**
+   * Initialize the storage helper
+   * Loads visitor store from AsyncStorage and cleans expired values
+   * Should be called once during SDK initialization
+   */
+  static async initialize(): Promise<void> {
+    if (this.isInitialized) {
+      return;
+    }
+
+    try {
+      // Load visitor store from AsyncStorage
+      const storedData = await AsyncStorage.getItem(VISITOR_STORE_KEY);
+      if (storedData) {
+        this.visitorStoreCache = JSON.parse(storedData);
+        Logger.logDbg(
+          'StorageHelper: Loaded visitor store with',
+          Object.keys(this.visitorStoreCache).length,
+          'items'
+        );
+      }
+
+      // Clean expired visitor data
+      await this.clearExpiredVisitorData();
+
+      this.isInitialized = true;
+      Logger.logDbg('StorageHelper: Initialized successfully');
+    } catch (err) {
+      Logger.logError('StorageHelper: Error initializing', err);
+      // Reset to empty state on error
+      this.visitorStoreCache = {};
+      this.isInitialized = true;
+    }
+  }
+
+  /**
+   * Clear visitor-scoped values older than 30 days
+   */
+  static async clearExpiredVisitorData(): Promise<void> {
+    try {
+      const now = Date.now();
+      const keysToRemove: string[] = [];
+
+      for (const key of Object.keys(this.visitorStoreCache)) {
+        const entry = this.visitorStoreCache[key];
+        if (entry && now - entry.timestamp > VISITOR_EXPIRY_MS) {
+          keysToRemove.push(key);
+        }
+      }
+
+      if (keysToRemove.length > 0) {
+        for (const key of keysToRemove) {
+          delete this.visitorStoreCache[key];
+        }
+
+        // Persist the cleaned store
+        await this.persistVisitorStore();
+
+        Logger.logDbg(
+          'StorageHelper: Cleared',
+          keysToRemove.length,
+          'expired visitor values'
+        );
+      }
+    } catch (err) {
+      Logger.logError('StorageHelper: Error clearing expired data', err);
+    }
+  }
+
+  /**
+   * Persist the visitor store cache to AsyncStorage
+   */
+  private static async persistVisitorStore(): Promise<void> {
+    try {
+      await AsyncStorage.setItem(
+        VISITOR_STORE_KEY,
+        JSON.stringify(this.visitorStoreCache)
+      );
+    } catch (err) {
+      Logger.logError('StorageHelper: Error persisting visitor store', err);
+    }
+  }
+
+  /**
+   * Check if a value is defined (not null, undefined, or empty string)
+   */
+  private static isDefined(value: any): boolean {
+    return value !== null && value !== undefined && value !== '';
+  }
+
+  /**
+   * Store a data element value based on storage duration
+   * @param deKey - The data element key
+   * @param value - The value to store
+   * @param storageDuration - The storage duration type
+   */
+  static deStorageDurationSet(
+    deKey: string,
+    value: any,
+    storageDuration: DeStorageDuration
+  ): void {
+    try {
+      if (!this.isDefined(deKey) || !this.isDefined(value)) {
+        // Key and value are required
+        return;
+      }
+
+      if (!storageDuration) {
+        storageDuration = DeStorageDuration.EVENT;
+      }
+
+      switch (storageDuration) {
+        case DeStorageDuration.SESSION:
+          // Store in memory (cleared on app restart)
+          this.sessionStore[deKey] = value;
+          Logger.logDbg('StorageHelper: Stored SESSION value for', deKey);
+          break;
+
+        case DeStorageDuration.VISITOR:
+          // Store in AsyncStorage cache with timestamp
+          this.visitorStoreCache[deKey] = {
+            value: value,
+            timestamp: Date.now(),
+          };
+          // Persist to AsyncStorage in background
+          this.persistVisitorStore().catch((err) => {
+            Logger.logError(
+              'StorageHelper: Error persisting visitor value',
+              err
+            );
+          });
+          Logger.logDbg('StorageHelper: Stored VISITOR value for', deKey);
+          break;
+
+        case DeStorageDuration.EVENT:
+        case DeStorageDuration.NONE:
+        default:
+          // No persistence needed for EVENT or NONE
+          break;
+      }
+    } catch (err) {
+      Logger.logError('StorageHelper: Error in deStorageDurationSet', err);
+    }
+  }
+
+  /**
+   * Retrieve a data element value based on storage duration
+   * @param deKey - The data element key
+   * @param defaultValue - Default value if not found
+   * @param storageDuration - The storage duration type
+   * @returns The stored value or default value
+   */
+  static deStorageDurationGet(
+    deKey: string,
+    defaultValue: any,
+    storageDuration: DeStorageDuration
+  ): any {
+    try {
+      if (!this.isDefined(deKey)) {
+        return defaultValue;
+      }
+
+      if (!storageDuration) {
+        storageDuration = DeStorageDuration.EVENT;
+      }
+
+      switch (storageDuration) {
+        case DeStorageDuration.SESSION: {
+          // Get from in-memory session store
+          const sessionValue = this.sessionStore[deKey];
+          if (this.isDefined(sessionValue)) {
+            return sessionValue;
+          }
+          return defaultValue;
+        }
+
+        case DeStorageDuration.VISITOR: {
+          // Get from visitor store cache
+          const visitorEntry = this.visitorStoreCache[deKey];
+          if (visitorEntry && this.isDefined(visitorEntry.value)) {
+            // Check if not expired
+            if (Date.now() - visitorEntry.timestamp <= VISITOR_EXPIRY_MS) {
+              return visitorEntry.value;
+            } else {
+              // Value is expired, remove it
+              delete this.visitorStoreCache[deKey];
+              this.persistVisitorStore().catch((err) => {
+                Logger.logError(
+                  'StorageHelper: Error removing expired value',
+                  err
+                );
+              });
+            }
+          }
+          return defaultValue;
+        }
+
+        case DeStorageDuration.EVENT:
+        case DeStorageDuration.NONE:
+        default:
+          // No retrieval for EVENT or NONE
+          return defaultValue;
+      }
+    } catch (err) {
+      Logger.logError('StorageHelper: Error in deStorageDurationGet', err);
+      return defaultValue;
+    }
+  }
+
+  /**
+   * Clear all session-scoped values (called on new session if needed)
+   */
+  static clearSessionStore(): void {
+    this.sessionStore = {};
+    Logger.logDbg('StorageHelper: Cleared session store');
+  }
+
+  /**
+   * Clear all visitor-scoped values
+   */
+  static async clearVisitorStore(): Promise<void> {
+    try {
+      this.visitorStoreCache = {};
+      await AsyncStorage.removeItem(VISITOR_STORE_KEY);
+      Logger.logDbg('StorageHelper: Cleared visitor store');
+    } catch (err) {
+      Logger.logError('StorageHelper: Error clearing visitor store', err);
+    }
+  }
+}