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

package/index.js

@@ -0,0 +1,261 @@
+const Joi = require('@parameter1/joi');
+const { validate } = require('@parameter1/joi/utils');
+const omeda = require('@mindful-web/marko-web-omeda');
+const identityX = require('@mindful-web/marko-web-identity-x');
+const addOmedaHooksToIdentityXConfig = require('./add-integration-hooks');
+const setPromoSourceCookie = require('./middleware/set-promo-source');
+const stripOlyticsParam = require('./middleware/strip-olytics-param');
+const resyncCustomerData = require('./middleware/resync-customer-data');
+const setOlyticsCookie = require('./middleware/set-olytics-cookie');
+const setIdentityCookie = require('./middleware/set-identity-cookie');
+const rapidIdentify = require('./middleware/rapid-identify');
+const rapidIdentifyRouter = require('./routes/rapid-identify');
+const props = require('./validation/props');
+const schemas = require('./validation/schemas');
+
+/**
+ * @typedef {import('./validation/schemas/hook-behavior')
+ *            .HookBehaviorSchema} HookBehaviorSchema
+ * @typedef {import('./validation/schemas/hook-demographic')
+ *            .HookDemographicSchema} HookDemographicSchema
+ * @typedef {import('./validation/schemas/hook-promo-code')
+ *            .HookPromoCodeSchema} HookPromoCodeSchema
+ * @typedef {import('@mindful-web/marko-web-identity-x/config')} IdentityXConfig
+
+ * @typedef OmedaIdentityXConfig
+ * @prop {HookDemographicSchema[]} appendDemographicToHook
+ * @prop {HookPromoCodeSchema[]} appendPromoCodeToHook
+ * @prop {string} appId The Omeda Application Identifier
+ * @prop {BehaviorSchema} behaviors
+ * @prop {BehaviorAttributeSchema} behaviorAttributes
+ * @prop {string} brandKey
+ * @prop {string} clientKey
+ * @prop {boolean} [createFromIdentity=true] createFromIdentity
+ * @prop {HookBehaviorSchema[]} hookBehavior
+ * @prop {IdentityXConfig} idxConfig
+ * @prop {string} [idxOmedaRapidIdentifyProp=$idxOmedaRapidIdentify]
+ * @prop {object} idxRouteTemplates
+ * @prop {string} inputId
+ * @prop {string} [omedaGraphQLClientProp=$omedaGraphQLClient]
+ * @prop {string} [omedaPromoCodeCookieName=omeda_promo_code]
+ * @prop {?string} omedaPromoCodeDefault
+ * @prop {string} [omedaRapidIdentifyProp=$omedaRapidIdentify]
+ * @prop {?ShouldAwaitSchema} shouldAwait
+ * @prop {?Promise<object>} onLoginLinkSentFormatter
+ * @prop {?Promise<object>} onAuthenticationSuccessFormatter
+ * @prop {?Promise<object>} onUserProfileUpdateFormatter
+ * @prop {number} rapidIdentProductId
+ *
+ * @typedef BehaviorSchema
+ * @prop {number} logIn
+ * @prop {number} verifyEmail
+ * @prop {number} submitProfile
+ *
+ * @typedef BehaviorAttributeSchema
+ * @prop {BehaviorAttributeWebsite} website
+ * @prop {BehaviorAttributeActionSource} actionSource
+ * @prop {BehaviorAttributeNewsletterSignupType} newsletterSignupType
+ * @prop {BehaviorAttributeContentGateType} contentGateType
+ *
+ * @typedef BehaviorAttributeWebsite
+ * @prop {number} id
+ * @prop {number} valueId
+ *
+ * @typedef BehaviorAttributeActionSource
+ * @prop {number} id
+ * @prop {object} valueIds
+ * @prop {number} valueIds.default
+ * @prop {number} valueIds.newsletterSignup
+ * @prop {number} valueIds.comments
+ * @prop {number} valueIds.contentGate
+ *
+ * @typedef BehaviorAttributeContentGateType
+ * @prop {number} id
+ * @prop {object} valueIds
+ * @prop {number} valueIds.default
+ * @prop {number} valueIds.metered
+ * @prop {number} valueIds.printPreview
+ *
+ * @typedef BehaviorAttributeNewsletterSignupType
+ * @prop {number} id
+ * @prop {object} valueIds
+ * @prop {number} valueIds.default
+ * @prop {number} valueIds.pushdown
+ * @prop {number} valueIds.inlineContent
+ * @prop {number} valueIds.inlineSection
+ * @prop {number} valueIds.footer
+ *
+ * @typedef ShouldAwaitSchema
+ * @prop {boolean} [onLoginLinkSent=false] onLoginLinkSent
+ * @prop {boolean} [onAuthenticationSuccess=true] onAuthenticationSuccess
+ * @prop {boolean} [onUserProfileUpdate=false] onUserProfileUpdate
+ */
+
+const defaultFormatter = async ({ payload }) => payload;
+
+/**
+ * @param {import('express').Application} app
+ * @param {OmedaIdentityXConfig} params
+ */
+module.exports = (app, params = {}) => {
+  const {
+    appendBehaviorToHook,
+    appendDemographicToHook,
+    appendPromoCodeToHook,
+    appId,
+    behaviors,
+    behaviorAttributes,
+    brandKey,
+    clientKey,
+    createFromIdentity,
+    idxConfig,
+    idxOmedaRapidIdentifyProp,
+    idxRouteTemplates,
+    inputId,
+    omedaGraphQLClientProp,
+    omedaPromoCodeCookieName,
+    omedaPromoCodeDefault,
+    omedaRapidIdentifyProp,
+    shouldAwait,
+    onLoginLinkSentFormatter = defaultFormatter,
+    onAuthenticationSuccessFormatter = defaultFormatter,
+    onUserProfileUpdateFormatter = defaultFormatter,
+    rapidIdentProductId,
+  } = validate(Joi.object({
+    appendBehaviorToHook: Joi.array().items(schemas.hookBehavior),
+    appendDemographicToHook: Joi.array().items(schemas.hookDemographic),
+    appendPromoCodeToHook: Joi.array().items(schemas.hookPromoCode),
+    appId: Joi.string().required(),
+    shouldAwait: schemas.shouldAwait,
+    /**
+     * Behavior config is now mandatory and can be generated by the CLI.
+     * @see https://github.com/parameter1/identity-x-omeda-cli
+     *  */
+    behaviors: Joi.object({
+      logIn: Joi.number().required(),
+      verifyEmail: Joi.number().required(),
+      submitProfile: Joi.number().required(),
+    }).required(),
+    behaviorAttributes: Joi.object({
+      website: Joi.object({
+        // The Omeda BehaviorAttribute ID for the `Parameter1 Website` attribute.
+        id: Joi.number().required(),
+        // The Omeda DefinedValue ID for the current website.
+        valueId: Joi.number().required(),
+      }).required(),
+      actionSource: Joi.object({
+        // The Omeda BehaviorAttribute ID for the `Parameter1 Action Source` attribute.
+        id: Joi.number().required(),
+        valueIds: Joi.object({
+          default: Joi.number().required(),
+          newsletterSignup: Joi.number().required(),
+          comments: Joi.number().required(),
+          contentGate: Joi.number().required(),
+        }).required(),
+      }).required(),
+      newsletterSignupType: Joi.object({
+        // The Omeda BehaviorAttribute ID for the `Parameter1 Newsletter Signup Type` attribute.
+        id: Joi.number().required(),
+        valueIds: Joi.object({
+          default: Joi.number().required(),
+          pushdown: Joi.number().required(),
+          inlineContent: Joi.number().required(),
+          inlineSection: Joi.number().required(),
+          footer: Joi.number().required(),
+        }).required(),
+      }).required(),
+      contentGateType: Joi.object({
+        // The Omeda BehaviorAttribute ID for the `Parameter1 Content Gate Type` attribute.
+        id: Joi.number().required(),
+        valueIds: Joi.object({
+          default: Joi.number().required(),
+          metered: Joi.number().required(),
+          printPreview: Joi.number().required(),
+        }).required(),
+      }).required(),
+    }).required(),
+    brandKey: props.brandKey.required(),
+    clientKey: props.clientKey.required(),
+    createFromIdentity: Joi.boolean().default(true),
+    idxConfig: props.idxConfig.required(),
+    idxOmedaRapidIdentifyProp: Joi.string().default('$idxOmedaRapidIdentify'),
+    idxRouteTemplates: Joi.object().required(),
+    inputId: Joi.string().required(),
+    omedaGraphQLClientProp: Joi.string().default('$omedaGraphQLClient'),
+    omedaPromoCodeCookieName: Joi.string().default('omeda_promo_code'),
+    omedaPromoCodeDefault: Joi.string(),
+    omedaRapidIdentifyProp: Joi.string().default('$omedaRapidIdentify'),
+    onLoginLinkSentFormatter: Joi.function(),
+    onAuthenticationSuccessFormatter: Joi.function(),
+    onUserProfileUpdateFormatter: Joi.function(),
+    rapidIdentProductId: Joi.number().required(),
+  }), params);
+
+  // strip `oly_enc_id` when identity-x user is logged-in
+  app.use(stripOlyticsParam());
+
+  // set `omeda_promo_code` when the URL parameter is present
+  app.use(setPromoSourceCookie({
+    omedaPromoCodeCookieName,
+  }));
+
+  // install omeda middleware
+  omeda(app, {
+    brandKey,
+    clientKey,
+    appId,
+    inputId,
+    rapidIdentProductId,
+    omedaGraphQLClientProp,
+    omedaRapidIdentifyProp,
+  });
+
+  // add appropiate identity-x to omeda integration hooks
+  addOmedaHooksToIdentityXConfig({
+    appendBehaviorToHook,
+    appendDemographicToHook,
+    appendPromoCodeToHook,
+    behaviors,
+    behaviorAttributes,
+    brandKey,
+    idxConfig,
+    idxOmedaRapidIdentifyProp,
+    omedaGraphQLClientProp,
+    omedaPromoCodeCookieName,
+    omedaPromoCodeDefault,
+    shouldAwait,
+    onLoginLinkSentFormatter,
+    onAuthenticationSuccessFormatter,
+    onUserProfileUpdateFormatter,
+  });
+
+  // attach the identity-x rapid identification wrapper middleware
+  app.use(rapidIdentify({
+    brandKey,
+    productId: rapidIdentProductId,
+    prop: idxOmedaRapidIdentifyProp,
+    omedaRapidIdentifyProp,
+    omedaPromoCodeCookieName,
+    omedaPromoCodeDefault,
+  }));
+
+  // install identity x
+  identityX(app, idxConfig, { templates: idxRouteTemplates });
+
+  app.use(setOlyticsCookie({ brandKey }));
+  app.use(setIdentityCookie({ brandKey, createFromIdentity }));
+
+  // install the Omeda data sync middleware
+  app.use(resyncCustomerData({
+    brandKey,
+    omedaGraphQLClientProp,
+  }));
+
+  // register the rapid identify AJAX route
+  app.use('/__idx/omeda-rapid-ident', rapidIdentifyRouter({
+    brandKey,
+    idxOmedaRapidIdentifyProp,
+    omedaPromoCodeCookieName,
+    omedaPromoCodeDefault,
+  }));
+};

