hof 22.8.4-unhandled-error-fix-beta.1 → 22.9.0-beta

package/package/utilities/helpers/index.js

@@ -0,0 +1,189 @@
+/* eslint-disable no-param-reassign, consistent-return */
+'use strict';
+
+const _ = require('lodash');
+const logger = require('../../lib/logger');
+
+module.exports = class Helpers {
+  /**
+   * Utility function which returns the
+   * name of the step a field is present on
+   * @param {String} field - id of the field
+   * @param {Object} steps - steps config object
+   * @returns {String} - the key of the step where field is found
+   */
+  static getStepFromFieldName(field, stepsConfig) {
+    return _.findKey(stepsConfig, step => step.fields && step.fields.indexOf(field) > -1);
+  }
+
+  /**
+   * Alternative 'falsy' check which doesn't
+   * return false for 0 or false
+   * @param {any} value - the value to check
+   * @returns {Boolean} - if the value is 'empty'
+   */
+  static isEmptyValue(value) {
+    return value === undefined || value === null || value === '';
+  }
+
+  /**
+   * Helper function to lookup and return the page title
+   * translation if found. If not it will fallback to the
+   * label or legend of the first field on the page
+   * @param {String} route - the route of the step
+   * @param {Function} lookup - i18n-lookup bound to translate and Mustache.render
+   * @param {Object} fields - a key:value map of step fields
+   * @param {Object} locals - the locals map for mustache rendering
+   * @returns {String} - the first translation found
+   */
+  static getTitle(route, lookup, fields, locals) {
+    let fieldName = '';
+    if (_.size(fields)) {
+      fieldName = Object.keys(fields)[0];
+    }
+    return lookup([
+      `pages.${route}.header`,
+      `fields.${fieldName}.label`,
+      `fields.${fieldName}.legend`
+    ], locals);
+  }
+
+  /**
+   * Helper function to return intro if
+   * located in pages.{route}.intro
+   * @param {String} route - the route of the step
+   * @param {Function} lookup - i18n-lookup bound to translate and Mustache.render
+   * @param {Object} locals - the locals map for mustache rendering
+   * @returns {String} the translation if found
+   */
+  static getIntro(route, lookup, locals) {
+    return lookup([
+      `pages.${route}.intro`
+    ], locals);
+  }
+
+  /**
+   * Utility function which returns true
+   * if a field type has associated options
+   * @param {String} mixin - the name of the mixin
+   * @returns {Boolean} - if the mixin has associated options
+   */
+  static hasOptions(mixin) {
+    return mixin === 'radio-group' || mixin === 'checkbox-group' || mixin === 'select';
+  }
+
+  /**
+   * helper function for looking up values in
+   * fields that have options
+   * @param {Function} translate - translate function
+   * @param {String} field - the id of the field
+   * @param {String} value - the value of the field
+   * @returns {String} the translation of the label if found,
+   * the raw value if not
+   */
+  static getValue(translate, field, values) {
+    if (!Array.isArray(values)) {
+      values = [values];
+    }
+    return values.map(value => {
+      const key = `fields.${field}.options.${value}.label`;
+      const result = translate(key);
+      return result === key ? value : result;
+    }).join('\n');
+  }
+
+  /**
+   * utility function which returns undefined on
+   * failed translations instead of returning the key
+   * @param {Function} translate - the translate function
+   * @param {String} key - the key to translate
+   * @returns {String|undefined} the string result if successful, undefined if not
+   */
+  static conditionalTranslate(translate, key) {
+    const result = translate(key);
+    if (result !== key) {
+      return result;
+    }
+  }
+
+  /**
+   * Utility function which looks up translations with fallback values
+   * If the translation is for a field, it will first try fields.key.summary
+   * If this fails it will try fields.key.label, if this fails it will try
+   * fields.key.legend (radio-group and checkbox-group).
+   *
+   * If the translation is not for a field it will first try pages.key.summary,
+   * if this fails it will fallback to pages.keys.header.
+   * @param {Function} lookup - i18n lookup bound to translate
+   * @param {String} key - the key of the field/page
+   * @param {Boolean} isField - if the translation is for a field
+   * @return {String} the result of the translation
+   */
+  static getTranslation(lookup, key, isField) {
+    if (isField) {
+      return lookup([
+        `fields.${key}.summary`,
+        `fields.${key}.label`,
+        `fields.${key}.legend`
+      ]) || key;
+    }
+    return lookup([
+      `pages.${key}.summary`,
+      `pages.${key}.header`
+    ]) || key;
+  }
+  /**
+   * utility function which returns true or false on
+   * forks depending on whether a value exists on the page
+   * @param {Object} req - an http request object
+   * @param {Object} res - an http response object
+   * @param {Function|Object} condition - a field condition that is either a function or object
+   * @returns {Boolean} the boolean result of whether a field value is set on the page or session for a fork
+   */
+  static isFieldValueInPageOrSessionValid(req, res, condition) {
+    return _.isFunction(condition) ?
+      condition(req, res) :
+      condition.value === (req.form.values[condition.field] ||
+      (!Object.keys(req.form.values).includes(condition.field) &&
+      _.get(req, `form.historicalValues[${condition.field}]`)));
+  }
+
+  /**
+   * Read an environment variable and coerce it to boolean.
+   *
+   * @param {*}     rawValue    The raw value (e.g. process.env.FEATURE_FLAG)
+   * @param {boolean} [fallback=false]   Value to use if rawValue is null/undefined/invalid
+   * @param {string} [envVarName='ENV_VAR']  Name for log context
+   * @returns {boolean}
+   */
+  static getEnvBoolean(rawValue, fallback = false, envVarName = 'ENV_VAR') {
+    if (typeof rawValue === 'boolean') {
+      return rawValue;
+    }
+
+    if (rawValue === null || rawValue === undefined) {
+      return fallback;
+    }
+
+    if (typeof rawValue === 'string') {
+      const normalized = rawValue.trim().toLowerCase();
+      if (normalized === 'true') {
+        return true;
+      }
+      if (normalized === 'false') {
+        return false;
+      }
+      logger.warn(
+        `Invalid environment variable ${envVarName} value "${rawValue}" ` +
+        '– must be "true" or "false"; defaulting to ' +
+        `${fallback}`
+      );
+      return fallback;
+    }
+
+    logger.warn(
+      `Invalid environment variable ${envVarName} type (${typeof rawValue}); defaulting to ${fallback}`
+    );
+    return fallback;
+  }
+};

