@mparticle/web-sdk 2.28.1 → 2.28.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mparticle/web-sdk",
-    "version": "2.28.1",
+    "version": "2.28.3",
     "description": "mParticle core SDK for web applications",
     "license": "Apache-2.0",
     "keywords": [

package/src/aliasRequestApiClient.ts

@@ -0,0 +1,89 @@
+import { IAliasRequest, IAliasCallback } from "./identity.interfaces";
+import { MParticleWebSDK } from "./sdkRuntimeModels";
+import Constants from './constants';
+import { FetchUploader, XHRUploader } from './uploaders';
+import { HTTP_ACCEPTED, HTTP_OK } from "./constants";
+
+
+const { HTTPCodes, Messages } = Constants;
+
+interface IAliasResponseBody {
+    message?: string
+}
+
+export async function sendAliasRequest (mpInstance: MParticleWebSDK, aliasRequest: IAliasRequest, aliasCallback: IAliasCallback) {
+        const { verbose, error } = mpInstance.Logger;
+        const { invokeAliasCallback } = mpInstance._Helpers;
+        const { aliasUrl } = mpInstance._Store.SDKConfig;
+        const { devToken: apiKey } = mpInstance._Store;
+
+        verbose(Messages.InformationMessages.SendAliasHttp);
+
+        // https://go.mparticle.com/work/SQDSDKS-6750
+        const uploadUrl = `https://${aliasUrl}${apiKey}/Alias`;
+        const uploader = window.fetch
+        ? new FetchUploader(uploadUrl)
+        : new XHRUploader(uploadUrl);
+        
+        
+        // https://go.mparticle.com/work/SQDSDKS-6568
+        const uploadPayload = {
+            method: 'post',
+            headers: {
+                Accept: 'text/plain;charset=UTF-8',
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(aliasRequest),
+        };
+
+        try {
+            const response = await uploader.upload(uploadPayload);
+
+            let message: string;
+            let aliasResponseBody: IAliasResponseBody;
+
+            // FetchUploader returns the response as a JSON object that we have to await
+            if (response.json) {
+                // HTTP responses of 202, 200, and 403 do not have a response.  response.json will always exist on a fetch, but can only be await-ed when the response is not empty, otherwise it will throw an error.
+                try {
+                    aliasResponseBody = await response.json();
+                } catch (e) {
+                    verbose('The request has no response body');
+                }
+            } else {
+                // https://go.mparticle.com/work/SQDSDKS-6568
+                // XHRUploader returns the response as a string that we need to parse
+                const xhrResponse = response as unknown as XMLHttpRequest;
+                // debugger;
+                aliasResponseBody = xhrResponse.responseText
+                    ? JSON.parse(xhrResponse.responseText)
+                    : '';
+            }
+
+            let errorMessage: string;
+
+            switch (response.status) {
+                case HTTP_OK:
+                case HTTP_ACCEPTED:
+                    // https://go.mparticle.com/work/SQDSDKS-6670
+                    message =
+                        'Successfully sent forwarding stats to mParticle Servers';
+                    break;
+                default:
+                    // 400 has an error message, but 403 doesn't
+                    if (aliasResponseBody?.message) {
+                        errorMessage = aliasResponseBody.message;
+                    }
+                    message =
+                        'Issue with sending Alias Request to mParticle Servers, received HTTP Code of ' +
+                        response.status;
+            }
+
+            verbose(message);
+            invokeAliasCallback(aliasCallback, response.status, errorMessage);
+        } catch (e) {
+            const err = e as Error;
+            error('Error sending alias request to mParticle servers. ' + err);
+            invokeAliasCallback(aliasCallback, HTTPCodes.noHttpCoverage, (err.message));
+        }
+    };

package/src/constants.ts

@@ -189,4 +189,10 @@ export default Constants;
 
 // https://go.mparticle.com/work/SQDSDKS-6080
 export const ONE_DAY_IN_SECONDS = 60 * 60 * 24;
-export const MILLIS_IN_ONE_SEC = 1000;
+export const MILLIS_IN_ONE_SEC = 1000;
+
+// https://developer.mozilla.org/en-US/docs/Web/HTTP/Status
+export const HTTP_OK = 200 as const;
+export const HTTP_ACCEPTED = 202 as const;
+export const HTTP_BAD_REQUEST = 400 as const;
+export const HTTP_FORBIDDEN = 403 as const;

package/src/identity-user-interfaces.ts

@@ -84,6 +84,14 @@ export interface IdentityCallback {
     (result: IdentityResult): void;
 }
 
+export interface IIdentityResponse {
+    // https://go.mparticle.com/work/SQDSDKS-6672
+    responseText: IdentityResultBody;
+    status: number;
+    cacheMaxAge?: number; // Default: 86400
+    expireTimestamp?: number;
+}
+
 export interface IdentityResult {
     httpCode: typeof HTTPCodes;
     getPreviousUser(): User;

package/src/identity-utils.ts

@@ -2,62 +2,95 @@ 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 {
+    IdentityApiData,
+    UserIdentities,
+    IdentityCallback,
+} from '@mparticle/web-sdk';
 import { IdentityAPIMethod } from './identity.interfaces';
+import {
+    IdentityResultBody,
+    IIdentityResponse,
+} from './identity-user-interfaces';
 
 const { Identify, Modify, Login, Logout } = Constants.IdentityMethods;
+const CACHE_HEADER = 'x-mp-max-age' as const;
 
 export type IdentityCache = BaseVault<Dictionary<ICachedIdentityCall>>;
 
+// https://go.mparticle.com/work/SQDSDKS-6675
 export type IParseCachedIdentityResponse = (
-    cachedIdentity: ICachedIdentityCall,
+    cachedIdentity: IIdentityResponse,
     mpid: string,
     callback: IdentityCallback,
     identityApiData: IdentityApiData,
     identityMethod: string,
     knownIdentities: IKnownIdentities,
     fromCachedIdentity: boolean
-) => void
+) => void;
 
 export interface IKnownIdentities extends UserIdentities {
     device_application_stamp?: string;
 }
 
 export interface ICachedIdentityCall {
+    // https://go.mparticle.com/work/SQDSDKS-6672
     responseText: string;
     status: number;
     expireTimestamp: number;
 }
 
+// https://go.mparticle.com/work/SQDSDKS-6568
+// Temporary adapter to convert the XMLHttpRequest response to the IIdentityResponse interface
+export const xhrIdentityResponseAdapter = (
+    possiblyXhr: XMLHttpRequest | IIdentityResponse
+): IIdentityResponse => {
+    if (possiblyXhr.hasOwnProperty('expireTimestamp')) {
+        // If there is an `expireTimestamp`, it is an IIdentityResponse object, so just return it.  This indicates it was a previously cached value.
+        return possiblyXhr as IIdentityResponse;
+    } else {
+        // If there is no `expireTimestamp`, then it is an XHR object and needs to be parsed.
+        return {
+            status: possiblyXhr.status,
+
+            // Sometimes responseText can be an empty string, such as a 404 response
+            responseText: (possiblyXhr as XMLHttpRequest).responseText
+                ? JSON.parse((possiblyXhr as XMLHttpRequest).responseText)
+                : {},
+            cacheMaxAge: parseNumber(
+                (possiblyXhr as XMLHttpRequest)?.getResponseHeader(
+                    CACHE_HEADER
+                ) || ''
+            ),
+            expireTimestamp: 0,
+        };
+    }
+};
+
 export const cacheOrClearIdCache = (
     method: string,
     knownIdentities: IKnownIdentities,
     idCache: BaseVault<Dictionary<ICachedIdentityCall>>,
-    xhr: XMLHttpRequest,
-    parsingCachedResponse: boolean,
+    identityResponse: IIdentityResponse,
+    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';
+    if (parsingCachedResponse) {
+        return;
+    }
 
     // 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);
-    }
+    const expireTimestamp = getExpireTimestamp(identityResponse?.cacheMaxAge);
 
     switch (method) {
-        case Login: 
-        case Identify: 
+        case Login:
+        case Identify:
             cacheIdentityRequest(
                 method,
                 knownIdentities,
                 expireTimestamp,
                 idCache,
-                xhr 
+                identityResponse
             );
             break;
         case Modify:
@@ -65,26 +98,32 @@ export const cacheOrClearIdCache = (
             idCache.purge();
             break;
     }
-}
+};
 
 export const cacheIdentityRequest = (
     method: IdentityAPIMethod,
     identities: IKnownIdentities,
     expireTimestamp: number,
     idCache: IdentityCache,
-    xhr: XMLHttpRequest
+    identityResponse: IIdentityResponse
 ): void => {
-    const cache: Dictionary<ICachedIdentityCall> = idCache.retrieve() || ({} as Dictionary<ICachedIdentityCall>);
+    const { responseText, status } = identityResponse;
+    const cache: Dictionary<ICachedIdentityCall> =
+        idCache.retrieve() || ({} as Dictionary<ICachedIdentityCall>);
     const cacheKey = concatenateIdentities(method, identities);
     const hashedKey = generateHash(cacheKey);
 
-    const { mpid, is_logged_in } = JSON.parse(xhr.responseText);
-    const cachedResponseText = {
+    const { mpid, is_logged_in } = responseText;
+    const cachedResponseBody = {
         mpid,
         is_logged_in,
     };
 
-    cache[hashedKey] = { responseText: JSON.stringify(cachedResponseText), status: xhr.status, expireTimestamp};
+    cache[hashedKey] = {
+        responseText: JSON.stringify(cachedResponseBody),
+        status,
+        expireTimestamp,
+    };
     idCache.store(cache);
 };
 
@@ -115,7 +154,8 @@ export const concatenateIdentities = (
 
         concatenatedIdentities = userIDArray.reduce(
             (prevValue: string, currentValue: string, index: number) => {
-                const idName: string = Types.IdentityType.getIdentityName(index);
+                const idName: string =
+                    Types.IdentityType.getIdentityName(index);
                 return `${prevValue}${idName}=${currentValue};`;
             },
             cacheKey
@@ -128,12 +168,12 @@ export const concatenateIdentities = (
 export const hasValidCachedIdentity = (
     method: IdentityAPIMethod,
     proposedUserIdentities: IKnownIdentities,
-    idCache?: IdentityCache,
+    idCache?: IdentityCache
 ): 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 
+    // 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 
+    // "queued events contain login mpid instead of identify mpid when calling
     // login immediately after mParticle initializes"
     const cache = idCache?.retrieve();
 
@@ -152,12 +192,12 @@ export const hasValidCachedIdentity = (
     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 {
@@ -168,8 +208,8 @@ export const hasValidCachedIdentity = (
 export const getCachedIdentity = (
     method: IdentityAPIMethod,
     proposedUserIdentities: IKnownIdentities,
-    idCache: IdentityCache,
-): ICachedIdentityCall | null => {
+    idCache: IdentityCache
+): IIdentityResponse | null => {
     const cacheKey: string = concatenateIdentities(
         method,
         proposedUserIdentities
@@ -179,7 +219,11 @@ export const getCachedIdentity = (
     const cache = idCache.retrieve();
     const cachedIdentity = cache ? cache[hashedKey] : null;
 
-    return cachedIdentity;
+    return {
+        responseText: parseIdentityResponse(cachedIdentity.responseText),
+        expireTimestamp: cachedIdentity.expireTimestamp,
+        status: cachedIdentity.status,
+    };
 };
 
 // https://go.mparticle.com/work/SQDSDKS-6079
@@ -200,9 +244,12 @@ export const createKnownIdentities = (
     return identitiesResult;
 };
 
-export const removeExpiredIdentityCacheDates = (idCache: BaseVault<Dictionary<ICachedIdentityCall>>) => {
-    const cache: Dictionary<ICachedIdentityCall> = idCache.retrieve() || {} as Dictionary<ICachedIdentityCall>;
-    
+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
@@ -210,10 +257,10 @@ export const removeExpiredIdentityCacheDates = (idCache: BaseVault<Dictionary<IC
         if (cache[key].expireTimestamp < currentTime) {
             delete cache[key];
         }
-    };
+    }
 
     idCache.store(cache);
-}
+};
 
 export const tryCacheIdentity = (
     knownIdentities: IKnownIdentities,
@@ -223,7 +270,7 @@ export const tryCacheIdentity = (
     callback: IdentityCallback,
     identityApiData: IdentityApiData,
     identityMethod: IdentityAPIMethod
-): boolean =>  {
+): boolean => {
     // https://go.mparticle.com/work/SQDSDKS-6095
     const shouldReturnCachedIdentity = hasValidCachedIdentity(
         identityMethod,
@@ -252,4 +299,10 @@ export const tryCacheIdentity = (
         return true;
     }
     return false;
-}
+};
+
+const getExpireTimestamp = (maxAge: number = ONE_DAY_IN_SECONDS): number =>
+    new Date().getTime() + maxAge * MILLIS_IN_ONE_SEC;
+
+const parseIdentityResponse = (responseText: string): IdentityResultBody =>
+    responseText ? JSON.parse(responseText) : ({} as IdentityResultBody);

package/src/identity.interfaces.ts

@@ -10,6 +10,7 @@ import {
     IUserIdentityChangeEvent,
     IMParticleUser,
     mParticleUserCart,
+    IIdentityResponse,
 } from './identity-user-interfaces';
 const { platform, sdkVendor, sdkVersion, HTTPCodes } = Constants;
 
@@ -114,6 +115,15 @@ export interface IAliasRequest {
     scope?: string;
 }
 
+export interface IAliasCallback {
+    (result: IAliasResult): void;
+}
+
+export interface IAliasResult {
+    httpCode: number;
+    message: string;
+}
+
 export interface SDKIdentityApi {
     HTTPCodes: typeof HTTPCodes;
     identify?(
@@ -170,7 +180,7 @@ export interface IIdentity {
         userInMemory: IMParticleUser
     ): IUserIdentityChangeEvent;
     parseIdentityResponse(
-        xhr: XMLHttpRequest,
+        identityResponse: IIdentityResponse,
         previousMPID: MPID,
         callback: IdentityCallback,
         identityApiData: IdentityApiData,

package/src/identity.js

@@ -1,9 +1,10 @@
-import Constants from './constants';
+import Constants, { HTTP_OK } from './constants';
 import Types from './types';
 import {
     cacheOrClearIdCache,
     createKnownIdentities,
     tryCacheIdentity,
+    xhrIdentityResponseAdapter,
 } from './identity-utils';
 import AudienceManager from './audienceManager';
 const { Messages, HTTPCodes, FeatureFlags, IdentityMethods } = Constants;
@@ -1460,7 +1461,7 @@ export default function Identity(mpInstance) {
 
     // https://go.mparticle.com/work/SQDSDKS-6355
     this.parseIdentityResponse = function(
-        xhr,
+        identityResponse,
         previousMPID,
         callback,
         identityApiData,
@@ -1486,9 +1487,7 @@ export default function Identity(mpInstance) {
                 'Parsing "' + method + '" identity response from server'
             );
 
-            identityApiResult = xhr.responseText
-                ? JSON.parse(xhr.responseText)
-                : null;
+            identityApiResult = identityResponse.responseText ?? null;
 
             mpInstance._Store.isLoggedIn =
                 identityApiResult?.is_logged_in || false;
@@ -1513,13 +1512,16 @@ export default function Identity(mpInstance) {
                 );
             }
 
-            if (xhr.status === 200) {
+            if (identityResponse.status === HTTP_OK) {
                 if (getFeatureFlag(CacheIdentity)) {
+                    const identityResponseForCache = xhrIdentityResponseAdapter(
+                        identityResponse
+                    );
                     cacheOrClearIdCache(
                         method,
                         knownIdentities,
                         self.idCache,
-                        xhr,
+                        identityResponseForCache,
                         parsingCachedResponse
                     );
                 }
@@ -1642,7 +1644,9 @@ export default function Identity(mpInstance) {
 
             if (callback) {
                 const callbackCode =
-                    xhr.status === 0 ? HTTPCodes.noHttpCoverage : xhr.status;
+                    identityResponse.status === 0
+                        ? HTTPCodes.noHttpCoverage
+                        : identityResponse.status;
 
                 mpInstance._Helpers.invokeCallback(
                     callback,
@@ -1657,7 +1661,7 @@ export default function Identity(mpInstance) {
                 // https://go.mparticle.com/work/SQDSDKS-6500
                 mpInstance.Logger.error(
                     'Received HTTP response code of ' +
-                        xhr.status +
+                        identityResponse.status +
                         ' - ' +
                         identityApiResult.errors[0].message
                 );
@@ -1671,7 +1675,7 @@ export default function Identity(mpInstance) {
             if (callback) {
                 mpInstance._Helpers.invokeCallback(
                     callback,
-                    xhr.status,
+                    identityResponse.status,
                     identityApiResult || null
                 );
             }

package/src/identityApiClient.js

@@ -1,4 +1,6 @@
 import Constants from './constants';
+import { xhrIdentityResponseAdapter } from './identity-utils';
+import { sendAliasRequest } from './aliasRequestApiClient';
 
 var HTTPCodes = Constants.HTTPCodes,
     Messages = Constants.Messages;
@@ -6,59 +8,8 @@ var HTTPCodes = Constants.HTTPCodes,
 const { Modify } = Constants.IdentityMethods;
 
 export default function IdentityAPIClient(mpInstance) {
-    this.sendAliasRequest = function(aliasRequest, callback) {
-        var xhr,
-            xhrCallback = function() {
-                if (xhr.readyState === 4) {
-                    // https://go.mparticle.com/work/SQDSDKS-6368
-                    mpInstance.Logger.verbose(
-                        'Received ' + xhr.statusText + ' from server'
-                    );
-                    //only parse error messages from failing requests
-                    if (xhr.status !== 200 && xhr.status !== 202) {
-                        if (xhr.responseText) {
-                            var response = JSON.parse(xhr.responseText);
-                            if (response.hasOwnProperty('message')) {
-                                var errorMessage = response.message;
-                                mpInstance._Helpers.invokeAliasCallback(
-                                    callback,
-                                    xhr.status,
-                                    errorMessage
-                                );
-                                return;
-                            }
-                        }
-                    }
-                    mpInstance._Helpers.invokeAliasCallback(
-                        callback,
-                        xhr.status
-                    );
-                }
-            };
-        mpInstance.Logger.verbose(Messages.InformationMessages.SendAliasHttp);
-
-        xhr = mpInstance._Helpers.createXHR(xhrCallback);
-        if (xhr) {
-            try {
-                xhr.open(
-                    'post',
-                    mpInstance._Helpers.createServiceUrl(
-                        mpInstance._Store.SDKConfig.aliasUrl,
-                        mpInstance._Store.devToken
-                    ) + '/Alias'
-                );
-                xhr.send(JSON.stringify(aliasRequest));
-            } catch (e) {
-                mpInstance._Helpers.invokeAliasCallback(
-                    callback,
-                    HTTPCodes.noHttpCoverage,
-                    e
-                );
-                mpInstance.Logger.error(
-                    'Error sending alias request to mParticle servers. ' + e
-                );
-            }
-        }
+    this.sendAliasRequest = async function(aliasRequest, callback) {
+        await sendAliasRequest(mpInstance, aliasRequest, callback);
     };
 
     this.sendIdentityRequest = function(
@@ -78,8 +29,11 @@ export default function IdentityAPIClient(mpInstance) {
                     mpInstance.Logger.verbose(
                         'Received ' + xhr.statusText + ' from server'
                     );
+
+                    // https://go.mparticle.com/work/SQDSDKS-6565
+                    const identityResponse = xhrIdentityResponseAdapter(xhr);
                     parseIdentityResponse(
-                        xhr,
+                        identityResponse,
                         previousMPID,
                         callback,
                         originalIdentityApiData,

package/src/sdkRuntimeModels.ts

@@ -16,7 +16,11 @@ import { IPersistence } from './persistence.interfaces';
 import { IMPSideloadedKit } from './sideloadedKit';
 import { ISessionManager } from './sessionManager';
 import { Kit, MPForwarder } from './forwarders.interfaces';
-import { IIdentity, SDKIdentityApi } from './identity.interfaces';
+import {
+    IIdentity,
+    SDKIdentityApi,
+    IAliasCallback,
+} from './identity.interfaces';
 import {
     ISDKUserAttributeChangeData,
     ISDKUserIdentityChanges,
@@ -265,6 +269,11 @@ export interface SDKHelpersApi {
     generateHash?(value: string): string;
     // https://go.mparticle.com/work/SQDSDKS-6317
     getFeatureFlag?(feature: string): boolean | string; // TODO: Feature Constants should be converted to enum
+    invokeAliasCallback(
+        aliasCallback: IAliasCallback,
+        number: number,
+        errorMessage: string
+    ): void;
     isDelayedByIntegration?(
         delayedIntegrations: Dictionary<boolean>,
         timeoutStart: number,

package/src/uploaders.ts

@@ -47,6 +47,7 @@ export class XHRUploader extends AsyncUploader {
     // 3   LOADING Downloading; responseText holds partial data.
     // 4   DONE    The operation is complete.
 
+    // https://go.mparticle.com/work/SQDSDKS-6736
     private async makeRequest(
         url: string,
         data: string,
@@ -58,13 +59,17 @@ export class XHRUploader extends AsyncUploader {
                 if (xhr.readyState !== 4) return;
 
                 // Process the response
-                if (xhr.status >= 200 && xhr.status < 300) {
-                    resolve(xhr as unknown as Response);
-                } else {
-                    reject(xhr);
-                }
+                // We resolve all xhr responses whose ready state is 4 regardless of HTTP codes that may be errors (400+)
+                // because these are valid HTTP responses.
+                resolve((xhr as unknown) as Response);
             };
 
+            // Reject a promise only when there is an xhr error
+            xhr.onerror = () => {
+                reject((xhr as unknown) as Response);
+            };
+
+
             xhr.open(method, url);
             xhr.send(data);
         });