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

package/config.js

@@ -0,0 +1,161 @@
+const { get, getAsArray, getAsObject } = require('@mindful-web/object-path');
+const { isFunction: isFn } = require('@mindful-web/utils');
+const validHooks = require('./hooks');
+
+const { log } = console;
+
+class IdentityXConfiguration {
+  /**
+   *
+   * @param {object} options
+   * @param {string} options.appId The application ID to use.
+   * @param {string} [options.apiToken] An API token to use. Only required when doing write ops.
+   * @param {string[]} [options.requiredServerFields] Required fields, server enforced.
+   * @param {string[]} [options.requiredClientFields] Required fields, client-side only.
+   * @param {string[]} [options.requiredCreateFields] Required fields, when creating a new user.
+   * @param {string[]} [options.activeCustomFieldIds] Limit displayed custom fields, if present.
+   * @param {string[]} [options.hiddenFields] The fields to hide from the profile.
+   * @param {function} [options.onHookError]
+   * @param {object} options.rest
+   */
+  constructor({
+    appId,
+    apiToken,
+    requiredServerFields = [],
+    requiredClientFields = [],
+    requiredCreateFields = [],
+    activeCustomFieldIds = [],
+    additionalCustomFieldIds = [],
+    defaultFieldLabels = {},
+    hiddenFields = ['city', 'street', 'addressExtra', 'phoneNumber', 'mobileNumber'],
+    defaultCountryCode,
+    booleanQuestionsLabel,
+    gtmUserFields = {},
+    onHookError,
+    ...rest
+  } = {}) {
+    if (!appId) throw new Error('Unable to configure IdentityX: no Application ID was provided.');
+    this.appId = appId;
+    this.apiToken = apiToken;
+    this.options = {
+      enableChangeEmail: false,
+      requiredServerFields,
+      requiredClientFields,
+      requiredCreateFields,
+      activeCustomFieldIds,
+      additionalCustomFieldIds,
+      defaultFieldLabels,
+      hiddenFields,
+      defaultCountryCode,
+      booleanQuestionsLabel,
+      gtmUserFields,
+      onHookError: (e) => {
+        if (process.env.NODE_ENV === 'development') {
+          log('ERROR IN IDENTITY-X HOOK', e);
+          if (e.networkError) log('Network Error', get(e, 'networkError.result.errors.0'));
+        }
+        if (isFn(onHookError)) onHookError(e);
+      },
+      ...rest,
+    };
+
+    this.endpointTypes = [
+      'authenticate',
+      'changeEmail',
+      'login',
+      'logout',
+      'register',
+      'profile',
+    ];
+    this.hooks = validHooks.reduce((o, name) => ({ ...o, [name]: [] }), {});
+  }
+
+  /**
+   * Adds a function to the hook queue.
+   *
+   * @param {object} params
+   * @param {string} params.string The hook name to register the function with.
+   * @param {function} params.fn The function to call. Can be async/promise.
+   * @param {boolean} [params.shouldAwait=false] Whether the function should be awaited.
+   */
+  addHook({ name, fn, shouldAwait = false } = {}) {
+    if (!validHooks.includes(name)) throw new Error(`No hook found for '${name}'`);
+    if (!isFn(fn)) throw new Error('The hook `fn` must be a function.');
+    this.hooks[name].push({ fn, shouldAwait });
+    return this;
+  }
+
+  commentsEnabled() {
+    return this.get('comments.enabled', true);
+  }
+
+  getAppId() {
+    return this.appId;
+  }
+
+  getApiToken() {
+    return this.apiToken;
+  }
+
+  getEndpointFor(type) {
+    return this.get(`endpoints.${type}`, `/user/${type}`);
+  }
+
+  getEndpoints() {
+    return this.endpointTypes.reduce((o, type) => {
+      const endpoint = this.getEndpointFor(type);
+      return { ...o, [type]: endpoint };
+    }, {});
+  }
+
+  getRequiredServerFields() {
+    return this.getAsArray('requiredServerFields');
+  }
+
+  getGTMUserData(user) {
+    if (!user) return {};
+    const questions = this.getAsObject('gtmUserFields');
+    const userData = { id: user.id };
+    Object.entries(questions).forEach(([key, value]) => {
+      const select = getAsArray(user, 'customSelectFieldAnswers').find(({ id }) => id === value);
+      if (select && select.answers.length) userData[key] = select.answers.map(({ label }) => label).join('|');
+      const boolean = getAsArray(user, 'customBooleanFieldAnswers').find(({ id }) => id === value);
+      if (boolean && boolean.hasAnswered) userData[key] = boolean.answer;
+    });
+    return userData;
+  }
+
+  getRequiredClientFields() {
+    return this.getAsArray('requiredClientFields');
+  }
+
+  getRequiredCreateFields() {
+    return this.getAsArray('requiredCreateFields');
+  }
+
+  getHiddenFields() {
+    return this.getAsArray('hiddenFields');
+  }
+
+  getActiveCustomFieldIds() {
+    return this.getAsArray('activeCustomFieldIds');
+  }
+
+  getAdditionalCustomFieldIds() {
+    return this.getAsArray('additionalCustomFieldIds');
+  }
+
+  get(path, def) {
+    return get(this.options, path, def);
+  }
+
+  getAsArray(path) {
+    return getAsArray(this.options, path);
+  }
+
+  getAsObject(path) {
+    return getAsObject(this.options, path);
+  }
+}
+
+module.exports = IdentityXConfiguration;

