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

package/middleware/set-identity-cookie.js

@@ -0,0 +1,77 @@
+const { asyncRoute } = require('@mindful-web/utils');
+const { get } = require('@mindful-web/object-path');
+const olyticsCookie = require('@mindful-web/marko-web-omeda/olytics/customer-cookie');
+const { getResponseCookies } = require('@mindful-web/utils');
+const query = require('../api/queries/customer-by-encrypted-id');
+
+/**
+ *
+ * @param {import('express').Request} req
+ * @param {import('express').Response} res
+ * @returns {String|null}
+ */
+const findOlyticsId = (req, res) => {
+  // Read from request cookies
+  const reqId = olyticsCookie.parseFrom(req);
+  if (reqId) return reqId;
+  // request query param
+  const { oly_enc_id: qId } = req.query;
+  if (qId && olyticsCookie.clean(qId)) return olyticsCookie.clean(qId);
+  // response cookie
+  const cookies = getResponseCookies(res);
+  const resId = olyticsCookie.parseFrom({ cookies });
+  return resId;
+};
+
+/**
+ * @typedef OIDXRequest
+ * @prop {import('@parameter1/omeda-graphql-client')} $omedaGraphQLClient
+ * @prop {import('@mindful-web/marko-web-identity-x/service')} identityX
+ *
+ * @typedef MiddlewareConstructor
+ * @prop {string} brandKey              The Omeda Brand Key (tenant identifier).
+ * @prop {boolean} createFromIdentity   If true, create the app user and set identity's external id.
+ *
+ * @param {MiddlewareConstructor}
+ */
+module.exports = ({
+  brandKey,
+  createFromIdentity = true,
+}) => asyncRoute(async (req, res, next) => {
+  /** @type {OIDXRequest} */
+  const { identityX: idx, $omedaGraphQLClient: omeda } = req;
+  const cookie = idx.getIdentity(res);
+
+  // Don't overwrite an existing cookie
+  if (cookie) return next();
+
+  // get oly enc id. if we don't have one, bail
+  const omedaId = findOlyticsId(req, res);
+  if (!omedaId) return next();
+
+  // Look up idx user by encrypted id
+  const namespace = { provider: 'omeda', tenant: brandKey.toLowerCase(), type: 'customer' };
+  const identity = await idx.findUserByExternalId({ identifier: omedaId, namespace });
+  if (identity) {
+    idx.setIdentityCookie(identity.id);
+    return next();
+  }
+
+  // If disabled, don't create a user from the incoming identity.
+  if (!createFromIdentity) return next();
+
+  const or = await omeda.query({ query, variables: { id: omedaId } });
+  const email = get(or, 'data.customerByEncryptedId.primaryEmailAddress.emailAddress');
+  if (email) {
+    // Upsert the user and add the external id to it.
+    const { id } = await idx.createAppUser({ email });
+    await idx.addExternalUserId({
+      userId: id,
+      identifier: { value: omedaId, type: 'encrypted' },
+      namespace,
+    });
+    idx.setIdentityCookie(id);
+    return next();
+  }
+  return next();
+});

package/middleware/set-olytics-cookie.js

@@ -0,0 +1,25 @@
+const { asyncRoute } = require('@mindful-web/utils');
+const olyticsCookie = require('@mindful-web/marko-web-omeda/olytics/customer-cookie');
+const findEncryptedId = require('../external-id/find-encrypted-customer-id');
+
+module.exports = ({
+  brandKey,
+}) => asyncRoute(async (req, res, next) => {
+  const { user } = await req.identityX.loadActiveContext();
+
+  if (!user || !user.id) return next();
+  const idxEncId = findEncryptedId({ externalIds: user.externalIds, brandKey });
+  const cookieEncId = olyticsCookie.parseFrom(req);
+  if (!idxEncId && cookieEncId && !res.headersSent) {
+    // an identity-x user without an encrypted id is logged in.
+    // clear any encrypted id cookies if they are set.
+    olyticsCookie.clearFrom(res);
+    return next();
+  }
+  // if theres a mismatch between the idx user encrypted id and the
+  // cookie id, reset the cookie id.
+  if (idxEncId !== cookieEncId && !res.headersSent) {
+    olyticsCookie.setTo(res, idxEncId);
+  }
+  return next();
+});

package/middleware/set-promo-source.js

