@becollective/utils 1.10.3 → 2.0.1

package/src/forms.ts

@@ -0,0 +1,807 @@
+/* eslint-disable no-prototype-builtins */
+import Ajv from 'ajv';
+const ajv: any = new Ajv({
+  allErrors: true,
+  verbose: true,
+});
+
+type ValidateDataNameError = {
+  name: string;
+  key: string;
+  value: any;
+}
+
+type ValidateDataPropertyError = {
+  property: string;
+  message: string;
+  key: string;
+}
+
+const phoneNumber = require('libphonenumber-js');
+
+const BC_REPORTABLE_FIELDS = {
+  BC_ADDRESS: 'BC_ADDRESS',
+  BC_PHONE: 'BC_PHONE',
+  BC_OWN_VEHICLE: 'BC_OWN_VEHICLE',
+  BC_DRIVERS_LICENCE: 'BC_DRIVERS_LICENCE',
+  BC_WORKING_WITH_CHILDREN: 'BC_WORKING_WITH_CHILDREN',
+  BC_POLICE_CHECK: 'BC_POLICE_CHECK',
+  BC_MEDICAL_CONDITIONS: 'BC_MEDICAL_CONDITIONS',
+  BC_COUNTRY_OF_BIRTH: 'BC_COUNTRY_OF_BIRTH',
+};
+
+const widgetTypes = [
+  'WidgetDate',
+  'WidgetDateRange',
+  'WidgetDropDown',
+  'WidgetHeading',
+  'WidgetSpacer',
+  'WidgetLocation',
+  'WidgetNumber',
+  'WidgetPhone',
+  'WidgetRadio',
+  'WidgetTextArea',
+  'WidgetTextBox',
+  'WidgetTextParagraph',
+  'WidgetTickbox',
+  'WidgetToggle',
+  'WidgetSkillsRequired',
+  'WidgetFile',
+  'WidgetQualifications',
+  'WidgetCountry',
+  'WidgetSocialPrescribing',
+];
+
+const countDecimals = (value) => {
+  if (Math.floor(value) === value) return 0;
+
+  const str = value.toString();
+  // This handles scientific notation on long decimals from toString ie "1e-9"
+  if (str.indexOf('.') !== -1 && str.indexOf('-') !== -1) {
+    return parseInt(str.split('-')[1] || 0);
+  }
+  else if (str.indexOf('.') !== -1) {
+    return parseInt(str.split('.')[1].length || 0);
+  }
+  return parseInt(str.split('-')[1] || 0);
+};
+
+const isValidYear = (value) => {
+  const year = new Date(value).getFullYear();
+  return year < 9999 && year > 999;
+};
+
+const validateType = async (params: { type: string, data: any, schema?: any, error?: string }) => {
+  const { type, data, schema, error } = params;
+  if (validator.dataTypeIsValid[type](data, schema)) {
+    return;
+  }
+  throw {
+    name: error || `Property is not a ${type}`
+  };
+};
+
+const validator = {
+  validateSchema: async (schema, uischema) => {
+    if (!schema.hasOwnProperty('properties')) {
+      throw {
+        name: 'missing-properties'
+      };
+    }
+    else if (!schema.hasOwnProperty('required')) {
+      throw {
+        name: 'missing-required'
+      };
+    }
+
+    let err;
+    let result;
+    const errors: any[] = [];
+    const keys = Object.keys(schema.properties);
+
+    result = validator.validateSchemaPropertiesExist(schema.required, keys, 'required-item-not-found');
+
+    if (result) {
+      throw result;
+    }
+
+    result = validator.validateSchemaPropertiesExist(uischema['ui:order'], keys, 'order-item-not-found');
+    if (result) {
+      throw result;
+    }
+
+    result = validator.validateSchemaPropertiesExist(keys, Object.keys(uischema), 'ui-data-schema-mismatch');
+    if (result) {
+      throw result;
+    }
+
+    result = validator.validatePropertiesTitleUniqueness(schema.properties, 'Titles must be unique.');
+    if (result) {
+      throw result;
+    }
+
+    for await (const item of keys) {
+      const o = schema.properties[item];
+      /*
+        o is each property. eg.
+        {
+          type: 'array',
+          title: 'Where did you hear about us?',
+          items: {
+            type: 'string',
+            enum: [ 'Newspaper', 'Google', 'Word of mouth' ]
+          },
+          uniqueItems: true,
+          bcReportable: 'BC_HOW_DID_YOU_HEAR',
+          bcRequired: false
+        }
+      */
+      const f = validator.getValidatorForType(o.bcType || o.type);
+
+      if (o.hasOwnProperty('bcReportable')) {
+        if (!BC_REPORTABLE_FIELDS[o.bcReportable] && !o.bcReportable.startsWith('USER_')) {
+          errors.push({
+            name: 'invalid-reportable-field',
+            object: o,
+          });
+        }
+      }
+
+      if (f) {
+        const valid = ajv.validate(f, o);
+        if (valid !== true) {
+          const errorMsgs = ajv.errors.map(({ instancePath, message }) => {
+            let property = instancePath.replace(/\//g, '.');
+            if (property.charAt(0) === '.') {
+              property = property.slice(1, property.length);
+            }
+            return {
+              key: item,
+              property,
+              message,
+            };
+          });
+          errors.push(...errorMsgs);
+        }
+        continue;
+      }
+      else {
+        errors.push({ name: 'invalid-schema-type', object: o });
+        continue;
+      }
+    }
+
+    if (errors.length) {
+      throw errors;
+    }
+
+    Object.keys(uischema).map((o) => {
+      if (o === 'ui:order') {
+        return;
+      }
+
+      const data = uischema[o];
+      const valid = ajv.validate(validator.uiSchema, data);
+      if (valid !== true) {
+        errors.push({ name: 'invalid-uischema-property', object: o });
+      }
+    });
+
+    if (errors.length) {
+      throw errors;
+    }
+
+    return true;
+  },
+
+  validateSchemaPropertiesExist: (properties, keys, err) => {
+    const errors: (ValidateDataNameError | ValidateDataPropertyError)[] = [];
+
+    for (const i in properties) {
+      if (keys.indexOf(properties[i]) === -1) {
+        errors.push({
+          name: err,
+          key: i,
+          value: properties[i],
+        });
+      }
+    }
+
+    if (errors.length) {
+      return errors;
+    }
+
+    return null;
+  },
+
+  /**
+   * Check if every field in the form has a unique title
+   * @param {object} properties fields properties
+   * @param {string} err error name
+   */
+  validatePropertiesTitleUniqueness: (properties, err) => {
+    const errors: (ValidateDataNameError | ValidateDataPropertyError)[] = [];
+    const titleCounts = {};
+    for (const key in properties) {
+      // "spacer" and "textParagraph" are special fields whose title is fixed and
+      // doesn't show in UI, hence no unique check required for them
+      if (
+        properties[key].bcType &&
+        (properties[key].bcType === 'spacer' || properties[key].bcType === 'textParagraph')
+      ) {
+        continue;
+      }
+      const title = properties[key].title.trim().toLowerCase();
+      titleCounts[title] = titleCounts[title] ? [...titleCounts[title], key] : [key];
+    }
+    for (const title in titleCounts) {
+      if (titleCounts[title].length > 1) {
+        titleCounts[title].forEach((key) => {
+          errors.push({
+            key,
+            property: key,
+            message: err,
+          });
+        });
+      }
+    }
+    if (errors.length) {
+      return errors;
+    }
+    return null;
+  },
+
+  /**
+   * Creates a new object from the input obj.
+   * All entries from the input whose values are empty arrays are missing in the new object
+   * @param {Object} data 1-depth obj
+   * @returns A new object without empty arrays
+   */
+  stripEmptyArraysFromData: (data) => {
+    const strippedObject = {};
+    Object.keys(data).forEach((k) => {
+      if (!(Array.isArray(data[k]) && data[k].length === 0)) strippedObject[k] = data[k];
+    });
+    return strippedObject;
+  },
+
+  validateData: async (schema, data) => {
+    // data is the user submitted form data.
+    const keys = Object.keys(data);
+    const properties = Object.keys(schema.properties);
+    const errors: (ValidateDataNameError | ValidateDataPropertyError)[] = [];
+
+    keys.map((o) => {
+      const found = false;
+      if (properties.indexOf(o) === -1) {
+        errors.push({
+          name: 'properties-not-found',
+          key: o,
+          value: data[o],
+        });
+      }
+    });
+
+    schema.required.map((o) => {
+      const isFileType = schema.properties[o].bcType === 'file';
+
+      if (keys.indexOf(o) === -1 && !isFileType) {
+        errors.push({
+          name: 'required-data-not-found',
+          key: o,
+          value: data[o],
+        });
+      }
+    });
+
+    if (errors.length) {
+      throw errors;
+    }
+
+    for await (const item of properties) {
+      if (!data.hasOwnProperty(item)) {
+        continue;
+      }
+
+      // property is the schema property.
+      // eg. { title: 'Phone Number', type: 'string', bcType: 'phone' };
+      const property = schema.properties[item];
+      const value = data[item];
+      // value is the data the user submits for the above property
+      // eg. +61434111222
+
+      try {
+        const v: Function = validator.getValidatorForTypeData(property.bcType || property.type) as Function;
+        await v(property, value);
+      }
+      catch(e) {
+        errors.push(e as unknown as any);
+      }
+    }
+
+    if (errors.length) {
+      throw(errors);
+    }
+
+    return;
+  },
+
+  getValidatorForType: (type) => {
+    return validator.schemaTypes[type] || null;
+  },
+
+  getValidatorForTypeData: (type) => {
+    const v = validator.dataTypes[type];
+    if(v) {
+        return v;
+    }
+    throw {
+      name: 'Datatype not found',
+    };
+  },
+
+  uiSchema: {
+    type: 'object',
+    required: ['ui:title', 'ui:widget'],
+    properties: {
+      'ui:title': {
+        type: 'string',
+      },
+      'ui:helpertext': {
+        type: 'string',
+      },
+      'ui:bc-helpertext': {
+        type: 'string',
+      },
+      'ui:bc-required': {
+        type: 'boolean',
+      },
+      'ui:bc-multiSelect': {
+        type: 'boolean',
+      },
+      'ui:widget': {
+        type: 'string',
+        enum: widgetTypes,
+      },
+    },
+  },
+
+  schemaTypes: {
+    string: {
+      type: 'object',
+      required: ['title'],
+      properties: {
+        title: {
+          type: 'string',
+          minLength: 1,
+        },
+      },
+    },
+    number: {
+      type: 'object',
+      required: ['title'],
+      properties: {
+        title: {
+          type: 'string',
+          minLength: 1,
+        },
+      },
+    },
+    boolean: {
+      type: 'object',
+      required: ['title'],
+      properties: {
+        title: {
+          type: 'string',
+          minLength: 1,
+        },
+      },
+    },
+    date: {
+      type: 'object',
+      required: ['title'],
+      properties: {
+        title: {
+          type: 'string',
+          minLength: 1,
+        },
+        type: {
+          const: 'string',
+        },
+      },
+    },
+    dateRange: {
+      type: 'object',
+      required: ['title'],
+      properties: {
+        title: {
+          type: 'string',
+          minLength: 1,
+        },
+        type: {
+          const: 'object',
+        },
+      },
+    },
+    phone: {
+      type: 'object',
+      required: ['title'],
+      properties: {
+        title: {
+          type: 'string',
+          minLength: 1,
+        },
+        type: {
+          const: 'string',
+        },
+      },
+    },
+    skills: {
+      type: 'object',
+      required: ['title'],
+      properties: {
+        title: {
+          type: 'string',
+          minLength: 1,
+        },
+        uniqueItems: {
+          type: 'boolean',
+        },
+        items: {
+          type: 'object',
+          properties: {
+            anyOf: {
+              type: 'array',
+              minItems: 1,
+              items: {
+                type: 'object',
+                properties: {
+                  type: { type: 'string' },
+                  title: { type: 'string' },
+                  enum: {
+                    type: 'array',
+                    minItems: 1,
+                    items: {
+                      type: 'string',
+                      minLength: 1,
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+    qualifications: {
+      type: 'object',
+      required: ['title'],
+      properties: {
+        title: {
+          type: 'string',
+          minLength: 1,
+        },
+        uniqueItems: {
+          type: 'boolean',
+        },
+        items: {
+          type: 'object',
+          properties: {
+            type: {
+              const: 'string',
+            },
+            enum: {
+              type: 'array',
+              minItems: 1,
+              items: [{ type: 'string' }],
+            },
+          },
+        },
+      },
+    },
+    array: {
+      type: 'object',
+      required: ['title'],
+      properties: {
+        title: {
+          type: 'string',
+          minLength: 1,
+        },
+        uniqueItems: {
+          type: 'boolean',
+        },
+        items: {
+          type: 'object',
+          properties: {
+            anyOf: {
+              type: 'array',
+              minItems: 1,
+              uniqueItems: true,
+              items: {
+                type: 'object',
+                properties: {
+                  type: { type: 'string' },
+                  title: { type: 'string' },
+                  enum: {
+                    type: 'array',
+                    minItems: 1,
+                    items: {
+                      type: 'string',
+                      minLength: 1,
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+    heading: {
+      type: 'object',
+      required: ['title'],
+      properties: {
+        title: {
+          type: 'string',
+          minLength: 1,
+        },
+        type: {
+          const: 'string',
+        },
+      },
+    },
+    spacer: {
+      type: 'object',
+      properties: {
+        type: {
+          const: 'string',
+        },
+      },
+    },
+    location: {
+      type: 'object',
+      required: ['title'],
+      properties: {
+        title: {
+          type: 'string',
+          minLength: 1,
+        },
+        type: {
+          const: 'object',
+        },
+      },
+    },
+    file: {
+      type: 'object',
+      required: ['title'],
+      properties: {
+        title: {
+          type: 'string',
+          minLength: 1,
+        },
+      },
+    },
+    textParagraph: {
+      type: 'object',
+      required: ['text'],
+      properties: {
+        text: {
+          type: 'string',
+          minLength: 1,
+        },
+      },
+    },
+  },
+
+  // NOTE: schema below is not the whole schema but the individual property
+  // eg. { title: 'Phone Number', type: 'string', bcType: 'phone' };
+  dataTypeIsValid: {
+    string: (data, schema) => {
+      const isString =
+        schema && schema.required ? !!(typeof data === 'string' && data.length) : !!(typeof data === 'string');
+      if (schema && schema.items && schema.items.enum) {
+        return isString && schema.items.enum.includes(data);
+      }
+
+      return isString;
+    },
+    boolean: (data) => {
+      return data === true || data === false;
+    },
+    number: (data) => {
+      return typeof data === 'number' && countDecimals(data) <= 10;
+    },
+    // date and dateRange must be ISOString format
+    date: (data) => {
+      return typeof data === 'string' && new Date(data).toString() !== 'Invalid Date' && isValidYear(data);
+    },
+    dateRange: (data) => {
+      const fromIsValid = validator.dataTypeIsValid.date(data.from);
+      const toIsValid = validator.dataTypeIsValid.date(data.to);
+      const toDateIsAFterFromDate = new Date(data.from) <= new Date(data.to);
+
+      return fromIsValid && toIsValid && toDateIsAFterFromDate;
+    },
+    phone: (data) => {
+      return phoneNumber.isValidNumber(data || '');
+    },
+    skills: (data, schema) => {
+      if (!schema || !schema.items) return false;
+
+      let hasAnyOf = false;
+      try {
+        hasAnyOf =
+          ajv.validate(
+            {
+              type: 'array',
+              items: schema.items.anyOf,
+              minItems: 1,
+            },
+            data
+          ) === true;
+      }
+      catch (e) {}
+      return hasAnyOf;
+    },
+    qualifications: (data, schema) => {
+      if (!schema || !schema.items) return false;
+
+      return (
+        ajv.validate(
+          {
+            type: 'array',
+            items: schema.items,
+            minItems: 1,
+          },
+          data
+        ) === true
+      );
+    },
+    array: (data, schema) => {
+      if (!schema || !schema.items) return false;
+      let hasAnyOf = false;
+      let hasItems = false;
+      try {
+        hasAnyOf =
+          ajv.validate(
+            {
+              type: 'array',
+              items: schema.items.anyOf,
+              minItems: 1,
+            },
+            data
+          ) === true;
+
+        hasItems =
+          ajv.validate(
+            {
+              type: 'array',
+              items: schema.items,
+              minItems: 1,
+            },
+            data
+          ) === true;
+      }
+      catch (e) {}
+
+      return hasItems || hasAnyOf;
+    },
+    heading: () => true,
+    spacer: () => true,
+    location: (data) => {
+      const s = {
+        type: 'object',
+        required: ['geo'],
+        properties: {
+          geo: {
+            type: 'object',
+            required: ['lat', 'lng'],
+            properties: {
+              lat: {
+                type: 'number',
+                minimum: -90,
+                maximum: 90,
+              },
+              lng: {
+                type: 'number',
+                minimum: -180,
+                maximum: 180,
+              },
+            },
+          },
+          locality: {
+            type: 'object',
+            properties: {
+              long: {
+                type: 'string',
+              },
+              short: {
+                type: 'string',
+              },
+            },
+          },
+          region: {
+            type: 'object',
+            properties: {
+              long: {
+                type: 'string',
+              },
+              short: {
+                type: 'string',
+              },
+            },
+          },
+          country: {
+            type: 'object',
+            properties: {
+              long: {
+                type: 'string',
+              },
+              short: {
+                type: 'string',
+              },
+            },
+          },
+        },
+      };
+
+      if (ajv.validate(s, data) === true) {
+        return true;
+      }
+
+      return false;
+    },
+    file: (data) => {
+      if (data === null || typeof data.name === 'string') {
+        return true;
+      }
+
+      const s = {
+        type: 'object',
+        required: ['opportunityId', 'volunteerId', 'filename'],
+        properties: {
+          opportunityId: {
+            type: 'string',
+            pattern: '[a-z0-9]{24}',
+          },
+          volunteerId: {
+            type: 'string',
+            pattern: '[a-z0-9]{24}',
+          },
+          filename: {
+            type: 'string',
+          },
+        },
+      };
+
+      if (ajv.validate(s, data) === true) {
+        return true;
+      }
+
+      return false;
+    },
+  },
+
+  dataTypes: {
+    string: (schema, data) => validateType({ type: 'string', data, schema }),
+    boolean: (schema, data) => validateType({ type: 'boolean', data }),
+    date: (schema, data) => validateType({ type: 'date', data }),
+    dateRange: (schema, data) => validateType({ type: 'dateRange', error: 'Property is not a date range', data }),
+    phone: (schema, data) => validateType({ type: 'phone', error: 'Property is not a phone number', data }),
+    skills: (schema, data) =>
+      validateType({ type: 'skills', error: 'Property is not valid list of skills', data, schema }),
+    qualifications: (schema, data) =>
+      validateType({ type: 'qualifications', error: 'Property is not valid list of qualifications', data, schema }),
+    array: (schema, data) =>
+      validateType({ type: 'array', error: 'Datatype is not an array of strings', data, schema }),
+    heading: (schema, data) => validateType({ type: 'heading', data }),
+    spacer: (schema, data) => validateType({ type: 'spacer', data: null }),
+    location: (schema, data) =>
+      validateType({ type: 'location', error: 'Datatype is not valid location object', data }),
+    file: (schema, data) => validateType({ type: 'file', error: 'File must not be set', data }),
+    number: (schema, data) => validateType({ type: 'number', error: 'Property is not a number', data }),
+    textParagraph: (schema, data) => validateType({ type: 'string', data, schema }),
+  },
+};
+
+module.exports = validator;