package/hooks.js

@@ -0,0 +1,20 @@
+/**
+ * @typedef {(
+ *   "onAuthenticationSuccess"|
+ *   "onChangeEmailLinkSent"|
+ *   "onChangeEmailSuccess"|
+ *   "onLoadActiveContext"|
+ *   "onLoginLinkSent"|
+ *   "onLogout"|
+ *   "onUserProfileUpdate"
+ * )} HookTypeEnum
+ */
+module.exports = [
+  'onAuthenticationSuccess',
+  'onChangeEmailLinkSent',
+  'onChangeEmailSuccess',
+  'onLoadActiveContext',
+  'onLoginLinkSent',
+  'onLogout',
+  'onUserProfileUpdate',
+];

package/index.js

@@ -0,0 +1,30 @@
+const routes = require('./routes');
+const middleware = require('./middleware');
+
+/**
+ *
+ * @param {object} app The express app instance
+ * @param {IdentityXConfiguration} config The IdentityX config
+ */
+module.exports = (app, config, {
+  templates = {},
+} = {}) => {
+  app.use(middleware(config));
+  app.use('/__idx', routes);
+
+  config.endpointTypes.forEach((type) => {
+    const endpoint = config.getEndpointFor(type);
+    const template = templates[type];
+    if (!template) return;
+
+    app.get(endpoint, (req, res) => {
+      const { token } = req.identityX;
+      // Redirect to profile if a user token is already present (refresh after link click)
+      if (type === 'authenticate' && token) {
+        const redirectTo = req.query.redirectTo || config.getEndpointFor('profile');
+        res.redirect(302, redirectTo);
+      }
+      res.marko(template);
+    });
+  });
+};

package/marko.json

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

package/middleware/content-access-state.js

@@ -0,0 +1,31 @@
+const { get, getAsObject } = require('@mindful-web/object-path');
+
+const cookieNamePrefix = '__idx_form';
+// default is one day
+const maxAge = process.env.IDX_CONTENT_ACCESS_MAXAGE
+  ? Number(process.env.IDX_CONTENT_ACCESS_MAXAGE)
+  : (24 * 60 * 60 * 1000);
+
+const contentAccessState = ({ res, content }) => {
+  // Handle setting of contentAccessState Object
+  const { surveyType, surveyId } = getAsObject(content, 'gating');
+  const cookieName = `${cookieNamePrefix}_${surveyId}_${content.id}`;
+
+  const setFormDisplay = ({ req }) => {
+    res.locals.contentAccessState.displayForm = !get(req, `cookies.${cookieName}`);
+  };
+  res.locals.contentAccessState = {
+    displayForm: false,
+    setFormDisplay,
+  };
+
+  if (surveyType === 'idx') {
+    const cookie = { name: cookieName, maxAge };
+    res.locals.contentAccessState.formId = surveyId;
+    res.locals.contentAccessState.cookie = cookie;
+  }
+};
+
+module.exports = {
+  contentAccessState,
+};

package/middleware/content-download-state.js