package/integration-hooks/index.js

@@ -0,0 +1,9 @@
+const onAuthenticationSuccess = require('./on-authentication-success');
+const onLoginLinkSent = require('./on-login-link-sent');
+const onUserProfileUpdate = require('./on-user-profile-update');
+
+module.exports = {
+  onAuthenticationSuccess,
+  onLoginLinkSent,
+  onUserProfileUpdate,
+};

package/integration-hooks/on-authentication-success.js

@@ -0,0 +1,59 @@
+const Joi = require('@parameter1/joi');
+const { validate } = require('@parameter1/joi/utils');
+const olyticsCookie = require('@mindful-web/marko-web-omeda/olytics/customer-cookie');
+const extractPromoCode = require('../utils/extract-promo-code');
+const findEncryptedId = require('../external-id/find-encrypted-customer-id');
+const props = require('../validation/props');
+const schemas = require('../validation/schemas');
+
+module.exports = async (params = {}) => {
+  const {
+    appendBehaviors,
+    appendDemographics,
+    appendPromoCodes,
+    behavior,
+    brandKey,
+    formatter,
+    idxOmedaRapidIdentify,
+    omedaPromoCodeCookieName,
+    omedaPromoCodeDefault,
+    promoCode: hookDataPromoCode,
+    res,
+    req,
+    user,
+  } = validate(Joi.object({
+    appendBehaviors: Joi.array().items(schemas.appendBehavior).default([]),
+    appendDemographics: Joi.array().items(schemas.appendDemographic).default([]),
+    appendPromoCodes: Joi.array().items(schemas.appendPromoCode).default([]),
+    behavior: schemas.behavior.required(),
+    brandKey: props.brandKey.required(),
+    formatter: Joi.function().required(),
+    user: Joi.object().required(),
+    res: Joi.object().required(),
+    req: Joi.object().required(),
+  }).unknown(true), params);
+  const encryptedId = findEncryptedId({ externalIds: user.externalIds, brandKey });
+  if (!encryptedId) return;
+  olyticsCookie.setTo(res, encryptedId);
+
+  const promoCode = extractPromoCode({
+    promoCode: hookDataPromoCode,
+    omedaPromoCodeCookieName,
+    omedaPromoCodeDefault,
+    cookies: res.req.cookies,
+  });
+
+  const payload = await formatter({
+    ...params, // Pass all params through to the formatter
+    req,
+    payload: {
+      user,
+      behavior,
+      promoCode,
+      appendBehaviors,
+      appendDemographics,
+      appendPromoCodes,
+    },
+  });
+  await idxOmedaRapidIdentify(payload);
+};

