@adobe/alloy 2.19.0-beta.9 → 2.19.1-beta.0

package/libEs6/components/DecisioningEngine/createEventRegistry.js

@@ -0,0 +1,120 @@
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+import { createRestoreStorage, createSaveStorage, getExpirationDate, getActivityId, hasExperienceData, getDecisionProvider } from "./utils";
+import { EVENT_TYPE_TRUE } from "../../constants/eventType";
+import { ADOBE_JOURNEY_OPTIMIZER } from "../../constants/decisionProvider";
+const STORAGE_KEY = "events";
+const MAX_EVENT_RECORDS = 1000;
+const RETENTION_PERIOD = 30;
+const prefixed = key => `iam.${key}`;
+export const createEventPruner = (limit = MAX_EVENT_RECORDS, retentionPeriod = RETENTION_PERIOD) => {
+  return events => {
+    const pruned = {};
+    Object.keys(events).forEach(eventType => {
+      pruned[eventType] = {};
+      Object.values(events[eventType]).filter(entry => new Date(entry.firstTimestamp) >= getExpirationDate(retentionPeriod)).sort((a, b) => a.firstTimestamp - b.firstTimestamp).slice(-1 * limit).forEach(entry => {
+        pruned[eventType][entry.event[prefixed("id")]] = entry;
+      });
+    });
+    return pruned;
+  };
+};
+export default (({
+  storage
+}) => {
+  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 (!eventType || !eventId) {
+      return undefined;
+    }
+    if (!events[eventType]) {
+      events[eventType] = {};
+    }
+    const existingEvent = events[eventType][eventId];
+    const count = existingEvent ? existingEvent.count : 0;
+    const timestamp = new Date().getTime();
+    const firstTimestamp = existingEvent ? existingEvent.firstTimestamp || existingEvent.timestamp : timestamp;
+    events[eventType][eventId] = {
+      event: {
+        ...event,
+        [prefixed("id")]: eventId,
+        [prefixed("eventType")]: eventType,
+        [prefixed("action")]: action
+      },
+      firstTimestamp,
+      timestamp,
+      count: count + 1
+    };
+    save(events);
+    return events[eventType][eventId];
+  };
+  const addExperienceEdgeEvent = event => {
+    const {
+      xdm = {}
+    } = event.getContent();
+    const {
+      _experience
+    } = xdm;
+    if (!hasExperienceData(xdm)) {
+      return;
+    }
+    const {
+      decisioning = {}
+    } = _experience;
+    const {
+      propositionEventType: propositionEventTypeObj = {},
+      propositionAction = {},
+      propositions = []
+    } = decisioning;
+    const propositionEventTypesList = Object.keys(propositionEventTypeObj);
+
+    // https://wiki.corp.adobe.com/pages/viewpage.action?spaceKey=CJM&title=Proposition+Event+Types
+    if (propositionEventTypesList.length === 0) {
+      return;
+    }
+    const validPropositionEventType = propositionEventType => propositionEventTypeObj[propositionEventType] === EVENT_TYPE_TRUE;
+    const {
+      id: action
+    } = propositionAction;
+    propositionEventTypesList.filter(validPropositionEventType).forEach(propositionEventType => {
+      propositions.forEach(proposition => {
+        if (getDecisionProvider(proposition) !== ADOBE_JOURNEY_OPTIMIZER) {
+          return;
+        }
+        addEvent({}, propositionEventType, getActivityId(proposition), action);
+      });
+    });
+  };
+  const getEvent = (eventType, eventId) => {
+    if (!events[eventType]) {
+      return undefined;
+    }
+    return events[eventType][eventId];
+  };
+  return {
+    addExperienceEdgeEvent,
+    addEvent,
+    getEvent,
+    toJSON: () => events,
+    setStorage
+  };
+});

package/libEs6/components/DecisioningEngine/createOnResponseHandler.js

