TNT-35311 Add response tokens

packages/target-decisioning-engine/src/constants.js

@@ -27,3 +27,23 @@ CDN_BASE[ENVIRONMENT_STAGE] = CDN_BASE_STAGE;
 CDN_BASE[ENVIRONMENT_DEV] = CDN_BASE_DEV;
 
 export { CDN_BASE };
+
+// Response token keys
+export const ACTIVITY_DECISIONING_METHOD = "activity.decisioningMethod";
+export const ACTIVITY_ID = "activity.id";
+export const ACTIVITY_NAME = "activity.name";
+export const ACTIVITY_TYPE = "activity.type";
+export const EXPERIENCE_ID = "experience.id";
+export const EXPERIENCE_NAME = "experience.name";
+export const LOCATION_ID = "location.id";
+export const LOCATION_NAME = "location.name";
+export const LOCATION_TYPE = "location.type";
+export const OFFER_ID = "offer.id";
+export const OFFER_NAME = "offer.name";
+export const OPTION_ID = "option.id";
+export const OPTION_NAME = "option.name";
+export const GEO_CITY = "geo.city";
+export const GEO_COUNTRY = "geo.country";
+export const GEO_STATE = "geo.state";
+export const GEO_LATITUDE = "geo.latitude";
+export const GEO_LONGITUDE = "geo.longitude";

packages/target-decisioning-engine/src/decisionProvider.js

