@dwp/govuk-casa 7.0.6 → 8.0.0-beta1

package/lib/utils/sanitise.js

@@ -1,74 +0,0 @@
-const { URL } = require('url');
-
-const reLeadingSlashes = /^\/+/;
-
-/**
- * Sanitise waypoint.
- *
- * Valid examples:
- *  a-waypoint
- *  an-origin/a-waypoint
- *  an-origin/a-waypoint/with-forward-slash
- *
- * @param {string} waypoint Waypoint, including optional Plan origin
- * @returns {string} Waypoint
- */
-function sanitiseWaypoint(waypoint = '') {
-  if (typeof waypoint !== 'string') {
-    return '';
-  }
-
-  return waypoint.toLowerCase().replace(/[^a-z0-9/-]/g, '').replace(/\/+/g, '/').replace(/^\/+/, '')
-    .replace(/\/+$/, '');
-}
-
-/**
- * Sanitise the pathname of a URL, and prepend with a forward slash.
- *
- * Valid examples:
- *  /some-path
- *  /mount-url/some-path
- *  /further/path/parts
- *
- * @param {string} path Path
- * @returns {string} Path
- */
-function sanitiseAbsolutePath(path) {
-  if (typeof path !== 'string') {
-    return '/';
-  }
-
-  return `/${path.toLowerCase().replace(/[^a-z0-9/-]/g, '').replace(/\/+/g, '/').replace(/^\/+/, '')
-    .replace(/\/+$/, '')}`;
-}
-
-/**
- * Coeerce url to a relative represenation.
- *
- * @param {string} url URL to sanitise
- * @returns {string} Sanitised URL
- */
-function sanitiseRelativeUrl(url) {
-  if (typeof url !== 'string') {
-    return '/';
-  }
-
-  const sanitised = new URL(url, 'https://base.test');
-
-  return `/${sanitised.pathname}`.replace(reLeadingSlashes, '/') + sanitised.search;
-}
-
-function sanitiseContextId(id) {
-  if (typeof id !== 'string') {
-    return '';
-  }
-
-  return String(id).replace(/[^a-z0-9-]/g, '');
-}
-
-module.exports = {
-  sanitiseWaypoint,
-  sanitiseAbsolutePath,
-  sanitiseRelativeUrl,
-  sanitiseContextId,
-};

package/lib/utils/validate.js

@@ -1,32 +0,0 @@
-const invalidSlugRegex = /[^a-z0-9-]/;
-const invalidSlugPathRegex = /[^a-z0-9/-]/;
-
-function validateMountUrl(mountUrl, { name = 'mountUrl' } = {}) {
-  if (typeof mountUrl !== 'string') {
-    throw new TypeError(`${name} must be a string`);
-  }
-
-  if (invalidSlugPathRegex.test(mountUrl)) {
-    throw new SyntaxError(`${name} contains invalid characters`);
-  }
-
-  if (!mountUrl.length || mountUrl[0] !== '/' || mountUrl[mountUrl.length - 1] !== '/') {
-    throw new SyntaxError(`${name} must begin and end with a /`)
-  }
-}
-
-function validateWaypoint(waypoint, { name = 'waypoint', withOrigin = false } = {}) {
-  if (typeof waypoint !== 'string') {
-    throw new TypeError(`${name} must be a string`);
-  }
-
-  const regex = withOrigin ? invalidSlugPathRegex : invalidSlugRegex;
-  if (regex.test(waypoint)) {
-    throw new SyntaxError(`${name} contains invalid characters`);
-  }
-}
-
-module.exports = {
-  validateMountUrl,
-  validateWaypoint,
-};

package/lib/validation/ArrayObjectField.js