@@ -0,0 +1,20 @@
+/**
+ * Sets the `omeda_promo_code` cookie to identify the customer's promotion source if the
+ * `omeda_promo_code` URL parameter is present.
+ * '
+ * @param {String} omedaPromoCodeCookieName The name of the cookie to interact with
+ */
+module.exports = ({
+  omedaPromoCodeCookieName = 'omeda_promo_code',
+} = {}) => (req, res, next) => {
+  const { [omedaPromoCodeCookieName]: promoCode } = req.query;
+  const incomingPromoCode = `${promoCode || ''}`.trim().toUpperCase();
+
+  // Set the promo source cookie
+  if (incomingPromoCode) {
+    const options = { maxAge: 60 * 60 * 24 * 365, httpOnly: false };
+    res.cookie(omedaPromoCodeCookieName, incomingPromoCode, options);
+  }
+
+  next();
+};

package/middleware/strip-olytics-param.js

@@ -0,0 +1,23 @@
+const tokenCookie = require('@mindful-web/marko-web-identity-x/utils/token-cookie');
+const olyticsCookie = require('@mindful-web/marko-web-omeda/olytics/customer-cookie');
+
+module.exports = () => (req, res, next) => {
+  const currentEncId = olyticsCookie.parseFrom(req);
+  const idxUserExists = tokenCookie.exists(req);
+
+  const { oly_enc_id: id, ...q } = req.query;
+  const incomingEncId = olyticsCookie.clean(id);
+
+  if (!idxUserExists && incomingEncId && incomingEncId !== currentEncId) {
+    // No IdentityX context, set the cookie and move on
+    olyticsCookie.setTo(res, incomingEncId);
+    next();
+  } else if (idxUserExists && incomingEncId && incomingEncId !== currentEncId) {
+    // Incoming id conflicts!
+    const params = (new URLSearchParams(q)).toString();
+    const redirectTo = `${req.path}${params ? `?${params}` : ''}`;
+    res.redirect(302, redirectTo);
+  } else {
+    next();
+  }
+};

package/omeda-data/get-answered-question-map.js

@@ -0,0 +1,19 @@
+/**
+ * Builds a map of user answers to custom select/boolean questions.
+ */
+module.exports = (user) => {
+  const answeredQuestionMap = new Map();
+  user.customSelectFieldAnswers.forEach((select) => {
+    if (!select.hasAnswered) return;
+    answeredQuestionMap.set(select.field.id, true);
+  });
+  user.customBooleanFieldAnswers.forEach((boolean) => {
+    if (!boolean.hasAnswered) return;
+    answeredQuestionMap.set(boolean.field.id, true);
+  });
+  user.customTextFieldAnswers.forEach((field) => {
+    if (!field.hasAnswered) return;
+    answeredQuestionMap.set(field.field.id, true);
+  });
+  return answeredQuestionMap;
+};

package/omeda-data/get-omeda-customer-record.js

@@ -0,0 +1,46 @@
+const gql = require('graphql-tag');
+
+const query = gql`
+  query CustomerByEncryptedId($id: String!) {
+    customerByEncryptedId(input: { id: $id, errorOnNotFound: false }) {
+      id
+      firstName
+      lastName
+      title
+      companyName
+      primaryPostalAddress {
+        countryCode
+        regionCode
+        postalCode
+        street
+        extraAddress
+        city
+      }
+      primaryMobileNumber {
+        phoneNumber
+      }
+      primaryPhoneNumber {
+        phoneNumber
+      }
+      demographics {
+        demographic { id description }
+        value { id description }
+        valueText
+        writeInDesc
+      }
+      primaryEmailAddress {
+        optInStatus { deploymentTypeId status { id } }
+      }
+      subscriptions {
+        product { id deploymentTypeId }
+        receive
+      }
+    }
+  }
+`;
+
+module.exports = async ({ omedaGraphQLClient, encryptedCustomerId }) => {
+  const variables = { id: encryptedCustomerId };
+  const { data } = await omedaGraphQLClient.query({ query, variables });
+  return data.customerByEncryptedId;
+};

package/omeda-data/get-omeda-linked-fields.js

