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

package/.eslintignore

@@ -0,0 +1 @@
+*.marko.js

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Parameter1 LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,86 @@
+# Mindful Web Marko Omeda+IdentityX Integrations
+Omeda+IdentityX components for Mindful Web/Marko websites.
+
+Based on the identity provider(s) in use, install and configure ***only one*** of these packages. *The other packages can be installed separately if needed, but this package should be the only one configured.*
+
+1. [omeda-identity-x](../marko-web-omeda-identity-x): For sites with both Omeda and IdentityX.
+2. [omeda](../marko-web-omeda): For sites with Omeda, but **without** IdentityX.
+3. [identity-x](../marko-web-identity-x): For sites with IdentityX, but **without** Omeda.
+
+Additional information can be found in the [Omeda](https://training.omeda.com/knowledge-base/api-overview/) and [IdentityX](https://docs.parameter1.com/identity-x) API documentation.
+
+## Configuration
+All configuration data must be passed to the middleware when loaded (See [Middleware Setup](#1-middleware-setup) below.)
+
+| Property  | Required? | Description | Default value |
+| - | - | - | - |
+| `brandKey` | **Yes** | The Omeda Brand key (such as `orgcd`).
+| `clientKey` | No | The Omeda client key (such as `client_orgc`.) *Required if sending deployment optIns via the underlying omeda package!* [marko-web-omeda docs](../marko-web-omeda)
+| `appId` | **Yes** | The Omeda application API read token
+| `inputId` | **Yes** | The Omeda application API write token
+| `rapidIdentProductId` | **Yes** | The Omeda identifier for a Website product (ProductType=7).
+| `idxConfig` | **Yes** | An instance of the IdentityX configuration class (see [marko-web-identity-x#1](../marko-web-identity-x/config.js)) | _n/a_
+| `idxRouteTemplates` | **Yes** | An object containing the Marko templates to use for each IdentityX endpoint. (see [marko-web-identity-x#2](../marko-web-identity-x/index.js))
+| `omedaPromoCodeCookieName` | No | The name of the cookie to look for a persisted/original promo code. | `omeda_promo_code` |
+| `omedaPromoCodeDefault` | No | The default promo code to send with all Omeda requests. Falls back to input ID default configured by Omeda. |
+| `idxOmedaRapidIdentifyProp` | No | The property (in the express app context) where the O+IdX rapid identification service is located. | `$idxOmedaRapidIdentify` |
+| `omedaGraphQLClientProp` | No | The property (in the express app context) where the Omeda GraphQL client is located. | `$omedaGraphQLClient` |
+| `omedaRapidIdentifyProp` | No | The property (in the express app context) where the Omeda rapid identification service is located. | `$omedaRapidIdentify` |
+| `appendBehaviorToHook` | No | An array of objects defining behaviors to append to rapid identification calls.
+| `appendBehaviorToHook[].hook` | | The name of the hook, such as `onLoginLinkSent`
+| `appendBehaviorToHook[].behaviorId` || The Omeda Behavior ID to append to the rapid identification call.
+| `appendDemographicToHook` | No | An array of objects defining demographics to append to rapid identification calls.
+| `appendDemographicToHook[].hook` | | The name of the hook, such as `onLoginLinkSent`
+| `appendDemographicToHook[].demographicId` || The Omeda Demographic ID to append.
+| `appendDemographicToHook[].valueIds` || An array of Omeda Demographic Value IDs (`Int`s) to append
+| `appendDemographicToHook[].writeInValue` || A string to include as an OEC/Other value
+| `appendPromoCodeToHook` | No | An array of objects defining demographics to append to rapid identification calls.
+| `appendPromoCodeToHook[].hook` | | The name of the hook, such as `onLoginLinkSent`
+| `appendPromoCodeToHook[].promoCode` || The Omeda Promo Code (`String`) to append.
+
+## Usage
+This package:
+1. Configures the underlying [omeda](../marko-web-omeda) and [identity-x](../marko-web-identity-x) packages
+2. Hooks into the IdentityX library to push Omeda data to IdX and push IdX data to Omeda when profile updates happen
+3. Makes the rapid identification endpoint (`/__idx/omeda-rapid-ident`) available on a mindful-web website
+4. (Optional) Provides a Vue component to call the rapid identification endpoint
+
+### 1. Middleware Setup
+To make the local omeda mountpoint available, load the middleware exported by this package. For most applications, this will be done in the `startServer` function passed to the marko-web package.
+
+See config section above and the Omeda and IdentityX package documentation for available configurations.
+
+```js
+const handler = require('@mindful-web/marko-web-omeda-identity-x');
+const omedaConfig = require('./config/omeda');
+const idXConfig = require('./config/identity-x');
+const idxRouteTemplates = require('./templates/user');
+
+startServer({
+  onStart: async (app) => {
+    handler(app, {
+      ...omedaConfig,
+      idxConfig,
+      idxRouteTemplates,
+    })
+  },
+}
+```
+
+It can also be loaded as a standard Express route middleware.
+```js
+module.exports = (app) => {
+  handler(app, { ...omedaConfig, idxConfig, idxRouteTemplates });
+};
+```
+
+### 2. Rapid Identification
+
+To use the Rapid Identification hook, load the Vue component in your Browser config. When enabled, the Omeda Rapid Identification API will be called automatically when the `oly_enc_id` URL query parameter is present.
+```js
+import OmedaIdentityX from '@mindful-web/marko-web-omeda-identity-x/browser';
+
+export default (Browser) => {
+  OmedaIdentityX(Browser);
+};
+```

package/add-integration-hooks.js

@@ -0,0 +1,119 @@
+const Joi = require('@parameter1/joi');
+const { validate } = require('@parameter1/joi/utils');
+const { get } = require('@mindful-web/object-path');
+const appendDataFactory = require('./utils/append-data');
+const behaviorFactory = require('./utils/build-behavior');
+const schemas = require('./validation/schemas');
+const props = require('./validation/props');
+const {
+  onAuthenticationSuccess,
+  onLoginLinkSent,
+  onUserProfileUpdate,
+} = require('./integration-hooks');
+
+/**
+ *
+ * @param {object} params
+ * @param {IdentityXConfiguration} params.idxConfig
+ */
+module.exports = (params = {}) => {
+  const {
+    appendBehaviorToHook,
+    appendDemographicToHook,
+    appendPromoCodeToHook,
+    behaviors,
+    behaviorAttributes,
+    idxConfig,
+    brandKey,
+    omedaGraphQLClientProp,
+    idxOmedaRapidIdentifyProp,
+    omedaPromoCodeCookieName,
+    omedaPromoCodeDefault,
+    shouldAwait,
+    onLoginLinkSentFormatter,
+    onAuthenticationSuccessFormatter,
+    onUserProfileUpdateFormatter,
+  } = validate(Joi.object({
+    appendBehaviorToHook: Joi.array().items(schemas.hookBehavior).default([]),
+    appendDemographicToHook: Joi.array().items(schemas.hookDemographic).default([]),
+    appendPromoCodeToHook: Joi.array().items(schemas.hookPromoCode).default([]),
+    behaviors: Joi.object().required(),
+    behaviorAttributes: Joi.object().required(),
+    brandKey: props.brandKey.required(),
+    idxConfig: props.idxConfig.required(),
+    idxOmedaRapidIdentifyProp: Joi.string().required(),
+    omedaGraphQLClientProp: Joi.string().required(),
+    omedaPromoCodeCookieName: Joi.string().required(),
+    omedaPromoCodeDefault: Joi.string(),
+    shouldAwait: schemas.shouldAwait,
+    onLoginLinkSentFormatter: Joi.function().required(),
+    onAuthenticationSuccessFormatter: Joi.function().required(),
+    onUserProfileUpdateFormatter: Joi.function().required(),
+  }), params);
+
+  const buildBehaviorFor = behaviorFactory({ behaviors, behaviorAttributes });
+  const appendDataFor = appendDataFactory({
+    behaviors: appendBehaviorToHook,
+    demographics: appendDemographicToHook,
+    promoCodes: appendPromoCodeToHook,
+  });
+
+  idxConfig.addHook({
+    name: 'onLoginLinkSent',
+    shouldAwait: shouldAwait.onLoginLinkSent,
+    fn: async (args) => onLoginLinkSent({
+      ...args,
+      brandKey,
+      idxOmedaRapidIdentify: get(args, `req.${idxOmedaRapidIdentifyProp}`),
+      omedaGraphQLClient: get(args, `req.${omedaGraphQLClientProp}`),
+      omedaPromoCodeCookieName,
+      omedaPromoCodeDefault,
+      formatter: onLoginLinkSentFormatter,
+      ...appendDataFor('onLoginLinkSent'),
+      behavior: buildBehaviorFor('onLoginLinkSent', {
+        actionSource: get(args, 'actionSource'),
+        newsletterSignupType: get(args, 'newsletterSignupType'),
+        contentGateType: get(args, 'contentGateType'),
+      }),
+    }),
+  });
+
+  idxConfig.addHook({
+    name: 'onAuthenticationSuccess',
+    shouldAwait: shouldAwait.onAuthenticationSuccess,
+    fn: async (args) => onAuthenticationSuccess({
+      ...args,
+      brandKey,
+      idxOmedaRapidIdentify: get(args, `req.${idxOmedaRapidIdentifyProp}`),
+      omedaPromoCodeCookieName,
+      omedaPromoCodeDefault,
+      formatter: onAuthenticationSuccessFormatter,
+      ...appendDataFor('onAuthenticationSuccess'),
+      behavior: buildBehaviorFor('onAuthenticationSuccess', {
+        actionSource: get(args, 'actionSource'),
+        newsletterSignupType: get(args, 'newsletterSignupType'),
+        contentGateType: get(args, 'contentGateType'),
+      }),
+    }),
+  });
+
+  idxConfig.addHook({
+    name: 'onUserProfileUpdate',
+    shouldAwait: shouldAwait.onUserProfileUpdate,
+    fn: async (args) => onUserProfileUpdate({
+      ...args,
+      idxOmedaRapidIdentify: get(args, `req.${idxOmedaRapidIdentifyProp}`),
+      omedaPromoCodeCookieName,
+      omedaPromoCodeDefault,
+      formatter: onUserProfileUpdateFormatter,
+      ...appendDataFor('onUserProfileUpdate'),
+      behavior: buildBehaviorFor('onUserProfileUpdate', {
+        actionSource: get(args, 'actionSource'),
+        newsletterSignupType: get(args, 'newsletterSignupType'),
+        contentGateType: get(args, 'contentGateType'),
+      }),
+    }),
+  });
+
+  return idxConfig;
+};

package/api/queries/customer-by-encrypted-id.js

@@ -0,0 +1,10 @@
+const gql = require('graphql-tag');
+
+module.exports = gql`
+  query IdXIdentifyCustomer($id: String!) {
+    customerByEncryptedId(input: { id: $id, errorOnNotFound: false }) {
+      id
+      primaryEmailAddress { emailAddress }
+    }
+  }
+`;

package/browser/.eslintrc.js

@@ -0,0 +1 @@
+module.exports = require('../../../eslintrc.browser');

package/browser/index.js

@@ -0,0 +1,43 @@
+import IdentityX from '@mindful-web/marko-web-identity-x/browser';
+
+const RapidIdentify = () => import(/* webpackChunkName: "omeda-identity-x-rapid-identify" */ './rapid-identify.vue');
+
+export default (Browser, idxArgs = {}) => {
+  IdentityX(Browser, idxArgs);
+
+  const { EventBus } = Browser;
+  EventBus.$on('identity-x-authenticated', (args = {}) => {
+    const { user = {} } = args;
+    const externalIds = user.externalIds || [];
+    const eid = externalIds.find((external) => {
+      if (!external || !external.namespace || !external.identifier) return false;
+      const { namespace, identifier } = external;
+      return namespace.provider === 'omeda'
+        && namespace.tenant
+        && namespace.type === 'customer'
+        && identifier.type === 'encrypted'
+        && identifier.value;
+    });
+
+    const encryptedId = eid ? eid.identifier.value : null;
+    const brandKey = eid ? eid.namespace.tenant : null;
+    EventBus.$emit('omeda-identity-x-authenticated', {
+      ...args,
+      user,
+      eid,
+      brandKey,
+      encryptedId,
+    });
+  });
+
+  Browser.register('OmedaIdentityXRapidIdentify', RapidIdentify, {
+    on: {
+      'encrypted-id-found': (...args) => {
+        EventBus.$emit('omeda-identity-x-rapid-identify-encrypted-id-found', ...args);
+      },
+      response: (...args) => {
+        EventBus.$emit('omeda-identity-x-rapid-identify-response', ...args);
+      },
+    },
+  });
+};

package/browser/rapid-identify.vue

@@ -0,0 +1,34 @@
+<template>
+  <div class="omeda-rapid-identity-x" style="display: none;" />
+</template>
+
+<script>
+const { error } = console;
+
+export default {
+  props: {
+    endpoint: {
+      type: String,
+      default: '/__idx/omeda-rapid-ident',
+    },
+  },
+
+  created() {
+    this.rapidIdentify();
+  },
+
+  methods: {
+    async rapidIdentify() {
+      try {
+        const res = await fetch(this.endpoint, { method: 'GET' });
+        const json = await res.json();
+        const { encryptedId } = json;
+        if (encryptedId) this.$emit('encrypted-id-found', encryptedId);
+        this.$emit('response', json);
+      } catch (e) {
+        error('IdentityX to Omeda identification failed.', e);
+      }
+    },
+  },
+};
+</script>

package/components/identify.marko

@@ -0,0 +1,16 @@
+import getCookieId from "@mindful-web/marko-web-omeda-identity-x/utils/get-cookie-id";
+import { getResponseCookies } from "@mindful-web/utils";
+
+$ const { req, res } = out.global;
+$ const { identityX } = req;
+$ const cookies = { ...req.cookies, ...getResponseCookies(res) };
+$ const olyEncId = cookies.oly_enc_id ? getCookieId(cookies.oly_enc_id, 'enc') : undefined;
+$ const olyAnonId = cookies.oly_anon_id ? getCookieId(cookies.oly_anon_id, 'anon') : undefined;
+
+<if(Boolean(identityX))>
+  <marko-web-resolve|{ resolved: user }| promise=identityX.getIdentityData()>
+    <if(user || olyEncId || olyAnonId)>
+      <marko-web-identity-x-identify provider-data={ oly_enc_id: olyEncId, oly_anon_id: olyAnonId } />
+    </if>
+  </marko-web-resolve>
+</if>

package/components/identify.marko.js

@@ -0,0 +1,60 @@
+// Compiled using marko@4.20.2 - DO NOT EDIT
+"use strict";
+
+var marko_template = module.exports = require("marko/dist/html").t(__filename),
+    marko_componentType = "/@mindful-web/marko-web-omeda-identity-x$1.0.0/components/identify.marko",
+    marko_component = require("./identify.marko"),
+    marko_renderer = require("marko/dist/runtime/components/renderer"),
+    module_getCookieId = require("@mindful-web/marko-web-omeda-identity-x/utils/get-cookie-id"),
+    getCookieId = module_getCookieId.default || module_getCookieId,
+    module_utils_module = require("@mindful-web/utils"),
+    utils_module = module_utils_module.default || module_utils_module,
+    getResponseCookies = module_utils_module.getResponseCookies,
+    marko_web_identity_x_identify_template = require("@mindful-web/marko-web-identity-x/components/identify.marko"),
+    marko_loadTag = require("marko/dist/runtime/helpers/load-tag"),
+    marko_web_identity_x_identify_tag = marko_loadTag(marko_web_identity_x_identify_template),
+    marko_web_resolve_template = require("@mindful-web/marko-core/components/resolve.marko"),
+    marko_web_resolve_tag = marko_loadTag(marko_web_resolve_template);
+
+function render(input, out, __component, component, state) {
+  var data = input;
+
+  const { req, res } = out.global;
+
+  const { identityX } = req;
+
+  const cookies = { ...req.cookies, ...getResponseCookies(res) };
+
+  const olyEncId = cookies.oly_enc_id ? getCookieId(cookies.oly_enc_id, 'enc') : undefined;
+
+  const olyAnonId = cookies.oly_anon_id ? getCookieId(cookies.oly_anon_id, 'anon') : undefined;
+
+  if (Boolean(identityX)) {
+    marko_web_resolve_tag({
+        promise: identityX.getIdentityData(),
+        renderBody: function(out, { resolved: user }) {
+          if ((user || olyEncId) || olyAnonId) {
+            marko_web_identity_x_identify_tag({
+                providerData: {
+                    oly_enc_id: olyEncId,
+                    oly_anon_id: olyAnonId
+                  }
+              }, out, __component, "1");
+          }
+        }
+      }, out, __component, "0");
+  }
+}
+
+marko_template._ = marko_renderer(render, {
+    e_: marko_componentType
+  }, marko_component);
+
+marko_template.meta = {
+    id: "/@mindful-web/marko-web-omeda-identity-x$1.0.0/components/identify.marko",
+    component: "./identify.marko",
+    tags: [
+      "@mindful-web/marko-web-identity-x/components/identify.marko",
+      "@mindful-web/marko-core/components/resolve.marko"
+    ]
+  };

package/components/marko.json

@@ -0,0 +1,6 @@
+{
+  "taglib-imports": [],
+  "<marko-web-omeda-identity-x-identify>": {
+    "template": "./identify.marko"
+  }
+}

package/external-id/find-encrypted-customer-id.js

@@ -0,0 +1,10 @@
+const { asArray } = require('@mindful-web/utils');
+const getEncryptedId = require('./get-encrypted-customer-id');
+
+module.exports = ({ externalIds, brandKey } = {}) => {
+  const eid = asArray(externalIds).find((externalId) => getEncryptedId({
+    externalId,
+    brandKey,
+  }));
+  return eid ? eid.identifier.value : null;
+};

package/external-id/get-encrypted-customer-id.js

@@ -0,0 +1,7 @@
+const olyticsCookie = require('@mindful-web/marko-web-omeda/olytics/customer-cookie');
+const isEncryptedId = require('./is-encrypted-customer-id');
+
+module.exports = ({ externalId, brandKey } = {}) => {
+  if (!isEncryptedId({ externalId, brandKey })) return null;
+  return olyticsCookie.clean(externalId.identifier.value);
+};

package/external-id/get-omeda-namespaces.js

@@ -0,0 +1,16 @@
+const { asArray } = require('@mindful-web/utils');
+const isOmedaNamespace = require('./is-omeda-namespace');
+
+module.exports = ({
+  externalIds = [],
+  brandKey,
+  type,
+  idType,
+  valueMatcher,
+} = {}) => asArray(externalIds.filter((externalId) => isOmedaNamespace({
+  externalId,
+  brandKey,
+  type,
+  idType,
+  valueMatcher,
+})));

package/external-id/is-demographic-id.js

@@ -0,0 +1,8 @@
+const isOmedaNamespace = require('./is-omeda-namespace');
+
+module.exports = ({ externalId, brandKey } = {}) => isOmedaNamespace({
+  externalId,
+  brandKey,
+  type: 'demographic',
+  valueMatcher: (id) => parseInt(id, 10),
+});

package/external-id/is-deployment-type-id.js

@@ -0,0 +1,8 @@
+const isOmedaNamespace = require('./is-omeda-namespace');
+
+module.exports = ({ externalId, brandKey } = {}) => isOmedaNamespace({
+  externalId,
+  brandKey,
+  type: 'deploymentType',
+  valueMatcher: (id) => parseInt(id, 10),
+});

package/external-id/is-encrypted-customer-id.js

@@ -0,0 +1,10 @@
+const olyticsCookie = require('@mindful-web/marko-web-omeda/olytics/customer-cookie');
+const isOmedaNamespace = require('./is-omeda-namespace');
+
+module.exports = ({ externalId, brandKey } = {}) => isOmedaNamespace({
+  externalId,
+  brandKey,
+  type: 'customer',
+  idType: 'encrypted',
+  valueMatcher: (id) => olyticsCookie.clean(id),
+});

package/external-id/is-omeda-namespace.js

@@ -0,0 +1,18 @@
+const { isFunction: isFn } = require('@mindful-web/utils');
+
+module.exports = ({
+  externalId,
+  brandKey,
+  type,
+  idType,
+  valueMatcher,
+} = {}) => {
+  if (!externalId) return false;
+  const { namespace, identifier } = externalId;
+  return namespace.provider === 'omeda'
+    && namespace.tenant === brandKey.toLowerCase()
+    && (type ? namespace.type === type : true)
+    && identifier.value
+    && (idType ? identifier.type === idType : true)
+    && (isFn(valueMatcher) ? valueMatcher(identifier.value) : true);
+};

package/external-id/is-product-id.js

@@ -0,0 +1,8 @@
+const isOmedaNamespace = require('./is-omeda-namespace');
+
+module.exports = ({ externalId, brandKey } = {}) => isOmedaNamespace({
+  externalId,
+  brandKey,
+  type: 'product',
+  valueMatcher: (id) => parseInt(id, 10),
+});