@mindful-web/marko-web-omeda-identity-x 1.0.0

package/rapid-identify.js

@@ -0,0 +1,194 @@
+const gql = require('graphql-tag');
+const { get, getAsArray } = require('@mindful-web/object-path');
+const isOmedaDemographicId = require('./external-id/is-demographic-id');
+const isDeploymentTypeId = require('./external-id/is-deployment-type-id');
+const isProductId = require('./external-id/is-product-id');
+
+const ALPHA3_CODE = gql`
+  query GetAlpha3Code($alpha2: String!) {
+    localeCountry(input: { code: $alpha2 }) { id alpha3 }
+  }
+`;
+
+const getAlpha3CodeFor = async (alpha2, identityX) => {
+  const { data } = await identityX.client.query({
+    query: ALPHA3_CODE,
+    variables: { alpha2 },
+  });
+  return get(data, 'localeCountry.alpha3');
+};
+
+/**
+ *
+ * @param {object} params
+ * @param {string} params.brandKey The Omeda brand key
+ * @param {number} params.productId The Omeda product ID to associate with the identification
+ * @param {object} params.appUser The IdentityX user
+ * @param {string} [params.promoCode] An optional code to send to Omeda for tracking the
+ *                                    acquisition source
+ * @param {IdentityX} params.identityX The Marko web IdentityX service
+ * @param {function} params.omedaRapidIdentify The Omeda rapid identifcation action
+ */
+module.exports = async ({
+  brandKey,
+  productId,
+  appUser,
+
+  promoCode,
+
+  deploymentTypes = [],
+
+  appendBehaviors,
+  appendDemographics,
+  appendPromoCodes,
+
+  behavior,
+
+  identityX,
+  omedaRapidIdentify,
+} = {}) => {
+  const {
+    givenName,
+    familyName,
+    organization,
+    organizationTitle,
+    countryCode,
+    regionCode,
+    postalCode,
+    street,
+    addressExtra,
+    city,
+    phoneNumber,
+    mobileNumber,
+  } = appUser;
+
+  let alpha3;
+  if (countryCode) {
+    // omeda requires and ISO alpha3 country code.
+    alpha3 = await getAlpha3CodeFor(countryCode, identityX);
+  }
+
+  const behaviors = [{ id: behavior.id, attributes: getAsArray(behavior, 'attributes') }];
+  const demographics = getAsArray(appUser, 'customSelectFieldAnswers').filter((select) => {
+    const { field, hasAnswered } = select;
+    if (!field.active || !field.externalId || !hasAnswered) return false;
+    return isOmedaDemographicId({ externalId: field.externalId, brandKey })
+      && select.answers.some((answer) => answer.externalIdentifier);
+  }).map((select) => {
+    const { field } = select;
+    const { identifier } = field.externalId;
+    const writeInValue = select.answers.reduce((v, answer) => (v || answer.writeInValue), null);
+    return {
+      id: parseInt(identifier.value, 10),
+      values: select.answers.map((answer) => answer.externalIdentifier).filter((v) => v),
+      ...(writeInValue && { writeInValue }),
+    };
+  });
+
+  getAsArray(appUser, 'customTextFieldAnswers').forEach((text) => {
+    const { field, hasAnswered } = text;
+    const { externalId } = field;
+    if (!field.active || !externalId || !hasAnswered) return;
+
+    const { identifier } = field.externalId;
+    const id = parseInt(identifier.value, 10);
+    if (isOmedaDemographicId({ externalId, brandKey })) {
+      demographics.push({ id, values: [`${text.value}`] });
+    }
+  });
+
+  const subscriptions = [];
+  getAsArray(appUser, 'customBooleanFieldAnswers').forEach((boolean) => {
+    const { field, hasAnswered } = boolean;
+    const { externalId } = field;
+    if (!field.active || !externalId || !hasAnswered) return;
+
+    const { identifier } = field.externalId;
+    const id = parseInt(identifier.value, 10);
+
+    if (isOmedaDemographicId({ externalId, brandKey })) {
+      demographics.push({ id, values: [`${boolean.value}`] });
+    }
+
+    if (isDeploymentTypeId({ externalId, brandKey })) {
+      deploymentTypes.push({ id, optedIn: boolean.answer });
+    }
+
+    if (isProductId({ externalId, brandKey })) {
+      subscriptions.push({ id, receive: boolean.answer });
+    }
+  });
+
+  // Append custom demographic answer, if specified
+  if (appendDemographics && appendDemographics.length) {
+    appendDemographics.forEach(({ demographicId, valueIds, writeInValue }) => {
+      demographics.push({
+        id: demographicId,
+        values: valueIds.map((v) => `${v}`),
+        ...(writeInValue && { writeInValue }),
+      });
+    });
+  }
+
+  // Append custom behavior, if specified
+  if (appendBehaviors && appendBehaviors.length) {
+    appendBehaviors.forEach(({ behaviorId, attributes }) => {
+      behaviors.push({
+        id: behaviorId,
+        // Only pass attributes through if they are present
+        ...(attributes && attributes.length && {
+          attributes: attributes.map((attr) => ({
+            id: attr.id,
+            ...(attr.valueId && { valueId: attr.valueId }),
+            ...(attr.value && { value: attr.value }),
+          })),
+        }),
+      });
+    });
+  }
+
+  const promoCodes = [];
+  if (promoCode) promoCodes.push(promoCode);
+
+  // Append promo codes, if specified
+  if (appendPromoCodes && appendPromoCodes.length) {
+    appendPromoCodes.forEach((code) => promoCodes.push(code.promoCode));
+  }
+
+  const { id, encryptedCustomerId } = await omedaRapidIdentify({
+    email: appUser.email,
+    productId,
+    ...(givenName && { firstName: givenName }),
+    ...(familyName && { lastName: familyName }),
+    ...(organization && { companyName: organization }),
+    ...(organizationTitle && { title: organizationTitle }),
+    ...(alpha3 && { countryCode: alpha3 }),
+    ...(regionCode && { regionCode }),
+    ...(postalCode && { postalCode }),
+    ...(street && { street }),
+    ...(addressExtra && { addressExtra }),
+    ...(city && { city }),
+    ...(mobileNumber && { mobileNumber }),
+    ...(phoneNumber && { phoneNumber }),
+    ...(demographics.length && { demographics }),
+    ...(behaviors.length && { behaviors }),
+    ...(deploymentTypes.length && { deploymentTypes }),
+    ...(promoCodes.length && { promoCode: [...promoCodes].pop() }),
+    ...(subscriptions.length && { subscriptions }),
+  });
+
+  const namespace = { provider: 'omeda', tenant: brandKey.toLowerCase(), type: 'customer' };
+  await Promise.all([
+    identityX.addExternalUserId({
+      userId: appUser.id,
+      identifier: { value: `${id}` },
+      namespace,
+    }),
+    identityX.addExternalUserId({
+      userId: appUser.id,
+      identifier: { value: encryptedCustomerId, type: 'encrypted' },
+      namespace,
+    }),
+  ]);
+  return { id, encryptedCustomerId };
+};

