@mparticle/web-sdk 2.32.0 → 2.32.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mparticle/web-sdk",
-    "version": "2.32.0",
+    "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,10 +9,11 @@ import {
 import { Dictionary } from './utils';
 import {
     AsyncUploader,
-    fetchPayload,
+    IFetchPayload,
     FetchUploader,
     XHRUploader,
 } from './uploaders';
+import { IPixelConfiguration } from './cookieSyncManager';
 
 export interface IKitConfigs extends IKitFilterSettings {
     name: string;
@@ -65,17 +66,6 @@ export interface IConsentRuleValue {
     hasConsented: boolean;
 }
 
-export interface IPixelConfig {
-    name: string;
-    moduleId: number;
-    esId: number;
-    isDebug: boolean;
-    isProduction: boolean;
-    settings: Dictionary;
-    frequencyCap: number;
-    pixelUrl: string;
-    redirectUrl: string;
-}
 
 export interface IConfigResponse {
     appName: string;
@@ -85,7 +75,7 @@ export interface IConfigResponse {
     secureServiceUrl: string;
     minWebviewBridgeVersion: number;
     workspaceToken: string;
-    pixelConfigs: IPixelConfig[];
+    pixelConfigs: IPixelConfiguration[];
     flags: SDKEventCustomFlags;
 }
 
@@ -135,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/consent.ts

@@ -38,6 +38,10 @@ export interface SDKConsentApi {
     createConsentState: (consentState?: ConsentState) => ConsentState;
     ConsentSerialization: IConsentSerialization;
     createPrivacyConsent: ICreatePrivacyConsentFunction;
+    isEnabledForUserConsent: (
+        consentRules: IConsentRules,
+        user: IMParticleUser
+    ) => boolean;
 }
 
 export interface IConsentSerialization {

package/src/cookieSyncManager.ts

@@ -0,0 +1,162 @@
+import {
+    Dictionary,
+    isEmpty,
+    createCookieSyncUrl,
+} from './utils';
+import Constants from './constants';
+import { MParticleWebSDK } from './sdkRuntimeModels';
+import { MPID } from '@mparticle/web-sdk';
+import { IConsentRules } from './consent';
+
+const { Messages } = Constants;
+const { InformationMessages } = Messages;
+
+export const DAYS_IN_MILLISECONDS = 1000 * 60 * 60 * 24;
+
+export type CookieSyncDates = Dictionary<number>; 
+
+export interface IPixelConfiguration {
+    name?: string;
+    moduleId: number;
+    esId?: number;
+    isDebug?: boolean;
+    isProduction?: boolean;
+    settings: Dictionary<string>;
+    frequencyCap: number;
+    pixelUrl: string;
+    redirectUrl: string;
+    filteringConsentRuleValues?: IConsentRules;
+}
+export interface ICookieSyncManager {
+    attemptCookieSync: (
+        mpid: MPID,
+        mpidIsNotInCookies?: boolean
+    ) => void;
+    performCookieSync: (
+        url: string,
+        moduleId: string,
+        mpid: MPID,
+        cookieSyncDates: CookieSyncDates,
+    ) => void;
+    combineUrlWithRedirect: (
+        mpid: MPID,
+        pixelUrl: string,
+        redirectUrl: string
+    ) => string;
+}
+
+export default function CookieSyncManager(
+    this: ICookieSyncManager,
+    mpInstance: MParticleWebSDK
+) {
+    const self = this;
+
+    // Public
+    this.attemptCookieSync = (
+        mpid: MPID,
+        mpidIsNotInCookies?: boolean
+    ): void => {
+        const { pixelConfigurations, webviewBridgeEnabled } = mpInstance._Store;
+
+        if (!mpid || webviewBridgeEnabled) {
+            return;
+        }
+
+        const persistence = mpInstance._Persistence.getPersistence();
+
+        if (isEmpty(persistence)) {
+            return;
+        }
+
+        pixelConfigurations.forEach((pixelSettings: IPixelConfiguration) => {
+            // set requiresConsent to false to start each additional pixel configuration
+            // set to true only if filteringConsenRuleValues.values.length exists
+            let requiresConsent = false;
+            // Filtering rules as defined in UI
+            const {
+                filteringConsentRuleValues,
+                pixelUrl,
+                redirectUrl,
+                moduleId,
+                // Tells you how often we should do a cookie sync (in days)
+                frequencyCap,
+            } = pixelSettings;
+            const { values } = filteringConsentRuleValues || {};
+
+            if (isEmpty(pixelUrl)) {
+                return;
+            }
+
+            if (!isEmpty(values)) {
+                requiresConsent = true;
+            }
+
+            // If MPID is new to cookies, we should not try to perform the cookie sync
+            // because a cookie sync can only occur once a user either consents or doesn't.
+            // we should not check if it's enabled if the user has a blank consent
+            if (requiresConsent && mpidIsNotInCookies) {
+                return;
+            }
+
+            const { isEnabledForUserConsent } = mpInstance._Consent;
+
+            if (!isEnabledForUserConsent(filteringConsentRuleValues, mpInstance.Identity.getCurrentUser())) {
+                return;
+            }
+
+            const cookieSyncDates: CookieSyncDates = persistence[mpid]?.csd ?? {};
+            const lastSyncDateForModule: number = cookieSyncDates[moduleId] || null;
+
+            if (!isLastSyncDateExpired(frequencyCap, lastSyncDateForModule)) {
+                return;
+            }
+
+            // Url for cookie sync pixel
+            const fullUrl = createCookieSyncUrl(mpid, pixelUrl, redirectUrl)
+
+            self.performCookieSync(
+                fullUrl,
+                moduleId.toString(),
+                mpid,
+                cookieSyncDates
+            );
+        });
+    };
+
+    // Private
+    this.performCookieSync = (
+        url: string,
+        moduleId: string,
+        mpid: MPID,
+        cookieSyncDates: CookieSyncDates,
+    ): void => {
+        const img = document.createElement('img');
+
+        mpInstance.Logger.verbose(InformationMessages.CookieSync);
+        img.onload = function() {
+            cookieSyncDates[moduleId] = new Date().getTime();
+
+            mpInstance._Persistence.saveUserCookieSyncDatesToPersistence(
+                mpid,
+                cookieSyncDates
+            );
+        };
+        img.src = url;
+    };
+}
+
+export const isLastSyncDateExpired = (
+    frequencyCap: number,
+    lastSyncDate?: number
+): boolean => {
+    // If there is no lastSyncDate, then there is no previous cookie sync, so we should sync the cookie
+    if (!lastSyncDate) {
+        return true;
+    }
+
+    // Otherwise, compare the last sync date to determine if it should do a cookie sync again
+    return (
+        new Date().getTime() >
+        new Date(lastSyncDate).getTime() + frequencyCap * DAYS_IN_MILLISECONDS
+    );
+};

package/src/identity.js

@@ -1231,10 +1231,7 @@ export default function Identity(mpInstance) {
                     this.getUserIdentities().userIdentities,
                     mpInstance._APIClient.prepareForwardingStats
                 );
-                mpInstance._CookieSyncManager.attemptCookieSync(
-                    null,
-                    this.getMPID()
-                );
+                mpInstance._CookieSyncManager.attemptCookieSync(this.getMPID());
             },
             isLoggedIn: function() {
                 return isLoggedIn;
@@ -1563,7 +1560,6 @@ export default function Identity(mpInstance) {
                     );
 
                     mpInstance._CookieSyncManager.attemptCookieSync(
-                        previousMPID,
                         identityApiResult.mpid,
                         mpidIsNotInCookies
                     );

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/nativeSdkHelpers.interfaces.ts

@@ -0,0 +1,13 @@
+export interface INativeSdkHelpers {
+    initializeSessionAttributes: (apiKey: string) => void;
+    isBridgeV2Available: (bridgeName: string) => boolean;
+    isWebviewEnabled: (
+        requiredWebviewBridgeName: string,
+        minWebviewBridgeVersion: number
+    ) => boolean;
+    isBridgeV1Available: () => boolean;
+    sendToNative: (path: string, value: string) => void;
+    sendViaBridgeV1: (path: string, value: string) => void;
+    sendViaIframeToIOS: (path: string, value: string) => void;
+    sendViaBridgeV2: (path: string, value: string, requiredWebviewBridgeName: boolean) => void;
+}

package/src/persistence.interfaces.ts

@@ -14,6 +14,7 @@ import {
 import { Dictionary } from './utils';
 import { IMinifiedConsentJSONObject } from './consent';
 import { UserAttributes } from './identity-user-interfaces';
+import { CookieSyncDates } from './cookieSyncManager';
 
 export type UploadsTable = Dictionary<any>;
 export interface iForwardingStatsBatches {
@@ -79,10 +80,8 @@ export interface IPersistenceMinified extends Dictionary {
     // };
 }
 
-export type CookieSyncDate = Dictionary<number>;
-
 export interface IUserPersistenceMinified extends Dictionary {
-    csd: CookieSyncDate; // Cookie Sync Dates // list of timestamps for last cookie sync
+    csd: CookieSyncDates; // list of timestamps for last cookie sync per module
     con: IMinifiedConsentJSONObject; // Consent State
     ui: UserIdentities; // User Identities
     ua: UserAttributes; // User Attributes
@@ -121,7 +120,7 @@ export interface IPersistence {
     getDomain(doc: string, locationHostname: string): string;
     getCartProducts(mpid: MPID): Product[];
     setCartProducts(allProducts: Product[]): void;
-    saveUserCookieSyncDatesToPersistence(mpid: MPID, csd: CookieSyncDate): void;
+    saveUserCookieSyncDatesToPersistence(mpid: MPID, csd: CookieSyncDates): void;
     savePersistence(persistance: IPersistenceMinified): void;
     getPersistence(): IPersistenceMinified;
     getFirstSeenTime(mpid: MPID): string | null;

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';
@@ -31,6 +30,8 @@ import {
 } from './identity-user-interfaces';
 import { IIdentityType } from './types.interfaces';
 import IntegrationCapture from './integrationCapture';
+import { INativeSdkHelpers } from './nativeSdkHelpers.interfaces';
+import { ICookieSyncManager, IPixelConfiguration } from './cookieSyncManager';
 
 // TODO: Resolve this with version in @mparticle/web-sdk
 export type SDKEventCustomFlags = Dictionary<any>;
@@ -158,6 +159,7 @@ export interface MParticleWebSDK {
     Logger: SDKLoggerApi;
     MPSideloadedKit: IMPSideloadedKit;
     _APIClient: any; // TODO: Set up API Client
+    _CookieSyncManager: ICookieSyncManager;
     _Store: IStore;
     _Forwarders: any;
     _Helpers: SDKHelpersApi;
@@ -167,7 +169,7 @@ export interface MParticleWebSDK {
     _SessionManager: ISessionManager;
     _Consent: SDKConsentApi;
     Consent: SDKConsentApi;
-    _NativeSdkHelpers: any; // TODO: Set up API
+    _NativeSdkHelpers: INativeSdkHelpers;
     _Persistence: IPersistence;
     _preInit: any; // TODO: Set up API
     _instances?: Dictionary<MParticleWebSDK>;
@@ -228,6 +230,7 @@ export interface SDKInitConfig
     sideloadedKits?: MPForwarder[];
     dataPlanOptions?: KitBlockerOptions;
     flags?: Dictionary;
+    pixelConfigs?: IPixelConfiguration[];
 
     aliasMaxWindow?: number;
     deviceId?: string;
@@ -283,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