@adobe/alloy 2.19.0-beta.10 → 2.19.0-beta.12

package/libEs6/components/DecisioningEngine/index.js

@@ -0,0 +1,119 @@
+/*
+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";
+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,
+          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";
+export default createDecisioningEngine;

package/libEs6/components/DecisioningEngine/utils.js

@@ -0,0 +1,74 @@
+/*
+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;
+};

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/createOnClickHandler.js

@@ -11,8 +11,8 @@ governing permissions and limitations under the License.
 */
 
 import { isNonEmptyArray } from "../../utils";
-import { INTERACT } from "./constants/eventType";
-import { PropositionEventType } from "./constants/propositionEventType";
+import { INTERACT } from "../../constants/eventType";
+import { PropositionEventType } from "../../constants/propositionEventType";
 export default (({
   mergeDecisionsMeta,
   collectClicks,
@@ -43,7 +43,9 @@ export default (({
           };
         }
         event.mergeXdm(xdm);
-        mergeDecisionsMeta(event, decisionsMeta, PropositionEventType.INTERACT, eventLabel);
+        mergeDecisionsMeta(event, decisionsMeta, [PropositionEventType.INTERACT], eventLabel ? {
+          label: eventLabel
+        } : undefined);
       }
     }
   };

package/libEs6/components/Personalization/createOnDecisionHandler.js

@@ -0,0 +1,43 @@
+/*
+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 default (({
+  processPropositions,
+  createProposition,
+  collect
+}) => {
+  return ({
+    viewName,
+    renderDecisions,
+    propositions
+  }) => {
+    if (!renderDecisions) {
+      return Promise.resolve();
+    }
+    const propositionsToExecute = propositions.map(proposition => createProposition(proposition, true));
+    const {
+      render,
+      returnedPropositions
+    } = processPropositions(propositionsToExecute);
+    render().then(decisionsMeta => {
+      if (decisionsMeta.length > 0) {
+        collect({
+          decisionsMeta,
+          viewName
+        });
+      }
+    });
+    return Promise.resolve({
+      propositions: returnedPropositions
+    });
+  };
+});

package/libEs6/components/Personalization/createPersonalizationDetails.js

@@ -13,7 +13,7 @@ governing permissions and limitations under the License.
 import { includes, isNonEmptyString, isNonEmptyArray } from "../../utils";
 import { buildPageSurface, normalizeSurfaces } from "./utils/surfaceUtils";
 import PAGE_WIDE_SCOPE from "../../constants/pageWideScope";
-import { DEFAULT_CONTENT_ITEM, DOM_ACTION, HTML_CONTENT_ITEM, JSON_CONTENT_ITEM, REDIRECT_ITEM } from "./constants/schema";
+import { DEFAULT_CONTENT_ITEM, DOM_ACTION, HTML_CONTENT_ITEM, MESSAGE_IN_APP, JSON_CONTENT_ITEM, REDIRECT_ITEM, RULESET_ITEM, MESSAGE_FEED_ITEM } from "../../constants/schema";
 const addPageWideScope = scopes => {
   if (!includes(scopes, PAGE_WIDE_SCOPE)) {
     scopes.push(PAGE_WIDE_SCOPE);
@@ -68,7 +68,7 @@ export default (({
         addPageWideScope(scopes);
         addPageSurface(eventSurfaces, getPageLocation);
       }
-      const schemas = [DEFAULT_CONTENT_ITEM, HTML_CONTENT_ITEM, JSON_CONTENT_ITEM, REDIRECT_ITEM];
+      const schemas = [DEFAULT_CONTENT_ITEM, HTML_CONTENT_ITEM, JSON_CONTENT_ITEM, REDIRECT_ITEM, RULESET_ITEM, MESSAGE_IN_APP, MESSAGE_FEED_ITEM];
       if (includes(scopes, PAGE_WIDE_SCOPE)) {
         schemas.push(DOM_ACTION);
       }

package/libEs6/components/Personalization/createPreprocessors.js

@@ -0,0 +1,19 @@
+/*
+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 { DOM_ACTION } from "../../constants/schema";
+import remapHeadOffers from "./dom-actions/remapHeadOffers";
+import remapCustomCodeOffers from "./dom-actions/remapCustomCodeOffers";
+export default (() => {
+  return {
+    [DOM_ACTION]: [remapHeadOffers, remapCustomCodeOffers]
+  };
+});

package/libEs6/components/Personalization/createViewCacheManager.js

@@ -12,7 +12,7 @@ governing permissions and limitations under the License.
 
 import { groupBy } from "../../utils";
 import defer from "../../utils/defer";
-import { DEFAULT_CONTENT_ITEM } from "./constants/schema";
+import { DEFAULT_CONTENT_ITEM } from "../../constants/schema";
 import { VIEW_SCOPE_TYPE } from "./constants/scopeType";
 export default (({
   createProposition

package/libEs6/components/Personalization/event.js

@@ -10,24 +10,29 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 
-const EVENT_TYPE_TRUE = 1;
+import { EVENT_TYPE_TRUE } from "../../constants/eventType";
 
 /* eslint-disable no-underscore-dangle */
-export const mergeDecisionsMeta = (event, decisionsMeta, eventType, eventLabel = "") => {
+export const mergeDecisionsMeta = (event, decisionsMeta, propositionEventTypes, propositionAction) => {
+  // Do not send a display notification with no decisions. Even empty view changes
+  // should include a proposition.
+  if (decisionsMeta.length === 0) {
+    return;
+  }
+  const propositionEventType = {};
+  propositionEventTypes.forEach(type => {
+    propositionEventType[type] = EVENT_TYPE_TRUE;
+  });
   const xdm = {
     _experience: {
       decisioning: {
         propositions: decisionsMeta,
-        propositionEventType: {
-          [eventType]: EVENT_TYPE_TRUE
-        }
+        propositionEventType
       }
     }
   };
-  if (eventLabel) {
-    xdm._experience.decisioning.propositionAction = {
-      label: eventLabel
-    };
+  if (propositionAction) {
+    xdm._experience.decisioning.propositionAction = propositionAction;
   }
   event.mergeXdm(xdm);
 };

package/libEs6/components/Personalization/handlers/createProcessInAppMessage.js

@@ -0,0 +1,77 @@
+/*
+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 { APPLICATION_JSON } from "../../../constants/contentType";
+const DEFAULT_CONTENT = "defaultContent";
+const expectedProps = ["content", "contentType"];
+const expectedContentProps = ["mobileParameters", "webParameters", "html"];
+const isValidInAppMessage = (data, logger) => {
+  for (let i = 0; i < expectedProps.length; i += 1) {
+    const prop = expectedProps[i];
+    if (!Object.prototype.hasOwnProperty.call(data, prop)) {
+      logger.warn(`Invalid in-app message data: missing property '${prop}'.`, data);
+      return false;
+    }
+  }
+  const {
+    content,
+    contentType
+  } = data;
+  if (contentType === APPLICATION_JSON) {
+    for (let i = 0; i < expectedContentProps.length; i += 1) {
+      const prop = expectedContentProps[i];
+      if (!Object.prototype.hasOwnProperty.call(content, prop)) {
+        logger.warn(`Invalid in-app message data.content: missing property '${prop}'.`, data);
+        return false;
+      }
+    }
+  }
+  return true;
+};
+export default (({
+  modules,
+  logger
+}) => {
+  return item => {
+    const data = item.getData();
+    const meta = {
+      ...item.getProposition().getNotification()
+    };
+    if (!data) {
+      logger.warn("Invalid in-app message data: undefined.", data);
+      return {};
+    }
+    const {
+      type = DEFAULT_CONTENT
+    } = data;
+    if (!modules[type]) {
+      logger.warn("Invalid in-app message data: unknown type.", data);
+      return {};
+    }
+    if (!isValidInAppMessage(data, logger)) {
+      return {};
+    }
+    if (!meta) {
+      logger.warn("Invalid in-app message meta: undefined.", meta);
+      return {};
+    }
+    return {
+      render: () => {
+        return modules[type]({
+          ...data,
+          meta
+        });
+      },
+      setRenderAttempted: true,
+      includeInNotification: true
+    };
+  };
+});