@mparticle/web-sdk 2.21.2 → 2.22.0

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

@@ -163,6 +163,7 @@ const Constants = {
         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/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/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;

package/src/sideloadedKit.ts

@@ -0,0 +1,124 @@
+import KitFilterHelper from './kitFilterHelper';
+import {
+    IFilteringConsentRuleValues,
+    IFilteringEventAttributeValue,
+    IFilteringUserAttributeValue,
+    IKitFilterSettings,
+} from './configAPIClient';
+import { UnregisteredKit } from './forwarders.interfaces';
+import { EventTypeEnum, IdentityType } from './types.interfaces';
+
+export interface IMPSideloadedKit {
+    kitInstance: UnregisteredKit;
+    filterDictionary: IKitFilterSettings;
+
+    addEventTypeFilter(eventType: EventTypeEnum): void;
+    addEventNameFilter(eventType: EventTypeEnum, eventName: string): void;
+    addEventAttributeFilter(
+        eventType: EventTypeEnum,
+        eventName: string,
+        customAttributeKey: string
+    ): void;
+    addScreenNameFilter(screenName: string): void;
+    addScreenAttributeFilter(screenName: string, screenAttribute: string): void;
+    addUserIdentityFilter(userIdentity: IdentityType): void;
+    addUserAttributeFilter(userAttributeKey: string): void;
+}
+
+// This constructor is necessary to be able ot call new on mParticle.SideloadedKit
+// https://stackoverflow.com/questions/13407036/how-does-interfaces-with-construct-signatures-work
+export interface IMPSideloadedKitConstructor {
+    new(unregisteredKitInstance: UnregisteredKit): IMPSideloadedKit;
+}
+
+export default class MPSideloadedKit implements IMPSideloadedKit{
+    public kitInstance: UnregisteredKit;
+    public filterDictionary: IKitFilterSettings = {
+        eventTypeFilters: [],
+        eventNameFilters: [],
+        screenNameFilters: [],
+        screenAttributeFilters: [],
+        userIdentityFilters: [],
+        userAttributeFilters: [],
+        attributeFilters: [],
+        consentRegulationFilters: [],
+        consentRegulationPurposeFilters: [],
+        messageTypeFilters: [],
+        messageTypeStateFilters: [],
+
+        // The below filtering members are optional, but we instantiate them
+        // to simplify public method assignment
+        filteringEventAttributeValue: {} as IFilteringEventAttributeValue,
+        filteringUserAttributeValue: {} as IFilteringUserAttributeValue,
+        filteringConsentRuleValues: {} as IFilteringConsentRuleValues,
+    };
+
+    constructor(unregisteredKitInstance: UnregisteredKit) {
+        this.kitInstance = unregisteredKitInstance;
+    }
+
+    public addEventTypeFilter(eventType: EventTypeEnum): void {
+        const hashedEventType = KitFilterHelper.hashEventType(eventType);
+        this.filterDictionary.eventTypeFilters.push(hashedEventType);
+    }
+
+    public addEventNameFilter(
+        eventType: EventTypeEnum,
+        eventName: string
+    ): void {
+        const hashedEventName = KitFilterHelper.hashEventName(
+            eventName,
+            eventType
+        );
+        this.filterDictionary.eventNameFilters.push(hashedEventName);
+    }
+
+    public addEventAttributeFilter(
+        eventType: EventTypeEnum,
+        eventName: string,
+        customAttributeKey: string
+    ): void {
+        const hashedEventAttribute = KitFilterHelper.hashEventAttributeKey(
+            eventType,
+            eventName,
+            customAttributeKey
+        );
+        this.filterDictionary.attributeFilters.push(hashedEventAttribute);
+    }
+
+    public addScreenNameFilter(screenName: string): void {
+        const hashedScreenName = KitFilterHelper.hashEventName(
+            screenName,
+            EventTypeEnum.Unknown
+        );
+        this.filterDictionary.screenNameFilters.push(hashedScreenName);
+    }
+
+    public addScreenAttributeFilter(
+        screenName: string,
+        screenAttribute: string
+    ): void {
+        const hashedScreenAttribute = KitFilterHelper.hashEventAttributeKey(
+            EventTypeEnum.Unknown,
+            screenName,
+            screenAttribute
+        );
+        this.filterDictionary.screenAttributeFilters.push(
+            hashedScreenAttribute
+        );
+    }
+
+    public addUserIdentityFilter(userIdentity: IdentityType): void {
+        const hashedIdentityType = KitFilterHelper.hashUserIdentity(
+            userIdentity
+        );
+        this.filterDictionary.userIdentityFilters.push(hashedIdentityType);
+    }
+
+    public addUserAttributeFilter(userAttributeKey: string): void {
+        const hashedUserAttributeKey = KitFilterHelper.hashUserAttribute(
+            userAttributeKey
+        );
+        this.filterDictionary.userAttributeFilters.push(hashedUserAttributeKey);
+    }
+}

package/src/types.interfaces.ts

@@ -0,0 +1,52 @@
+export enum EventTypeEnum {
+    Unknown,
+    Navigation,
+    Location,
+    Search,
+    Transaction,
+    UserContent,
+    UserPreference,
+    Social,
+    Other,
+    Media,
+}
+
+// TODO: https://mparticle-eng.atlassian.net/browse/SQDSDKS-5403
+export enum MessageType {
+    SessionStart = 1,
+    SessionEnd = 2,
+    PageView = 3,
+    PageEvent = 4,
+    CrashReport = 5,
+    OptOut = 6,
+    AppStateTransition = 10,
+    Profile = 14,
+    Commerce = 16,
+    UserAttributeChange = 17,
+    UserIdentityChange = 18,
+    Media = 20,
+};
+
+export enum IdentityType {
+    Other = 0,
+    CustomerId = 1,
+    Facebook = 2,
+    Twitter = 3,
+    Google = 4,
+    Microsoft = 5,
+    Yahoo = 6,
+    Email = 7,
+    FacebookCustomAudienceId = 9,
+    Other2 = 10,
+    Other3 = 11,
+    Other4 = 12,
+    Other5 = 13,
+    Other6 = 14,
+    Other7 = 15,
+    Other8 = 16,
+    Other9 = 17,
+    Other10 = 18,
+    MobileNumber = 19,
+    PhoneNumber2 = 20,
+    PhoneNumber3 = 21,
+}