@@ -0,0 +1,66 @@
+const gql = require('graphql-tag');
+const { getAsArray } = require('@mindful-web/object-path');
+const isOmedaDeploymentTypeId = require('../external-id/is-deployment-type-id');
+const isOmedaDemographicId = require('../external-id/is-demographic-id');
+const isOmedaProductId = require('../external-id/is-product-id');
+
+const query = gql`
+  query GetCustomFields {
+    fields {
+      edges {
+        node {
+          id
+          name
+          type
+          active
+          externalId {
+            id
+            namespace { provider tenant type }
+            identifier { value }
+          }
+          ... on SelectField {
+            multiple
+            options {
+              id
+              externalIdentifier
+            }
+          }
+
+          ... on BooleanField {
+            whenTrue { type value }
+            whenFalse { type value }
+          }
+        }
+      }
+    }
+  }
+`;
+
+module.exports = async ({
+  identityX,
+  brandKey,
+}) => {
+  const { data } = await identityX.client.query({ query });
+
+  const omedaLinkedFields = {
+    demographic: [],
+    deploymentType: [],
+    product: [],
+  };
+  getAsArray(data, 'fields.edges').forEach((edge) => {
+    const { node: field } = edge;
+    const { externalId } = field;
+    if (!field.active || !externalId) return;
+    if (isOmedaDemographicId({ externalId, brandKey })) {
+      omedaLinkedFields.demographic.push(field);
+    }
+    if (field.type === 'boolean' && isOmedaDeploymentTypeId({ externalId, brandKey })) {
+      omedaLinkedFields.deploymentType.push(field);
+    }
+    if (field.type === 'boolean' && isOmedaProductId({ externalId, brandKey })) {
+      omedaLinkedFields.product.push(field);
+    }
+  });
+
+  return omedaLinkedFields;
+};

package/omeda-data/index.js

@@ -0,0 +1,19 @@
+const getAnsweredQuestionMap = require('./get-answered-question-map');
+const getOmedaCustomerRecord = require('./get-omeda-customer-record');
+const getOmedaLinkedFields = require('./get-omeda-linked-fields');
+const setOmedaData = require('./set-omeda-data');
+const setOmedaDemographics = require('./set-omeda-demographics');
+const setOmedaDeploymentTypes = require('./set-omeda-deployment-types');
+const setOmedaProducts = require('./set-omeda-products');
+const updateIdentityX = require('./update-identity-x');
+
+module.exports = {
+  getAnsweredQuestionMap,
+  getOmedaCustomerRecord,
+  getOmedaLinkedFields,
+  setOmedaData,
+  setOmedaDemographics,
+  setOmedaDeploymentTypes,
+  setOmedaProducts,
+  updateIdentityX,
+};

package/omeda-data/set-omeda-data.js

@@ -0,0 +1,35 @@
+const gql = require('graphql-tag');
+const { get } = require('@mindful-web/object-path');
+
+const SET_OMEDA_DATA = gql`
+mutation SetOmedaData($input: SetAppUserUnverifiedDataMutationInput!) {
+  setAppUserUnverifiedData(input: $input) { id }
+}
+`;
+
+/**
+* Sets Omeda customer data (such as name, address, etc) to the IdentityX user fields.
+*/
+module.exports = async ({ identityX, user, omedaCustomer }) => {
+  const input = {
+    email: user.email,
+
+    givenName: omedaCustomer.firstName,
+    familyName: omedaCustomer.lastName,
+    organization: omedaCustomer.companyName,
+    organizationTitle: omedaCustomer.title,
+
+    countryCode: get(omedaCustomer, 'primaryPostalAddress.countryCode'),
+    regionCode: get(omedaCustomer, 'primaryPostalAddress.regionCode'),
+    postalCode: get(omedaCustomer, 'primaryPostalAddress.postalCode'),
+    street: get(omedaCustomer, 'primaryPostalAddress.street'),
+    addressExtra: get(omedaCustomer, 'primaryPostalAddress.extraAddress'),
+    city: get(omedaCustomer, 'primaryPostalAddress.city'),
+    mobileNumber: get(omedaCustomer, 'primaryMobileNumber.phoneNumber'),
+    phoneNumber: get(omedaCustomer, 'primaryPhoneNumber.phoneNumber'),
+  };
+  return identityX.client.mutate({
+    mutation: SET_OMEDA_DATA,
+    variables: { input },
+  });
+};

package/omeda-data/set-omeda-demographics.js

