@mparticle/web-sdk 2.32.1 → 2.32.3

package/src/identityApiClient.ts

@@ -0,0 +1,351 @@
+import Constants, { HTTP_ACCEPTED, HTTP_BAD_REQUEST, HTTP_OK } from './constants';
+import {
+    AsyncUploader,
+    FetchUploader,
+    XHRUploader,
+    IFetchPayload,
+} from './uploaders';
+import { CACHE_HEADER } from './identity-utils';
+import { parseNumber, valueof } from './utils';
+import {
+    IAliasCallback,
+    IAliasRequest,
+    IdentityAPIMethod,
+    IIdentity,
+    IIdentityAPIRequestData,
+} from './identity.interfaces';
+import {
+    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;
+}
+
+// A successfull Alias request will return a 202 with no body
+export interface IAliasResponseBody {}
+
+interface IdentityApiRequestPayload extends IFetchPayload {
+    headers: {
+        Accept: string;
+        'Content-Type': string;
+        'x-mp-key': string;
+    };
+}
+
+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
+) {
+    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 aliasResponseBody: IAliasResponseBody;
+            let message: string;
+            let errorMessage: string;
+
+            switch (response.status) {
+                // A successfull Alias request will return without a body
+                case HTTP_ACCEPTED:
+                case HTTP_OK:
+                    // https://go.mparticle.com/work/SQDSDKS-6670
+                    message = 'Received Alias Response from server: ' + JSON.stringify(response.status);
+                    break;
+
+                // 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 errorMessage = (e as Error).message || e.toString();
+            error('Error sending alias request to mParticle servers. ' + errorMessage);
+            invokeAliasCallback(
+                aliasCallback,
+                HTTPCodes.noHttpCoverage,
+                errorMessage,
+            );
+        }
+    };
+
+    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),
+        };
+        mpInstance._Store.identityCallInFlight = true;
+
+        try {
+            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 (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);
+                }
+            }
+
+            mpInstance._Store.identityCallInFlight = false;
+
+            verbose(message);
+            parseIdentityResponse(
+                identityResponse,
+                previousMPID,
+                callback,
+                originalIdentityApiData,
+                method,
+                knownIdentities,
+                false
+            );
+        } catch (err) {
+            mpInstance._Store.identityCallInFlight = false;
+            
+            const errorMessage = (err as Error).message || err.toString();
+
+            error('Error sending identity request to servers' + ' - ' + errorMessage);
+            invokeCallback(
+                callback,
+                HTTPCodes.noHttpCoverage,
+                errorMessage,
+            );
+        }
+    };
+
+    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/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

@@ -3,12 +3,13 @@ import { DataPlanVersion } from '@mparticle/data-planning-models';
 import {
     MPConfiguration,
     MPID,
-    Callback,
     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';
@@ -29,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>;
@@ -100,6 +108,11 @@ export interface SDKPromotion {
     Position?: string;
 }
 
+export interface SDKImpression {
+    Name: string;
+    Product: SDKProduct;
+}
+
 export interface SDKProductImpression {
     ProductImpressionList?: string;
     ProductList?: SDKProduct[];
@@ -143,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;
@@ -165,6 +178,7 @@ export interface MParticleWebSDK {
     _Forwarders: any;
     _Helpers: SDKHelpersApi;
     _Events: IEvents;
+    _Ecommerce: IECommerce;
     config: SDKInitConfig;
     _ServerModel: IServerModel;
     _SessionManager: ISessionManager;
@@ -189,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;
@@ -197,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
@@ -285,10 +301,11 @@ export interface SDKHelpersApi {
         timeoutStart: number,
         now: number
     ): boolean;
+    isEventType?(type: valueof<typeof EventType>): boolean;
     isObject?(item: any);
     invokeCallback?(
-        callback: Callback,
-        code: string,
+        callback: IdentityCallback,
+        code: number,
         body: string,
         mParticleUser?: IMParticleUser,
         previousMpid?: MPID

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