package/integration-hooks/on-login-link-sent.js

@@ -0,0 +1,106 @@
+const Joi = require('@parameter1/joi');
+const { validate } = require('@parameter1/joi/utils');
+const extractPromoCode = require('../utils/extract-promo-code');
+const schemas = require('../validation/schemas');
+const {
+  getAnsweredQuestionMap,
+  getOmedaCustomerRecord,
+  getOmedaLinkedFields,
+  updateIdentityX,
+} = require('../omeda-data');
+const props = require('../validation/props');
+
+module.exports = async (params = {}) => {
+  const {
+    appendBehaviors,
+    appendDemographics,
+    appendPromoCodes,
+    behavior,
+    brandKey,
+    formatter,
+    idxOmedaRapidIdentify,
+    omedaGraphQLClient,
+    omedaPromoCodeCookieName,
+    omedaPromoCodeDefault,
+    promoCode: hookDataPromoCode,
+    req,
+    source,
+    service: identityX,
+    user,
+  } = validate(Joi.object({
+    appendBehaviors: Joi.array().items(schemas.appendBehavior).default([]),
+    appendDemographics: Joi.array().items(schemas.appendDemographic).default([]),
+    appendPromoCodes: Joi.array().items(schemas.appendPromoCode).default([]),
+    behavior: schemas.behavior.required(),
+    brandKey: props.brandKey.required(),
+    formatter: Joi.function().required(),
+    idxOmedaRapidIdentify: Joi.function().required(),
+    omedaGraphQLClient: Joi.object().required(),
+    omedaPromoCodeCookieName: Joi.string().required(),
+    omedaPromoCodeDefault: Joi.string(),
+    promoCode: Joi.string(),
+    req: Joi.object().required(),
+    source: Joi.string().required(),
+    service: Joi.object().required(),
+    user: Joi.object().required(),
+  }).unknown(), params);
+
+  const promoCode = extractPromoCode({
+    promoCode: hookDataPromoCode,
+    omedaPromoCodeCookieName,
+    omedaPromoCodeDefault,
+    cookies: req.cookies,
+  });
+
+  const requiredCreateFields = identityX.config.getRequiredCreateFields();
+
+  const [omedaLinkedFields, { encryptedCustomerId }] = await Promise.all([
+    getOmedaLinkedFields({ identityX, brandKey }),
+    idxOmedaRapidIdentify(await formatter({
+      ...params, // Pass all params through to the formatter
+      req,
+      source,
+      payload: {
+        user: user.verified ? user : {
+          ...(requiredCreateFields.reduce((obj, key) => ({ ...obj, [key]: user[key] }), {})),
+          id: user.id,
+          email: user.email,
+        },
+        behavior,
+        promoCode,
+        appendBehaviors,
+        appendDemographics,
+        appendPromoCodes,
+      },
+    })),
+  ]);
+
+  const answers = getAnsweredQuestionMap(user);
+  const hasAllDemos = omedaLinkedFields.demographic.every((field) => answers.has(field.id));
+  const hasAllDeployments = omedaLinkedFields.deploymentType
+    .every((field) => answers.has(field.id));
+  const hasAllProducts = omedaLinkedFields.product.every((field) => answers.has(field.id));
+  const hasAnsweredAllOmedaQuestions = hasAllDemos && hasAllDeployments && hasAllProducts;
+
+  // If the user is verified and has answered all Omeda questions, do nothing.
+  if (user.verified && hasAnsweredAllOmedaQuestions) return;
+
+  // Find the Omeda customer record to prime the identity-x user record.
+  const omedaCustomer = await getOmedaCustomerRecord({ omedaGraphQLClient, encryptedCustomerId });
+
+  // Update the IdentityX user record with the Omeda data (if any is present)
+  await updateIdentityX({
+    identityX,
+    brandKey,
+    user,
+    omedaCustomer,
+    omedaLinkedFields,
+  }, {
+    // Only set existing Omeda data to IdentityX if the user is not yet verified (aka, new user)
+    updateData: !user.verified,
+    // Update each type of linked (custom select/boolean) field if any are missing a value.
+    updateDemographics: !hasAllDemos,
+    updateDeploymentTypes: !hasAllDeployments,
+    updateProducts: !hasAllProducts,
+  });
+};

