Consent & local storage config flag

sandbox/src/components/InAppMessagesDemo/InAppMessages.js

@@ -40,8 +40,14 @@ const {
   alloyInstance
 } = config[configKey];
 
+const getURLParams = key => {
+  const urlParams = new URLSearchParams(window.location.search);
+  return urlParams.get(key);
+};
+
 if (alloyInstance !== window.alloy) {
   alloyInstance("configure", {
+    defaultConsent: getURLParams("defaultConsent") || "in",
     datastreamId,
     orgId,
     edgeDomain,

src/components/DecisioningEngine/createEventRegistry.js

@@ -46,14 +46,24 @@ export const createEventPruner = (
 };
 
 export default ({ storage }) => {
-  const restore = createRestoreStorage(storage, STORAGE_KEY);
-  const save = createSaveStorage(
-    storage,
-    STORAGE_KEY,
-    createEventPruner(MAX_EVENT_RECORDS, RETENTION_PERIOD)
-  );
-
-  const events = restore({});
+  let currentStorage = storage;
+  let restore;
+  let save;
+  let events;
+  const setStorage = newStorage => {
+    currentStorage = newStorage;
+
+    restore = createRestoreStorage(currentStorage, STORAGE_KEY);
+    save = createSaveStorage(
+      currentStorage,
+      STORAGE_KEY,
+      createEventPruner(MAX_EVENT_RECORDS, RETENTION_PERIOD)
+    );
+    events = restore({});
+  };
+
+  setStorage(storage);
+
   const addEvent = (event, eventType, eventId, action) => {
     if (!events[eventType]) {
       events[eventType] = {};
@@ -132,5 +142,11 @@ export default ({ storage }) => {
     return events[eventType][eventId];
   };
 
-  return { addExperienceEdgeEvent, addEvent, getEvent, toJSON: () => events };
+  return {
+    addExperienceEdgeEvent,
+    addEvent,
+    getEvent,
+    toJSON: () => events,
+    setStorage
+  };
 };

src/components/DecisioningEngine/index.js

@@ -22,24 +22,33 @@ import {
   MOBILE_EVENT_TYPE
 } from "./constants";
 import createEvaluateRulesetsCommand from "./createEvaluateRulesetsCommand";
+import { clearLocalStorage, createInMemoryStorage } from "./utils";
 
-const createDecisioningEngine = ({ config, createNamespacedStorage }) => {
-  const { orgId } = config;
+const createDecisioningEngine = ({
+  config,
+  createNamespacedStorage,
+  consent
+}) => {
+  const { orgId, personalizationStorageEnabled } = config;
   const storage = createNamespacedStorage(
     `${sanitizeOrgIdForCookieName(orgId)}.decisioning.`
   );
-  const eventRegistry = createEventRegistry({ storage: storage.persistent });
-  let applyResponse;
+  if (!personalizationStorageEnabled) {
+    clearLocalStorage(storage.persistent);
+  }
 
+  const eventRegistry = createEventRegistry({
+    storage: createInMemoryStorage()
+  });
   const decisionProvider = createDecisionProvider({ eventRegistry });
   const contextProvider = createContextProvider({ eventRegistry, window });
 
   const evaluateRulesetsCommand = createEvaluateRulesetsCommand({
     contextProvider,
     decisionProvider
   });
-
   const subscribeRulesetItems = createSubscribeRulesetItems();
+  let applyResponse;
 
   return {
     lifecycle: {
@@ -48,6 +57,18 @@ const createDecisioningEngine = ({ config, createNamespacedStorage }) => {
       },
       onComponentsRegistered(tools) {
         applyResponse = createApplyResponse(tools.lifecycle);
+        if (personalizationStorageEnabled) {
+          consent
+            .awaitConsent()
+            .then(() => {
+              eventRegistry.setStorage(storage.persistent);
+            })
+            .catch(() => {
+              if (storage) {
+                clearLocalStorage(storage.persistent);
+              }
+            });
+        }
       },
       onBeforeEvent({
         event,

src/components/DecisioningEngine/utils.js

@@ -47,3 +47,17 @@ export const getActivityId = proposition => {
 
   return id;
 };
+export const createInMemoryStorage = () => {
+  const inMemoryStorage = {};
+  return {
+    getItem: key => {
+      return key in inMemoryStorage ? inMemoryStorage[key] : null;
+    },
+    setItem: (key, value) => {
+      inMemoryStorage[key] = value;
+    }
+  };
+};
+export const clearLocalStorage = storage => {
+  storage.clear();
+};

src/core/config/createCoreConfigs.js

@@ -38,6 +38,7 @@ export default () =>
     orgId: string()
       .unique()
       .required(),
+    personalizationStorageEnabled: boolean().default(true),
     onBeforeEventSend: callback().default(noop),
     edgeConfigOverrides: validateConfigOverride
   }).deprecated("edgeConfigId", string().unique(), "datastreamId");

test/unit/specs/components/DecisioningEngine/contextTestUtils.js

@@ -129,7 +129,6 @@ export const setupResponseHandler = (applyResponse, window, condition) => {
   ]);
   const eventRegistry = createEventRegistry({ storage });
   const decisionProvider = createDecisionProvider({ eventRegistry });
-
   const contextProvider = createContextProvider({ eventRegistry, window });
 
   const onResponseHandler = createOnResponseHandler({

test/unit/specs/components/DecisioningEngine/createDecisionProvider.spec.js

@@ -20,7 +20,6 @@ describe("DecisioningEngine:createDecisionProvider", () => {
   beforeEach(() => {
     storage = jasmine.createSpyObj("storage", ["getItem", "setItem", "clear"]);
     eventRegistry = createEventRegistry({ storage });
-
     decisionProvider = createDecisionProvider({ eventRegistry });
     decisionProvider.addPayloads([
       {

test/unit/specs/components/DecisioningEngine/createOnResponseHandler.spec.js

@@ -28,7 +28,6 @@ describe("DecisioningEngine:createOnResponseHandler", () => {
 
     storage = jasmine.createSpyObj("storage", ["getItem", "setItem", "clear"]);
     eventRegistry = createEventRegistry({ storage });
-
     decisionProvider = createDecisionProvider({ eventRegistry });
     applyResponse = createApplyResponse(lifecycle);
   });

test/unit/specs/components/DecisioningEngine/index.spec.js

@@ -10,7 +10,7 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 import createDecisioningEngine from "../../../../../src/components/DecisioningEngine/index";
-import { injectStorage } from "../../../../../src/utils";
+import { defer, injectStorage } from "../../../../../src/utils";
 import {
   mockRulesetResponseWithCondition,
   proposition
@@ -21,15 +21,26 @@ describe("createDecisioningEngine:commands:evaluateRulesets", () => {
   let mockEvent;
   let onResponseHandler;
   let decisioningEngine;
-  beforeEach(() => {
+  let awaitConsentDeferred;
+  let consent;
+
+  beforeEach(async () => {
     mergeData = jasmine.createSpy();
-    const config = { orgId: "exampleOrgId" };
+    awaitConsentDeferred = defer();
+    consent = jasmine.createSpyObj("consent", {
+      awaitConsent: awaitConsentDeferred.promise
+    });
+    const config = {
+      orgId: "exampleOrgId",
+      personalizationStorageEnabled: true
+    };
     window.referrer =
       "https://www.google.com/search?q=adobe+journey+optimizer&oq=adobe+journey+optimizer";
     const createNamespacedStorage = injectStorage(window);
     decisioningEngine = createDecisioningEngine({
       config,
-      createNamespacedStorage
+      createNamespacedStorage,
+      consent
     });
     mockEvent = {
       getContent: () => ({}),
@@ -38,6 +49,7 @@ describe("createDecisioningEngine:commands:evaluateRulesets", () => {
       mergeData
     };
     decisioningEngine.lifecycle.onComponentsRegistered(() => {});
+    await awaitConsentDeferred.resolve();
   });
 
   it("should run the evaluateRulesets command and satisfy the rule based on global context", () => {

test/unit/specs/components/DecisioningEngine/utils.spec.js

@@ -10,6 +10,7 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 import {
+  createInMemoryStorage,
   createRestoreStorage,
   createSaveStorage,
   getActivityId,
@@ -18,9 +19,11 @@ import {
 
 describe("DecisioningEngine:utils", () => {
   let storage;
+  let inMemoryStorage;
 
   beforeEach(() => {
     storage = jasmine.createSpyObj("storage", ["getItem", "setItem", "clear"]);
+    inMemoryStorage = createInMemoryStorage();
   });
 
   it("restores from storage", () => {
@@ -191,4 +194,27 @@ describe("DecisioningEngine:utils", () => {
     };
     expect(getActivityId(proposition)).toEqual(undefined);
   });
+  it("should set and retrieve an item from in-memory storage", () => {
+    const key = "testKey";
+    const value = "testValue";
+    inMemoryStorage.setItem(key, value);
+    const retrievedValue = inMemoryStorage.getItem(key);
+    expect(retrievedValue).toEqual(value);
+  });
+
+  it("should return null for a non-existent item", () => {
+    const key = "nonExistentKey";
+    const retrievedValue = inMemoryStorage.getItem(key);
+    expect(retrievedValue).toBeNull();
+  });
+
+  it("should overwrite the value for an existing key", () => {
+    const key = "existingKey";
+    const originalValue = "originalValue";
+    const updatedValue = "updatedValue";
+    inMemoryStorage.setItem(key, originalValue);
+    inMemoryStorage.setItem(key, updatedValue);
+    const retrievedValue = inMemoryStorage.getItem(key);
+    expect(retrievedValue).toEqual(updatedValue);
+  });
 });