[MOB-9999] Aggregate user update event gets deleted (#469)

* prettify code

* [MOB-9703] Added support for fetching new JWT prior to calling merge

* [MOB-9999] Aggregate user update event gets deleted

* missed this

* fix up tests and issues

* update types

* update types some more

* forgot to commit this

---------

Co-authored-by: mitch prewitt <mitch.prewitt@iterable.com>

Author: darshan-iterable

src/anonymousUserTracking/anonymousUserEventManager.ts

@@ -2,7 +2,8 @@
 import { v4 as uuidv4 } from 'uuid';
 import {
   UpdateCartRequestParams,
-  TrackPurchaseRequestParams
+  TrackPurchaseRequestParams,
+  CommerceItem
 } from '../commerce/types';
 
 import {
@@ -26,7 +27,8 @@ import {
   KEY_PREFER_USERID,
   ENDPOINTS,
   DEFAULT_EVENT_THRESHOLD_LIMIT,
-  SHARED_PREF_ANON_USAGE_TRACKED
+  SHARED_PREF_ANON_USAGE_TRACKED,
+  SHARED_PREFS_USER_UPDATE_OBJECT_KEY
 } from '../constants';
 import { baseIterableRequest } from '../request';
 import { IterableResponse } from '../types';
@@ -42,6 +44,39 @@ import { updateUserSchema } from '../users/users.schema';
 import { InAppTrackRequestParams } from '../events';
 import config from '../utils/config';
 
+// Type definitions for anonymous event data objects
+type AnonTrackEventData = {
+  eventName: string;
+  createdAt: number;
+  dataFields?: Record<string, any>;
+  createNewFields: boolean;
+  eventType: string;
+};
+
+type AnonTrackPurchaseData = {
+  items: CommerceItem[];
+  createdAt: number;
+  dataFields?: Record<string, any>;
+  total: number;
+  eventType: string;
+};
+
+type AnonUpdateCartData = {
+  items: CommerceItem[];
+  eventType: string;
+  preferUserId: boolean;
+  createdAt: number;
+};
+
+type AnonUserUpdateData = Record<string, any> & {
+  eventType: string;
+};
+
+type AnonEventData =
+  | AnonTrackEventData
+  | AnonTrackPurchaseData
+  | AnonUpdateCartData;
+
 type AnonUserFunction = (userId: string) => void;
 
 let anonUserIdSetter: AnonUserFunction | null = null;
@@ -136,15 +171,15 @@ export class AnonymousUserEventManager {
       [KEY_CREATE_NEW_FIELDS]: true,
       [SHARED_PREFS_EVENT_TYPE]: TRACK_EVENT
     };
-    this.storeEventListToLocalStorage(newDataObject, false);
+    this.storeEventListToLocalStorage(newDataObject);
   }
 
   async trackAnonUpdateUser(payload: UpdateUserParams) {
     const newDataObject = {
       ...payload.dataFields,
       [SHARED_PREFS_EVENT_TYPE]: UPDATE_USER
     };
-    this.storeEventListToLocalStorage(newDataObject, true);
+    this.storeUserUpdateToLocalStorage(newDataObject);
   }
 
   async trackAnonPurchaseEvent(payload: TrackPurchaseRequestParams) {
@@ -155,7 +190,7 @@ export class AnonymousUserEventManager {
       [KEY_TOTAL]: payload.total,
       [SHARED_PREFS_EVENT_TYPE]: TRACK_PURCHASE
     };
-    this.storeEventListToLocalStorage(newDataObject, false);
+    this.storeEventListToLocalStorage(newDataObject);
   }
 
   async trackAnonUpdateCart(payload: UpdateCartRequestParams) {
@@ -165,17 +200,23 @@ export class AnonymousUserEventManager {
       [KEY_PREFER_USERID]: true,
       [KEY_CREATED_AT]: this.getCurrentTime()
     };
-    this.storeEventListToLocalStorage(newDataObject, false);
+    this.storeEventListToLocalStorage(newDataObject);
   }
 
   private checkCriteriaCompletion(): string | null {
     const criteriaData = localStorage.getItem(SHARED_PREFS_CRITERIA);
     const localStoredEventList = localStorage.getItem(
       SHARED_PREFS_EVENT_LIST_KEY
     );
+    const localStoredUserUpdate = localStorage.getItem(
+      SHARED_PREFS_USER_UPDATE_OBJECT_KEY
+    );
     try {
       if (criteriaData && localStoredEventList) {
-        const checker = new CriteriaCompletionChecker(localStoredEventList);
+        const checker = new CriteriaCompletionChecker(
+          localStoredEventList,
+          localStoredUserUpdate
+        );
         return checker.getMatchedCriteria(criteriaData);
       }
     } catch (error) {
@@ -191,14 +232,11 @@ export class AnonymousUserEventManager {
     if (!anonymousUsageTracked) return;
 
     const userData = localStorage.getItem(SHARED_PREFS_ANON_SESSIONS);
-    const eventList = localStorage.getItem(SHARED_PREFS_EVENT_LIST_KEY);
-    const events = eventList ? JSON.parse(eventList) : [];
+    const strUserUpdate = localStorage.getItem(
+      SHARED_PREFS_USER_UPDATE_OBJECT_KEY
+    );
+    const dataFields = strUserUpdate ? JSON.parse(strUserUpdate) : {};
 
-    const dataFields = {
-      ...events.find(
-        (event: any) => event[SHARED_PREFS_EVENT_TYPE] === UPDATE_USER
-      )
-    };
     delete dataFields[SHARED_PREFS_EVENT_TYPE];
 
     const userId = uuidv4();
@@ -238,15 +276,7 @@ export class AnonymousUserEventManager {
         }
       });
       if (response?.status === 200) {
-        // Update local storage, remove updateUser from local storage
-        localStorage.setItem(
-          SHARED_PREFS_EVENT_LIST_KEY,
-          JSON.stringify(
-            events.filter(
-              (event: any) => event[SHARED_PREFS_EVENT_TYPE] !== UPDATE_USER
-            )
-          )
-        );
+        localStorage.removeItem(SHARED_PREFS_USER_UPDATE_OBJECT_KEY);
 
         const onAnonUserCreated = config.getConfig('onAnonUserCreated');
 
@@ -267,6 +297,11 @@ export class AnonymousUserEventManager {
       ? JSON.parse(strTrackEventList)
       : [];
 
+    const strUserUpdate = localStorage.getItem(
+      SHARED_PREFS_USER_UPDATE_OBJECT_KEY
+    );
+    const userUpdateObject = strUserUpdate ? JSON.parse(strUserUpdate) : {};
+
     if (trackEventList.length) {
       trackEventList.forEach(
         (
@@ -288,31 +323,28 @@ export class AnonymousUserEventManager {
               this.updateCart(event);
               break;
             }
-            case UPDATE_USER: {
-              this.updateUser({ dataFields: event });
-              break;
-            }
             default:
               break;
           }
           this.removeAnonSessionCriteriaData();
         }
       );
     }
+
+    if (Object.keys(userUpdateObject).length) {
+      // eslint-disable-next-line no-param-reassign
+      delete userUpdateObject[SHARED_PREFS_EVENT_TYPE];
+      this.updateUser(userUpdateObject);
+    }
   }
 
   removeAnonSessionCriteriaData() {
     localStorage.removeItem(SHARED_PREFS_ANON_SESSIONS);
     localStorage.removeItem(SHARED_PREFS_EVENT_LIST_KEY);
+    localStorage.removeItem(SHARED_PREFS_USER_UPDATE_OBJECT_KEY);
   }
 
-  private async storeEventListToLocalStorage(
-    newDataObject: Record<
-      any /* eslint-disable-line @typescript-eslint/no-explicit-any */,
-      any /* eslint-disable-line @typescript-eslint/no-explicit-any */
-    >,
-    shouldOverWrite: boolean
-  ) {
+  private async storeEventListToLocalStorage(newDataObject: AnonEventData) {
     const anonymousUsageTracked = isAnonymousUsageTracked();
 
     if (!anonymousUsageTracked) return;
@@ -324,24 +356,7 @@ export class AnonymousUserEventManager {
       previousDataArray = JSON.parse(strTrackEventList);
     }
 
-    if (shouldOverWrite) {
-      const trackingType = newDataObject[SHARED_PREFS_EVENT_TYPE];
-      const indexToUpdate = previousDataArray.findIndex(
-        (obj: any) => obj[SHARED_PREFS_EVENT_TYPE] === trackingType
-      );
-      if (indexToUpdate !== -1) {
-        const dataToUpdate = previousDataArray[indexToUpdate];
-
-        previousDataArray[indexToUpdate] = {
-          ...dataToUpdate,
-          ...newDataObject
-        };
-      } else {
-        previousDataArray.push(newDataObject);
-      }
-    } else {
-      previousDataArray.push(newDataObject);
-    }
+    previousDataArray.push(newDataObject);
 
     // - The code below limits the number of events stored in local storage.
     // - The event list acts as a queue, with the oldest events being deleted
@@ -366,6 +381,37 @@ export class AnonymousUserEventManager {
     }
   }
 
+  private async storeUserUpdateToLocalStorage(
+    newDataObject: AnonUserUpdateData
+  ) {
+    const anonymousUsageTracked = isAnonymousUsageTracked();
+
+    if (!anonymousUsageTracked) return;
+
+    const strUserUpdate = localStorage.getItem(
+      SHARED_PREFS_USER_UPDATE_OBJECT_KEY
+    );
+    let userUpdateObject = {};
+
+    if (strUserUpdate) {
+      userUpdateObject = JSON.parse(strUserUpdate);
+    }
+
+    userUpdateObject = {
+      ...userUpdateObject,
+      ...newDataObject
+    };
+
+    localStorage.setItem(
+      SHARED_PREFS_USER_UPDATE_OBJECT_KEY,
+      JSON.stringify(userUpdateObject)
+    );
+    const criteriaId = this.checkCriteriaCompletion();
+    if (criteriaId !== null) {
+      this.createAnonymousUser(criteriaId);
+    }
+  }
+
   private getCurrentTime = () => {
     const dateInMillis = new Date().getTime();
     const dateInSeconds = Math.floor(dateInMillis / 1000);