package/package/utilities/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+module.exports = {
+  autofill: require('./autofill'),
+  countries: require('./countries'),
+  helpers: require('./helpers'),
+  reqres: require('./reqres'),
+  testData: require('./test-data')
+};

package/package/utilities/reqres/index.js

@@ -0,0 +1,18 @@
+
+const reqres = require('reqres');
+const Model = require('../../model');
+
+module.exports = {
+  req: options => {
+    const opts = options || {};
+    const req = reqres.req(opts);
+    req.form = req.form || {};
+    req.form.values = req.form.values || {};
+    req.form.options = req.form.options || {};
+    req.sessionModel = new Model(opts.session);
+    req.translate = key => key;
+    req.log = () => {};
+    return req;
+  },
+  res: reqres.res
+};

package/package/utilities/test-data/data/domain.json

@@ -0,0 +1,7 @@
+[
+  "example.com",
+  "example.org",
+  "gmail.com",
+  "a-super-long-domain-with-hyphens-in-it.com",
+  "long-tld.technology"
+]

package/package/utilities/test-data/data/firstname.json

@@ -0,0 +1,16 @@
+[
+  "Anna",
+  "Bjørn",
+  "Caroline",
+  "David",
+  "Emma",
+  "Frank",
+  "Grace",
+  "Harold",
+  "Irene",
+  "Jean-Paul",
+  "Kerry",
+  "Lenny",
+  "Marie",
+  "Neil"
+]

package/package/utilities/test-data/data/lastname.json

@@ -0,0 +1,10 @@
+[
+  "Adams",
+  "Baker",
+  "Clarke",
+  "Davies",
+  "Edwards",
+  "Fletcher",
+  "McDonald",
+  "O'Grady"
+]

package/package/utilities/test-data/data/postcode.json

@@ -0,0 +1,12 @@
+[
+  "CR0 2EU",
+  "WV10 6JN",
+  "NR7 7WP",
+  "MK18 5JE",
+  "N19 4PD",
+  "DL13 2EA",
+  "GU51 1DR",
+  "NE24 1LW",
+  "SE24 9JG",
+  "PO40 9SJ"
+]

package/package/utilities/test-data/data/streetname.json

@@ -0,0 +1,8 @@
+[
+  "Church",
+  "Letsby",
+  "High",
+  "Low",
+  "Long",
+  "Winding"
+]

package/package/utilities/test-data/data/streetsuffix.json

@@ -0,0 +1,7 @@
+[
+  "Street",
+  "Road",
+  "Avenue",
+  "Terrace",
+  "Grove"
+]

package/package/utilities/test-data/data/town.json

@@ -0,0 +1,9 @@
+[
+  "London",
+  "Edinburgh",
+  "Birmingham",
+  "Leeds",
+  "Croydon",
+  "Stowe-on-the-Wold",
+  "Bishop's Stortford"
+]

