@mparticle/web-sdk 2.32.2 → 2.32.4

package/src/identity-user-interfaces.ts

@@ -1,21 +1,21 @@
 import { AllUserAttributes, MPID, Product, User } from '@mparticle/web-sdk';
 import { SDKIdentityTypeEnum } from './identity.interfaces';
-import { MessageType } from './types.interfaces';
-import { BaseEvent } from './sdkRuntimeModels';
+import { MessageType } from './types';
+import { BaseEvent, SDKProduct } from './sdkRuntimeModels';
 import Constants from './constants';
 const { HTTPCodes } = Constants;
 
 // Cart is Deprecated and private to mParticle user in @mparticle/web-sdk
 // but we need to expose it here for type safety in some of our tests
-interface Cart {
+interface ICart {
     /**
      * @deprecated Cart persistence in mParticle has been deprecated. Please use mParticle.eCommerce.logProductAction(mParticle.ProductActionType.AddToCart, [products])
      */
-    add: (product: Product, logEventBoolean?: boolean) => void;
+    add: (product: SDKProduct, logEventBoolean?: boolean) => void;
     /**
      * @deprecated Cart persistence in mParticle has been deprecated. Please use mParticle.eCommerce.logProductAction(mParticle.ProductActionType.RemoveFromCart, [products])
      */
-    remove: (product: Product, logEventBoolean?: boolean) => void;
+    remove: (product: SDKProduct, logEventBoolean?: boolean) => void;
     /**
      * @deprecated Cart persistence in mParticle has been deprecated.
      */
@@ -23,7 +23,7 @@ interface Cart {
     /**
      * @deprecated Cart Products have been deprecated
      */
-    getCartProducts: () => Product[];
+    getCartProducts: () => SDKProduct[];
 }
 
 // https://go.mparticle.com/work/SQDSDKS-5033
@@ -36,7 +36,7 @@ export interface IMParticleUser extends User {
     /*
      * @deprecated
      */
-    getCart(): Cart;
+    getCart(): ICart;
 }
 
 export interface ISDKUserIdentity {
@@ -58,7 +58,7 @@ export interface ISDKUserIdentityChangeData {
 }
 
 export interface IUserIdentityChangeEvent extends BaseEvent {
-    messageType: MessageType.UserIdentityChange;
+    messageType: typeof MessageType.UserIdentityChange;
     userIdentityChanges: ISDKUserIdentityChanges;
 }
 
@@ -75,7 +75,7 @@ export interface ISDKUserAttributeChangeData {
 }
 
 export interface IUserAttributeChangeEvent extends BaseEvent {
-    messageType: MessageType.UserAttributeChange;
+    messageType: typeof MessageType.UserAttributeChange;
     userAttributeChanges: ISDKUserAttributeChangeData;
 }
 
@@ -115,10 +115,10 @@ export interface IdentityModifyResultBody {
 }
 
 export interface mParticleUserCart {
-    add(product: Product, logEvent: boolean): void;
-    remove(product: Product, logEvent: boolean): void;
+    add(product: SDKProduct | SDKProduct[], logEvent: boolean): void;
+    remove(product: SDKProduct | SDKProduct[], logEvent: boolean): void;
     clear(): void;
-    getCartProducts(): Product[];
+    getCartProducts(): SDKProduct[];
 }
 
 // https://go.mparticle.com/work/SQDSDKS-5196

package/src/identity.js

@@ -1,5 +1,5 @@
 import Constants, { HTTP_OK } from './constants';
-import Types from './types';
+import Types, { IdentityType } from './types';
 import {
     cacheOrClearIdCache,
     createKnownIdentities,
@@ -17,7 +17,6 @@ import {
     isObject,
 } from './utils';
 import { hasMPIDAndUserLoginChanged, hasMPIDChanged } from './user-utils';
-import { getNewIdentitiesByName } from './type-utils';
 import { processReadyQueue } from './pre-init-utils';
 
 export default function Identity(mpInstance) {
@@ -1619,7 +1618,7 @@ export default function Identity(mpInstance) {
                     self.setForwarderCallbacks(newUser, method);
                 }
 
-                const newIdentitiesByName = getNewIdentitiesByName(
+                const newIdentitiesByName = IdentityType.getNewIdentitiesByName(
                     newIdentitiesByType
                 );
 

package/src/identityApiClient.ts

@@ -1,4 +1,4 @@
-import Constants, { HTTP_ACCEPTED, HTTP_OK } from './constants';
+import Constants, { HTTP_ACCEPTED, HTTP_BAD_REQUEST, HTTP_OK } from './constants';
 import {
     AsyncUploader,
     FetchUploader,
@@ -6,7 +6,7 @@ import {
     IFetchPayload,
 } from './uploaders';
 import { CACHE_HEADER } from './identity-utils';
-import { parseNumber } from './utils';
+import { parseNumber, valueof } from './utils';
 import {
     IAliasCallback,
     IAliasRequest,
@@ -15,7 +15,6 @@ import {
     IIdentityAPIRequestData,
 } from './identity.interfaces';
 import {
-    Callback,
     IdentityApiData,
     MPID,
     UserIdentities,
@@ -25,7 +24,7 @@ import {
     IdentityResultBody,
     IIdentityResponse,
 } from './identity-user-interfaces';
-import { MParticleWebSDK } from './sdkRuntimeModels';
+import { IMParticleWebSDKInstance } from './mp-instance';
 
 const { HTTPCodes, Messages, IdentityMethods } = Constants;
 
@@ -53,9 +52,8 @@ export interface IIdentityApiClient {
     getIdentityResponseFromXHR: (response: XMLHttpRequest) => IIdentityResponse;
 }
 
-export interface IAliasResponseBody {
-    message?: string;
-}
+// A successfull Alias request will return a 202 with no body
+export interface IAliasResponseBody {}
 
 interface IdentityApiRequestPayload extends IFetchPayload {
     headers: {
@@ -65,9 +63,26 @@ interface IdentityApiRequestPayload extends IFetchPayload {
     };
 }
 
+type HTTP_STATUS_CODES = typeof HTTP_OK | typeof HTTP_ACCEPTED;
+
+interface IdentityApiError {
+    code: string;
+    message: string;
+}
+
+interface IdentityApiErrorResponse {
+    Errors: IdentityApiError[],
+    ErrorCode: string,
+    StatusCode: valueof<HTTP_STATUS_CODES>;
+    RequestId: string;
+}
+
+// All Identity Api Responses have the same structure, except for Alias
+interface IAliasErrorResponse extends IdentityApiError {}
+
 export default function IdentityAPIClient(
     this: IIdentityApiClient,
-    mpInstance: MParticleWebSDK
+    mpInstance: IMParticleWebSDKInstance
 ) {
     this.sendAliasRequest = async function(
         aliasRequest: IAliasRequest,
@@ -99,55 +114,72 @@ export default function IdentityAPIClient(
         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 message: string;
             let errorMessage: string;
 
             switch (response.status) {
-                case HTTP_OK:
+                // A successfull Alias request will return without a body
                 case HTTP_ACCEPTED:
+                case HTTP_OK:
                     // https://go.mparticle.com/work/SQDSDKS-6670
-                    message =
-                        'Successfully sent forwarding stats to mParticle Servers';
+                    message = 'Received Alias Response from server: ' + JSON.stringify(response.status);
                     break;
-                default:
-                    // 400 has an error message, but 403 doesn't
-                    if (aliasResponseBody?.message) {
-                        errorMessage = aliasResponseBody.message;
+
+                // Our Alias Request API will 400 if there is an issue with the request body (ie timestamps are too far 
+                // in the past or MPIDs don't exist).
+                // A 400 will return an error in the response body and will go through the happy path to report the error
+                case HTTP_BAD_REQUEST:
+                    // 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.
+                    if (response.json) {
+                        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)
+                            : '';
                     }
+
+                    const errorResponse: IAliasErrorResponse = aliasResponseBody as unknown as IAliasErrorResponse;
+
+                    if (errorResponse?.message) {
+                        errorMessage = errorResponse.message;
+                    }
+
                     message =
                         'Issue with sending Alias Request to mParticle Servers, received HTTP Code of ' +
                         response.status;
+                    
+                    if (errorResponse?.code) {
+                        message += ' - ' + errorResponse.code;
+                    }
+
+                    break;
+                    
+                // Any unhandled errors, such as 500 or 429, will be caught here as well
+                default: {
+                    throw new Error('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);
+            const errorMessage = (e as Error).message || e.toString();
+            error('Error sending alias request to mParticle servers. ' + errorMessage);
             invokeAliasCallback(
                 aliasCallback,
                 HTTPCodes.noHttpCoverage,
-                err.message
+                errorMessage,
             );
         }
     };
@@ -197,33 +229,67 @@ export default function IdentityAPIClient(
             },
             body: JSON.stringify(identityApiRequest),
         };
+        mpInstance._Store.identityCallInFlight = true;
 
         try {
-            mpInstance._Store.identityCallInFlight = true;
             const response: Response = await uploader.upload(fetchPayload);
 
             let identityResponse: IIdentityResponse;
+            let message: string;
+
+            switch (response.status) {
+                case HTTP_ACCEPTED:
+                case HTTP_OK:
+
+                // Our Identity API will return a 400 error if there is an issue with the requeest body
+                // such as if the body is empty or one of the attributes is missing or malformed
+                // A 400 will return an error in the response body and will go through the happy path to report the error
+                case HTTP_BAD_REQUEST:
+                        
+                    // FetchUploader returns the response as a JSON object that we have to await
+                    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
+                        );
+                    }
 
-            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
-                );
+                    if (identityResponse.status === HTTP_BAD_REQUEST) {
+                        const errorResponse: IdentityApiErrorResponse = identityResponse.responseText as unknown as IdentityApiErrorResponse;
+                        message = 'Issue with sending Identity Request to mParticle Servers, received HTTP Code of ' + identityResponse.status;
+
+                        if (errorResponse?.Errors) {
+                            const errorMessage = errorResponse.Errors.map((error) => error.message).join(', ');
+                            message += ' - ' + errorMessage;
+                        }
+
+                    } else {
+                        message = 'Received Identity Response from server: ';
+                        message += JSON.stringify(identityResponse.responseText);
+                    }
+
+                    break;
+                    
+                // Our Identity API will return:
+                // - 401 if the `x-mp-key` is incorrect or missing
+                // - 403 if the there is a permission or account issue related to the `x-mp-key`
+                // 401 and 403 have no response bodies and should be rejected outright
+                default: {
+                    throw new Error('Received HTTP Code of ' + response.status);
+                }
             }
 
-            verbose(
-                'Received Identity Response from server: ' +
-                    JSON.stringify(identityResponse.responseText)
-            );
+            mpInstance._Store.identityCallInFlight = false;
 
+            verbose(message);
             parseIdentityResponse(
                 identityResponse,
                 previousMPID,
@@ -234,15 +300,16 @@ export default function IdentityAPIClient(
                 false
             );
         } catch (err) {
+            mpInstance._Store.identityCallInFlight = false;
+            
             const errorMessage = (err as Error).message || err.toString();
 
-            mpInstance._Store.identityCallInFlight = false;
+            error('Error sending identity request to servers' + ' - ' + errorMessage);
             invokeCallback(
                 callback,
                 HTTPCodes.noHttpCoverage,
                 errorMessage,
             );
-            error('Error sending identity request to servers' + ' - ' + err);
         }
     };
 

package/src/integrationCapture.ts

@@ -190,10 +190,13 @@ export default class IntegrationCapture {
             return mappedClickIds;
         }
 
-        for (const [key, value] of Object.entries(clickIds)) {
-            const mappedKey = mappingList[key]?.mappedKey;
-            if (!isEmpty(mappedKey)) {
-                mappedClickIds[mappedKey] = value;
+        for (const key in clickIds) {
+            if (clickIds.hasOwnProperty(key)) {
+                const value = clickIds[key];
+                const mappedKey = mappingList[key]?.mappedKey;
+                if (!isEmpty(mappedKey)) {
+                    mappedClickIds[mappedKey] = value;
+                }
             }
         }
 
@@ -207,12 +210,11 @@ export default class IntegrationCapture {
     ): Dictionary<string> {
         const processedClickIds: Dictionary<string> = {};
 
-        for (const [key, value] of Object.entries(clickIds)) {
-            const processor = integrationMapping[key]?.processor;
-            if (processor) {
-                processedClickIds[key] = processor(value, url, timestamp);
-            } else {
-                processedClickIds[key] = value;
+        for (const key in clickIds) {
+            if (clickIds.hasOwnProperty(key)) {
+                const value = clickIds[key];
+                const processor = integrationMapping[key]?.processor;
+                processedClickIds[key] = processor ? processor(value, url, timestamp) : value;
             }
         }
 
@@ -222,10 +224,12 @@ export default class IntegrationCapture {
     private filterMappings(
         outputType: valueof<typeof IntegrationOutputs>
     ): IntegrationIdMapping {
-        return Object.fromEntries(
-            Object.entries(integrationMapping).filter(
-                ([, value]) => value.output === outputType
-            )
-        );
+        const filteredMappings: IntegrationIdMapping = {};
+        for (const key in integrationMapping) {
+            if (integrationMapping[key].output === outputType) {
+                filteredMappings[key] = integrationMapping[key];
+            }
+        }
+        return filteredMappings;
     }
 }

package/src/kitBlocking.ts

@@ -3,6 +3,7 @@ import { SDKEvent, MParticleWebSDK, KitBlockerDataPlan, SDKProduct } from './sdk
 import { BaseEvent, EventTypeEnum, CommerceEvent, ScreenViewEvent, CustomEvent } from '@mparticle/event-models';
 import Types from './types'
 import { DataPlanPoint } from '@mparticle/data-planning-models';
+import { IMParticleWebSDKInstance } from './mp-instance';
 
 /*  
     TODO: Including this as a workaround because attempting to import it from
@@ -41,9 +42,9 @@ export default class KitBlocker {
     blockUserAttributes = false;
     blockUserIdentities = false;
     kitBlockingEnabled = false;
-    mpInstance: MParticleWebSDK;
+    mpInstance: IMParticleWebSDKInstance;
 
-    constructor(dataPlan: KitBlockerDataPlan, mpInstance: MParticleWebSDK) {
+    constructor(dataPlan: KitBlockerDataPlan, mpInstance: IMParticleWebSDKInstance) {
         // if data plan is not requested, the data plan is {document: null}
         if (dataPlan && !dataPlan.document) {
             this.kitBlockingEnabled = false;

package/src/kitFilterHelper.ts

@@ -1,18 +1,17 @@
-import { generateHash } from "./utils";
+import { generateHash, valueof } from "./utils";
 // TODO: https://mparticle-eng.atlassian.net/browse/SQDSDKS-5381
-import { EventTypeEnum, IdentityType } from "./types.interfaces";
-import Constants from './constants';
+import { EventType, IdentityType } from "./types";
 
 export default class KitFilterHelper {
-    static hashEventType(eventType: EventTypeEnum): number {
+    static hashEventType(eventType: valueof<typeof EventType>): number {
         return generateHash(eventType as unknown as string);
     };
 
-    static hashEventName(eventName: string, eventType: EventTypeEnum): number {
+    static hashEventName(eventName: string, eventType: valueof<typeof EventType>): number {
         return generateHash(eventType + eventName);
     };
 
-    static hashEventAttributeKey(eventType: EventTypeEnum, eventName: string, customAttributeName: string): number {
+    static hashEventAttributeKey(eventType: valueof<typeof EventType>, eventName: string, customAttributeName: string): number {
         return generateHash(eventType + eventName + customAttributeName);
     }
     
@@ -22,7 +21,7 @@ export default class KitFilterHelper {
 
     // User Identities are not actually hashed, this method is named this way to
     // be consistent with the filter class. UserIdentityType is also a number
-    static hashUserIdentity(userIdentity: IdentityType): IdentityType {
+    static hashUserIdentity(userIdentity: typeof IdentityType): typeof IdentityType {
         return userIdentity;
     }
 

package/src/mockBatchCreator.ts

@@ -1,11 +1,10 @@
 // This file is used ONLY for the mParticle ESLint plugin. It should NOT be used otherwise!
 
 import ServerModel from './serverModel';
-import { SDKEvent, BaseEvent, MParticleWebSDK } from './sdkRuntimeModels';
+import { SDKEvent, BaseEvent } from './sdkRuntimeModels';
 import { convertEvents } from './sdkToEventsApiConverter';
-import * as EventsApi from '@mparticle/event-models';
 import { Batch } from '@mparticle/event-models';
-import { IMPSideloadedKit } from './sideloadedKit';
+import { IMParticleWebSDKInstance } from './mp-instance';
 
 const mockFunction = function() {
     return null;
@@ -15,7 +14,7 @@ export default class _BatchValidator {
         return ({
             // Certain Helper, Store, and Identity properties need to be mocked to be used in the `returnBatch` method
             _Helpers: {
-                sanitizeAttributes: window.mParticle.getInstance()._Helpers
+                sanitizeAttributes: (window.mParticle.getInstance() as unknown as IMParticleWebSDKInstance)._Helpers
                     .sanitizeAttributes,
                 generateHash: function() {
                     return 'mockHash';
@@ -23,7 +22,7 @@ export default class _BatchValidator {
                 generateUniqueId: function() {
                     return 'mockId';
                 },
-                extend: window.mParticle.getInstance()._Helpers.extend,
+                extend: (window.mParticle.getInstance() as unknown as IMParticleWebSDKInstance)._Helpers.extend,
                 createServiceUrl: mockFunction,
                 parseNumber: mockFunction,
                 isObject: mockFunction,
@@ -118,7 +117,7 @@ export default class _BatchValidator {
             logLevel: 'none',
             setPosition: mockFunction,
             upload: mockFunction,
-        } as unknown) as MParticleWebSDK;
+        } as unknown) as IMParticleWebSDKInstance;
     }
 
     private createSDKEventFunction(event): SDKEvent {