@mparticle/web-sdk 2.24.0 → 2.25.0

package/src/identity-utils.ts

@@ -0,0 +1,247 @@
+import Constants, { ONE_DAY_IN_SECONDS, MILLIS_IN_ONE_SEC } from './constants';
+import { Dictionary, parseNumber, isObject, generateHash } from './utils';
+import { BaseVault } from './vault';
+import Types from './types';
+import { IdentityApiData, UserIdentities, IdentityCallback } from '@mparticle/web-sdk';
+import { IdentityAPIMethod, MParticleWebSDK } from './sdkRuntimeModels';
+
+const { Identify, Modify, Login, Logout } = Constants.IdentityMethods;
+
+export type IParseCachedIdentityResponse = (
+    cachedIdentity: ICachedIdentityCall,
+    mpid: string,
+    callback: IdentityCallback,
+    identityApiData: IdentityApiData,
+    identityMethod: string,
+    knownIdentities: IKnownIdentities,
+    fromCachedIdentity: boolean
+) => void
+
+export interface IKnownIdentities extends UserIdentities {
+    device_application_stamp?: string;
+}
+
+export interface ICachedIdentityCall {
+    responseText: string;
+    status: number;
+    expireTimestamp: number;
+}
+
+export const cacheOrClearIdCache = (
+    method: string,
+    knownIdentities: IKnownIdentities,
+    idCache: BaseVault<Dictionary<ICachedIdentityCall>>,
+    xhr: XMLHttpRequest,
+    parsingCachedResponse: boolean,
+): void => {
+    // when parsing a response that has already been cached, simply return instead of attempting another cache
+    if (parsingCachedResponse) { return; }
+
+    const CACHE_HEADER = 'x-mp-max-age';
+
+    // default the expire timestamp to one day in milliseconds unless a header comes back
+    let now = new Date().getTime();
+    let expireTimestamp = now + ONE_DAY_IN_SECONDS * MILLIS_IN_ONE_SEC;
+    if (xhr.getAllResponseHeaders().includes(CACHE_HEADER)) {
+        expireTimestamp =
+            now + (parseNumber(xhr.getResponseHeader(CACHE_HEADER)) * MILLIS_IN_ONE_SEC);
+    }
+
+    switch (method) {
+        case Login: 
+        case Identify: 
+            cacheIdentityRequest(
+                method,
+                knownIdentities,
+                expireTimestamp,
+                idCache,
+                xhr 
+            );
+            break;
+        case Modify:
+        case Logout:
+            idCache.purge();
+            break;
+    }
+}
+
+export const cacheIdentityRequest = (
+    method: IdentityAPIMethod,
+    identities: IKnownIdentities,
+    expireTimestamp: number,
+    idCache: BaseVault<Dictionary<ICachedIdentityCall>>,
+    xhr: XMLHttpRequest
+): void => {
+    const cache: Dictionary<ICachedIdentityCall> = idCache.retrieve() || ({} as Dictionary<ICachedIdentityCall>);
+    const cacheKey = concatenateIdentities(method, identities);
+    const hashedKey = generateHash(cacheKey);
+
+    cache[hashedKey] = { responseText: xhr.responseText, status: xhr.status, expireTimestamp};
+    idCache.store(cache);
+};
+
+// We need to ensure that identities are concatenated in a deterministic way, so
+// we sort the identities based on their enum.
+// we create an array, set the user identity at the index of the user identity type
+export const concatenateIdentities = (
+    method: IdentityAPIMethod,
+    userIdentities: IKnownIdentities
+): string => {
+    const DEVICE_APPLICATION_STAMP = 'device_application_stamp';
+    // set DAS first since it is not an official identity type
+    let cacheKey: string = `${method}:${DEVICE_APPLICATION_STAMP}=${userIdentities.device_application_stamp};`;
+    const idLength: number = Object.keys(userIdentities).length;
+    let concatenatedIdentities: string = '';
+
+    if (idLength) {
+        let userIDArray: Array<string> = new Array();
+        // create an array where each index is equal to the user identity type
+        for (let key in userIdentities) {
+            if (key === DEVICE_APPLICATION_STAMP) {
+                continue;
+            } else {
+                userIDArray[Types.IdentityType.getIdentityType(key)] =
+                    userIdentities[key];
+            }
+        }
+
+        concatenatedIdentities = userIDArray.reduce(
+            (prevValue: string, currentValue: string, index: number) => {
+                const idName: string = Types.IdentityType.getIdentityName(index);
+                return `${prevValue}${idName}=${currentValue};`;
+            },
+            cacheKey
+        );
+    }
+
+    return concatenatedIdentities;
+};
+
+export const hasValidCachedIdentity = (
+    method: IdentityAPIMethod,
+    proposedUserIdentities: IKnownIdentities,
+    idCache?: BaseVault<Dictionary<ICachedIdentityCall>>
+): boolean => {
+    // There is an edge case where multiple identity calls are taking place 
+    // before identify fires, so there may not be a cache.  See what happens when 
+    // the ? in idCache is removed to the following test
+    // "queued events contain login mpid instead of identify mpid when calling 
+    // login immediately after mParticle initializes"
+    const cache = idCache?.retrieve();
+
+    // if there is no cache, then there is no valid cached identity
+    if (!cache) {
+        return false;
+    }
+
+    const cacheKey: string = concatenateIdentities(
+        method,
+        proposedUserIdentities
+    );
+    const hashedKey = generateHash(cacheKey);
+
+    // if cache doesn't have the cacheKey, there is no valid cached identity
+    if (!cache.hasOwnProperty(hashedKey)) {
+        return false;
+    }
+    
+    // If there is a valid cache key, compare the expireTimestamp to the current time.
+    // If the current time is greater than the expireTimestamp, it is not a valid
+    // cached identity.
+    const expireTimestamp = cache[hashedKey].expireTimestamp;
+    
+    if (expireTimestamp < new Date().getTime()) {
+        return false;
+    } else {
+        return true;
+    }
+};
+
+export const getCachedIdentity = (
+    method: IdentityAPIMethod,
+    proposedUserIdentities: IKnownIdentities,
+    idCache: BaseVault<Dictionary<ICachedIdentityCall>>
+): ICachedIdentityCall | null => {
+    const cacheKey: string = concatenateIdentities(
+        method,
+        proposedUserIdentities
+    );
+    const hashedKey = generateHash(cacheKey);
+
+    const cache = idCache.retrieve();
+    const cachedIdentity = cache ? cache[hashedKey] : null;
+
+    return cachedIdentity;
+};
+
+// https://go.mparticle.com/work/SQDSDKS-6079
+export const createKnownIdentities = (
+    identityApiData: IdentityApiData,
+    deviceId: string
+): IKnownIdentities => {
+    const identitiesResult: IKnownIdentities = {};
+
+    if (isObject(identityApiData?.userIdentities)) {
+        for (let identity in identityApiData.userIdentities) {
+            identitiesResult[identity] =
+                identityApiData.userIdentities[identity];
+        }
+    }
+    identitiesResult.device_application_stamp = deviceId;
+
+    return identitiesResult;
+};
+
+export const removeExpiredIdentityCacheDates = (idCache: BaseVault<Dictionary<ICachedIdentityCall>>) => {
+    const cache: Dictionary<ICachedIdentityCall> = idCache.retrieve() || {} as Dictionary<ICachedIdentityCall>;
+    
+    const currentTime: number = new Date().getTime();
+
+    // Iterate over the cache and remove any key/value pairs that are expired
+    for (let key in cache) {
+        if (cache[key].expireTimestamp < currentTime) {
+            delete cache[key];
+        }
+    };
+
+    idCache.store(cache);
+}
+
+export const tryCacheIdentity = (
+    knownIdentities: IKnownIdentities,
+    idCache: BaseVault<Dictionary<ICachedIdentityCall>>,
+    parseIdentityResponse: IParseCachedIdentityResponse,
+    mpid: string,
+    callback: IdentityCallback,
+    identityApiData: IdentityApiData,
+    identityMethod: IdentityAPIMethod
+): boolean =>  {
+    // https://go.mparticle.com/work/SQDSDKS-6095
+    const shouldReturnCachedIdentity = hasValidCachedIdentity(
+        identityMethod,
+        knownIdentities,
+        idCache
+    );
+
+    // If Identity is cached, then immediately parse the identity response
+    if (shouldReturnCachedIdentity) {
+        const cachedIdentity = getCachedIdentity(
+            identityMethod,
+            knownIdentities,
+            idCache
+        );
+
+        parseIdentityResponse(
+            cachedIdentity,
+            mpid,
+            callback,
+            identityApiData,
+            identityMethod,
+            knownIdentities,
+            true
+        );
+
+        return true;
+    }
+    return false;
+}

