@mparticle/web-sdk 2.25.3 → 2.26.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mparticle/web-sdk",
-    "version": "2.25.3",
+    "version": "2.26.1",
     "description": "mParticle core SDK for web applications",
     "license": "Apache-2.0",
     "keywords": [

package/src/apiClient.ts

@@ -38,9 +38,10 @@ export default function APIClient(
     const self = this;
     this.queueEventForBatchUpload = function(event: SDKEvent) {
         if (!this.uploader) {
+            // https://go.mparticle.com/work/SQDSDKS-6317
             const millis: number = parseNumber(mpInstance._Helpers.getFeatureFlag(
                 Constants.FeatureFlags.EventBatchingIntervalMillis
-            ));
+            ) as string);
             this.uploader = new BatchUploader(mpInstance, millis);
         }
         this.uploader.queueEvent(event);

package/src/audience.ts

@@ -0,0 +1,9 @@
+export default class Audience {
+    public audience_id: number;
+
+    constructor(
+        audience_id: number,
+    ) {
+        this.audience_id = audience_id;
+    }
+}

package/src/audienceManager.ts

@@ -0,0 +1,88 @@
+import { SDKLoggerApi } from './sdkRuntimeModels';
+import {
+    FetchUploader,
+    XHRUploader,
+    AsyncUploader,
+    fetchPayload
+} from './uploaders';
+import Audience from './audience';
+
+export interface IAudienceMembershipsServerResponse {
+    dt: 'cam';  // current audience memberships
+    ct: number; // timestamp
+    id: string;
+    audience_memberships: Audience[];
+}
+
+export interface IAudienceMemberships {
+    currentAudienceMemberships: Audience[];
+}
+
+export default class AudienceManager {
+    public url: string = '';
+    public userAudienceAPI: AsyncUploader;
+    public logger: SDKLoggerApi;
+
+    constructor(
+        userAudienceUrl: string,
+        apiKey: string,
+        logger: SDKLoggerApi,
+    ) {
+        this.logger = logger;
+        this.url = `https://${userAudienceUrl}${apiKey}/audience`;
+        this.userAudienceAPI = window.fetch
+            ? new FetchUploader(this.url)
+            : new XHRUploader(this.url);
+    }
+
+    public async sendGetUserAudienceRequest(mpid: string, callback: (userAudiences: IAudienceMemberships) => void) {
+        this.logger.verbose('Fetching user audiences from server');
+
+        const fetchPayload: fetchPayload = {
+            method: 'GET',
+            headers: {
+                Accept: '*/*',
+            },
+        };
+        const audienceURLWithMPID = `${this.url}?mpid=${mpid}`;
+
+        try {
+             const userAudiencePromise: Response = await this.userAudienceAPI.upload(
+                 fetchPayload,
+                 audienceURLWithMPID
+             );
+
+            if (
+                userAudiencePromise.status >= 200 &&
+                userAudiencePromise.status < 300
+            ) {
+                this.logger.verbose(`User Audiences successfully received`);
+
+                const userAudienceMembershipsServerResponse: IAudienceMembershipsServerResponse = await userAudiencePromise.json();
+                const parsedUserAudienceMemberships: IAudienceMemberships = {
+                    currentAudienceMemberships: userAudienceMembershipsServerResponse?.audience_memberships
+                }
+
+                try {
+                    callback(parsedUserAudienceMemberships);
+                } catch(e) {
+                    throw new Error('Error invoking callback on user audience response.');
+                }
+
+            } else if (userAudiencePromise.status === 401) {
+                throw new Error('`HTTP error status ${userAudiencePromise.status} while retrieving User Audiences - please verify your API key.`');
+            } else if (userAudiencePromise.status === 403) {
+                throw new Error('`HTTP error status ${userAudiencePromise.status} while retrieving User Audiences - please verify your workspace is enabled for audiences.`');
+            } else {
+                // In case there is an HTTP error we did not anticipate.
+                throw new Error(
+                    `Uncaught HTTP Error ${userAudiencePromise.status}.`
+                );
+            }
+        } catch (e) {
+            this.logger.error(
+                `Error retrieving audiences. ${e}`
+            );
+        }
+    }
+}

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/helpers.js

@@ -441,7 +441,6 @@ export default function Helpers(mpInstance) {
     this.inArray = utils.inArray;
     this.isObject = utils.isObject;
     this.decoded = utils.decoded;
-    this.returnConvertedBoolean = utils.returnConvertedBoolean;
     this.parseStringOrNumber = utils.parseStringOrNumber;
     this.generateHash = utils.generateHash;
     this.generateUniqueId = utils.generateUniqueId;

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/mockBatchCreator.ts

@@ -5,7 +5,7 @@ import { SDKEvent, BaseEvent, MParticleWebSDK } from './sdkRuntimeModels';
 import { convertEvents } from './sdkToEventsApiConverter';
 import * as EventsApi from '@mparticle/event-models';
 import { Batch } from '@mparticle/event-models';
-import { IMPSideloadedKit} from './sideloadedKit';
+import { IMPSideloadedKit } from './sideloadedKit';
 
 const mockFunction = function() {
     return null;
@@ -27,7 +27,6 @@ export default class _BatchValidator {
                 createServiceUrl: mockFunction,
                 parseNumber: mockFunction,
                 isObject: mockFunction,
-                returnConvertedBoolean: mockFunction,
                 Validators: null,
             },
             _resetForTests: mockFunction,