@@ -0,0 +1,27 @@
+const { get } = require('@mindful-web/object-path');
+
+const cookieNamePrefix = '__idx_form';
+const maxAge = process.env.IDX_CONTENT_DOWNLOAD_MAXAGE
+  ? Number(process.env.IDX_CONTENT_DOWNLOAD_MAXAGE)
+  : (24 * 60 * 60 * 1000);
+
+const contentDownloadState = ({ res, content }) => {
+  // Handle setting of contentDownloadState Object
+  const surveyId = 'content-download';
+  const cookieName = `${cookieNamePrefix}_${surveyId}_${content.id}`;
+
+  const setFormDisplay = ({ req }) => {
+    res.locals.contentDownloadState.displayForm = !get(req, `cookies.${cookieName}`);
+  };
+  res.locals.contentDownloadState = {
+    displayForm: false,
+    setFormDisplay,
+  };
+  const cookie = { name: cookieName, maxAge };
+  res.locals.contentDownloadState.formId = surveyId;
+  res.locals.contentDownloadState.cookie = cookie;
+};
+
+module.exports = {
+  contentDownloadState,
+};

package/middleware.js

@@ -0,0 +1,32 @@
+const { asyncRoute } = require('@mindful-web/utils');
+const IdentityX = require('./service');
+
+/**
+ * An Express middleware that injects the IdentityX service.
+ *
+ * @param {IdentityXConfiguration} config The IdentityX config object
+ * @returns {function} The middleware function
+ *
+ * @typedef IdentityXRequest
+ * @prop {IdentityX} identityX The IdentityX service instance
+ */
+module.exports = (config) => asyncRoute(async (req, res, next) => {
+  const service = new IdentityX({ req, res, config });
+  req.identityX = service;
+  res.locals.identityX = service;
+
+  const cookie = service.getIdentity(res);
+
+  // Don't overwrite an existing cookie
+  if (cookie) return next();
+
+  // Set cookie for logged in users
+  if (service.token) {
+    const { user } = await service.loadActiveContext();
+    if (user && user.id) {
+      service.setIdentityCookie(user.id);
+    }
+  }
+
+  return next();
+});

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@mindful-web/marko-web-identity-x",
+  "version": "1.0.0",
+  "description": "Marko Wrapper for IdentityX",
+  "repository": "https://github.com/parameter1/mindful-web/tree/main/packages/marko-web-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-gtm": "^1.0.0",
+    "@mindful-web/object-path": "^1.0.0",
+    "@mindful-web/utils": "^1.0.0",
+    "apollo-cache-inmemory": "^1.6.6",
+    "apollo-client": "^2.6.10",
+    "apollo-link-context": "^1.0.20",
+    "apollo-link-http": "^1.5.17",
+    "body-parser": "^1.20.1",
+    "cookie": "0.3.1",
+    "dayjs": "^1.11.7",
+    "express": "^4.18.2",
+    "graphql-tag": "^2.12.6",
+    "jsonwebtoken": "^8.5.1",
+    "node-fetch": "^2.6.9",
+    "object-path": "^0.11.8"
+  },
+  "peerDependencies": {
+    "@mindful-web/marko-core": "^0.0.0",
+    "@mindful-web/marko-web": "^0.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "0b77cab713eb5841202bb86c7119949866bc68b5"
+}

package/routes/access.js

@@ -0,0 +1,29 @@
+const gql = require('graphql-tag');
+const { asyncRoute } = require('@mindful-web/utils');
+
+const mutation = gql`
+  mutation StoreContentAccessSubmission($input: CreateContentAccessSubmissionMutationInput!) {
+    createContentAccessSubmission(input:$input) {
+      id
+    }
+  }
+`;
+
+module.exports = asyncRoute(async (req, res) => {
+  /** @type {import('../middleware').IdentityXRequest} */
+  const { body, apollo, identityX } = req;
+  const { contentId, payload, cookie } = body;
+  const input = {
+    contentId,
+    payload,
+    ipAddress: req.ip,
+  };
+  const { name: COOKIE_NAME, maxAge } = cookie;
+  await apollo.mutate({ mutation, variables: { input } });
+  res.cookie(COOKIE_NAME, true, { maxAge, httpOnly: false });
+  const entity = await identityX.generateEntityId();
+  res.json({
+    ok: true,
+    entity,
+  });
+});

package/routes/authenticate.js

