@mparticle/web-sdk 2.63.0 → 2.64.0

package/dist/types/src/forwarder-utils.d.ts

@@ -0,0 +1,15 @@
+import * as EventsApi from '@mparticle/event-models';
+import { IKitFilterSettings } from './configAPIClient';
+type ForwarderFilterConfig = Pick<IKitFilterSettings, 'eventNameFilters' | 'eventTypeFilters' | 'screenNameFilters' | 'screenAttributeFilters' | 'attributeFilters' | 'userIdentityFilters' | 'filteringEventAttributeValue'>;
+export declare function isBlockedByForwardingRule(messageType: number, attributes: Record<string, unknown> | null, forwarder: ForwarderFilterConfig): boolean;
+export declare function isBlockedByEventFilter(messageType: number, hashedEventName: number, hashedEventType: number, forwarder: ForwarderFilterConfig): boolean;
+export declare function filterEventAttributes(messageType: number, eventCategory: number, eventName: string, attributes: Record<string, unknown> | null, forwarder: ForwarderFilterConfig): Record<string, unknown> | null;
+export declare function filterUserIdentities(userIdentities: Array<{
+    Type: number;
+}> | undefined, filterList: number[]): Array<{
+    Type: number;
+}>;
+export declare function isBatchEventAllowed(batchEvent: EventsApi.BaseEvent, forwarder: ForwarderFilterConfig): boolean;
+export declare function filterBatchEventAttributes(batchEvent: EventsApi.BaseEvent, forwarder: ForwarderFilterConfig): void;
+export declare function filterBatchIdentities(userIdentities: Record<string, unknown> | undefined, filterList: number[] | undefined): Record<string, unknown> | undefined;
+export {};

package/dist/types/src/helpers.d.ts