package/routes/rapid-identify.js

@@ -0,0 +1,70 @@
+const { Router } = require('express');
+const { getAsObject } = require('@mindful-web/object-path');
+const { asyncRoute } = require('@mindful-web/utils');
+const jsonErrorHandler = require('@mindful-web/marko-web/express/json-error-handler');
+
+const tokenCookie = require('@mindful-web/marko-web-identity-x/utils/token-cookie');
+const olyticsCookie = require('@mindful-web/marko-web-omeda/olytics/customer-cookie');
+
+const findEncryptedId = require('../external-id/find-encrypted-customer-id');
+const extractPromoCode = require('../utils/extract-promo-code');
+
+module.exports = ({
+  brandKey,
+  idxOmedaRapidIdentifyProp = '$idxOmedaRapidIdentify',
+  omedaPromoCodeCookieName = 'omeda_promo_code',
+  omedaPromoCodeDefault,
+} = {}) => {
+  if (!brandKey) throw new Error('An Omeda brand key is required to use this middleware.');
+  const router = Router();
+  router.get('/', asyncRoute(async (req, res) => {
+    const idxOmedaRapidIdentify = req[idxOmedaRapidIdentifyProp];
+    if (!idxOmedaRapidIdentify) throw new Error(`Unable to find the IdentityX+Omeda rapid identifier on the request using ${idxOmedaRapidIdentifyProp}`);
+
+    const promoCode = extractPromoCode({
+      omedaPromoCodeCookieName,
+      omedaPromoCodeDefault,
+      cookies: req.cookies,
+    });
+
+    const data = {
+      userId: null,
+      encryptedId: null,
+      source: null,
+      didResetCookie: false,
+      brandKey: brandKey.toLowerCase(),
+    };
+    const idxUserExists = tokenCookie.exists(req);
+    if (!idxUserExists) return res.json(data);
+
+    const context = await req.identityX.loadActiveContext();
+    const user = getAsObject(context, 'user');
+    if (!user.id) return res.json(data);
+    data.userId = user.id;
+
+    // determine if an encrypted ID already exists for this user and brand.
+    const encryptedId = findEncryptedId({ externalIds: user.externalIds, brandKey });
+    if (encryptedId) {
+      data.encryptedId = encryptedId;
+      data.source = 'existing';
+    } else {
+      // no omeda identifier found for this user, rapidly identify.
+      const { encryptedCustomerId } = await idxOmedaRapidIdentify({ user, promoCode });
+      data.encryptedId = encryptedCustomerId;
+      data.source = 'new';
+    }
+
+    // finally, reset the olytics cookie if it isn't present
+    // or doesn't match the current encrypted id.
+    const currentEncId = olyticsCookie.parseFrom(req);
+
+    if (!currentEncId || currentEncId !== data.encryptedId) {
+      olyticsCookie.setTo(res, data.encryptedId);
+      data.didResetCookie = true;
+    }
+    return res.json(data);
+  }));
+
+  router.use(jsonErrorHandler());
+  return router;
+};