@@ -0,0 +1,45 @@
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+import { PERSONALIZATION_DECISIONS_HANDLE } from "../../constants/handle";
+import flattenObject from "../../utils/flattenObject";
+export default (({
+  renderDecisions,
+  decisionProvider,
+  applyResponse,
+  event,
+  personalization,
+  decisionContext
+}) => {
+  const context = {
+    ...flattenObject(event.getContent()),
+    ...decisionContext
+  };
+  return ({
+    response
+  }) => {
+    decisionProvider.addPayloads(response.getPayloadsByType(PERSONALIZATION_DECISIONS_HANDLE));
+
+    // only evaluate events that include a personalization query
+    if (!event.hasQuery()) {
+      return {
+        propositions: []
+      };
+    }
+    const propositions = decisionProvider.evaluate(context);
+    return applyResponse({
+      renderDecisions,
+      propositions,
+      event,
+      personalization
+    });
+  };
+});

package/libEs6/components/DecisioningEngine/createSubscribeRulesetItems.js

@@ -0,0 +1,79 @@
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+import { arrayOf, callback as callbackType, objectOf, string } from "../../utils/validation";
+import createSubscription from "../../utils/createSubscription";
+import { includes } from "../../utils";
+const validateOptions = ({
+  options
+}) => {
+  const validator = objectOf({
+    surfaces: arrayOf(string()).uniqueItems(),
+    schemas: arrayOf(string()).uniqueItems(),
+    callback: callbackType().required()
+  }).noUnknownFields();
+  return validator(options);
+};
+const emissionPreprocessor = (params, propositions) => {
+  const {
+    surfacesFilter,
+    schemasFilter
+  } = params;
+  const result = {
+    propositions: propositions.filter(payload => surfacesFilter ? includes(surfacesFilter, payload.scope) : true).map(payload => {
+      const {
+        items = []
+      } = payload;
+      return {
+        ...payload,
+        items: items.filter(item => schemasFilter ? includes(schemasFilter, item.schema) : true)
+      };
+    }).filter(payload => payload.items.length > 0)
+  };
+  return [result];
+};
+const emissionCondition = (params, result) => {
+  return result.propositions.length > 0;
+};
+export default (() => {
+  const subscription = createSubscription();
+  subscription.setEmissionPreprocessor(emissionPreprocessor);
+  subscription.setEmissionCondition(emissionCondition);
+  const run = ({
+    surfaces,
+    schemas,
+    callback
+  }) => {
+    const unsubscribe = subscription.add(callback, {
+      surfacesFilter: surfaces instanceof Array ? surfaces : undefined,
+      schemasFilter: schemas instanceof Array ? schemas : undefined
+    });
+    return Promise.resolve({
+      unsubscribe
+    });
+  };
+  const optionsValidator = options => validateOptions({
+    options
+  });
+  const refresh = propositions => {
+    if (!subscription.hasSubscriptions()) {
+      return;
+    }
+    subscription.emit(propositions);
+  };
+  return {
+    refresh,
+    command: {
+      optionsValidator,
+      run
+    }
+  };
+});

package/libEs6/components/DecisioningEngine/index.js