@@ -0,0 +1,137 @@
+const gql = require('graphql-tag');
+const getAnsweredQuestionMap = require('./get-answered-question-map');
+
+const SET_OMEDA_SELECT_FIELD_ANSWERS = gql`
+  mutation SetOmedaSelectFieldAnswers($input: UpdateAppUserCustomSelectAnswersMutationInput!) {
+    updateAppUserCustomSelectAnswers(input: $input) { id }
+  }
+`;
+
+const SET_OMEDA_BOOLEAN_FIELD_ANSWERS = gql`
+  mutation SetOmedaBooleanFieldAnswers($input: UpdateAppUserCustomBooleanAnswersMutationInput!) {
+    updateAppUserCustomBooleanAnswers(input: $input) { id }
+  }
+`;
+
+const SET_OMEDA_TEXT_FIELD_ANSWERS = gql`
+  mutation SetOmedaTextFieldAnswers($input: UpdateAppUserCustomTextAnswersMutationInput!) {
+    updateAppUserCustomTextAnswers(input: $input) { id }
+  }
+`;
+
+/**
+ * Sets IdentityX custom select answers based on the Omeda customer's demographics
+ */
+module.exports = async ({
+  identityX,
+  user,
+  omedaCustomer,
+  fields = [],
+}) => {
+  const answeredQuestionMap = getAnsweredQuestionMap(user);
+
+  const omedaCustomerDemoValuesMap = omedaCustomer.demographics
+    .reduce((map, {
+      demographic,
+      value,
+      valueText,
+      writeInDesc,
+    }) => {
+      if (valueText) {
+        map.set(`${demographic.id}`, { valueText });
+        return map;
+      }
+      if (!value || !value.id) return map; // skip demos without value IDs
+      const id = `${demographic.id}`;
+      const ids = map.has(id) ? map.get(id).ids : new Set();
+      ids.add(`${value.id}`);
+      map.set(id, { ids, writeInDesc });
+      return map;
+    }, new Map());
+
+  const booleanAnswerMap = new Map();
+  const selectAnswerMap = new Map();
+  const textAnswerMap = new Map();
+  fields.forEach((field) => {
+    if (answeredQuestionMap.has(field.id)) return;
+    const { value: demoId } = field.externalId.identifier;
+    if (!omedaCustomerDemoValuesMap.has(demoId)) return;
+    const value = omedaCustomerDemoValuesMap.get(demoId);
+    const { ids: valueIdSet, valueText, writeInDesc } = value;
+
+    if (field.type === 'text' && valueText) {
+      textAnswerMap.set(field.id, valueText);
+    }
+
+    if (field.type === 'select') {
+      field.options.forEach((option) => {
+        const { externalIdentifier } = option;
+        if (!externalIdentifier || !valueIdSet.has(externalIdentifier)) return;
+        const ids = selectAnswerMap.has(field.id) ? selectAnswerMap.get(field.id).ids : new Set();
+        ids.add(option.id);
+        selectAnswerMap.set(field.id, { ids, writeInDesc });
+      });
+    }
+
+    if (field.type === 'boolean') {
+      const { whenTrue, whenFalse } = field;
+      // What is this? Why are we setting it twice?
+      if (whenTrue.type === 'INTEGER' && valueIdSet.has(`${whenTrue.value}`)) {
+        booleanAnswerMap.set(field.id, true);
+        return;
+      }
+      if (whenFalse.type === 'INTEGER' && valueIdSet.has(`${whenFalse.value}`)) {
+        booleanAnswerMap.set(field.id, false);
+      }
+    }
+  });
+
+  await (async () => {
+    if (!selectAnswerMap.size) return;
+    const answers = [];
+    selectAnswerMap.forEach((value, fieldId) => {
+      const optionIds = [...value.ids];
+      answers.push({
+        fieldId,
+        optionIds,
+        ...(value.writeInDesc && {
+          writeInValues: optionIds.map((id) => ({
+            optionId: id,
+            value: value.writeInDesc,
+          })),
+        }),
+      });
+    });
+    await identityX.client.mutate({
+      mutation: SET_OMEDA_SELECT_FIELD_ANSWERS,
+      variables: { input: { id: user.id, answers } },
+      context: { apiToken: identityX.config.getApiToken() },
+    });
+  })();
+
+  await (async () => {
+    if (!booleanAnswerMap.size) return;
+    const answers = [];
+    booleanAnswerMap.forEach((value, fieldId) => {
+      answers.push({ fieldId, value });
+    });
+    await identityX.client.mutate({
+      mutation: SET_OMEDA_BOOLEAN_FIELD_ANSWERS,
+      variables: { input: { id: user.id, answers } },
+      context: { apiToken: identityX.config.getApiToken() },
+    });
+  })();
+
+  await (async () => {
+    if (!textAnswerMap.size) return;
+    const answers = [];
+    textAnswerMap.forEach((value, fieldId) => {
+      answers.push({ fieldId, value });
+    });
+    await identityX.client.mutate({
+      mutation: SET_OMEDA_TEXT_FIELD_ANSWERS,
+      variables: { input: { id: user.id, answers } },
+      context: { apiToken: identityX.config.getApiToken() },
+    });
+  })();
+};