@@ -1,49 +0,0 @@
-/**
- * An array of objects field. This is identical to the `typeObjectField`
- * function, but the data against which it is tested is expected to be an array
- * of objects that match the structure of the `obj` defined here.
- *
- * @param {object} obj Object of fields that will be tested.
- * @param {Array} validators Validation rules that must be satisfied.
- * @param {Function | null} condition Condition to meet before validators are run.
- * @returns {object} Validation object suitable for processing.
- * @throws {TypeError} When arguments are invalid.
- */
-module.exports = (obj = {}, validators = [], condition) => {
-  if (Object.prototype.toString.call(obj) !== '[object Object]') {
-    throw new TypeError(`Children object must be an object, got ${typeof Object.prototype.toString.call(obj)}`);
-  }
-
-  validators.forEach((v) => {
-    if (typeof v !== 'function') {
-      throw new TypeError(`Validators must be a function, got ${typeof v}`);
-    }
-  });
-
-  if (typeof condition !== 'undefined' && typeof condition !== 'function') {
-    throw new TypeError(`Conditional must be a function, got ${typeof condition}`);
-  }
-
-  return Object.create(Object.prototype, {
-    type: {
-      writable: false,
-      confirgurable: false,
-      value: 'array_object',
-    },
-    condition: {
-      writable: false,
-      configurable: false,
-      value: condition || (() => true),
-    },
-    validators: {
-      value: validators,
-      writable: false,
-      configurable: false,
-    },
-    children: {
-      value: obj,
-      writable: false,
-      configurable: false,
-    },
-  });
-};

package/lib/validation/ObjectField.js

@@ -1,53 +0,0 @@
-/**
- * An object field. The defined `obj` is an object of fieldName:Field mappings.
- * For example:
- *  {
- *    "contactName": Validation.SimpleField([...]),
- *    "contactDob": Validation.SimpleField([...]),
- *    "contactAddress": Validation.ObjectField(addressObject, [...])}
- *  }
- *
- * @param {object} obj Object of fields that will be tested
- * @param {Array|null} validators Validation rules that must be satisfied
- * @param {Function|null} condition Condition to meet before validators are run
- * @returns {object} Validation object suitable for processing
- * @throws {TypeError} When arguments are invalid
- */
-module.exports = (obj = {}, validators = [], condition) => {
-  if (Object.prototype.toString.call(obj) !== '[object Object]') {
-    throw new TypeError(`Children object must be an object, got ${typeof Object.prototype.toString.call(obj)}`);
-  }
-
-  validators.forEach((v) => {
-    if (typeof v !== 'function') {
-      throw new TypeError(`Validators must be a function, got ${typeof v}`);
-    }
-  });
-
-  if (typeof condition !== 'undefined' && typeof condition !== 'function') {
-    throw new TypeError(`Conditional must be a function, got ${typeof condition}`);
-  }
-
-  return Object.create(Object.prototype, {
-    type: {
-      writable: false,
-      confirgurable: false,
-      value: 'object',
-    },
-    condition: {
-      writable: false,
-      configurable: false,
-      value: condition || (() => true),
-    },
-    validators: {
-      value: validators,
-      writable: false,
-      configurable: false,
-    },
-    children: {
-      value: obj,
-      writable: false,
-      configurable: false,
-    },
-  });
-};

package/lib/validation/SimpleField.d.ts

@@ -1,11 +0,0 @@
-import { ValidatorConditionFunction, ValidatorFunction } from '../../index';
-
-export = SimpleField;
-
-declare function SimpleField (validators: Array<ValidatorFunction | ValidatorFactory>, condition?: ValidatorConditionFunction): SimpleFieldValidatorConfig | never;
-
-interface SimpleFieldValidatorConfig {
-  readonly type: 'simple',
-  readonly condition: ValidatorConditionFunction,
-  readonly validators: Array<ValidatorFunction | ValidatorFactory>,
-}

package/lib/validation/SimpleField.js

@@ -1,46 +0,0 @@
-/* eslint-disable valid-jsdoc */
-const ValidatorFactory = require('./ValidatorFactory.js');
-
-/**
- * A simple field.
- *
- * @param {Array<ValidatorFactory | Function | object>} validators Validation rules to satisfy
- * @param {Function | null} condition Condition to meet before validators are run
- * @returns {SimpleFieldValidatorConfig} Validation object suitable for processing
- * @throws {TypeError} When conditional is not the correct type
- *
- * @typedef { import('../../index').ValidatorConditionFunction } ValidatorConditionFunction
- * @typedef { import('../../index').ValidatorFunction } ValidatorFunction
- *
- * @typedef {object} SimpleFieldValidatorConfig Prepared field validator
- * @property {string} type The type of field validator (always 'simple')
- * @property {ValidatorConditionFunction} condition Condition to run validators
- * @property {Array<ValidatorFunction | ValidatorFactory>} validators List of validators to run
- */
-module.exports = (validators = [], condition) => {
-  // Isolate and validate validate functions
-  const parsedValidators = validators.map(ValidatorFactory.coerceToValidatorObject);
-
-  // Validate condition function, if present
-  if (typeof condition !== 'undefined' && typeof condition !== 'function') {
-    throw new TypeError(`Conditional must be a function, got ${typeof condition}`);
-  }
-
-  return Object.create(Object.prototype, {
-    type: {
-      writable: false,
-      confirgurable: false,
-      value: 'simple',
-    },
-    condition: {
-      writable: false,
-      configurable: false,
-      value: condition || (() => true),
-    },
-    validators: {
-      value: parsedValidators,
-      writable: false,
-      configurable: false,
-    },
-  });
-};