@@ -0,0 +1,124 @@
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+import { noop, sanitizeOrgIdForCookieName } from "../../utils";
+import createOnResponseHandler from "./createOnResponseHandler";
+import createDecisionProvider from "./createDecisionProvider";
+import createApplyResponse from "./createApplyResponse";
+import createEventRegistry from "./createEventRegistry";
+import createContextProvider from "./createContextProvider";
+import createSubscribeRulesetItems from "./createSubscribeRulesetItems";
+import { CONTEXT_KEY, CONTEXT_EVENT_SOURCE, CONTEXT_EVENT_TYPE } from "./constants";
+import createEvaluateRulesetsCommand from "./createEvaluateRulesetsCommand";
+import { clearLocalStorage, createInMemoryStorage } from "./utils";
+import { objectOf, boolean } from "../../utils/validation";
+const createDecisioningEngine = ({
+  config,
+  createNamespacedStorage,
+  consent
+}) => {
+  const {
+    orgId,
+    personalizationStorageEnabled
+  } = config;
+  const storage = createNamespacedStorage(`${sanitizeOrgIdForCookieName(orgId)}.decisioning.`);
+  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: {
+      onDecision({
+        propositions
+      }) {
+        subscribeRulesetItems.refresh(propositions);
+      },
+      onComponentsRegistered(tools) {
+        applyResponse = createApplyResponse(tools.lifecycle);
+        if (personalizationStorageEnabled) {
+          consent.awaitConsent().then(() => {
+            eventRegistry.setStorage(storage.persistent);
+          }).catch(() => {
+            if (storage) {
+              clearLocalStorage(storage.persistent);
+            }
+          });
+        }
+      },
+      onBeforeEvent({
+        event,
+        renderDecisions,
+        personalization = {},
+        onResponse = noop
+      }) {
+        const {
+          decisionContext = {}
+        } = personalization;
+        onResponse(createOnResponseHandler({
+          renderDecisions,
+          decisionProvider,
+          applyResponse,
+          event,
+          personalization,
+          decisionContext: contextProvider.getContext({
+            [CONTEXT_KEY.TYPE]: CONTEXT_EVENT_TYPE.EDGE,
+            [CONTEXT_KEY.SOURCE]: CONTEXT_EVENT_SOURCE.REQUEST,
+            ...decisionContext
+          })
+        }));
+        eventRegistry.addExperienceEdgeEvent(event);
+      }
+    },
+    commands: {
+      evaluateRulesets: {
+        run: ({
+          renderDecisions,
+          personalization = {}
+        }) => {
+          const {
+            decisionContext = {}
+          } = personalization;
+          return evaluateRulesetsCommand.run({
+            renderDecisions,
+            decisionContext: {
+              [CONTEXT_KEY.TYPE]: CONTEXT_EVENT_TYPE.RULES_ENGINE,
+              [CONTEXT_KEY.SOURCE]: CONTEXT_EVENT_SOURCE.REQUEST,
+              ...decisionContext
+            },
+            applyResponse
+          });
+        },
+        optionsValidator: evaluateRulesetsCommand.optionsValidator
+      },
+      subscribeRulesetItems: subscribeRulesetItems.command
+    }
+  };
+};
+createDecisioningEngine.namespace = "DecisioningEngine";
+createDecisioningEngine.configValidators = objectOf({
+  personalizationStorageEnabled: boolean().default(false)
+});
+export default createDecisioningEngine;

package/libEs6/components/DecisioningEngine/utils.js

@@ -0,0 +1,83 @@
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+export const createRestoreStorage = (storage, storageKey) => {
+  return defaultValue => {
+    const stored = storage.getItem(storageKey);
+    if (!stored) {
+      return defaultValue;
+    }
+    try {
+      return JSON.parse(stored);
+    } catch (e) {
+      return defaultValue;
+    }
+  };
+};
+export const createSaveStorage = (storage, storageKey, prepareFn = value => value) => {
+  return value => {
+    storage.setItem(storageKey, JSON.stringify(prepareFn(value)));
+  };
+};
+export const getExpirationDate = retentionPeriod => {
+  const expirationDate = new Date();
+  expirationDate.setDate(expirationDate.getDate() - retentionPeriod);
+  return expirationDate;
+};
+export const getActivityId = proposition => {
+  const {
+    scopeDetails = {}
+  } = proposition;
+  const {
+    activity = {}
+  } = scopeDetails;
+  const {
+    id
+  } = activity;
+  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();
+};
+export const hasExperienceData = xdm => {
+  const {
+    eventType = "",
+    _experience
+  } = xdm;
+  if (!eventType || eventType === "") {
+    return false;
+  }
+  if (!_experience || typeof _experience !== "object") {
+    return false;
+  }
+  return true;
+};
+export const getDecisionProvider = proposition => {
+  const {
+    scopeDetails = {}
+  } = proposition;
+  const {
+    decisionProvider
+  } = scopeDetails;
+  return decisionProvider;
+};

