@depup/joi 18.1.1-depup.0

package/lib/types/alternatives.js

@@ -0,0 +1,430 @@
+'use strict';
+
+const { assert, merge } = require('@hapi/hoek');
+
+const Any = require('./any');
+const Common = require('../common');
+const Compile = require('../compile');
+const Errors = require('../errors');
+const Ref = require('../ref');
+
+
+const internals = {};
+
+
+module.exports = Any.extend({
+
+    type: 'alternatives',
+
+    flags: {
+
+        match: { default: 'any' }                 // 'any', 'one', 'all'
+    },
+
+    terms: {
+
+        matches: { init: [], register: Ref.toSibling }
+    },
+
+    args(schema, ...schemas) {
+
+        if (schemas.length === 1) {
+            if (Array.isArray(schemas[0])) {
+                return schema.try(...schemas[0]);
+            }
+        }
+
+        return schema.try(...schemas);
+    },
+
+    validate(value, helpers) {
+
+        const { schema, error, state, prefs } = helpers;
+
+        // Match all or one
+
+        if (schema._flags.match) {
+            const matched = [];
+            const failed = [];
+
+            for (let i = 0; i < schema.$_terms.matches.length; ++i) {
+                const item = schema.$_terms.matches[i];
+                const localState = state.nest(item.schema, `match.${i}`);
+                localState.snapshot();
+
+                const result = item.schema.$_validate(value, localState, prefs);
+                if (!result.errors) {
+                    matched.push(result.value);
+                    localState.commit();
+                }
+                else {
+                    failed.push(result.errors);
+                    localState.restore();
+                }
+            }
+
+            if (matched.length === 0) {
+                const context = {
+                    details: failed.map((f) => Errors.details(f, { override: false }))
+                };
+
+                return { errors: error('alternatives.any', context) };
+            }
+
+            // Match one
+
+            if (schema._flags.match === 'one') {
+                return matched.length === 1 ? { value: matched[0] } : { errors: error('alternatives.one') };
+            }
+
+            // Match all
+
+            if (matched.length !== schema.$_terms.matches.length) {
+                const context = {
+                    details: failed.map((f) => Errors.details(f, { override: false }))
+                };
+
+                return { errors: error('alternatives.all', context) };
+            }
+
+            const isAnyObj = (alternative) => {
+
+                return alternative.$_terms.matches.some((v) => {
+
+                    return v.schema.type === 'object' ||
+                        (v.schema.type === 'alternatives' && isAnyObj(v.schema));
+                });
+            };
+
+            return isAnyObj(schema) ? { value: matched.reduce((acc, v) => merge(acc, v, { mergeArrays: false })) } : { value: matched[matched.length - 1] };
+        }
+
+        // Match any
+
+        const errors = [];
+        for (let i = 0; i < schema.$_terms.matches.length; ++i) {
+            const item = schema.$_terms.matches[i];
+
+            // Try
+
+            if (item.schema) {
+                const localState = state.nest(item.schema, `match.${i}`);
+                localState.snapshot();
+
+                const result = item.schema.$_validate(value, localState, prefs);
+                if (!result.errors) {
+                    localState.commit();
+                    return result;
+                }
+
+                localState.restore();
+                errors.push({ schema: item.schema, reports: result.errors });
+                continue;
+            }
+
+            // Conditional
+
+            const input = item.ref ? item.ref.resolve(value, state, prefs) : value;
+            const tests = item.is ? [item] : item.switch;
+
+            for (let j = 0; j < tests.length; ++j) {
+                const test = tests[j];
+                const { is, then, otherwise } = test;
+
+                const id = `match.${i}${item.switch ? '.' + j : ''}`;
+                if (!is.$_match(input, state.nest(is, `${id}.is`), prefs)) {
+                    if (otherwise) {
+                        return otherwise.$_validate(value, state.nest(otherwise, `${id}.otherwise`), prefs);
+                    }
+                }
+                else if (then) {
+                    return then.$_validate(value, state.nest(then, `${id}.then`), prefs);
+                }
+            }
+        }
+
+        return internals.errors(errors, helpers);
+    },
+
+    jsonSchema(schema, res, mode, options) {
+
+        const matches = [];
+
+        // Collect all alternative schemas from 'matches' term
+
+        for (const match of schema.$_terms.matches) {
+            if (match.schema) {
+                matches.push(match.schema.$_jsonSchema(mode, options));
+            }
+            else {
+                // Handle conditional matches (when/switch)
+
+                const tests = match.is ? [match] : match.switch;
+                for (const test of tests) {
+                    if (test.then) {
+                        matches.push(test.then.$_jsonSchema(mode, options));
+                    }
+
+                    if (test.otherwise) {
+                        matches.push(test.otherwise.$_jsonSchema(mode, options));
+                    }
+                }
+            }
+        }
+
+        if (matches.length) {
+            delete res.type;
+
+            // Map alternatives to 'anyOf' or 'oneOf' based on the match flag
+
+            const matchMode = schema._flags.match ?? 'any';
+            if (matchMode === 'one') {
+                res.oneOf = matches;
+            }
+            else {
+                res.anyOf = matches;
+            }
+        }
+
+        return res;
+    },
+
+    rules: {
+
+        conditional: {
+            method(condition, options) {
+
+                assert(!this._flags._endedSwitch, 'Unreachable condition');
+                assert(!this._flags.match, 'Cannot combine match mode', this._flags.match, 'with conditional rule');
+                assert(options.break === undefined, 'Cannot use break option with alternatives conditional');
+
+                const obj = this.clone();
+
+                const match = Compile.when(obj, condition, options);
+                const conditions = match.is ? [match] : match.switch;
+                for (const item of conditions) {
+                    if (item.then &&
+                        item.otherwise) {
+
+                        obj.$_setFlag('_endedSwitch', true, { clone: false });
+                        break;
+                    }
+                }
+
+                obj.$_terms.matches.push(match);
+                return obj.$_mutateRebuild();
+            }
+        },
+
+        match: {
+            method(mode) {
+
+                assert(['any', 'one', 'all'].includes(mode), 'Invalid alternatives match mode', mode);
+
+                if (mode !== 'any') {
+                    for (const match of this.$_terms.matches) {
+                        assert(match.schema, 'Cannot combine match mode', mode, 'with conditional rules');
+                    }
+                }
+
+                return this.$_setFlag('match', mode);
+            }
+        },
+
+        try: {
+            method(...schemas) {
+
+                assert(schemas.length, 'Missing alternative schemas');
+                Common.verifyFlat(schemas, 'try');
+
+                assert(!this._flags._endedSwitch, 'Unreachable condition');
+
+                const obj = this.clone();
+                for (const schema of schemas) {
+                    obj.$_terms.matches.push({ schema: obj.$_compile(schema) });
+                }
+
+                return obj.$_mutateRebuild();
+            }
+        }
+    },
+
+    overrides: {
+
+        label(name) {
+
+            const obj = this.$_parent('label', name);
+            const each = (item, source) => {
+
+                return source.path[0] !== 'is' && typeof item._flags.label !== 'string' ? item.label(name) : undefined;
+            };
+
+            return obj.$_modify({ each, ref: false });
+        },
+
+        isAsync() {
+
+            if (this.$_terms.externals?.length) {
+                return true;
+            }
+
+            for (const match of this.$_terms.matches) {
+
+                if (match.schema?.isAsync()) {
+                    return true;
+                }
+
+                if (match.then?.isAsync()) {
+                    return true;
+                }
+
+                if (match.otherwise?.isAsync()) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    },
+
+    rebuild(schema) {
+
+        // Flag when an alternative type is an array
+
+        const each = (item) => {
+
+            if (Common.isSchema(item) &&
+                item.type === 'array') {
+
+                schema.$_setFlag('_arrayItems', true, { clone: false });
+            }
+        };
+
+        schema.$_modify({ each });
+    },
+
+    manifest: {
+
+        build(obj, desc) {
+
+            if (desc.matches) {
+                for (const match of desc.matches) {
+                    const { schema, ref, is, not, then, otherwise } = match;
+                    if (schema) {
+                        obj = obj.try(schema);
+                    }
+                    else if (ref) {
+                        obj = obj.conditional(ref, { is, then, not, otherwise, switch: match.switch });
+                    }
+                    else {
+                        obj = obj.conditional(is, { then, otherwise });
+                    }
+                }
+            }
+
+            return obj;
+        }
+    },
+
+    messages: {
+        'alternatives.all': '{{#label}} does not match all of the required types',
+        'alternatives.any': '{{#label}} does not match any of the allowed types',
+        'alternatives.match': '{{#label}} does not match any of the allowed types',
+        'alternatives.one': '{{#label}} matches more than one allowed type',
+        'alternatives.types': '{{#label}} must be one of {{#types}}'
+    }
+});
+
+
+// Helpers
+
+internals.errors = function (failures, { error, state }) {
+
+    // Nothing matched due to type criteria rules
+
+    if (!failures.length) {
+        return { errors: error('alternatives.any') };
+    }
+
+    // Single error
+
+    if (failures.length === 1) {
+        return { errors: failures[0].reports };
+    }
+
+    // Analyze reasons
+
+    const valids = new Set();
+    const complex = [];
+
+    for (const { reports, schema } of failures) {
+
+        // Multiple errors (!abortEarly)
+
+        if (reports.length > 1) {
+            return internals.unmatched(failures, error);
+        }
+
+        // Custom error
+
+        const report = reports[0];
+        if (report instanceof Errors.Report === false) {
+            return internals.unmatched(failures, error);
+        }
+
+        // Internal object or array error
+
+        if (report.state.path.length !== state.path.length) {
+            complex.push({ type: schema.type, report });
+            continue;
+        }
+
+        // Valids
+
+        if (report.code === 'any.only') {
+            for (const valid of report.local.valids) {
+                valids.add(valid);
+            }
+
+            continue;
+        }
+
+        // Base type
+
+        const [type, code] = report.code.split('.');
+        if (code !== 'base') {
+            complex.push({ type: schema.type, report });
+        }
+        else if (report.code === 'object.base') {
+            valids.add(report.local.type);
+        }
+        else {
+            valids.add(type);
+        }
+    }
+
+    // All errors are base types or valids
+
+    if (!complex.length) {
+        return { errors: error('alternatives.types', { types: [...valids] }) };
+    }
+
+    // Single complex error
+
+    if (complex.length === 1) {
+        return { errors: complex[0].report };
+    }
+
+    return internals.unmatched(failures, error);
+};
+
+
+internals.unmatched = function (failures, error) {
+
+    const errors = [];
+    for (const failure of failures) {
+        errors.push(...failure.reports);
+    }
+
+    return { errors: error('alternatives.match', Errors.details(errors, { override: false })) };
+};

package/lib/types/any.js

@@ -0,0 +1,174 @@
+'use strict';
+
+const { assert } = require('@hapi/hoek');
+
+const Base = require('../base');
+const Common = require('../common');
+const Messages = require('../messages');
+
+
+const internals = {};
+
+
+module.exports = Base.extend({
+
+    type: 'any',
+
+    flags: {
+
+        only: { default: false }
+    },
+
+    terms: {
+
+        alterations: { init: null },
+        examples: { init: null },
+        externals: { init: null },
+        metas: { init: [] },
+        notes: { init: [] },
+        shared: { init: null },
+        tags: { init: [] },
+        whens: { init: null }
+    },
+
+    rules: {
+
+        custom: {
+            method(method, description) {
+
+                assert(typeof method === 'function', 'Method must be a function');
+                assert(description === undefined || description && typeof description === 'string', 'Description must be a non-empty string');
+
+                return this.$_addRule({ name: 'custom', args: { method, description } });
+            },
+            validate(value, helpers, { method }) {
+
+                try {
+                    return method(value, helpers);
+                }
+                catch (err) {
+                    return helpers.error('any.custom', { error: err });
+                }
+            },
+            args: ['method', 'description'],
+            multi: true
+        },
+
+        messages: {
+            method(messages) {
+
+                return this.prefs({ messages });
+            }
+        },
+
+        shared: {
+            method(schema) {
+
+                assert(Common.isSchema(schema) && schema._flags.id, 'Schema must be a schema with an id');
+
+                const obj = this.clone();
+                obj.$_terms.shared = obj.$_terms.shared || [];
+                obj.$_terms.shared.push(schema);
+                obj.$_mutateRegister(schema);
+                return obj;
+            }
+        },
+
+        warning: {
+            method(code, local) {
+
+                assert(code && typeof code === 'string', 'Invalid warning code');
+
+                return this.$_addRule({ name: 'warning', args: { code, local }, warn: true });
+            },
+            validate(value, helpers, { code, local }) {
+
+                return helpers.error(code, local);
+            },
+            args: ['code', 'local'],
+            multi: true
+        }
+    },
+
+    modifiers: {
+
+        keep(rule, enabled = true) {
+
+            rule.keep = enabled;
+        },
+
+        message(rule, message) {
+
+            rule.message = Messages.compile(message);
+        },
+
+        warn(rule, enabled = true) {
+
+            rule.warn = enabled;
+        }
+    },
+
+    manifest: {
+
+        build(obj, desc) {
+
+            for (const key in desc) {
+                const values = desc[key];
+
+                if (['examples', 'externals', 'metas', 'notes', 'tags'].includes(key)) {
+                    for (const value of values) {
+                        obj = obj[key.slice(0, -1)](value);
+                    }
+
+                    continue;
+                }
+
+                if (key === 'alterations') {
+                    const alter = {};
+                    for (const { target, adjuster } of values) {
+                        alter[target] = adjuster;
+                    }
+
+                    obj = obj.alter(alter);
+                    continue;
+                }
+
+                if (key === 'whens') {
+                    for (const value of values) {
+                        const { ref, is, not, then, otherwise, concat } = value;
+                        if (concat) {
+                            obj = obj.concat(concat);
+                        }
+                        else if (ref) {
+                            obj = obj.when(ref, { is, not, then, otherwise, switch: value.switch, break: value.break });
+                        }
+                        else {
+                            obj = obj.when(is, { then, otherwise, break: value.break });
+                        }
+                    }
+
+                    continue;
+                }
+
+                if (key === 'shared') {
+                    for (const value of values) {
+                        obj = obj.shared(value);
+                    }
+                }
+            }
+
+            return obj;
+        }
+    },
+
+    messages: {
+        'any.custom': '{{#label}} failed custom validation because {{#error.message}}',
+        'any.default': '{{#label}} threw an error when running default method',
+        'any.failover': '{{#label}} threw an error when running failover method',
+        'any.invalid': '{{#label}} contains an invalid value',
+        'any.only': '{{#label}} must be {if(#valids.length == 1, "", "one of ")}{{#valids}}',
+        'any.ref': '{{#label}} {{#arg}} references {{:#ref}} which {{#reason}}',
+        'any.required': '{{#label}} is required',
+        'any.unknown': '{{#label}} is not allowed'
+    }
+});