@mparticle/web-sdk 2.25.2 → 2.26.0

package/src/batchUploader.ts

@@ -10,6 +10,12 @@ import { convertEvents } from './sdkToEventsApiConverter';
 import Types from './types';
 import { getRampNumber, isEmpty } from './utils';
 import { SessionStorageVault, LocalStorageVault } from './vault';
+import { 
+    AsyncUploader,
+    FetchUploader,
+    XHRUploader,
+    fetchPayload
+} from './uploaders';
 
 /**
  * BatchUploader contains all the logic to store/retrieve events and batches
@@ -108,11 +114,12 @@ export class BatchUploader {
             _Store: { deviceId },
         } = this.mpInstance;
 
-        const offlineStorageFeatureFlagValue = getFeatureFlag(
+        // https://go.mparticle.com/work/SQDSDKS-6317
+        const offlineStorageFeatureFlagValue: string = getFeatureFlag(
             Constants.FeatureFlags.OfflineStorage
-        );
+        ) as string;
 
-        const offlineStoragePercentage = parseInt(
+        const offlineStoragePercentage: number = parseInt(
             offlineStorageFeatureFlagValue,
             10
         );
@@ -422,66 +429,4 @@ export class BatchUploader {
         }
         return null;
     }
-}
-
-abstract class AsyncUploader {
-    url: string;
-    public abstract upload(fetchPayload: fetchPayload): Promise<XHRResponse>;
-
-    constructor(url: string) {
-        this.url = url;
-    }
-}
-
-class FetchUploader extends AsyncUploader {
-    public async upload(fetchPayload: fetchPayload): Promise<XHRResponse> {
-        const response: XHRResponse = await fetch(this.url, fetchPayload);
-        return response;
-    }
-}
-
-class XHRUploader extends AsyncUploader {
-    public async upload(fetchPayload: fetchPayload): Promise<XHRResponse> {
-        const response: XHRResponse = await this.makeRequest(
-            this.url,
-            fetchPayload.body
-        );
-        return response;
-    }
-
-    private async makeRequest(
-        url: string,
-        data: string
-    ): Promise<XMLHttpRequest> {
-        const xhr: XMLHttpRequest = new XMLHttpRequest();
-        return new Promise((resolve, reject) => {
-            xhr.onreadystatechange = () => {
-                if (xhr.readyState !== 4) return;
-
-                // Process the response
-                if (xhr.status >= 200 && xhr.status < 300) {
-                    resolve(xhr);
-                } else {
-                    reject(xhr);
-                }
-            };
-
-            xhr.open('post', url);
-            xhr.send(data);
-        });
-    }
-}
-
-interface XHRResponse {
-    status: number;
-    statusText?: string;
-}
-
-interface fetchPayload {
-    method: string;
-    headers: {
-        Accept: string;
-        'Content-Type': string;
-    };
-    body: string;
-}
+}

package/src/constants.ts

@@ -26,6 +26,8 @@ const Constants = {
             BadKey: 'Key value cannot be object or array',
             BadLogPurchase:
                 'Transaction attributes and a product are both required to log a purchase, https://docs.mparticle.com/?javascript#measuring-transactions',
+            AudienceAPINotEnabled:
+                'Your workspace is not enabled to retrieve user audiences.',
         },
         InformationMessages: {
             CookieSearch: 'Searching for cookie',
@@ -135,6 +137,7 @@ const Constants = {
         configUrl: 'jssdkcdns.mparticle.com/JS/v2/',
         identityUrl: 'identity.mparticle.com/v1/',
         aliasUrl: 'jssdks.mparticle.com/v1/identity/',
+        userAudienceUrl: 'nativesdks.mparticle.com/v1/',
     },
     Base64CookieKeys: {
         csm: 1,
@@ -170,6 +173,7 @@ const Constants = {
         OfflineStorage: 'offlineStorage',
         DirectUrlRouting: 'directURLRouting',
         CacheIdentity: 'cacheIdentity',
+        AudienceAPI: 'audienceAPI',
     },
     DefaultInstance: 'default_instance',
     CCPAPurpose: 'data_sale_opt_out',

package/src/identity.js

@@ -5,15 +5,17 @@ import {
     createKnownIdentities,
     tryCacheIdentity,
 } from './identity-utils';
+import AudienceManager from './audienceManager';
 
-var Messages = Constants.Messages,
-    HTTPCodes = Constants.HTTPCodes;
+const { Messages, HTTPCodes, FeatureFlags } = Constants;
+const { ErrorMessages } = Messages;
 
 const { Identify, Modify, Login, Logout } = Constants.IdentityMethods;
 
 export default function Identity(mpInstance) {
     var self = this;
     this.idCache = null;
+    this.audienceManager = null;
 
     this.checkIdentitySwap = function(
         previousMPID,
@@ -1265,6 +1267,34 @@ export default function Identity(mpInstance) {
             getFirstSeenTime: function() {
                 return mpInstance._Persistence.getFirstSeenTime(mpid);
             },
+            /**
+             * Get user audiences
+             * @method getuserAudiences
+             * @param {Function} [callback] A callback function that is invoked when the user audience request completes
+             */
+            getUserAudiences: function(callback) {
+                // user audience API is feature flagged
+                if (
+                    !mpInstance._Helpers.getFeatureFlag(
+                        FeatureFlags.AudienceAPI
+                    )
+                ) {
+                    mpInstance.Logger.error(
+                        ErrorMessages.AudienceAPINotEnabled
+                    );
+                    return;
+                }
+                if (self.audienceManager === null) {
+                    self.audienceManager = new AudienceManager(
+                        mpInstance._Store.SDKConfig.userAudienceUrl,
+                        mpInstance._Store.devToken,
+                        mpInstance.Logger,
+                        mpid
+                    );
+                }
+
+                self.audienceManager.sendGetUserAudienceRequest(mpid, callback);
+            },
         };
     };
 

