@mparticle/web-sdk 2.18.3 → 2.19.1

package/src/serverModel.ts

@@ -17,17 +17,17 @@ import { parseNumber, parseStringOrNumber, Dictionary } from './utils';
 import { ServerSettings } from './store';
 import { MPID } from '@mparticle/web-sdk';
 import {
-    IConsentStateDTO,
-    IGDPRConsentStateDTO,
+    IConsentStateV2DTO,
+    IGDPRConsentStateV2DTO,
     IPrivacyV2DTO,
     SDKConsentState,
-} from './consent.interfaces';
+} from './consent';
 
 const MessageType = Types.MessageType;
 const ApplicationTransitionType = Types.ApplicationTransitionType;
 
 // TODO: Confirm which attributes are optional
-export interface IServerDTO {
+export interface IServerV2DTO {
     id: string | number;
     nm: string | number;
     pr: number;
@@ -61,7 +61,7 @@ export interface IServerDTO {
     das?: string;
     mpid?: MPID;
     smpids?: MPID[];
-    con?: IConsentStateDTO;
+    con?: IConsentStateV2DTO;
     fr?: boolean;
     iu?: boolean; // isUpgrade
     at?: number;
@@ -69,13 +69,13 @@ export interface IServerDTO {
     flags?: Dictionary<string[]>;
     cu?: string;
     sc?: {
-        pl: IProductDTO[];
+        pl: IProductV2DTO[];
     };
     pd?: {
         an: number;
         cs: number;
         co: string;
-        pl: IProductDTO[];
+        pl: IProductV2DTO[];
         ta: string;
         ti: string;
         tcc: string;
@@ -85,13 +85,13 @@ export interface IServerDTO {
     };
     pm?: {
         an: string;
-        pl: IPromotionDTO[];
+        pl: IPromotionV2DTO[];
     };
-    pi?: IProductImpressionDTO[];
+    pi?: IProductImpressionV2DTO[];
     pet?: number;
 }
 
-export interface IProductDTO {
+export interface IProductV2DTO {
     id: string | number;
     nm: string | number;
     pr: number;
@@ -105,16 +105,16 @@ export interface IProductDTO {
     attrs: Record<string, string> | null;
 }
 
-export interface IPromotionDTO {
+export interface IPromotionV2DTO {
     id: string | number;
     nm: string | number;
     ps: string | number;
     cr: string;
 }
 
-export interface IProductImpressionDTO {
+export interface IProductImpressionV2DTO {
     pil: string;
-    pl: IProductDTO[];
+    pl: IProductV2DTO[];
 }
 
 export interface IUploadObject extends SDKEvent {
@@ -129,14 +129,14 @@ export interface IUploadObject extends SDKEvent {
 }
 
 export interface IServerModel {
-    convertEventToDTO: (event: IUploadObject) => IServerDTO;
+    convertEventToV2DTO: (event: IUploadObject) => IServerV2DTO;
     createEventObject: (event: BaseEvent, user?: MParticleUser) => SDKEvent;
-    convertToConsentStateDTO: (state: SDKConsentState) => IConsentStateDTO;
+    convertToConsentStateV2DTO: (state: SDKConsentState) => IConsentStateV2DTO;
     appendUserInfo: (user: MParticleUser, event: SDKEvent) => void;
 }
 
 // TODO: Make this a pure function that returns a new object
-function convertCustomFlags(event: SDKEvent, dto: IServerDTO) {
+function convertCustomFlags(event: SDKEvent, dto: IServerV2DTO) {
     var valueArray: string[] = [];
     dto.flags = {};
 
@@ -171,7 +171,7 @@ function convertCustomFlags(event: SDKEvent, dto: IServerDTO) {
     }
 }
 
-function convertProductToDTO(product: SDKProduct): IProductDTO {
+function convertProductToV2DTO(product: SDKProduct): IProductV2DTO {
     return {
         id: parseStringOrNumber(product.Sku),
         nm: parseStringOrNumber(product.Name),
@@ -187,13 +187,13 @@ function convertProductToDTO(product: SDKProduct): IProductDTO {
     };
 }
 
-function convertProductListToDTO(productList: SDKProduct[]): IProductDTO[] {
+function convertProductListToV2DTO(productList: SDKProduct[]): IProductV2DTO[] {
     if (!productList) {
         return [];
     }
 
     return productList.map(function(product) {
-        return convertProductToDTO(product);
+        return convertProductToV2DTO(product);
     });
 }
 
@@ -245,16 +245,16 @@ export default function ServerModel(
         event.UserIdentities = validUserIdentities;
     };
 
-    this.convertToConsentStateDTO = function(
+    this.convertToConsentStateV2DTO = function(
         state: SDKConsentState
-    ): IConsentStateDTO {
+    ): IConsentStateV2DTO {
         if (!state) {
             return null;
         }
-        var jsonObject: IConsentStateDTO = {};
+        var jsonObject: IConsentStateV2DTO = {};
         var gdprConsentState = state.getGDPRConsentState();
         if (gdprConsentState) {
-            var gdpr: IGDPRConsentStateDTO = {};
+            var gdpr: IGDPRConsentStateV2DTO = {};
             jsonObject.gdpr = gdpr;
             for (var purpose in gdprConsentState) {
                 if (gdprConsentState.hasOwnProperty(purpose)) {
@@ -292,7 +292,7 @@ export default function ServerModel(
             };
         }
 
-        return jsonObject as IConsentStateDTO;
+        return jsonObject as IConsentStateV2DTO;
     };
 
     this.createEventObject = function(
@@ -408,8 +408,8 @@ export default function ServerModel(
         return null;
     };
 
-    this.convertEventToDTO = function(event: IUploadObject): IServerDTO {
-        var dto: Partial<IServerDTO> = {
+    this.convertEventToV2DTO = function(event: IUploadObject): IServerV2DTO {
+        var dto: Partial<IServerV2DTO> = {
             n: event.EventName,
             et: event.EventCategory,
             ua: event.UserAttributes,
@@ -441,7 +441,7 @@ export default function ServerModel(
             }
         }
 
-        var consent = self.convertToConsentStateDTO(event.ConsentState);
+        var consent = self.convertToConsentStateV2DTO(event.ConsentState);
         if (consent) {
             dto.con = consent;
         }
@@ -458,7 +458,7 @@ export default function ServerModel(
         }
 
         if (event.CustomFlags) {
-            convertCustomFlags(event, dto as IServerDTO);
+            convertCustomFlags(event, dto as IServerV2DTO);
         }
 
         if (event.EventDataType === MessageType.Commerce) {
@@ -467,7 +467,9 @@ export default function ServerModel(
             // TODO: If Cart is deprecated, we should deprecate this too
             if (event.ShoppingCart) {
                 dto.sc = {
-                    pl: convertProductListToDTO(event.ShoppingCart.ProductList),
+                    pl: convertProductListToV2DTO(
+                        event.ShoppingCart.ProductList
+                    ),
                 };
             }
 
@@ -478,7 +480,7 @@ export default function ServerModel(
                         event.ProductAction.CheckoutStep
                     ),
                     co: event.ProductAction.CheckoutOptions,
-                    pl: convertProductListToDTO(
+                    pl: convertProductListToV2DTO(
                         event.ProductAction.ProductList
                     ),
                     ti: event.ProductAction.TransactionId,
@@ -512,7 +514,7 @@ export default function ServerModel(
                 dto.pi = event.ProductImpressions.map(function(impression) {
                     return {
                         pil: impression.ProductImpressionList,
-                        pl: convertProductListToDTO(impression.ProductList),
+                        pl: convertProductListToV2DTO(impression.ProductList),
                     };
                 });
             }
@@ -520,6 +522,6 @@ export default function ServerModel(
             dto.pet = event.ProfileMessageType;
         }
 
-        return dto as IServerDTO;
+        return dto as IServerV2DTO;
     };
 }

package/src/store.ts

@@ -23,7 +23,7 @@ import {
     SDKProduct,
 } from './sdkRuntimeModels';
 import { isNumber, isDataPlanSlug, Dictionary } from './utils';
-import { SDKConsentState } from './consent.interfaces';
+import { SDKConsentState } from './consent';
 
 // This represents the runtime configuration of the SDK AFTER
 // initialization has been complete and all settings and
@@ -219,9 +219,10 @@ export default function Store(
             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;
         }

package/src/vault.ts

@@ -0,0 +1,141 @@
+import { Logger } from '@mparticle/web-sdk';
+import { Dictionary, isEmpty } from './utils';
+
+interface IVaultOptions {
+    logger?: Logger;
+    offlineStorageEnabled?: boolean;
+}
+
+export default class Vault<StorableItem extends Dictionary> {
+    public contents: Dictionary<StorableItem>;
+    private readonly _storageKey: string;
+    private readonly _itemKey: keyof StorableItem;
+    private logger?: Logger;
+    private offlineStorageEnabled: boolean = false;
+
+    /**
+     *
+     * @param {string} storageKey the local storage key string
+     * @param {string} itemKey an element within your StorableItem to use as a key
+     * @param {IVaultOptions} options A Dictionary of IVaultOptions
+     */
+    constructor(
+        storageKey: string,
+        itemKey: keyof StorableItem,
+        options?: IVaultOptions
+    ) {
+        this._storageKey = storageKey;
+        this._itemKey = itemKey;
+        this.contents = this.getItems() || {};
+
+        this.offlineStorageEnabled = options?.offlineStorageEnabled;
+
+        // Add a fake logger in case one is not provided or needed
+        this.logger = options?.logger || {
+            verbose: () => {},
+            warning: () => {},
+            error: () => {},
+        };
+    }
+
+    /**
+     * Stores a single Item using `itemId` as an index
+     * @method storeItem
+     * @param item {StorableItem} a Dictonary with key to store
+     */
+    public storeItem(item: StorableItem): void {
+        this.contents = this.getItems();
+
+        if (item[this._itemKey]) {
+            this.contents[item[this._itemKey]] = item;
+            this.logger.verbose(
+                `Saved items to vault with key: ${item[this._itemKey]}`
+            );
+        }
+
+        this.saveItems(this.contents);
+    }
+
+    /**
+     * Stores Items using `itemId` as an index
+     * @method storeItems
+     * @param {StorableItem[]} an Array of StorableItems
+     */
+    public storeItems(items: StorableItem[]): void {
+        items.forEach((item) => this.storeItem(item));
+    }
+
+    /**
+     * Removes a single StorableItem based on `indexId`
+     * @method removeItem
+     * @param {String} indexId
+     */
+    public removeItem(indexId: string): void {
+        this.logger.verbose(`Removing from vault: ${indexId}`);
+        this.contents = this.getItems() || {};
+
+        try {
+            delete this.contents[indexId];
+
+            this.saveItems(this.contents);
+        } catch (error) {
+            this.logger.error(
+                `Unable to remove item without a matching ID ${indexId}`
+            );
+            this.logger.error(error as string);
+        }
+    }
+
+    /**
+     * Retrieves all StorableItems from local storage as an array
+     * @method retrieveItems
+     * @returns {StorableItem[]} an array of Items
+     */
+    public retrieveItems(): StorableItem[] {
+        this.contents = this.getItems();
+
+        return Object.keys(this.contents).map((item) => this.contents[item]);
+    }
+
+    /**
+     * Removes all persisted data from local storage based on this vault's `key`
+     * @method purge
+     */
+    public purge(): void {
+        this.contents = {};
+        this.removeItems();
+    }
+
+    private saveItems(items: Dictionary<StorableItem>): void {
+        if (!this.offlineStorageEnabled) {
+            return;
+        }
+        try {
+            window.localStorage.setItem(
+                this._storageKey,
+                !isEmpty(items) ? JSON.stringify(items) : ''
+            );
+        } catch (error) {
+            this.logger.error(`Cannot Save items to Local Storage: ${items}`);
+            this.logger.error(error as string);
+        }
+    }
+
+    private getItems(): Dictionary<StorableItem> {
+        if (!this.offlineStorageEnabled) {
+            return this.contents;
+        }
+        // TODO: Handle cases where Local Storage is unavailable
+        // https://go.mparticle.com/work/SQDSDKS-5022
+        const itemString = window.localStorage.getItem(this._storageKey);
+
+        return itemString ? JSON.parse(itemString) : {};
+    }
+
+    private removeItems(): void {
+        if (!this.offlineStorageEnabled) {
+            return;
+        }
+        window.localStorage.removeItem(this._storageKey);
+    }
+}

package/src/consent.interfaces.ts

@@ -1,89 +0,0 @@
-// TODO: Migrate this to Consent.ts when that is created
-import { ConsentState, PrivacyConsentState } from '@mparticle/web-sdk';
-
-export interface IGDPRConsentObject {
-    purpose: string;
-}
-
-export interface ICCPAConsentObject {
-    purpose: string;
-}
-
-export interface IConsentJSONObject {
-    gdpr?: Partial<IGDPRConsentObject>;
-    ccpa?: Partial<ICCPAConsentObject>;
-}
-
-interface ICreatePrivacyConsentFunction {
-    (
-        consented: boolean,
-        timestamp?: number,
-        consentDocument?: string,
-        location?: string,
-        hardwareId?: string
-    ): PrivacyConsentState | null;
-}
-
-// TODO: Refactor this with Consent Namespace in @types/mparticle-web-sdk
-//       https://go.mparticle.com/work/SQDSDKS-5009
-export interface SDKConsentApi {
-    createGDPRConsent: ICreatePrivacyConsentFunction;
-    createCCPAConsent: ICreatePrivacyConsentFunction;
-    createConsentState: (consentState?: ConsentState) => ConsentState;
-    ConsentSerialization: IConsentSerialization;
-    createPrivacyConsent: ICreatePrivacyConsentFunction;
-}
-
-export interface IConsentSerialization {
-    toMinifiedJsonObject: (state: ConsentState) => IConsentJSONObject;
-    fromMinifiedJsonObject: (json: IConsentJSONObject) => ConsentState;
-}
-
-// TODO: Resolve discrepency between ConsentState and SDKConsentState
-//       https://go.mparticle.com/work/SQDSDKS-5009
-export interface SDKConsentState
-    extends Omit<ConsentState, 'getGDPRConsentState' | 'getCCPAConsentState'> {
-    getGDPRConsentState(): SDKGDPRConsentState;
-    getCCPAConsentState(): SDKCCPAConsentState;
-}
-
-export interface SDKGDPRConsentState {
-    [key: string]: SDKConsentStateData;
-}
-
-// TODO: Resolve discrepency between ConsentState and SDKConsentState
-//       https://go.mparticle.com/work/SQDSDKS-5009
-//       Specifically PrivacyConsentState, GDPRConsentState and CCPAConsentState
-//       Treat all attributes as required, but we had to override this
-//       to be optional for a bugfix:
-//       https://github.com/mParticle/mparticle-web-sdk/commit/3b11ead79f25b417737442a4fabd6435750f46b8
-export interface SDKConsentStateData {
-    Consented: boolean;
-    Timestamp?: number;
-    ConsentDocument?: string;
-    Location?: string;
-    HardwareId?: string;
-}
-
-export interface SDKCCPAConsentState extends SDKConsentStateData {}
-
-export interface IPrivacyV2DTO {
-    c: boolean; // Consented
-    ts: number; // Timestamp
-    d: string; // Document
-    l: string; // Location
-    h: string; // HardwareID
-}
-
-export interface IGDPRConsentStateDTO {
-    [key: string]: IPrivacyV2DTO;
-}
-
-export interface ICCPAConsentStateDTO {
-    data_sale_opt_out: IPrivacyV2DTO;
-}
-
-export interface IConsentStateDTO {
-    gdpr?: IGDPRConsentStateDTO;
-    ccpa?: ICCPAConsentStateDTO;
-}