package/lib/validation/ValidationError.d.ts

@@ -1,14 +0,0 @@
-import { ValidationErrorObject, ValidatorErrorObjectGenerator, ValidatorContext } from '../../index';
-
-export = ValidationError;
-
-declare class ValidationError {
-  constructor(errorParam: ValidationErrorObject | string);
-
-  static make(params: {
-    errorMsg: string | ValidationErrorObject | ValidatorErrorObjectGenerator | Error,
-    dataContext?: ValidatorContext
-  }): ValidationError;
-
-  withContext(context: ValidatorContext): ValidationError;
-}

package/lib/validation/ValidationError.js

@@ -1,170 +0,0 @@
-const util = require('../Util.js');
-
-const params = new WeakMap();
-
-class ValidationError {
-  /**
-   * Make a ValidationError instance from a primitive object (or a function that
-   * returns a primitive object) that is specific to the given journey context.
-   *
-   * The returned `error` (or the function that returns the equivalent) must
-   * match the structure required by the ValidationError constructor.
-   *
-   * `errorMsg` can be one of these formats:
-   *   String => 'common:errors.my-error-message'
-   *   Object => (see constructor argument for structure of this object)
-   *   Function => Function returns object suitable for constructor (see example below)
-   *   Error => A JavaScript error. It's `message` will be used as the error.
-   *
-   * `dataContext` is an object containing the same data passed to all validator
-   * functions, and contains:
-   *   waypointId => The current waypoint being requested
-   *   fieldName => Name of the field being validated
-   *   journeyContext => The full JourneyContext of the current request.
-   *
-   * Example function signature that can be used for `errorMsg`:
-   *   ({ waypointId, fieldName, journeyContext }) => ({
-   *     summary: 'my-waypoint:some.key.to.say.hello',
-   *     variables: {
-   *       name: journeyContext.getDataForPage(waypointId).name,
-   *     }
-   *   });
-   *
-   * @param {object} args See args above
-   * @param {any} args.errorMsg Error message to seed the ValidationError
-   * @param {object} args.dataContext Validation context
-   * @returns {object} Primitive error matching structure above
-   * @throws {TypeError} If errorMsg is not in a valid type
-   */
-  static make({ errorMsg, dataContext = {} }) {
-    // Convert strings to the most basic object primitive
-    if (typeof errorMsg === 'string') {
-      return new ValidationError({
-        summary: errorMsg,
-        inline: errorMsg,
-        focusSuffix: [],
-      });
-    }
-
-    // No contextual changes applicable; return ValidationErorr made from the
-    // original object
-    if (Object.prototype.toString.call(errorMsg) === '[object Object]') {
-      return new ValidationError(errorMsg);
-    }
-
-    // Use the user-defined function to generate an error primitive for the
-    // given context
-    if (typeof errorMsg === 'function') {
-      return new ValidationError(errorMsg.call(null, { ...dataContext }));
-    }
-
-    // Core Error
-    if (errorMsg instanceof Error) {
-      return new ValidationError({
-        summary: errorMsg.message,
-        inline: errorMsg.message,
-        focusSuffix: errorMsg.focusSuffix || [],
-      });
-    }
-
-    // Unsupported
-    throw new TypeError('errorMsg must be a string, Error, primitive object or function that generates a primitive object');
-  }
-
-  /**
-   * `error` may be a simple string, in which case that string reppresents the
-   * error mesaage (equivalent to `error.summary` in the structure below).
-   *
-   * `error`, when passed as an object, must match this structure:
-   *
-   * {
-   *   summary: "",         // required
-   *   inline: "",          // optional, may be deprecated in future
-   *   focusSuffix: "",     // optional
-   *   fieldKeySuffix: "",  // optional
-   *   variables: {         // optional
-   *     myVariable: 'a value'
-   *   }
-   * }
-   *
-   * @param {object|string} errorParam See object structure above
-   */
-  constructor(errorParam = {}) {
-    if (Object.prototype.toString.call(errorParam) !== '[object Object]' && typeof errorParam !== 'string') {
-      throw new TypeError('Constructor requires a string or object');
-    }
-    const error = typeof errorParam === 'string' ? { summary: errorParam } : errorParam;
-
-    // Store parameters for later use in applying contexts
-    const originals = {
-      summary: error.summary,
-      // may be deprecated; summary and inline should always match
-      inline: error.inline || error.summary,
-      focusSuffix: error.focusSuffix || [],
-      fieldKeySuffix: error.fieldKeySuffix || undefined,
-      variables: error.variables || {},
-      message: error.summary,
-      field: error.field || undefined,
-      fieldHref: error.fieldHref || undefined,
-      validator: error.validator || undefined,
-    };
-    params.set(this, originals);
-
-    // Duplicate parameters to make them available in public scope. These are
-    // the values that will be readable, and reflect any context that may have
-    // been applied
-    Object.keys(originals).forEach((o) => {
-      Object.defineProperty(this, o, {
-        value: originals[o],
-        enumerable: true,
-        writable: true,
-      });
-    });
-  }
-
-  /**
-   * Modifies the error to reflect the given context.
-   *
-   * `context` is an object containing the following attributes
-   * string waypointId
-   * string fieldName
-   * JourneyContext journeyContext
-   *
-   * @param {object} context See structure above
-   * @returns {ValidationError} Chain
-   */
-  withContext(context) {
-    // Get original constructor parameters
-    const originals = params.get(this);
-
-    // Expand variables
-    if (typeof originals.variables === 'function') {
-      this.variables = originals.variables.call(this, context);
-    }
-
-    // Set field name
-    if (context.fieldName) {
-      let focusSuffix;
-      let fieldHref = `#f-${util.normalizeHtmlObjectPath(context.fieldName)}`;
-      if (originals.fieldKeySuffix) {
-        fieldHref += originals.fieldKeySuffix;
-      } else if (originals.focusSuffix && originals.focusSuffix.length) {
-        focusSuffix = Array.isArray(originals.focusSuffix)
-          ? originals.focusSuffix
-          : [originals.focusSuffix];
-        fieldHref += focusSuffix[0];
-      }
-
-      this.field = util.normalizeHtmlObjectPath(context.fieldName + (originals.fieldKeySuffix || ''));
-      this.fieldHref = fieldHref;
-      this.focusSuffix = focusSuffix || [];
-    }
-
-    // Set validator name
-    this.validator = context.validator || undefined;
-
-    return this;
-  }
-}
-
-module.exports = ValidationError;

