@becollective/utils 2.0.13 → 2.0.14

package/lib/src/forms.js

@@ -1,728 +0,0 @@
-"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;