@@ -12,6 +12,7 @@ import { RequestType } from "./enums";
 import {
   addTrace,
   cleanUp,
+  createResponseTokensPostProcessor,
   prepareExecuteResponse,
   preparePrefetchResponse,
   removePageLoadAttributes
@@ -41,7 +42,7 @@ function DecisionProvider(
   logger,
   traceProvider
 ) {
-  const { rules } = artifact;
+  const { responseTokens, rules } = artifact;
   const globalMboxName = artifact.globalMbox || DEFAULT_GLOBAL_MBOX;
 
   const clientId = config.client;
@@ -263,7 +264,7 @@ function DecisionProvider(
     return response;
   }
 
-  function getExecuteDecisions() {
+  function getExecuteDecisions(postProcessors) {
     const decisions = getDecisions("execute", [
       function prepareNotification(rule, mboxResponse, requestType, tracer) {
         notificationProvider.addNotification(
@@ -274,23 +275,27 @@ function DecisionProvider(
         return mboxResponse;
       },
       prepareExecuteResponse,
-      addTrace,
-      cleanUp
+      ...postProcessors
     ]);
 
     notificationProvider.sendNotifications();
 
     return decisions;
   }
 
-  function getPrefetchDecisions() {
+  function getPrefetchDecisions(postProcessors) {
     return getDecisions("prefetch", [
       preparePrefetchResponse,
-      addTrace,
-      cleanUp
+      ...postProcessors
     ]);
   }
 
+  const addResponseTokens = createResponseTokensPostProcessor(
+    context,
+    responseTokens
+  );
+  const commonPostProcessor = [addResponseTokens, addTrace, cleanUp];
+
   const response = objectWithoutUndefinedValues({
     status: dependency.remoteNeeded ? PARTIAL_CONTENT : OK,
     remoteMboxes: dependency.remoteMboxes,
@@ -301,8 +306,8 @@ function DecisionProvider(
     },
     client: clientId,
     edgeHost: undefined,
-    execute: getExecuteDecisions(),
-    prefetch: getPrefetchDecisions()
+    execute: getExecuteDecisions(commonPostProcessor),
+    prefetch: getPrefetchDecisions(commonPostProcessor)
   });
 
   logger.debug(`${LOG_TAG}`, request, response);

packages/target-decisioning-engine/src/postProcessors.js

@@ -1,10 +1,31 @@
 /* eslint-disable no-unused-vars */
 import {
+  isDefined,
   isUndefined,
   objectWithoutUndefinedValues,
   MetricType
 } from "@adobe/target-tools";
 import { RequestType } from "./enums";
+import {
+  ACTIVITY_DECISIONING_METHOD,
+  ACTIVITY_ID,
+  ACTIVITY_NAME,
+  ACTIVITY_TYPE,
+  EXPERIENCE_ID,
+  EXPERIENCE_NAME,
+  GEO_CITY,
+  GEO_COUNTRY,
+  GEO_LATITUDE,
+  GEO_LONGITUDE,
+  GEO_STATE,
+  LOCATION_ID,
+  LOCATION_NAME,
+  LOCATION_TYPE,
+  OFFER_ID,
+  OFFER_NAME,
+  OPTION_ID,
+  OPTION_NAME
+} from "./constants";
 
 function noBlankOptions(option) {
   return !(isUndefined(option.type) && isUndefined(option.content));
@@ -128,3 +149,88 @@ export function removePageLoadAttributes(
 
   return processed;
 }
+
+/**
+ * @param {Object} context
+ * @param {Array<string>} responseTokensInArtifact
+ */
+export function createResponseTokensPostProcessor(
+  context,
+  responseTokensInArtifact = []
+) {
+  const responseTokens = {};
+  responseTokens[ACTIVITY_DECISIONING_METHOD] = "on-device";
+
+  if (
+    responseTokensInArtifact.includes(GEO_CITY) &&
+    isDefined(context.geo.city)
+  ) {
+    responseTokens[GEO_CITY] = context.geo.city;
+  }
+  if (
+    responseTokensInArtifact.includes(GEO_COUNTRY) &&
+    isDefined(context.geo.country)
+  ) {
+    responseTokens[GEO_COUNTRY] = context.geo.country;
+  }
+  if (
+    responseTokensInArtifact.includes(GEO_STATE) &&
+    isDefined(context.geo.region)
+  ) {
+    responseTokens[GEO_STATE] = context.geo.region;
+  }
+  if (
+    responseTokensInArtifact.includes(GEO_LATITUDE) &&
+    isDefined(context.geo.latitude)
+  ) {
+    responseTokens[GEO_LATITUDE] = context.geo.latitude;
+  }
+  if (
+    responseTokensInArtifact.includes(GEO_LONGITUDE) &&
+    isDefined(context.geo.longitude)
+  ) {
+    responseTokens[GEO_LONGITUDE] = context.geo.longitude;
+  }
+
+  /**
+   * @param {import("../types/DecisioningArtifact").Rule} rule
+   * @param {import("@adobe/target-tools/delivery-api-client/models/MboxResponse").MboxResponse} mboxResponse
+   */
+  return function addResponseTokens(rule, mboxResponse) {
+    const meta = rule.meta || {};
+    const responseTokensFromMeta = [
+      ACTIVITY_ID,
+      ACTIVITY_NAME,
+      ACTIVITY_TYPE,
+      EXPERIENCE_ID,
+      EXPERIENCE_NAME,
+      LOCATION_ID,
+      LOCATION_NAME,
+      LOCATION_TYPE,
+      OFFER_ID,
+      OFFER_NAME,
+      OPTION_ID,
+      OPTION_NAME
+    ].reduce((accumulator, key) => {
+      if (responseTokensInArtifact.includes(key) && isDefined(meta[key])) {
+        accumulator[key] = meta[key];
+      }
+      return accumulator;
+    }, {});
+
+    const options = mboxResponse.options.map(option => {
+      return {
+        ...option,
+        responseTokens: {
+          ...responseTokensFromMeta,
+          ...responseTokens
+        }
+      };
+    });
+
+    return {
+      ...mboxResponse,
+      options
+    };
+  };
+}

packages/target-decisioning-engine/src/ruleEvaluator.js

@@ -4,6 +4,7 @@ import { isDefined } from "@adobe/target-tools";
 import { createMboxContext, createPageContext } from "./contextProvider";
 import { computeAllocation } from "./allocationProvider";
 import { cloneDeep } from "./utils";
+import { ACTIVITY_ID } from "./constants";
 
 /**
  *
@@ -41,7 +42,7 @@ export function ruleEvaluator(clientId, visitorId) {
       page,
       referring,
       mbox: createMboxContext(requestDetail),
-      allocation: computeAllocation(clientId, rule.meta.activityId, visitorId)
+      allocation: computeAllocation(clientId, rule.meta[ACTIVITY_ID], visitorId)
     };
 
     const ruleSatisfied = jsonLogic.apply(rule.condition, ruleContext);
@@ -63,6 +64,6 @@ export function ruleEvaluator(clientId, visitorId) {
         consequence = postProcessFunc(rule, consequence, requestType, tracer);
       });
     }
-    return cloneDeep(consequence); // we return a new object because at.js has a tendency to mutate reponses and we don't want it to mutate the rule consequence itself
+    return cloneDeep(consequence); // we return a new object because at.js has a tendency to mutate response and we don't want it to mutate the rule consequence itself
   };
 }

packages/target-decisioning-engine/src/traceProvider.js

@@ -1,5 +1,6 @@
 import Messages from "./messages";
 import { isDefined, isUndefined, ChannelType } from "@adobe/target-tools";
+import { ACTIVITY_ID, ACTIVITY_TYPE, EXPERIENCE_ID } from "./constants";
 
 const byOrder = (a, b) => a.order - b.order;
 
@@ -105,15 +106,16 @@ export function RequestTracer(traceProvider, artifact) {
    */
   function addCampaign(rule, ruleSatisfied) {
     const { meta } = rule;
+    const activityId = meta[ACTIVITY_ID];
 
-    if (ruleSatisfied && isUndefined(campaigns[meta.activityId])) {
+    if (ruleSatisfied && isUndefined(campaigns[activityId])) {
       campaignOrder += 1;
 
-      campaigns[meta.activityId] = {
-        id: meta.activityId,
+      campaigns[activityId] = {
+        id: activityId,
         order: campaignOrder,
-        campaignType: meta.activityType,
-        branchId: meta.experienceId,
+        campaignType: meta[ACTIVITY_TYPE],
+        branchId: meta[EXPERIENCE_ID],
         offers: meta.offerIds || [],
         environment: artifact.meta.environment
       };
@@ -129,15 +131,16 @@ export function RequestTracer(traceProvider, artifact) {
   function addEvaluatedCampaignTarget(rule, ruleContext, ruleSatisfied) {
     const { meta } = rule;
     const { audienceIds = [] } = meta;
+    const activityId = meta[ACTIVITY_ID];
 
-    if (isUndefined(evaluatedCampaignTargets[meta.activityId])) {
+    if (isUndefined(evaluatedCampaignTargets[activityId])) {
       evaluatedCampaignTargetOrder += 1;
 
-      evaluatedCampaignTargets[meta.activityId] = {
+      evaluatedCampaignTargets[activityId] = {
         order: evaluatedCampaignTargetOrder,
         context: ruleContext,
-        campaignId: meta.activityId,
-        campaignType: meta.activityType,
+        campaignId: activityId,
+        campaignType: meta[ACTIVITY_TYPE],
         matchedSegmentIds: new Set(),
         unmatchedSegmentIds: new Set(),
         matchedRuleConditions: [],
@@ -146,12 +149,12 @@ export function RequestTracer(traceProvider, artifact) {
     }
 
     audienceIds.forEach(audienceId => {
-      evaluatedCampaignTargets[meta.activityId][
+      evaluatedCampaignTargets[activityId][
         ruleSatisfied ? "matchedSegmentIds" : "unmatchedSegmentIds"
       ].add(audienceId);
     });
 
-    evaluatedCampaignTargets[meta.activityId][
+    evaluatedCampaignTargets[activityId][
       ruleSatisfied ? "matchedRuleConditions" : "unmatchedRuleConditions"
     ].push(rule.condition);
   }
@@ -180,12 +183,14 @@ export function RequestTracer(traceProvider, artifact) {
    */
   function traceNotification(rule) {
     const { meta } = rule;
-    if (!(campaigns[meta.activityId].notifications instanceof Array)) {
-      campaigns[meta.activityId].notifications = [];
+    const activityId = meta[ACTIVITY_ID];
+
+    if (!(campaigns[activityId].notifications instanceof Array)) {
+      campaigns[activityId].notifications = [];
     }
 
     return notification => {
-      campaigns[meta.activityId].notifications.push(notification);
+      campaigns[activityId].notifications.push(notification);
     };
   }
 

packages/target-decisioning-engine/src/utils.js

@@ -13,7 +13,6 @@ import {
   POSSIBLE_ENVIRONMENTS
 } from "@adobe/target-tools";
 import Messages from "./messages";
-import { RequestType } from "./enums";
 import { CDN_BASE, SUPPORTED_ARTIFACT_MAJOR_VERSION } from "./constants";
 
 /**
@@ -22,11 +21,7 @@ import { CDN_BASE, SUPPORTED_ARTIFACT_MAJOR_VERSION } from "./constants";
  * @return {string}
  */
 export function getRuleKey(rule) {
-  const { locationType, activityId, locationId = 0 } = rule.meta;
-
-  return locationType === RequestType.VIEW
-    ? `${activityId}-${locationId}`
-    : `${activityId}`;
+  return rule.ruleKey;
 }
 
 export function parseURL(url) {