@@ -0,0 +1,58 @@
+const gql = require('graphql-tag');
+const { asyncRoute } = require('@mindful-web/utils');
+const tokenCookie = require('../utils/token-cookie');
+const contextCookie = require('../utils/context-cookie');
+const callHooksFor = require('../utils/call-hooks-for');
+const userFragment = require('../api/fragments/active-user');
+
+const loginAppUser = gql`
+  mutation LoginAppUser($input: LoginAppUserMutationInput!) {
+    loginAppUser(input: $input) {
+      token {
+        id
+        value
+      }
+      user {
+        ...ActiveUserFragment
+      }
+      loginSource
+    }
+  }
+
+  ${userFragment}
+`;
+
+module.exports = asyncRoute(async (req, res) => {
+  /** @type {import('../middleware').IdentityXRequest} */
+  const { identityX, body } = req;
+  const { token, additionalEventData } = body;
+  if (!token) throw new Error('No login token was provided.');
+
+  const input = { token };
+  const variables = { input };
+  const { data = {} } = await identityX.client.mutate({ mutation: loginAppUser, variables });
+  const { token: authToken, user, loginSource } = data.loginAppUser;
+
+  // call authentication hooks
+  await callHooksFor(identityX, 'onAuthenticationSuccess', {
+    req,
+    res,
+    user,
+    authToken,
+    loginSource,
+    additionalEventData,
+  });
+  tokenCookie.setTo(res, authToken.value);
+  contextCookie.setTo(res, { loginSource });
+  identityX.setIdentityCookie(user.id);
+  const entity = await identityX.generateEntityId({ userId: user.id });
+  const refreshed = await identityX.findUserById(user.id);
+  res.json({
+    ok: true,
+    applicationId: identityX.config.getAppId(),
+    user: refreshed,
+    loginSource,
+    additionalEventData,
+    entity,
+  });
+});

package/routes/change-email-confirm.js

@@ -0,0 +1,60 @@
+const gql = require('graphql-tag');
+const jwt = require('jsonwebtoken');
+const { get } = require('@mindful-web/object-path');
+const { asyncRoute } = require('@mindful-web/utils');
+const tokenCookie = require('../utils/token-cookie');
+const contextCookie = require('../utils/context-cookie');
+const callHooksFor = require('../utils/call-hooks-for');
+const userFragment = require('../api/fragments/active-user');
+
+const mutation = gql`
+  mutation ChangeEmailConfirm($input: ChangeAppUserEmailMutationInput!) {
+    changeAppUserEmail(input: $input) {
+      token {
+        id
+        value
+      }
+      user {
+        ...ActiveUserFragment
+      }
+    }
+  }
+
+  ${userFragment}
+`;
+
+module.exports = asyncRoute(async (req, res) => {
+  /** @type {import('../middleware').IdentityXRequest} */
+  const { identityX, body } = req;
+  const { token } = body;
+  const loginSource = 'change-email';
+  if (!token) throw new Error('No login token was provided.');
+
+  const input = { token };
+  const variables = { input };
+  const { data = {} } = await identityX.client.mutate({ mutation, variables });
+  const { token: authToken, user } = data.changeAppUserEmail;
+
+  const decoded = await jwt.decode(token);
+  await callHooksFor(identityX, 'onChangeEmailSuccess', {
+    user,
+    oldEmail: get(decoded, 'data.email'),
+  });
+
+  // call authentication hooks
+  await callHooksFor(identityX, 'onAuthenticationSuccess', {
+    req,
+    res,
+    user,
+    authToken,
+    loginSource,
+  });
+  tokenCookie.setTo(res, authToken.value);
+  contextCookie.setTo(res, { loginSource });
+  const entity = await identityX.generateEntityId({ userId: user.id });
+  res.json({
+    ok: true,
+    user,
+    entity,
+  });
+});

package/routes/change-email-init.js

@@ -0,0 +1,16 @@
+const { asyncRoute } = require('@mindful-web/utils');
+
+module.exports = asyncRoute(async (req, res) => {
+  /** @type {import('../middleware').IdentityXRequest} */
+  const { identityX, body } = req;
+  const { email } = body;
+  const entity = await identityX.generateEntityId();
+
+  // Send login link.
+  await identityX.sendChangeEmailLink({ email });
+  await identityX.logoutAppUser();
+  return res.json({
+    ok: true,
+    entity,
+  });
+});

package/routes/comment-count.js

@@ -0,0 +1,19 @@
+const gql = require('graphql-tag');
+const { asyncRoute } = require('@mindful-web/utils');
+
+const query = gql`
+  query CountComments($identifier: String!) {
+    commentsForStream(input: { identifier: $identifier }) {
+      totalCount
+    }
+  }
+`;
+
+module.exports = asyncRoute(async (req, res) => {
+  /** @type {import('../middleware').IdentityXRequest} */
+  const { identityX } = req;
+  const { identifier } = req.params;
+  const variables = { identifier };
+  const { data } = await identityX.client.query({ query, variables });
+  res.json(data.commentsForStream);
+});

