@mparticle/web-sdk 2.62.0 → 2.64.0

package/src/forwarders.js

@@ -1,9 +1,17 @@
-import Types from './types';
 import filteredMparticleUser from './filteredMparticleUser';
-import { isEmpty } from './utils';
+import { isEmpty, extend } from './utils';
 import KitFilterHelper from './kitFilterHelper';
 import Constants from './constants';
 import APIClient from './apiClient';
+import {
+    isBlockedByForwardingRule,
+    isBlockedByEventFilter,
+    filterEventAttributes,
+    filterUserIdentities,
+    isBatchEventAllowed,
+    filterBatchEventAttributes,
+    filterBatchIdentities,
+} from './forwarder-utils';
 
 const { Modify, Identify, Login, Logout } = Constants.IdentityMethods;
 
@@ -65,7 +73,7 @@ export default function Forwarders(mpInstance, kitBlocker) {
                         userIdentities,
                         forwarder.userIdentityFilters
                     );
-                    var filteredUserAttributes = mpInstance._Helpers.filterUserAttributes(
+                    const filteredUserAttributes = KitFilterHelper.filterUserAttributes(
                         user ? user.getAllUserAttributes() : {},
                         forwarder.userAttributeFilters
                     );
@@ -177,64 +185,9 @@ export default function Forwarders(mpInstance, kitBlocker) {
     };
 
     this.sendEventToForwarders = function(event) {
-        var clonedEvent,
-            hashedEventName,
-            hashedEventType,
-            filterUserIdentities = function(event, filterList) {
-                if (event.UserIdentities && event.UserIdentities.length) {
-                    event.UserIdentities.forEach(function(userIdentity, i) {
-                        if (
-                            mpInstance._Helpers.inArray(
-                                filterList,
-                                KitFilterHelper.hashUserIdentity(
-                                    userIdentity.Type
-                                )
-                            )
-                        ) {
-                            event.UserIdentities.splice(i, 1);
-
-                            if (i > 0) {
-                                i--;
-                            }
-                        }
-                    });
-                }
-            },
-            filterAttributes = function(event, filterList) {
-                var hash;
-
-                if (!filterList) {
-                    return;
-                }
-
-                for (var attrName in event.EventAttributes) {
-                    if (event.EventAttributes.hasOwnProperty(attrName)) {
-                        hash = KitFilterHelper.hashEventAttributeKey(
-                            event.EventCategory,
-                            event.EventName,
-                            attrName
-                        );
-
-                        if (mpInstance._Helpers.inArray(filterList, hash)) {
-                            delete event.EventAttributes[attrName];
-                        }
-                    }
-                }
-            },
-            inFilteredList = function(filterList, hash) {
-                if (filterList && filterList.length) {
-                    if (mpInstance._Helpers.inArray(filterList, hash)) {
-                        return true;
-                    }
-                }
-
-                return false;
-            },
-            forwardingRuleMessageTypes = [
-                Types.MessageType.PageEvent,
-                Types.MessageType.PageView,
-                Types.MessageType.Commerce,
-            ];
+        let clonedEvent;
+        let hashedEventName;
+        let hashedEventType;
 
         if (
             !mpInstance._Store.webviewBridgeEnabled &&
@@ -249,153 +202,61 @@ export default function Forwarders(mpInstance, kitBlocker) {
             );
 
             for (
-                var i = 0;
+                let i = 0;
                 i < mpInstance._Store.activeForwarders.length;
                 i++
             ) {
-                // Check attribute forwarding rule. This rule allows users to only forward an event if a
-                // specific attribute exists and has a specific value. Alternatively, they can specify
-                // that an event not be forwarded if the specified attribute name and value exists.
-                // The two cases are controlled by the "includeOnMatch" boolean value.
-                // Supported message types for attribute forwarding rules are defined in the forwardingRuleMessageTypes array
+                const forwarder = mpInstance._Store.activeForwarders[i];
 
                 if (
-                    forwardingRuleMessageTypes.indexOf(event.EventDataType) >
-                        -1 &&
-                    mpInstance._Store.activeForwarders[i]
-                        .filteringEventAttributeValue &&
-                    mpInstance._Store.activeForwarders[i]
-                        .filteringEventAttributeValue.eventAttributeName &&
-                    mpInstance._Store.activeForwarders[i]
-                        .filteringEventAttributeValue.eventAttributeValue
+                    isBlockedByForwardingRule(
+                        event.EventDataType,
+                        event.EventAttributes,
+                        forwarder
+                    )
                 ) {
-                    var foundProp = null;
-
-                    // Attempt to find the attribute in the collection of event attributes
-                    if (event.EventAttributes) {
-                        for (var prop in event.EventAttributes) {
-                            var hashedEventAttributeName;
-                            hashedEventAttributeName = KitFilterHelper.hashAttributeConditionalForwarding(
-                                prop
-                            );
-
-                            if (
-                                hashedEventAttributeName ===
-                                mpInstance._Store.activeForwarders[i]
-                                    .filteringEventAttributeValue
-                                    .eventAttributeName
-                            ) {
-                                foundProp = {
-                                    name: hashedEventAttributeName,
-                                    value: KitFilterHelper.hashAttributeConditionalForwarding(
-                                        event.EventAttributes[prop]
-                                    ),
-                                };
-                            }
-
-                            if (foundProp) {
-                                break;
-                            }
-                        }
-                    }
-
-                    var isMatch =
-                        foundProp !== null &&
-                        foundProp.value ===
-                            mpInstance._Store.activeForwarders[i]
-                                .filteringEventAttributeValue
-                                .eventAttributeValue;
-
-                    var shouldInclude =
-                        mpInstance._Store.activeForwarders[i]
-                            .filteringEventAttributeValue.includeOnMatch ===
-                        true
-                            ? isMatch
-                            : !isMatch;
-
-                    if (!shouldInclude) {
-                        continue;
-                    }
+                    continue;
                 }
 
                 // Clone the event object, as we could be sending different attributes to each forwarder
-                clonedEvent = {};
-                clonedEvent = mpInstance._Helpers.extend(
-                    true,
-                    clonedEvent,
-                    event
-                );
-                // Check event filtering rules
+                clonedEvent = extend(true, {}, event);
+
                 if (
-                    event.EventDataType === Types.MessageType.PageEvent &&
-                    (inFilteredList(
-                        mpInstance._Store.activeForwarders[i].eventNameFilters,
-                        hashedEventName
-                    ) ||
-                        inFilteredList(
-                            mpInstance._Store.activeForwarders[i]
-                                .eventTypeFilters,
-                            hashedEventType
-                        ))
-                ) {
-                    continue;
-                } else if (
-                    event.EventDataType === Types.MessageType.Commerce &&
-                    inFilteredList(
-                        mpInstance._Store.activeForwarders[i].eventTypeFilters,
-                        hashedEventType
-                    )
-                ) {
-                    continue;
-                } else if (
-                    event.EventDataType === Types.MessageType.PageView &&
-                    inFilteredList(
-                        mpInstance._Store.activeForwarders[i].screenNameFilters,
-                        hashedEventName
+                    isBlockedByEventFilter(
+                        event.EventDataType,
+                        hashedEventName,
+                        hashedEventType,
+                        forwarder
                     )
                 ) {
                     continue;
                 }
 
-                // Check attribute filtering rules
-                if (clonedEvent.EventAttributes) {
-                    if (event.EventDataType === Types.MessageType.PageEvent) {
-                        filterAttributes(
-                            clonedEvent,
-                            mpInstance._Store.activeForwarders[i]
-                                .attributeFilters
-                        );
-                    } else if (
-                        event.EventDataType === Types.MessageType.PageView
-                    ) {
-                        filterAttributes(
-                            clonedEvent,
-                            mpInstance._Store.activeForwarders[i]
-                                .screenAttributeFilters
-                        );
-                    }
-                }
+                clonedEvent.EventAttributes = filterEventAttributes(
+                    event.EventDataType,
+                    event.EventCategory,
+                    event.EventName,
+                    clonedEvent.EventAttributes,
+                    forwarder
+                );
 
                 // Check user identity filtering rules
-                filterUserIdentities(
-                    clonedEvent,
-                    mpInstance._Store.activeForwarders[i].userIdentityFilters
+                clonedEvent.UserIdentities = filterUserIdentities(
+                    clonedEvent.UserIdentities,
+                    forwarder.userIdentityFilters
                 );
 
                 // Check user attribute filtering rules
-                clonedEvent.UserAttributes = mpInstance._Helpers.filterUserAttributes(
+                clonedEvent.UserAttributes = KitFilterHelper.filterUserAttributes(
                     clonedEvent.UserAttributes,
-                    mpInstance._Store.activeForwarders[i].userAttributeFilters
+                    forwarder.userAttributeFilters
                 );
 
-                if (mpInstance._Store.activeForwarders[i].process) {
+                if (forwarder.process) {
                     mpInstance.Logger.verbose(
-                        'Sending message to forwarder: ' +
-                            mpInstance._Store.activeForwarders[i].name
-                    );
-                    var result = mpInstance._Store.activeForwarders[i].process(
-                        clonedEvent
+                        'Sending message to forwarder: ' + forwarder.name
                     );
+                    const result = forwarder.process(clonedEvent);
 
                     if (result) {
                         mpInstance.Logger.verbose(result);
@@ -405,6 +266,61 @@ export default function Forwarders(mpInstance, kitBlocker) {
         }
     };
 
+    this.sendBatchToForwarders = function(batch) {
+        if (
+            mpInstance._Store.webviewBridgeEnabled ||
+            !mpInstance._Store.activeForwarders
+        ) {
+            return;
+        }
+
+        for (const forwarder of mpInstance._Store.activeForwarders) {
+            if (!forwarder.processBatch) {
+                continue;
+            }
+
+            try {
+                const batchCopy = extend(true, {}, batch);
+
+                if (batchCopy.events) {
+                    batchCopy.events = batchCopy.events.filter(function(
+                        batchEvent
+                    ) {
+                        return isBatchEventAllowed(batchEvent, forwarder);
+                    });
+
+                    batchCopy.events.forEach(function(batchEvent) {
+                        filterBatchEventAttributes(batchEvent, forwarder);
+                    });
+                }
+
+                batchCopy.user_identities = filterBatchIdentities(
+                    batchCopy.user_identities,
+                    forwarder.userIdentityFilters
+                );
+
+                if (batchCopy.user_attributes) {
+                    batchCopy.user_attributes = KitFilterHelper.filterUserAttributes(
+                        batchCopy.user_attributes,
+                        forwarder.userAttributeFilters
+                    );
+                }
+
+                if (!batchCopy.events || batchCopy.events.length === 0) {
+                    continue;
+                }
+
+                const result = forwarder.processBatch(batchCopy);
+
+                if (result) {
+                    mpInstance.Logger.verbose(result);
+                }
+            } catch (e) {
+                mpInstance.Logger.verbose(e);
+            }
+        }
+    };
+
     this.handleForwarderUserAttributes = function(functionNameKey, key, value) {
         if (
             (kitBlocker && kitBlocker.isAttributeKeyBlocked(key)) ||
@@ -747,7 +663,6 @@ export default function Forwarders(mpInstance, kitBlocker) {
             config.filteringConsentRuleValues || {};
         newForwarder.excludeAnonymousUser =
             config.excludeAnonymousUser || false;
-
         return newForwarder;
     };
 

package/src/helpers.js

@@ -99,154 +99,7 @@ export default function Helpers(mpInstance) {
         }
     };
 
-    // https://go.mparticle.com/work/SQDSDKS-6047
-    // Standalone version of jQuery.extend, from https://github.com/dansdom/extend
-    this.extend = function() {
-        var options,
-            name,
-            src,
-            copy,
-            copyIsArray,
-            clone,
-            target = arguments[0] || {},
-            i = 1,
-            length = arguments.length,
-            deep = false,
-            // helper which replicates the jquery internal functions
-            objectHelper = {
-                hasOwn: Object.prototype.hasOwnProperty,
-                class2type: {},
-                type: function(obj) {
-                    return obj == null
-                        ? String(obj)
-                        : objectHelper.class2type[
-                              Object.prototype.toString.call(obj)
-                          ] || 'object';
-                },
-                isPlainObject: function(obj) {
-                    if (
-                        !obj ||
-                        objectHelper.type(obj) !== 'object' ||
-                        obj.nodeType ||
-                        objectHelper.isWindow(obj)
-                    ) {
-                        return false;
-                    }
-
-                    try {
-                        if (
-                            obj.constructor &&
-                            !objectHelper.hasOwn.call(obj, 'constructor') &&
-                            !objectHelper.hasOwn.call(
-                                obj.constructor.prototype,
-                                'isPrototypeOf'
-                            )
-                        ) {
-                            return false;
-                        }
-                    } catch (e) {
-                        return false;
-                    }
-
-                    var key;
-                    for (key in obj) {
-                    } // eslint-disable-line no-empty
-
-                    return (
-                        key === undefined || objectHelper.hasOwn.call(obj, key)
-                    );
-                },
-                isArray:
-                    Array.isArray ||
-                    function(obj) {
-                        return objectHelper.type(obj) === 'array';
-                    },
-                isFunction: function(obj) {
-                    return objectHelper.type(obj) === 'function';
-                },
-                isWindow: function(obj) {
-                    return obj != null && obj == obj.window;
-                },
-            }; // end of objectHelper
-
-        // Handle a deep copy situation
-        if (typeof target === 'boolean') {
-            deep = target;
-            target = arguments[1] || {};
-            // skip the boolean and the target
-            i = 2;
-        }
-
-        // Handle case when target is a string or something (possible in deep copy)
-        if (typeof target !== 'object' && !objectHelper.isFunction(target)) {
-            target = {};
-        }
-
-        // If no second argument is used then this can extend an object that is using this method
-        if (length === i) {
-            target = this;
-            --i;
-        }
-
-        for (; i < length; i++) {
-            // Only deal with non-null/undefined values
-            if ((options = arguments[i]) != null) {
-                // Extend the base object
-                for (name in options) {
-                    // Prevent prototype pollution
-                    // https://github.com/advisories/GHSA-jf85-cpcp-j695
-                    if (
-                        name === '__proto__' ||
-                        name === 'constructor' ||
-                        name === 'prototype'
-                    ) {
-                        continue;
-                    }
-
-                    // Only copy own properties
-                    if (!Object.prototype.hasOwnProperty.call(options, name)) {
-                        continue;
-                    }
-
-                    src = target[name];
-                    copy = options[name];
-
-                    // Prevent never-ending loop
-                    if (target === copy) {
-                        continue;
-                    }
-
-                    // Recurse if we're merging plain objects or arrays
-                    if (
-                        deep &&
-                        copy &&
-                        (objectHelper.isPlainObject(copy) ||
-                            (copyIsArray = objectHelper.isArray(copy)))
-                    ) {
-                        if (copyIsArray) {
-                            copyIsArray = false;
-                            clone = src && objectHelper.isArray(src) ? src : [];
-                        } else {
-                            clone =
-                                src && objectHelper.isPlainObject(src)
-                                    ? src
-                                    : {};
-                        }
-
-                        // Never move original objects, clone them
-                        target[name] = self.extend(deep, clone, copy);
-
-                        // Don't bring in undefined values
-                    } else if (copy !== undefined) {
-                        target[name] = copy;
-                    }
-                }
-            }
-        }
-
-        // Return the modified object
-        return target;
-    };
+    this.extend = utils.extend;
 
     this.createServiceUrl = function(secureServiceUrl, devToken) {
         var serviceScheme =

package/src/mockBatchCreator.ts

@@ -5,6 +5,7 @@ import { SDKEvent, BaseEvent } from './sdkRuntimeModels';
 import { convertEvents } from './sdkToEventsApiConverter';
 import { Batch } from '@mparticle/event-models';
 import { IMParticleWebSDKInstance } from './mp-instance';
+import { extend } from './utils';
 
 const mockFunction = function() {
     return null;
@@ -22,7 +23,7 @@ export default class _BatchValidator {
                 generateUniqueId: function() {
                     return 'mockId';
                 },
-                extend: (window.mParticle.getInstance() as unknown as IMParticleWebSDKInstance)._Helpers.extend,
+                extend,
                 createServiceUrl: mockFunction,
                 parseNumber: mockFunction,
                 isObject: mockFunction,

package/src/mp-instance.ts

@@ -36,7 +36,7 @@ import Consent, { IConsent } from './consent';
 import KitBlocker from './kitBlocking';
 import ConfigAPIClient, { IKitConfigs } from './configAPIClient';
 import IdentityAPIClient from './identityApiClient';
-import { isFunction, parseConfig, valueof, generateDeprecationMessage } from './utils';
+import { isFunction, parseConfig, valueof, generateDeprecationMessage, extend } from './utils';
 import { DisabledVault, LocalStorageVault } from './vault';
 import { removeExpiredIdentityCacheDates, hasExplicitIdentifier } from './identity-utils';
 import IntegrationCapture from './integrationCapture';
@@ -228,7 +228,7 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
                 );
 
                 configApiClient.getSDKConfiguration().then(result => {
-                    const mergedConfig = this._Helpers.extend(
+                    const mergedConfig = extend(
                         {},
                         config,
                         result

package/src/persistence.js

@@ -49,7 +49,7 @@ export default function _Persistence(mpInstance) {
                     if (localStorageData) {
                         if (cookies) {
                             // https://go.mparticle.com/work/SQDSDKS-6047
-                            allData = mpInstance._Helpers.extend(
+                            allData = Utils.extend(
                                 false,
                                 localStorageData,
                                 cookies
@@ -68,7 +68,7 @@ export default function _Persistence(mpInstance) {
                     if (cookies) {
                         if (localStorageData) {
                             // https://go.mparticle.com/work/SQDSDKS-6047
-                            allData = mpInstance._Helpers.extend(
+                            allData = Utils.extend(
                                 false,
                                 localStorageData,
                                 cookies
@@ -255,7 +255,7 @@ export default function _Persistence(mpInstance) {
             }
 
             if (Object.keys(mpInstance._Store.nonCurrentUserMPIDs).length) {
-                localStorageData = mpInstance._Helpers.extend(
+                localStorageData = Utils.extend(
                     {},
                     localStorageData,
                     mpInstance._Store.nonCurrentUserMPIDs
@@ -451,7 +451,7 @@ export default function _Persistence(mpInstance) {
         cookies = setGlobalStorageAttributes(cookies);
 
         if (Object.keys(mpInstance._Store.nonCurrentUserMPIDs).length) {
-            cookies = mpInstance._Helpers.extend(
+            cookies = Utils.extend(
                 {},
                 cookies,
                 mpInstance._Store.nonCurrentUserMPIDs

package/src/roktManager.ts

@@ -305,27 +305,39 @@ export default class RoktManager {
             }
             
             if (!isEmpty(newIdentities)) {
-                // Call identify with the new user identities
+                // Fire-and-forget identify — best-effort, does not block selectPlacements
                 try {
-                    await new Promise<void>((resolve, reject) => {
-                        this.identityService.identify({
+                    this.identityService.identify(
+                        {
                             userIdentities: {
                                 ...currentUserIdentities,
-                                ...newIdentities
+                                ...newIdentities,
+                            },
+                        },
+                        (result) => {
+                            const httpCode = Number(result?.httpCode);
+                            if (httpCode && (httpCode >= 400 || httpCode < 0)) {
+                                this.logger.error(
+                                    'Background identify failed with HTTP ' + httpCode
+                                );
                             }
-                        }, () => {
-                            resolve();
-                        });
-                    });
+                            // 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.
+                            this.processMessageQueue();
+                        }
+                    );
                 } catch (error) {
                     const errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
-                    this.logger.error('Failed to identify user with updated identities: ' + errorMessage);
+                    this.logger.error('Background identify threw an error: ' + errorMessage);
                 }
             }
-            
-            // Refresh current user identities to ensure we have the latest values before building enrichedAttributes
-            this.currentUser = this.identityService.getCurrentUser();
-            const finalUserIdentities = this.currentUser?.getUserIdentities()?.userIdentities || {};
+
+            // Optimistic merge: apply the pending identity changes locally so
+            // enrichedAttributes are correct without waiting for the identify round-trip.
+            // The next call to selectPlacements re-fetches currentUser (see line above),
+            // so stale identity state does not persist beyond this invocation.
+            const finalUserIdentities = { ...currentUserIdentities, ...newIdentities };
 
             this.setUserAttributes(mappedAttributes);