package/src/mp-instance.js

@@ -86,6 +86,9 @@ export default function mParticleInstance(instanceName) {
     this._Identity = new Identity(this);
     this.Identity = this._Identity.IdentityAPI;
     this.generateHash = this._Helpers.generateHash;
+
+    // https://go.mparticle.com/work/SQDSDKS-6289
+    // TODO: Replace this with Store once Store is moved earlier in the init process
     this.getDeviceId = this._Persistence.getDeviceId;
 
     if (typeof window !== 'undefined') {
@@ -231,7 +234,7 @@ export default function mParticleInstance(instanceName) {
             self.setDeviceId(guid);
         }, self);
         if (queued) return;
-        this._Persistence.setDeviceId(guid);
+        this._Store.setDeviceId(guid);
     };
     /**
      * Returns a boolean for whether or not the SDKhas been fully initialized

package/src/sdkRuntimeModels.ts

@@ -1,6 +1,11 @@
 import * as EventsApi from '@mparticle/event-models';
 import { DataPlanVersion } from '@mparticle/data-planning-models';
-import { MPConfiguration, IdentityApiData } from '@mparticle/web-sdk';
+import {
+    MPConfiguration,
+    IdentityApiData,
+    MPID,
+    Callback,
+} from '@mparticle/web-sdk';
 import { IStore } from './store';
 import Validators from './validators';
 import { Dictionary, valueof } from './utils';
@@ -246,19 +251,27 @@ export interface SDKIdentityApi {
 
 export interface SDKHelpersApi {
     canLog?(): boolean;
-    createServiceUrl(arg0: string, arg1: string): void;
+    createServiceUrl(url: string, devToken?: string): void;
     createXHR?(cb: () => void): XMLHttpRequest;
     extend?(...args: any[]);
     parseNumber?(value: string | number): number;
     generateUniqueId();
     generateHash?(value: string): string;
-    getFeatureFlag?(feature: string); // TODO: Feature Constants should be converted to enum
+    // https://go.mparticle.com/work/SQDSDKS-6317
+    getFeatureFlag?(feature: string): boolean | string; // TODO: Feature Constants should be converted to enum
     isDelayedByIntegration?(
         delayedIntegrations: Dictionary<boolean>,
         timeoutStart: number,
         now: number
     ): boolean;
     isObject?(item: any);
+    invokeCallback?(
+        callback: Callback,
+        code: string,
+        body: string,
+        mParticleUser?: MParticleUser,
+        previousMpid?: MPID
+    ): void;
     returnConvertedBoolean(data: string | boolean | number): boolean;
     sanitizeAttributes?(
         attrs: Dictionary<string>,

package/src/sessionManager.ts

@@ -129,7 +129,7 @@ export default function SessionManager(
                 messageType: Types.MessageType.SessionEnd,
             });
 
-            nullifySession();
+            mpInstance._Store.nullifySession();
             return;
         }
 
@@ -175,7 +175,7 @@ export default function SessionManager(
                 });
 
                 mpInstance._Store.sessionStartDate = null;
-                nullifySession();
+                mpInstance._Store.nullifySession();
             }
         }
     };
@@ -204,7 +204,7 @@ export default function SessionManager(
         clearTimeout(mpInstance._Store.globalTimer);
     };
 
-    this.startNewSessionIfNeeded = function(): void {
+    this.startNewSessionIfNeeded = function (): void {
         if (!mpInstance._Store.webviewBridgeEnabled) {
             const persistence = mpInstance._Persistence.getPersistence();
 
@@ -217,11 +217,4 @@ export default function SessionManager(
             }
         }
     };
-
-    function nullifySession(): void {
-        mpInstance._Store.sessionId = null;
-        mpInstance._Store.dateLastEventSent = null;
-        mpInstance._Store.sessionAttributes = {};
-        mpInstance._Persistence.update();
-    }
 }

package/src/store.ts

@@ -23,6 +23,7 @@ import {
 import { isNumber, isDataPlanSlug, Dictionary, parseNumber } from './utils';
 import { SDKConsentState } from './consent';
 import { Kit, MPForwarder } from './forwarders.interfaces';
+import { IPersistenceMinified } from './persistence.interfaces';
 
 // This represents the runtime configuration of the SDK AFTER
 // initialization has been complete and all settings and
@@ -60,6 +61,7 @@ export interface SDKConfig {
     aliasUrl?: string;
     configUrl?: string;
     identityUrl?: string;
+    userAudienceUrl?: string;
     isIOS?: boolean;
     maxProducts: number;
     requestConfig?: boolean;
@@ -162,6 +164,18 @@ export interface IStore {
     integrationDelayTimeoutStart: number; // UNIX Timestamp
     webviewBridgeEnabled?: boolean;
     wrapperSDKInfo: WrapperSDKInfo;
+
+    persistenceData?: IPersistenceMinified;
+
+    getDeviceId?(): string;
+    setDeviceId?(deviceId: string): void;
+
+    getFirstSeenTime?(mpid: MPID): number;
+    setFirstSeenTime?(mpid: MPID, time?: number): void;
+    getLastSeenTime?(mpid: MPID): number;
+    setLastSeenTime?(mpid: MPID, time?: number): void;
+
+    nullifySession?: () => void;
 }
 
 // TODO: Merge this with SDKStoreApi in sdkRuntimeModels
@@ -214,6 +228,27 @@ export default function Store(
             version: null,
             isInfoSet: false,
         },
+
+        // Placeholder for in-memory persistence model
+        persistenceData: {
+            cu: null,
+            gs: {
+                sid: null,
+                ie: null,
+                sa: null,
+                ss: null,
+                dt: null,
+                av: null,
+                cgid: null,
+                das: null,
+                ia: null,
+                c: null,
+                csm: null,
+                les: null,
+                ssd: null,
+            },
+            l: null,
+        },
     };
 
     for (var key in defaultStore) {
@@ -418,6 +453,92 @@ export default function Store(
             }
         }
     }
+
+    this.getDeviceId = () => this.deviceId;
+    this.setDeviceId = (deviceId: string) => {
+        this.deviceId = deviceId;
+        this.persistenceData.gs.das = deviceId;
+        mpInstance._Persistence.update();
+    };
+
+    this.nullifySession = (): void => {
+        this.sessionId = null;
+        this.dateLastEventSent = null;
+        this.sessionAttributes = {};
+        mpInstance._Persistence.update();
+    };
+
+    this.getFirstSeenTime = (mpid: MPID) => {
+        if (!mpid) {
+            return null;
+        }
+
+        if (
+            this.persistenceData &&
+            this.persistenceData[mpid] &&
+            this.persistenceData[mpid].fst
+        ) {
+            return this.persistenceData[mpid].fst;
+        } else {
+            return null;
+        }
+    };
+
+    this.setFirstSeenTime = (mpid: MPID, _time?: number) => {
+        if (!mpid) {
+            return;
+        }
+
+        const time = _time || new Date().getTime();
+
+        if (this.persistenceData) {
+            if (!this.persistenceData[mpid]) {
+                this.persistenceData[mpid] = {};
+            }
+            if (!this.persistenceData[mpid].fst) {
+                this.persistenceData[mpid].fst = time;
+                mpInstance._Persistence.savePersistence(this.persistenceData);
+            }
+        }
+    };
+
+    this.getLastSeenTime = (mpid: MPID) => {
+        if (!mpid) {
+            return null;
+        }
+        //     // https://go.mparticle.com/work/SQDSDKS-6315
+        const currentUser = mpInstance.Identity.getCurrentUser();
+        if (mpid === currentUser?.getMPID()) {
+            // if the mpid is the current user, its last seen time is the current time
+            return new Date().getTime();
+        } else if (
+            this.persistenceData &&
+            this.persistenceData[mpid] &&
+            this.persistenceData[mpid].lst
+        ) {
+            return this.persistenceData[mpid].lst;
+        } else {
+            return null;
+        }
+    };
+
+    this.setLastSeenTime = (mpid: MPID, _time?: number) => {
+        if (!mpid) {
+            return;
+        }
+
+        const time = _time || new Date().getTime();
+
+        if (this.persistenceData) {
+            if (!this.persistenceData[mpid]) {
+                this.persistenceData[mpid] = {};
+            }
+            if (!this.persistenceData[mpid].lst) {
+                this.persistenceData[mpid].lst = time;
+                mpInstance._Persistence.savePersistence(this.persistenceData);
+            }
+        }
+    };
 }
 
 export function processFlags(
@@ -431,6 +552,7 @@ export function processFlags(
         OfflineStorage,
         DirectUrlRouting,
         CacheIdentity,
+        AudienceAPI,
     } = Constants.FeatureFlags;
 
     if (!config.flags) {
@@ -446,6 +568,7 @@ export function processFlags(
     flags[OfflineStorage] = config.flags[OfflineStorage] || '0';
     flags[DirectUrlRouting] = config.flags[DirectUrlRouting] === 'True';
     flags[CacheIdentity] = config.flags[CacheIdentity] === 'True';
+    flags[AudienceAPI] = config.flags[AudienceAPI] === 'True';
 
     return flags;
 }
@@ -527,4 +650,4 @@ function processDirectBaseUrls(
     }
 
     return directBaseUrls;
-}
+}

package/src/uploaders.ts

@@ -0,0 +1,59 @@
+export interface fetchPayload {
+    method: string;
+    headers: {
+        Accept: string;
+        'Content-Type'?: string;
+    };
+    body?: string;
+}
+
+export abstract class AsyncUploader {
+    url: string;
+    public abstract upload(
+        fetchPayload: fetchPayload,
+        url?: string
+    ): Promise<Response>;
+
+    constructor(url: string) {
+        this.url = url;
+    }
+}
+
+export class FetchUploader extends AsyncUploader {
+    public async upload(
+        fetchPayload: fetchPayload,
+        _url?: string
+    ): Promise<Response> {
+        const url = _url || this.url;
+        return await fetch(url, fetchPayload);
+    }
+}
+
+export class XHRUploader extends AsyncUploader {
+    public async upload(fetchPayload: fetchPayload): Promise<Response> {
+        const response: Response = await this.makeRequest(
+            this.url,
+            fetchPayload.body
+        );
+        return response;
+    }
+
+    private async makeRequest(url: string, data: string): Promise<Response> {
+        const xhr: XMLHttpRequest = new XMLHttpRequest();
+        return new Promise((resolve, reject) => {
+            xhr.onreadystatechange = () => {
+                if (xhr.readyState !== 4) return;
+
+                // Process the response
+                if (xhr.status >= 200 && xhr.status < 300) {
+                    resolve((xhr as unknown) as Response);
+                } else {
+                    reject(xhr);
+                }
+            };
+
+            xhr.open('post', url);
+            xhr.send(data);
+        });
+    }
+}