@mparticle/web-sdk 3.11.0 → 3.12.0

package/src/consent.ts

@@ -285,37 +285,52 @@ export default function Consent(this: IConsent, mpInstance: IMParticleWebSDKInst
 
         fromMinifiedJsonObject(json: IMinifiedConsentJSONObject): ConsentState {
             const state: ConsentState = self.createConsentState();
-            if (json.gdpr) {
+            if (!isObject(json)) {
+                return state;
+            }
+            if (isObject(json.gdpr)) {
                 for (const purpose in json.gdpr) {
                     if (hasOwnProp(json.gdpr, purpose)) {
-                        const gdprConsent = self.createPrivacyConsent(
-                            json.gdpr[purpose].c,
-                            json.gdpr[purpose].ts,
-                            json.gdpr[purpose].d,
-                            json.gdpr[purpose].l,
-                            json.gdpr[purpose].h
+                        state.addGDPRConsentState(
+                            purpose,
+                            privacyConsentFromMinifiedJson(json.gdpr[purpose])
                         );
-                        state.addGDPRConsentState(purpose, gdprConsent);
                     }
                 }
             }
 
-            if (json.ccpa) {
+            if (isObject(json.ccpa)) {
                 if (hasOwnProp(json.ccpa, CCPAPurpose)) {
-                    const ccpaConsent = self.createPrivacyConsent(
-                        json.ccpa[CCPAPurpose].c,
-                        json.ccpa[CCPAPurpose].ts,
-                        json.ccpa[CCPAPurpose].d,
-                        json.ccpa[CCPAPurpose].l,
-                        json.ccpa[CCPAPurpose].h
+                    state.setCCPAConsentState(
+                        privacyConsentFromMinifiedJson(json.ccpa[CCPAPurpose])
                     );
-                    state.setCCPAConsentState(ccpaConsent);
                 }
             }
             return state;
         },
     };
 
+    function privacyConsentFromMinifiedJson(
+        minifiedConsent: IPrivacyV2DTO
+    ): PrivacyConsentState | null {
+        if (!isObject(minifiedConsent)) {
+            return null;
+        }
+        const timestampIsObject =
+            typeof minifiedConsent.ts === 'object' &&
+            minifiedConsent.ts !== null;
+        if (timestampIsObject) {
+            return null;
+        }
+        return self.createPrivacyConsent(
+            minifiedConsent.c,
+            minifiedConsent.ts,
+            minifiedConsent.d,
+            minifiedConsent.l,
+            minifiedConsent.h
+        );
+    }
+
     // TODO: Refactor this method into a constructor
     this.createConsentState = function(
         this: ConsentState,

package/src/events.ts

@@ -402,7 +402,7 @@ export default function Events(
         eventType: valueof<typeof EventType>
     ): void {
         let elements: ArrayLike<Element> | Element[] = [],
-            handler = function(e: Event): void {
+            handler = function(e: Event, element: DOMHandlerElement): void {
                 const timeoutHandler = function(): void {
                     if (element.href) {
                         window.location.href = element.href;
@@ -447,7 +447,6 @@ export default function Events(
                     );
                 }
             },
-            element: DOMHandlerElement,
             i: number;
 
         if (!selector) {
@@ -472,17 +471,20 @@ export default function Events(
             );
 
             for (i = 0; i < elements.length; i++) {
-                element = elements[i] as DOMHandlerElement;
+                const element = elements[i] as DOMHandlerElement;
+                const elementHandler = function(e: Event): void {
+                    handler(e, element);
+                };
 
                 if (element.addEventListener) {
                     // Modern browsers
-                    element.addEventListener(domEvent, handler, false);
+                    element.addEventListener(domEvent, elementHandler, false);
                 } else if (element.attachEvent) {
                     // IE < 9
-                    element.attachEvent('on' + domEvent, handler);
+                    element.attachEvent('on' + domEvent, elementHandler);
                 } else {
                     // All other browsers
-                    (element as any)['on' + domEvent] = handler;
+                    (element as any)['on' + domEvent] = elementHandler;
                 }
             }
         } else {

package/src/identity.ts

@@ -1498,10 +1498,6 @@ export default function Identity(
                     mpInstance._Persistence.update();
                     mpInstance._Store.syncPersistenceData();
 
-                    mpInstance._Persistence.findPrevCookiesBasedOnUI(
-                        identityApiData
-                    );
-
                     // https://go.mparticle.com/work/SQDSDKS-6357
                     mpInstance._Store.context =
                         identityApiResult.context || mpInstance._Store.context;

package/src/kitBlocking.ts

@@ -20,6 +20,10 @@ const DataPlanMatchType = {
     ProductImpression: "product_impression"
 }
 
+const withNoChange = (event: SDKEvent): SDKEvent => event;
+const withoutUserAttributes = (event: SDKEvent): SDKEvent => ({ ...event, UserAttributes: {} });
+const withoutUserIdentities = (event: SDKEvent): SDKEvent => ({ ...event, UserIdentities: [] });
+
 /*  
     inspiration from https://github.com/mParticle/data-planning-node/blob/master/src/data_planning/data_plan_event_validator.ts
     but modified to only include commerce events, custom events, screen views, and removes validation
@@ -318,29 +322,51 @@ export default class KitBlocker {
             then product attributes if applicable, then user attributes, 
             then the user identities
         */
-       try {
-           if (event) {
-               event = this.transformEventAndEventAttributes(event)
-           }
-       
-           if (event && event.EventDataType === Types.MessageType.Commerce) {
-               event = this.transformProductAttributes(event);
-           }
-   
-           if (event) {
-               event = this.transformUserAttributes(event);
-               event = this.transformUserIdentities(event);
-           }
-
-           return event;
-       } catch(e) {
+        if (event) {
+            event = this.applyBlockingStep('the event and its attributes', this.transformEventAndEventAttributes, event, withNoChange);
+        }
+
+        if (event && event.EventDataType === Types.MessageType.Commerce) {
+            event = this.applyBlockingStep('product attributes', this.transformProductAttributes, event, withNoChange);
+        }
+
+        if (event) {
+            event = this.applyBlockingStep('user attributes', this.transformUserAttributes, event, withoutUserAttributes);
+            event = this.applyBlockingStep('user identities', this.transformUserIdentities, event, withoutUserIdentities);
+        }
+
         return event;
-       }
+    }
+
+    applyBlockingStep(
+        filteredData: string,
+        step: (event: SDKEvent) => SDKEvent,
+        event: SDKEvent,
+        onFailure: (event: SDKEvent) => SDKEvent
+    ): SDKEvent {
+        try {
+            return step.call(this, event);
+        } catch (stepError) {
+            const fallbackEvent = onFailure(event);
+            this.reportFailedStep(filteredData, stepError);
+            return fallbackEvent;
+        }
+    }
+
+    reportFailedStep(filteredData: string, stepError: unknown): void {
+        try {
+            this.mpInstance.Logger.error('Kit blocking could not filter ' + filteredData + ': ' + stepError);
+        } catch {
+            // Best-effort: a logger or error value that throws must not stop the remaining steps.
+        }
     }
 
     transformEventAndEventAttributes(event: SDKEvent): SDKEvent {
         const clonedEvent = {...event};
         const baseEvent: BaseEvent = convertEvent(clonedEvent);
+        if (!baseEvent) {
+            return clonedEvent;
+        }
         const matchKey: string = this.getMatchKey(baseEvent);
         const matchedEvent = this.dataPlanMatchLookups[matchKey];
 
@@ -364,7 +390,7 @@ export default class KitBlocker {
                 return clonedEvent;
             }
             if (matchedEvent) {
-                for (const key of Object.keys(clonedEvent.EventAttributes)) {
+                for (const key of Object.keys(clonedEvent.EventAttributes ?? {})) {
                     if (!matchedEvent[key]) {
                         delete clonedEvent.EventAttributes[key];
                     }
@@ -384,13 +410,18 @@ export default class KitBlocker {
         const matchKey: string = this.getProductAttributeMatchKey(baseEvent);
         const matchedEvent = this.dataPlanMatchLookups[matchKey];
 
-        function removeAttribute(matchedEvent: { [key: string]: string }, productList: SDKProduct[]): void {
-            productList.forEach(product => { 
+        function withPlannedAttributesOnly(plannedAttributes: { [key: string]: boolean }, productList: SDKProduct[]): SDKProduct[] {
+            return productList?.map(product => {
+                if (!product.Attributes) {
+                    return product;
+                }
+                const attributes = {};
                 for (const productKey of Object.keys(product.Attributes)) {
-                    if (!matchedEvent[productKey]) {
-                        delete product.Attributes[productKey];
+                    if (plannedAttributes[productKey] === true) {
+                        attributes[productKey] = product.Attributes[productKey];
                     }
                 }
+                return { ...product, Attributes: attributes };
             });
         }
 
@@ -414,17 +445,18 @@ export default class KitBlocker {
                 return clonedEvent;
             }
             if (matchedEvent) {
-                switch (event.EventCategory) {
-                    case Types.CommerceEventType.ProductImpression:
-                        clonedEvent.ProductImpressions.forEach(impression=> {
-                            removeAttribute(matchedEvent, impression?.ProductList)
-                        });
-                        break;
-                    case Types.CommerceEventType.ProductPurchase:
-                        removeAttribute(matchedEvent, clonedEvent.ProductAction?.ProductList)
-                        break;
-                    default: 
-                        this.mpInstance.Logger.warning('Product Not Supported ')
+                if (clonedEvent.ProductAction) {
+                    clonedEvent.ProductAction = {
+                        ...clonedEvent.ProductAction,
+                        ProductList: withPlannedAttributesOnly(matchedEvent, clonedEvent.ProductAction.ProductList),
+                    };
+                } else if (clonedEvent.ProductImpressions) {
+                    clonedEvent.ProductImpressions = clonedEvent.ProductImpressions.map(impression => ({
+                        ...impression,
+                        ProductList: withPlannedAttributesOnly(matchedEvent, impression.ProductList),
+                    }));
+                } else {
+                    this.mpInstance.Logger.warning('Product Not Supported ')
                 }
                 
                 return clonedEvent;
@@ -439,17 +471,15 @@ export default class KitBlocker {
     transformUserAttributes(event: SDKEvent) {
         const clonedEvent = {...event};
         if (this.blockUserAttributes) {
-            /* 
-                If the user attribute is not found in the matchedAttributes
-                then remove it from event.UserAttributes as it is blocked
-            */
             const matchedAttributes = this.dataPlanMatchLookups['user_attributes'];
-            if (this.mpInstance._Helpers.isObject(matchedAttributes)) {
+            if (this.mpInstance._Helpers.isObject(matchedAttributes) && clonedEvent.UserAttributes) {
+                const plannedUserAttributes = {};
                 for (const ua of Object.keys(clonedEvent.UserAttributes)) {
-                    if (!matchedAttributes[ua]) {
-                        delete clonedEvent.UserAttributes[ua]
+                    if (matchedAttributes[ua] === true) {
+                        plannedUserAttributes[ua] = clonedEvent.UserAttributes[ua];
                     }
                 }
+                clonedEvent.UserAttributes = plannedUserAttributes;
             }
         }
     
@@ -507,27 +537,18 @@ export default class KitBlocker {
     }
 
     transformUserIdentities(event: SDKEvent) {
-            /* 
-                If the user identity is not found in matchedIdentities
-                then remove it from event.UserIdentities as it is blocked.
-                event.UserIdentities is of type [{Identity: 'id1', Type: 7}, ...]
-                and so to compare properly in matchedIdentities, each Type needs 
-                to be converted to an identityName
-            */
         const clonedEvent = {...event};
 
         if (this.blockUserIdentities) {
             const matchedIdentities = this.dataPlanMatchLookups['user_identities'];
             if (this.mpInstance._Helpers.isObject(matchedIdentities)) {
                 if (clonedEvent?.UserIdentities?.length) {
-                    clonedEvent.UserIdentities.forEach((uiByType, i) => {
+                    clonedEvent.UserIdentities = clonedEvent.UserIdentities.filter(uiByType => {
                         const identityName = Types.IdentityType.getIdentityName(
                             this.mpInstance._Helpers.parseNumber(uiByType.Type)
                         );
-    
-                        if (!matchedIdentities[identityName]) {
-                            clonedEvent.UserIdentities.splice(i, 1);
-                        }
+
+                        return matchedIdentities[identityName];
                     });
                 }
             }

package/src/nativeSdkHelpers.ts

@@ -118,7 +118,7 @@ export default function NativeSdkHelpers(
     this.isBridgeV1Available = function(): boolean {
         if (
             mpInstance._Store.SDKConfig.useNativeSdk ||
-            window.mParticleAndroid ||
+            getAndroidBridge(androidBridgeNameBase) ||
             mpInstance._Store.SDKConfig.isIOS
         ) {
             return true;
@@ -160,14 +160,13 @@ export default function NativeSdkHelpers(
     };
 
     this.sendViaBridgeV1 = function(path: string, value: string): void {
-        if (
-            window.mParticleAndroid &&
-            window.mParticleAndroid.hasOwnProperty(path)
-        ) {
+        const androidBridge = getAndroidBridge(androidBridgeNameBase);
+
+        if (androidBridge && androidBridge.hasOwnProperty(path)) {
             mpInstance.Logger.verbose(
                 Messages.InformationMessages.SendAndroid + path
             );
-            window.mParticleAndroid[path](value);
+            androidBridge[path](value);
         } else if (mpInstance._Store.SDKConfig.isIOS) {
             mpInstance.Logger.verbose(
                 Messages.InformationMessages.SendIOS + path

package/src/persistence.interfaces.ts

@@ -1,5 +1,4 @@
 import {
-    IdentityApiData,
     MPID,
     Product,
     UserIdentities,
@@ -111,7 +110,6 @@ export interface IPersistence {
         domain: string,
         maxCookieSize: number
     ): string;
-    findPrevCookiesBasedOnUI(identityApiData: IdentityApiData): void;
     encodePersistence(persistence: string): string;
     decodePersistence(persistenceString: string | null): string | void;
     getCookieDomain(): string;

package/src/persistence.ts

@@ -3,7 +3,7 @@ import Polyfill from './polyfill';
 import * as Utils from './utils';
 import { IMParticleWebSDKInstance } from './mp-instance';
 import { IPersistence, IPersistenceMinified } from './persistence.interfaces';
-import { IdentityApiData, MPID } from '@mparticle/web-sdk';
+import { MPID } from '@mparticle/web-sdk';
 import { CookieSyncDates } from './cookieSyncManager';
 import { Dictionary } from './utils';
 import { IMParticleInstanceManager } from './sdkRuntimeModels';
@@ -85,9 +85,9 @@ export default function _Persistence(
     ) {
         if (!cookies) {
             self.storeDataInMemory(localStorageData);
-            return;
+            return undefined;
         }
-        const allData = mergeStorageSources(localStorageData, cookies);
+        const allData = localStorageData || cookies;
         self.storeDataInMemory(allData);
         self.expireCookies(mpInstance._Store.storageName);
         return allData;
@@ -122,21 +122,24 @@ export default function _Persistence(
         }
     }
 
-    function clearCorruptStorage(): void {
+    function clearCorruptStorage(cookieWasLoaded: boolean): void {
         if (
             self.useLocalStorage() &&
             mpInstance._Store.isLocalStorageAvailable
         ) {
-            localStorage.removeItem(mpInstance._Store.storageName);
+            if (!cookieWasLoaded) {
+                localStorage.removeItem(mpInstance._Store.storageName);
+            }
             return;
         }
         self.expireCookies(mpInstance._Store.storageName);
     }
 
     this.initializeStorage = function(): void {
+        let cookies: IPersistenceMinified | null = null;
         try {
             const localStorageData = self.getLocalStorage();
-            const cookies = self.getCookie();
+            cookies = self.getCookie();
 
             // https://go.mparticle.com/work/SQDSDKS-6045
             setFirstRunFromExistingData(localStorageData, cookies);
@@ -156,7 +159,7 @@ export default function _Persistence(
         } catch (e) {
             // If cookies or local storage is corrupt, we want to remove it
             // so that in the future, initializeStorage will work
-            clearCorruptStorage();
+            clearCorruptStorage(Boolean(cookies));
             mpInstance.Logger.error('Error initializing storage: ' + e);
         }
     };
@@ -417,10 +420,7 @@ export default function _Persistence(
             l,
             parts,
             name,
-            cookie,
-            result: string | Dictionary<string> | undefined = key
-                ? undefined
-                : {};
+            cookie;
 
         mpInstance.Logger.verbose(Messages.InformationMessages.CookieSearch);
 
@@ -443,25 +443,23 @@ export default function _Persistence(
             }
 
             if (key && key === name) {
-                result = (mpInstance._Helpers as Dictionary).converted(cookie);
-                break;
-            }
+                const decodedPersistence = self.decodePersistence(
+                    (mpInstance._Helpers as Dictionary).converted(cookie)
+                );
+                const persistence = decodedPersistence
+                    ? JSON.parse(decodedPersistence)
+                    : null;
 
-            if (!key) {
-                (result as Dictionary<string>)[name as string] = (
-                    mpInstance._Helpers as Dictionary
-                ).converted(cookie);
+                if (mpInstance._Helpers.isObject(persistence)) {
+                    mpInstance.Logger.verbose(
+                        Messages.InformationMessages.CookieFound
+                    );
+                    return persistence;
+                }
             }
         }
 
-        if (result) {
-            mpInstance.Logger.verbose(Messages.InformationMessages.CookieFound);
-            return JSON.parse(
-                self.decodePersistence(result as string) as string
-            );
-        } else {
-            return null;
-        }
+        return null;
     };
 
     // https://go.mparticle.com/work/SQDSDKS-5022
@@ -746,85 +744,6 @@ export default function _Persistence(
         );
     }
 
-    function cookieUiMatchesRequestedIdentity(
-        cookieUIs,
-        requestedIdentityType: string,
-        requestedValue
-    ): boolean {
-        for (let cookieUIType in cookieUIs) {
-            if (
-                requestedIdentityType === cookieUIType &&
-                requestedValue === cookieUIs[cookieUIType]
-            ) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    function findMpidForRequestedIdentity(
-        persistence: IPersistenceMinified,
-        requestedIdentityType: string,
-        requestedValue
-    ) {
-        let matchedUser;
-        for (let key in persistence) {
-            // any value in persistence that has an MPID key will be an MPID to search through
-            // other keys on the cookie are currentSessionMPIDs and currentMPID which should not be searched
-            if (
-                !mpInstance._Helpers.isObject(persistence[key]) ||
-                !persistence[key].mpid
-            ) {
-                continue;
-            }
-            if (
-                cookieUiMatchesRequestedIdentity(
-                    persistence[key].ui,
-                    requestedIdentityType,
-                    requestedValue
-                )
-            ) {
-                matchedUser = key;
-            }
-        }
-        return matchedUser;
-    }
-
-    function findMpidMatchingIdentities(
-        persistence: IPersistenceMinified | null,
-        identityApiData: IdentityApiData
-    ) {
-        let matchedUser;
-        for (let requestedIdentityType in identityApiData.userIdentities) {
-            if (!persistence || !Object.keys(persistence).length) {
-                continue;
-            }
-            const match = findMpidForRequestedIdentity(
-                persistence,
-                requestedIdentityType,
-                identityApiData.userIdentities[requestedIdentityType]
-            );
-            if (match) {
-                matchedUser = match;
-            }
-        }
-        return matchedUser;
-    }
-
-    this.findPrevCookiesBasedOnUI = function(identityApiData: IdentityApiData): void {
-        const persistence = mpInstance._Persistence.getPersistence();
-        if (!identityApiData) {
-            return;
-        }
-        const matchedUser = findMpidMatchingIdentities(
-            persistence,
-            identityApiData
-        );
-        if (matchedUser) {
-            self.storeDataInMemory(persistence, matchedUser);
-        }
-    };
-
     function isNonEmptyArrayOrObject(value): boolean {
         if (Array.isArray(value)) {
             return value.length > 0;
@@ -947,8 +866,6 @@ export default function _Persistence(
                 continue;
             }
             if (!SDKv2NonMPIDCookieKeys[mpid]) {
-                // Written as an object by encodeMpidRecords, then read as one by
-                // findMpidForRequestedIdentity and copied by copyNonCurrentUserMpids.
                 if (!mpInstance._Helpers.isObject(persistence[mpid])) {
                     delete persistence[mpid];
                     continue;

package/src/roktManager.ts

@@ -26,6 +26,8 @@ import { subscribeToRouteChange } from "./routeChangeMonitor";
 
 const PASSBACK_CONVERSION_TRACKING_ID = 'passbackconversiontrackingid';
 
+type AttributeTargetUser = Pick<IMParticleUser, 'getUserIdentities' | 'setUserAttributes'>;
+
 // https://docs.rokt.com/developers/integration-guides/web/library/attributes
 export type RoktAttributeValueArray = Array<string | number | boolean>;
 export type RoktAttributeValueType = string | number | boolean | undefined | null;
@@ -374,7 +376,11 @@ export default class RoktManager {
                 });
             }
             
-            if (!isEmpty(newIdentities)) {
+            const userAttributes = this.toUserAttributes(mappedAttributes);
+
+            if (isEmpty(newIdentities)) {
+                this.setUserAttributes(this.currentUser, userAttributes);
+            } else {
                 // Fire-and-forget identify — best-effort, does not block selectPlacements
                 try {
                     this.identityService.identify(
@@ -391,6 +397,7 @@ export default class RoktManager {
                                     'Background identify failed with HTTP ' + httpCode
                                 );
                             }
+                            this.setUserAttributes(result?.getUser?.(), userAttributes, newIdentities);
                             // Drain any selectPlacements calls that were deferred while
                             // identify was in-flight. By the time this callback fires,
                             // identityCallInFlight has already been reset to false.
@@ -402,6 +409,7 @@ export default class RoktManager {
                         'Background identify threw an error: ' +
                             getErrorMessage(error)
                     );
+                    this.setUserAttributes(this.identityService.getCurrentUser(), userAttributes, newIdentities);
                 }
             }
 
@@ -411,8 +419,6 @@ export default class RoktManager {
             // so stale identity state does not persist beyond this invocation.
             const finalUserIdentities = { ...currentUserIdentities, ...newIdentities };
 
-            this.setUserAttributes(mappedAttributes);
-
             const timeOnSite = this.store?.getTimeOnSite?.();
             const totalTimeOnSite = this.store?.getTotalTimeOnSite?.();
 
@@ -641,7 +647,7 @@ export default class RoktManager {
         return Boolean(this.kit && this.kit.launcher);
     }
 
-    private setUserAttributes(attributes: RoktAttributes): void {
+    private toUserAttributes(attributes: RoktAttributes): Dictionary<RoktAttributeValueType> {
         const reservedAttributes = ['sandbox'];
         const filteredAttributes = {};
         
@@ -652,13 +658,39 @@ export default class RoktManager {
             }
         }
 
+        return filteredAttributes;
+    }
+
+    private setUserAttributes(
+        user: AttributeTargetUser | null | undefined,
+        userAttributes: Dictionary<RoktAttributeValueType>,
+        identitiesUserMustNotContradict: UserIdentities = {}
+    ): void {
+        if (!user) {
+            this.logger.warning('selectPlacements attributes were not set because there is no user to set them on.');
+            return;
+        }
+
         try {
-            this.currentUser.setUserAttributes(filteredAttributes);
+            if (this.hasContradictingIdentity(user, identitiesUserMustNotContradict)) {
+                this.logger.warning(
+                    'selectPlacements attributes were not set because identify did not resolve to a user with the passed email or hashed email.'
+                );
+                return;
+            }
+            user.setUserAttributes(userAttributes);
         } catch (error) {
             this.logger.error('Error setting user attributes: ' + error);
         }
     }
 
+    private hasContradictingIdentity(user: AttributeTargetUser, identities: UserIdentities): boolean {
+        return Object.keys(identities).some((identityType) => {
+            const userValue = user.getUserIdentities()?.userIdentities?.[identityType];
+            return Boolean(userValue) && userValue !== identities[identityType];
+        });
+    }
+
     private mapPlacementAttributes(attributes: RoktAttributes, placementAttributesMapping: Dictionary<string>[]): RoktAttributes {
         const mappingLookup: { [key: string]: string } = {};
         for (const mapping of placementAttributesMapping) {