package/package/utilities/test-data/index.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const countries = require('homeoffice-countries').allCountries;
+
+const pick = set => set[Math.floor(Math.random() * set.length)];
+
+const Data = {};
+
+[
+  'firstname',
+  'lastname',
+  'streetname',
+  'streetsuffix',
+  'town',
+  'postcode',
+  'domain'
+].forEach(key => {
+  const values = require(`./data/${key}`);
+  Object.defineProperty(Data, key, {
+    get: () => pick(values)
+  });
+});
+
+Object.defineProperty(Data, 'name', {
+  get: function () {
+    return `${Data.firstname} ${Data.lastname}`;
+  }
+});
+
+Object.defineProperty(Data, 'address', {
+  get: function () {
+    return `${Data.number(1, 100)} ${Data.streetname} ${Data.streetsuffix}, ${Data.town}, ${Data.postcode}`;
+  }
+});
+
+Object.defineProperty(Data, 'email', {
+  get: function () {
+    return `${Data.firstname.toLowerCase()}.${Data.lastname.toLowerCase()}@${Data.domain}`;
+  }
+});
+
+Object.defineProperty(Data, 'phone', {
+  get: function () {
+    const prefix = pick(['01', '07', '+44(0)7', '+44(0)1']);
+    return `${prefix}${Data.number(100, 999)} ${Data.number(100, 999)} ${Data.number(100, 999)}`;
+  }
+});
+
+Object.defineProperty(Data, 'country', {
+  get: () => pick(countries)
+});
+
+Data.number = (mn, mx) => {
+  let min = mn;
+  let max = mx;
+
+  if (min && max === undefined) {
+    max = min;
+    min = 0;
+  }
+  if (max === undefined) {
+    max = 100;
+  }
+  return min + Math.floor(Math.random() * (max - min));
+};
+
+module.exports = Data;

package/package/wizard/behaviours/complete.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const constants = require('../util/constants');
+
+module.exports = superclass => class extends superclass {
+  constructor(options) {
+    super(options);
+    if (options.next && options.steps && options.steps[options.next]) {
+      const nextOptions = options.steps[options.next];
+      if (typeof nextOptions.allowPostComplete === 'undefined') {
+        nextOptions.allowPostComplete = true;
+      }
+    }
+  }
+
+  successHandler(req, res, callback) {
+    req.sessionModel.set(constants.APPLICATION_COMPLETE, true);
+    super.successHandler(req, res, callback);
+  }
+};

package/package/wizard/behaviours/index.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = {
+  complete: require('./complete')
+};

package/package/wizard/index.js