@@ -5,7 +5,7 @@ export default class Helpers {
     getFeatureFlag: (feature: any) => any;
     invokeCallback: (callback: any, code: any, body: any, mParticleUser: any, previousMpid: any) => void;
     invokeAliasCallback: (callback: any, code: any, message: any) => void;
-    extend: (...args: any[]) => any;
+    extend: typeof utils.extend;
     createServiceUrl: (secureServiceUrl: any, devToken: any) => string;
     createXHR: (cb: any) => any;
     filterUserIdentities: (userIdentitiesObject: any, filterList: any) => {

package/dist/types/src/sdkToEventsApiConverter.d.ts

@@ -40,4 +40,6 @@ export declare function convertSDKLocation(sdkEventLocation: SDKGeoLocation): Ev
 export declare function convertUserAttributeChangeEvent(sdkEvent: SDKEvent): EventsApi.UserAttributeChangeEvent | null;
 export declare function convertUserIdentityChangeEvent(sdkEvent: SDKEvent): EventsApi.UserIdentityChangeEvent | null;
 export declare function convertUserIdentityTypeToServerIdentityType(identityType: SDKIdentityTypeEnum): EventsApi.IdentityType;
+export declare function getEventNameFromBatchEvent(batchEvent: EventsApi.BaseEvent): string;
+export declare function getEventCategoryFromBatchEvent(batchEvent: EventsApi.BaseEvent): number;
 export {};

package/dist/types/src/types.d.ts

@@ -74,6 +74,9 @@ export declare const PerformanceMarkType: {
     JointSdkSelectPlacements: "mp:jointSdkSelectPlacements";
     JointSdkRoktKitInit: "mp:jointSdkRoktKitInit";
 };
+export declare function getMessageTypeFromEventType(eventType: string): number;
+export declare function getEventCategoryFromCustomEventType(customEventType: string): number;
+export declare function getIdentityTypeFromBatchKey(key: string): number;
 declare const _default: {
     readonly MessageType: {
         SessionStart: 1;

package/dist/types/src/utils.d.ts

@@ -79,4 +79,5 @@ declare const obfuscateData: (value: any) => any;
  * // Returns: { email: 'string' }
  */
 declare const obfuscateDevData: (data: any, isDevelopmentMode?: boolean) => any;
-export { createCookieString, revertCookieString, createCookieSyncUrl, valueof, AttributeValue, converted, decoded, obfuscateDevData, filterDictionaryWithHash, findKeyInObject, generateDeprecationMessage, generateHash, generateUniqueId, getRampNumber, inArray, isObject, isStringOrNumber, obfuscateData, parseConfig, parseNumber, parseSettingsString, parseStringOrNumber, replaceCommasWithPipes, replacePipesWithCommas, replaceApostrophesWithQuotes, replaceQuotesWithApostrophes, returnConvertedBoolean, toDataPlanSlug, isString, isNumber, isFunction, isDataPlanSlug, isEmpty, isValidAttributeValue, isValidCustomFlagProperty, mergeObjects, moveElementToEnd, queryStringParser, getCookies, getHref, replaceMPID, replaceAmpWithAmpersand, };
+declare function extend(...args: any[]): any;
+export { createCookieString, revertCookieString, createCookieSyncUrl, valueof, AttributeValue, converted, decoded, obfuscateDevData, filterDictionaryWithHash, findKeyInObject, generateDeprecationMessage, generateHash, generateUniqueId, getRampNumber, inArray, isObject, isStringOrNumber, obfuscateData, parseConfig, parseNumber, parseSettingsString, parseStringOrNumber, replaceCommasWithPipes, replacePipesWithCommas, replaceApostrophesWithQuotes, replaceQuotesWithApostrophes, returnConvertedBoolean, toDataPlanSlug, isString, isNumber, isFunction, isDataPlanSlug, isEmpty, isValidAttributeValue, isValidCustomFlagProperty, mergeObjects, moveElementToEnd, queryStringParser, getCookies, getHref, replaceMPID, replaceAmpWithAmpersand, extend, };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mparticle/web-sdk",
-    "version": "2.63.0",
+    "version": "2.64.0",
     "description": "mParticle core SDK for web applications",
     "license": "Apache-2.0",
     "keywords": [

package/src/apiClient.ts

@@ -3,7 +3,7 @@ import Types from './types';
 import { BatchUploader } from './batchUploader';
 import { SDKEvent, SDKDataPlan } from './sdkRuntimeModels';
 import KitBlocker from './kitBlocking';
-import { Dictionary, isEmpty, parseNumber } from './utils';
+import { Dictionary, isEmpty, parseNumber, extend } from './utils';
 import { IUploadObject } from './serverModel';
 import { MPForwarder } from './forwarders.interfaces';
 import { IMParticleUser, ISDKUserAttributes } from './identity-user-interfaces';
@@ -122,7 +122,7 @@ export default function APIClient(
         const defaultOptions = {
             shouldUploadEvent: true,
         };
-        const options = mpInstance._Helpers.extend(defaultOptions, _options);
+        const options = extend(defaultOptions, _options);
 
         if (mpInstance._Store.webviewBridgeEnabled) {
             mpInstance._NativeSdkHelpers.sendToNative(

package/src/ecommerce.js

@@ -1,5 +1,6 @@
 import Types from './types';
 import Constants from './constants';
+import { extend } from './utils';
 
 var Messages = Constants.Messages;
 
@@ -378,13 +379,13 @@ export default function Ecommerce(mpInstance) {
         commerceEvent.ProductImpressions.forEach(function(productImpression) {
             if (productImpression.ProductList) {
                 productImpression.ProductList.forEach(function(product) {
-                    var attributes = mpInstance._Helpers.extend(
+                    let attributes = extend(
                         false,
                         {},
                         commerceEvent.EventAttributes
                     );
                     if (product.Attributes) {
-                        for (var attribute in product.Attributes) {
+                        for (const attribute in product.Attributes) {
                             attributes[attribute] =
                                 product.Attributes[attribute];
                         }
@@ -425,11 +426,7 @@ export default function Ecommerce(mpInstance) {
         }
         var promotions = commerceEvent.PromotionAction.PromotionList;
         promotions.forEach(function(promotion) {
-            var attributes = mpInstance._Helpers.extend(
-                false,
-                {},
-                commerceEvent.EventAttributes
-            );
+            let attributes = extend(false, {}, commerceEvent.EventAttributes);
             self.extractPromotionAttributes(attributes, promotion);
 
             var appEvent = mpInstance._ServerModel.createEventObject({
@@ -459,11 +456,7 @@ export default function Ecommerce(mpInstance) {
             commerceEvent.ProductAction.ProductActionType ===
                 Types.ProductActionType.Refund
         ) {
-            var attributes = mpInstance._Helpers.extend(
-                false,
-                {},
-                commerceEvent.EventAttributes
-            );
+            let attributes = extend(false, {}, commerceEvent.EventAttributes);
             attributes['Product Count'] = commerceEvent.ProductAction
                 .ProductList
                 ? commerceEvent.ProductAction.ProductList.length
@@ -498,7 +491,7 @@ export default function Ecommerce(mpInstance) {
         }
 
         products.forEach(function(product) {
-            var attributes = mpInstance._Helpers.extend(
+            let attributes = extend(
                 false,
                 commerceEvent.EventAttributes,
                 product.Attributes

package/src/forwarder-utils.ts

@@ -0,0 +1,260 @@
+import Types, {
+    EventType,
+    getMessageTypeFromEventType,
+    getIdentityTypeFromBatchKey,
+} from './types';
+import { inArray, valueof } from './utils';
+import KitFilterHelper from './kitFilterHelper';
+import * as EventsApi from '@mparticle/event-models';
+import { IKitFilterSettings } from './configAPIClient';
+import {
+    getEventNameFromBatchEvent,
+    getEventCategoryFromBatchEvent,
+} from './sdkToEventsApiConverter';
+
+type ForwarderFilterConfig = Pick<
+    IKitFilterSettings,
+    | 'eventNameFilters'
+    | 'eventTypeFilters'
+    | 'screenNameFilters'
+    | 'screenAttributeFilters'
+    | 'attributeFilters'
+    | 'userIdentityFilters'
+    | 'filteringEventAttributeValue'
+>;
+
+const FORWARDING_RULE_MESSAGE_TYPES: number[] = [
+    Types.MessageType.PageEvent,
+    Types.MessageType.PageView,
+    Types.MessageType.Commerce,
+];
+
+function inFilteredList(
+    filterList: number[] | undefined,
+    hash: number
+): boolean {
+    if (filterList && filterList.length) {
+        return inArray(filterList, hash);
+    }
+    return false;
+}
+
+export function isBlockedByForwardingRule(
+    messageType: number,
+    attributes: Record<string, unknown> | null,
+    forwarder: ForwarderFilterConfig
+): boolean {
+    if (
+        !FORWARDING_RULE_MESSAGE_TYPES.includes(messageType) ||
+        !forwarder.filteringEventAttributeValue ||
+        !forwarder.filteringEventAttributeValue.eventAttributeName ||
+        !forwarder.filteringEventAttributeValue.eventAttributeValue
+    ) {
+        return false;
+    }
+
+    let foundProp: { name: string; value: string } | null = null;
+
+    if (attributes) {
+        for (const prop in attributes) {
+            if (attributes.hasOwnProperty(prop)) {
+                const hashedName = KitFilterHelper.hashAttributeConditionalForwarding(
+                    prop
+                );
+
+                if (
+                    hashedName ===
+                    forwarder.filteringEventAttributeValue.eventAttributeName
+                ) {
+                    foundProp = {
+                        name: hashedName,
+                        value: KitFilterHelper.hashAttributeConditionalForwarding(
+                            attributes[prop] as string
+                        ),
+                    };
+                    break;
+                }
+            }
+        }
+    }
+
+    const isMatch =
+        foundProp !== null &&
+        foundProp.value ===
+            forwarder.filteringEventAttributeValue.eventAttributeValue;
+
+    const shouldInclude =
+        forwarder.filteringEventAttributeValue.includeOnMatch === true
+            ? isMatch
+            : !isMatch;
+
+    return !shouldInclude;
+}
+
+export function isBlockedByEventFilter(
+    messageType: number,
+    hashedEventName: number,
+    hashedEventType: number,
+    forwarder: ForwarderFilterConfig
+): boolean {
+    if (
+        messageType === Types.MessageType.PageEvent &&
+        (inFilteredList(forwarder.eventNameFilters, hashedEventName) ||
+            inFilteredList(forwarder.eventTypeFilters, hashedEventType))
+    ) {
+        return true;
+    } else if (
+        messageType === Types.MessageType.Commerce &&
+        inFilteredList(forwarder.eventTypeFilters, hashedEventType)
+    ) {
+        return true;
+    } else if (
+        messageType === Types.MessageType.PageView &&
+        inFilteredList(forwarder.screenNameFilters, hashedEventName)
+    ) {
+        return true;
+    }
+    return false;
+}
+
+export function filterEventAttributes(
+    messageType: number,
+    eventCategory: number,
+    eventName: string,
+    attributes: Record<string, unknown> | null,
+    forwarder: ForwarderFilterConfig
+): Record<string, unknown> | null {
+    if (!attributes) {
+        return attributes;
+    }
+
+    let filterList: number[] | undefined;
+    if (messageType === Types.MessageType.PageEvent) {
+        filterList = forwarder.attributeFilters;
+    } else if (messageType === Types.MessageType.PageView) {
+        filterList = forwarder.screenAttributeFilters;
+    }
+
+    if (!filterList) {
+        return attributes;
+    }
+
+    const filtered: Record<string, unknown> = {};
+    for (const attrName in attributes) {
+        if (attributes.hasOwnProperty(attrName)) {
+            const hash = KitFilterHelper.hashEventAttributeKey(
+                eventCategory as valueof<typeof EventType>,
+                eventName,
+                attrName
+            );
+
+            if (!inArray(filterList, hash)) {
+                filtered[attrName] = attributes[attrName];
+            }
+        }
+    }
+    return filtered;
+}
+
+export function filterUserIdentities(
+    userIdentities: Array<{ Type: number }> | undefined,
+    filterList: number[]
+): Array<{ Type: number }> {
+    if (!userIdentities || !userIdentities.length) {
+        return userIdentities || [];
+    }
+
+    return userIdentities.filter(function(userIdentity) {
+        return !inArray(
+            filterList,
+            KitFilterHelper.hashUserIdentity(userIdentity.Type)
+        );
+    });
+}
+
+export function isBatchEventAllowed(
+    batchEvent: EventsApi.BaseEvent,
+    forwarder: ForwarderFilterConfig
+): boolean {
+    if (!batchEvent || !(batchEvent as any).data) {
+        return true;
+    }
+
+    const messageType = getMessageTypeFromEventType(
+        (batchEvent as any).event_type
+    );
+    const eventName = getEventNameFromBatchEvent(batchEvent);
+    const eventCategory = getEventCategoryFromBatchEvent(batchEvent);
+
+    if (
+        isBlockedByForwardingRule(
+            messageType,
+            (batchEvent as any).data.custom_attributes,
+            forwarder
+        )
+    ) {
+        return false;
+    }
+
+    const hashedEventName = KitFilterHelper.hashEventName(
+        eventName,
+        eventCategory as valueof<typeof EventType>
+    );
+    const hashedEventType = KitFilterHelper.hashEventType(
+        eventCategory as valueof<typeof EventType>
+    );
+
+    return !isBlockedByEventFilter(
+        messageType,
+        hashedEventName,
+        hashedEventType,
+        forwarder
+    );
+}
+
+export function filterBatchEventAttributes(
+    batchEvent: EventsApi.BaseEvent,
+    forwarder: ForwarderFilterConfig
+): void {
+    if (!batchEvent || !(batchEvent as any).data) {
+        return;
+    }
+
+    const messageType = getMessageTypeFromEventType(
+        (batchEvent as any).event_type
+    );
+    const eventName = getEventNameFromBatchEvent(batchEvent);
+    const eventCategory = getEventCategoryFromBatchEvent(batchEvent);
+
+    (batchEvent as any).data.custom_attributes = filterEventAttributes(
+        messageType,
+        eventCategory,
+        eventName,
+        (batchEvent as any).data.custom_attributes,
+        forwarder
+    );
+}
+
+export function filterBatchIdentities(
+    userIdentities: Record<string, unknown> | undefined,
+    filterList: number[] | undefined
+): Record<string, unknown> | undefined {
+    if (!userIdentities || !filterList) {
+        return userIdentities;
+    }
+
+    const filtered: Record<string, unknown> = {};
+    for (const key in userIdentities) {
+        if (userIdentities.hasOwnProperty(key)) {
+            const identityType = getIdentityTypeFromBatchKey(key);
+
+            if (
+                identityType === -1 ||
+                !inArray(filterList, identityType)
+            ) {
+                filtered[key] = userIdentities[key];
+            }
+        }
+    }
+    return filtered;
+}