@mparticle/web-sdk 2.18.1 → 2.18.3

package/src/{apiClient.js → apiClient.ts}

@@ -1,15 +1,51 @@
 import Constants from './constants';
 import Types from './types';
 import { BatchUploader } from './batchUploader';
+import {
+    MParticleUser,
+    MParticleWebSDK,
+    MPForwarder,
+    SDKEvent,
+} from './sdkRuntimeModels';
+import KitBlocker from './kitBlocking';
+import { Dictionary } from './utils';
+import { IUploadObject } from './serverModel';
 
-var Messages = Constants.Messages;
+const Messages = Constants.Messages;
 
-export default function APIClient(mpInstance, kitBlocker) {
+export type ForwardingStatsData = Dictionary<any>;
+
+export interface IAPIClient {
+    uploader: BatchUploader | null;
+    queueEventForBatchUpload: (event: SDKEvent) => void;
+    shouldEnableBatching: () => boolean;
+    processQueuedEvents: () => void;
+    appendUserInfoToEvents: (user: MParticleUser, events: SDKEvent[]) => void;
+    sendEventToServer: (event: SDKEvent, _options?: Dictionary<any>) => void;
+    sendSingleEventToServer: (event: SDKEvent) => void;
+    sendBatchForwardingStatsToServer: (
+        forwardingStatsData: ForwardingStatsData,
+        xhr: XMLHttpRequest
+    ) => void;
+    sendSingleForwardingStatsToServer: (
+        forwardingStatsData: ForwardingStatsData
+    ) => void;
+    prepareForwardingStats: (
+        forwarder: MPForwarder,
+        event: IUploadObject
+    ) => void;
+}
+
+export default function APIClient(
+    this: IAPIClient,
+    mpInstance: MParticleWebSDK,
+    kitBlocker: KitBlocker
+) {
     this.uploader = null;
-    var self = this;
-    this.queueEventForBatchUpload = function(event) {
+    const self = this;
+    this.queueEventForBatchUpload = function(event: SDKEvent) {
         if (!this.uploader) {
-            var millis = mpInstance._Helpers.getFeatureFlag(
+            const millis = mpInstance._Helpers.getFeatureFlag(
                 Constants.FeatureFlags.EventBatchingIntervalMillis
             );
             this.uploader = new BatchUploader(mpInstance, millis);
@@ -22,7 +58,7 @@ export default function APIClient(mpInstance, kitBlocker) {
     this.shouldEnableBatching = function() {
         // Returns a string of a number that must be parsed
         // Invalid strings will be parsed to NaN which is falsey
-        var eventsV3Percentage = parseInt(
+        const eventsV3Percentage = parseInt(
             mpInstance._Helpers.getFeatureFlag(Constants.FeatureFlags.EventsV3),
             10
         );
@@ -31,20 +67,20 @@ export default function APIClient(mpInstance, kitBlocker) {
             return false;
         }
 
-        var rampNumber = mpInstance._Helpers.getRampNumber(
+        const rampNumber = mpInstance._Helpers.getRampNumber(
             mpInstance._Store.deviceId
         );
         return eventsV3Percentage >= rampNumber;
     };
 
     this.processQueuedEvents = function() {
-        var mpid,
+        let mpid,
             currentUser = mpInstance.Identity.getCurrentUser();
         if (currentUser) {
             mpid = currentUser.getMPID();
         }
         if (mpInstance._Store.eventQueue.length && mpid) {
-            var localQueueCopy = mpInstance._Store.eventQueue;
+            const localQueueCopy = mpInstance._Store.eventQueue;
             mpInstance._Store.eventQueue = [];
             this.appendUserInfoToEvents(currentUser, localQueueCopy);
             localQueueCopy.forEach(function(event) {
@@ -62,10 +98,10 @@ export default function APIClient(mpInstance, kitBlocker) {
     };
 
     this.sendEventToServer = function(event, _options) {
-        var defaultOptions = {
+        const defaultOptions = {
             shouldUploadEvent: true,
         };
-        var options = mpInstance._Helpers.extend(defaultOptions, _options);
+        const options = mpInstance._Helpers.extend(defaultOptions, _options);
 
         if (mpInstance._Store.webviewBridgeEnabled) {
             mpInstance._NativeSdkHelpers.sendToNative(
@@ -75,7 +111,7 @@ export default function APIClient(mpInstance, kitBlocker) {
             return;
         }
 
-        var mpid,
+        let mpid,
             currentUser = mpInstance.Identity.getCurrentUser();
         if (currentUser) {
             mpid = currentUser.getMPID();
@@ -126,7 +162,7 @@ export default function APIClient(mpInstance, kitBlocker) {
         if (event.EventDataType === Types.MessageType.Media) {
             return;
         }
-        var xhr,
+        let xhr,
             xhrCallback = function() {
                 if (xhr.readyState === 4) {
                     mpInstance.Logger.verbose(
@@ -153,7 +189,9 @@ export default function APIClient(mpInstance, kitBlocker) {
                 );
                 xhr.send(
                     JSON.stringify(
-                        mpInstance._ServerModel.convertEventToDTO(event)
+                        mpInstance._ServerModel.convertEventToDTO(
+                            event as IUploadObject
+                        )
                     )
                 );
             } catch (e) {
@@ -165,7 +203,8 @@ export default function APIClient(mpInstance, kitBlocker) {
     };
 
     this.sendBatchForwardingStatsToServer = function(forwardingStatsData, xhr) {
-        var url, data;
+        let url;
+        let data;
         try {
             url = mpInstance._Helpers.createServiceUrl(
                 mpInstance._Store.SDKConfig.v2SecureServiceUrl,
@@ -188,9 +227,10 @@ export default function APIClient(mpInstance, kitBlocker) {
     };
 
     this.sendSingleForwardingStatsToServer = function(forwardingStatsData) {
-        var url, data;
+        let url;
+        let data;
         try {
-            var xhrCallback = function() {
+            const xhrCallback = function() {
                 if (xhr.readyState === 4) {
                     if (xhr.status === 202) {
                         mpInstance.Logger.verbose(
@@ -201,7 +241,7 @@ export default function APIClient(mpInstance, kitBlocker) {
                     }
                 }
             };
-            var xhr = mpInstance._Helpers.createXHR(xhrCallback);
+            const xhr = mpInstance._Helpers.createXHR(xhrCallback);
             url = mpInstance._Helpers.createServiceUrl(
                 mpInstance._Store.SDKConfig.v1SecureServiceUrl,
                 mpInstance._Store.devToken
@@ -220,8 +260,8 @@ export default function APIClient(mpInstance, kitBlocker) {
     };
 
     this.prepareForwardingStats = function(forwarder, event) {
-        var forwardingStatsData,
-            queue = mpInstance._Forwarders.getForwarderStatsQueue();
+        let forwardingStatsData;
+        const queue = mpInstance._Forwarders.getForwarderStatsQueue();
 
         if (forwarder && forwarder.isVisible) {
             forwardingStatsData = {

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/consent.interfaces.ts

@@ -0,0 +1,89 @@
+// TODO: Migrate this to Consent.ts when that is created
+import { ConsentState, PrivacyConsentState } from '@mparticle/web-sdk';
+
+export interface IGDPRConsentObject {
+    purpose: string;
+}
+
+export interface ICCPAConsentObject {
+    purpose: string;
+}
+
+export interface IConsentJSONObject {
+    gdpr?: Partial<IGDPRConsentObject>;
+    ccpa?: Partial<ICCPAConsentObject>;
+}
+
+interface ICreatePrivacyConsentFunction {
+    (
+        consented: boolean,
+        timestamp?: number,
+        consentDocument?: string,
+        location?: string,
+        hardwareId?: string
+    ): PrivacyConsentState | null;
+}
+
+// TODO: Refactor this with Consent Namespace in @types/mparticle-web-sdk
+//       https://go.mparticle.com/work/SQDSDKS-5009
+export interface SDKConsentApi {
+    createGDPRConsent: ICreatePrivacyConsentFunction;
+    createCCPAConsent: ICreatePrivacyConsentFunction;
+    createConsentState: (consentState?: ConsentState) => ConsentState;
+    ConsentSerialization: IConsentSerialization;
+    createPrivacyConsent: ICreatePrivacyConsentFunction;
+}
+
+export interface IConsentSerialization {
+    toMinifiedJsonObject: (state: ConsentState) => IConsentJSONObject;
+    fromMinifiedJsonObject: (json: IConsentJSONObject) => ConsentState;
+}
+
+// TODO: Resolve discrepency between ConsentState and SDKConsentState
+//       https://go.mparticle.com/work/SQDSDKS-5009
+export interface SDKConsentState
+    extends Omit<ConsentState, 'getGDPRConsentState' | 'getCCPAConsentState'> {
+    getGDPRConsentState(): SDKGDPRConsentState;
+    getCCPAConsentState(): SDKCCPAConsentState;
+}
+
+export interface SDKGDPRConsentState {
+    [key: string]: SDKConsentStateData;
+}
+
+// TODO: Resolve discrepency between ConsentState and SDKConsentState
+//       https://go.mparticle.com/work/SQDSDKS-5009
+//       Specifically PrivacyConsentState, GDPRConsentState and CCPAConsentState
+//       Treat all attributes as required, but we had to override this
+//       to be optional for a bugfix:
+//       https://github.com/mParticle/mparticle-web-sdk/commit/3b11ead79f25b417737442a4fabd6435750f46b8
+export interface SDKConsentStateData {
+    Consented: boolean;
+    Timestamp?: number;
+    ConsentDocument?: string;
+    Location?: string;
+    HardwareId?: string;
+}
+
+export interface SDKCCPAConsentState extends SDKConsentStateData {}
+
+export interface IPrivacyV2DTO {
+    c: boolean; // Consented
+    ts: number; // Timestamp
+    d: string; // Document
+    l: string; // Location
+    h: string; // HardwareID
+}
+
+export interface IGDPRConsentStateDTO {
+    [key: string]: IPrivacyV2DTO;
+}
+
+export interface ICCPAConsentStateDTO {
+    data_sale_opt_out: IPrivacyV2DTO;
+}
+
+export interface IConsentStateDTO {
+    gdpr?: IGDPRConsentStateDTO;
+    ccpa?: ICCPAConsentStateDTO;
+}

package/src/mockBatchCreator.ts

@@ -7,15 +7,15 @@ import * as EventsApi from '@mparticle/event-models';
 
 const mockFunction = function () {
     return null;
-}
+};
 export default class _BatchValidator {
     private getMPInstance() {
         return {
             // Certain Helper, Store, and Identity properties need to be mocked to be used in the `returnBatch` method
             _Helpers: {
-                sanitizeAttributes: window.mParticle.getInstance()._Helpers
-                    .sanitizeAttributes,
-                generateUniqueId: function() {
+                sanitizeAttributes:
+                    window.mParticle.getInstance()._Helpers.sanitizeAttributes,
+                generateUniqueId: function () {
                     return 'mockId';
                 },
                 extend: window.mParticle.getInstance()._Helpers.extend,
@@ -28,6 +28,11 @@ export default class _BatchValidator {
             _resetForTests: mockFunction,
             _APIClient: null,
             _Consent: null,
+            _Forwarders: null,
+            _NativeSdkHelpers: null,
+            _Persistence: null,
+            _preInit: null,
+            Consent: null,
             _ServerModel: null,
             _SessionManager: null,
             _Store: {
@@ -69,6 +74,11 @@ export default class _BatchValidator {
                 kits: {},
                 configuredForwarders: [],
                 pixelConfigurations: [],
+                wrapperSDKInfo: {
+                    name: 'none',
+                    version: null,
+                    isInfoSet: false,
+                },
                 SDKConfig: {
                     isDevelopmentMode: false,
                     onCreateBatch: mockFunction,
@@ -102,7 +112,7 @@ export default class _BatchValidator {
             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,12 +1,12 @@
 import * as EventsApi from '@mparticle/event-models';
-import { Batch } from '@mparticle/event-models';
-import { DataPlanVersion, DataPlan } from '@mparticle/data-planning-models';
+import { DataPlanVersion } from '@mparticle/data-planning-models';
 import { MPConfiguration, IdentityApiData } from '@mparticle/web-sdk';
-import { IStore, SDKConfig } from './store';
+import { IStore } from './store';
 import Validators from './validators';
 import { Dictionary } from './utils';
 import { IServerModel } from './serverModel';
-
+import { IKitConfigs } from './configAPIClient';
+import { SDKConsentApi, SDKConsentState } from './consent.interfaces';
 
 // TODO: Resolve this with version in @mparticle/web-sdk
 export type SDKEventCustomFlags = Dictionary<any>;
@@ -131,12 +131,17 @@ export interface MParticleWebSDK {
     Logger: SDKLoggerApi;
     _APIClient: any; // TODO: Set up API Client
     _Store: IStore;
+    _Forwarders: any;
     _Helpers: SDKHelpersApi;
     config: SDKInitConfig;
     _ServerModel: IServerModel;
     _SessionManager: any; // TODO: Set up Session Manager
-    _Consent: any; // TODO: Set up Consent SDK
-    _resetForTests(MPConfig?: SDKConfig): void;
+    _Consent: SDKConsentApi;
+    Consent: SDKConsentApi;
+    _NativeSdkHelpers: any; // TODO: Set up API
+    _Persistence: any; // TODO: Set up Persistence API
+    _preInit: any; // TODO: Set up API
+    _resetForTests(MPConfig?: SDKInitConfig): void;
     init(apiKey: string, config: SDKInitConfig, instanceName?: string): void;
     getAppName(): string;
     getAppVersion(): string;
@@ -158,10 +163,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;
 
@@ -172,11 +180,11 @@ 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;
 
-    kitConfigs?: KitConfigs[];
+    kitConfigs?: IKitConfigs[];
     kits?: Dictionary<Kit>;
     dataPlanOptions?: KitBlockerOptions;
     flags?: Dictionary;
@@ -216,12 +224,23 @@ export interface SDKIdentityApi {
 
 export interface SDKHelpersApi {
     createServiceUrl(arg0: string, arg1: string): void;
-    extend(...args: any[]);
-    parseNumber(value: string | number): number;
+    createXHR?(cb: () => void): XMLHttpRequest;
+    extend?(...args: any[]);
+    parseNumber?(value: string | number): number;
     generateUniqueId();
-    isObject(item: any);
+    getFeatureFlag?(feature: string); // TODO: Feature Constants should be converted to enum
+    getRampNumber?(deviceId: string): number;
+    isDelayedByIntegration?(
+        delayedIntegrations: Dictionary<boolean>,
+        timeoutStart: number,
+        now: number
+    ): boolean;
+    isObject?(item: any);
     returnConvertedBoolean(data: string | boolean | number): boolean;
-    sanitizeAttributes(attrs: Dictionary<string>, name: string): Dictionary<string> | null;
+    sanitizeAttributes?(
+        attrs: Dictionary<string>,
+        name: string
+    ): Dictionary<string> | null;
     Validators: typeof Validators;
 }
 
@@ -247,6 +266,9 @@ export interface SDKConfigApi {
     appVersion?: string;
     onCreateBatch(batch: EventsApi.Batch): EventsApi.Batch;
 }
+
+// FIXME: Resolve with User in @types/mparticle-web-sdk
+//        https://go.mparticle.com/work/SQDSDKS-5033
 export interface MParticleUser {
     getMPID(): string;
     getConsentState(): any; // FIXME:
@@ -254,25 +276,6 @@ export interface MParticleUser {
     getUserIdentities(): IdentityApiData; // FIXME: Is this correct?
 }
 
-export interface SDKConsentState {
-    getGDPRConsentState(): SDKGDPRConsentState;
-    getCCPAConsentState(): SDKCCPAConsentState;
-}
-
-export interface SDKGDPRConsentState {
-    [key: string]: SDKConsentStateData;
-}
-
-export interface SDKConsentStateData {
-    Consented: boolean;
-    Timestamp?: number;
-    ConsentDocument?: string;
-    Location?: string;
-    HardwareId?: string;
-}
-
-export interface SDKCCPAConsentState extends SDKConsentStateData {}
-
 export interface SDKUserIdentityChangeData {
     New: Identity;
     Old: Identity;