package/libEs6/components/Personalization/createActionsProvider.js

@@ -0,0 +1,70 @@
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+import createPreprocessors from "./createPreprocessors";
+import { assign } from "../../utils";
+export default (({
+  modules,
+  preprocessors = createPreprocessors(),
+  logger
+}) => {
+  const logActionError = (action, error) => {
+    if (logger.enabled) {
+      const details = JSON.stringify(action);
+      const {
+        message,
+        stack
+      } = error;
+      const errorMessage = `Failed to execute action ${details}. ${message} ${stack ? `\n ${stack}` : ""}`;
+      logger.warn(errorMessage);
+    }
+  };
+  const logActionCompleted = action => {
+    if (logger.enabled) {
+      const details = JSON.stringify(action);
+      logger.info(`Action ${details} executed.`);
+    }
+  };
+  const getExecuteAction = (schema, type) => {
+    if (!modules[schema] || !modules[schema][type]) {
+      return () => Promise.reject(new Error(`Action "${type}" not found for schema "${schema}"`));
+    }
+    return modules[schema][type];
+  };
+  const applyPreprocessors = action => {
+    const {
+      schema
+    } = action;
+    const preprocessorsList = preprocessors[schema];
+    if (!schema || !(preprocessorsList instanceof Array) || preprocessorsList.length === 0) {
+      return action;
+    }
+    return preprocessorsList.reduce((processed, fn) => assign(processed, fn(processed)), action);
+  };
+  const executeAction = action => {
+    const processedAction = applyPreprocessors(action);
+    const {
+      type,
+      schema
+    } = processedAction;
+    const execute = getExecuteAction(schema, type);
+    return execute(processedAction).then(result => {
+      logActionCompleted(processedAction);
+      return result;
+    }).catch(error => {
+      logActionError(processedAction, error);
+      throw error;
+    });
+  };
+  return {
+    executeAction
+  };
+});

package/libEs6/components/Personalization/createApplyPropositions.js

@@ -11,9 +11,9 @@ governing permissions and limitations under the License.
 */
 
 import { isNonEmptyArray, isObject, defer } from "../../utils";
-import { DOM_ACTION, HTML_CONTENT_ITEM } from "./constants/schema";
+import { DOM_ACTION, HTML_CONTENT_ITEM, MESSAGE_IN_APP } from "../../constants/schema";
 import PAGE_WIDE_SCOPE from "../../constants/pageWideScope";
