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

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,
@@ -66,6 +83,9 @@ export class Reporter {
     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 {
@@ -90,17 +110,18 @@ export class Reporter {
     eventName: string,
     evtId: string
   ): 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);
+    // 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();
     NetworkService.sendPostRequest(
-      `${DataStore.getSSTUrl()}/${data.dws ?? 'n'}/${evtId}`,
-      data
+      `${DataStore.getSSTUrl()}/${payload.dws ?? 'n'}/${evtId}`,
+      payload
     );
   }
 

package/src/common/storage-helper.ts

@@ -0,0 +1,266 @@
+/**
+ * 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);
+    }
+  }
+}

package/src/common/utils.ts

@@ -11,6 +11,7 @@ import { EventBus } from './event-bus';
 import { Dimensions, ScaledSize } from 'react-native';
 import { URL } from 'react-native-url-polyfill';
 import AsyncStorage from '@react-native-async-storage/async-storage';
+import { ulid } from 'ulid';
 
 export class Utils {
   static triggerEvent(eventName: string, payload: any): void {
@@ -136,7 +137,7 @@ export class Utils {
         if (tfItem.eTyp === 'URL_ENC') {
           paramValue = encodeURIComponent(paramValue);
         } else if (tfItem.eTyp === 'BASE64') {
-          paramValue = Buffer.from(paramValue).toString('base64');
+          paramValue = this.toBase64(paramValue);
         }
       }
     }
@@ -204,8 +205,25 @@ export class Utils {
     }
   }
 
+  /**
+   * Encode string to Base64 - React Native compatible
+   * Works with both ASCII and UTF-8 strings
+   * @param str String to encode
+   * @returns Base64 encoded string
+   */
+  static toBase64(str: string): string {
+    try {
+      // Handle UTF-8 strings properly using encodeURIComponent + unescape trick
+      // This works in all JavaScript engines including React Native's Hermes/JSC
+      return btoa(unescape(encodeURIComponent(str)));
+    } catch (err) {
+      Logger.logError('Error encoding to Base64:', err);
+      return str; // Return original value if encoding fails
+    }
+  }
+
   static getUniqueID(): string {
-    return Constants.LARGE_RANDOM_POOL();
+    return ulid();
   }
 
   /**