@mparticle/web-sdk 2.32.2 → 2.32.3

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,
@@ -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,6 +63,23 @@ 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
@@ -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

@@ -222,10 +222,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/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/mp-instance.js

@@ -212,8 +212,8 @@ export default function mParticleInstance(instanceName) {
      */
     this.getEnvironment = function() {
         return self._Store.SDKConfig.isDevelopmentMode
-            ? Types.Environment.Development
-            : Types.Environment.Production;
+            ? Constants.Environment.Development
+            : Constants.Environment.Production;
     };
     /**
      * Returns the mParticle SDK version number
@@ -824,7 +824,7 @@ export default function mParticleInstance(instanceName) {
          * @for mParticle.eCommerce
          * @method logCheckout
          * @param {Number} step checkout step number
-         * @param {String} option
+         * @param {String} checkout option string
          * @param {Object} attrs
          * @param {Object} [customFlags] Custom flags for the event
          * @deprecated

package/src/sdkRuntimeModels.ts

@@ -4,10 +4,12 @@ import {
     MPConfiguration,
     MPID,
     IdentityApiData,
+    SDKEventOptions,
+    SDKEventAttrs,
 } 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';
@@ -28,10 +30,17 @@ import {
     IdentityCallback,
     ISDKUserAttributes,
 } from './identity-user-interfaces';
-import { IIdentityType } from './types.interfaces';
+import {
+    CommerceEventType,
+    EventType,
+    IdentityType,
+    PromotionActionType,
+} from './types';
 import IntegrationCapture from './integrationCapture';
 import { INativeSdkHelpers } from './nativeSdkHelpers.interfaces';
 import { ICookieSyncManager, IPixelConfiguration } from './cookieSyncManager';
+import { IEvents } from './events.interfaces';
+import { IECommerce, SDKECommerceAPI } from './ecommerce.interfaces';
 
 // TODO: Resolve this with version in @mparticle/web-sdk
 export type SDKEventCustomFlags = Dictionary<any>;
@@ -99,6 +108,11 @@ export interface SDKPromotion {
     Position?: string;
 }
 
+export interface SDKImpression {
+    Name: string;
+    Product: SDKProduct;
+}
+
 export interface SDKProductImpression {
     ProductImpressionList?: string;
     ProductList?: SDKProduct[];
@@ -142,18 +156,18 @@ export interface SDKProduct {
     Position?: number;
     CouponCode?: string;
     TotalAmount?: number;
-    Attributes?: { [key: string]: string };
-}
 
-// Temporary Interfaces for Events Module
-interface IEvents {
-    logEvent?(event: BaseEvent): void;
+    // https://go.mparticle.com/work/SQDSDKS-4801
+    Attributes?: Record<string, unknown> | null;
 }
 
 export interface MParticleWebSDK {
     addForwarder(mockForwarder: MPForwarder): void;
     _IntegrationCapture: IntegrationCapture;
-    IdentityType: IIdentityType;
+    IdentityType: valueof<typeof IdentityType>;
+    CommerceEventType: valueof<typeof CommerceEventType>;
+    EventType: valueof<typeof EventType>;
+    PromotionType: valueof<typeof PromotionActionType>;
     _Identity: IIdentity;
     Identity: SDKIdentityApi;
     Logger: SDKLoggerApi;
@@ -164,6 +178,7 @@ export interface MParticleWebSDK {
     _Forwarders: any;
     _Helpers: SDKHelpersApi;
     _Events: IEvents;
+    _Ecommerce: IECommerce;
     config: SDKInitConfig;
     _ServerModel: IServerModel;
     _SessionManager: ISessionManager;
@@ -188,7 +203,7 @@ export interface MParticleWebSDK {
     getDeviceId(): string;
     setDeviceId(deviceId: string): void;
     setSessionAttribute(key: string, value: string): void;
-    getInstance(): MParticleWebSDK; // TODO: Create a new type for MParticleWebSDKInstance
+    getInstance(instanceName?: string): MParticleWebSDK; // https://go.mparticle.com/work/SQDSDKS-4804
     ServerModel();
     upload();
     setLogLevel(logLevel: LogLevelType): void;
@@ -196,16 +211,18 @@ export interface MParticleWebSDK {
     startNewSession(): void;
     logEvent(
         eventName: string,
-        eventType?: number,
-        attrs?: { [key: string]: string },
-        customFlags?: SDKEventCustomFlags
+        eventType?: valueof<typeof EventType>,
+        attrs?: SDKEventAttrs,
+        customFlags?: SDKEventCustomFlags,
+        eventOptions?: SDKEventOptions
     ): void;
-    logBaseEvent(event: any): void;
-    eCommerce: any;
+    logBaseEvent(event: BaseEvent, eventOptions?: SDKEventOptions): void;
+    eCommerce: SDKECommerceAPI;
     logLevel: string;
     ProductActionType: SDKProductActionType;
     generateHash(value: string): string;
     isIOS?: boolean;
+    sessionManager: Pick<ISessionManager, 'getSession'>; // https://go.mparticle.com/work/SQDSDKS-6949
 }
 
 // Used in cases where server requires booleans as strings
@@ -284,6 +301,7 @@ export interface SDKHelpersApi {
         timeoutStart: number,
         now: number
     ): boolean;
+    isEventType?(type: valueof<typeof EventType>): boolean;
     isObject?(item: any);
     invokeCallback?(
         callback: IdentityCallback,

package/src/sdkToEventsApiConverter.ts

@@ -373,7 +373,7 @@ export function convertProducts(
             price: sdkProduct.Price,
             quantity: sdkProduct.Quantity,
             coupon_code: sdkProduct.CouponCode,
-            custom_attributes: sdkProduct.Attributes,
+            custom_attributes: sdkProduct.Attributes as Record<string, string>,
         };
         products.push(product);
     }

package/src/serverModel.ts

@@ -110,7 +110,7 @@ export interface IProductV2DTO {
     ps: number;
     cc: string | number;
     tpa: number;
-    attrs: Record<string, string> | null;
+    attrs: Record<string, unknown> | undefined;
 }
 
 export interface IPromotionV2DTO {

package/src/sideloadedKit.ts

@@ -6,22 +6,23 @@ import {
     IKitFilterSettings,
 } from './configAPIClient';
 import { UnregisteredKit } from './forwarders.interfaces';
-import { EventTypeEnum, IdentityType } from './types.interfaces';
+import { EventType, IdentityType } from './types';
+import { valueof } from './utils';
 
 export interface IMPSideloadedKit {
     kitInstance: UnregisteredKit;
     filterDictionary: IKitFilterSettings;
 
-    addEventTypeFilter(eventType: EventTypeEnum): void;
-    addEventNameFilter(eventType: EventTypeEnum, eventName: string): void;
+    addEventTypeFilter(eventType: valueof<typeof EventType>): void;
+    addEventNameFilter(eventType: valueof<typeof EventType>, eventName: string): void;
     addEventAttributeFilter(
-        eventType: EventTypeEnum,
+        eventType: valueof<typeof EventType>,
         eventName: string,
         customAttributeKey: string
     ): void;
     addScreenNameFilter(screenName: string): void;
     addScreenAttributeFilter(screenName: string, screenAttribute: string): void;
-    addUserIdentityFilter(userIdentity: IdentityType): void;
+    addUserIdentityFilter(userIdentity: typeof IdentityType): void;
     addUserAttributeFilter(userAttributeKey: string): void;
 }
 
@@ -57,13 +58,13 @@ export default class MPSideloadedKit implements IMPSideloadedKit{
         this.kitInstance = unregisteredKitInstance;
     }
 
-    public addEventTypeFilter(eventType: EventTypeEnum): void {
+    public addEventTypeFilter(eventType: valueof<typeof EventType>): void {
         const hashedEventType = KitFilterHelper.hashEventType(eventType);
         this.filterDictionary.eventTypeFilters.push(hashedEventType);
     }
 
     public addEventNameFilter(
-        eventType: EventTypeEnum,
+        eventType: valueof<typeof EventType>,
         eventName: string
     ): void {
         const hashedEventName = KitFilterHelper.hashEventName(
@@ -74,7 +75,7 @@ export default class MPSideloadedKit implements IMPSideloadedKit{
     }
 
     public addEventAttributeFilter(
-        eventType: EventTypeEnum,
+        eventType: valueof<typeof EventType>,
         eventName: string,
         customAttributeKey: string
     ): void {
@@ -89,7 +90,7 @@ export default class MPSideloadedKit implements IMPSideloadedKit{
     public addScreenNameFilter(screenName: string): void {
         const hashedScreenName = KitFilterHelper.hashEventName(
             screenName,
-            EventTypeEnum.Unknown
+            EventType.Unknown,
         );
         this.filterDictionary.screenNameFilters.push(hashedScreenName);
     }
@@ -99,7 +100,7 @@ export default class MPSideloadedKit implements IMPSideloadedKit{
         screenAttribute: string
     ): void {
         const hashedScreenAttribute = KitFilterHelper.hashEventAttributeKey(
-            EventTypeEnum.Unknown,
+            EventType.Unknown,
             screenName,
             screenAttribute
         );
@@ -108,7 +109,7 @@ export default class MPSideloadedKit implements IMPSideloadedKit{
         );
     }
 
-    public addUserIdentityFilter(userIdentity: IdentityType): void {
+    public addUserIdentityFilter(userIdentity: typeof IdentityType): void {
         const hashedIdentityType = KitFilterHelper.hashUserIdentity(
             userIdentity
         );