@mparticle/web-sdk 2.27.0 → 2.28.1

package/package.json

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

package/src/apiClient.ts

@@ -1,14 +1,13 @@
 import Constants from './constants';
 import Types from './types';
 import { BatchUploader } from './batchUploader';
-import { MParticleWebSDK, SDKEvent } from './sdkRuntimeModels';
+import { MParticleWebSDK, SDKEvent, SDKDataPlan } from './sdkRuntimeModels';
 import KitBlocker from './kitBlocking';
 import { Dictionary, getRampNumber, isEmpty, parseNumber } from './utils';
 import { IUploadObject } from './serverModel';
 import { MPForwarder } from './forwarders.interfaces';
-import { IMParticleUser } from './identity-user-interfaces';
-
-export type ForwardingStatsData = Dictionary<any>;
+import { IMParticleUser, ISDKUserAttributes } from './identity-user-interfaces';
+import { AsyncUploader, FetchUploader, XHRUploader } from './uploaders';
 
 export interface IAPIClient {
     uploader: BatchUploader | null;
@@ -18,18 +17,30 @@ export interface IAPIClient {
     sendEventToServer: (event: SDKEvent, _options?: Dictionary<any>) => void;
     sendSingleEventToServer: (event: SDKEvent) => void;
     sendBatchForwardingStatsToServer: (
-        forwardingStatsData: ForwardingStatsData,
+        forwardingStatsData: IForwardingStatsData,
         xhr: XMLHttpRequest
     ) => void;
-    sendSingleForwardingStatsToServer: (
-        forwardingStatsData: ForwardingStatsData
-    ) => void;
+    initializeForwarderStatsUploader: () => AsyncUploader;
     prepareForwardingStats: (
         forwarder: MPForwarder,
         event: IUploadObject
     ) => void;
 }
 
+export interface IForwardingStatsData {
+    mid: number; // Module Id
+    esid: number; // Event Subscription Id
+    n: string; // Event Name
+    attrs: ISDKUserAttributes; // User Attributes
+    sdk: string; // SDK Version
+    dt: number; // Data Type
+    et: number; // Event Type
+    dbg: boolean; // Development Mode (for debugging in Live Stream)
+    ct: number; // Current Timestamp
+    eec: number; // Expanded Event Count
+    dp: SDKDataPlan; // Data Plan
+}
+
 export default function APIClient(
     this: IAPIClient,
     mpInstance: MParticleWebSDK,
@@ -161,41 +172,26 @@ export default function APIClient(
         }
     };
 
-    this.sendSingleForwardingStatsToServer = function(forwardingStatsData) {
-        let url;
-        let data;
-        try {
-            const xhrCallback = function() {
-                if (xhr.readyState === 4) {
-                    if (xhr.status === 202) {
-                        mpInstance.Logger.verbose(
-                            'Successfully sent  ' +
-                                xhr.statusText +
-                                ' from server'
-                        );
-                    }
-                }
-            };
-            const xhr = mpInstance._Helpers.createXHR(xhrCallback);
-            url = mpInstance._Helpers.createServiceUrl(
-                mpInstance._Store.SDKConfig.v1SecureServiceUrl,
-                mpInstance._Store.devToken
-            );
-            data = forwardingStatsData;
+    this.initializeForwarderStatsUploader = (): AsyncUploader => {
+        const {
+            v1SecureServiceUrl: forwardingDomain,
+        } = mpInstance._Store.SDKConfig;
+        const { devToken } = mpInstance._Store;
 
-            if (xhr) {
-                xhr.open('post', url + '/Forwarding');
-                xhr.send(JSON.stringify(data));
-            }
-        } catch (e) {
-            mpInstance.Logger.error(
-                'Error sending forwarding stats to mParticle servers.'
-            );
-        }
+        const uploadUrl: string = `https://${forwardingDomain}${devToken}/Forwarding`;
+
+        const uploader: AsyncUploader = window.fetch
+            ? new FetchUploader(uploadUrl)
+            : new XHRUploader(uploadUrl);
+
+        return uploader;
     };
 
-    this.prepareForwardingStats = function(forwarder, event) {
-        let forwardingStatsData;
+    this.prepareForwardingStats = function(
+        forwarder: MPForwarder,
+        event:SDKEvent,
+    ) : void {
+        let forwardingStatsData: IForwardingStatsData;
         const queue = mpInstance._Forwarders.getForwarderStatsQueue();
 
         if (forwarder && forwarder.isVisible) {
@@ -212,6 +208,11 @@ export default function APIClient(
                 eec: event.ExpandedEventCount,
                 dp: event.DataPlan,
             };
+            
+            const {
+                sendSingleForwardingStatsToServer,
+                setForwarderStatsQueue,
+            } = mpInstance._Forwarders;
 
             if (
                 mpInstance._Helpers.getFeatureFlag(
@@ -219,9 +220,9 @@ export default function APIClient(
                 )
             ) {
                 queue.push(forwardingStatsData);
-                mpInstance._Forwarders.setForwarderStatsQueue(queue);
+                setForwarderStatsQueue(queue);
             } else {
-                self.sendSingleForwardingStatsToServer(forwardingStatsData);
+                sendSingleForwardingStatsToServer(forwardingStatsData);
             }
         }
     };

package/src/configAPIClient.ts

@@ -7,12 +7,12 @@ import {
     SDKInitConfig,
 } from './sdkRuntimeModels';
 import { Dictionary } from './utils';
-
-export type SDKCompleteInitCallback = (
-    apiKey: string,
-    config: SDKInitConfig,
-    mpInstance: MParticleWebSDK
-) => void;
+import {
+    AsyncUploader,
+    fetchPayload,
+    FetchUploader,
+    XHRUploader,
+} from './uploaders';
 
 export interface IKitConfigs extends IKitFilterSettings {
     name: string;
@@ -47,13 +47,13 @@ export interface IKitFilterSettings {
 export interface IFilteringEventAttributeValue {
     eventAttributeName: string;
     eventAttributeValue: string;
-    includeOnMatch: boolean
+    includeOnMatch: boolean;
 }
 
 export interface IFilteringUserAttributeValue {
     userAttributeName: string;
     userAttributeValue: string;
-    includeOnMatch: boolean
+    includeOnMatch: boolean;
 }
 export interface IFilteringConsentRuleValues {
     includeOnMatch: boolean;
@@ -62,10 +62,9 @@ export interface IFilteringConsentRuleValues {
 
 export interface IConsentRuleValue {
     consentPurpose: string;
-    hasConsented: boolean
+    hasConsented: boolean;
 }
 
-
 export interface IPixelConfig {
     name: string;
     moduleId: number;
@@ -91,78 +90,92 @@ export interface IConfigResponse {
 }
 
 export interface IConfigAPIClient {
-    getSDKConfiguration: (
-        apiKey: string,
-        config: SDKInitConfig,
-        completeSDKInitialization: SDKCompleteInitCallback,
-        mpInstance: MParticleWebSDK
-    ) => void;
+    apiKey: string;
+    config: SDKInitConfig;
+    mpInstance: MParticleWebSDK;
+    getSDKConfiguration: () => Promise<IConfigResponse>;
 }
 
-export default function ConfigAPIClient(this: IConfigAPIClient) {
-    this.getSDKConfiguration = (
-        apiKey,
-        config,
-        completeSDKInitialization,
-        mpInstance
-    ): void => {
-        let url: string;
+const buildUrl = (
+    configUrl: string,
+    apiKey: string,
+    dataPlanConfig?: DataPlanConfig | null,
+    isDevelopmentMode?: boolean | null
+): string => {
+    const url = configUrl + apiKey + '/config';
+    const env = isDevelopmentMode ? '1' : '0';
+    const queryParams = [`env=${env}`];
+
+    const { planId, planVersion } = dataPlanConfig || {};
+
+    if (planId) {
+        queryParams.push(`plan_id=${planId}`);
+    }
+
+    if (planVersion) {
+        queryParams.push(`plan_version=${planVersion}`);
+    }
+
+    return `${url}?${queryParams.join('&')}`;
+};
+
+export default function ConfigAPIClient(
+    this: IConfigAPIClient,
+    apiKey: string,
+    config: SDKInitConfig,
+    mpInstance: MParticleWebSDK
+): void {
+    const baseUrl = 'https://' + mpInstance._Store.SDKConfig.configUrl;
+    const { isDevelopmentMode } = config;
+    const dataPlan = config.dataPlan as DataPlanConfig;
+    const uploadUrl = buildUrl(baseUrl, apiKey, dataPlan, isDevelopmentMode);
+    const uploader: AsyncUploader = window.fetch
+        ? new FetchUploader(uploadUrl)
+        : new XHRUploader(uploadUrl);
+
+    this.getSDKConfiguration = async (): Promise<IConfigResponse> => {
+        let configResponse: IConfigResponse;
+        const fetchPayload: fetchPayload = {
+            method: 'get',
+            headers: {
+                Accept: 'text/plain;charset=UTF-8',
+                'Content-Type': 'text/plain;charset=UTF-8',
+            },
+            body: null,
+        };
+
         try {
-            const xhrCallback = function() {
-                if (xhr.readyState === 4) {
-                    // when a 200 returns, merge current config with what comes back from config, prioritizing user inputted config
-                    if (xhr.status === 200) {
-                        config = mpInstance._Helpers.extend(
-                            {},
-                            config,
-                            JSON.parse(xhr.responseText)
-                        );
-                        completeSDKInitialization(apiKey, config, mpInstance);
-                        mpInstance.Logger.verbose(
-                            'Successfully received configuration from server'
-                        );
-                    } else {
-                        // if for some reason a 200 doesn't return, then we initialize with the just the passed through config
-                        completeSDKInitialization(apiKey, config, mpInstance);
-                        mpInstance.Logger.verbose(
-                            'Issue with receiving configuration from server, received HTTP Code of ' +
-                                xhr.status
-                        );
-                    }
-                }
-            };
-
-            const xhr = mpInstance._Helpers.createXHR(xhrCallback);
-            url =
-                'https://' +
-                mpInstance._Store.SDKConfig.configUrl +
-                apiKey +
-                '/config?env=';
-            if (config.isDevelopmentMode) {
-                url = url + '1';
-            } else {
-                url = url + '0';
-            }
+            const response = await uploader.upload(fetchPayload);
+            if (response.status === 200) {
+                mpInstance?.Logger?.verbose(
+                    'Successfully received configuration from server'
+                );
 
-            const dataPlan = config.dataPlan as DataPlanConfig;
-            if (dataPlan) {
-                if (dataPlan.planId) {
-                    url = url + '&plan_id=' + dataPlan.planId || '';
-                }
-                if (dataPlan.planVersion) {
-                    url = url + '&plan_version=' + dataPlan.planVersion || '';
+                // https://go.mparticle.com/work/SQDSDKS-6568
+                // FetchUploader returns the response as a JSON object that we have to await
+                if (response.json) {
+                    configResponse = await response.json();
+                    return configResponse;
+                } else {
+                    // https://go.mparticle.com/work/SQDSDKS-6568
+                    // XHRUploader returns the response as a string that we need to parse
+                    const xhrResponse = response as unknown as XMLHttpRequest;
+                    configResponse = JSON.parse(xhrResponse.responseText);
+                    return configResponse;
                 }
             }
 
-            if (xhr) {
-                xhr.open('get', url);
-                xhr.send(null);
-            }
+            mpInstance?.Logger?.verbose(
+                'Issue with receiving configuration from server, received HTTP Code of ' +
+                    response.statusText
+            );
         } catch (e) {
-            completeSDKInitialization(apiKey, config, mpInstance);
-            mpInstance.Logger.error(
+            mpInstance?.Logger?.error(
                 'Error getting forwarder configuration from mParticle servers.'
             );
         }
+
+        // Returns the original config object if we cannot retrieve the remote config
+        return config as IConfigResponse;
     };
 }

package/src/forwarders.js

@@ -3,11 +3,16 @@ import filteredMparticleUser from './filteredMparticleUser';
 import { isEmpty } from './utils';
 import KitFilterHelper from './kitFilterHelper';
 import Constants from './constants';
+import APIClient from './apiClient';
 
 const { Modify, Identify, Login, Logout } = Constants.IdentityMethods;
 
 export default function Forwarders(mpInstance, kitBlocker) {
     var self = this;
+    this.forwarderStatsUploader = new APIClient(
+        mpInstance,
+        kitBlocker
+    ).initializeForwarderStatsUploader();
 
     const UserAttributeActionTypes = {
         setUserAttribute: 'setUserAttribute',
@@ -771,4 +776,31 @@ export default function Forwarders(mpInstance, kitBlocker) {
             );
         }
     };
+
+    this.sendSingleForwardingStatsToServer = async forwardingStatsData => {
+        // https://go.mparticle.com/work/SQDSDKS-6568
+        const fetchPayload = {
+            method: 'post',
+            body: JSON.stringify(forwardingStatsData),
+            headers: {
+                Accept: 'text/plain;charset=UTF-8',
+                'Content-Type': 'text/plain;charset=UTF-8',
+            },
+        };
+
+        const response = await this.forwarderStatsUploader.upload(fetchPayload);
+
+        let message;
+        // This is a fire and forget, so we only need to log the response based on the code, and not return any response body
+        if (response.status === 202) {
+            // https://go.mparticle.com/work/SQDSDKS-6670
+            message = 'Successfully sent forwarding stats to mParticle Servers';
+        } else {
+            message =
+                'Issue with forwarding stats to mParticle Servers, received HTTP Code of ' +
+                response.statusText;
+        }
+
+        mpInstance?.Logger?.verbose(message);
+    };
 }

package/src/identity.js

@@ -1665,7 +1665,8 @@ export default function Identity(mpInstance) {
 
             mpInstance.Logger.verbose('Successfully parsed Identity Response');
 
-            mpInstance._APIClient.processQueuedEvents();
+            // https://go.mparticle.com/work/SQDSDKS-6654
+            mpInstance._APIClient?.processQueuedEvents();
         } catch (e) {
             if (callback) {
                 mpInstance._Helpers.invokeCallback(
@@ -1716,7 +1717,7 @@ export default function Identity(mpInstance) {
                     isNewUserIdentityType,
                     currentUserInMemory
                 );
-                mpInstance._APIClient.sendEventToServer(
+                mpInstance._APIClient?.sendEventToServer(
                     userIdentityChangeEvent
                 );
             }
@@ -1770,7 +1771,7 @@ export default function Identity(mpInstance) {
             user
         );
         if (userAttributeChangeEvent) {
-            mpInstance._APIClient.sendEventToServer(userAttributeChangeEvent);
+            mpInstance._APIClient?.sendEventToServer(userAttributeChangeEvent);
         }
     };
 
@@ -1807,7 +1808,7 @@ export default function Identity(mpInstance) {
 
     this.reinitForwardersOnUserChange = function(prevUser, newUser) {
         if (hasMPIDAndUserLoginChanged(prevUser, newUser)) {
-            mpInstance._Forwarders.initForwarders(
+            mpInstance._Forwarders?.initForwarders(
                 newUser.getUserIdentities().userIdentities,
                 mpInstance._APIClient.prepareForwardingStats
             );
@@ -1816,11 +1817,11 @@ export default function Identity(mpInstance) {
 
     this.setForwarderCallbacks = function(user, method) {
         // https://go.mparticle.com/work/SQDSDKS-6036
-        mpInstance._Forwarders.setForwarderUserIdentities(
+        mpInstance._Forwarders?.setForwarderUserIdentities(
             user.getUserIdentities().userIdentities
         );
-        mpInstance._Forwarders.setForwarderOnIdentityComplete(user, method);
-        mpInstance._Forwarders.setForwarderOnUserIdentified(user);
+        mpInstance._Forwarders?.setForwarderOnIdentityComplete(user, method);
+        mpInstance._Forwarders?.setForwarderOnUserIdentified(user);
     };
 }
 

package/src/mp-instance.js

@@ -117,12 +117,21 @@ export default function mParticleInstance(instanceName) {
                 !config.hasOwnProperty('requestConfig') ||
                 config.requestConfig
             ) {
-                new ConfigAPIClient().getSDKConfiguration(
+                const configApiClient = new ConfigAPIClient(
                     apiKey,
                     config,
-                    completeSDKInitialization,
                     this
                 );
+
+                configApiClient.getSDKConfiguration().then(result => {
+                    const mergedConfig = this._Helpers.extend(
+                        {},
+                        config,
+                        result
+                    );
+
+                    completeSDKInitialization(apiKey, mergedConfig, this);
+                });
             } else {
                 completeSDKInitialization(apiKey, config, this);
             }

package/src/persistence.interfaces.ts

@@ -5,7 +5,7 @@ import {
     Product,
     UserIdentities,
 } from '@mparticle/web-sdk';
-import { ForwardingStatsData } from './apiClient';
+import { IForwardingStatsData } from './apiClient';
 import {
     IntegrationAttributes,
     ServerSettings,
@@ -18,7 +18,7 @@ import { UserAttributes } from './identity-user-interfaces';
 export type UploadsTable = Dictionary<any>;
 export interface iForwardingStatsBatches {
     uploadsTable: UploadsTable;
-    forwardingStatsEventQueue: ForwardingStatsData[];
+    forwardingStatsEventQueue: IForwardingStatsData[];
 }
 
 export interface IGlobalStoreV2MinifiedKeys {

package/src/sdkRuntimeModels.ts

@@ -65,6 +65,7 @@ export interface SDKEvent {
     CurrencyCode: string;
     DataPlan?: SDKDataPlan;
     LaunchReferral?: string;
+    ExpandedEventCount: number;
 }
 export interface SDKGeoLocation {
     lat: number | string;
@@ -256,7 +257,7 @@ export interface SDKHelpersApi {
     canLog?(): boolean;
     createMainStorageName?(workspaceToken: string): string;
     createProductStorageName?(workspaceToken: string): string;
-    createServiceUrl(url: string, devToken?: string): void;
+    createServiceUrl(url: string, devToken?: string): string;
     createXHR?(cb: () => void): XMLHttpRequest;
     extend?(...args: any[]);
     parseNumber?(value: string | number): number;

package/src/uploaders.ts

@@ -33,12 +33,25 @@ export class XHRUploader extends AsyncUploader {
     public async upload(fetchPayload: fetchPayload): Promise<Response> {
         const response: Response = await this.makeRequest(
             this.url,
-            fetchPayload.body
+            fetchPayload.body,
+            fetchPayload.method as 'post' | 'get'
         );
         return response;
     }
 
-    private async makeRequest(url: string, data: string): Promise<Response> {
+    // XHR Ready States
+    // https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/readyState
+    // 0   UNSENT  open() has not been called yet.
+    // 1   OPENED  send() has been called.
+    // 2   HEADERS_RECEIVED    send() has been called, and headers and status are available.
+    // 3   LOADING Downloading; responseText holds partial data.
+    // 4   DONE    The operation is complete.
+
+    private async makeRequest(
+        url: string,
+        data: string,
+        method: 'post' | 'get' = 'post'
+    ): Promise<Response> {
         const xhr: XMLHttpRequest = new XMLHttpRequest();
         return new Promise((resolve, reject) => {
             xhr.onreadystatechange = () => {
@@ -46,13 +59,13 @@ export class XHRUploader extends AsyncUploader {
 
                 // Process the response
                 if (xhr.status >= 200 && xhr.status < 300) {
-                    resolve((xhr as unknown) as Response);
+                    resolve(xhr as unknown as Response);
                 } else {
                     reject(xhr);
                 }
             };
 
-            xhr.open('post', url);
+            xhr.open(method, url);
             xhr.send(data);
         });
     }