package/routes/comments.js

@@ -0,0 +1,43 @@
+const gql = require('graphql-tag');
+const { asyncRoute } = require('@mindful-web/utils');
+
+const query = gql`
+  query ListComments($input: CommentsForStreamQueryInput!) {
+    commentsForStream(input: $input) {
+      totalCount
+      stream {
+        id
+        archived
+      }
+      pageInfo {
+        endCursor
+        hasNextPage
+      }
+      edges {
+        node {
+          id
+          body
+          approved
+          flagged
+          createdAt
+          user {
+            id
+            displayName
+          }
+        }
+      }
+    }
+  }
+`;
+
+module.exports = asyncRoute(async (req, res) => {
+  const { identifier } = req.params;
+  const { after } = req.query;
+  /** @type {import('../middleware').IdentityXRequest} */
+  const { identityX } = req;
+  const limit = after ? 20 : 5;
+  const pagination = { limit, after };
+  const variables = { input: { identifier, pagination } };
+  const { data } = await identityX.client.query({ query, variables });
+  res.json(data.commentsForStream);
+});

package/routes/countries.js

@@ -0,0 +1,19 @@
+const gql = require('graphql-tag');
+const { asyncRoute } = require('@mindful-web/utils');
+
+const localeCountries = gql`
+  query LocaleCountries {
+    localeCountries {
+      id
+      name
+      flag
+    }
+  }
+`;
+
+module.exports = asyncRoute(async (req, res) => {
+  /** @type {import('../middleware').IdentityXRequest} */
+  const { identityX } = req;
+  const { data } = await identityX.client.query({ query: localeCountries });
+  res.json(data.localeCountries);
+});

package/routes/create-comment.js

@@ -0,0 +1,25 @@
+const gql = require('graphql-tag');
+const { asyncRoute } = require('@mindful-web/utils');
+
+const mutation = gql`
+  mutation CreateComment($input: CreateCommentMutationInput!) {
+    createComment(input: $input) {
+      id
+    }
+  }
+`;
+
+module.exports = asyncRoute(async (req, res) => {
+  /** @type {import('../middleware').IdentityXRequest} */
+  const { identityX } = req;
+  const { displayName, body, stream } = req.body;
+
+  const input = { displayName, body, stream };
+  const variables = { input };
+  await identityX.client.mutate({ mutation, variables });
+  const entity = await identityX.generateEntityId();
+  res.json({
+    ok: true,
+    entity,
+  });
+});

package/routes/download.js

@@ -0,0 +1,29 @@
+const gql = require('graphql-tag');
+const { asyncRoute } = require('@mindful-web/utils');
+
+const mutation = gql`
+  mutation StoreContentDownloadSubmission($input: CreateContentDownloadSubmissionMutationInput!) {
+    createContentDownloadSubmission(input:$input) {
+      id
+    }
+  }
+`;
+
+module.exports = asyncRoute(async (req, res) => {
+  /** @type {import('../middleware').IdentityXRequest} */
+  const { body, apollo, identityX } = req;
+  const { contentId, payload, cookie } = body;
+  const input = {
+    contentId,
+    payload,
+    ipAddress: req.ip,
+  };
+  const { name: COOKIE_NAME, maxAge } = cookie;
+  await apollo.mutate({ mutation, variables: { input } });
+  res.cookie(COOKIE_NAME, true, { maxAge, httpOnly: false });
+  const entity = await identityX.generateEntityId();
+  res.json({
+    ok: true,
+    entity,
+  });
+});

package/routes/flag-comment.js

@@ -0,0 +1,21 @@
+const gql = require('graphql-tag');
+const { asyncRoute } = require('@mindful-web/utils');
+
+const mutation = gql`
+  mutation FlagComment($id: String!) {
+    setCommentFlagged(input: { id: $id, value: true }) {
+      id
+      flagged
+    }
+  }
+`;
+
+module.exports = asyncRoute(async (req, res) => {
+  /** @type {import('../middleware').IdentityXRequest} */
+  const { identityX } = req;
+  const { id } = req.params;
+  const variables = { id };
+  await identityX.client.mutate({ mutation, variables });
+  const entity = await identityX.generateEntityId();
+  res.json({ ok: true, entity });
+});