package/integration-hooks/on-user-profile-update.js

@@ -0,0 +1,54 @@
+const Joi = require('@parameter1/joi');
+const { validate } = require('@parameter1/joi/utils');
+const extractPromoCode = require('../utils/extract-promo-code');
+const schemas = require('../validation/schemas');
+
+module.exports = async (params = {}) => {
+  const {
+    appendBehaviors,
+    appendDemographics,
+    appendPromoCodes,
+    behavior,
+    formatter,
+    idxOmedaRapidIdentify,
+    omedaPromoCodeCookieName,
+    omedaPromoCodeDefault,
+    promoCode: hookDataPromoCode,
+    req,
+    user,
+  } = validate(Joi.object({
+    appendBehaviors: Joi.array().items(schemas.appendBehavior).default([]),
+    appendDemographics: Joi.array().items(schemas.appendDemographic).default([]),
+    appendPromoCodes: Joi.array().items(schemas.appendPromoCode).default([]),
+    behavior: schemas.behavior.required(),
+    formatter: Joi.function().required(),
+    idxOmedaRapidIdentify: Joi.function().required(),
+    omedaPromoCodeCookieName: Joi.string().required(),
+    omedaPromoCodeDefault: Joi.string(),
+    promoCode: Joi.string(),
+    req: Joi.object().required(),
+    user: Joi.object().required(),
+  }).unknown(), params);
+
+  const promoCode = extractPromoCode({
+    promoCode: hookDataPromoCode,
+    omedaPromoCodeCookieName,
+    omedaPromoCodeDefault,
+    cookies: req.cookies,
+  });
+
+  const payload = await formatter({
+    ...params, // Pass all params through to the formatter
+    req,
+    payload: {
+      user,
+      behavior,
+      promoCode,
+      appendBehaviors,
+      appendDemographics,
+      appendPromoCodes,
+    },
+  });
+
+  return idxOmedaRapidIdentify(payload);
+};

