@mparticle/web-sdk 2.31.1 → 2.32.1

package/src/identityApiClient.interfaces.ts

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

package/src/integrationCapture.ts

@@ -5,6 +5,7 @@ import {
     getCookies,
     getHref,
     isEmpty,
+    valueof,
 } from './utils';
 
 export interface IntegrationCaptureProcessorFunction {
@@ -48,11 +49,24 @@ export const facebookClickIdProcessor: IntegrationCaptureProcessorFunction = (
 
     return `fb.${subdomainIndex}.${_timestamp}.${clickId}`;
 };
+
+// Integration outputs are used to determine how click ids are used within the SDK
+// CUSTOM_FLAGS are sent out when an Event is created via ServerModel.createEventObject
+// PARTNER_IDENTITIES are sent out in a Batch when a group of events are converted to a Batch
+
+const IntegrationOutputs = {
+    CUSTOM_FLAGS: 'custom_flags',
+    PARTNER_IDENTITIES: 'partner_identities',
+} as const;
+
+interface IntegrationMappingItem {
+    mappedKey: string;
+    output: valueof<typeof IntegrationOutputs>;
+    processor?: IntegrationCaptureProcessorFunction;
+}
+
 interface IntegrationIdMapping {
-    [key: string]: {
-        mappedKey: string;
-        processor?: IntegrationCaptureProcessorFunction;
-    };
+    [key: string]: IntegrationMappingItem;
 }
 
 const integrationMapping: IntegrationIdMapping = {
@@ -60,33 +74,54 @@ const integrationMapping: IntegrationIdMapping = {
     fbclid: {
         mappedKey: 'Facebook.ClickId',
         processor: facebookClickIdProcessor,
+        output: IntegrationOutputs.CUSTOM_FLAGS,
     },
     _fbp: {
         mappedKey: 'Facebook.BrowserId',
+        output: IntegrationOutputs.CUSTOM_FLAGS,
     },
     _fbc: {
         mappedKey: 'Facebook.ClickId',
+        output: IntegrationOutputs.CUSTOM_FLAGS,
     },
 
     // Google
     gclid: {
         mappedKey: 'GoogleEnhancedConversions.Gclid',
+        output: IntegrationOutputs.CUSTOM_FLAGS,
     },
     gbraid: {
         mappedKey: 'GoogleEnhancedConversions.Gbraid',
+        output: IntegrationOutputs.CUSTOM_FLAGS,
     },
     wbraid: {
         mappedKey: 'GoogleEnhancedConversions.Wbraid',
+        output: IntegrationOutputs.CUSTOM_FLAGS,
     },
 
+    // TIKTOK
+    ttclid: {
+        mappedKey: 'TikTok.Callback',
+        output: IntegrationOutputs.CUSTOM_FLAGS,
+    },
+    _ttp: {
+        mappedKey: 'tiktok_cookie_id',
+        output: IntegrationOutputs.PARTNER_IDENTITIES,
+    },
 };
 
 export default class IntegrationCapture {
     public clickIds: Dictionary<string>;
     public readonly initialTimestamp: number;
+    public readonly filteredPartnerIdentityMappings: IntegrationIdMapping;
+    public readonly filteredCustomFlagMappings: IntegrationIdMapping;
 
     constructor() {
         this.initialTimestamp = Date.now();
+
+        // Cache filtered mappings for faster access
+        this.filteredPartnerIdentityMappings = this.filterMappings(IntegrationOutputs.PARTNER_IDENTITIES);
+        this.filteredCustomFlagMappings = this.filterMappings(IntegrationOutputs.CUSTOM_FLAGS);
     }
 
     /**
@@ -134,22 +169,42 @@ export default class IntegrationCapture {
      * @returns {SDKEventCustomFlags} The custom flags.
      */
     public getClickIdsAsCustomFlags(): SDKEventCustomFlags {
-        const customFlags: SDKEventCustomFlags = {};
+        return this.getClickIds(this.clickIds, this.filteredCustomFlagMappings);
+    }
 
-        if (!this.clickIds) {
-            return customFlags;
+    /**
+     * Returns only the `partner_identities` mapped integration output.
+     * @returns {Dictionary<string>} The partner identities.
+     */
+    public getClickIdsAsPartnerIdentities(): Dictionary<string> {
+        return this.getClickIds(this.clickIds, this.filteredPartnerIdentityMappings);
+    }
+
+    private getClickIds(
+        clickIds: Dictionary<string>,
+        mappingList: IntegrationIdMapping
+    ): Dictionary<string> {
+        const mappedClickIds: Dictionary<string> = {};
+
+        if (!clickIds) {
+            return mappedClickIds;
         }
 
-        for (const [key, value] of Object.entries(this.clickIds)) {
-            const mappedKey = integrationMapping[key]?.mappedKey;
+        for (const [key, value] of Object.entries(clickIds)) {
+            const mappedKey = mappingList[key]?.mappedKey;
             if (!isEmpty(mappedKey)) {
-                customFlags[mappedKey] = value;
+                mappedClickIds[mappedKey] = value;
             }
         }
-        return customFlags;
+
+        return mappedClickIds;
     }
 
-    private applyProcessors(clickIds: Dictionary<string>, url?: string, timestamp?: number): Dictionary<string> {
+    private applyProcessors(
+        clickIds: Dictionary<string>,
+        url?: string,
+        timestamp?: number
+    ): Dictionary<string> {
         const processedClickIds: Dictionary<string> = {};
 
         for (const [key, value] of Object.entries(clickIds)) {
@@ -163,4 +218,14 @@ export default class IntegrationCapture {
 
         return processedClickIds;
     }
+
+    private filterMappings(
+        outputType: valueof<typeof IntegrationOutputs>
+    ): IntegrationIdMapping {
+        return Object.fromEntries(
+            Object.entries(integrationMapping).filter(
+                ([, value]) => value.output === outputType
+            )
+        );
+    }
 }

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

@@ -31,6 +31,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 +160,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 +170,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 +231,7 @@ export interface SDKInitConfig
     sideloadedKits?: MPForwarder[];
     dataPlanOptions?: KitBlockerOptions;
     flags?: Dictionary;
+    pixelConfigs?: IPixelConfiguration[];
 
     aliasMaxWindow?: number;
     deviceId?: string;

package/src/sdkToEventsApiConverter.ts

@@ -13,15 +13,30 @@ import {
     SDKCCPAConsentState,
 } from './consent';
 import Types from './types';
-import { isEmpty } from './utils';
+import { Dictionary, isEmpty } from './utils';
 import { ISDKUserIdentity } from './identity-user-interfaces';
 import { SDKIdentityTypeEnum } from './identity.interfaces';
+import Constants from './constants';
+
+const { 
+    FeatureFlags
+} = Constants;
+const {
+    CaptureIntegrationSpecificIds
+} = FeatureFlags;
+
+type PartnerIdentities = Dictionary<string>;
+
+// https://go.mparticle.com/work/SQDSDKS-6964
+interface Batch extends EventsApi.Batch {
+    partner_identities?: PartnerIdentities;
+}
 
 export function convertEvents(
     mpid: string,
     sdkEvents: SDKEvent[],
     mpInstance: MParticleWebSDK
-): EventsApi.Batch | null {
+): Batch | null {
     if (!mpid) {
         return null;
     }
@@ -29,6 +44,16 @@ export function convertEvents(
         return null;
     }
 
+    const {
+        _IntegrationCapture,
+        _Helpers,
+    } = mpInstance
+
+    const {
+        getFeatureFlag,
+    } = _Helpers;
+
+
     const user = mpInstance.Identity.getCurrentUser();
 
     const uploadEvents: EventsApi.BaseEvent[] = [];
@@ -56,7 +81,7 @@ export function convertEvents(
         currentConsentState = user.getConsentState();
     }
 
-    const upload: EventsApi.Batch = {
+    const upload: Batch = {
         source_request_id: mpInstance._Helpers.generateUniqueId(),
         mpid,
         timestamp_unixtime_ms: new Date().getTime(),
@@ -102,6 +127,15 @@ export function convertEvents(
             },
         };
     }
+
+    const isIntegrationCaptureEnabled: boolean = getFeatureFlag && Boolean(getFeatureFlag(CaptureIntegrationSpecificIds));
+    if (isIntegrationCaptureEnabled) {
+        const capturedPartnerIdentities: PartnerIdentities = _IntegrationCapture?.getClickIdsAsPartnerIdentities();
+        if (!isEmpty(capturedPartnerIdentities)) {
+            upload.partner_identities = capturedPartnerIdentities;
+        }
+    }
+
     return upload;
 }
 

package/src/store.ts

@@ -37,6 +37,7 @@ import {
     IGlobalStoreV2MinifiedKeys,
     IPersistenceMinified,
 } from './persistence.interfaces';
+import { CookieSyncDates, IPixelConfiguration } from './cookieSyncManager';
 
 // This represents the runtime configuration of the SDK AFTER
 // initialization has been complete and all settings and
@@ -118,7 +119,6 @@ function createSDKConfig(config: SDKInitConfig): SDKConfig {
 
 // TODO: Placeholder Types to be filled in as we migrate more modules
 //       to TypeScript
-export type PixelConfiguration = Dictionary;
 export type ServerSettings = Dictionary;
 export type SessionAttributes = Dictionary;
 export type IntegrationAttributes = Dictionary<Dictionary<string>>;
@@ -168,7 +168,7 @@ export interface IStore {
     identifyCalled: boolean;
     isLoggedIn: boolean;
     sideloadedKitsCount?: number;
-    cookieSyncDates: Dictionary<number>;
+    cookieSyncDates: CookieSyncDates;
     integrationAttributes: IntegrationAttributes;
     requireDelay: boolean;
     isLocalStorageAvailable: boolean | null;
@@ -178,7 +178,7 @@ export interface IStore {
     kits: Dictionary<MPForwarder>;
     sideloadedKits: MPForwarder[];
     configuredForwarders: MPForwarder[];
-    pixelConfigurations: PixelConfiguration[];
+    pixelConfigurations: IPixelConfiguration[];
     integrationDelayTimeoutStart: number; // UNIX Timestamp
     webviewBridgeEnabled?: boolean;
     wrapperSDKInfo: WrapperSDKInfo;

package/src/utils.ts

@@ -1,3 +1,4 @@
+import { MPID } from '@mparticle/web-sdk';
 import Constants from './constants';
 
 const { Messages } = Constants;
@@ -175,6 +176,27 @@ const replaceApostrophesWithQuotes = (value: string): string =>
 const replaceQuotesWithApostrophes = (value: string): string =>
     value.replace(/\"/g, "'");
 
+const replaceMPID = (value: string, mpid: MPID): string => value.replace('%%mpid%%', mpid);
+
+const replaceAmpWithAmpersand = (value: string): string => value.replace(/&/g, '&');
+
+const createCookieSyncUrl = (
+    mpid: MPID,
+    pixelUrl: string,
+    redirectUrl?: string
+): string => {
+    const modifiedPixelUrl = replaceAmpWithAmpersand(pixelUrl);
+    const modifiedDirectUrl = redirectUrl
+        ? replaceAmpWithAmpersand(redirectUrl)
+        : null;
+
+    const url = replaceMPID(modifiedPixelUrl, mpid);
+    const redirect = modifiedDirectUrl
+        ? replaceMPID(modifiedDirectUrl, mpid)
+        : '';
+    return url + encodeURIComponent(redirect);
+};
+
 // FIXME: REFACTOR for V3
 // only used in store.js to sanitize server-side formatting of
 // booleans when checking for `isDevelopmentMode`
@@ -336,6 +358,7 @@ const getHref = (): string => {
 export {
     createCookieString,
     revertCookieString,
+    createCookieSyncUrl,
     valueof,
     converted,
     decoded,
@@ -366,4 +389,6 @@ export {
     queryStringParser,
     getCookies,
     getHref,
+    replaceMPID,
+    replaceAmpWithAmpersand,
 };

package/src/cookieSyncManager.js

@@ -1,197 +0,0 @@
-import Constants from './constants';
-
-var Messages = Constants.Messages;
-
-export default function cookieSyncManager(mpInstance) {
-    var self = this;
-
-    // Public
-    this.attemptCookieSync = function(previousMPID, mpid, mpidIsNotInCookies) {
-        // TODO: These should move inside the for loop
-        var pixelConfig,
-            lastSyncDateForModule,
-            url,
-            redirect,
-            urlWithRedirect,
-            requiresConsent;
-
-        // TODO: Make this exit quicker instead of nested
-        if (mpid && !mpInstance._Store.webviewBridgeEnabled) {
-            mpInstance._Store.pixelConfigurations.forEach(function(
-                pixelSettings
-            ) {
-                // set requiresConsent to false to start each additional pixel configuration
-                // set to true only if filteringConsenRuleValues.values.length exists
-                requiresConsent = false;
-
-                // TODO: Replace with isEmpty
-                if (
-                    pixelSettings.filteringConsentRuleValues &&
-                    pixelSettings.filteringConsentRuleValues.values &&
-                    pixelSettings.filteringConsentRuleValues.values.length
-                ) {
-                    requiresConsent = true;
-                }
-
-                pixelConfig = {
-                    // Kit Module ID
-                    moduleId: pixelSettings.moduleId,
-
-                    // Tells you how often we should do a cookie sync (in days)
-                    frequencyCap: pixelSettings.frequencyCap,
-
-                    // Url for cookie sync pixel
-                    pixelUrl: self.replaceAmp(pixelSettings.pixelUrl),
-
-                    // TODO: Document requirements for redirectUrl
-                    redirectUrl: pixelSettings.redirectUrl
-                        ? self.replaceAmp(pixelSettings.redirectUrl)
-                        : null,
-
-                    // Filtering rules as defined in UI
-                    filteringConsentRuleValues:
-                        pixelSettings.filteringConsentRuleValues,
-                };
-
-                // TODO: combine replaceMPID and replaceAmp into sanitizeUrl function
-                url = self.replaceMPID(pixelConfig.pixelUrl, mpid);
-                redirect = pixelConfig.redirectUrl
-                    ? self.replaceMPID(pixelConfig.redirectUrl, mpid)
-                    : '';
-                urlWithRedirect = url + encodeURIComponent(redirect);
-
-                // TODO: Refactor so that Persistence is only called once
-                //       outside of the loop
-                var persistence = mpInstance._Persistence.getPersistence();
-
-                // TODO: Is there a historic reason for checking for previousMPID?
-                //       it does not appear to be passed in anywhere
-                if (previousMPID && previousMPID !== mpid) {
-                    if (persistence && persistence[mpid]) {
-                        if (!persistence[mpid].csd) {
-                            persistence[mpid].csd = {};
-                        }
-                        self.performCookieSync(
-                            urlWithRedirect,
-                            pixelConfig.moduleId,
-                            mpid,
-                            persistence[mpid].csd,
-                            pixelConfig.filteringConsentRuleValues,
-                            mpidIsNotInCookies,
-                            requiresConsent
-                        );
-                    }
-                    return;
-                } else {
-                    // TODO: Refactor to check for the inverse and exit early
-                    //       rather than nesting
-                    if (persistence[mpid]) {
-                        if (!persistence[mpid].csd) {
-                            persistence[mpid].csd = {};
-                        }
-                        lastSyncDateForModule = persistence[mpid].csd[
-                            pixelConfig.moduleId.toString()
-                        ]
-                            ? persistence[mpid].csd[
-                                  pixelConfig.moduleId.toString()
-                              ]
-                            : null;
-
-                        if (lastSyncDateForModule) {
-                            // Check to see if we need to refresh cookieSync
-                            if (
-                                // TODO: Turn this into a convenience method for readability?
-                                //       We use similar comparisons elsewhere in the SDK,
-                                //       so perhaps we can make a time comparison convenience method
-                                new Date().getTime() >
-                                new Date(lastSyncDateForModule).getTime() +
-                                    pixelConfig.frequencyCap *
-                                        // TODO: Turn these numbers into a constant so
-                                        //       we can remember what this number is for
-                                        60 *
-                                        1000 *
-                                        60 *
-                                        24
-                            ) {
-                                self.performCookieSync(
-                                    urlWithRedirect,
-                                    pixelConfig.moduleId,
-                                    mpid,
-                                    persistence[mpid].csd,
-                                    pixelConfig.filteringConsentRuleValues,
-                                    mpidIsNotInCookies,
-                                    requiresConsent
-                                );
-                            }
-                        } else {
-                            self.performCookieSync(
-                                urlWithRedirect,
-                                pixelConfig.moduleId,
-                                mpid,
-                                persistence[mpid].csd,
-                                pixelConfig.filteringConsentRuleValues,
-                                mpidIsNotInCookies,
-                                requiresConsent
-                            );
-                        }
-                    }
-                }
-            });
-        }
-    };
-
-    // Private
-    this.replaceMPID = function(string, mpid) {
-        return string.replace('%%mpid%%', mpid);
-    };
-
-    // Private
-    // TODO: Rename function to replaceAmpWithAmpersand
-    this.replaceAmp = function(string) {
-        return string.replace(/&/g, '&');
-    };
-
-    // Private
-    this.performCookieSync = function(
-        url,
-        moduleId,
-        mpid,
-        cookieSyncDates,
-        filteringConsentRuleValues,
-        mpidIsNotInCookies,
-        requiresConsent
-    ) {
-        // 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 its enabled if the user has a blank consent
-        // TODO: We should do this check outside of this function
-        if (requiresConsent && mpidIsNotInCookies) {
-            return;
-        }
-
-        // TODO: Refactor so that check is made outside of the function.
-        //       Cache or store the boolean so that it only gets called once per
-        //       cookie sync attempt per module.
-        //       Currently, attemptCookieSync is called as a loop and therefore this
-        //       function polls the user object and consent multiple times.
-        if (
-            mpInstance._Consent.isEnabledForUserConsent(
-                filteringConsentRuleValues,
-                mpInstance.Identity.getCurrentUser()
-            )
-        ) {
-            var img = document.createElement('img');
-
-            mpInstance.Logger.verbose(Messages.InformationMessages.CookieSync);
-            img.onload = function() {
-                // TODO: Break this out into a convenience method so we can unit test
-                cookieSyncDates[moduleId.toString()] = new Date().getTime();
-                mpInstance._Persistence.saveUserCookieSyncDatesToPersistence(
-                    mpid,
-                    cookieSyncDates
-                );
-            };
-            img.src = url;
-        }
-    };
-}