@mindful-web/marko-web-postup 1.105.1 → 1.109.0

package/index.js

@@ -33,6 +33,7 @@ module.exports = (app, idxConfig, params = {}) => {
       companyname: 'organization',
       title: 'organizationTitle',
     }).description('The PostUp fields that should be mapped to IdentityX fields.'),
+    tenant: Joi.string().trim().required().description('The IdentityX external-id namespace tenant (`postup.<tenant>.<type>`) used for recipient ids, list and demographic questions. Required: there is no default.'),
   }), params);
 
   app.use((req, res, next) => {
@@ -66,6 +67,8 @@ module.exports = (app, idxConfig, params = {}) => {
  * @typedef PostUpConfig
  * @prop {Array} defaultListQuestionIds Array of object ids representing the default subscription questions
  * @prop {Object} fieldMap An object representing how fields should map from PostUp to IdentityX.
+ * @prop {string} tenant The IdentityX external-id namespace tenant for this site's PostUp recipient
+ *   ids and list/demographic questions (`postup.<tenant>.<type>`). Required.
  *
  * @typedef PostUpRequest
  * @prop {PostUp} postUp

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@mindful-web/marko-web-postup",
-  "version": "1.105.1",
+  "version": "1.109.0",
   "author": "Josh Worden <josh@parameter1.com>",
   "repository": "https://github.com/parameter1/mindful-web/tree/main/packages/marko-web-postup",
   "license": "MIT",
   "scripts": {
     "lint": "eslint --ext .js --ext .vue --max-warnings 5 --config ../../.eslintrc.js --ignore-path ../../.eslintignore ./",
     "lint:fix": "yarn lint --fix",
-    "test": "yarn lint"
+    "test": "yarn lint && ../../node_modules/.bin/mocha --reporter spec"
   },
   "dependencies": {
     "@mindful-web/env": "^1.0.0",
-    "@mindful-web/marko-web-identity-x": "^1.105.1",
+    "@mindful-web/marko-web-identity-x": "^1.109.0",
     "@mindful-web/object-path": "^1.92.0",
     "@mindful-web/utils": "^1.92.0",
     "@parameter1/joi": "^1.2.10",
@@ -21,6 +21,10 @@
     "newrelic": "^9.10.2",
     "node-fetch": "^2.6.1"
   },
+  "devDependencies": {
+    "chai": "^4.3.7",
+    "mocha": "^6.2.3"
+  },
   "engines": {
     "node": ">=14.15"
   },
@@ -32,5 +36,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "e6054405dc7918b784fd8cb8b8b0042dd251f248"
+  "gitHead": "fc1f82dda4017caab19f5019367c5e2284ed01f9"
 }

package/service.js

@@ -2,7 +2,7 @@ const debug = require('debug')('postup:service');
 const gql = require('graphql-tag');
 const { get, getAsArray } = require('@mindful-web/object-path');
 const { POSTUP_API_CREDENTIALS } = require('./env');
-const { filterByExternalId, filterFieldsByExternalId } = require('./utils');
+const { assertTenant, filterByExternalId, filterFieldsByExternalId } = require('./utils');
 const PostUpApiClient = require('./api-client');
 
 const SET_DATA = gql`
@@ -27,12 +27,14 @@ class PostUp {
   /**
    * @param {string} defaultListQuestionIds The array of default lists for auto-signups
    * @param {object} fieldMap A mapping of postup>identityx field keys
+   * @param {string} tenant The IdentityX external-id namespace tenant (required)
    */
   constructor({
     defaultListQuestionIds,
     fieldMap = {},
-    tenant = 'transpire',
+    tenant,
   } = {}) {
+    assertTenant(tenant);
     this.defaultListQuestionIds = defaultListQuestionIds;
     this.fieldMap = Object.entries(fieldMap).reduce((map, [key, value]) => {
       map.set(key, value);
@@ -85,7 +87,11 @@ class PostUp {
     });
 
     // Update custom selects
-    const questions = filterFieldsByExternalId(getAsArray(user, 'customSelectFieldAnswers'), 'demographic');
+    const questions = filterFieldsByExternalId(
+      getAsArray(user, 'customSelectFieldAnswers'),
+      'demographic',
+      this.tenant,
+    );
     const customSelectFieldAnswers = questions.reduce((arr, ans) => {
       // Don't overwrite previously set answers
       if (!ans.hasAnswered) {
@@ -116,7 +122,11 @@ class PostUp {
 
     const subs = await this.client.listSubscriptionsForRecipient(recipientId);
 
-    const subscriptions = filterFieldsByExternalId(getAsArray(user, 'customBooleanFieldAnswers'), 'list');
+    const subscriptions = filterFieldsByExternalId(
+      getAsArray(user, 'customBooleanFieldAnswers'),
+      'list',
+      this.tenant,
+    );
     const customBooleanFieldAnswers = subscriptions.reduce((arr, ans) => {
       const listId = get(ans, 'field.externalId.identifier.value');
       const match = subs.find((sub) => sub.listId === parseInt(listId, 10));
@@ -152,7 +162,11 @@ class PostUp {
     }), {});
 
     // External ID tagged questions
-    const questions = filterFieldsByExternalId(getAsArray(user, 'customSelectFieldAnswers'), 'demographic');
+    const questions = filterFieldsByExternalId(
+      getAsArray(user, 'customSelectFieldAnswers'),
+      'demographic',
+      this.tenant,
+    );
     questions.forEach((ans) => {
       if (ans.hasAnswered) {
         const key = get(ans, 'field.externalId.identifier.value');
@@ -164,7 +178,11 @@ class PostUp {
     // Update Postup with the user data and demographics
     await this.updateRecipient(user, demographics);
 
-    const answers = filterFieldsByExternalId(getAsArray(user, 'customBooleanFieldAnswers'), 'list');
+    const answers = filterFieldsByExternalId(
+      getAsArray(user, 'customBooleanFieldAnswers'),
+      'list',
+      this.tenant,
+    );
     const subscriptions = answers.reduce((map, answer) => {
       const id = get(answer, 'field.externalId.identifier.value');
       map.set(`${id}`, answer.value);
@@ -184,7 +202,7 @@ class PostUp {
    */
   async ensureUser(user, idx) {
     // 1. Check IdentityX user externalIds for postup recipient id, bail if found
-    const found = filterByExternalId(user.externalIds, 'recipient');
+    const found = filterByExternalId(user.externalIds, 'recipient', this.tenant);
     if (found && found.length) return user;
 
     // 2. Attempt to look up by email address. If found, push externalId to IdX/PostUp users
@@ -222,7 +240,11 @@ class PostUp {
    * @param {import('./hooks').IdentityXUser} user The IdentityX user object
    */
   async defaultListOptIns(idx, user) {
-    const subscriptions = filterFieldsByExternalId(getAsArray(user, 'customBooleanFieldAnswers'), 'list');
+    const subscriptions = filterFieldsByExternalId(
+      getAsArray(user, 'customBooleanFieldAnswers'),
+      'list',
+      this.tenant,
+    );
 
     const recipientId = await this.getRecipientId(user);
 
@@ -268,7 +290,7 @@ class PostUp {
    */
   async getRecipientId(user) {
     const { email } = user;
-    const extIds = filterByExternalId(user.externalIds, 'recipient');
+    const extIds = filterByExternalId(user.externalIds, 'recipient', this.tenant);
     const extId = get(extIds, '0.identifier.value');
     if (extId) return extId;
 

package/test/mocha.opts

@@ -0,0 +1,2 @@
+--recursive
+--timeout 2000

package/test/tenant.spec.js

@@ -0,0 +1,99 @@
+const { describe, it, before } = require('mocha');
+const { expect } = require('chai');
+
+// The service reads its API credentials from the environment when it is required.
+process.env.POSTUP_API_CREDENTIALS = process.env.POSTUP_API_CREDENTIALS || 'test';
+
+const PostUp = require('../service');
+const install = require('../index');
+
+const defaultListQuestionIds = ['5f0c8c1e2a1b3c4d5e6f7a8b'];
+
+/**
+ * Runs the package's request middleware once and returns the service it installed.
+ */
+const serviceFor = (params) => {
+  let middleware;
+  const app = { locals: {}, use: (fn) => { middleware = fn; } };
+  const idxConfig = { addHook: () => {} };
+  install(app, idxConfig, params);
+  const req = { cookies: {} };
+  middleware(req, { locals: {} }, () => {});
+  return req.PostUp;
+};
+
+/**
+ * A fake IdentityX service that records the external ids written to it.
+ */
+const fakeIdx = () => {
+  const added = [];
+  return { added, addExternalUserId: async (input) => { added.push(input); } };
+};
+
+const user = (tenant) => ({
+  id: 'idx-user',
+  email: 'user@example.com',
+  externalIds: [{
+    identifier: { value: '123' },
+    namespace: { provider: 'postup', tenant, type: 'recipient' },
+  }],
+});
+
+describe('tenant', () => {
+  describe('index', () => {
+    it('rejects a config without a tenant', () => {
+      expect(() => serviceFor({ defaultListQuestionIds })).to.throw(/"tenant" is required/);
+    });
+
+    it('rejects an empty tenant', () => {
+      expect(() => serviceFor({ defaultListQuestionIds, tenant: '  ' })).to.throw(/"tenant" is not allowed to be empty/);
+    });
+
+    it('passes a configured tenant to the service', () => {
+      expect(serviceFor({ defaultListQuestionIds, tenant: 'tenant-a' }).tenant).to.equal('tenant-a');
+    });
+
+    it('passes a second tenant to its own service', () => {
+      expect(serviceFor({ defaultListQuestionIds, tenant: 'tenant-b' }).tenant).to.equal('tenant-b');
+    });
+  });
+
+  describe('service', () => {
+    let service;
+    before(() => {
+      service = new PostUp({ defaultListQuestionIds, tenant: 'tenant-a' });
+      service.client = { updateRecipientExternalId: async () => {} };
+    });
+
+    it('throws when constructed without a tenant', () => {
+      expect(() => new PostUp({ defaultListQuestionIds })).to.throw(/tenant.*is required/);
+      expect(() => new PostUp()).to.throw(/tenant.*is required/);
+    });
+
+    it('writes the recipient external id in the configured tenant namespace', async () => {
+      const idx = fakeIdx();
+      await service.setExternalIds(idx, 'idx-user', 456);
+      expect(idx.added).to.deep.equal([{
+        userId: 'idx-user',
+        identifier: { value: '456' },
+        namespace: { provider: 'postup', tenant: 'tenant-a', type: 'recipient' },
+      }]);
+    });
+
+    it('reads the recipient id from the configured tenant namespace', async () => {
+      expect(await service.getRecipientId(user('tenant-a'))).to.equal('123');
+    });
+
+    it('ignores recipient ids from another tenant', async () => {
+      service.getUserByEmail = async () => [];
+      let error;
+      try {
+        await service.getRecipientId(user('tenant-b'));
+      } catch (e) {
+        error = e;
+      }
+      expect(error).to.be.an('error');
+      delete service.getUserByEmail;
+    });
+  });
+});

package/test/utils.spec.js

@@ -0,0 +1,85 @@
+const { describe, it } = require('mocha');
+const { expect } = require('chai');
+const { assertTenant, filterByExternalId, filterFieldsByExternalId } = require('../utils');
+
+const externalId = (tenant, type, value, provider = 'postup') => ({
+  identifier: { value },
+  namespace: { provider, tenant, type },
+});
+const answer = (tenant, type, value, provider = 'postup') => ({
+  field: { id: `${tenant}-${type}-${value}`, externalId: externalId(tenant, type, value, provider) },
+});
+
+const externalIds = [
+  externalId('tenant-a', 'recipient', '1'),
+  externalId('tenant-b', 'recipient', '2'),
+  externalId('tenant-b', 'list', '3'),
+  externalId('tenant-b', 'recipient', '4', 'omeda'),
+];
+const answers = [
+  answer('tenant-a', 'list', '10'),
+  answer('tenant-a', 'demographic', 'industry'),
+  answer('tenant-b', 'list', '20'),
+  answer('tenant-b', 'demographic', 'jobtitle'),
+  answer('tenant-b', 'list', '30', 'omeda'),
+];
+const values = (arr, path) => arr.map((v) => path.split('.').reduce((o, k) => o[k], v));
+
+describe('utils', () => {
+  describe('assertTenant', () => {
+    [undefined, null, '', '   ', 1].forEach((tenant) => {
+      it(`throws for ${JSON.stringify(tenant)}`, () => {
+        expect(() => assertTenant(tenant)).to.throw(/tenant.*is required/);
+      });
+    });
+
+    it('accepts a non-empty string', () => {
+      expect(() => assertTenant('tenant-a')).to.not.throw();
+    });
+  });
+
+  describe('filterByExternalId', () => {
+    it('returns only postup ids of the given type for one tenant', () => {
+      const found = filterByExternalId(externalIds, 'recipient', 'tenant-a');
+      expect(values(found, 'identifier.value')).to.deep.equal(['1']);
+    });
+
+    it('returns only postup ids of the given type for a second tenant', () => {
+      const found = filterByExternalId(externalIds, 'recipient', 'tenant-b');
+      expect(values(found, 'identifier.value')).to.deep.equal(['2']);
+    });
+
+    it('returns nothing for a tenant with no ids', () => {
+      expect(filterByExternalId(externalIds, 'recipient', 'other')).to.deep.equal([]);
+    });
+
+    it('throws without a tenant', () => {
+      expect(() => filterByExternalId(externalIds, 'recipient')).to.throw(/tenant.*is required/);
+    });
+  });
+
+  describe('filterFieldsByExternalId', () => {
+    it('returns only postup fields of the given type for one tenant', () => {
+      expect(values(filterFieldsByExternalId(answers, 'list', 'tenant-a'), 'field.id'))
+        .to.deep.equal(['tenant-a-list-10']);
+      expect(values(filterFieldsByExternalId(answers, 'demographic', 'tenant-a'), 'field.id'))
+        .to.deep.equal(['tenant-a-demographic-industry']);
+    });
+
+    it('returns only postup fields of the given type for a second tenant', () => {
+      expect(values(filterFieldsByExternalId(answers, 'list', 'tenant-b'), 'field.id'))
+        .to.deep.equal(['tenant-b-list-20']);
+      expect(values(filterFieldsByExternalId(answers, 'demographic', 'tenant-b'), 'field.id'))
+        .to.deep.equal(['tenant-b-demographic-jobtitle']);
+    });
+
+    it('ignores answers without an external id', () => {
+      expect(filterFieldsByExternalId([{ field: { id: 'x' } }], 'list', 'tenant-a'))
+        .to.deep.equal([]);
+    });
+
+    it('throws without a tenant', () => {
+      expect(() => filterFieldsByExternalId(answers, 'list')).to.throw(/tenant.*is required/);
+    });
+  });
+});

package/utils.js

@@ -1,12 +1,53 @@
 const { getAsObject } = require('@mindful-web/object-path');
 
+/**
+ * Throws unless the tenant is a non-empty string. There is no default tenant: a missing tenant
+ * would otherwise silently match no external ids (and so write recipient ids and answers into
+ * an `undefined` namespace).
+ *
+ * @param {string} tenant
+ */
+const assertTenant = (tenant) => {
+  if (typeof tenant !== 'string' || !tenant.trim()) {
+    throw new Error('A PostUp `tenant` (the IdentityX external-id namespace tenant) is required.');
+  }
+};
+
+const matches = (ns, type, tenant) => ns.provider === 'postup'
+  && ns.type === type
+  && ns.tenant === tenant;
+
 module.exports = {
-  filterByExternalId: (arr, type) => arr.filter((v) => {
-    const ns = getAsObject(v, 'namespace');
-    return ns.provider === 'postup' && ns.type === type && ns.tenant === 'transpire';
-  }),
-  filterFieldsByExternalId: (arr, type) => arr.filter((v) => {
-    const ns = getAsObject(v, 'field.externalId.namespace');
-    return ns.provider === 'postup' && ns.type === type && ns.tenant === 'transpire';
-  }),
+  assertTenant,
+
+  /**
+   * Returns the external ids in the PostUp namespace for the given type and tenant.
+   *
+   * @param {Array} arr IdentityX external ids (`{ namespace, identifier }`)
+   * @param {string} type The namespace type, e.g. `recipient`
+   * @param {string} tenant The namespace tenant (required)
+   */
+  filterByExternalId: (arr, type, tenant) => {
+    assertTenant(tenant);
+    return arr.filter((v) => {
+      const ns = getAsObject(v, 'namespace');
+      return matches(ns, type, tenant);
+    });
+  },
+
+  /**
+   * Returns the custom field answers whose field external id is in the PostUp namespace for the
+   * given type and tenant.
+   *
+   * @param {Array} arr IdentityX custom field answers (`{ field: { externalId: { namespace } } }`)
+   * @param {string} type The namespace type, e.g. `demographic` or `list`
+   * @param {string} tenant The namespace tenant (required)
+   */
+  filterFieldsByExternalId: (arr, type, tenant) => {
+    assertTenant(tenant);
+    return arr.filter((v) => {
+      const ns = getAsObject(v, 'field.externalId.namespace');
+      return matches(ns, type, tenant);
+    });
+  },
 };