@mparticle/web-sdk 2.21.1 → 2.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mparticle/web-sdk",
-    "version": "2.21.1",
+    "version": "2.22.0",
     "description": "mParticle core SDK for web applications",
     "license": "Apache-2.0",
     "keywords": [
@@ -46,7 +46,7 @@
         "test:integrations:module": "npm run test:integrations:module:webpack && npm run test:integrations:module:rollup",
         "test:integrations:module:webpack": "npm run build:webpack:module && npm run test:karma:webpack:module",
         "test:integrations:module:rollup": "npm run build:rollup:module && npm run test:karma:rollup:module",
-        "test:requirejs": "npm run test:requirejs:before && npm run test:requirejs:after",
+        "test:requirejs": "npm run build && npm run test:requirejs:before && npm run test:requirejs:after",
         "test:requirejs:before": "cross-env FILE_ORDER=before_mp karma start test/integrations/requirejs/karma.requirejs.config.js",
         "test:requirejs:after": "cross-env FILE_ORDER=after_mp karma start test/integrations/requirejs/karma.requirejs.config.js",
         "test:karma:webpack:cjs": "cross-env BUNDLER=webpack karma start test/integrations/cjs/karma.webpack.config.js",
@@ -108,6 +108,7 @@
         "fetch-mock": "^7.5.1",
         "gts": "^3.1.0",
         "jest": "^29.5.0",
+        "jest-environment-jsdom": "^29.5.0",
         "karma": "^6.3.2",
         "karma-chai": "^0.1.0",
         "karma-chrome-launcher": "^3.1.0",

package/src/apiClient.ts

@@ -8,17 +8,14 @@ import {
     SDKEvent,
 } from './sdkRuntimeModels';
 import KitBlocker from './kitBlocking';
-import { Dictionary, getRampNumber } from './utils';
+import { Dictionary, getRampNumber, isEmpty } from './utils';
 import { IUploadObject } from './serverModel';
 
-const Messages = Constants.Messages;
-
 export type ForwardingStatsData = Dictionary<any>;
 
 export interface IAPIClient {
     uploader: BatchUploader | null;
     queueEventForBatchUpload: (event: SDKEvent) => void;
-    shouldEnableBatching: () => boolean;
     processQueuedEvents: () => void;
     appendUserInfoToEvents: (user: MParticleUser, events: SDKEvent[]) => void;
     sendEventToServer: (event: SDKEvent, _options?: Dictionary<any>) => void;
@@ -55,22 +52,6 @@ export default function APIClient(
         mpInstance._Persistence.update();
     };
 
-    this.shouldEnableBatching = function() {
-        // Returns a string of a number that must be parsed
-        // Invalid strings will be parsed to NaN which is falsey
-        const eventsV3Percentage = parseInt(
-            mpInstance._Helpers.getFeatureFlag(Constants.FeatureFlags.EventsV3),
-            10
-        );
-
-        if (!eventsV3Percentage) {
-            return false;
-        }
-
-        const rampNumber = getRampNumber(mpInstance._Store.deviceId);
-        return eventsV3Percentage >= rampNumber;
-    };
-
     this.processQueuedEvents = function() {
         let mpid,
             currentUser = mpInstance.Identity.getCurrentUser();
@@ -135,15 +116,15 @@ export default function APIClient(
 
         this.processQueuedEvents();
 
-        if (event && options.shouldUploadEvent) {
-            if (this.shouldEnableBatching()) {
-                this.queueEventForBatchUpload(event);
-            } else {
-                this.sendSingleEventToServer(event);
-            }
+        if (isEmpty(event)) {
+            return;
+        }
+
+        if (options.shouldUploadEvent) {
+            this.queueEventForBatchUpload(event);
         }
 
-        if (event && event.EventName !== Types.MessageType.AppStateTransition) {
+        if (event.EventName !== Types.MessageType.AppStateTransition) {
             if (kitBlocker && kitBlocker.kitBlockingEnabled) {
                 event = kitBlocker.createBlockedEvent(event);
             }
@@ -156,50 +137,6 @@ export default function APIClient(
         }
     };
 
-    this.sendSingleEventToServer = function(event) {
-        if (event.EventDataType === Types.MessageType.Media) {
-            return;
-        }
-        let xhr,
-            xhrCallback = function() {
-                if (xhr.readyState === 4) {
-                    mpInstance.Logger.verbose(
-                        'Received ' + xhr.statusText + ' from server'
-                    );
-                    mpInstance._Persistence.update();
-                }
-            };
-
-        if (!event) {
-            mpInstance.Logger.error(Messages.ErrorMessages.EventEmpty);
-            return;
-        }
-        mpInstance.Logger.verbose(Messages.InformationMessages.SendHttp);
-        xhr = mpInstance._Helpers.createXHR(xhrCallback);
-        if (xhr) {
-            try {
-                xhr.open(
-                    'post',
-                    mpInstance._Helpers.createServiceUrl(
-                        mpInstance._Store.SDKConfig.v2SecureServiceUrl,
-                        mpInstance._Store.devToken
-                    ) + '/Events'
-                );
-                xhr.send(
-                    JSON.stringify(
-                        mpInstance._ServerModel.convertEventToV2DTO(
-                            event as IUploadObject
-                        )
-                    )
-                );
-            } catch (e) {
-                mpInstance.Logger.error(
-                    'Error sending event to mParticle servers. ' + e
-                );
-            }
-        }
-    };
-
     this.sendBatchForwardingStatsToServer = function(forwardingStatsData, xhr) {
         let url;
         let data;

package/src/configAPIClient.ts

@@ -14,7 +14,7 @@ export type SDKCompleteInitCallback = (
     mpInstance: MParticleWebSDK
 ) => void;
 
-export interface IKitConfigs {
+export interface IKitConfigs extends IKitFilterSettings {
     name: string;
     moduleId: number;
     isDebug: boolean;
@@ -22,30 +22,39 @@ export interface IKitConfigs {
     isDebugString: BooleanStringLowerCase;
     hasDebugString: BooleanStringLowerCase;
     settings: Dictionary;
+    eventSubscriptionId: number;
+    excludeAnonymousUser: boolean;
+}
+
+export interface IKitFilterSettings {
+    eventTypeFilters: number[];
+    eventNameFilters: number[];
     screenNameFilters: number[];
     screenAttributeFilters: number[];
     userIdentityFilters: number[];
     userAttributeFilters: number[];
-    eventNameFilters: number[];
-    eventTypeFilters: number[];
     attributeFilters: number[];
-    filteringEventAttributeValue: IFilteringAttributeValue;
-    filteringUserAttributeValue: IFilteringAttributeValue;
-    filteringConsentRuleValues: IFilteringConsentRulesValue;
+    filteringEventAttributeValue?: IFilteringEventAttributeValue;
+    filteringUserAttributeValue?: IFilteringUserAttributeValue;
+    filteringConsentRuleValues?: IFilteringConsentRuleValues;
     consentRegulationFilters: number[];
     consentRegulationPurposeFilters: number[];
     messageTypeFilters: number[];
     messageTypeStateFilters: number[];
-    eventSubscriptionId: number;
-    excludeAnonymousUser: boolean;
 }
 
-export interface IFilteringAttributeValue {
+export interface IFilteringEventAttributeValue {
     eventAttributeName: string;
     eventAttributeValue: string;
     includeOnMatch: boolean
 }
-export interface IFilteringConsentRulesValue {
+
+export interface IFilteringUserAttributeValue {
+    userAttributeName: string;
+    userAttributeValue: string;
+    includeOnMatch: boolean
+}
+export interface IFilteringConsentRuleValues {
     includeOnMatch: boolean;
     values: IConsentRuleValue[];
 }

package/src/consent.ts

@@ -6,9 +6,10 @@ import {
 } from '@mparticle/web-sdk';
 import { MParticleUser, MParticleWebSDK } from './sdkRuntimeModels';
 import { Dictionary, isObject } from './utils';
+import KitFilterHelper from './kitFilterHelper';
+import Constants from './constants';
 
-// Specifies to compiler that CCPAPurpose can only be one specific value
-export const CCPAPurpose = 'data_sale_opt_out' as const;
+const { CCPAPurpose } = Constants;
 
 export interface IMinifiedConsentJSONObject {
     gdpr?: Dictionary<IPrivacyV2DTO>;
@@ -144,15 +145,13 @@ export default function Consent(this: IConsent, mpInstance: MParticleWebSDK) {
             // GDPR - '1' + purpose name
             // CCPA - '2data_sale_opt_out' (there is only 1 purpose of data_sale_opt_out for CCPA)
             const GDPRConsentHashPrefix = '1';
-            const CCPAHashString = '2' + CCPAPurpose;
+            const CCPAHashPrefix = '2';
 
             const gdprConsentState = consentState.getGDPRConsentState();
             if (gdprConsentState) {
                 for (const purpose in gdprConsentState) {
                     if (gdprConsentState.hasOwnProperty(purpose)) {
-                        purposeHash = mpInstance._Helpers
-                            .generateHash(GDPRConsentHashPrefix + purpose)
-                            .toString();
+                        purposeHash = KitFilterHelper.hashConsentPurposeConditionalForwarding(GDPRConsentHashPrefix, purpose);
                         purposeHashes[purposeHash] =
                             gdprConsentState[purpose].Consented;
                     }
@@ -160,9 +159,7 @@ export default function Consent(this: IConsent, mpInstance: MParticleWebSDK) {
             }
             const CCPAConsentState = consentState.getCCPAConsentState();
             if (CCPAConsentState) {
-                purposeHash = mpInstance._Helpers
-                    .generateHash(CCPAHashString)
-                    .toString();
+                purposeHash = KitFilterHelper.hashConsentPurposeConditionalForwarding(CCPAHashPrefix, CCPAPurpose);
                 purposeHashes[purposeHash] = CCPAConsentState.Consented;
             }
         }

package/src/constants.ts

@@ -159,11 +159,11 @@ const Constants = {
     },
     FeatureFlags: {
         ReportBatching: 'reportBatching',
-        EventsV3: 'eventsV3',
         EventBatchingIntervalMillis: 'eventBatchingIntervalMillis',
         OfflineStorage: 'offlineStorage',
     },
     DefaultInstance: 'default_instance',
+    CCPAPurpose: 'data_sale_opt_out'
 } as const;
 
 export default Constants;

package/src/forwarders.js

@@ -1,6 +1,7 @@
 import Types from './types';
 import filteredMparticleUser from './filteredMparticleUser';
 import { isEmpty } from './utils';
+import KitFilterHelper from './kitFilterHelper';
 
 export default function Forwarders(mpInstance, kitBlocker) {
     var self = this;
@@ -110,12 +111,12 @@ export default function Forwarders(mpInstance, kitBlocker) {
             ) {
                 for (var attrName in userAttributes) {
                     if (userAttributes.hasOwnProperty(attrName)) {
-                        attrHash = mpInstance._Helpers
-                            .generateHash(attrName)
-                            .toString();
-                        valueHash = mpInstance._Helpers
-                            .generateHash(userAttributes[attrName])
-                            .toString();
+                        attrHash = KitFilterHelper.hashAttributeConditionalForwarding(
+                            attrName
+                        );
+                        valueHash = KitFilterHelper.hashAttributeConditionalForwarding(
+                            userAttributes[attrName]
+                        );
 
                         if (
                             attrHash === filterObject.userAttributeName &&
@@ -177,7 +178,9 @@ export default function Forwarders(mpInstance, kitBlocker) {
                         if (
                             mpInstance._Helpers.inArray(
                                 filterList,
-                                userIdentity.Type
+                                KitFilterHelper.hashUserIdentity(
+                                    userIdentity.Type
+                                )
                             )
                         ) {
                             event.UserIdentities.splice(i, 1);
@@ -198,8 +201,10 @@ export default function Forwarders(mpInstance, kitBlocker) {
 
                 for (var attrName in event.EventAttributes) {
                     if (event.EventAttributes.hasOwnProperty(attrName)) {
-                        hash = mpInstance._Helpers.generateHash(
-                            event.EventCategory + event.EventName + attrName
+                        hash = KitFilterHelper.hashEventAttributeKey(
+                            event.EventCategory,
+                            event.EventName,
+                            attrName
                         );
 
                         if (mpInstance._Helpers.inArray(filterList, hash)) {
@@ -227,10 +232,11 @@ export default function Forwarders(mpInstance, kitBlocker) {
             !mpInstance._Store.webviewBridgeEnabled &&
             mpInstance._Store.activeForwarders
         ) {
-            hashedEventName = mpInstance._Helpers.generateHash(
-                event.EventCategory + event.EventName
+            hashedEventName = KitFilterHelper.hashEventName(
+                event.EventName,
+                event.EventCategory
             );
-            hashedEventType = mpInstance._Helpers.generateHash(
+            hashedEventType = KitFilterHelper.hashEventType(
                 event.EventCategory
             );
 
@@ -261,9 +267,9 @@ export default function Forwarders(mpInstance, kitBlocker) {
                     if (event.EventAttributes) {
                         for (var prop in event.EventAttributes) {
                             var hashedEventAttributeName;
-                            hashedEventAttributeName = mpInstance._Helpers
-                                .generateHash(prop)
-                                .toString();
+                            hashedEventAttributeName = KitFilterHelper.hashAttributeConditionalForwarding(
+                                prop
+                            );
 
                             if (
                                 hashedEventAttributeName ===
@@ -273,11 +279,9 @@ export default function Forwarders(mpInstance, kitBlocker) {
                             ) {
                                 foundProp = {
                                     name: hashedEventAttributeName,
-                                    value: mpInstance._Helpers
-                                        .generateHash(
-                                            event.EventAttributes[prop]
-                                        )
-                                        .toString(),
+                                    value: KitFilterHelper.hashAttributeConditionalForwarding(
+                                        event.EventAttributes[prop]
+                                    ),
                                 };
                             }
 
@@ -620,7 +624,14 @@ export default function Forwarders(mpInstance, kitBlocker) {
                 // which is typed { kits: Dictionary<constructor> }.
                 // The constructors are keyed by the name of the kit.
                 config.sideloadedKits.forEach(function(sideloadedKit) {
-                    sideloadedKit.register(sideloadedKits);
+                    try {
+                        sideloadedKit.kitInstance.register(sideloadedKits);
+                    } catch (e) {
+                        console.error(
+                            'Error registering sideloaded kit ' +
+                                sideloadedKit.kitInstance.name
+                        );
+                    }
                 });
 
                 // Then configure each kit

package/src/helpers.js

@@ -2,6 +2,7 @@ import Types from './types';
 import Constants from './constants';
 import * as utils from './utils';
 import Validators from './validators';
+import KitFilterHelper from './kitFilterHelper';
 
 var StorageNames = Constants.StorageNames;
 
@@ -306,13 +307,13 @@ export default function Helpers(mpInstance) {
         userIdentitiesObject,
         filterList
     ) {
-        var filteredUserIdentities = {};
+        const filteredUserIdentities = {};
 
         if (userIdentitiesObject && Object.keys(userIdentitiesObject).length) {
-            for (var userIdentityName in userIdentitiesObject) {
+            for (const userIdentityName in userIdentitiesObject) {
                 if (userIdentitiesObject.hasOwnProperty(userIdentityName)) {
-                    var userIdentityType = Types.IdentityType.getIdentityType(
-                        userIdentityName
+                    const userIdentityType = KitFilterHelper.hashUserIdentity(
+                        Types.IdentityType.getIdentityType(userIdentityName)
                     );
                     if (!self.inArray(filterList, userIdentityType)) {
                         filteredUserIdentities[userIdentityName] =
@@ -331,7 +332,9 @@ export default function Helpers(mpInstance) {
         if (userAttributes && Object.keys(userAttributes).length) {
             for (var userAttribute in userAttributes) {
                 if (userAttributes.hasOwnProperty(userAttribute)) {
-                    var hashedUserAttribute = self.generateHash(userAttribute);
+                    const hashedUserAttribute = KitFilterHelper.hashUserAttribute(
+                        userAttribute
+                    );
                     if (!self.inArray(filterList, hashedUserAttribute)) {
                         filteredUserAttributes[userAttribute] =
                             userAttributes[userAttribute];
@@ -344,7 +347,9 @@ export default function Helpers(mpInstance) {
     };
 
     this.isFilteredUserAttribute = function(userAttributeKey, filterList) {
-        const hashedUserAttribute = self.generateHash(userAttributeKey);
+        const hashedUserAttribute = KitFilterHelper.hashUserAttribute(
+            userAttributeKey
+        );
         return filterList && self.inArray(filterList, hashedUserAttribute);
     };
 

package/src/identity.js

@@ -1058,42 +1058,36 @@ export default function Identity(mpInstance) {
                         mpInstance._Persistence.savePersistence(cookies, mpid);
                     }
 
-                    if (mpInstance._APIClient.shouldEnableBatching()) {
-                        // If the new attributeList length is different previous, then there is a change event.
-                        // Loop through new attributes list, see if they are all in the same index as previous user attributes list
-                        // If there are any changes, break, and immediately send a userAttributeChangeEvent with full array as a value
-                        if (
-                            !previousUserAttributeValue ||
-                            !Array.isArray(previousUserAttributeValue)
-                        ) {
-                            userAttributeChange = true;
-                        } else if (
-                            newValue.length !==
-                            previousUserAttributeValue.length
-                        ) {
-                            userAttributeChange = true;
-                        } else {
-                            for (var i = 0; i < newValue.length; i++) {
-                                if (
-                                    previousUserAttributeValue[i] !==
-                                    newValue[i]
-                                ) {
-                                    userAttributeChange = true;
-                                    break;
-                                }
+                    // If the new attributeList length is different previous, then there is a change event.
+                    // Loop through new attributes list, see if they are all in the same index as previous user attributes list
+                    // If there are any changes, break, and immediately send a userAttributeChangeEvent with full array as a value
+                    if (
+                        !previousUserAttributeValue ||
+                        !Array.isArray(previousUserAttributeValue)
+                    ) {
+                        userAttributeChange = true;
+                    } else if (
+                        newValue.length !== previousUserAttributeValue.length
+                    ) {
+                        userAttributeChange = true;
+                    } else {
+                        for (var i = 0; i < newValue.length; i++) {
+                            if (previousUserAttributeValue[i] !== newValue[i]) {
+                                userAttributeChange = true;
+                                break;
                             }
                         }
+                    }
 
-                        if (userAttributeChange) {
-                            self.sendUserAttributeChangeEvent(
-                                key,
-                                newValue,
-                                previousUserAttributeValue,
-                                isNewAttribute,
-                                false,
-                                this
-                            );
-                        }
+                    if (userAttributeChange) {
+                        self.sendUserAttributeChangeEvent(
+                            key,
+                            newValue,
+                            previousUserAttributeValue,
+                            isNewAttribute,
+                            false,
+                            this
+                        );
                     }
 
                     mpInstance._Forwarders.initForwarders(
@@ -1716,10 +1710,6 @@ export default function Identity(mpInstance) {
     ) {
         var currentUserInMemory, userIdentityChangeEvent;
 
-        if (!mpInstance._APIClient.shouldEnableBatching()) {
-            return;
-        }
-
         if (!mpid) {
             if (method !== 'modify') {
                 return;
@@ -1785,9 +1775,6 @@ export default function Identity(mpInstance) {
         deleted,
         user
     ) {
-        if (!mpInstance._APIClient.shouldEnableBatching()) {
-            return;
-        }
         var userAttributeChangeEvent = self.createUserAttributeChange(
             attributeKey,
             newUserAttributeValue,

package/src/kitFilterHelper.ts

@@ -0,0 +1,47 @@
+import { generateHash } from "./utils";
+// TODO: https://mparticle-eng.atlassian.net/browse/SQDSDKS-5381
+import { EventTypeEnum, IdentityType } from "./types.interfaces";
+import Constants from './constants';
+
+export default class KitFilterHelper {
+    static hashEventType(eventType: EventTypeEnum): number {
+        return generateHash(eventType as unknown as string);
+    };
+
+    static hashEventName(eventName: string, eventType: EventTypeEnum): number {
+        return generateHash(eventType + eventName);
+    };
+
+    static hashEventAttributeKey(eventType: EventTypeEnum, eventName: string, customAttributeName: string): number {
+        return generateHash(eventType + eventName + customAttributeName);
+    }
+    
+    static hashUserAttribute(userAttributeKey: string): number {
+        return generateHash(userAttributeKey);
+    }
+
+    // User Identities are not actually hashed, this method is named this way to
+    // be consistent with the filter class. UserIdentityType is also a number
+    static hashUserIdentity(userIdentity: IdentityType): IdentityType {
+        return userIdentity;
+    }
+
+    static hashConsentPurpose(prefix: string, purpose: string){
+        return generateHash(prefix + purpose)
+
+    }
+
+    // The methods below are for conditional forwarding, a type of filter
+    // hashAttributeCondiitonalForwarding is used for both User and Event
+    // attribute keys and attribute values
+    // The backend returns the hashes as strings for conditional forwarding
+    // but returns "regular" filters as arrays of numbers
+    // See IFilteringEventAttributeValue in configApiClient.ts as an example
+    static hashAttributeConditionalForwarding(attribute: string): string {
+        return generateHash(attribute).toString();
+    }
+
+    static hashConsentPurposeConditionalForwarding(prefix: string, purpose: string): string {
+        return this.hashConsentPurpose(prefix, purpose).toString();
+    }
+}

package/src/mockBatchCreator.ts

@@ -5,6 +5,7 @@ import { SDKEvent, BaseEvent, MParticleWebSDK } from './sdkRuntimeModels';
 import { convertEvents } from './sdkToEventsApiConverter';
 import * as EventsApi from '@mparticle/event-models';
 import { Batch } from '@mparticle/event-models';
+import { IMPSideloadedKit} from './sideloadedKit';
 
 const mockFunction = function() {
     return null;
@@ -31,6 +32,7 @@ export default class _BatchValidator {
             },
             _resetForTests: mockFunction,
             _APIClient: null,
+            MPSideloadedKit: null,
             _Consent: null,
             _Forwarders: null,
             _NativeSdkHelpers: null,

package/src/mp-instance.js

@@ -1288,18 +1288,6 @@ function completeSDKInitialization(apiKey, config, mpInstance) {
     mpInstance._APIClient = new APIClient(mpInstance, kitBlocker);
     mpInstance._Forwarders = new Forwarders(mpInstance, kitBlocker);
     if (config.flags) {
-        if (config.flags.hasOwnProperty(Constants.FeatureFlags.EventsV3)) {
-            // TODO: Remove this after 8/12/2022
-            if (config.flags[Constants.FeatureFlags.EventsV3] !== '100') {
-                var message =
-                    'mParticle will be enabling Event Batching for all customers on July 12, 2022. ' +
-                    'For more details, please see our docs: https://docs.mparticle.com/developers/sdk/web/getting-started/';
-                mpInstance.Logger.warning(message);
-            }
-
-            mpInstance._Store.SDKConfig.flags[Constants.FeatureFlags.EventsV3] =
-                config.flags[Constants.FeatureFlags.EventsV3];
-        }
         if (
             config.flags.hasOwnProperty(
                 Constants.FeatureFlags.EventBatchingIntervalMillis

package/src/mparticle-instance-manager.js

@@ -3,6 +3,7 @@ import Types from './types';
 import Constants from './constants';
 import mParticleInstance from './mp-instance.js';
 import _BatchValidator from './mockBatchCreator';
+import MPSideloadedKit from './sideloadedKit';
 
 if (!Array.prototype.forEach) {
     Array.prototype.forEach = Polyfill.forEach;
@@ -30,6 +31,8 @@ function mParticle() {
     this.CommerceEventType = Types.CommerceEventType;
     this.PromotionType = Types.PromotionActionType;
     this.ProductActionType = Types.ProductActionType;
+    this.MPSideloadedKit = MPSideloadedKit;
+
     if (typeof window !== 'undefined') {
         this.isIOS =
             window.mParticle && window.mParticle.isIOS

package/src/sdkRuntimeModels.ts

@@ -8,7 +8,7 @@ import { IServerModel } from './serverModel';
 import { IKitConfigs } from './configAPIClient';
 import { SDKConsentApi, SDKConsentState } from './consent';
 import { IPersistence } from './persistence.interfaces';
-
+import { IMPSideloadedKit } from './sideloadedKit';
 // TODO: Resolve this with version in @mparticle/web-sdk
 export type SDKEventCustomFlags = Dictionary<any>;
 
@@ -130,6 +130,7 @@ export interface MParticleWebSDK {
     addForwarder(mockForwarder: MPForwarder): void;
     Identity: SDKIdentityApi;
     Logger: SDKLoggerApi;
+    MPSideloadedKit: IMPSideloadedKit;
     _APIClient: any; // TODO: Set up API Client
     _Store: IStore;
     _Forwarders: any;