@mparticle/web-sdk 2.25.3 → 2.26.0

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

@@ -61,6 +61,7 @@ export interface SDKConfig {
     aliasUrl?: string;
     configUrl?: string;
     identityUrl?: string;
+    userAudienceUrl?: string;
     isIOS?: boolean;
     maxProducts: number;
     requestConfig?: boolean;
@@ -169,6 +170,11 @@ export interface IStore {
     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;
 }
 
@@ -260,19 +266,16 @@ export default function Store(
             this.SDKConfig.flags = {};
         }
 
-        this.SDKConfig.flags = processFlags(
-            config,
-            this.SDKConfig as SDKConfig
-        );
+        this.SDKConfig.flags = processFlags(config, this
+            .SDKConfig as SDKConfig);
 
         if (config.deviceId) {
             this.deviceId = config.deviceId;
         }
         if (config.hasOwnProperty('isDevelopmentMode')) {
-            this.SDKConfig.isDevelopmentMode =
-                mpInstance._Helpers.returnConvertedBoolean(
-                    config.isDevelopmentMode
-                );
+            this.SDKConfig.isDevelopmentMode = mpInstance._Helpers.returnConvertedBoolean(
+                config.isDevelopmentMode
+            );
         } else {
             this.SDKConfig.isDevelopmentMode = false;
         }
@@ -464,6 +467,78 @@ export default function Store(
         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(
@@ -477,6 +552,7 @@ export function processFlags(
         OfflineStorage,
         DirectUrlRouting,
         CacheIdentity,
+        AudienceAPI,
     } = Constants.FeatureFlags;
 
     if (!config.flags) {
@@ -492,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;
 }

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