package/src/identity.js

@@ -1,13 +1,20 @@
 import Constants from './constants';
 import Types from './types';
+import {
+    cacheOrClearIdCache,
+    createKnownIdentities,
+    tryCacheIdentity,
+} from './identity-utils';
 
 var Messages = Constants.Messages,
     HTTPCodes = Constants.HTTPCodes;
 
-const { Identify, Modify } = Constants.IdentityMethods;
+const { Identify, Modify, Login, Logout } = Constants.IdentityMethods;
 
 export default function Identity(mpInstance) {
     var self = this;
+    this.idCache = null;
+
     this.checkIdentitySwap = function(
         previousMPID,
         currentMPID,
@@ -24,24 +31,6 @@ export default function Identity(mpInstance) {
     };
 
     this.IdentityRequest = {
-        createKnownIdentities: function(identityApiData, deviceId) {
-            var identitiesResult = {};
-
-            if (
-                identityApiData &&
-                identityApiData.userIdentities &&
-                mpInstance._Helpers.isObject(identityApiData.userIdentities)
-            ) {
-                for (var identity in identityApiData.userIdentities) {
-                    identitiesResult[identity] =
-                        identityApiData.userIdentities[identity];
-                }
-            }
-            identitiesResult.device_application_stamp = deviceId;
-
-            return identitiesResult;
-        },
-
         preProcessIdentityRequest: function(identityApiData, callback, method) {
             mpInstance.Logger.verbose(
                 Messages.InformationMessages.StartingLogEvent + ': ' + method
@@ -103,7 +92,7 @@ export default function Identity(mpInstance) {
                 request_id: mpInstance._Helpers.generateUniqueId(),
                 request_timestamp_ms: new Date().getTime(),
                 previous_mpid: mpid || null,
-                known_identities: this.createKnownIdentities(
+                known_identities: createKnownIdentities(
                     identityApiData,
                     deviceId
                 ),
@@ -246,7 +235,7 @@ export default function Identity(mpInstance) {
                 preProcessResult = mpInstance._Identity.IdentityRequest.preProcessIdentityRequest(
                     identityApiData,
                     callback,
-                    'identify'
+                    Identify
                 );
             if (currentUser) {
                 mpid = currentUser.getMPID();
@@ -262,6 +251,25 @@ export default function Identity(mpInstance) {
                     mpInstance._Store.context,
                     mpid
                 );
+                if (
+                    mpInstance._Helpers.getFeatureFlag(
+                        Constants.FeatureFlags.CacheIdentity
+                    )
+                ) {
+                    const successfullyCachedIdentity = tryCacheIdentity(
+                        identityApiRequest.known_identities,
+                        self.idCache,
+                        self.parseIdentityResponse,
+                        mpid,
+                        callback,
+                        identityApiData,
+                        Identify
+                    );
+
+                    if (successfullyCachedIdentity) {
+                        return;
+                    }
+                }
 
                 if (mpInstance._Helpers.canLog()) {
                     if (mpInstance._Store.webviewBridgeEnabled) {
@@ -281,11 +289,12 @@ export default function Identity(mpInstance) {
                     } else {
                         mpInstance._IdentityAPIClient.sendIdentityRequest(
                             identityApiRequest,
-                            'identify',
+                            Identify,
                             callback,
                             identityApiData,
                             self.parseIdentityResponse,
-                            mpid
+                            mpid,
+                            identityApiRequest.known_identities
                         );
                     }
                 } else {
@@ -319,7 +328,7 @@ export default function Identity(mpInstance) {
                 preProcessResult = mpInstance._Identity.IdentityRequest.preProcessIdentityRequest(
                     identityApiData,
                     callback,
-                    'logout'
+                    Logout
                 );
             if (currentUser) {
                 mpid = currentUser.getMPID();
@@ -355,7 +364,7 @@ export default function Identity(mpInstance) {
                     } else {
                         mpInstance._IdentityAPIClient.sendIdentityRequest(
                             identityApiRequest,
-                            'logout',
+                            Logout,
                             callback,
                             identityApiData,
                             self.parseIdentityResponse,
@@ -408,8 +417,9 @@ export default function Identity(mpInstance) {
                 preProcessResult = mpInstance._Identity.IdentityRequest.preProcessIdentityRequest(
                     identityApiData,
                     callback,
-                    'login'
+                    Login
                 );
+
             if (currentUser) {
                 mpid = currentUser.getMPID();
             }
@@ -425,6 +435,26 @@ export default function Identity(mpInstance) {
                     mpid
                 );
 
+                if (
+                    mpInstance._Helpers.getFeatureFlag(
+                        Constants.FeatureFlags.CacheIdentity
+                    )
+                ) {
+                    const successfullyCachedIdentity = tryCacheIdentity(
+                        identityApiRequest.known_identities,
+                        self.idCache,
+                        self.parseIdentityResponse,
+                        mpid,
+                        callback,
+                        identityApiData,
+                        Login
+                    );
+
+                    if (successfullyCachedIdentity) {
+                        return;
+                    }
+                }
+
                 if (mpInstance._Helpers.canLog()) {
                     if (mpInstance._Store.webviewBridgeEnabled) {
                         mpInstance._NativeSdkHelpers.sendToNative(
@@ -443,11 +473,12 @@ export default function Identity(mpInstance) {
                     } else {
                         mpInstance._IdentityAPIClient.sendIdentityRequest(
                             identityApiRequest,
-                            'login',
+                            Login,
                             callback,
                             identityApiData,
                             self.parseIdentityResponse,
-                            mpid
+                            mpid,
+                            identityApiRequest.known_identities
                         );
                     }
                 } else {
@@ -481,7 +512,7 @@ export default function Identity(mpInstance) {
                 preProcessResult = mpInstance._Identity.IdentityRequest.preProcessIdentityRequest(
                     identityApiData,
                     callback,
-                    'modify'
+                    Modify
                 );
             if (currentUser) {
                 mpid = currentUser.getMPID();
@@ -520,11 +551,12 @@ export default function Identity(mpInstance) {
                     } else {
                         mpInstance._IdentityAPIClient.sendIdentityRequest(
                             identityApiRequest,
-                            'modify',
+                            Modify,
                             callback,
                             identityApiData,
                             self.parseIdentityResponse,
-                            mpid
+                            mpid,
+                            identityApiRequest.known_identities
                         );
                     }
                 } else {
@@ -1423,7 +1455,9 @@ export default function Identity(mpInstance) {
         previousMPID,
         callback,
         identityApiData,
-        method
+        method,
+        knownIdentities,
+        parsingCachedResponse
     ) {
         var prevUser = mpInstance.Identity.getUser(previousMPID),
             newUser,
@@ -1478,6 +1512,20 @@ export default function Identity(mpInstance) {
             }
 
             if (xhr.status === 200) {
+                if (
+                    mpInstance._Helpers.getFeatureFlag(
+                        Constants.FeatureFlags.CacheIdentity
+                    )
+                ) {
+                    cacheOrClearIdCache(
+                        method,
+                        knownIdentities,
+                        self.idCache,
+                        xhr,
+                        parsingCachedResponse
+                    );
+                }
+
                 if (method === Modify) {
                     newIdentitiesByType = mpInstance._Identity.IdentityRequest.combineUserIdentities(
                         previousUIByName,
@@ -1715,7 +1763,7 @@ export default function Identity(mpInstance) {
         var currentUserInMemory, userIdentityChangeEvent;
 
         if (!mpid) {
-            if (method !== 'modify') {
+            if (method !== Modify) {
                 return;
             }
         }

package/src/identityApiClient.js

@@ -66,7 +66,8 @@ export default function IdentityAPIClient(mpInstance) {
         callback,
         originalIdentityApiData,
         parseIdentityResponse,
-        mpid
+        mpid,
+        knownIdentities
     ) {
         var xhr,
             previousMPID,
@@ -80,7 +81,9 @@ export default function IdentityAPIClient(mpInstance) {
                         previousMPID,
                         callback,
                         originalIdentityApiData,
-                        method
+                        method,
+                        knownIdentities,
+                        false
                     );
                 }
             };

package/src/mockBatchCreator.ts

@@ -12,7 +12,7 @@ const mockFunction = function() {
 };
 export default class _BatchValidator {
     private getMPInstance() {
-        return {
+        return ({
             // Certain Helper, Store, and Identity properties need to be mocked to be used in the `returnBatch` method
             _Helpers: {
                 sanitizeAttributes: window.mParticle.getInstance()._Helpers
@@ -119,7 +119,7 @@ export default class _BatchValidator {
             logLevel: 'none',
             setPosition: mockFunction,
             upload: mockFunction,
-        } as MParticleWebSDK;
+        } as unknown) as MParticleWebSDK;
     }
 
     private createSDKEventFunction(event): SDKEvent {

package/src/mp-instance.js

@@ -36,6 +36,8 @@ import Consent from './consent';
 import KitBlocker from './kitBlocking';
 import ConfigAPIClient from './configAPIClient';
 import IdentityAPIClient from './identityApiClient';
+import { LocalStorageVault } from './vault';
+import { removeExpiredIdentityCacheDates } from './identity-utils';
 
 var Messages = Constants.Messages,
     HTTPCodes = Constants.HTTPCodes;
@@ -1302,12 +1304,27 @@ function completeSDKInitialization(apiKey, config, mpInstance) {
         }
     }
 
+    // add a new function to apply items to the store that require config to be returned
     mpInstance._Store.storageName = mpInstance._Helpers.createMainStorageName(
         config.workspaceToken
     );
     mpInstance._Store.prodStorageName = mpInstance._Helpers.createProductStorageName(
         config.workspaceToken
     );
+
+    // idCache is instantiated here as opposed to when _Identity is instantiated
+    // because it depends on _Store.storageName, which is not sent until above
+    // because it is a setting on config which returns asyncronously
+    // in self hosted mode
+    mpInstance._Identity.idCache = new LocalStorageVault(
+        `${mpInstance._Store.storageName}-id-cache`,
+        {
+            logger: mpInstance.Logger,
+        }
+    );
+
+    removeExpiredIdentityCacheDates(mpInstance._Identity.idCache);
+
     if (config.hasOwnProperty('workspaceToken')) {
         mpInstance._Store.SDKConfig.workspaceToken = config.workspaceToken;
     } else {

package/src/mparticle-instance-manager.js

@@ -355,7 +355,7 @@ function mParticle() {
     };
 
     this.Identity = {
-        HTTPCodes: self.getInstance().Identity.HTTPCodes,
+        HTTPCodes: Constants.HTTPCodes,
         aliasUsers: function(aliasRequest, callback) {
             self.getInstance().Identity.aliasUsers(aliasRequest, callback);
         },

package/src/sdkRuntimeModels.ts

@@ -3,7 +3,7 @@ import { DataPlanVersion } from '@mparticle/data-planning-models';
 import { MPConfiguration, IdentityApiData } from '@mparticle/web-sdk';
 import { IStore } from './store';
 import Validators from './validators';
-import { Dictionary } from './utils';
+import { Dictionary, valueof } from './utils';
 import { IServerModel } from './serverModel';
 import { IKitConfigs } from './configAPIClient';
 import { SDKConsentApi, SDKConsentState } from './consent';
@@ -11,6 +11,7 @@ import { IPersistence } from './persistence.interfaces';
 import { IMPSideloadedKit } from './sideloadedKit';
 import { ISessionManager } from './sessionManager';
 import { Kit, MPForwarder } from './forwarders.interfaces';
+import Constants from './constants';
 
 // TODO: Resolve this with version in @mparticle/web-sdk
 export type SDKEventCustomFlags = Dictionary<any>;
@@ -52,6 +53,8 @@ export interface SDKEvent {
     LaunchReferral?: string;
 }
 
+export type IdentityAPIMethod = valueof<typeof Constants.IdentityMethods>;
+
 export interface SDKGeoLocation {
     lat: number | string;
     lng: number | string;
@@ -238,6 +241,7 @@ export interface SDKIdentityApi {
     login;
     logout;
     modify;
+    getUser(mpid: string): MParticleUser;
 }
 
 export interface SDKHelpersApi {

package/src/store.ts

@@ -116,6 +116,7 @@ export interface IFeatureFlags {
     eventBatchingIntervalMillis?: number;
     offlineStorage?: string;
     directURLRouting?: boolean;
+    cacheIdentity?: boolean;
 }
 
 // Temporary Interface until Store can be refactored as a class
@@ -429,6 +430,7 @@ export function processFlags(
         EventBatchingIntervalMillis,
         OfflineStorage,
         DirectUrlRouting,
+        CacheIdentity,
     } = Constants.FeatureFlags;
 
     if (!config.flags) {
@@ -443,6 +445,7 @@ export function processFlags(
         Constants.DefaultConfig.uploadInterval;
     flags[OfflineStorage] = config.flags[OfflineStorage] || '0';
     flags[DirectUrlRouting] = config.flags[DirectUrlRouting] === 'True';
+    flags[CacheIdentity] = config.flags[CacheIdentity] === 'True';
 
     return flags;
 }

package/src/validators.ts

@@ -8,8 +8,7 @@ import {
 } from './utils';
 import Constants from './constants';
 import { IdentityApiData } from '@mparticle/web-sdk';
-
-type IdentityAPIMethod = 'login' | 'logout' | 'identify' | 'modify';
+import { IdentityAPIMethod } from './sdkRuntimeModels';
 
 type ValidationIdentitiesReturn = {
     valid: boolean;