package/marko.json

@@ -0,0 +1,6 @@
+{
+  "taglib-id": "@mindful-web/marko-web-omeda",
+  "taglib-imports": [
+    "./components/marko.json"
+  ]
+}

package/middleware/README.md

@@ -0,0 +1,12 @@
+Omeda+IdentityX Middleware
+===
+
+## Set Identity Cookie
+This [middleware](./set-identity-cookie.js) sets the IdentityX Identity cookie. This cookie represents the identity that all user behavior should be attributed to.
+
+Test cases:
+1. Fully anonymous user (no omeda or idx tokens). No cookie should be set.
+2. Logged in user w/o cookie: cookkie should be set
+3. Logged in user w/ cookie: Cookie shoudl not be set.
+4. Omeda identity cookie present, identityx user exists for ext id: cookie shoul dbe set.
+5. Omeda identity cookie present, no identityx user exists: cookie should be set.

package/middleware/rapid-identify.js

@@ -0,0 +1,56 @@
+const idxOmedaRapidIdentify = require('../rapid-identify');
+const extractPromoCode = require('../utils/extract-promo-code');
+
+module.exports = ({
+  brandKey,
+  productId,
+
+  prop = '$idxOmedaRapidIdentify',
+  omedaRapidIdentifyProp = '$omedaRapidIdentify',
+  omedaPromoCodeCookieName = 'omeda_promo_code',
+  omedaPromoCodeDefault,
+}) => {
+  if (!prop) throw new Error('An Omeda + IdentityX rapid identifcation prop is required.');
+  if (!omedaRapidIdentifyProp) throw new Error('The Omeda rapid identifcation prop is required.');
+
+  return (req, res, next) => {
+    const omedaRapidIdentify = req[omedaRapidIdentifyProp];
+    if (!omedaRapidIdentify) throw new Error(`Unable to find the Omeda rapid identifier on the request using ${omedaRapidIdentifyProp}`);
+
+    const handler = async ({
+      user,
+      promoCode,
+      deploymentTypes,
+      appendBehaviors,
+      appendDemographics,
+      appendPromoCodes,
+      behavior,
+    } = {}) => idxOmedaRapidIdentify({
+      brandKey,
+      productId,
+      appUser: user,
+      promoCode: extractPromoCode({
+        promoCode,
+        omedaPromoCodeCookieName,
+        omedaPromoCodeDefault,
+        cookies: req.cookies,
+      }),
+
+      // Custom behaviors, demos, or codes to append to the API call
+      deploymentTypes,
+      appendBehaviors,
+      appendDemographics,
+      appendPromoCodes,
+
+      // The pre-configured behavior/attribute definitions.
+      behavior,
+
+      identityX: req.identityX,
+      omedaRapidIdentify,
+    });
+
+    req[prop] = handler;
+    res.locals[prop] = handler;
+    next();
+  };
+};

