@adobe/alloy 2.20.0-beta.2 → 2.20.0-beta.4

package/libEs6/components/DecisioningEngine/createContextProvider.js

@@ -0,0 +1,95 @@
+/*
+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 getBrowser from "../../utils/getBrowser.js";
+import parseUrl from "../../utils/parseUrl.js";
+import flattenObject from "../../utils/flattenObject.js";
+import libraryVersion from "../../constants/libraryVersion.js";
+export default (({
+  eventRegistry,
+  window
+}) => {
+  const pageLoadTimestamp = new Date().getTime();
+  const getBrowserContext = () => {
+    return {
+      name: getBrowser(window)
+    };
+  };
+  const getPageContext = () => {
+    return {
+      title: window.title,
+      url: window.url,
+      ...parseUrl(window.url)
+    };
+  };
+  const getReferrerContext = () => {
+    return {
+      url: window.referrer,
+      ...parseUrl(window.referrer)
+    };
+  };
+  const getTimeContext = () => {
+    const now = new Date();
+    const currentTimestamp = now.getTime();
+    return {
+      pageLoadTimestamp,
+      currentTimestamp,
+      currentDate: now.getDate(),
+      // Day of the week starts on Monday as is practiced in ISO 8601, but we want it to start on Sunday to match the authoring UI rule
+      "~state.com.adobe.module.lifecycle/lifecyclecontextdata.dayofweek": now.getDay() + 1,
+      "~state.com.adobe.module.lifecycle/lifecyclecontextdata.hourofday": now.getHours(),
+      currentMinute: now.getMinutes(),
+      currentMonth: now.getMonth(),
+      currentYear: now.getFullYear(),
+      pageVisitDuration: currentTimestamp - pageLoadTimestamp,
+      "~timestampu": currentTimestamp / 1000,
+      "~timestampz": now.toISOString()
+    };
+  };
+  const getWindowContext = () => {
+    const height = window.height;
+    const width = window.width;
+    const scrollY = window.scrollY;
+    const scrollX = window.scrollX;
+    return {
+      height,
+      width,
+      scrollY,
+      scrollX
+    };
+  };
+  const coreGlobalContext = {
+    browser: getBrowserContext(),
+    page: getPageContext(),
+    referringPage: getReferrerContext()
+  };
+  const getGlobalContext = () => {
+    return {
+      ...coreGlobalContext,
+      ...getTimeContext(),
+      window: getWindowContext(),
+      "~sdkver": libraryVersion
+    };
+  };
+  const getContext = (addedContext = {}) => {
+    const context = {
+      ...getGlobalContext(),
+      ...addedContext
+    };
+    return {
+      ...flattenObject(context),
+      events: eventRegistry.toJSON()
+    };
+  };
+  return {
+    getContext
+  };
+});

package/libEs6/components/DecisioningEngine/createDecisionHistory.js

@@ -0,0 +1,25 @@
+/*
+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 { PropositionEventType } from "../../constants/propositionEventType.js";
+export default (({
+  eventRegistry
+}) => {
+  const recordQualified = id => {
+    if (!id) {
+      return undefined;
+    }
+    return eventRegistry.addEvent({}, PropositionEventType.TRIGGER, id);
+  };
+  return {
+    recordQualified
+  };
+});

package/libEs6/components/DecisioningEngine/createDecisionProvider.js

@@ -0,0 +1,41 @@
+/*
+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 createEvaluableRulesetPayload from "./createEvaluableRulesetPayload.js";
+import createDecisionHistory from "./createDecisionHistory.js";
+import { getActivityId } from "./utils.js";
+export default (({
+  eventRegistry
+}) => {
+  const payloadsBasedOnActivityId = {};
+  const decisionHistory = createDecisionHistory({
+    eventRegistry
+  });
+  const addPayload = payload => {
+    const activityId = getActivityId(payload);
+    if (!activityId) {
+      return;
+    }
+    const evaluableRulesetPayload = createEvaluableRulesetPayload(payload, eventRegistry, decisionHistory);
+    if (evaluableRulesetPayload.isEvaluable) {
+      payloadsBasedOnActivityId[activityId] = evaluableRulesetPayload;
+    }
+  };
+  const evaluate = (context = {}) => Object.values(payloadsBasedOnActivityId).map(payload => payload.evaluate(context)).filter(payload => payload.items.length > 0);
+  const addPayloads = personalizationPayloads => {
+    personalizationPayloads.forEach(addPayload);
+  };
+  return {
+    addPayload,
+    addPayloads,
+    evaluate
+  };
+});

package/libEs6/components/DecisioningEngine/createEvaluableRulesetPayload.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 RulesEngine from "@adobe/aep-rules-engine";
+import { JSON_CONTENT_ITEM, RULESET_ITEM } from "../../constants/schema.js";
+import { DISPLAY } from "../../constants/eventType.js";
+import { getActivityId } from "./utils.js";
+import flattenArray from "../../utils/flattenArray.js";
+import createConsequenceAdapter from "./createConsequenceAdapter.js";
+const isRulesetItem = item => {
+  const {
+    schema,
+    data
+  } = item;
+  if (schema === RULESET_ITEM) {
+    return true;
+  }
+  if (schema !== JSON_CONTENT_ITEM) {
+    return false;
+  }
+  try {
+    const content = typeof data.content === "string" ? JSON.parse(data.content) : data.content;
+    return content && Object.prototype.hasOwnProperty.call(content, "version") && Object.prototype.hasOwnProperty.call(content, "rules");
+  } catch (error) {
+    return false;
+  }
+};
+export default ((payload, eventRegistry, decisionHistory) => {
+  const consequenceAdapter = createConsequenceAdapter();
+  const activityId = getActivityId(payload);
+  const items = [];
+  const addItem = item => {
+    const {
+      data = {},
+      schema
+    } = item;
+    const content = schema === RULESET_ITEM ? data : data.content;
+    if (!content) {
+      return;
+    }
+    items.push(RulesEngine(typeof content === "string" ? JSON.parse(content) : content));
+  };
+  const evaluate = context => {
+    const displayEvent = eventRegistry.getEvent(DISPLAY, activityId);
+    const displayedDate = displayEvent ? displayEvent.firstTimestamp : undefined;
+    const qualifyingItems = flattenArray(items.map(item => item.execute(context))).map(consequenceAdapter).map(item => {
+      const {
+        firstTimestamp: qualifiedDate
+      } = decisionHistory.recordQualified(activityId) || {};
+      return {
+        ...item,
+        data: {
+          ...item.data,
+          qualifiedDate,
+          displayedDate
+        }
+      };
+    });
+    return {
+      ...payload,
+      items: qualifyingItems
+    };
+  };
+  if (Array.isArray(payload.items)) {
+    payload.items.filter(isRulesetItem).forEach(addItem);
+  }
+  return {
+    evaluate,
+    isEvaluable: items.length > 0
+  };
+});

package/libEs6/components/DecisioningEngine/createEvaluateRulesetsCommand.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 { boolean, objectOf } from "../../utils/validation/index.js";
+const validateOptions = ({
+  options
+}) => {
+  const validator = objectOf({
+    renderDecisions: boolean(),
+    personalization: objectOf({
+      decisionContext: objectOf({})
+    })
+  }).noUnknownFields();
+  return validator(options);
+};
+export default (({
+  contextProvider,
+  decisionProvider
+}) => {
+  const run = ({
+    renderDecisions,
+    decisionContext,
+    applyResponse
+  }) => {
+    return applyResponse({
+      renderDecisions,
+      propositions: decisionProvider.evaluate(contextProvider.getContext(decisionContext))
+    });
+  };
+  const optionsValidator = options => validateOptions({
+    options
+  });
+  return {
+    optionsValidator,
+    run
+  };
+});

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.js";
+import { EVENT_TYPE_TRUE } from "../../constants/eventType.js";
+import { ADOBE_JOURNEY_OPTIMIZER } from "../../constants/decisionProvider.js";
+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.js";
+import flattenObject from "../../utils/flattenObject.js";
+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/index.js";
+import createSubscription from "../../utils/createSubscription.js";
+import { includes } from "../../utils/index.js";
+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/index.js";
+import createOnResponseHandler from "./createOnResponseHandler.js";
+import createDecisionProvider from "./createDecisionProvider.js";
+import createApplyResponse from "./createApplyResponse.js";
+import createEventRegistry from "./createEventRegistry.js";
+import createContextProvider from "./createContextProvider.js";
+import createSubscribeRulesetItems from "./createSubscribeRulesetItems.js";
+import { CONTEXT_KEY, CONTEXT_EVENT_SOURCE, CONTEXT_EVENT_TYPE } from "./constants.js";
+import createEvaluateRulesetsCommand from "./createEvaluateRulesetsCommand.js";
+import { clearLocalStorage, createInMemoryStorage } from "./utils.js";
+import { objectOf, boolean } from "../../utils/validation/index.js";
+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;