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

package/routes/index.js

@@ -0,0 +1,40 @@
+const { Router } = require('express');
+const { json } = require('body-parser');
+const jsonErrorHandler = require('../utils/json-error-handler');
+const access = require('./access');
+const authenticate = require('./authenticate');
+const changeEmailConfirm = require('./change-email-confirm');
+const changeEmailInit = require('./change-email-init');
+const commentCount = require('./comment-count');
+const comments = require('./comments');
+const countries = require('./countries');
+const createComment = require('./create-comment');
+const download = require('./download');
+const flagComment = require('./flag-comment');
+const login = require('./login');
+const loginFields = require('./login-fields');
+const logout = require('./logout');
+const profile = require('./profile');
+const regions = require('./regions');
+
+const router = Router();
+
+router.use(json());
+router.get('/comment-count/:identifier', commentCount);
+router.get('/comments/:identifier', comments);
+router.get('/countries', countries);
+router.get('/regions', regions);
+router.post('/access', access);
+router.post('/authenticate', authenticate);
+router.post('/change-email/confirm', changeEmailConfirm);
+router.post('/change-email/initiate', changeEmailInit);
+router.post('/comment', createComment);
+router.post('/comment/flag/:id', flagComment);
+router.post('/download', download);
+router.post('/login-fields', loginFields);
+router.post('/login', login);
+router.post('/logout', logout);
+router.post('/profile', profile);
+router.use(jsonErrorHandler());
+
+module.exports = router;

package/routes/login-fields.js

@@ -0,0 +1,35 @@
+const gql = require('graphql-tag');
+const { asyncRoute } = require('@mindful-web/utils');
+
+const { isArray } = Array;
+
+const mutation = gql`
+  mutation SetPreLoginFields($input: SetAppUserUnverifiedDataMutationInput!) {
+    setAppUserUnverifiedData(input: $input) {
+      id
+    }
+  }
+`;
+
+module.exports = asyncRoute(async (req, res) => {
+  /** @type {import('../middleware').IdentityXRequest} */
+  const { identityX, body } = req;
+  const {
+    email,
+    values,
+  } = body;
+
+  const regionalConsentAnswers = isArray(values.regionalConsentAnswers)
+    ? values.regionalConsentAnswers
+    : [];
+
+  const input = {
+    ...values,
+    regionalConsentAnswers: regionalConsentAnswers
+      .map((answer) => ({ policyId: answer.id, given: answer.given })),
+    email,
+  };
+  await identityX.client.mutate({ mutation, variables: { input } });
+  const entity = await identityX.generateEntityId();
+  return res.json({ ok: true, entity });
+});

package/routes/login.js

@@ -0,0 +1,95 @@
+const gql = require('graphql-tag');
+const { asyncRoute } = require('@mindful-web/utils');
+
+const mutation = gql`
+  mutation SetPreLoginFields($input: SetAppUserUnverifiedDataMutationInput!) {
+    setAppUserUnverifiedData(input: $input) {
+      id
+    }
+  }
+`;
+
+const forceProfileReVerificationUser = gql`
+  mutation ForceRevalidateAppUser($input: ForceProfileReVerificationAppUserMutationInput!) {
+    forceProfileReVerificationAppUser(input: $input) {
+      id
+      forceProfileReVerification
+    }
+  }
+`;
+
+module.exports = asyncRoute(async (req, res) => {
+  /** @type {import('../middleware').IdentityXRequest} */
+  const { identityX, body } = req;
+  const {
+    authUrl,
+    email,
+    source,
+    redirectTo,
+    additionalEventData = {},
+  } = body;
+  let appUser = await identityX.loadAppUserByEmail(email);
+
+  // Check for required creation fields
+  const required = identityX.config.getRequiredCreateFields();
+  if (required.length) {
+    // If we don't have a user, or the user is missing some of the required fields
+    if (!appUser || (appUser && !required.every((key) => appUser[key]))) {
+      additionalEventData.createdNewUser = true;
+      // And they weren't presented in the login request, require them.
+      if (!required.every((key) => body[key])) {
+        return res.status(400).json({ ok: false, requiresUserInput: true });
+      }
+    }
+  }
+
+  if (!appUser || (appUser && !required.every((key) => appUser[key]))) {
+    // Create the user.
+    appUser = await identityX.createAppUser({ email });
+    additionalEventData.createdNewUser = true;
+  }
+
+  if (additionalEventData.forceProfileReVerification) {
+    const { id } = appUser;
+    await identityX.client.mutate({
+      mutation: forceProfileReVerificationUser,
+      variables: { input: { id } },
+    });
+  }
+
+  // Set the fields as unverified app data and continue login.
+  if (required.length && additionalEventData.createdNewUser) {
+    const regionalConsentAnswers = Array.isArray(body.regionalConsentAnswers)
+      ? body.regionalConsentAnswers
+      : [];
+    const input = {
+      ...(required.reduce((obj, key) => ({ ...obj, [key]: body[key] }), {})),
+      regionalConsentAnswers: regionalConsentAnswers
+        .map((answer) => ({ policyId: answer.id, given: answer.given })),
+      email,
+    };
+    await identityX.client.mutate({ mutation, variables: { input } });
+  }
+
+  // Refresh the user for verification/new field state
+  if (additionalEventData.forceProfileReVerification || additionalEventData.createdNewUser) {
+    appUser = await identityX.loadAppUserByEmail(email);
+  }
+  const entity = await identityX.generateEntityId({ userId: appUser.id });
+
+  // Send login link.
+  await identityX.sendLoginLink({
+    appUser,
+    authUrl,
+    source,
+    redirectTo,
+    additionalEventData,
+  });
+  const returnedAppUser = { id: appUser.id, email: appUser.email };
+  return res.json({
+    ok: true,
+    additionalEventData,
+    appUser: returnedAppUser,
+    entity,
+  });
+});

