hof 22.9.0-beta → 22.9.0-beta.v2

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

@@ -1,139 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-const debug = require('debug')('hof:progress-check');
-const helpers = require('../util/helpers');
-
-module.exports = (route, controller, steps, begin) => {
-  const start = begin || '/';
-  const previousSteps = helpers.getRouteSteps(route, steps);
-  const prereqs = (controller.options.prereqs || []).concat(previousSteps);
-
-  const invalidatingFields = _.pickBy(controller.options.fields, function (field) {
-    return field && field.invalidates && field.invalidates.length;
-  });
-
-  const getAllPossibleSteps = (stepName, scopedSteps, stps) => {
-    let allSteps = stps || [stepName];
-    let step = scopedSteps[stepName];
-    const forksReducer = (arr, fork) => getAllPossibleSteps(fork, scopedSteps, allSteps);
-    // don't loop over steps that have already been added
-    while (step && step.next && allSteps.indexOf(step.next) === -1) {
-      allSteps.push(step.next);
-      // ignore forks that have already been traversed.
-      const forks = _.difference(_.map(step.forks, 'target'), allSteps);
-      allSteps = allSteps.concat(forks.reduce(forksReducer, []));
-      step = scopedSteps[step.next];
-    }
-    return _.uniq(allSteps);
-  };
-
-  // Gets all the possible routes
-  const walkAllPossibleSteps = (stepName, allStepsInService, allVisitedSteps) => {
-    const stepIncludingFieldsAndForks = allStepsInService[stepName];
-    if (!stepIncludingFieldsAndForks) { return; }
-
-    const forkTargets = _.map(stepIncludingFieldsAndForks.forks, 'target') || [];
-    const nextStep = stepIncludingFieldsAndForks.next || '';
-
-    // If there is no next step or fork, then we have reached the end of the journey
-    if (!forkTargets.length && !nextStep) {
-      allVisitedSteps.push(stepName);
-      // eslint-disable-next-line consistent-return
-      return _.uniq(allVisitedSteps);
-    }
-
-    const nextStepsAndForks = _.uniq(forkTargets.concat(nextStep));
-
-    // We need to transverse through all 'Next' and 'Forks' for this route
-    nextStepsAndForks.map(each => {
-      if (!allVisitedSteps.includes(each)) {
-        allVisitedSteps.push(each);
-        walkAllPossibleSteps(each, allStepsInService, allVisitedSteps);
-      }
-    });
-  };
-
-  // Create a list of all visited steps
-  const createAllVisitedSteps = (stepName, allStepsInService) => {
-    const allVisitedSteps = [stepName];
-    if (allStepsInService[stepName]) {
-      walkAllPossibleSteps(stepName, allStepsInService, allVisitedSteps);
-    }
-    return _.uniq(allVisitedSteps);
-  };
-
-  const invalidateStep = (stepName, scopedSteps, sessionModel) => {
-    debug('Invalidating', stepName);
-    const step = scopedSteps[stepName] || {};
-    sessionModel.unset(step.fields || []);
-    sessionModel.set('steps', _.without(sessionModel.get('steps'), stepName));
-  };
-
-  // detect if a path will arrive back at the current step if followed
-  const isLoop = (target, current) => {
-    debug('target', target);
-    debug('current', current);
-    debug('paths', getAllPossibleSteps(target, steps));
-    return getAllPossibleSteps(target, steps).indexOf(current) > -1;
-  };
-
-  const invalidatePath = (req, res) => {
-    const nextStep = controller.getForkTarget(req, res);
-
-    const forks = controller.options.forks.map(fork => fork.target);
-
-    let potentialPaths = [controller.options.next].concat(forks);
-    debug('potential paths', potentialPaths);
-    // do not invalidate forks which loop back to the current step and are *not* being followed
-    potentialPaths = potentialPaths.filter(path => path === nextStep || !isLoop(path, route));
-    debug('next', nextStep);
-    debug('potential paths', potentialPaths);
-    // if we're following a loop then allow the loop to be invalidated
-    const whitelist = isLoop(nextStep, req.path) ? [route] : createAllVisitedSteps(nextStep, steps);
-    // aggregate all potential journeys from the invalidating step
-    const invalidateSteps = potentialPaths.reduce((arr, step) => arr.concat(getAllPossibleSteps(step, steps)), []);
-
-    _.difference(_.uniq(invalidateSteps), whitelist).forEach(step => {
-      invalidateStep(step, steps, req.sessionModel);
-    });
-  };
-
-  controller.on('complete', (req, res, p) => {
-    const sessionsteps = req.sessionModel.get('steps') || [];
-    const path = p || route;
-    debug('Marking path complete ', path);
-    const index = sessionsteps.indexOf(path);
-    if (index > -1) {
-      sessionsteps.splice(index, 1);
-    }
-    sessionsteps.push(path);
-    req.sessionModel.set('steps', sessionsteps);
-
-    if (req.method === 'POST' && controller.options.forks) {
-      invalidatePath(req, res);
-    }
-  });
-
-  return (req, res, next) => {
-    _.each(invalidatingFields, (field, key) => {
-      req.sessionModel.on('change:' + key, () => {
-        debug('Unsetting fields %s', field.invalidates.join(', '));
-        req.sessionModel.unset(field.invalidates);
-      });
-    });
-
-    const visited = _.intersection(req.sessionModel.get('steps'), prereqs);
-
-    debug('Steps ', req.sessionModel.get('steps'));
-    debug('Prereqs ' + prereqs);
-    debug('Visited ' + visited);
-    if (visited.length || !prereqs.length || route === start) {
-      next();
-    } else {
-      const err = new Error('Attempt to access page without prerequisite steps being completed');
-      err.code = 'MISSING_PREREQ';
-      next(err);
-    }
-  };
-};

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

