@mparticle/web-sdk 2.15.4 → 2.16.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mparticle/web-sdk",
-    "version": "2.15.4",
+    "version": "2.16.1",
     "description": "mParticle core SDK for web applications",
     "license": "Apache-2.0",
     "keywords": [
@@ -27,7 +27,6 @@
         "build:npm": "cross-env ENVIRONMENT=prod BUILD=cjs rollup --config rollup.config.js",
         "build:esm": "cross-env ENVIRONMENT=prod BUILD=esm rollup --config rollup.config.js",
         "build:stub": "cross-env ENVIRONMENT=prod BUILD=stub rollup --config rollup.config.js",
-        "build:docs": "yuidoc src/",
         "build:snippet": "uglifyjs snippet.js -nm -o snippet.min.js",
         "build:browserify:cjs": "browserify test/integrations/cjs/browserify/index.js -o test/integrations/cjs/dist/browserify-output.js  && npm run test:karma:browserify:cjs",
         "build:rollup:cjs": "rollup --config test/integrations/cjs/rollup/rollup.config.js  && npm run test:karma:rollup:cjs",
@@ -68,7 +67,7 @@
         "@babel/preset-env": "^7.6.0",
         "@babel/preset-typescript": "^7.6.0",
         "@mparticle/data-planning-models": "^0.1.0",
-        "@mparticle/event-models": "^1.1.2",
+        "@mparticle/event-models": "^1.1.4",
         "@rollup/plugin-json": "^4.1.0",
         "@semantic-release/changelog": "^5.0.1",
         "@semantic-release/exec": "^5.0.0",
@@ -112,8 +111,7 @@
         "typescript": "^4.2.4",
         "uglify-js": "^3.4.9",
         "webpack": "^5.36.2",
-        "webpack-cli": "^4.6.0",
-        "yuidocjs": "^0.10.2"
+        "webpack-cli": "^4.6.0"
     },
     "dependencies": {
         "@babel/runtime": "^7.6.0",

package/src/batchUploader.ts

@@ -131,9 +131,16 @@ export class BatchUploader {
                 eventsBySession.set(sdkEvent.SessionId, events);
             }
             for (const entry of Array.from(eventsBySession.entries())) {
-                const upload = convertEvents(mpid, entry[1], mpInstance);
-                if (upload) {
-                    newUploads.push(upload);
+                let uploadBatchObject = convertEvents(mpid, entry[1], mpInstance);
+                const onCreateBatchCallback = mpInstance._Store.SDKConfig.onCreateBatch;
+
+                if (onCreateBatchCallback) {
+                    uploadBatchObject = onCreateBatchCallback(uploadBatchObject);
+                    uploadBatchObject.mutated = true;
+                }
+
+                if (uploadBatchObject) {
+                    newUploads.push(uploadBatchObject);
                 }
             }
         }

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

@@ -1,6 +1,6 @@
 import { version } from '../package.json';
 
-var Constants = {
+const Constants = {
     sdkVersion: version,
     sdkVendor: 'mparticle',
     platform: 'web',
@@ -164,6 +164,6 @@ var Constants = {
         EventBatchingIntervalMillis: 'eventBatchingIntervalMillis',
     },
     DefaultInstance: 'default_instance',
-};
+} as const;
 
 export default Constants;

package/src/helpers.js

@@ -1,9 +1,10 @@
 import Types from './types';
 import Constants from './constants';
 import Slugify from 'slugify';
+import * as utils from './utils';
+import Validators from './validators';
 
-var StorageNames = Constants.StorageNames,
-    pluses = /\+/g;
+var StorageNames = Constants.StorageNames;
 
 export default function Helpers(mpInstance) {
     var self = this;
@@ -19,14 +20,6 @@ export default function Helpers(mpInstance) {
         return false;
     };
 
-    this.returnConvertedBoolean = function(data) {
-        if (data === 'false' || data === '0') {
-            return false;
-        } else {
-            return Boolean(data);
-        }
-    };
-
     this.getFeatureFlag = function(feature) {
         if (mpInstance._Store.SDKConfig.flags.hasOwnProperty(feature)) {
             return mpInstance._Store.SDKConfig.flags[feature];
@@ -250,26 +243,6 @@ export default function Helpers(mpInstance) {
         return target;
     };
 
-    this.isObject = function(value) {
-        var objType = Object.prototype.toString.call(value);
-
-        return objType === '[object Object]' || objType === '[object Error]';
-    };
-
-    this.inArray = function(items, name) {
-        var i = 0;
-
-        if (Array.prototype.indexOf) {
-            return items.indexOf(name, 0) >= 0;
-        } else {
-            for (var n = items.length; i < n; i++) {
-                if (i in items && items[i] === name) {
-                    return true;
-                }
-            }
-        }
-    };
-
     this.createServiceUrl = function(secureServiceUrl, devToken) {
         var serviceScheme =
             window.mParticle && mpInstance._Store.SDKConfig.forceHttps
@@ -415,36 +388,6 @@ export default function Helpers(mpInstance) {
         return filteredUserAttributes;
     };
 
-    this.findKeyInObject = function(obj, key) {
-        if (key && obj) {
-            for (var prop in obj) {
-                if (
-                    obj.hasOwnProperty(prop) &&
-                    prop.toLowerCase() === key.toLowerCase()
-                ) {
-                    return prop;
-                }
-            }
-        }
-
-        return null;
-    };
-
-    this.decoded = function(s) {
-        return decodeURIComponent(s.replace(pluses, ' '));
-    };
-
-    this.converted = function(s) {
-        if (s.indexOf('"') === 0) {
-            s = s
-                .slice(1, -1)
-                .replace(/\\"/g, '"')
-                .replace(/\\\\/g, '\\');
-        }
-
-        return s;
-    };
-
     this.isEventType = function(type) {
         for (var prop in Types.EventType) {
             if (Types.EventType.hasOwnProperty(prop)) {
@@ -456,16 +399,8 @@ export default function Helpers(mpInstance) {
         return false;
     };
 
-    this.parseNumber = function(value) {
-        if (isNaN(value) || !isFinite(value)) {
-            return 0;
-        }
-        var floatValue = parseFloat(value);
-        return isNaN(floatValue) ? 0 : floatValue;
-    };
-
     this.parseStringOrNumber = function(value) {
-        if (self.Validators.isStringOrNumber(value)) {
+        if (Validators.isStringOrNumber(value)) {
             return value;
         } else {
             return null;
@@ -531,157 +466,6 @@ export default function Helpers(mpInstance) {
         return sanitizedAttrs;
     };
 
-    this.Validators = {
-        isValidAttributeValue: function(value) {
-            return (
-                value !== undefined &&
-                !self.isObject(value) &&
-                !Array.isArray(value)
-            );
-        },
-
-        // Neither null nor undefined can be a valid Key
-        isValidKeyValue: function(key) {
-            return Boolean(key && !self.isObject(key) && !Array.isArray(key));
-        },
-
-        isStringOrNumber: function(value) {
-            return typeof value === 'string' || typeof value === 'number';
-        },
-
-        isNumber: function(value) {
-            return typeof value === 'number';
-        },
-
-        isFunction: function(fn) {
-            return typeof fn === 'function';
-        },
-
-        validateIdentities: function(identityApiData, method) {
-            var validIdentityRequestKeys = {
-                userIdentities: 1,
-                onUserAlias: 1,
-                copyUserAttributes: 1,
-            };
-            if (identityApiData) {
-                if (method === 'modify') {
-                    if (
-                        (self.isObject(identityApiData.userIdentities) &&
-                            !Object.keys(identityApiData.userIdentities)
-                                .length) ||
-                        !self.isObject(identityApiData.userIdentities)
-                    ) {
-                        return {
-                            valid: false,
-                            error:
-                                Constants.Messages.ValidationMessages
-                                    .ModifyIdentityRequestUserIdentitiesPresent,
-                        };
-                    }
-                }
-                for (var key in identityApiData) {
-                    if (identityApiData.hasOwnProperty(key)) {
-                        if (!validIdentityRequestKeys[key]) {
-                            return {
-                                valid: false,
-                                error:
-                                    Constants.Messages.ValidationMessages
-                                        .IdentityRequesetInvalidKey,
-                            };
-                        }
-                        if (
-                            key === 'onUserAlias' &&
-                            !mpInstance._Helpers.Validators.isFunction(
-                                identityApiData[key]
-                            )
-                        ) {
-                            return {
-                                valid: false,
-                                error:
-                                    Constants.Messages.ValidationMessages
-                                        .OnUserAliasType +
-                                    typeof identityApiData[key],
-                            };
-                        }
-                    }
-                }
-                if (Object.keys(identityApiData).length === 0) {
-                    return {
-                        valid: true,
-                    };
-                } else {
-                    // identityApiData.userIdentities can't be undefined
-                    if (identityApiData.userIdentities === undefined) {
-                        return {
-                            valid: false,
-                            error:
-                                Constants.Messages.ValidationMessages
-                                    .UserIdentities,
-                        };
-                        // identityApiData.userIdentities can be null, but if it isn't null or undefined (above conditional), it must be an object
-                    } else if (
-                        identityApiData.userIdentities !== null &&
-                        !self.isObject(identityApiData.userIdentities)
-                    ) {
-                        return {
-                            valid: false,
-                            error:
-                                Constants.Messages.ValidationMessages
-                                    .UserIdentities,
-                        };
-                    }
-                    if (
-                        self.isObject(identityApiData.userIdentities) &&
-                        Object.keys(identityApiData.userIdentities).length
-                    ) {
-                        for (var identityType in identityApiData.userIdentities) {
-                            if (
-                                identityApiData.userIdentities.hasOwnProperty(
-                                    identityType
-                                )
-                            ) {
-                                if (
-                                    Types.IdentityType.getIdentityType(
-                                        identityType
-                                    ) === false
-                                ) {
-                                    return {
-                                        valid: false,
-                                        error:
-                                            Constants.Messages
-                                                .ValidationMessages
-                                                .UserIdentitiesInvalidKey,
-                                    };
-                                }
-                                if (
-                                    !(
-                                        typeof identityApiData.userIdentities[
-                                            identityType
-                                        ] === 'string' ||
-                                        identityApiData.userIdentities[
-                                            identityType
-                                        ] === null
-                                    )
-                                ) {
-                                    return {
-                                        valid: false,
-                                        error:
-                                            Constants.Messages
-                                                .ValidationMessages
-                                                .UserIdentitiesInvalidValues,
-                                    };
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            return {
-                valid: true,
-            };
-        },
-    };
-
     this.isDelayedByIntegration = function(
         delayedIntegrations,
         timeoutStart,
@@ -724,4 +508,16 @@ export default function Helpers(mpInstance) {
     this.isSlug = function(str) {
         return str === Slugify(str);
     };
+
+    // Utility Functions
+    this.converted = utils.converted;
+    this.findKeyInObject = utils.findKeyInObject;
+    this.parseNumber = utils.parseNumber;
+    this.inArray = utils.inArray;
+    this.isObject = utils.isObject;
+    this.decoded = utils.decoded;
+    this.returnConvertedBoolean = utils.returnConvertedBoolean;
+
+    // Imported Validators
+    this.Validators = Validators;
 }

package/src/mp-instance.js

@@ -1218,6 +1218,14 @@ function completeSDKInitialization(apiKey, config, mpInstance) {
     mpInstance._Forwarders = new Forwarders(mpInstance, kitBlocker);
     if (config.flags) {
         if (config.flags.hasOwnProperty(Constants.FeatureFlags.EventsV3)) {
+            // TODO: Remove this after 8/12/2022
+            if (config.flags[Constants.FeatureFlags.EventsV3] !== '100') {
+                var message =
+                    'mParticle will be enabling Event Batching for all customers on July 12, 2022. ' +
+                    'For more details, please see our docs: https://docs.mparticle.com/developers/sdk/web/getting-started/';
+                mpInstance.Logger.warning(message);
+            }
+
             mpInstance._Store.SDKConfig.flags[Constants.FeatureFlags.EventsV3] =
                 config.flags[Constants.FeatureFlags.EventsV3];
         }

package/src/sdkRuntimeModels.ts

@@ -24,6 +24,7 @@ export interface SDKEvent {
     CustomFlags?: { [key: string]: string };
     AppVersion?: string;
     AppName?: string;
+    Package?: string;
     ConsentState?: SDKConsentState;
     IntegrationAttributes?: { [key: string]: { [key: string]: string } };
     ProductAction?: SDKProductAction;
@@ -142,8 +143,10 @@ export interface SDKConfig {
         warning?(msg) 
         verbose?(msg) 
     };
+    onCreateBatch(batch: EventsApi.Batch): EventsApi.Batch;
     dataPlan: DataPlanConfig;
     appVersion?: string;
+    package?: string;
     flags?: { [key: string]: string | number };
     kitConfigs: any;
     appName?: string;
@@ -202,6 +205,7 @@ export interface SDKConfigApi {
     v3SecureServiceUrl?: string;
     isDevelopmentMode: boolean;
     appVersion?: string;
+    onCreateBatch(batch: EventsApi.Batch): EventsApi.Batch
 }
 export interface MParticleUser {
     getMPID(): string;

package/src/sdkToEventsApiConverter.ts

@@ -55,6 +55,7 @@ export function convertEvents(
         application_info: {
             application_version: lastEvent.AppVersion,
             application_name: lastEvent.AppName,
+            package: lastEvent.Package,
         },
         device_info: {
             platform: EventsApi.DeviceInformationPlatformEnum.web,

package/src/serverModel.js

@@ -207,6 +207,7 @@ export default function ServerModel(mpInstance) {
                 ExpandedEventCount: 0,
                 AppVersion: mpInstance.getAppVersion(),
                 AppName: mpInstance.getAppName(),
+                Package: mpInstance._Store.SDKConfig.package,
                 ClientGeneratedId: mpInstance._Store.clientId,
                 DeviceId: mpInstance._Store.deviceId,
                 IntegrationAttributes: mpInstance._Store.integrationAttributes,

package/src/store.js

@@ -154,6 +154,10 @@ export default function Store(config, mpInstance) {
             this.SDKConfig.appName = config.appName;
         }
 
+        if (config.hasOwnProperty('package')) {
+            this.SDKConfig.package = config.package;
+        }
+
         if (config.hasOwnProperty('integrationDelayTimeout')) {
             this.SDKConfig.integrationDelayTimeout =
                 config.integrationDelayTimeout;
@@ -264,6 +268,18 @@ export default function Store(config, mpInstance) {
             }
         }
 
+        if (config.hasOwnProperty('onCreateBatch')) {
+            if (typeof config.onCreateBatch === 'function') {
+                this.SDKConfig.onCreateBatch = config.onCreateBatch;
+            } else {
+                mpInstance.Logger.error(
+                    'config.onCreateBatch must be a function'
+                );
+                // set to undefined because all items are set on createSDKConfig
+                this.SDKConfig.onCreateBatch = undefined;
+            }
+        }
+
         if (!config.hasOwnProperty('flags')) {
             this.SDKConfig.flags = {};
         }

package/src/utils.ts

@@ -0,0 +1,82 @@
+type valueof<T> = T[keyof T];
+
+const inArray = (items: any[], name: string): boolean => {
+    const i = 0;
+
+    if (Array.prototype.indexOf) {
+        return items.indexOf(name, 0) >= 0;
+    } else {
+        for (var n = items.length; i < n; i++) {
+            if (i in items && items[i] === name) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+};
+
+const findKeyInObject = (obj: any, key: string): string => {
+    if (key && obj) {
+        for (var prop in obj) {
+            if (
+                obj.hasOwnProperty(prop) &&
+                prop.toLowerCase() === key.toLowerCase()
+            ) {
+                return prop;
+            }
+        }
+    }
+
+    return null;
+};
+
+const isObject = (value: any): boolean => {
+    var objType = Object.prototype.toString.call(value);
+    return objType === '[object Object]' || objType === '[object Error]';
+};
+
+const parseNumber = (value: string | number): number => {
+    if (isNaN(value as number) || !isFinite(value as number)) {
+        return 0;
+    }
+    var floatValue = parseFloat(value as string);
+    return isNaN(floatValue) ? 0 : floatValue;
+};
+
+// FIXME: REFACTOR for V3
+// only used in store.js to sanitize server-side formatting of
+// booleans when checking for `isDevelopmentMode`
+// Should be removed in v3
+const returnConvertedBoolean = (data: string | boolean | number) => {
+    if (data === 'false' || data === '0') {
+        return false;
+    } else {
+        return Boolean(data);
+    }
+};
+
+const decoded = (s: string): string =>
+    decodeURIComponent(s.replace(/\+/g, ' '));
+
+const converted = (s: string): string => {
+    if (s.indexOf('"') === 0) {
+        s = s
+            .slice(1, -1)
+            .replace(/\\"/g, '"')
+            .replace(/\\\\/g, '\\');
+    }
+
+    return s;
+};
+
+export {
+    valueof,
+    converted,
+    decoded,
+    findKeyInObject,
+    inArray,
+    isObject,
+    parseNumber,
+    returnConvertedBoolean,
+};

package/src/validators.ts

@@ -0,0 +1,165 @@
+import Types from './types';
+import { isObject } from './utils';
+import Constants from './constants';
+import { IdentityApiData } from '@mparticle/web-sdk';
+import { valueof } from './utils';
+
+type IdentityAPIMethod = 'login' | 'logout' | 'identify' | 'modify';
+
+type ValidationIdentitiesReturn = {
+    valid: boolean;
+    error?: valueof<typeof Constants.Messages.ValidationMessages>;
+};
+
+const Validators = {
+    isValidAttributeValue: function(value: any): boolean {
+        return value !== undefined && !isObject(value) && !Array.isArray(value);
+    },
+
+    // Neither null nor undefined can be a valid Key
+    isValidKeyValue: function(key: any): boolean {
+        return Boolean(
+            key &&
+                !isObject(key) &&
+                !Array.isArray(key) &&
+                !this.isFunction(key)
+        );
+    },
+
+    isStringOrNumber: function(value: any): boolean {
+        return typeof value === 'string' || typeof value === 'number';
+    },
+
+    isNumber: function(value: any): boolean {
+        return typeof value === 'number';
+    },
+
+    isFunction: (fn: any): boolean => {
+        return typeof fn === 'function';
+    },
+
+    validateIdentities: function(
+        identityApiData: IdentityApiData,
+        method?: IdentityAPIMethod
+    ): ValidationIdentitiesReturn {
+        var validIdentityRequestKeys = {
+            userIdentities: 1,
+            onUserAlias: 1,
+            copyUserAttributes: 1,
+        };
+        if (identityApiData) {
+            if (method === 'modify') {
+                if (
+                    (isObject(identityApiData.userIdentities) &&
+                        !Object.keys(identityApiData.userIdentities).length) ||
+                    !isObject(identityApiData.userIdentities)
+                ) {
+                    return {
+                        valid: false,
+                        error:
+                            Constants.Messages.ValidationMessages
+                                .ModifyIdentityRequestUserIdentitiesPresent,
+                    };
+                }
+            }
+            for (var key in identityApiData) {
+                if (identityApiData.hasOwnProperty(key)) {
+                    if (!validIdentityRequestKeys[key]) {
+                        return {
+                            valid: false,
+                            error:
+                                Constants.Messages.ValidationMessages
+                                    .IdentityRequesetInvalidKey,
+                        };
+                    }
+                    if (
+                        key === 'onUserAlias' &&
+                        !Validators.isFunction(identityApiData[key])
+                    ) {
+                        return {
+                            valid: false,
+                            // FIXME: Validates type safety
+                            error:
+                                Constants.Messages.ValidationMessages
+                                    .OnUserAliasType +
+                                typeof identityApiData[key],
+                        };
+                    }
+                }
+            }
+            if (Object.keys(identityApiData).length === 0) {
+                return {
+                    valid: true,
+                };
+            } else {
+                // identityApiData.userIdentities can't be undefined
+                if (identityApiData.userIdentities === undefined) {
+                    return {
+                        valid: false,
+                        error:
+                            Constants.Messages.ValidationMessages
+                                .UserIdentities,
+                    };
+                    // identityApiData.userIdentities can be null, but if it isn't null or undefined (above conditional), it must be an object
+                } else if (
+                    identityApiData.userIdentities !== null &&
+                    !isObject(identityApiData.userIdentities)
+                ) {
+                    return {
+                        valid: false,
+                        error:
+                            Constants.Messages.ValidationMessages
+                                .UserIdentities,
+                    };
+                }
+                if (
+                    isObject(identityApiData.userIdentities) &&
+                    Object.keys(identityApiData.userIdentities).length
+                ) {
+                    for (var identityType in identityApiData.userIdentities) {
+                        if (
+                            identityApiData.userIdentities.hasOwnProperty(
+                                identityType
+                            )
+                        ) {
+                            if (
+                                Types.IdentityType.getIdentityType(
+                                    identityType
+                                ) === false
+                            ) {
+                                return {
+                                    valid: false,
+                                    error:
+                                        Constants.Messages.ValidationMessages
+                                            .UserIdentitiesInvalidKey,
+                                };
+                            }
+                            if (
+                                !(
+                                    typeof identityApiData.userIdentities[
+                                        identityType
+                                    ] === 'string' ||
+                                    identityApiData.userIdentities[
+                                        identityType
+                                    ] === null
+                                )
+                            ) {
+                                return {
+                                    valid: false,
+                                    error:
+                                        Constants.Messages.ValidationMessages
+                                            .UserIdentitiesInvalidValues,
+                                };
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return {
+            valid: true,
+        };
+    },
+};
+
+export default Validators;