@mparticle/web-sdk 2.32.1 → 2.32.2

package/package.json

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

package/src/audienceManager.ts

@@ -3,7 +3,7 @@ import {
     FetchUploader,
     XHRUploader,
     AsyncUploader,
-    fetchPayload
+    IFetchPayload
 } from './uploaders';
 import Audience from './audience';
 
@@ -38,7 +38,7 @@ export default class AudienceManager {
     public async sendGetUserAudienceRequest(mpid: string, callback: (userAudiences: IAudienceMemberships) => void) {
         this.logger.verbose('Fetching user audiences from server');
 
-        const fetchPayload: fetchPayload = {
+        const fetchPayload: IFetchPayload = {
             method: 'GET',
             headers: {
                 Accept: '*/*',

package/src/batchUploader.ts

@@ -9,7 +9,7 @@ import {
     AsyncUploader,
     FetchUploader,
     XHRUploader,
-    fetchPayload,
+    IFetchPayload,
 } from './uploaders';
 import { IMParticleUser } from './identity-user-interfaces';
 
@@ -366,7 +366,7 @@ export class BatchUploader {
         logger.verbose(`Batch count: ${uploads.length}`);
 
         for (let i = 0; i < uploads.length; i++) {
-            const fetchPayload: fetchPayload = {
+            const fetchPayload: IFetchPayload = {
                 method: 'POST',
                 headers: {
                     Accept: BatchUploader.CONTENT_TYPE,

package/src/configAPIClient.ts

@@ -9,7 +9,7 @@ import {
 import { Dictionary } from './utils';
 import {
     AsyncUploader,
-    fetchPayload,
+    IFetchPayload,
     FetchUploader,
     XHRUploader,
 } from './uploaders';
@@ -125,7 +125,7 @@ export default function ConfigAPIClient(
 
     this.getSDKConfiguration = async (): Promise<IConfigResponse> => {
         let configResponse: IConfigResponse;
-        const fetchPayload: fetchPayload = {
+        const fetchPayload: IFetchPayload = {
             method: 'get',
             headers: {
                 Accept: 'text/plain;charset=UTF-8',

package/src/identityApiClient.ts

@@ -0,0 +1,284 @@
+import Constants, { HTTP_ACCEPTED, HTTP_OK } from './constants';
+import {
+    AsyncUploader,
+    FetchUploader,
+    XHRUploader,
+    IFetchPayload,
+} from './uploaders';
+import { CACHE_HEADER } from './identity-utils';
+import { parseNumber } from './utils';
+import {
+    IAliasCallback,
+    IAliasRequest,
+    IdentityAPIMethod,
+    IIdentity,
+    IIdentityAPIRequestData,
+} from './identity.interfaces';
+import {
+    Callback,
+    IdentityApiData,
+    MPID,
+    UserIdentities,
+} from '@mparticle/web-sdk';
+import {
+    IdentityCallback,
+    IdentityResultBody,
+    IIdentityResponse,
+} from './identity-user-interfaces';
+import { MParticleWebSDK } from './sdkRuntimeModels';
+
+const { HTTPCodes, Messages, IdentityMethods } = Constants;
+
+const { Modify } = IdentityMethods;
+
+export interface IIdentityApiClient {
+    sendAliasRequest: (
+        aliasRequest: IAliasRequest,
+        aliasCallback: IAliasCallback
+    ) => Promise<void>;
+    sendIdentityRequest: (
+        identityApiRequest: IIdentityAPIRequestData,
+        method: IdentityAPIMethod,
+        callback: IdentityCallback,
+        originalIdentityApiData: IdentityApiData,
+        parseIdentityResponse: IIdentity['parseIdentityResponse'],
+        mpid: MPID,
+        knownIdentities: UserIdentities
+    ) => Promise<void>;
+    getUploadUrl: (method: IdentityAPIMethod, mpid: MPID) => string;
+    getIdentityResponseFromFetch: (
+        response: Response,
+        responseBody: IdentityResultBody
+    ) => IIdentityResponse;
+    getIdentityResponseFromXHR: (response: XMLHttpRequest) => IIdentityResponse;
+}
+
+export interface IAliasResponseBody {
+    message?: string;
+}
+
+interface IdentityApiRequestPayload extends IFetchPayload {
+    headers: {
+        Accept: string;
+        'Content-Type': string;
+        'x-mp-key': string;
+    };
+}
+
+export default function IdentityAPIClient(
+    this: IIdentityApiClient,
+    mpInstance: MParticleWebSDK
+) {
+    this.sendAliasRequest = async function(
+        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: AsyncUploader = window.fetch
+            ? new FetchUploader(uploadUrl)
+            : new XHRUploader(uploadUrl);
+
+        // https://go.mparticle.com/work/SQDSDKS-6568
+        const uploadPayload: IFetchPayload = {
+            method: 'post',
+            headers: {
+                Accept: 'text/plain;charset=UTF-8',
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(aliasRequest),
+        };
+
+        try {
+            const response: 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;
+
+                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
+            );
+        }
+    };
+
+    this.sendIdentityRequest = async function(
+        identityApiRequest: IIdentityAPIRequestData,
+        method: IdentityAPIMethod,
+        callback: IdentityCallback,
+        originalIdentityApiData: IdentityApiData,
+        parseIdentityResponse: IIdentity['parseIdentityResponse'],
+        mpid: MPID,
+        knownIdentities: UserIdentities
+    ) {
+        const { verbose, error } = mpInstance.Logger;
+        const { invokeCallback } = mpInstance._Helpers;
+
+        verbose(Messages.InformationMessages.SendIdentityBegin);
+        if (!identityApiRequest) {
+            error(Messages.ErrorMessages.APIRequestEmpty);
+            return;
+        }
+        verbose(Messages.InformationMessages.SendIdentityHttp);
+
+        if (mpInstance._Store.identityCallInFlight) {
+            invokeCallback(
+                callback,
+                HTTPCodes.activeIdentityRequest,
+                'There is currently an Identity request processing. Please wait for this to return before requesting again'
+            );
+            return;
+        }
+
+        const previousMPID = mpid || null;
+        const uploadUrl = this.getUploadUrl(method, mpid);
+
+        const uploader: AsyncUploader = window.fetch
+            ? new FetchUploader(uploadUrl)
+            : new XHRUploader(uploadUrl);
+
+        // https://go.mparticle.com/work/SQDSDKS-6568
+        const fetchPayload: IdentityApiRequestPayload = {
+            method: 'post',
+            headers: {
+                Accept: 'text/plain;charset=UTF-8',
+                'Content-Type': 'application/json',
+                'x-mp-key': mpInstance._Store.devToken,
+            },
+            body: JSON.stringify(identityApiRequest),
+        };
+
+        try {
+            mpInstance._Store.identityCallInFlight = true;
+            const response: Response = await uploader.upload(fetchPayload);
+
+            let identityResponse: IIdentityResponse;
+
+            if (response.json) {
+                // https://go.mparticle.com/work/SQDSDKS-6568
+                // FetchUploader returns the response as a JSON object that we have to await
+                const responseBody: IdentityResultBody = await response.json();
+
+                identityResponse = this.getIdentityResponseFromFetch(
+                    response,
+                    responseBody
+                );
+            } else {
+                identityResponse = this.getIdentityResponseFromXHR(
+                    (response as unknown) as XMLHttpRequest
+                );
+            }
+
+            verbose(
+                'Received Identity Response from server: ' +
+                    JSON.stringify(identityResponse.responseText)
+            );
+
+            parseIdentityResponse(
+                identityResponse,
+                previousMPID,
+                callback,
+                originalIdentityApiData,
+                method,
+                knownIdentities,
+                false
+            );
+        } catch (err) {
+            const errorMessage = (err as Error).message || err.toString();
+
+            mpInstance._Store.identityCallInFlight = false;
+            invokeCallback(
+                callback,
+                HTTPCodes.noHttpCoverage,
+                errorMessage,
+            );
+            error('Error sending identity request to servers' + ' - ' + err);
+        }
+    };
+
+    this.getUploadUrl = (method: IdentityAPIMethod, mpid: MPID) => {
+        const uploadServiceUrl: string = mpInstance._Helpers.createServiceUrl(
+            mpInstance._Store.SDKConfig.identityUrl
+        );
+
+        const uploadUrl: string =
+            method === Modify
+                ? uploadServiceUrl + mpid + '/' + method
+                : uploadServiceUrl + method;
+
+        return uploadUrl;
+    };
+
+    this.getIdentityResponseFromFetch = (
+        response: Response,
+        responseBody: IdentityResultBody
+    ): IIdentityResponse => ({
+        status: response.status,
+        responseText: responseBody,
+        cacheMaxAge: parseInt(response.headers.get(CACHE_HEADER)) || 0,
+        expireTimestamp: 0,
+    });
+
+    this.getIdentityResponseFromXHR = (
+        response: XMLHttpRequest
+    ): IIdentityResponse => ({
+        status: response.status,
+        responseText: response.responseText
+            ? JSON.parse(response.responseText)
+            : {},
+        cacheMaxAge: parseNumber(
+            response.getResponseHeader(CACHE_HEADER) || ''
+        ),
+        expireTimestamp: 0,
+    });
+}

package/src/sdkRuntimeModels.ts

@@ -3,7 +3,6 @@ import { DataPlanVersion } from '@mparticle/data-planning-models';
 import {
     MPConfiguration,
     MPID,
-    Callback,
     IdentityApiData,
 } from '@mparticle/web-sdk';
 import { IStore } from './store';
@@ -287,8 +286,8 @@ export interface SDKHelpersApi {
     ): boolean;
     isObject?(item: any);
     invokeCallback?(
-        callback: Callback,
-        code: string,
+        callback: IdentityCallback,
+        code: number,
         body: string,
         mParticleUser?: IMParticleUser,
         previousMpid?: MPID

package/src/uploaders.ts

@@ -1,6 +1,6 @@
 type HTTPMethod = 'get' | 'post';
 
-export interface fetchPayload {
+export interface IFetchPayload {
     method: string;
     headers: {
         Accept: string;
@@ -12,7 +12,7 @@ export interface fetchPayload {
 export abstract class AsyncUploader {
     url: string;
     public abstract upload(
-        fetchPayload: fetchPayload,
+        fetchPayload: IFetchPayload,
         url?: string
     ): Promise<Response>;
 
@@ -23,7 +23,7 @@ export abstract class AsyncUploader {
 
 export class FetchUploader extends AsyncUploader {
     public async upload(
-        fetchPayload: fetchPayload,
+        fetchPayload: IFetchPayload,
         _url?: string
     ): Promise<Response> {
         const url = _url || this.url;
@@ -32,7 +32,7 @@ export class FetchUploader extends AsyncUploader {
 }
 
 export class XHRUploader extends AsyncUploader {
-    public async upload(fetchPayload: fetchPayload): Promise<Response> {
+    public async upload(fetchPayload: IFetchPayload): Promise<Response> {
         const response: Response = await this.makeRequest(
             this.url,
             fetchPayload.body,

package/src/aliasRequestApiClient.ts

@@ -1,90 +0,0 @@
-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";
-import { IIdentityApiClientSendAliasRequest } from "./identityApiClient.interfaces";
-
-
-const { HTTPCodes, Messages } = Constants;
-
-interface IAliasResponseBody {
-    message?: string
-}
-
-export const sendAliasRequest: IIdentityApiClientSendAliasRequest = async function  (mpInstance: MParticleWebSDK, aliasRequest: IAliasRequest, aliasCallback: IAliasCallback): Promise<void> {
-        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;
-
-                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/identityApiClient.interfaces.ts

@@ -1,44 +0,0 @@
-import { IdentityApiData, MPID, UserIdentities } from '@mparticle/web-sdk';
-import {
-    IdentityCallback,
-    IIdentityResponse,
-} from './identity-user-interfaces';
-import {
-    IAliasRequest,
-    IAliasCallback,
-    IIdentityRequest,
-    IdentityAPIMethod,
-    IIdentity,
-} from './identity.interfaces';
-import { MParticleWebSDK } from './sdkRuntimeModels';
-
-export interface IIdentityApiClient {
-    sendAliasRequest: (
-        aliasRequest: IAliasRequest,
-        aliasCallback: IAliasCallback
-    ) => Promise<void>;
-    sendIdentityRequest: (
-        identityApiRequest: IIdentityRequest,
-        method: IdentityAPIMethod,
-        callback: IdentityCallback,
-        originalIdentityApiData: IdentityApiData,
-        parseIdentityResponse: IIdentity['parseIdentityResponse'],
-        mpid: MPID,
-        knownIdentities: UserIdentities
-    ) => Promise<void>;
-    getUploadUrl: (method: IdentityAPIMethod, mpid: MPID) => string;
-    getIdentityResponseFromFetch: (
-        response: Response,
-        responseBody: string
-    ) => IIdentityResponse;
-    getIdentityResponseFromXHR: (response: Response) => IIdentityResponse;
-}
-
-// https://go.mparticle.com/work/SQDSDKS-6568
-// https://go.mparticle.com/work/SQDSDKS-6679
-// Combine with `sendIdentityRequest` above once module is fully migrated
-export type IIdentityApiClientSendAliasRequest = (
-    mpInstance: MParticleWebSDK,
-    aliasRequest: IAliasRequest,
-    aliasCallback: IAliasCallback
-) => Promise<void>;

package/src/identityApiClient.js

@@ -1,131 +0,0 @@
-import Constants from './constants';
-import { sendAliasRequest } from './aliasRequestApiClient';
-import { FetchUploader, XHRUploader } from './uploaders';
-import { CACHE_HEADER } from './identity-utils';
-import { parseNumber } from './utils';
-
-var HTTPCodes = Constants.HTTPCodes,
-    Messages = Constants.Messages;
-
-const { Modify } = Constants.IdentityMethods;
-
-export default function IdentityAPIClient(mpInstance) {
-    this.sendAliasRequest = async function(aliasRequest, callback) {
-        await sendAliasRequest(mpInstance, aliasRequest, callback);
-    };
-
-    this.sendIdentityRequest = async function(
-        identityApiRequest,
-        method,
-        callback,
-        originalIdentityApiData,
-        parseIdentityResponse,
-        mpid,
-        knownIdentities
-    ) {
-        const { verbose, error } = mpInstance.Logger;
-        const { invokeCallback } = mpInstance._Helpers;
-
-        verbose(Messages.InformationMessages.SendIdentityBegin);
-        if (!identityApiRequest) {
-            error(Messages.ErrorMessages.APIRequestEmpty);
-            return;
-        }
-        verbose(Messages.InformationMessages.SendIdentityHttp);
-
-        if (mpInstance._Store.identityCallInFlight) {
-            invokeCallback(
-                callback,
-                HTTPCodes.activeIdentityRequest,
-                'There is currently an Identity request processing. Please wait for this to return before requesting again'
-            );
-            return;
-        }
-
-        const previousMPID = mpid || null;
-        const uploadUrl = this.getUploadUrl(method, mpid);
-
-        const uploader = window.fetch
-            ? new FetchUploader(uploadUrl)
-            : new XHRUploader(uploadUrl);
-
-        const fetchPayload = {
-            method: 'post',
-            headers: {
-                Accept: 'text/plain;charset=UTF-8',
-                'Content-Type': 'application/json',
-                'x-mp-key': mpInstance._Store.devToken,
-            },
-            body: JSON.stringify(identityApiRequest),
-        };
-
-        try {
-            mpInstance._Store.identityCallInFlight = true;
-            const response = await uploader.upload(fetchPayload);
-
-            let identityResponse;
-
-            if (response.json) {
-                // https://go.mparticle.com/work/SQDSDKS-6568
-                // FetchUploader returns the response as a JSON object that we have to await
-                const responseBody = await response.json();
-                identityResponse = this.getIdentityResponseFromFetch(
-                    response,
-                    responseBody
-                );
-            } else {
-                identityResponse = this.getIdentityResponseFromXHR(response);
-            }
-
-            verbose(
-                'Received Identity Response from server: ' +
-                    JSON.stringify(identityResponse.responseText)
-            );
-
-            parseIdentityResponse(
-                identityResponse,
-                previousMPID,
-                callback,
-                originalIdentityApiData,
-                method,
-                knownIdentities,
-                false
-            );
-        } catch (err) {
-            mpInstance._Store.identityCallInFlight = false;
-            invokeCallback(callback, HTTPCodes.noHttpCoverage, err);
-            error('Error sending identity request to servers' + ' - ' + err);
-        }
-    };
-
-    this.getUploadUrl = (method, mpid) => {
-        const uploadServiceUrl = mpInstance._Helpers.createServiceUrl(
-            mpInstance._Store.SDKConfig.identityUrl
-        );
-
-        const uploadUrl =
-            method === Modify
-                ? uploadServiceUrl + mpid + '/' + method
-                : uploadServiceUrl + method;
-
-        return uploadUrl;
-    };
-
-    this.getIdentityResponseFromFetch = (response, responseBody) => ({
-        status: response.status,
-        responseText: responseBody,
-        cacheMaxAge: parseInt(response.headers.get(CACHE_HEADER)) || 0,
-        expireTimestamp: 0,
-    });
-
-    this.getIdentityResponseFromXHR = response => ({
-        status: response.status,
-        responseText: response.responseText
-            ? JSON.parse(response.responseText)
-            : {},
-        cacheMaxAge: parseNumber(
-            response.getResponseHeader(CACHE_HEADER) || ''
-        ),
-        expireTimestamp: 0,
-    });
-}