package/omeda-data/set-omeda-deployment-types.js

@@ -0,0 +1,51 @@
+const gql = require('graphql-tag');
+const { getAsArray } = require('@mindful-web/object-path');
+const getAnsweredQuestionMap = require('./get-answered-question-map');
+const isOmedaDeploymentType = require('../external-id/is-deployment-type-id');
+
+const SET_OMEDA_BOOLEAN_FIELD_ANSWERS = gql`
+mutation SetOmedaBooleanFieldAnswers($input: UpdateAppUserCustomBooleanAnswersMutationInput!) {
+  updateAppUserCustomBooleanAnswers(input: $input) { id }
+}
+`;
+
+/**
+ * Sets IdX boolean answers based on the Omeda customer's opt-in status
+ */
+module.exports = async ({
+  identityX,
+  brandKey,
+  user,
+  omedaCustomer,
+  fields = [],
+}) => {
+  const statusMap = getAsArray(omedaCustomer, 'primaryEmailAddress.optInStatus').reduce((map, { deploymentTypeId, status }) => {
+    const optedIn = status.id === 'IN';
+    map.set(`${deploymentTypeId}`, optedIn);
+    return map;
+  }, new Map());
+
+  const answeredQuestionMap = getAnsweredQuestionMap(user);
+  const answerMap = fields
+    .filter((field) => isOmedaDeploymentType({ externalId: field.externalId, brandKey }))
+    .reduce((map, field) => {
+      // Only set values that haven't already been answered.
+      if (answeredQuestionMap.has(field.id)) return map;
+      const { value } = field.externalId.identifier;
+      const receive = statusMap.get(`${value}`);
+      if (receive == null) return map;
+      map.set(field.id, receive);
+      return map;
+    }, new Map());
+  if (!answerMap.size) return;
+
+  const answers = [];
+  answerMap.forEach((value, fieldId) => {
+    answers.push({ fieldId, value });
+  });
+  await identityX.client.mutate({
+    mutation: SET_OMEDA_BOOLEAN_FIELD_ANSWERS,
+    variables: { input: { id: user.id, answers } },
+    context: { apiToken: identityX.config.getApiToken() },
+  });
+};

package/omeda-data/set-omeda-products.js

@@ -0,0 +1,50 @@
+const gql = require('graphql-tag');
+const { getAsArray } = require('@mindful-web/object-path');
+const getAnsweredQuestionMap = require('./get-answered-question-map');
+const isOmedaProductId = require('../external-id/is-product-id');
+
+const SET_OMEDA_BOOLEAN_FIELD_ANSWERS = gql`
+mutation SetOmedaBooleanFieldAnswers($input: UpdateAppUserCustomBooleanAnswersMutationInput!) {
+  updateAppUserCustomBooleanAnswers(input: $input) { id }
+}
+`;
+
+/**
+ * Sets IdX boolean answers based on the Omeda customer's opt-in status
+ */
+module.exports = async ({
+  identityX,
+  brandKey,
+  user,
+  omedaCustomer,
+  fields = [],
+}) => {
+  const statusMap = getAsArray(omedaCustomer, 'subscriptions').reduce((map, { product, receive }) => {
+    map.set(`${product.id}`, receive);
+    return map;
+  }, new Map());
+
+  const answeredQuestionMap = getAnsweredQuestionMap(user);
+  const answerMap = fields
+    .filter((field) => isOmedaProductId({ externalId: field.externalId, brandKey }))
+    .reduce((map, field) => {
+      // Only set values that haven't already been answered.
+      if (answeredQuestionMap.has(field.id)) return map;
+      const { value } = field.externalId.identifier;
+      const receive = statusMap.get(`${value}`);
+      if (receive == null) return map;
+      map.set(field.id, receive);
+      return map;
+    }, new Map());
+  if (!answerMap.size) return;
+
+  const answers = [];
+  answerMap.forEach((value, fieldId) => {
+    answers.push({ fieldId, value });
+  });
+  await identityX.client.mutate({
+    mutation: SET_OMEDA_BOOLEAN_FIELD_ANSWERS,
+    variables: { input: { id: user.id, answers } },
+    context: { apiToken: identityX.config.getApiToken() },
+  });
+};

