@becollective/utils 1.10.3 → 2.0.1

package/lib/forms.js

@@ -0,0 +1,728 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-prototype-builtins */
+const ajv_1 = __importDefault(require("ajv"));
+const ajv = new ajv_1.default({
+    allErrors: true,
+    verbose: true,
+});
+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) => {
+    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 = [];
+        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 = [];
+        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 = [];
+        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 = [];
+        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 = validator.getValidatorForTypeData(property.bcType || property.type);
+                await v(property, value);
+            }
+            catch (e) {
+                errors.push(e);
+            }
+        }
+        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;