@@ -1,17 +0,0 @@
-'use strict';
-
-const secureHttps = config => config.protocol === 'https' || config.env === 'production';
-
-module.exports = (route, controller, steps, first, settings) => (req, res, next) => {
-  if (controller.options.checkSession !== false && (req.method === 'POST' || req.path !== first)) {
-    if (req.cookies['hof-wizard-sc'] && req.session.exists !== true) {
-      const err = new Error('Session expired');
-      err.code = 'SESSION_TIMEOUT';
-      return next(err);
-    }
-  }
-  req.session.exists = true;
-  // Set samesite to lax to allow setting cookies on redirects from Gov.UK
-  res.cookie('hof-wizard-sc', 1, { sameSite: 'lax', secure: secureHttps(settings), httpOnly: true });
-  return next();
-};

package/package/wizard/middleware/csrf.js

@@ -1,47 +0,0 @@
-'use strict';
-
-const csrf = require('csrf')();
-
-module.exports = (route, controller) => {
-  if (controller.options.csrf !== false) {
-    return (req, res, next) => {
-      const verify = () => {
-        const secret = req.sessionModel.get('csrf-secret');
-        const safeMethods = ['GET', 'HEAD', 'OPTIONS'];
-
-        if (!secret) {
-          csrf.secret((err, sec) => {
-            if (err) {
-              next(err);
-            }
-            req.sessionModel.set('csrf-secret', sec);
-            verify();
-          });
-        } else if (safeMethods.indexOf(req.method) > -1) {
-          // The HTTP method is safe. No need to verify a
-          // token. Instead, provide a new one for future
-          // verification.
-          res.locals['csrf-token'] = csrf.create(secret);
-          next();
-        } else {
-          // The HTTP method is assumed to be unsafe so
-          // require verification.
-
-          // Token can be provided in either the request body
-          // or the headers. Preference is given to the body.
-          const token = req.body['x-csrf-token']
-          || req.headers['x-csrf-token'];
-
-          if (!csrf.verify(secret, token)) {
-            next({ code: 'CSRF_ERROR' });
-          } else {
-            next();
-          }
-        }
-      };
-
-      verify();
-    };
-  }
-  return (req, res, next) => next();
-};

package/package/wizard/middleware/session-model.js

@@ -1,11 +0,0 @@
-'use strict';
-
-const Model = require('../model');
-
-module.exports = options => (req, res, next) => {
-  req.sessionModel = new Model({}, {
-    session: req.session,
-    key: options.name
-  });
-  next();
-};

package/package/wizard/middleware/session.js

@@ -1,9 +0,0 @@
-'use strict';
-
-module.exports = (req, res, next) => {
-  if (typeof req.session === 'undefined') {
-    throw new Error('Session is undefined');
-  } else {
-    next();
-  }
-};

package/package/wizard/model.js

@@ -1,29 +0,0 @@
-'use strict';
-
-const Model = require('../model');
-
-module.exports = class SessionModel extends Model {
-  constructor(props, options) {
-    const session = options.session;
-    const key = options.key;
-
-    if (!key || typeof key !== 'string') {
-      throw new Error('session-model - key must be defined');
-    }
-
-    session[key] = session[key] || {};
-
-    // include session values on initialized attributes
-    const attrs = Object.assign({}, session[key], props);
-
-    super(attrs, options);
-
-    // write changes back to the session
-    this.on('change', changes => {
-      Object.assign(session[key], changes);
-    });
-    this.on('reset', () => {
-      session[key] = {};
-    });
-  }
-};

package/package/wizard/util/constants.js

@@ -1,5 +0,0 @@
-'use strict';
-
-module.exports = {
-  APPLICATION_COMPLETE: '__application_complete'
-};

package/package/wizard/util/helpers.js

@@ -1,19 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-
-module.exports = {
-  getRouteSteps(route, steps) {
-    return _.reduce(steps, (list, step, path) => {
-      const isNext = step.next === route;
-      const targets = _.map((step.forks || []), 'target');
-
-      const isFork = targets.some(fork => fork === route);
-
-      if (isNext || isFork) {
-        list.push(path);
-      }
-      return list;
-    }, []);
-  }
-};