refactor: remove identity cache privacy control dependencies

Author: jaissica12

src/constants.ts

@@ -236,11 +236,10 @@ export const HTTP_SERVER_ERROR = 500 as const;
 
 export type PrivacyControl = 'functional' | 'targeting';
 
-export type StorageTypes = 'SDKState' | 'OfflineEvents' | 'IdentityCache' | 'TimeOnSite';
+export type StorageTypes = 'SDKState' | 'OfflineEvents' | 'TimeOnSite';
 
 export const StoragePrivacyMap: Record<StorageTypes, PrivacyControl> = {
     SDKState: 'functional',
     OfflineEvents: 'functional',
-    IdentityCache: 'functional',
     TimeOnSite: 'targeting',
 };

src/mp-instance.ts

@@ -37,7 +37,7 @@ import KitBlocker from './kitBlocking';
 import ConfigAPIClient, { IKitConfigs } from './configAPIClient';
 import IdentityAPIClient from './identityApiClient';
 import { isFunction, parseConfig, valueof, generateDeprecationMessage } from './utils';
-import { DisabledVault, LocalStorageVault } from './vault';
+import { LocalStorageVault } from './vault';
 import { removeExpiredIdentityCacheDates } from './identity-utils';
 import IntegrationCapture from './integrationCapture';
 import { IPreInit, processReadyQueue } from './pre-init-utils';
@@ -1543,11 +1543,9 @@ function createKitBlocker(config, mpInstance) {
 }
 
 function createIdentityCache(mpInstance) {
-    const cacheKey = `${mpInstance._Store.storageName}-id-cache`;
-    if (mpInstance._Store.getPrivacyFlag('IdentityCache')) {
-        return new DisabledVault(cacheKey, { logger: mpInstance.Logger });
-    }
-    return new LocalStorageVault(cacheKey, { logger: mpInstance.Logger });
+    return new LocalStorageVault(`${mpInstance._Store.storageName}-id-cache`, {
+        logger: mpInstance.Logger,
+    });
 }
 
 function runPreConfigFetchInitialization(mpInstance, apiKey, config) {

src/vault.ts

@@ -102,20 +102,4 @@ export class SessionStorageVault<StorableItem> extends BaseVault<StorableItem> {
     constructor(storageKey: string, options?: IVaultOptions) {
         super(storageKey, window.sessionStorage, options);
     }
-}
-
-// DisabledVault is used when persistence is disabled by privacy flags.
-export class DisabledVault<StorableItem> extends BaseVault<StorableItem> {
-    constructor(storageKey: string, options?: IVaultOptions) {
-        super(storageKey, window.localStorage, options);
-        this.contents = null;
-    }
-
-    public store(_item: StorableItem): void {
-        this.contents = null;
-    }
-
-    public retrieve(): StorableItem | null {
-        return this.contents;
-    }
 }

test/src/tests-identity.ts

@@ -643,35 +643,6 @@ describe('identity', function() {
         });
     });
 
-    describe('privacy flags', function() {
-        beforeEach(function() {
-            mParticle.config.flags.cacheIdentity = 'True';
-            localStorage.clear();
-        });
-
-        describe('#createIdentityCache', function() {
-            it('should save id cache to local storage when noFunctional is false by default', async () => {
-                mParticle.init(apiKey, window.mParticle.config);
-                await waitForCondition(hasIdentifyReturned);
-                expect(localStorage.getItem('mprtcl-v4_abcdef-id-cache')).to.be.ok;
-            });
-
-            it('should NOT save id cache to local storage when noFunctional is true', async () => {
-                mParticle.config.launcherOptions = { noFunctional: true };
-                mParticle.init(apiKey, window.mParticle.config);
-                await waitForCondition(hasIdentifyReturned);
-                expect(localStorage.getItem('mprtcl-v4_abcdef-id-cache')).not.to.be.ok;
-            });
-
-            it('should save id cache to local storage when noFunctional is false', async () => {
-                mParticle.config.launcherOptions = { noFunctional: false };
-                mParticle.init(apiKey, window.mParticle.config);
-                await waitForCondition(hasIdentifyReturned);
-                expect(localStorage.getItem('mprtcl-v4_abcdef-id-cache')).to.be.ok;
-            });
-        });
-    });
-
     it('should respect consent rules on consent-change', async () => {
         await waitForCondition(hasIdentityCallInflightReturned);
         mParticle._resetForTests(MPConfig);

test/src/vault.spec.ts

@@ -1,7 +1,7 @@
 import { Batch } from '@mparticle/event-models';
 import { expect } from 'chai';
 import { Dictionary } from '../../src/utils';
-import { SessionStorageVault, LocalStorageVault, DisabledVault } from '../../src/vault';
+import { SessionStorageVault, LocalStorageVault } from '../../src/vault';
 
 const testObject: Dictionary<Dictionary<string>> = {
     foo: { foo: 'bar', buzz: 'bazz' },
@@ -419,76 +419,4 @@ describe('Vault', () => {
             );
         });
     });
-
-    describe('DisabledVault', () => {
-        afterEach(() => {
-            window.localStorage.clear();
-        });
-
-        describe('#store', () => {
-            it('should NOT write to localStorage', () => {
-                const storageKey = 'test-disabled-store-empty';
-                const vault = new DisabledVault<string>(storageKey);
-
-                vault.store('testString');
-
-                expect(vault.contents).to.equal(null);
-                expect(window.localStorage.getItem(storageKey)).to.equal(null);
-            });
-
-            it('should NOT overwrite existing localStorage value and keep contents null', () => {
-                const storageKey = 'test-disabled-store-existing';
-                window.localStorage.setItem(storageKey, 'existingItem');
-
-                const vault = new DisabledVault<string>(storageKey);
-
-                vault.store('newValue');
-
-                expect(vault.contents).to.equal(null);
-                expect(window.localStorage.getItem(storageKey)).to.equal('existingItem');
-            });
-        });
-
-        describe('#retrieve', () => {
-            it('should return null when nothing is stored', () => {
-                const storageKey = 'test-disabled-retrieve-empty';
-                const vault = new DisabledVault<string>(storageKey);
-                const retrievedItem = vault.retrieve();
-                expect(retrievedItem).to.equal(null);
-            });
-
-            it('should return null even if localStorage has a value', () => {
-                const storageKey = 'test-disabled-retrieve-existing';
-                window.localStorage.setItem(storageKey, 'existingItem');
-
-                const vault = new DisabledVault<string>(storageKey);
-                const retrievedItem = vault.retrieve();
-                expect(retrievedItem).to.equal(null);
-                expect(window.localStorage.getItem(storageKey)).to.equal('existingItem');
-            });
-        });
-
-        describe('#purge', () => {
-            it('should keep contents null when purging', () => {
-                const storageKey = 'test-disabled-purge-existing';
-                window.localStorage.setItem(storageKey, 'existing');
-
-                const vault = new DisabledVault<string>(storageKey);
-
-                vault.purge();
-
-                expect(vault.contents).to.equal(null);
-                expect(window.localStorage.getItem(storageKey)).to.equal(null);
-            });
-
-            it('should keep contents null when purging an empty key', () => {
-                const storageKey = 'test-disabled-purge-empty';
-                const vault = new DisabledVault<string>(storageKey);
-
-                vault.purge();
-                expect(vault.contents).to.equal(null);
-                expect(window.localStorage.getItem(storageKey)).to.equal(null);
-            });
-        });
-    });
 });