@mparticle/web-sdk 2.28.2 → 2.28.3

package/package.json

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

@@ -115,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?(

package/src/identity.js

@@ -1,4 +1,4 @@
-import Constants from './constants';
+import Constants, { HTTP_OK } from './constants';
 import Types from './types';
 import {
     cacheOrClearIdCache,
@@ -13,7 +13,6 @@ const { CacheIdentity } = FeatureFlags;
 const { Identify, Modify, Login, Logout } = IdentityMethods;
 import {
     generateDeprecationMessage,
-    HTTP_SUCCESS,
     isEmpty,
     isFunction,
     isObject,
@@ -1513,7 +1512,7 @@ export default function Identity(mpInstance) {
                 );
             }
 
-            if (identityResponse.status === HTTP_SUCCESS) {
+            if (identityResponse.status === HTTP_OK) {
                 if (getFeatureFlag(CacheIdentity)) {
                     const identityResponseForCache = xhrIdentityResponseAdapter(
                         identityResponse

package/src/identityApiClient.js

@@ -1,5 +1,6 @@
 import Constants from './constants';
 import { xhrIdentityResponseAdapter } from './identity-utils';
+import { sendAliasRequest } from './aliasRequestApiClient';
 
 var HTTPCodes = Constants.HTTPCodes,
     Messages = Constants.Messages;
@@ -7,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(

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);
         });

package/src/utils.ts

@@ -9,8 +9,6 @@ export type Dictionary<V = any> = Record<string, V>;
 
 export type Environment = 'development' | 'production';
 
-export const HTTP_SUCCESS = 200 as const;
-
 const createCookieString = (value: string): string =>
     replaceCommasWithPipes(replaceQuotesWithApostrophes(value));