package/middleware/resync-customer-data.js

@@ -0,0 +1,69 @@
+const { asyncRoute } = require('@mindful-web/utils');
+const { getAsArray } = require('@mindful-web/object-path');
+const resyncCookie = require('../utils/resync-cookie');
+const findEncryptedId = require('../external-id/find-encrypted-customer-id');
+const {
+  getOmedaCustomerRecord,
+  getOmedaLinkedFields,
+  updateIdentityX,
+} = require('../omeda-data');
+
+const { log } = console;
+
+/**
+ * A middleware to resync the IdentityX user data with the Omeda customer data. After syncing data,
+ * sets a cookie to prevent resyncs for the configured timeframe.
+ */
+module.exports = ({
+  brandKey,
+  omedaGraphQLClientProp = '$omedaGraphQLClient',
+}) => asyncRoute(async (req, res, next) => {
+  const { identityX, [omedaGraphQLClientProp]: omedaGraphQLClient } = req;
+  if (!omedaGraphQLClient) throw new Error(`Unable to load the Omeda GraphQL API from the request using prop ${omedaGraphQLClientProp}`);
+
+  // Load the user and find their external ID
+  const { user } = await req.identityX.loadActiveContext();
+  if (!user) return next();
+
+  // Only check for the cookie if we have a valid IdX user and Omeda customer
+  const encryptedCustomerId = findEncryptedId({ externalIds: getAsArray(user, 'externalIds'), brandKey });
+  if (!encryptedCustomerId) return next();
+
+  // If the cookie doesn't exist (or has expired), resync the user data
+  const cookie = resyncCookie.parseFrom(req);
+  if (cookie) return next();
+
+  // Load the customer data from Omeda and fields from IdentityX
+  const [omedaCustomer, omedaLinkedFields] = await Promise.all([
+    getOmedaCustomerRecord({ omedaGraphQLClient, encryptedCustomerId }),
+    getOmedaLinkedFields({ identityX, brandKey }),
+  ]);
+
+  if (!omedaCustomer) {
+    log(`Unable to resync Omeda customer using "${encryptedCustomerId}", aborting sync!`);
+    return next();
+  }
+
+  // Update the IdentityX user record custom select fields with the Omeda user data
+  await updateIdentityX({
+    identityX,
+    brandKey,
+    user,
+    omedaCustomer,
+    omedaLinkedFields,
+  }, {
+    // Do not update core user fields (name, email, etc) on a verified user.
+    updateData: !user.verified,
+    // Update any linked custom fields with the relevant values from Omeda.
+    updateDemographics: true,
+    updateDeploymentTypes: true,
+    updateProducts: true,
+  });
+
+  // Set the cookie to prevent further resyncs until interval is reached.
+  const value = { lastSync: Date.now() };
+  const maxAge = identityX.config.get('userResyncInterval', 7 * 24 * 60 * 60 * 1000); // 1 week
+  resyncCookie.setTo({ res, value, maxAge });
+
+  return next();
+});