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

package/src/common/utils.ts

@@ -11,6 +11,10 @@ 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';
+
+/** Maximum payload size in bytes (250KB) to prevent DoS attacks */
+const MAX_PAYLOAD_SIZE_BYTES = 250 * 1024;
 
 export class Utils {
   static triggerEvent(eventName: string, payload: any): void {
@@ -136,7 +140,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 +208,65 @@ 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
+    }
+  }
+
+  /**
+   * Encode an object payload to Base64 string
+   * @param payload Object to encode
+   * @returns Base64 encoded string, or empty string on error
+   */
+  static encodeToBase64(payload: Record<string, any>): string {
+    try {
+      const jsonStr = JSON.stringify(payload);
+      return this.toBase64(jsonStr);
+    } catch (err) {
+      Logger.logError('Error encoding payload to Base64:', err);
+      return '';
+    }
+  }
+
+  /**
+   * Get the size of a payload in bytes
+   * @param payload Object to measure
+   * @returns Size in bytes
+   */
+  static getPayloadSizeBytes(payload: Record<string, any>): number {
+    try {
+      const jsonStr = JSON.stringify(payload);
+      // Use TextEncoder for accurate byte count (handles UTF-8)
+      return new TextEncoder().encode(jsonStr).length;
+    } catch (err) {
+      Logger.logError('Error calculating payload size:', err);
+      return 0;
+    }
+  }
+
+  /**
+   * Check if payload exceeds the maximum allowed size (250KB)
+   * @param payload Object to check
+   * @returns True if payload is oversized
+   */
+  static isPayloadOversized(payload: Record<string, any>): boolean {
+    return this.getPayloadSizeBytes(payload) > MAX_PAYLOAD_SIZE_BYTES;
+  }
+
   static getUniqueID(): string {
-    return Constants.LARGE_RANDOM_POOL();
+    return ulid();
   }
 
   /**

package/src/eedl/eedl.ts

@@ -2,18 +2,15 @@ import { Utils } from '../common/utils';
 import type { EventProcessorFn, MapLike, TypedAny } from '../common/app-types';
 import { Logger } from '../common/logger';
 import AsyncStorage from '@react-native-async-storage/async-storage';
-import { customAlphabet } from 'nanoid/non-secure';
+import { ulid } from 'ulid';
 
 const eventsToPersist: Record<string, string> = {
   user_info: '_mpPendingUserInfo',
   mp_purchase: '_mpPendingPurchase',
 };
 
-// UUID v4 generator for React Native
-const getUUIDV4 = customAlphabet(
-  '1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
-  36
-);
+// Maximum number of events to keep in memory for state tracking and queues
+const MAX_TRACKED_EVENTS = 500;
 
 export class MpDataLayerHelper {
   isReady = false;
@@ -24,8 +21,14 @@ export class MpDataLayerHelper {
   dlInitEvent: string;
   receivedInitialEvent = false;
   eventQueue: Array<any> = [];
+  private isProcessing = false;
   private isEntryPoint = 0;
 
+  // Event deduplication
+  private eventDedupWindowMs = 5000; // Default 5 seconds
+  private eventDeduplicationCache: Map<string, number> = new Map();
+  private purchaseTransactionCache: Map<string, number> = new Map();
+
   constructor(
     private readonly dlEventName: string,
     private readonly dlInitMode: string,
@@ -72,8 +75,135 @@ export class MpDataLayerHelper {
     }
   }
 
+  /**
+   * Set the event deduplication window
+   * @param windowMs Window in milliseconds (0 to disable)
+   */
+  setDeduplicationWindow(windowMs: number): void {
+    this.eventDedupWindowMs = windowMs;
+    Logger.logDbg(`Event deduplication window set to: ${windowMs}ms`);
+  }
+
+  /**
+   * Generate a unique fingerprint for an event
+   * @param eventName Event name
+   * @param payload Event payload
+   * @returns Fingerprint string
+   */
+  private getEventFingerprint(eventName: string, payload: MapLike): string {
+    try {
+      // Use JSON.stringify for deterministic payload representation
+      const payloadStr = JSON.stringify(payload);
+      return `${eventName}::${payloadStr}`;
+    } catch (err) {
+      Logger.logError('Error generating event fingerprint', err);
+      return `${eventName}::${Date.now()}`; // Fallback to never match
+    }
+  }
+
+  /**
+   * Extract transaction_id from purchase event payload
+   * @param payload Event payload
+   * @returns transaction_id or null
+   */
+  private extractTransactionId(payload: MapLike): string | null {
+    // Check common field names for transaction_id
+    return (
+      payload.transaction_id ||
+      payload.transactionId ||
+      payload.orderId ||
+      payload.order_id ||
+      null
+    );
+  }
+
+  /**
+   * Check if event is a duplicate within the deduplication window
+   * @param eventName Event name
+   * @param payload Event payload
+   * @returns true if duplicate, false otherwise
+   */
+  private isDuplicateEvent(eventName: string, payload: MapLike): boolean {
+    // If deduplication is disabled (window = 0), never treat as duplicate
+    if (this.eventDedupWindowMs === 0) {
+      return false;
+    }
+
+    const now = Date.now();
+
+    // Special handling for purchase events - deduplicate by transaction_id
+    if (eventName === 'purchase' || eventName === 'mp_purchase') {
+      const transactionId = this.extractTransactionId(payload);
+
+      if (transactionId) {
+        const lastSeenTs = this.purchaseTransactionCache.get(transactionId);
+
+        if (lastSeenTs && now - lastSeenTs < this.eventDedupWindowMs) {
+          Logger.logDbg(
+            `Duplicate purchase event detected (transaction_id: ${transactionId}) within ${this.eventDedupWindowMs}ms window, skipping`
+          );
+          return true; // Duplicate
+        }
+
+        // Record this transaction
+        this.purchaseTransactionCache.set(transactionId, now);
+      } else {
+        Logger.logDbg(
+          'Purchase event without transaction_id, cannot deduplicate by transaction'
+        );
+      }
+    }
+
+    // General event deduplication by full fingerprint
+    const fingerprint = this.getEventFingerprint(eventName, payload);
+    const lastSeenTs = this.eventDeduplicationCache.get(fingerprint);
+
+    if (lastSeenTs && now - lastSeenTs < this.eventDedupWindowMs) {
+      Logger.logDbg(
+        `Duplicate event detected (${eventName}) within ${this.eventDedupWindowMs}ms window, skipping`
+      );
+      return true; // Duplicate
+    }
+
+    // Record this event
+    this.eventDeduplicationCache.set(fingerprint, now);
+
+    // Cleanup old entries periodically
+    this.cleanupDeduplicationCache(now);
+
+    return false;
+  }
+
+  /**
+   * Remove expired entries from deduplication caches
+   * @param now Current timestamp
+   */
+  private cleanupDeduplicationCache(now: number): void {
+    // Cleanup general event cache
+    for (const [
+      fingerprint,
+      timestamp,
+    ] of this.eventDeduplicationCache.entries()) {
+      if (now - timestamp > this.eventDedupWindowMs) {
+        this.eventDeduplicationCache.delete(fingerprint);
+      }
+    }
+
+    // Cleanup purchase transaction cache
+    for (const [
+      transactionId,
+      timestamp,
+    ] of this.purchaseTransactionCache.entries()) {
+      if (now - timestamp > this.eventDedupWindowMs) {
+        this.purchaseTransactionCache.delete(transactionId);
+      }
+    }
+  }
+
   pushEvent(eventName: string, payload: MapLike): void {
     Logger.logDbg('EV Push Event:: ', JSON.stringify(payload));
+
+    // Special events bypass queue and process immediately (no deduplication)
     if (
       eventName === 'set' ||
       eventName === 'persist' ||
@@ -84,22 +214,33 @@ export class MpDataLayerHelper {
       this.processQItems(eventName, payload).catch((err) =>
         Logger.logError('Error processing event', err)
       );
-    } else {
-      if (!this.receivedInitialEvent) {
-        // set only if this is not true already
-        this.receivedInitialEvent = eventName === this.dlInitEvent;
-        this.eventQueue.push([eventName, payload]);
-        if (this.isReady && this.receivedInitialEvent) {
-          this.ready();
-        }
-      } else if (!this.isReady) {
-        this.eventQueue.push([eventName, payload]);
-      } else {
-        // fire and forget for async operations
-        this.processQItems(eventName, payload).catch((err) =>
-          Logger.logError('Error processing event', err)
-        );
-      }
+      return;
+    }
+
+    // Check for duplicate events BEFORE queuing
+    if (this.isDuplicateEvent(eventName, payload)) {
+      // Duplicate detected, skip this event
+      return;
+    }
+
+    // Track if we received the initial event
+    if (!this.receivedInitialEvent) {
+      this.receivedInitialEvent = eventName === this.dlInitEvent;
+    }
+
+    // Always queue events for sequential processing (with eviction of oldest if at capacity)
+    if (this.eventQueue.length >= MAX_TRACKED_EVENTS) {
+      const evictedEvent = this.eventQueue.shift();
+      Logger.logDbg(
+        `Event queue at capacity (${MAX_TRACKED_EVENTS}), evicting oldest event:`,
+        evictedEvent?.[0]
+      );
+    }
+    this.eventQueue.push([eventName, payload]);
+
+    // Trigger processing if ready and initial event received
+    if (this.isReady && this.receivedInitialEvent) {
+      this.processNext();
     }
   }
 
@@ -292,8 +433,8 @@ export class MpDataLayerHelper {
     if (eventName === 'reset' || eventName === this.dlInitEvent) {
       this.reset();
 
-      // add an init event based uuid to the core data model
-      model['page_load_uid'] = getUUIDV4();
+      // add an init event based ulid to the core data model
+      model['page_load_uid'] = ulid();
       model['is_entry_point'] = this.getIsEntryPointValue();
       if (model['is_entry_point'] === 1) {
         // Note: In React Native, we don't have document.referrer, so we'll use a placeholder
@@ -341,7 +482,10 @@ export class MpDataLayerHelper {
       })
     );
 
-    // add to state tracker
+    // add to state tracker (with eviction of oldest events if at capacity)
+    if (this.stateTracker.length >= MAX_TRACKED_EVENTS) {
+      this.stateTracker.shift(); // Remove oldest event
+    }
     this.stateTracker.push(eventPayload);
 
     // trigger an event that can be listened to by other listeners
@@ -402,16 +546,32 @@ export class MpDataLayerHelper {
     return true;
   }
 
+  /**
+   * Full shutdown - clears all state and allows reinitialization
+   */
+  shutdown(): void {
+    this.isReady = false;
+    this._masterDataLayer = {};
+    this._persistedVars = {};
+    this.eventProcessors = {};
+    this.stateTracker = [];
+    this.receivedInitialEvent = false;
+    this.eventQueue = [];
+    this.isProcessing = false;
+    this.isEntryPoint = 0;
+    this.eventDeduplicationCache.clear();
+    this.purchaseTransactionCache.clear();
+    Logger.logDbg('EEDL shutdown complete');
+  }
+
   ready(): void {
     this.isReady = true;
     if (this.receivedInitialEvent) {
       Logger.logDbg('Initial event received: ', this.dlInitEvent);
-      // drain queue only if the initial configured event has been received,
-      // otherwise mark isReady but dont drain the queue. queue will be drained first when the init
-      // event is received
-      this.drainQueue().catch((err) =>
-        Logger.logError('Error draining queue', err)
-      );
+      // Start processing queue if we have events and initial event received
+      if (this.eventQueue.length > 0) {
+        this.processNext();
+      }
     } else {
       Logger.logDbg(
         `Initial event (${this.dlInitEvent}) NOT received. Events will be queued`
@@ -419,27 +579,41 @@ export class MpDataLayerHelper {
     }
   }
 
-  async drainQueue(): Promise<void> {
-    Logger.logDbg('drainQueue...');
-    // create a copy of the array
-    const _temp = [...this.eventQueue];
-    // clean the array
-    this.eventQueue.splice(0, this.eventQueue.length);
-    // find the event with dlInit event and execute it first, rest continues
-    const initialEventObjectIndex = _temp.findIndex(
-      (e) => [e][0]?.[0] === this.dlInitEvent
-    );
-    if (initialEventObjectIndex > -1) {
-      // splice and execute it
-      await this.processQItems(
-        _temp[initialEventObjectIndex][0],
-        _temp[initialEventObjectIndex][1]
-      );
-      _temp.splice(initialEventObjectIndex, 1);
+  /**
+   * Process next event in queue with atomic check-and-set
+   * Ensures only one event processes at a time, eliminating race conditions
+   */
+  processNext(): void {
+    // Atomic check-and-set: if already processing or queue empty, return
+    if (this.isProcessing || this.eventQueue.length === 0) {
+      return;
     }
-    // continue with other items
-    for (const item of _temp) {
-      await this.processQItems(item[0], item[1]);
+
+    this.isProcessing = true;
+
+    // Dequeue from front for FIFO ordering
+    const item = this.eventQueue.shift();
+
+    if (item) {
+      const [eventName, payload] = item;
+
+      // Process the event
+      this.processQItems(eventName, payload)
+        .catch((err) => {
+          Logger.logError('Error processing event in queue', err);
+        })
+        .finally(() => {
+          // Reset processing flag
+          this.isProcessing = false;
+
+          // Process next item if queue not empty
+          // Use setImmediate for non-blocking event loop
+          if (this.eventQueue.length > 0) {
+            setImmediate(() => this.processNext());
+          }
+        });
+    } else {
+      this.isProcessing = false;
     }
   }