-const SUPPORTED_SCHEMAS = [DOM_ACTION, HTML_CONTENT_ITEM];
+const SUPPORTED_SCHEMAS = [DOM_ACTION, HTML_CONTENT_ITEM, MESSAGE_IN_APP];
 export default (({
   processPropositions,
   createProposition,

package/libEs6/components/Personalization/createCollect.js

@@ -9,8 +9,8 @@ the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTA
 OF ANY KIND, either express or implied. See the License for the specific language
 governing permissions and limitations under the License.
 */
-import { DISPLAY } from "./constants/eventType";
-import { PropositionEventType } from "./constants/propositionEventType";
+import { DISPLAY } from "../../constants/eventType";
+import { getPropositionEventType } from "../../constants/propositionEventType";
 import { isNonEmptyArray } from "../../utils";
 export default (({
   eventManager,
@@ -19,12 +19,15 @@ export default (({
   // Called when a decision is auto-rendered for the __view__ scope or a SPA view(display and empty display notification)
   return ({
     decisionsMeta = [],
+    propositionAction,
     documentMayUnload = false,
+    eventType = DISPLAY,
+    propositionEventTypes = [getPropositionEventType(eventType)],
     viewName
   }) => {
     const event = eventManager.createEvent();
     const data = {
-      eventType: DISPLAY
+      eventType
     };
     if (viewName) {
       data.web = {
@@ -34,7 +37,7 @@ export default (({
       };
     }
     if (isNonEmptyArray(decisionsMeta)) {
-      mergeDecisionsMeta(event, decisionsMeta, PropositionEventType.DISPLAY);
+      mergeDecisionsMeta(event, decisionsMeta, propositionEventTypes, propositionAction);
     }
     event.mergeXdm(data);
     if (documentMayUnload) {

package/libEs6/components/Personalization/createComponent.js

@@ -13,8 +13,8 @@ governing permissions and limitations under the License.
 import { noop, flatMap, isNonEmptyArray } from "../../utils";
 import createPersonalizationDetails from "./createPersonalizationDetails";
 import { AUTHORING_ENABLED } from "./constants/loggerMessage";
+import { PropositionEventType } from "../../constants/propositionEventType";
 import validateApplyPropositionsOptions from "./validateApplyPropositionsOptions";
-import { PropositionEventType } from "./constants/propositionEventType";
 export default (({
   getPageLocation,
   logger,
@@ -28,10 +28,12 @@ export default (({
   applyPropositions,
   setTargetMigration,
   mergeDecisionsMeta,
-  renderedPropositions
+  renderedPropositions,
+  onDecisionHandler
 }) => {
   return {
     lifecycle: {
+      onDecision: onDecisionHandler,
       onBeforeRequest({
         request
       }) {
@@ -100,7 +102,7 @@ export default (({
           // from two places: the pending display notifications and the view change handler.
           const decisionsMeta = flatMap(decisionsMetas, dms => dms);
           if (isNonEmptyArray(decisionsMeta)) {
-            mergeDecisionsMeta(event, decisionsMeta, PropositionEventType.DISPLAY);
+            mergeDecisionsMeta(event, decisionsMeta, [PropositionEventType.DISPLAY]);
           }
         });
       },

package/libEs6/components/Personalization/createFetchDataHandler.js

@@ -9,17 +9,16 @@ the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTA
 OF ANY KIND, either express or implied. See the License for the specific language
 governing permissions and limitations under the License.
 */
-import { defer, groupBy } from "../../utils";
+import { groupBy } from "../../utils";
 const DECISIONS_HANDLE = "personalization:decisions";
 export default (({
   prehidingStyle,
   showContainers,
   hideContainers,
   mergeQuery,
-  collect,
   processPropositions,
   createProposition,
-  renderedPropositions
+  notificationHandler
 }) => {
   return ({
     cacheUpdate,
@@ -33,21 +32,7 @@ export default (({
       showContainers();
     }
     mergeQuery(event, personalizationDetails.createQueryDetails());
-    let handleNotifications;
-    if (personalizationDetails.isSendDisplayEvent()) {
-      handleNotifications = decisionsMeta => {
-        if (decisionsMeta.length > 0) {
-          collect({
-            decisionsMeta,
-            viewName: personalizationDetails.getViewName()
-          });
-        }
-      };
-    } else {
-      const renderedPropositionsDeferred = defer();
-      renderedPropositions.concat(renderedPropositionsDeferred.promise);
-      handleNotifications = renderedPropositionsDeferred.resolve;
-    }
+    const handleNotifications = notificationHandler(personalizationDetails.isSendDisplayEvent(), personalizationDetails.getViewName());
     onResponse(({
       response
     }) => {

package/libEs6/components/Personalization/createNotificationHandler.js

@@ -0,0 +1,29 @@
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+import { defer } from "../../utils";
+export default ((collect, renderedPropositions) => {
+  return (sendDisplayEvent, viewName) => {
+    if (!sendDisplayEvent) {
+      const renderedPropositionsDeferred = defer();
+      renderedPropositions.concat(renderedPropositionsDeferred.promise);
+      return renderedPropositionsDeferred.resolve;
+    }
+    return decisionsMeta => {
+      if (decisionsMeta.length > 0) {
+        collect({
+          decisionsMeta,
+          viewName
+        });
+      }
+    };
+  };
+});