@@ -0,0 +1,124 @@
+'use strict';
+
+const path = require('path');
+const express = require('express');
+const _ = require('lodash');
+const deprecate = require('deprecate');
+const FormController = require('../controller');
+const mix = require('mixwith').mix;
+
+const IncludedBehaviours = require('./behaviours');
+
+let count = 0;
+
+const getController = (SuperClass, behavs) => {
+  let behaviours = behavs ? _.castArray(behavs) : [];
+  if (!behaviours.length) {
+    return SuperClass;
+  }
+  behaviours = behaviours.map(behaviour => typeof behaviour === 'string' ? IncludedBehaviours[behaviour] : behaviour);
+  /*
+   * This class declaration could be better written using
+   * array spread syntax, supported in node >= 5.11.0:
+   *
+   * class Controller extends mix(SuperClass).with(...behaviours) {}
+   */
+  const _mix = mix(SuperClass);
+  return class extends _mix.with.apply(_mix, behaviours) {};
+};
+
+const Wizard = (steps, fields, setts) => {
+  const settings = Object.assign({
+    params: '/:action?',
+    controller: FormController
+  }, setts || {});
+
+  // prevent potentially conflicting session namespaces
+  if (!settings.name) {
+    settings.name = count;
+    count++;
+  }
+
+  settings.name = `hof-wizard-${settings.name}`;
+  settings.formatters = settings.formatters || ['trim', 'singlespaces', 'hyphens'];
+
+  const app = express.Router();
+
+  app.use(require('./middleware/session'));
+
+  let first;
+
+  if (!steps['/']) {
+    app.get('/', (req, res) => {
+      res.redirect(path.join(req.baseUrl, first));
+    });
+  }
+
+  _.each(steps, (opts, route) => {
+    first = first || route;
+
+    const options = _.cloneDeep(opts);
+
+    options.fields = (options.fields || []).reduce((obj, field) => {
+      obj[field] = fields[field] || {};
+      return obj;
+    }, {});
+    options.steps = steps;
+    options.route = route;
+    options.appConfig = settings.appConfig;
+    options.confirmStep = settings.confirmStep;
+    options.exitStep = settings.exitStep;
+    options.saveAndExitStep = settings.saveAndExitStep;
+    options.clearSession = options.clearSession || false;
+    options.fieldsConfig = _.cloneDeep(fields);
+    options.sanitiseInputs = settings.sanitiseInputs;
+
+    options.defaultFormatters = [].concat(settings.formatters);
+
+    // default template is the same as the pathname
+    options.template = options.template || route.replace(/^\//, '');
+    if (settings.templatePath) {
+      options.template = settings.templatePath + '/' + options.template;
+    }
+
+    options.i18n = settings.i18n;
+
+    if (options.controller) {
+      deprecate(
+        'hof-form-wizard: Passing a custom step controller is deprecated',
+        'Instead give one or more behaviours which will be mixed in to the base controller'
+      );
+    }
+
+    const SuperClass = options.controller || settings.controller;
+    const Controller = getController(SuperClass, options.behaviours);
+    const controller = new Controller(options);
+
+    controller.use([
+      require('./middleware/check-session')(route, controller, steps, first, settings),
+      require('./middleware/check-complete')(route, controller, steps, first),
+      require('./middleware/check-progress')(route, controller, steps, first)
+    ]);
+    if (settings.csrf !== false) {
+      controller.use(require('./middleware/csrf')(route, controller, steps, first));
+    }
+
+    app.route(route + settings.params)
+      .all((req, res, next) => {
+        if (settings.translate) {
+          req.translate = settings.translate;
+        }
+        next();
+      })
+      .all(require('./middleware/session-model')(settings))
+      .all(require('./middleware/back-links')(route, controller, steps, first))
+      .all(controller.requestHandler());
+  });
+
+  return app;
+};
+
+Wizard.Controller = FormController;
+Wizard.Error = FormController.Error;
+
+module.exports = Wizard;

package/package/wizard/middleware/back-links.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const path = require('path');
+const _ = require('lodash');
+const helpers = require('../util/helpers');
+
+module.exports = (route, controller, steps) => {
+  const previousSteps = helpers.getRouteSteps(route, steps);
+
+  const checkReferrer = (referrer, baseUrl) => {
+    const referrerPath = new URL(referrer).pathname;
+    const matchingPath = controller.options.backLinks.find(link => {
+      if (link.match(/^\//)) {
+        return path.normalize(link) === referrerPath;
+      } else if (path.relative(baseUrl, referrerPath)) {
+        return path.normalize(link) === path.relative(baseUrl, referrerPath);
+      } else if (referrerPath.replace(/^\//, '') === link.replace(/^\.*\//, '')) {
+        return path.normalize(link);
+      }
+      return undefined;
+    });
+    if (typeof matchingPath === 'string') {
+      return path.normalize(matchingPath);
+    }
+    return undefined;
+  };
+
+  const checkFormHistory = sessionData => {
+    const prev = _(sessionData)
+      .pickBy((value, key) => key.indexOf('hof-wizard') > -1)
+      .map('steps')
+      .flatten()
+      .uniq()
+      .value();
+
+    const allowedLinks = controller.options.backLinks.map(item =>
+      item.replace('\.', '')
+    );
+
+    const backLinks = _.intersection(prev, allowedLinks);
+
+    return backLinks.length ? _.last(backLinks).replace(/^\//, '') : undefined;
+  };
+
+  const getBackLink = req => {
+    const previous = _.intersection(req.sessionModel.get('steps'), previousSteps);
+    let backLink;
+
+    if (typeof controller.options.backLink !== 'undefined') {
+      return controller.options.backLink;
+    } else if (previous.length) {
+      backLink = req.baseUrl === '/' ? _.last(previous) : _.last(previous).replace(/^\//, '');
+    } else if (controller.options.backLinks && req.get('referrer')) {
+      backLink = checkReferrer(req.get('referrer'), req.baseUrl) || checkFormHistory(req.session);
+    }
+
+    return backLink;
+  };
+
+  return (req, res, next) => {
+    if (req.method === 'GET') {
+      const last = _.last(req.sessionModel.get('steps'));
+      req.isBackLink = (last === route || last === controller.options.next);
+      res.locals.backLink = getBackLink(req);
+    }
+    next();
+  };
+};

package/package/wizard/middleware/check-complete.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const constants = require('../util/constants');
+const path = require('path');
+
+module.exports = (route, controller, steps, start) => (req, res, next) => {
+  if (req.sessionModel.get(constants.APPLICATION_COMPLETE) && !controller.options.allowPostComplete) {
+    req.sessionModel.reset();
+    res.redirect(path.join(req.baseUrl, start));
+    return;
+  }
+  next();
+};