package/routes/logout.js

@@ -0,0 +1,19 @@
+const { asyncRoute } = require('@mindful-web/utils');
+const contextCookie = require('../utils/context-cookie');
+const tokenCookie = require('../utils/token-cookie');
+const callHooksFor = require('../utils/call-hooks-for');
+
+module.exports = asyncRoute(async (req, res) => {
+  /** @type {import('../middleware').IdentityXRequest} */
+  const { identityX } = req;
+  contextCookie.removeFrom(res);
+  const token = tokenCookie.getFrom(req);
+  if (!token) {
+    await callHooksFor(identityX, 'onLogout', { req, res });
+  } else {
+    await identityX.logoutAppUser({ token });
+  }
+  res.json({
+    ok: true,
+  });
+});

package/routes/profile.js

@@ -0,0 +1,183 @@
+const gql = require('graphql-tag');
+const { asyncRoute } = require('@mindful-web/utils');
+const { getAsArray, getAsObject } = require('@mindful-web/object-path');
+const userFragment = require('../api/fragments/active-user');
+const callHooksFor = require('../utils/call-hooks-for');
+
+const mutation = gql`
+  mutation UpdateUserProfile($input: UpdateOwnAppUserMutationInput!) {
+    updateOwnAppUser(input: $input) {
+      ...ActiveUserFragment
+    }
+  }
+
+  ${userFragment}
+`;
+
+const consentAnswers = gql`
+  mutation SetAppUserRegionalConsent($input: SetAppUserRegionalConsentMutationInput!) {
+    setAppUserRegionalConsent(input: $input) {
+      id
+    }
+  }
+`;
+
+const customBooleanFieldsMutation = gql`
+  mutation SetAppUserCustomBooleanFields($input: UpdateOwnAppUserCustomBooleanAnswersMutationInput!) {
+    updateOwnAppUserCustomBooleanAnswers(input: $input) {
+      id
+    }
+  }
+`;
+
+const customSelectFieldsMutation = gql`
+  mutation SetAppUserCustomSelectFields($input: UpdateOwnAppUserCustomSelectAnswersMutationInput!) {
+    updateOwnAppUserCustomSelectAnswers(input: $input) {
+      id
+    }
+  }
+`;
+
+const customTextFieldsMutation = gql`
+  mutation SetAppUserCustomTextFields($input: UpdateOwnAppUserCustomTextAnswersMutationInput!) {
+    updateOwnAppUserCustomTextAnswers(input: $input) {
+      id
+    }
+  }
+`;
+
+module.exports = asyncRoute(async (req, res) => {
+  /** @type {import('../middleware').IdentityXRequest} */
+  const { identityX, body } = req;
+  const {
+    givenName,
+    familyName,
+    organization,
+    organizationTitle,
+    countryCode,
+    regionCode,
+    postalCode,
+    city,
+    street,
+    addressExtra,
+    mobileNumber,
+    phoneNumber,
+    receiveEmail,
+    regionalConsentAnswers,
+    customBooleanFieldAnswers,
+    customSelectFieldAnswers,
+    customTextFieldAnswers,
+    additionalEventData = {},
+  } = body;
+  const input = {
+    givenName,
+    familyName,
+    organization,
+    organizationTitle,
+    countryCode,
+    regionCode,
+    postalCode,
+    city,
+    street,
+    addressExtra,
+    mobileNumber,
+    phoneNumber,
+    receiveEmail,
+  };
+
+  // get identity-x.forms custom-select question ids to append to ActiveCustomQuestionIds
+  const customFormFieldIds = Object.values(getAsObject(identityX, 'config.options.forms')).reduce((questions, form) => {
+    // loop over the fieldRows
+    getAsArray(form, 'fieldRows').forEach((row) => row.forEach((question) => {
+      // push the custom-select form being used with those forms to acceptable profile inputs
+      // @todo figure out if other types should also make it... custom-boolean specifically.
+      if (question.type === 'custom-select') questions.push(question.id);
+    }));
+    return questions;
+  }, []);
+
+  const customFieldIds = [
+    ...new Set([
+      ...getAsArray(identityX, 'config.options.activeCustomFieldIds'),
+      ...customFormFieldIds,
+    ]),
+  ];
+
+  const answers = regionalConsentAnswers
+    .map((answer) => ({ policyId: answer.id, given: answer.given }));
+
+  if (answers.length) {
+    await identityX.client.mutate({ mutation: consentAnswers, variables: { input: { answers } } });
+  }
+
+  if (customBooleanFieldAnswers.length) {
+    // only update custom questions when there some :)
+    const customBooleanFieldsInput = customBooleanFieldAnswers.map((fieldAnswer) => ({
+      fieldId: fieldAnswer.field.id,
+      // can either be true, false or null. convert null to false.
+      // the form submit is effectively answers the question.
+      value: Boolean(fieldAnswer.answer),
+    })).filter(
+      customFieldIds.length > 0
+        ? ({ fieldId }) => customFieldIds.includes(fieldId)
+        : () => true,
+    );
+    await identityX.client.mutate({
+      mutation: customBooleanFieldsMutation,
+      variables: { input: { answers: customBooleanFieldsInput } },
+    });
+  }
+
+  if (customSelectFieldAnswers.length) {
+    // only update custom questions when there some :)
+    const customSelectFieldsInput = customSelectFieldAnswers.map((fieldAnswer) => ({
+      fieldId: fieldAnswer.field.id,
+      optionIds: fieldAnswer.answers.map(({ id }) => id),
+      writeInValues: fieldAnswer.answers.reduce((arr, { id, writeInValue }) => ([
+        ...arr,
+        ...(writeInValue ? [{ optionId: id, value: writeInValue }] : []),
+      ]), []),
+    })).filter(
+      customFieldIds.length > 0
+        ? ({ fieldId }) => customFieldIds.includes(fieldId)
+        : () => true,
+    );
+    await identityX.client.mutate({
+      mutation: customSelectFieldsMutation,
+      variables: { input: { answers: customSelectFieldsInput } },
+    });
+  }
+
+  if (customTextFieldAnswers.length) {
+    // only update custom questions when there some :)
+    const customTextFieldsInput = customTextFieldAnswers.map((fieldAnswer) => ({
+      fieldId: fieldAnswer.field.id,
+      // the form submit is effectively answers the question.
+      value: fieldAnswer.value,
+    })).filter(
+      customFieldIds.length > 0
+        ? ({ fieldId }) => customFieldIds.includes(fieldId)
+        : () => true,
+    );
+    await identityX.client.mutate({
+      mutation: customTextFieldsMutation,
+      variables: { input: { answers: customTextFieldsInput } },
+    });
+  }
+
+  const { data } = await identityX.client.mutate({ mutation, variables: { input } });
+  const { updateOwnAppUser: user } = data;
+  await callHooksFor(identityX, 'onUserProfileUpdate', {
+    additionalEventData,
+    ...(additionalEventData || {}),
+    req,
+    user,
+  });
+  const entity = await identityX.generateEntityId({ userId: user.id });
+  res.json({
+    ok: true,
+    user,
+    additionalEventData,
+    entity,
+  });
+});

package/routes/regions.js

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