@mparticle/web-sdk 2.17.4 → 2.18.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mparticle/web-sdk",
-    "version": "2.17.4",
+    "version": "2.18.1",
     "description": "mParticle core SDK for web applications",
     "license": "Apache-2.0",
     "keywords": [
@@ -101,7 +101,7 @@
         "karma-chai": "^0.1.0",
         "karma-chrome-launcher": "^3.1.0",
         "karma-edge-launcher": "^0.4.1",
-        "karma-firefox-launcher": "^2.1.0",
+        "karma-firefox-launcher": "^2.1.2",
         "karma-ie-launcher": "^1.0.0",
         "karma-junit-reporter": "^2.0.1",
         "karma-mocha": "^2.0.1",

package/src/batchUploader.ts

@@ -7,6 +7,7 @@ import {
 } from './sdkRuntimeModels';
 import { convertEvents } from './sdkToEventsApiConverter';
 import Types from './types';
+import { isEmpty } from './utils';
 
 export class BatchUploader {
     //we upload JSON, but this content type is required to avoid a CORS preflight request
@@ -64,8 +65,8 @@ export class BatchUploader {
         return false;
     }
 
-    queueEvent(event: SDKEvent) {
-        if (event) {
+    queueEvent(event: SDKEvent): void {
+        if (!isEmpty(event)) {
             this.pendingEvents.push(event);
             this.mpInstance.Logger.verbose(
                 `Queuing event: ${JSON.stringify(event)}`
@@ -131,15 +132,24 @@ export class BatchUploader {
                 eventsBySession.set(sdkEvent.SessionId, events);
             }
             for (const entry of Array.from(eventsBySession.entries())) {
-                let uploadBatchObject = convertEvents(mpid, entry[1], mpInstance);
-                const onCreateBatchCallback = mpInstance._Store.SDKConfig.onCreateBatch;
+                let uploadBatchObject = convertEvents(
+                    mpid,
+                    entry[1],
+                    mpInstance
+                );
+                const onCreateBatchCallback =
+                    mpInstance._Store.SDKConfig.onCreateBatch;
 
                 if (onCreateBatchCallback) {
-                    uploadBatchObject = onCreateBatchCallback(uploadBatchObject);
+                    uploadBatchObject = onCreateBatchCallback(
+                        uploadBatchObject
+                    );
                     if (uploadBatchObject) {
                         uploadBatchObject.modified = true;
                     } else {
-                        mpInstance.Logger.warning('Skiping batch upload because no batch was returned from onCreateBatch callback');
+                        mpInstance.Logger.warning(
+                            'Skiping batch upload because no batch was returned from onCreateBatch callback'
+                        );
                     }
                 }
 
@@ -193,13 +203,18 @@ export class BatchUploader {
 
     private async upload(
         logger: SDKLoggerApi,
-        uploads: Batch[],
+        _uploads: Batch[],
         useBeacon: boolean
     ): Promise<Batch[]> {
         let uploader;
-        if (!uploads || uploads.length < 1) {
+
+        // Filter out any batches that don't have events
+        const uploads = _uploads.filter(upload => !isEmpty(upload.events));
+
+        if (isEmpty(uploads)) {
             return null;
         }
+
         logger.verbose(`Uploading batches: ${JSON.stringify(uploads)}`);
         logger.verbose(`Batch count: ${uploads.length}`);
 

package/src/helpers.js

@@ -398,14 +398,6 @@ export default function Helpers(mpInstance) {
         return false;
     };
 
-    this.parseStringOrNumber = function(value) {
-        if (Validators.isStringOrNumber(value)) {
-            return value;
-        } else {
-            return null;
-        }
-    };
-
     this.generateHash = function(name) {
         var hash = 0,
             i = 0,
@@ -512,6 +504,7 @@ export default function Helpers(mpInstance) {
     this.isObject = utils.isObject;
     this.decoded = utils.decoded;
     this.returnConvertedBoolean = utils.returnConvertedBoolean;
+    this.parseStringOrNumber = utils.parseStringOrNumber;
 
     // Imported Validators
     this.Validators = Validators;

package/src/mockBatchCreator.ts

@@ -4,6 +4,10 @@ import ServerModel from './serverModel';
 import { SDKEvent, BaseEvent, MParticleWebSDK } from './sdkRuntimeModels';
 import { convertEvents } from './sdkToEventsApiConverter';
 import * as EventsApi from '@mparticle/event-models';
+
+const mockFunction = function () {
+    return null;
+}
 export default class _BatchValidator {
     private getMPInstance() {
         return {
@@ -15,22 +19,89 @@ export default class _BatchValidator {
                     return 'mockId';
                 },
                 extend: window.mParticle.getInstance()._Helpers.extend,
+                createServiceUrl: mockFunction,
+                parseNumber: mockFunction,
+                isObject: mockFunction,
+                returnConvertedBoolean: mockFunction,
+                Validators: null,
             },
+            _resetForTests: mockFunction,
+            _APIClient: null,
+            _Consent: null,
+            _ServerModel: null,
+            _SessionManager: null,
             _Store: {
                 sessionId: 'mockSessionId',
-                SDKConfig: {},
-            },
-            Identity: {
-                getCurrentUser: function() {
-                    return null;
+                devToken: 'test_dev_token',
+                isFirstRun: true,
+                isEnabled: true,
+                sessionAttributes: {},
+                currentSessionMPIDs: [],
+                consentState: null,
+                clientId: null,
+                deviceId: null,
+                migrationData: {},
+                serverSettings: {},
+                dateLastEventSent: null,
+                sessionStartDate: null,
+                currentPosition: null,
+                isTracking: false,
+                watchPositionId: null,
+                cartProducts: [],
+                eventQueue: [],
+                currencyCode: null,
+                globalTimer: null,
+                context: null,
+                configurationLoaded: false,
+                identityCallInFlight: false,
+                migratingToIDSyncCookies: false,
+                nonCurrentUserMPIDs: {},
+                identifyCalled: false,
+                isLoggedIn: false,
+                cookieSyncDates: {},
+                integrationAttributes: {},
+                requireDelay: true,
+                isLocalStorageAvailable: null,
+                integrationDelayTimeoutStart: null,
+                storageName: null,
+                prodStorageName: null,
+                activeForwarders: [],
+                kits: {},
+                configuredForwarders: [],
+                pixelConfigurations: [],
+                SDKConfig: {
+                    isDevelopmentMode: false,
+                    onCreateBatch: mockFunction,
                 },
             },
-            getAppVersion: function() {
-                return null;
+            config: null,
+            eCommerce: null,
+            Identity: {
+                getCurrentUser: mockFunction,
+                IdentityAPI: {},
+                identify: mockFunction,
+                login: mockFunction,
+                logout: mockFunction,
+                modify: mockFunction,
             },
-            getAppName: function() {
-                return null;
+            Logger: {
+                verbose: mockFunction,
+                error: mockFunction,
+                warning: mockFunction,
             },
+            ProductActionType: null,
+            ServerModel: null,
+            addForwarder: mockFunction,
+            generateHash: mockFunction,
+            getAppVersion: mockFunction,
+            getAppName: mockFunction,
+            getInstance: mockFunction,
+            init: mockFunction,
+            logBaseEvent: mockFunction,
+            logEvent: mockFunction,
+            logLevel: 'none',
+            setPosition: mockFunction,
+            upload: mockFunction,
         };
     }
 

package/src/mp-instance.js

@@ -188,6 +188,16 @@ export default function mParticleInstance(instanceName) {
             self._preInit.readyQueue.push(f);
         }
     };
+    /**
+     * Returns the current mParticle environment setting
+     * @method getEnvironment
+     * @returns {String} mParticle environment setting
+     */
+    this.getEnvironment = function() {
+        return self._Store.SDKConfig.isDevelopmentMode
+            ? Types.Environment.Development
+            : Types.Environment.Production;
+    };
     /**
      * Returns the mParticle SDK version number
      * @method getVersion
@@ -1205,8 +1215,51 @@ export default function mParticleInstance(instanceName) {
     this._getIntegrationDelays = function() {
         return self._preInit.integrationDelays;
     };
-    this._setIntegrationDelay = function(module, boolean) {
-        self._preInit.integrationDelays[module] = boolean;
+    /*
+        An integration delay is a workaround that prevents events from being sent when it is necessary to do so.
+        Some server side integrations require a client side value to be included in the payload to successfully 
+        forward.  This value can only be pulled from the client side partner SDK.
+
+        During the kit initialization, the kit:
+        * sets an integration delay to `true`
+        * grabs the required value from the partner SDK,
+        * sets it via `setIntegrationAttribute`
+        * sets the integration delay to `false`
+
+        The core SDK can then read via `isDelayedByIntegration` to no longer delay sending events.
+
+        This integration attribute is now on the batch payload for the server side to read.
+
+        If there is no delay, then the events sent before an integration attribute is included would not
+        be forwarded successfully server side.
+    */
+    this._setIntegrationDelay = function(module, shouldDelayIntegration) {
+        self._preInit.integrationDelays[module] = shouldDelayIntegration;
+
+        // If the integration delay is set to true, no further action needed
+        if (shouldDelayIntegration === true) {
+            return;
+        }
+        // If the integration delay is set to false, check to see if there are any
+        // other integration delays set to true.  It not, process the queued events/.
+
+        const integrationDelaysKeys = Object.keys(
+            self._preInit.integrationDelays
+        );
+
+        if (integrationDelaysKeys.length === 0) {
+            return;
+        }
+
+        const hasIntegrationDelays = integrationDelaysKeys.some(function(
+            integration
+        ) {
+            return self._preInit.integrationDelays[integration] === true;
+        });
+
+        if (!hasIntegrationDelays) {
+            self._APIClient.processQueuedEvents();
+        }
     };
 }
 

package/src/mparticle-instance-manager.js

@@ -128,6 +128,9 @@ function mParticle() {
     this.getAppVersion = function() {
         return self.getInstance().getAppVersion();
     };
+    this.getEnvironment = function() {
+        return self.getInstance().getEnvironment();
+    };
     this.stopTrackingLocation = function() {
         self.getInstance().stopTrackingLocation();
     };

package/src/sdkRuntimeModels.ts

@@ -1,9 +1,15 @@
-import { DataPlanVersion } from '@mparticle/data-planning-models';
+import * as EventsApi from '@mparticle/event-models';
 import { Batch } from '@mparticle/event-models';
-import { MPConfiguration, SDKEventCustomFlags } from '@mparticle/web-sdk';
-import { SDKConfig } from './store';
-import { Dictionary } from './utils';
+import { DataPlanVersion, DataPlan } from '@mparticle/data-planning-models';
+import { MPConfiguration, IdentityApiData } from '@mparticle/web-sdk';
+import { IStore, SDKConfig } from './store';
 import Validators from './validators';
+import { Dictionary } from './utils';
+import { IServerModel } from './serverModel';
+
+
+// TODO: Resolve this with version in @mparticle/web-sdk
+export type SDKEventCustomFlags = Dictionary<any>;
 
 export interface SDKEvent {
     DeviceId: string;
@@ -25,7 +31,7 @@ export interface SDKEvent {
     Debug: boolean;
     Location?: SDKGeoLocation;
     OptOut?: boolean;
-    CustomFlags?: { [key: string]: string };
+    CustomFlags?: SDKEventCustomFlags;
     AppVersion?: string;
     AppName?: string;
     Package?: string;
@@ -123,12 +129,18 @@ export interface MParticleWebSDK {
     addForwarder(mockForwarder: MPForwarder): void;
     Identity: SDKIdentityApi;
     Logger: SDKLoggerApi;
-    _Store: SDKStoreApi;
+    _APIClient: any; // TODO: Set up API Client
+    _Store: IStore;
     _Helpers: SDKHelpersApi;
     config: SDKInitConfig;
-    _resetForTests(MPConfig: SDKConfig): void;
+    _ServerModel: IServerModel;
+    _SessionManager: any; // TODO: Set up Session Manager
+    _Consent: any; // TODO: Set up Consent SDK
+    _resetForTests(MPConfig?: SDKConfig): void;
     init(apiKey: string, config: SDKInitConfig, instanceName?: string): void;
-    getInstance();
+    getAppName(): string;
+    getAppVersion(): string;
+    getInstance(): MParticleWebSDK; // TODO: Create a new type for MParticleWebSDKInstance
     ServerModel();
     upload();
     setPosition(lat: number | string, lng: number | string): void;
@@ -160,7 +172,7 @@ export type MPForwarder = Dictionary;
 // Currently, this extends MPConfiguration in @types/mparticle__web-sdk
 // and the two will be merged in once the Store module is refactored
 export interface SDKInitConfig
-    extends Omit<MPConfiguration, 'dataPlan' | 'logLevel'> {
+extends Omit<MPConfiguration, 'dataPlan' | 'logLevel'> {
     dataPlan?: DataPlanConfig | KitBlockerDataPlan; // TODO: These should be eventually split into two different attributes
     logLevel?: LogLevelType;
 
@@ -204,10 +216,12 @@ export interface SDKIdentityApi {
 
 export interface SDKHelpersApi {
     createServiceUrl(arg0: string, arg1: string): void;
-    parseNumber(value: number);
+    extend(...args: any[]);
+    parseNumber(value: string | number): number;
     generateUniqueId();
     isObject(item: any);
     returnConvertedBoolean(data: string | boolean | number): boolean;
+    sanitizeAttributes(attrs: Dictionary<string>, name: string): Dictionary<string> | null;
     Validators: typeof Validators;
 }
 
@@ -217,7 +231,9 @@ export interface SDKLoggerApi {
     warning(arg0: string): void;
 }
 
+// TODO: Merge this with IStore in store.ts
 export interface SDKStoreApi {
+    isEnabled: boolean;
     isFirstRun: boolean;
     devToken: string;
     SDKConfig: SDKConfigApi;
@@ -229,10 +245,13 @@ export interface SDKConfigApi {
     v3SecureServiceUrl?: string;
     isDevelopmentMode: boolean;
     appVersion?: string;
-    onCreateBatch(batch: Batch): Batch;
+    onCreateBatch(batch: EventsApi.Batch): EventsApi.Batch;
 }
 export interface MParticleUser {
     getMPID(): string;
+    getConsentState(): any; // FIXME:
+    getAllUserAttributes(): any; // FIXME;
+    getUserIdentities(): IdentityApiData; // FIXME: Is this correct?
 }
 
 export interface SDKConsentState {
@@ -280,6 +299,10 @@ export interface BaseEvent {
     eventType?: number;
     data?: { [key: string]: string };
     customFlags?: { [key: string]: string };
+    toEventAPIObject?(): SDKEvent;
+    sourceMessageId?: string;
+    userAttributeChanges?: SDKUserAttributeChangeData;
+    userIdentityChanges?: SDKUserIdentityChangeData;
 }
 
 export interface KitBlockerOptions {