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

package/package/controller/controller.js

@@ -0,0 +1,258 @@
+'use strict';
+
+const _ = require('lodash');
+const i18nLookup = require('i18n-lookup');
+const Mustache = require('mustache');
+const BaseController = require('./base-controller');
+const Helpers = require('../utilities').helpers;
+
+const omitField = (field, req) => field.useWhen && (typeof field.useWhen === 'string'
+  ? req.sessionModel.get(field.useWhen) !== 'true'
+  : req.sessionModel.get(field.useWhen.field) !== field.useWhen.value);
+
+module.exports = class Controller extends BaseController {
+  constructor(options) {
+    super(options);
+    this.confirmStep = options.confirmStep || '/confirm';
+  }
+
+  configure(req, res, callback) {
+    const removeFields = Object.keys(_.pickBy(req.form.options.fields, field => omitField(field, req)));
+    if (removeFields.length) {
+      req.form.options.fields = _.omit(req.form.options.fields, removeFields);
+      req.sessionModel.unset(removeFields);
+    }
+    callback();
+  }
+
+  get(req, res, callback) {
+    const template = this.options.template || '';
+    res.render(template, err => {
+      if (err && err.message.match(/^Failed to lookup view/)) {
+        this.options.template = res.locals.partials.step;
+      }
+    });
+    super.get(req, res, callback);
+  }
+
+  getNextStep(req, res) {
+    let next = super.getNextStep(req, res);
+    const forks = req.form.options.forks || [];
+
+    const normaliseUrl = url => req.baseUrl === '/' ? url : req.baseUrl + url;
+
+    const confirmStep = normaliseUrl(this.confirmStep);
+
+    const completed = s => {
+      let step = s;
+      if (req.baseUrl !== '/') {
+        const re = new RegExp('^' + req.baseUrl);
+        step = step.replace(re, '');
+      }
+      // Has the user already completed the step?
+      return _.includes(req.sessionModel.get('steps'), step);
+    };
+
+    // If a form condition is met, its target supercedes the next property
+    next = _.reduce(forks, (result, value) => {
+      if (Helpers.isFieldValueInPageOrSessionValid(req, res, value.condition)) {
+        if (value.continueOnEdit) {
+          req.form.options.continueOnEdit = true;
+        }
+        return normaliseUrl(value.target);
+      }
+      return result;
+    }, next);
+
+
+    if (req.params.action === 'edit') {
+      if (!req.form.options.continueOnEdit && completed(next)) {
+        next = confirmStep;
+      }
+      if (next !== confirmStep) {
+        next += '/edit';
+      }
+    }
+
+    return next;
+  }
+
+  getBackLink(req, res) {
+    const backLink = res.locals.backLink;
+    const trailingEdit = req.params.action === 'edit' ? '/edit' : '';
+    const leadingSlash = /^\/?\w+/.test(req.baseUrl) ? '' : '/';
+
+    if (!backLink) {
+      return backLink;
+    }
+
+    return `${leadingSlash}${backLink}${trailingEdit}`;
+  }
+
+  getErrorStep(err, req) {
+    let redirect = super.getErrorStep(err, req);
+    if (req.params.action === 'edit' && !redirect.match(/\/edit$|\/edit\//)) {
+      redirect += '/edit';
+    }
+    return redirect;
+  }
+
+  locals(req, res) {
+    const lookup = i18nLookup(req.translate, Mustache.render);
+    const route = req.form.options.route.replace(/^\//, '');
+    const locals = super.locals(req, res);
+    const stepLocals = req.form.options.locals || {};
+
+    let fields = _.map(req.form.options.fields, (field, key) =>
+      Object.assign({}, field, { key })
+    );
+    // only include fields that aren't dependents to mitigate duplicate fields on the page
+    fields = fields.filter(field => !req.form.options.fields[field.key].dependent);
+
+    const exitStep = req.form.options.exitStep || '/exit';
+    const saveAndExitStep = req.form.options.saveAndExitStep || '/save-and-exit';
+    return _.extend({}, locals, {
+      fields,
+      route,
+      baseUrl: req.baseUrl,
+      exitStep,
+      saveAndExitStep,
+      skipToMain: this.getFirstFormItem(req.form.options.fields),
+      title: this.getTitle(route, lookup, req.form.options.fields, res.locals),
+      journeyHeaderURL: this.getJourneyHeaderURL(req.baseUrl),
+      header: this.getHeader(route, lookup, res.locals),
+      serviceName: this.getServiceName(lookup, res.locals),
+      captionHeading: this.getCaptionHeading(route, lookup, res.locals),
+      warning: this.getWarning(route, lookup, res.locals),
+      subHeading: this.getSubHeading(route, lookup, res.locals),
+      intro: this.getIntro(route, lookup, res.locals),
+      backLink: this.getBackLink(req, res),
+      nextPage: this.getNextStep(req, res),
+      errorLength: this.getErrorLength(req, res)
+    }, stepLocals);
+  }
+
+  getJourneyHeaderURL(url) {
+    return url === '' ? '/' : url;
+  }
+
+  getFirstFormItem(fields) {
+    let firstFieldKey;
+    if (_.size(fields)) {
+      firstFieldKey = Object.keys(fields)[0];
+    }
+    return firstFieldKey | 'main-content';
+  }
+
+  getHeader(route, lookup, locals) {
+    return lookup(`pages.${route}.header`, locals);
+  }
+
+  getServiceName(lookup, locals) {
+    return lookup([
+      'journey.serviceName',
+      'journey.header'
+    ], locals);
+  }
+
+  getCaptionHeading(route, lookup, locals) {
+    return lookup(`pages.${route}.captionHeading`, locals);
+  }
+
+  getSubHeading(route, lookup, locals) {
+    return lookup(`pages.${route}.subHeading`, locals);
+  }
+
+  getWarning(route, lookup, locals) {
+    return lookup(`pages.${route}.warning`, locals);
+  }
+
+  getTitle(route, lookup, fields, locals) {
+    let fieldName = '';
+    if (_.size(fields)) {
+      fieldName = Object.keys(fields)[0];
+    }
+    return lookup([
+      `pages.${route}.title`,
+      `pages.${route}.header`,
+      `fields.${fieldName}.label`,
+      `fields.${fieldName}.legend`
+    ], locals);
+  }
+
+  getIntro(route, lookup, locals) {
+    return lookup([
+      `pages.${route}.intro`
+    ], locals);
+  }
+
+  _getErrors(req, res, callback) {
+    super._getErrors(req, res, () => {
+      Object.keys(req.form.errors).forEach(key => {
+        if (req.form && req.form.options && req.form.options.fields) {
+          const field = req.form.options.fields[key];
+          // get first option for radios and checkbox
+          if (field.mixin === 'radio-group' || field.mixin === 'checkbox-group') {
+            // get first option for radios and checkbox where there is a toggle
+            if (typeof field.options[0] === 'object') {
+              req.form.errors[key].errorLinkId = key + '-' + field.options[0].value;
+            } else {
+              req.form.errors[key].errorLinkId = key + '-' + field.options[0];
+            }
+            // eslint-disable-next-line brace-style
+          }
+          // get first field for date input control
+          else if (field && field.mixin === 'input-date') {
+            req.form.errors[key].errorLinkId = key + '-day';
+          } else {
+            req.form.errors[key].errorLinkId = key;
+          }
+        }
+
+        req.form.errors[key].message = this.getErrorMessage(req.form.errors[key], req, res);
+      });
+      callback();
+    });
+  }
+
+  getErrorMessage(error, req, res) {
+    error.type = error.type || 'default';
+    error.options = error.options || {};
+    const keys = [
+      `fields.${error.key}.validation.${error.type}`,
+      `validation.${error.key}.${error.type}`,
+      `validation.${error.key}.default`,
+      `validation.${error.type}`,
+      'validation.default'
+    ];
+    const getArgs = () => {
+      if (error.type === 'before' || error.type === 'after') {
+        return { diff: error.arguments.join(' ') };
+      } else if (error.arguments && Array.isArray(error.arguments)) {
+        return { [error.type]: error.arguments[0] };
+      }
+      return {};
+    };
+    const context = Object.assign({
+      label: req.translate(`fields.${error.key}.label`).toLowerCase(),
+      legend: req.translate(`fields.${error.key}.legend`).toLowerCase()
+    }, res.locals, getArgs(error));
+
+    return i18nLookup(req.translate, Mustache.render)(keys, context);
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  getErrorLength(req, res) {
+    if (!req.form.errors) {
+      return undefined;
+    }
+
+    const errorLength = Object.keys(req.form.errors).length;
+
+    const propName = errorLength === 1 ? 'single' : 'multiple';
+
+    return errorLength ? {
+      [propName]: true
+    } : undefined;
+  }
+};

package/package/controller/deprecate-error.js

@@ -0,0 +1,10 @@
+'use strict';
+
+const deprecate = require('deprecate');
+
+module.exports = superclass => class DeprecatedError extends superclass {
+  constructor(options) {
+    deprecate('this.Error is deprecated in favour of this.ValidationError');
+    super(options);
+  }
+};

package/package/controller/formatting/formatters.js

@@ -0,0 +1,70 @@
+'use strict';
+
+module.exports = {
+
+  trim(value) {
+    return typeof value === 'string' ? value.trim() : value;
+  },
+
+  boolean(value) {
+    if (value === true || value === 'true') {
+      return true;
+    } else if (value === false || value === 'false') {
+      return false;
+    }
+    return undefined;
+  },
+
+  uppercase(value) {
+    return typeof value === 'string' ? value.toUpperCase() : value;
+  },
+
+  lowercase(value) {
+    return typeof value === 'string' ? value.toLowerCase() : value;
+  },
+
+  removespaces(value) {
+    return typeof value === 'string' ? value.replace(/\s+/g, '') : value;
+  },
+
+  singlespaces(value) {
+    return typeof value === 'string' ? value.replace(/\s+/g, ' ') : value;
+  },
+
+  hyphens(value) {
+    return typeof value === 'string' ? value.replace(/[–—-]+/g, '-') : value;
+  },
+
+  removeroundbrackets(value) {
+    return typeof value === 'string' ? value.replace(/[\(\)]/g, '') : value;
+  },
+
+  removehyphens(value) {
+    return typeof value === 'string' ? value.replace(/[–—-]+/g, '') : value;
+  },
+
+  removeslashes(value) {
+    return typeof value === 'string' ? value.replace(/[\/\\]/g, '') : value;
+  },
+
+  ukphoneprefix(value) {
+    return typeof value === 'string' ? value.replace(/^\+44\(?0?\)?/, '0') : value;
+  },
+
+  base64decode(value) {
+    return Buffer.from(value, 'base64').toString();
+  },
+
+  ukPostcode(value) {
+    if (typeof value !== 'string' || value === '') {
+      return value;
+    }
+
+    const postcode = this.uppercase(this.removespaces(value));
+    const firstPart = postcode.slice(0, -3);
+    const secondPart = postcode.slice(-3);
+
+    return `${firstPart} ${secondPart}`;
+  }
+
+};

package/package/controller/formatting/index.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const _ = require('lodash');
+
+function format(f, val, formatters) {
+  let value = val;
+  if (typeof f === 'string' && formatters[f]) {
+    return formatters[f](value);
+  } else if (typeof f === 'function') {
+    return f(value);
+  } else if (Array.isArray(f)) {
+    f.forEach(v => {
+      value = format(v, value, formatters);
+    });
+  }
+  return value;
+}
+
+module.exports = (fields, _default, f) => (key, v) => {
+  const formatters = f || require('./formatters');
+  let value = _.castArray(v);
+  if (_default && !(fields[key] && fields[key]['ignore-defaults'])) {
+    value = value.map(item => format(_default, item, formatters));
+  }
+  if (fields[key] && fields[key].formatter) {
+    value = value.map(item => format(fields[key].formatter, item, formatters));
+  }
+  if (value.length === 1) {
+    value = value[0];
+  }
+  return value;
+};

package/package/controller/index.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const Session = require('./behaviour-session');
+const Hooks = require('./behaviour-hooks');
+const Controller = require('./controller');
+const mix = require('mixwith').mix;
+
+class FormController extends mix(Controller).with(Session, Hooks) {}
+
+FormController.validators = require('./validation/validators');
+FormController.formatters = require('./formatting/formatters');
+
+FormController.ValidationError = require('./validation-error');
+
+module.exports = FormController;
+module.exports.Controller = Controller;
+module.exports.BaseController = require('./base-controller');

package/package/controller/validation/email.js

@@ -0,0 +1,30 @@
+/* eslint-disable vars-on-top */
+'use strict';
+
+// eslint-disable-next-line max-len
+const tester = /^[-!#$%&'*+\/0-9=?A-Z^_a-z`{|}~](\.?[-!#$%&'*+\/0-9=?A-Z^_a-z`{|}~])*@[a-zA-Z0-9](-*\.?[a-zA-Z0-9])*\.[a-zA-Z](-?[a-zA-Z0-9])+$/;
+
+module.exports = function (email) {
+  if (!email || !(typeof email === 'string')) return false;
+
+  const emailParts = email.split('@');
+
+  if (emailParts.length !== 2) return false;
+
+  const account = emailParts[0];
+  const address = emailParts[1];
+
+  if (account.length > 64) return false;
+
+  else if (address.length > 255) return false;
+
+  const domainParts = address.split('.');
+  if (domainParts.some(function (part) {
+    return part.length > 63;
+  })) return false;
+
+
+  if (!tester.test(email)) return false;
+
+  return true;
+};

package/package/controller/validation/index.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const _ = require('lodash');
+const debug = require('debug')('hmpo:validation');
+
+const validators = require('./validators');
+
+function applyValidator(vlt, value, key) {
+  const validator = typeof vlt === 'string' ? { type: vlt } : vlt;
+
+  function doValidate() {
+    debug('Applying %s validator with value "%s"', validator.type, value);
+    let args = [value];
+    if (!Array.isArray(validator.arguments)) {
+      validator.arguments = [validator.arguments];
+    }
+    args = args.concat(validator.arguments);
+    if (!validators[validator.type].apply(null, args)) {
+      return Object.assign({ key }, validator, { arguments: validator.arguments });
+    }
+    return undefined;
+  }
+
+  function customValidate() {
+    debug('Applying custom %s validator with value %s', validator.name, value);
+    if (!validator(value)) {
+      return Object.assign({ key }, { type: validator.name });
+    }
+    return undefined;
+  }
+
+  if (validators[validator.type]) {
+    return doValidate();
+  } else if (typeof validator  === 'function') {
+    if (validator.name) {
+      return customValidate();
+    }
+    throw new Error('Custom validator needs to be a named function');
+  } else {
+    throw new Error(`Undefined validator:${validator.type}`);
+  }
+}
+
+function validate(fields) {
+  _.each(fields, (field, key) => {
+    if (typeof fields[key].validate === 'string') {
+      fields[key].validate = [fields[key].validate];
+    }
+
+    if (fields[key].options) {
+      fields[key].validate = fields[key].validate || [];
+      fields[key].validate.push({
+        type: 'equal',
+        arguments: _.map(fields[key].options, option =>
+          typeof option === 'string' ? option : option.value
+        )
+      });
+    }
+  });
+
+  // eslint-disable-next-line consistent-return
+  return (key, value, values, emptyValue) => {
+    debug(`Validating field: "${key}" with value: "${value}"`);
+
+    function shouldValidate() {
+      // validationLink used to validates multiple dependent fields in checkbox-group
+      let dependent = fields[key].dependent || fields[key].validationLink;
+
+      if (typeof dependent === 'string') {
+        dependent = {
+          field: dependent,
+          value: true
+        };
+      }
+      if (!dependent
+        || (dependent && !fields[dependent.field])
+        || (dependent && (Array.isArray(values[dependent.field])
+          ? values[dependent.field].indexOf(dependent.value) > -1
+          : values[dependent.field] === dependent.value))
+      ) {
+        return true;
+      }
+      return false;
+    }
+
+    if (fields[key]) {
+      if (shouldValidate()) {
+        debug(`Applying validation on field ${key} with ${value}`);
+        return _.reduce(fields[key].validate, (err, validator) =>
+          err || applyValidator(validator, value, key)
+        , null);
+      }
+      values[key] = emptyValue === undefined ? '' : emptyValue;
+      debug('Skipping validation for field %s', key);
+    }
+  };
+}
+
+validate.validators = validators;
+
+module.exports = validate;

package/package/controller/validation/validators.js

@@ -0,0 +1,181 @@
+'use strict';
+
+const moment = require('moment');
+const _ = require('lodash');
+const libPhoneNumber = require('libphonenumber-js/max');
+const deprecate = require('deprecate');
+const emailValidator = require('./email');
+
+// validator methods should return false (or falsy value) for *invalid* input
+// and true (or truthy value) for *valid* input.
+const dateFormat = 'YYYY-MM-DD';
+let Validators;
+
+module.exports = Validators = {
+
+  string(value) {
+    return typeof value === 'string';
+  },
+
+  decimal(value) {
+    return value === '' || Validators.regex(value, /^-?[\d]*\.?\d{0,2}$/);
+  },
+
+  regex(value, match) {
+    return Validators.string(value) && !!value.match(match);
+  },
+
+  required(value) {
+    return value !== undefined && value !== '';
+  },
+
+  url(value) {
+    return value === '' ||
+      Validators.regex(value, /[-a-zA-Z0-9@:%._\+~#=]{2,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_\+.~#?&//=]*)/);
+  },
+
+  notUrl(value) {
+    return value === '' || !(Validators.url(value));
+  },
+
+  email(value) {
+    return value === '' || emailValidator(value);
+  },
+
+  between(value, min, max) {
+    return value === '' || (value <= max && value >= min);
+  },
+
+  min(value, min) {
+    return value === '' || value >= min;
+  },
+
+  max(value, max) {
+    return value === '' || value <= max;
+  },
+
+  minlength(value, length) {
+    return Validators.string(value) && (value === '' || value.length >= (length || 0));
+  },
+
+  maxlength(value, length) {
+    return Validators.string(value) && (value === '' || value.length <= length);
+  },
+
+  maxword(value, length) {
+    return Validators.string(value) && (value === '' || value.split(/\s+/).length <= length);
+  },
+
+  exactlength(value, length) {
+    return Validators.string(value) && (value === '' || value.length === length);
+  },
+
+  alphanum(value) {
+    return Validators.regex(value, /^[a-zA-Z0-9]*$/);
+  },
+
+  numeric(value) {
+    return Validators.regex(value, /^\d*$/);
+  },
+
+  equal(v) {
+    const values = [].slice.call(arguments, 1);
+    const value = _.castArray(v);
+    return values.length && _.every(value, item =>
+      item === '' || values.indexOf(item) > -1
+    );
+  },
+
+  phonenumber(value) {
+    deprecate('phonenumber validator', 'Recommend using internationalPhoneNumber for validating ' +
+      'international numbers or a different phone validator for more specific requirements.');
+    return value === '' || Validators.regex(value, /^\(?\+?[\d()-]{0,15}$/);
+  },
+
+  /**
+   * Validates international phone numbers (fixed and mobile) including UK.
+   * Non-GB phone numbers will require country code to validate.
+   */
+  internationalPhoneNumber(value, code) {
+    const countryCode = code || 'GB';
+    const phoneNumber = libPhoneNumber.parsePhoneNumberFromString(value, countryCode) || '';
+    const isValidComparedToGivenCountry = code ? phoneNumber.country === countryCode : true;
+    return value === '' || (phoneNumber && phoneNumber.isValid() && isValidComparedToGivenCountry);
+  },
+
+  ukPhoneNumber(value) {
+    const phoneNumber = libPhoneNumber.parsePhoneNumberFromString(value, 'GB')  || '';
+    return value === '' || (phoneNumber && phoneNumber.isValid() && phoneNumber.country === 'GB');
+  },
+
+  ukmobilephone(value) {
+    return value === '' || Validators.regex(value, /^(?:\+447|07)\d{9}$/);
+  },
+
+  date(value) {
+    return value === '' || Validators.regex(value, /\d{4}\-\d{2}\-\d{2}/) && moment(value, dateFormat).isValid();
+  },
+
+  'date-year'(value) {
+    return Validators.regex(value, /^\d{4}$/);
+  },
+
+  'date-month'(value) {
+    return Validators.regex(value, /^\d{2}$/) && parseInt(value, 10) > 0 && parseInt(value, 10) < 13;
+  },
+
+  'date-day'(value) {
+    return Validators.regex(value, /^\d{2}$/) && parseInt(value, 10) > 0 && parseInt(value, 10) < 32;
+  },
+
+  // eslint-disable-next-line no-inline-comments, spaced-comment
+  before(value, date) {
+    // validator can also do before(value, [diff, unit][, diff, unit])
+    let valueDate = moment(value, dateFormat);
+    let comparator;
+    if (arguments.length === 2) {
+      comparator = date;
+    } else {
+      comparator = moment();
+      const args = [].slice.call(arguments, 1);
+      let diff;
+      let unit;
+      while (args.length) {
+        diff = args.shift();
+        unit = args.shift() || 'years';
+        valueDate = valueDate.add(diff, unit);
+      }
+    }
+    return value === '' || Validators.date(value) && valueDate.isBefore(comparator);
+  },
+
+  after(value, date) {
+    // validator can also do after(value, [diff, unit][, diff, unit])
+    let valueDate = moment(value, dateFormat);
+    let comparator;
+    if (arguments.length === 2) {
+      comparator = date;
+    } else {
+      comparator = moment();
+      const args = [].slice.call(arguments, 1);
+      let diff;
+      let unit;
+      while (args.length) {
+        diff = args.shift();
+        unit = args.shift() || 'years';
+        valueDate = valueDate.add(diff, unit);
+      }
+    }
+    return value === '' || Validators.date(value) && valueDate.isAfter(comparator);
+  },
+
+  over18(value) {
+    return Validators.before(value, '18', 'years');
+  },
+
+  postcode(value) {
+    // eslint-disable-next-line max-len
+    return value === '' || Validators.regex(value, /^(([GIR] ?0[A]{2})|((([A-Z][0-9]{1,2})|(([A-Z][A-HJ-Y][0-9]{1,2})|(([A-Z][0-9][A-Z])|([A-Z][A-HJ-Y][0-9]?[A-Z])))) ?[0-9][A-Z]{2}))$/i);
+  }
+
+};