package/omeda-data/update-identity-x.js

@@ -0,0 +1,68 @@
+const setOmedaData = require('./set-omeda-data');
+const setOmedaDemographics = require('./set-omeda-demographics');
+const setOmedaDeploymentTypes = require('./set-omeda-deployment-types');
+const setOmedaProducts = require('./set-omeda-products');
+
+/**
+ * Provides a standard interface to update IdentityX user data from Omeda. All updates to IdX user
+ * data should run through this utility.
+ *
+ * @note These updates should NEVER be run concurrently, to prevent a race condition in the IdX API.
+ *
+ * @param {object} args Arguments to pass along to update utilities
+ * @param {object} flags Keys indicate which updates should be executed.
+ * @param {object} flags.updateData            If true, update the root fields (first/last name,etc)
+ * @param {object} flags.updateDemographics    If true, update custom select fields
+ * @param {object} flags.updateDeploymentTypes If true, update boolean `deploymentType` fields
+ * @param {object} flags.updateProducts        If true, update boolean `product` fields
+ */
+module.exports = async (
+  {
+    identityX,
+    brandKey,
+    user,
+    omedaCustomer,
+    omedaLinkedFields = {},
+  } = {},
+  {
+    updateData = false,
+    updateDemographics = false,
+    updateDeploymentTypes = false,
+    updateProducts = false,
+  } = {},
+) => {
+  if (updateData) {
+    await setOmedaData({
+      identityX,
+      user,
+      omedaCustomer,
+    });
+  }
+  if (updateDemographics) {
+    await setOmedaDemographics({
+      identityX,
+      brandKey,
+      user,
+      omedaCustomer,
+      fields: omedaLinkedFields.demographic,
+    });
+  }
+  if (updateDeploymentTypes) {
+    await setOmedaDeploymentTypes({
+      identityX,
+      brandKey,
+      user,
+      omedaCustomer,
+      fields: omedaLinkedFields.deploymentType,
+    });
+  }
+  if (updateProducts) {
+    await setOmedaProducts({
+      identityX,
+      brandKey,
+      user,
+      omedaCustomer,
+      fields: omedaLinkedFields.product,
+    });
+  }
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@mindful-web/marko-web-omeda-identity-x",
+  "version": "1.0.0",
+  "description": "Marko Omeda+IdentityX integration tools",
+  "repository": "https://github.com/parameter1/mindful-web/tree/main/packages/marko-web-omeda-identity-x",
+  "author": "Josh Worden <josh@parameter1.com>",
+  "license": "MIT",
+  "scripts": {
+    "lint:fix": "yarn lint --fix",
+    "lint": "eslint --ext .js --ext .vue --max-warnings 5 ./",
+    "compile": "mindful-web-marko-compile compile",
+    "prepublish": "yarn compile --silent",
+    "test": "yarn compile --no-clean && yarn lint"
+  },
+  "dependencies": {
+    "@mindful-web/marko-web-identity-x": "^1.0.0",
+    "@mindful-web/marko-web-omeda": "^1.0.0",
+    "@mindful-web/object-path": "^1.0.0",
+    "@mindful-web/utils": "^1.0.0",
+    "@parameter1/joi": "^1.2.10",
+    "graphql": "^14.7.0",
+    "graphql-tag": "^2.12.6"
+  },
+  "peerDependencies": {
+    "@mindful-web/marko-core": "^0.0.0",
+    "@mindful-web/marko-web": "^0.0.0",
+    "express": "^4.18.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "0b77cab713eb5841202bb86c7119949866bc68b5"
+}