package/lib/validation/ValidatorFactory.d.ts

@@ -1,32 +0,0 @@
-import { ValidationErrorObject, ValidatorContext } from '../../index';
-
-export = ValidatorFactory;
-
-declare class ValidatorFactory {
-  public config: config;
-
-  static make(config?: object): {
-    validate: Function,
-    sanitise: Function,
-    config: config,
-  }
-
-  static coerceToValidatorObject(input: ValidatorFactory | Function | any): validatorObject;
-
-  constructor(config?: config);
-
-  validate(fieldValue: any, context: ValidatorContext): Promise<null | ValidationErrorObject>;
-
-  sanitise(fieldValue: any, context: ValidatorContext): any;
-}
-
-type config = {
-  [key: string]: any,
-};
-
-type validatorObject = {
-  name?: string,
-  config?: config,
-  sanitise?: Function,
-  validate?: Function,
-};

package/lib/validation/ValidatorFactory.js

@@ -1,91 +0,0 @@
-/* eslint-disable class-methods-use-this */
-const { isObjectType } = require('../Util.js');
-
-class ValidatorFactory {
-  /**
-   * This is a convenience method that will bind and return this class'
-   * `validate()` function, so you can call it directly rather than calling the
-   * method. i.e.
-   *
-   *  MyValidator.make()('value to validate')
-   *    versus
-   *  (new MyValidator()).validate('value to validate')
-   *
-   * It also attaches the `sanitise()` method as a static property to that
-   * function.
-   *
-   * @param {object} config Validator config
-   * @returns {object} Validator object
-   * @throws {TypeError} When configurarion is invalid.
-   */
-  static make(config = {}) {
-    if (!isObjectType(config)) {
-      throw new TypeError('Configuration must be an object');
-    }
-
-    const validator = Reflect.construct(this, [config]);
-
-    /* eslint-disable-next-line sonarjs/prefer-object-literal */
-    const instance = {};
-    instance.name = validator.name || validator.constructor.name;
-    instance.config = config;
-    instance.validate = validator.validate.bind(instance);
-    instance.sanitise = validator.sanitise.bind(instance);
-
-    Object.freeze(instance);
-
-    return instance;
-  }
-
-  static coerceToValidatorObject(input) {
-    let validator = Object.create(null);
-    validator.validate = () => (Promise.reject(
-      new Error('validate() method has not been defined'),
-    ));
-    validator.sanitise = (val) => (val);
-    validator.config = Object.create(null);
-
-    // An uninstantied Validator subclass
-    if (typeof input === 'function' && Reflect.getPrototypeOf(input) === ValidatorFactory) {
-      validator = input.make();
-    } else if (typeof input === 'function') {
-      // A plain function is assumed to be just the validation logic. We do not
-      // bind the function to `validator` here because it may already be bound to
-      // another context in userland.
-      validator.name = input.name || input.constructor.name || 'unknown';
-      validator.validate = input;
-    } else if (isObjectType(input)) {
-      // A plain object
-      validator = {
-        validate: input.validate || validator.validate,
-        sanitise: input.sanitise || validator.sanitise,
-        config: input.config || validator.config,
-        name: input.name || validator.name,
-      };
-    } else {
-      // An unsupported scenario
-      throw new TypeError(`Cannot coerce input to a validator object (typeof = ${typeof input})`);
-    }
-
-    return validator;
-  }
-
-  constructor(config = {}) {
-    if (new.target === ValidatorFactory) {
-      throw new TypeError('Cannot instantiate the abstract class, ValidatorFactory');
-    }
-    this.config = config;
-  }
-
-  /* eslint-disable-next-line no-unused-vars */
-  validate(fieldValue, context) {
-    throw new Error('validate() method has not been implemented');
-  }
-
-  /* eslint-disable-next-line no-unused-vars */
-  sanitise(fieldValue, context) {
-    return fieldValue;
-  }
-}
-
-module.exports = ValidatorFactory;

