@mparticle/web-sdk 2.32.2 → 2.32.4

package/package.json

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

package/src/apiClient.ts

@@ -1,13 +1,14 @@
 import Constants from './constants';
 import Types from './types';
 import { BatchUploader } from './batchUploader';
-import { MParticleWebSDK, SDKEvent, SDKDataPlan } from './sdkRuntimeModels';
+import { SDKEvent, SDKDataPlan } from './sdkRuntimeModels';
 import KitBlocker from './kitBlocking';
-import { Dictionary, getRampNumber, isEmpty, parseNumber } from './utils';
+import { Dictionary, isEmpty, parseNumber } from './utils';
 import { IUploadObject } from './serverModel';
 import { MPForwarder } from './forwarders.interfaces';
 import { IMParticleUser, ISDKUserAttributes } from './identity-user-interfaces';
 import { AsyncUploader, FetchUploader, XHRUploader } from './uploaders';
+import { IMParticleWebSDKInstance } from './mp-instance';
 
 export interface IAPIClient {
     uploader: BatchUploader | null;
@@ -43,7 +44,7 @@ export interface IForwardingStatsData {
 
 export default function APIClient(
     this: IAPIClient,
-    mpInstance: MParticleWebSDK,
+    mpInstance: IMParticleWebSDKInstance,
     kitBlocker: KitBlocker
 ) {
     this.uploader = null;
@@ -135,7 +136,10 @@ export default function APIClient(
             this.queueEventForBatchUpload(event);
         }
 
-        if (event.EventName !== Types.MessageType.AppStateTransition) {
+        // https://go.mparticle.com/work/SQDSDKS-6935
+        // While Event Name is 'usually' a string, there are some cases where it is a number
+        // in that it could be a type of MessageType Enum
+        if (event.EventName as unknown as number !== Types.MessageType.AppStateTransition) {
             if (kitBlocker && kitBlocker.kitBlockingEnabled) {
                 event = kitBlocker.createBlockedEvent(event);
             }

package/src/batchUploader.ts

@@ -1,8 +1,8 @@
 import { Batch } from '@mparticle/event-models';
 import Constants from './constants';
-import { SDKEvent, MParticleWebSDK, SDKLoggerApi } from './sdkRuntimeModels';
+import { SDKEvent, SDKLoggerApi } from './sdkRuntimeModels';
 import { convertEvents } from './sdkToEventsApiConverter';
-import Types from './types';
+import { MessageType } from './types';
 import { getRampNumber, isEmpty } from './utils';
 import { SessionStorageVault, LocalStorageVault } from './vault';
 import {
@@ -12,6 +12,7 @@ import {
     IFetchPayload,
 } from './uploaders';
 import { IMParticleUser } from './identity-user-interfaces';
+import { IMParticleWebSDKInstance } from './mp-instance';
 
 /**
  * BatchUploader contains all the logic to store/retrieve events and batches
@@ -36,7 +37,7 @@ export class BatchUploader {
     uploadIntervalMillis: number;
     eventsQueuedForProcessing: SDKEvent[];
     batchesQueuedForProcessing: Batch[];
-    mpInstance: MParticleWebSDK;
+    mpInstance: IMParticleWebSDKInstance;
     uploadUrl: string;
     batchingEnabled: boolean;
     private eventVault: SessionStorageVault<SDKEvent[]>;
@@ -46,10 +47,10 @@ export class BatchUploader {
 
     /**
      * Creates an instance of a BatchUploader
-     * @param {MParticleWebSDK} mpInstance - the mParticle SDK instance
+     * @param {IMParticleWebSDKInstance} mpInstance - the mParticle SDK instance
      * @param {number} uploadInterval - the desired upload interval in milliseconds
      */
-    constructor(mpInstance: MParticleWebSDK, uploadInterval: number) {
+    constructor(mpInstance: IMParticleWebSDKInstance, uploadInterval: number) {
         this.mpInstance = mpInstance;
         this.uploadIntervalMillis = uploadInterval;
         this.batchingEnabled =
@@ -167,29 +168,35 @@ export class BatchUploader {
      * @param event event that should be queued
      */
     public queueEvent(event: SDKEvent): void {
-        if (!isEmpty(event)) {
-            this.eventsQueuedForProcessing.push(event);
-            if (this.offlineStorageEnabled && this.eventVault) {
-                this.eventVault.store(this.eventsQueuedForProcessing);
-            }
-            this.mpInstance.Logger.verbose(
-                `Queuing event: ${JSON.stringify(event)}`
-            );
-            this.mpInstance.Logger.verbose(
-                `Queued event count: ${this.eventsQueuedForProcessing.length}`
-            );
+        if (isEmpty(event)) {
+            return;
+        }
 
-            // TODO: Remove this check once the v2 code path is removed
-            //       https://go.mparticle.com/work/SQDSDKS-3720
-            if (
-                !this.batchingEnabled ||
-                Types.TriggerUploadType[event.EventDataType]
-            ) {
-                this.prepareAndUpload(false, false);
-            }
+        const { verbose } = this.mpInstance.Logger;
+
+        this.eventsQueuedForProcessing.push(event);
+        if (this.offlineStorageEnabled && this.eventVault) {
+            this.eventVault.store(this.eventsQueuedForProcessing);
+        }
+
+        verbose(`Queuing event: ${JSON.stringify(event)}`);
+        verbose(`Queued event count: ${this.eventsQueuedForProcessing.length}`);
+
+        if (this.shouldTriggerImmediateUpload(event.EventDataType)) {
+            this.prepareAndUpload(false, false);
         }
     }
 
+    // https://go.mparticle.com/work/SQDSDKS-3720
+    private shouldTriggerImmediateUpload (eventDataType: number): boolean {
+        const priorityEvents = [
+            MessageType.Commerce,
+            MessageType.UserIdentityChange,
+        ] as const;
+
+        return !this.batchingEnabled || priorityEvents.includes(eventDataType as typeof priorityEvents[number]);
+    };
+
     /**
      * This implements crucial logic to:
      * - bucket pending events by MPID, and then by Session, and upload individual batches for each bucket.
@@ -202,7 +209,7 @@ export class BatchUploader {
     private static createNewBatches(
         sdkEvents: SDKEvent[],
         defaultUser: IMParticleUser,
-        mpInstance: MParticleWebSDK
+        mpInstance: IMParticleWebSDKInstance
     ): Batch[] | null {
         if (!defaultUser || !sdkEvents || !sdkEvents.length) {
             return null;
@@ -274,9 +281,9 @@ export class BatchUploader {
      * @param triggerFuture whether to trigger the loop again - for manual/forced uploads this should be false
      * @param useBeacon whether to use the beacon API - used when the page is being unloaded
      */
-    private async prepareAndUpload(
-        triggerFuture: boolean,
-        useBeacon: boolean
+    public async prepareAndUpload(
+        triggerFuture: boolean = false,
+        useBeacon: boolean = false,
     ): Promise<void> {
         // Fetch current user so that events can be grouped by MPID
         const currentUser = this.mpInstance.Identity.getCurrentUser();

package/src/configAPIClient.ts

@@ -2,7 +2,6 @@ import { DataPlanConfig } from '@mparticle/web-sdk';
 import {
     BooleanStringLowerCase,
     DataPlanResult,
-    MParticleWebSDK,
     SDKEventCustomFlags,
     SDKInitConfig,
 } from './sdkRuntimeModels';
@@ -14,6 +13,7 @@ import {
     XHRUploader,
 } from './uploaders';
 import { IPixelConfiguration } from './cookieSyncManager';
+import { IMParticleWebSDKInstance } from './mp-instance';
 
 export interface IKitConfigs extends IKitFilterSettings {
     name: string;
@@ -82,7 +82,7 @@ export interface IConfigResponse {
 export interface IConfigAPIClient {
     apiKey: string;
     config: SDKInitConfig;
-    mpInstance: MParticleWebSDK;
+    mpInstance: IMParticleWebSDKInstance;
     getSDKConfiguration: () => Promise<IConfigResponse>;
 }
 
@@ -113,7 +113,7 @@ export default function ConfigAPIClient(
     this: IConfigAPIClient,
     apiKey: string,
     config: SDKInitConfig,
-    mpInstance: MParticleWebSDK
+    mpInstance: IMParticleWebSDKInstance
 ): void {
     const baseUrl = 'https://' + mpInstance._Store.SDKConfig.configUrl;
     const { isDevelopmentMode } = config;

package/src/consent.ts

@@ -4,11 +4,11 @@ import {
     GDPRConsentState,
     PrivacyConsentState,
 } from '@mparticle/web-sdk';
-import { MParticleWebSDK } from './sdkRuntimeModels';
 import { Dictionary, isObject } from './utils';
 import KitFilterHelper from './kitFilterHelper';
 import Constants from './constants';
 import { IMParticleUser } from './identity-user-interfaces';
+import { IMParticleWebSDKInstance } from './mp-instance';
 
 const { CCPAPurpose } = Constants;
 
@@ -36,12 +36,6 @@ export interface SDKConsentApi {
     createGDPRConsent: ICreatePrivacyConsentFunction;
     createCCPAConsent: ICreatePrivacyConsentFunction;
     createConsentState: (consentState?: ConsentState) => ConsentState;
-    ConsentSerialization: IConsentSerialization;
-    createPrivacyConsent: ICreatePrivacyConsentFunction;
-    isEnabledForUserConsent: (
-        consentRules: IConsentRules,
-        user: IMParticleUser
-    ) => boolean;
 }
 
 export interface IConsentSerialization {
@@ -120,7 +114,7 @@ export interface IConsent {
     ConsentSerialization: IConsentSerialization;
 }
 
-export default function Consent(this: IConsent, mpInstance: MParticleWebSDK) {
+export default function Consent(this: IConsent, mpInstance: IMParticleWebSDKInstance) {
     const self = this;
 
     // this function is called when consent is required to

package/src/constants.ts

@@ -184,6 +184,11 @@ const Constants = {
         Login: 'login',
         Identify: 'identify',
     },
+
+    Environment: {
+        Development: 'development',
+        Production: 'production',
+    },
 } as const;
 
 export default Constants;
@@ -196,4 +201,7 @@ export const MILLIS_IN_ONE_SEC = 1000;
 export const HTTP_OK = 200 as const;
 export const HTTP_ACCEPTED = 202 as const;
 export const HTTP_BAD_REQUEST = 400 as const;
+export const HTTP_UNAUTHORIZED = 401 as const;
 export const HTTP_FORBIDDEN = 403 as const;
+export const HTTP_NOT_FOUND = 404 as const;
+export const HTTP_SERVER_ERROR = 500 as const;

package/src/cookieSyncManager.ts

@@ -4,9 +4,9 @@ import {
     createCookieSyncUrl,
 } from './utils';
 import Constants from './constants';
-import { MParticleWebSDK } from './sdkRuntimeModels';
 import { MPID } from '@mparticle/web-sdk';
 import { IConsentRules } from './consent';
+import { IMParticleWebSDKInstance } from './mp-instance';
 
 const { Messages } = Constants;
 const { InformationMessages } = Messages;
@@ -47,7 +47,7 @@ export interface ICookieSyncManager {
 
 export default function CookieSyncManager(
     this: ICookieSyncManager,
-    mpInstance: MParticleWebSDK
+    mpInstance: IMParticleWebSDKInstance
 ) {
     const self = this;
 

package/src/ecommerce.interfaces.ts

@@ -0,0 +1,201 @@
+import {
+    ProductAction,
+    Product,
+    Promotion,
+    CommerceEvent,
+} from '@mparticle/event-models';
+import {
+    SDKEventAttrs,
+    SDKEventOptions,
+    TransactionAttributes,
+} from '@mparticle/web-sdk';
+import { valueof } from './utils';
+import {
+    ProductActionType,
+    PromotionActionType,
+    CommerceEventType,
+    EventType,
+} from './types';
+import {
+    SDKEvent,
+    SDKEventCustomFlags,
+    SDKImpression,
+    SDKProduct,
+    SDKProductImpression,
+    SDKPromotion,
+} from './sdkRuntimeModels';
+
+interface IECommerceShared {
+    createProduct(
+        name: string,
+        sku: string | number,
+        price: string | number,
+        quantity?: string | number,
+        variant?: string,
+        category?: string,
+        brand?: string,
+        position?: number,
+        couponCode?: string,
+        attributes?: SDKEventAttrs
+    ): SDKProduct | null;
+    createImpression(name: string, product: Product): SDKImpression | null;
+    createPromotion(
+        id: string | number,
+        creative?: string,
+        name?: string,
+        position?: number
+    ): SDKPromotion | null;
+    createTransactionAttributes(
+        id: string | number,
+        affiliation?: string,
+        couponCode?: string,
+        revenue?: string | number,
+        shipping?: string | number,
+        tax?: number
+    ): TransactionAttributes | null;
+    expandCommerceEvent(event: CommerceEvent): SDKEvent[] | null;
+}
+
+export interface SDKCart {
+    add(product: SDKProduct | SDKProduct[], logEvent?: boolean): void;
+    remove(product: SDKProduct | SDKProduct[], logEvent?: boolean): void;
+    clear(): void;
+}
+
+// Used for the public `eCommerce` namespace
+export interface SDKECommerceAPI extends IECommerceShared {
+    logCheckout(
+        step: number,
+        option?: string,
+        attrs?: SDKEventAttrs,
+        customFlags?: SDKEventCustomFlags
+    ): void;
+    logImpression(
+        impression: SDKProductImpression,
+        attrs?: SDKEventAttrs,
+        customFlags?: SDKEventCustomFlags,
+        eventOptions?: SDKEventOptions
+    ): void;
+    logProductAction(
+        productActionType: valueof<typeof ProductActionType>,
+        product: SDKProduct | SDKProduct[],
+        attrs?: SDKEventAttrs,
+        customFlags?: SDKEventCustomFlags,
+        transactionAttributes?: TransactionAttributes,
+        eventOptions?: SDKEventOptions
+    ): void;
+    logPromotion(
+        type: valueof<typeof PromotionActionType>,
+        promotion: SDKPromotion,
+        attrs?: SDKEventAttrs,
+        customFlags?: SDKEventCustomFlags,
+        eventOptions?: SDKEventOptions
+    ): void;
+    setCurrencyCode(code: string): void;
+
+    /*
+     * @deprecated
+     */
+    Cart: SDKCart;
+
+    /*
+     * @deprecated
+     */
+    logPurchase(
+        transactionAttributes: TransactionAttributes,
+        product: SDKProduct | SDKProduct[],
+        clearCart?: boolean,
+        attrs?: SDKEventAttrs,
+        customFlags?: SDKEventCustomFlags
+    ): void;
+
+    /*
+     * @deprecated
+     */
+    logRefund(
+        transactionAttributes: TransactionAttributes,
+        product: SDKProduct | SDKProduct[],
+        clearCart?: boolean,
+        attrs?: SDKEventAttrs,
+        customFlags?: SDKEventCustomFlags
+    ): void;
+}
+
+interface ExtractedActionAttributes {
+    Affiliation?: string;
+    'Coupon Code'?: string;
+    'Total Amount'?: number;
+    'Shipping Amount'?: number;
+    'Tax Amount'?: number;
+    'Checkout Option'?: string;
+    'Checkout Step'?: number;
+    'Transaction ID'?: string;
+}
+interface ExtractedProductAttributes {
+    'Coupon Code'?: string;
+    Brand?: string;
+    Category?: string;
+    Name?: string;
+    Id?: string;
+    'Item Price'?: number;
+    Quantity?: number;
+    Position?: number;
+    Variant?: string;
+    'Total Product Amount': number;
+}
+interface ExtractedPromotionAttributes {
+    Id?: string;
+    Creative?: string;
+    Name?: string;
+    Position?: number;
+}
+interface ExtractedTransactionId {
+    'Transaction ID'?: string;
+}
+
+// Used for the private `_Ecommerce` namespace
+export interface IECommerce extends IECommerceShared {
+    buildProductList(event: SDKEvent, product: Product | Product[]): Product[];
+    convertProductActionToEventType(
+        productActionType: valueof<typeof ProductActionType>
+    ): // https://go.mparticle.com/work/SQDSDKS-4801
+    typeof CommerceEventType | typeof EventType | null;
+    convertPromotionActionToEventType(
+        promotionActionType: valueof<typeof PromotionActionType>
+    ): typeof CommerceEventType | null;
+    convertTransactionAttributesToProductAction(
+        transactionAttributes: TransactionAttributes,
+        productAction: ProductAction
+    ): void;
+    createCommerceEventObject(
+        customFlags: SDKEventCustomFlags,
+        options?: SDKEventOptions
+    ): SDKEvent | null;
+    expandProductAction(commerceEvent: CommerceEvent): SDKEvent[];
+    expandProductImpression(commerceEvent: CommerceEvent): SDKEvent[];
+    expandPromotionAction(commerceEvent: CommerceEvent): SDKEvent[];
+    extractActionAttributes(
+        attributes: ExtractedActionAttributes,
+        productAction: ProductAction
+    ): void;
+    extractProductAttributes(
+        attributes: ExtractedProductAttributes,
+        product: Product
+    ): void;
+    extractPromotionAttributes(
+        attributes: ExtractedPromotionAttributes,
+        promotion: Promotion
+    ): void;
+    extractTransactionId(
+        attributes: ExtractedTransactionId,
+        productAction: ProductAction
+    ): void;
+    generateExpandedEcommerceName(eventName: string, plusOne: boolean): string;
+    getProductActionEventName(
+        productActionType: valueof<typeof ProductActionType>
+    ): string;
+    getPromotionActionEventName(
+        promotionActionType: valueof<typeof PromotionActionType>
+    ): string;
+    sanitizeAmount(amount: string | number, category: string): number;
+}

package/src/ecommerce.js

@@ -5,6 +5,8 @@ var Messages = Constants.Messages;
 
 export default function Ecommerce(mpInstance) {
     var self = this;
+
+    // https://go.mparticle.com/work/SQDSDKS-4801
     this.convertTransactionAttributesToProductAction = function(
         transactionAttributes,
         productAction
@@ -103,8 +105,11 @@ export default function Ecommerce(mpInstance) {
                 return Types.CommerceEventType.ProductRemoveFromCart;
             case Types.ProductActionType.RemoveFromWishlist:
                 return Types.CommerceEventType.ProductRemoveFromWishlist;
+
+            // https://go.mparticle.com/work/SQDSDKS-4801
             case Types.ProductActionType.Unknown:
                 return Types.EventType.Unknown;
+
             case Types.ProductActionType.ViewDetail:
                 return Types.CommerceEventType.ProductViewDetail;
             default:
@@ -139,6 +144,7 @@ export default function Ecommerce(mpInstance) {
         );
     };
 
+    // https://go.mparticle.com/work/SQDSDKS-4801
     this.extractProductAttributes = function(attributes, product) {
         if (product.CouponCode) {
             attributes['Coupon Code'] = product.CouponCode;
@@ -170,12 +176,14 @@ export default function Ecommerce(mpInstance) {
         attributes['Total Product Amount'] = product.TotalAmount || 0;
     };
 
+    // https://go.mparticle.com/work/SQDSDKS-4801
     this.extractTransactionId = function(attributes, productAction) {
         if (productAction.TransactionId) {
             attributes['Transaction Id'] = productAction.TransactionId;
         }
     };
 
+    // https://go.mparticle.com/work/SQDSDKS-4801
     this.extractActionAttributes = function(attributes, productAction) {
         self.extractTransactionId(attributes, productAction);
 
@@ -208,6 +216,7 @@ export default function Ecommerce(mpInstance) {
         }
     };
 
+    // https://go.mparticle.com/work/SQDSDKS-4801
     this.extractPromotionAttributes = function(attributes, promotion) {
         if (promotion.Id) {
             attributes['Id'] = promotion.Id;

package/src/events.interfaces.ts

@@ -0,0 +1,83 @@
+import {
+    Callback,
+    SDKEventAttrs,
+    SDKEventOptions,
+    TransactionAttributes,
+} from '@mparticle/web-sdk';
+import {
+    BaseEvent,
+    SDKEvent,
+    SDKEventCustomFlags,
+    SDKProduct,
+    SDKProductImpression,
+    SDKPromotion,
+} from './sdkRuntimeModels';
+import { valueof } from './utils';
+import { EventType, ProductActionType, PromotionActionType } from './types';
+
+// Supports wrapping event handlers functions that will ideally return a specific type
+type EventHandlerFunction<T> = (element: HTMLLinkElement | HTMLFormElement) => T;
+
+export interface IEvents {
+    addEventHandler(
+        domEvent: string,
+        selector: string | Node,
+        eventName: EventHandlerFunction<string> | string,
+        data: EventHandlerFunction<SDKEventAttrs> | SDKEventAttrs,
+        eventType: valueof<typeof EventType>
+    ): void;
+    logAST(): void;
+    logCheckoutEvent(
+        step: number,
+
+        // User options specified during the checkout process
+        // e.g., FedEx, DHL, UPS for delivery options;
+        // Visa, MasterCard, AmEx for payment options.
+        option?: string,
+
+        attrs?: SDKEventAttrs,
+        customFlags?: SDKEventCustomFlags
+    ): void;
+    logCommerceEvent(
+        commerceEvent: SDKEvent,
+        attrs?: SDKEventAttrs,
+        options?: SDKEventOptions
+    ): void;
+    logEvent(event: BaseEvent, eventOptions?: SDKEventOptions): void;
+    logImpressionEvent(
+        impression: SDKProductImpression,
+        attrs?: SDKEventAttrs,
+        customFlags?: SDKEventCustomFlags,
+        eventOptions?: SDKEventOptions
+    );
+    logOptOut(): void;
+    logProductActionEvent(
+        productActionType: valueof<typeof ProductActionType>,
+        product: SDKProduct | SDKProduct[],
+        attrs?: SDKEventAttrs,
+        customFlags?: SDKEventCustomFlags,
+        transactionAttributes?: TransactionAttributes,
+        eventOptions?: SDKEventOptions
+    ): void;
+    logPromotionEvent(
+        promotionType: valueof<typeof PromotionActionType>,
+        promotion: SDKPromotion,
+        attrs?: SDKEventAttrs,
+        customFlags?: SDKEventCustomFlags,
+        eventOptions?: SDKEventOptions
+    ): void;
+    logPurchaseEvent(
+        transactionAttributes: TransactionAttributes,
+        product: SDKProduct | SDKProduct[],
+        attrs?: SDKEventAttrs,
+        customFlags?: SDKEventCustomFlags
+    ): void;
+    logRefundEvent(
+        transactionAttributes: TransactionAttributes,
+        product: SDKProduct | SDKProduct[],
+        attrs?: SDKEventAttrs,
+        customFlags?: SDKEventCustomFlags
+    ): void;
+    startTracking(callback: Callback): void;
+    stopTracking(): void;
+}

package/src/events.js

@@ -438,10 +438,13 @@ export default function Events(mpInstance) {
                 element = elements[i];
 
                 if (element.addEventListener) {
+                    // Modern browsers
                     element.addEventListener(domEvent, handler, false);
                 } else if (element.attachEvent) {
+                    // IE < 9
                     element.attachEvent('on' + domEvent, handler);
                 } else {
+                    // All other browsers
                     element['on' + domEvent] = handler;
                 }
             }

package/src/forwarders.interfaces.ts

@@ -63,9 +63,6 @@ export interface ConfiguredKit
     setOptOut(isOptingOut: boolean): string | KitMappedMethodFailure;
     removeUserAttribute(key: string): string;
     setUserAttribute(key: string, value: string): string;
-
-    // TODO: Convert type to enum during Identity migration
-    // https://go.mparticle.com/work/SQDSDKS-5218
     setUserIdentity(id: UserIdentityId, type: UserIdentityType): void;
 
     // TODO: https://go.mparticle.com/work/SQDSDKS-5156