package/utils/append-data.js

@@ -0,0 +1,24 @@
+/**
+ * Returns the Omeda behaviors, demographics, or promo codes that should be appended to the API call
+ * based on the supplied event hook.
+ */
+module.exports = ({
+  behaviors = [],
+  demographics = [],
+  promoCodes = [],
+}) => (hookName) => {
+  const appendBehaviors = behaviors
+    .filter(({ hook }) => hook === hookName)
+    .map(({ hook, ...rest }) => rest);
+  const appendDemographics = demographics
+    .filter(({ hook }) => hook === hookName)
+    .map(({ hook, ...rest }) => rest);
+  const appendPromoCodes = promoCodes
+    .filter(({ hook }) => hook === hookName)
+    .map(({ hook, ...rest }) => rest);
+  return {
+    ...(appendBehaviors.length && { appendBehaviors }),
+    ...(appendDemographics.length && { appendDemographics }),
+    ...(appendPromoCodes.length && { appendPromoCodes }),
+  };
+};

package/utils/build-behavior.js

@@ -0,0 +1,32 @@
+const { get } = require('@mindful-web/object-path');
+
+const getBehavior = (event, behaviors) => {
+  switch (event) {
+    case 'onLoginLinkSent':
+      return behaviors.logIn;
+    case 'onAuthenticationSuccess':
+      return behaviors.verifyEmail;
+    case 'onUserProfileUpdate':
+      return behaviors.submitProfile;
+    default:
+      return undefined;
+  }
+};
+
+const buildAttributes = (attrs, data) => Object.keys(attrs).reduce((arr, key) => {
+  const attr = attrs[key];
+  const valueId = get(attrs, `${key}.valueIds.${data[key]}`, attr.valueId);
+  if (!valueId) return arr;
+  return [...arr, { id: attr.id, valueId }];
+}, []);
+
+/**
+ * Returns an Omeda Behavior ID and attribute map for the supplied IdentityX event data.
+ * @returns Object|undefined
+ */
+module.exports = ({ behaviors, behaviorAttributes }) => (event, data) => {
+  const behaviorId = getBehavior(event, behaviors);
+  if (!behaviorId) return undefined;
+  const attributes = buildAttributes(behaviorAttributes, data);
+  return { id: behaviorId, attributes };
+};

package/utils/extract-promo-code.js

@@ -0,0 +1,8 @@
+const { get } = require('@mindful-web/object-path');
+
+module.exports = ({
+  promoCode,
+  omedaPromoCodeCookieName = 'omeda_promo_code',
+  omedaPromoCodeDefault,
+  cookies = {},
+} = {}) => promoCode || get(cookies, omedaPromoCodeCookieName) || omedaPromoCodeDefault;

package/utils/get-cookie-id.js

@@ -0,0 +1,11 @@
+module.exports = (value, type) => {
+  if (!value) return null;
+  const trimmed = `${value.replace(/^"/, '').replace(/"$/, '')}`.trim();
+  if (type === 'anon') {
+    return /^[a-z0-9-]{36}$/i.test(trimmed) ? trimmed : null;
+  }
+  if (type === 'enc') {
+    return /^[a-z0-9]{15}$/i.test(trimmed) ? trimmed : null;
+  }
+  return null;
+};

package/utils/resync-cookie.js

@@ -0,0 +1,25 @@
+const COOKIE_NAME = '__idx_omeda_sync';
+const defaultMaxAge = 7 * 24 * 60 * 60 * 1000; // 1 week
+
+const parseFrom = (req) => {
+  try {
+    return JSON.parse(req.cookies[COOKIE_NAME]);
+  } catch (e) {
+    return false;
+  }
+};
+
+const setTo = ({
+  res,
+  value,
+  maxAge = defaultMaxAge,
+}) => {
+  const v = JSON.stringify(value);
+  res.cookie(COOKIE_NAME, v, { maxAge, httpOnly: false });
+  return true;
+};
+
+module.exports = {
+  parseFrom,
+  setTo,
+};

package/validation/props.js