package/lib/validation/index.js

@@ -1,22 +0,0 @@
-const SimpleField = require('./SimpleField.js');
-const ObjectField = require('./ObjectField.js');
-const ArrayObjectField = require('./ArrayObjectField.js');
-const ValidationError = require('./ValidationError.js');
-const processor = require('./processor.js');
-const rules = require('./rules/index.js');
-
-module.exports = {
-  // Field type constructors
-  SimpleField,
-  ObjectField,
-  ArrayObjectField,
-
-  // Error classes
-  ValidationError,
-
-  // Core validation processor
-  processor,
-
-  // Core rules
-  rules,
-};

package/lib/validation/processor/flattenErrorArray.js

@@ -1,24 +0,0 @@
-const ValidationError = require('../ValidationError.js');
-
-/**
- * Converts a (potentially) deeply nested array of ValidationErrors into a flat
- * array.
- *
- * @param  {Array<ValidationError>} errorsArray Array of errors.
- * @returns {Array} The flatted array.
- * @throws {TypeError} When error is not a ValidationError
- */
-module.exports = (errorsArray = []) => {
-  let errors = errorsArray;
-  if (!Array.isArray(errorsArray)) {
-    errors = [errorsArray];
-  }
-
-  const flattend = errors.flat(Infinity);
-
-  if (!flattend.every((e) => (e instanceof ValidationError))) {
-    throw new TypeError('All errors must be instances of ValidationError.');
-  }
-
-  return flattend;
-};