@mparticle/web-sdk 2.18.0 → 2.18.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mparticle/web-sdk",
-    "version": "2.18.0",
+    "version": "2.18.2",
     "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/configAPIClient.ts

@@ -0,0 +1,141 @@
+import { DataPlanConfig } from '@mparticle/web-sdk';
+import {
+    BooleanStringLowerCase,
+    DataPlanResult,
+    MParticleWebSDK,
+    SDKEventCustomFlags,
+    SDKInitConfig,
+} from './sdkRuntimeModels';
+import { Dictionary } from './utils';
+
+export type SDKCompleteInitCallback = (
+    apiKey: string,
+    config: SDKInitConfig,
+    mpInstance: MParticleWebSDK
+) => void;
+
+export interface IKitConfigs {
+    name: string;
+    moduleId: number;
+    isDebug: boolean;
+    isVisible: boolean;
+    isDebugString: BooleanStringLowerCase;
+    hasDebugString: BooleanStringLowerCase;
+    settings: Dictionary;
+    screenNameFilters: number[];
+    screenAttributeFilters: number[];
+    userIdentityFilters: number[];
+    userAttributeFilters: number[];
+    eventNameFilters: number[];
+    eventTypeFilters: number[];
+    attributeFilters: number[];
+    filteringEventAttributeValue: Dictionary;
+    filteringConsentRuleValues: Dictionary;
+    consentRegulationFilters: number[];
+    consentRegulationPurposeFilters: number[];
+    messageTypeFilters: number[];
+    messageTypeStateFilters: number[];
+    eventSubscriptionId: number;
+    excludeAnonymousUser: boolean;
+}
+
+export interface IPixelConfig {
+    name: string;
+    moduleId: number;
+    esId: number;
+    isDebug: boolean;
+    isProduction: boolean;
+    settings: Dictionary;
+    frequencyCap: number;
+    pixelUrl: string;
+    redirectUrl: string;
+}
+
+export interface IConfigResponse {
+    appName: string;
+    dataPlanResult: DataPlanResult;
+    kitConfigs: IKitConfigs[];
+    serviceUrl: string;
+    secureServiceUrl: string;
+    minWebviewBridgeVersion: number;
+    workspaceToken: string;
+    pixelConfigs: IPixelConfig[];
+    flags: SDKEventCustomFlags;
+}
+
+export interface IConfigAPIClient {
+    getSDKConfiguration: (
+        apiKey: string,
+        config: SDKInitConfig,
+        completeSDKInitialization: SDKCompleteInitCallback,
+        mpInstance: MParticleWebSDK
+    ) => void;
+}
+
+export default function ConfigAPIClient(this: IConfigAPIClient) {
+    this.getSDKConfiguration = (
+        apiKey,
+        config,
+        completeSDKInitialization,
+        mpInstance
+    ): void => {
+        let url: string;
+        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 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 || '';
+                }
+            }
+
+            if (xhr) {
+                xhr.open('get', url);
+                xhr.send(null);
+            }
+        } catch (e) {
+            completeSDKInitialization(apiKey, config, mpInstance);
+            mpInstance.Logger.error(
+                'Error getting forwarder configuration from mParticle servers.'
+            );
+        }
+    };
+}

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,23 +19,95 @@ 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: [],
+                wrapperSDKInfo: {
+                    name: 'none',
+                    version: null,
+                    isInfoSet: false,
+                },
+                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,
+        } as MParticleWebSDK;
     }
 
     returnBatch(event: BaseEvent) {

package/src/mp-instance.js

@@ -1261,6 +1261,26 @@ export default function mParticleInstance(instanceName) {
             self._APIClient.processQueuedEvents();
         }
     };
+
+    // Internal use only. Used by our wrapper SDKs to identify themselves during initialization.
+    this._setWrapperSDKInfo = function(name, version) {
+        var queued = queueIfNotInitialized(function() {
+            self._setWrapperSDKInfo(name, version);
+        }, self);
+
+        if (queued) return;
+
+        if (
+            self._Store.wrapperSDKInfo === undefined ||
+            !self._Store.wrapperSDKInfo.isInfoSet
+        ) {
+            self._Store.wrapperSDKInfo = {
+                name: name,
+                version: version,
+                isInfoSet: true,
+            };
+        }
+    };
 }
 
 // Some (server) config settings need to be returned before they are set on SDKConfig in a self hosted environment

package/src/mparticle-instance-manager.js

@@ -472,6 +472,9 @@ function mParticle() {
     this._getActiveForwarders = function() {
         return self.getInstance()._getActiveForwarders();
     };
+    this._setWrapperSDKInfo = function(name, version) {
+        self.getInstance()._setWrapperSDKInfo(name, version);
+    };
 }
 
 var mparticleInstance = new mParticle();

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';
+import { IKitConfigs } from './configAPIClient';
+
+// 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;
@@ -146,10 +158,13 @@ export interface MParticleWebSDK {
     isIOS?: boolean;
 }
 
+// Used in cases where server requires booleans as strings
+export type BooleanStringLowerCase = 'false' | 'true';
+export type BooleanStringTitleCase = 'False' | 'True';
+
 export type LogLevelType = 'none' | 'verbose' | 'warning' | 'error';
 
 // TODO: Create true types for Kits and Kit Configs
-export type KitConfigs = Dictionary;
 export type Kit = Dictionary;
 export type MPForwarder = Dictionary;
 
@@ -164,7 +179,7 @@ export interface SDKInitConfig
     dataPlan?: DataPlanConfig | KitBlockerDataPlan; // TODO: These should be eventually split into two different attributes
     logLevel?: LogLevelType;
 
-    kitConfigs?: KitConfigs[];
+    kitConfigs?: IKitConfigs[];
     kits?: Dictionary<Kit>;
     dataPlanOptions?: KitBlockerOptions;
     flags?: Dictionary;
@@ -204,10 +219,16 @@ export interface SDKIdentityApi {
 
 export interface SDKHelpersApi {
     createServiceUrl(arg0: string, arg1: string): void;
-    parseNumber(value: number);
+    createXHR?(cb: () => void): XMLHttpRequest;
+    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 +238,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 +252,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 +306,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 {