@@ -0,0 +1,20 @@
+const Joi = require('@parameter1/joi');
+const IdXConfig = require('@mindful-web/marko-web-identity-x/config');
+const validHooks = require('@mindful-web/marko-web-identity-x/hooks');
+
+module.exports = {
+  behaviorAttribute: Joi.object({
+    id: Joi.number().required(),
+    valueId: Joi.number(),
+    value: Joi.string(),
+  }).xor('valueId', 'value'),
+  behaviorId: Joi.number(),
+  brandKey: Joi.string().trim().lowercase(),
+  clientKey: Joi.string().trim().lowercase(),
+  demographicId: Joi.number(),
+  hook: Joi.string().valid(...validHooks),
+  idxConfig: Joi.object().instance(IdXConfig),
+  promoCode: Joi.string(),
+  valueId: Joi.number(),
+  writeInValue: Joi.string(),
+};

package/validation/schemas/append-behavior.js

@@ -0,0 +1,7 @@
+const Joi = require('@parameter1/joi');
+const { behaviorAttribute, behaviorId } = require('../props');
+
+module.exports = Joi.object({
+  behaviorId: behaviorId.required(),
+  attributes: Joi.array().items(behaviorAttribute).default([]),
+});

package/validation/schemas/append-demographic.js

@@ -0,0 +1,8 @@
+const Joi = require('@parameter1/joi');
+const { demographicId, valueId } = require('../props');
+
+module.exports = Joi.object({
+  demographicId: demographicId.required(),
+  valueIds: Joi.array().items(valueId.required()).required(),
+  writeInValue: Joi.string(),
+});

package/validation/schemas/append-promo-code.js

@@ -0,0 +1,5 @@
+const Joi = require('@parameter1/joi');
+
+module.exports = Joi.object({
+  promoCode: Joi.string().required(),
+});

package/validation/schemas/behavior.js

@@ -0,0 +1,7 @@
+const Joi = require('@parameter1/joi');
+const { behaviorAttribute, behaviorId } = require('../props');
+
+module.exports = Joi.object({
+  id: behaviorId.required(),
+  attributes: Joi.array().items(behaviorAttribute).default([]),
+});

package/validation/schemas/hook-behavior.js

@@ -0,0 +1,12 @@
+const Joi = require('@parameter1/joi');
+const { behaviorId, hook } = require('../props');
+
+/**
+ * @typedef HookBehaviorSchema
+ * @prop {import('@mindful-web/marko-web-identity-x/hooks').HookTypeEnum} hook
+ * @prop {number} behaviorId
+ */
+module.exports = Joi.object({
+  hook: hook.required(),
+  behaviorId: behaviorId.required(),
+});

package/validation/schemas/hook-demographic.js

@@ -0,0 +1,16 @@
+const Joi = require('@parameter1/joi');
+const { demographicId, valueId, hook } = require('../props');
+
+/**
+ * @typedef HookDemographicSchema
+ * @prop {import('@mindful-web/marko-web-identity-x/hooks').HookTypeEnum} hook
+ * @prop {number} demographicId
+ * @prop {number[]} valueIds
+ * @prop {?string} writeInValue
+ */
+module.exports = Joi.object({
+  hook: hook.required(),
+  demographicId: demographicId.required(),
+  valueIds: Joi.array().items(valueId.required()).required(),
+  writeInValue: Joi.string(),
+});

package/validation/schemas/hook-promo-code.js

@@ -0,0 +1,12 @@
+const Joi = require('@parameter1/joi');
+const { hook } = require('../props');
+
+/**
+ * @typedef HookPromoCodeSchema
+ * @prop {import('@mindful-web/marko-web-identity-x/hooks').HookTypeEnum} hook
+ * @prop {string} promoCode
+ */
+module.exports = Joi.object({
+  hook: hook.required(),
+  promoCode: Joi.string().required(),
+});

package/validation/schemas/index.js

@@ -0,0 +1,19 @@
+const appendBehavior = require('./append-behavior');
+const appendDemographic = require('./append-demographic');
+const appendPromoCode = require('./append-promo-code');
+const behavior = require('./behavior');
+const hookBehavior = require('./hook-behavior');
+const hookDemographic = require('./hook-demographic');
+const hookPromoCode = require('./hook-promo-code');
+const shouldAwait = require('./should-await');
+
+module.exports = {
+  appendBehavior,
+  appendDemographic,
+  appendPromoCode,
+  behavior,
+  hookBehavior,
+  hookDemographic,
+  hookPromoCode,
+  shouldAwait,
+};

package/validation/schemas/should-await.js

@@ -0,0 +1,7 @@
+const Joi = require('@parameter1/joi');
+
+module.exports = Joi.object({
+  onLoginLinkSent: Joi.boolean().default(false),
+  onAuthenticationSuccess: Joi.boolean().default(true),
+  onUserProfileUpdate: Joi.boolean().default(false),
+}).default();