joi 18.0.2 → 18.1.0

package/lib/base.js

@@ -16,7 +16,12 @@ const Validator = require('./validator');
 const Values = require('./values');
 
 
-const internals = {};
+const internals = {
+    standardTypes: new Set(['string', 'number', 'integer', 'boolean', 'object', 'array', 'null']),
+    jsonSchemaTarget: 'draft-2020-12',
+    primitiveTypes: new Set(['string', 'number', 'boolean']),
+    nullSchema: () => ({ type: 'null' })
+};
 
 
 internals.Base = class {
@@ -62,6 +67,168 @@ internals.Base = class {
         return Manifest.describe(this);
     }
 
+    $_jsonSchema(mode, options = {}) {
+
+        if (options.target !== undefined &&
+            options.target !== internals.jsonSchemaTarget) {
+
+            throw new Error(`Unsupported JSON Schema target: ${options.target}`);
+        }
+
+        const rootCall = !options.$defs;
+        const defs = options.$defs ?? {};
+
+        let schema = {};
+
+        const isTypeAny = this.type === 'any';
+        const isOnly = this._flags.only;
+
+        const valids = this._valids && Array.from(this._valids._values).filter((v) => v !== null);
+        let typesOverlap = true;
+
+        // If 'only' is set, check if the allowed values' types overlap with the schema type
+
+        if (valids && valids.length && isOnly && !isTypeAny) {
+            const types = new Set(valids.map((v) => typeof v));
+            typesOverlap = types.has(this.type) || (this.type === 'date' && types.has('object'));
+        }
+
+        // Set the JSON Schema 'type' if it's a standard type and there's an overlap
+
+        if (!isTypeAny && typesOverlap && internals.standardTypes.has(this.type)) {
+            schema.type = this.type;
+        }
+
+        if (this._flags.description) {
+            schema.description = this._flags.description;
+        }
+
+        if (this._flags.default !== undefined && typeof this._flags.default !== 'function') {
+            schema.default = this._flags.default;
+        }
+
+        // Apply type-specific JSON Schema conversion
+
+        const subOptions = { ...options, $defs: defs };
+        if (this._definition.jsonSchema && typesOverlap) {
+            schema = this._definition.jsonSchema(this, schema, mode, subOptions);
+        }
+
+        // Apply rule-specific JSON Schema conversions
+
+        for (const rule of this._rules) {
+            const definition = this._definition.rules[rule.name];
+            if (definition.jsonSchema && typesOverlap) {
+                schema = definition.jsonSchema(rule, schema, isOnly, mode, subOptions);
+            }
+        }
+
+        // Handle shared schemas
+
+        if (this.$_terms.shared) {
+            for (const shared of this.$_terms.shared) {
+                defs[shared._flags.id] = shared.$_jsonSchema(mode, subOptions);
+            }
+        }
+
+        if (rootCall && Object.keys(defs).length) {
+            schema.$defs = defs;
+        }
+
+        // Handle allowed values (valids)
+
+        if (this._valids) {
+
+            const values = valids.filter((v) => typeof v !== 'symbol');
+            if (values.length) {
+                if (this._flags.only) {
+                    schema.enum = values;
+
+                    const list = Common.intersect(new Set(values.map((v) => typeof v)), internals.primitiveTypes);
+
+                    if (list.size) {
+                        const types = [...list];
+                        schema.type = types.length === 1 ? types[0] : types;
+                    }
+                }
+                else {
+                    // If values are allowed but not exclusive, add them via 'anyOf' if they differ from the main type
+
+                    const otherTypes = values.filter((v) => typeof v !== this.type || isTypeAny);
+                    if (otherTypes.length && !(isTypeAny && !isOnly)) {
+                        if (!schema.anyOf) {
+                            schema = {
+                                anyOf: [schema]
+                            };
+                        }
+
+                        schema.anyOf.push({ enum: otherTypes });
+                    }
+                }
+            }
+        }
+
+        // Handle 'null' if it's an allowed value
+
+        if (this._valids && this._valids.has(null) && !(isTypeAny && !isOnly)) {
+            if (this._valids.length === 1 && (isTypeAny || isOnly)) {
+                schema.type = 'null';
+            }
+            else if (schema.type) {
+                schema.type = [schema.type, 'null'];
+            }
+            else if (schema.anyOf) {
+                schema.anyOf.unshift(internals.nullSchema());
+            }
+            else {
+                schema = {
+                    anyOf: [
+                        internals.nullSchema(),
+                        schema
+                    ]
+                };
+            }
+        }
+
+        // Handle conditionals (whens) by generating multiple possible schemas combined with 'anyOf'
+
+        if (this.$_terms.whens) {
+
+            const base = this.clone();
+            base.$_terms.whens = null;
+
+            const matches = [];
+            for (const when of this.$_terms.whens) {
+                const tests = when.is ? [when] : when.switch;
+                for (let i = 0; i < tests.length; ++i) {
+                    const test = tests[i];
+                    if (test.then) {
+                        matches.push(base.concat(test.then).$_jsonSchema(mode, subOptions));
+                    }
+
+                    if (test.otherwise) {
+                        matches.push(base.concat(test.otherwise).$_jsonSchema(mode, subOptions));
+                    }
+
+                    if (!test.then || (i === tests.length - 1 && !test.otherwise)) {
+                        matches.push(base.$_jsonSchema(mode, subOptions));
+                    }
+                }
+            }
+
+            const results = [];
+            for (const match of matches) {
+                if (!results.some((r) => deepEqual(r, match))) {
+                    results.push(match);
+                }
+            }
+
+            return { anyOf: results };
+        }
+
+        return schema;
+    }
+
     // Rules
 
     allow(...values) {
@@ -1116,6 +1283,10 @@ internals.Base = class {
                 }
 
                 return mapToStandardError(result.error);
+            },
+            jsonSchema: {
+                input: (options) => this.$_jsonSchema('input', options),
+                output: (options) => this.$_jsonSchema('output', options)
             }
         };
     }

package/lib/common.js

@@ -99,6 +99,25 @@ exports.default = function (value, defaultValue) {
 };
 
 
+exports.intersect = function (set, other) {
+
+    /* $lab:coverage:off$ */
+    if (typeof set.intersection === 'function') {
+        return set.intersection(other);
+    }
+
+    const result = new Set();
+    for (const item of set) {
+        if (other.has(item)) {
+            result.add(item);
+        }
+    }
+
+    return result;
+    /* $lab:coverage:on$ */
+};
+
+
 exports.isIsoDate = function (date) {
 
     return internals.isoDate.test(date);

package/lib/extend.js

@@ -129,6 +129,12 @@ exports.type = function (from, options) {
 
     def.rules = rules;
 
+    // JSON Schema
+
+    if (!def.jsonSchema) {
+        def.jsonSchema = parent.jsonSchema;
+    }
+
     // Modifiers
 
     const modifiers = Object.assign({}, parent.modifiers);

package/lib/index.d.ts

@@ -8,7 +8,7 @@
 // TypeScript Version: 2.8
 
 // TODO express type of Schema in a type-parameter (.default, .valid, .example etc)
-import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec";
 
 declare namespace Joi {
   type Types =
@@ -1003,7 +1003,14 @@ declare namespace Joi {
 
   interface AnySchema<TSchema = any>
     extends SchemaInternals,
-      StandardSchemaV1<TSchema> {
+      StandardSchemaV1<any, TSchema>,
+      StandardJSONSchemaV1<any, TSchema> {
+    /**
+     * The Standard properties.
+     */
+    readonly "~standard": StandardSchemaV1.Props<any, TSchema> &
+      StandardJSONSchemaV1.Props<any, TSchema>;
+
     /**
      * Flags of current schema.
      */

package/lib/schemas.js

@@ -80,7 +80,8 @@ internals.rule = Joi.object({
     manifest: Joi.boolean(),
     method: Joi.function().allow(false),
     multi: Joi.boolean(),
-    validate: Joi.function()
+    validate: Joi.function(),
+    jsonSchema: Joi.function()
 });
 
 
@@ -114,6 +115,7 @@ exports.extension = Joi.object({
     prepare: Joi.function().maxArity(3),
     rebuild: Joi.function().arity(1),
     rules: Joi.object().pattern(internals.nameRx, internals.rule),
+    jsonSchema: Joi.function(),
     terms: Joi.object().pattern(internals.nameRx, Joi.object({
         init: Joi.array().allow(null).required(),
         manifest: Joi.object().pattern(/.+/, [

package/lib/types/alternatives.js

@@ -146,6 +146,49 @@ module.exports = Any.extend({
         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: {

package/lib/types/array.js

@@ -68,6 +68,87 @@ module.exports = Any.extend({
         return { value: value.slice() };        // Clone the array so that we don't modify the original
     },
 
+    jsonSchema(schema, res, mode, options) {
+
+        const ordered = schema.$_terms.ordered;
+
+        // Handle ordered items (tuple-like) using 'prefixItems'
+
+        if (ordered.length) {
+            res.prefixItems = ordered.map((item) => item.$_jsonSchema(mode, options));
+        }
+
+        if (schema.$_terms.items.length) {
+            let items;
+            if (schema.$_terms.items.length === 1) {
+                items = schema.$_terms.items[0].$_jsonSchema(mode, options);
+            }
+            else {
+                items = {
+                    anyOf: schema.$_terms.items.map((item) => item.$_jsonSchema(mode, options))
+                };
+            }
+
+            // If there are ordered items, remaining items are 'unevaluatedItems'
+
+            if (ordered.length) {
+                res.unevaluatedItems = items;
+                res.minItems = ordered.length;
+            }
+            else {
+                res.items = items;
+            }
+        }
+        else if (ordered.length) {
+            // No additional items allowed beyond the ordered ones
+
+            res.unevaluatedItems = false;
+            res.minItems = ordered.length;
+            res.maxItems = ordered.length;
+        }
+
+        // Map 'has' rules to 'contains' in JSON Schema
+
+        const contains = [];
+        for (const rule of schema._rules) {
+            if (rule.name === 'has') {
+                contains.push(rule.args.schema.$_jsonSchema(mode, options));
+            }
+        }
+
+        if (contains.length) {
+            if (contains.length === 1) {
+                res.contains = contains[0];
+            }
+            else {
+                res.allOf = contains.map((item) => ({ contains: item }));
+            }
+        }
+
+        if (schema._flags.single &&
+            schema.$_terms.items.length) {
+
+            let items;
+            if (schema.$_terms.items.length === 1) {
+                items = schema.$_terms.items[0].$_jsonSchema(mode, options);
+            }
+            else {
+                items = {
+                    anyOf: schema.$_terms.items.map((item) => item.$_jsonSchema(mode, options))
+                };
+            }
+
+            res = {
+                anyOf: [
+                    res,
+                    items
+                ]
+            };
+        }
+
+        return res;
+    },
+
     rules: {
 
         has: {
@@ -368,6 +449,13 @@ module.exports = Any.extend({
 
                 return helpers.error('array.' + name, { limit: args.limit, value });
             },
+            jsonSchema(rule, res) {
+
+                res.minItems = rule.args.limit;
+                res.maxItems = rule.args.limit;
+
+                return res;
+            },
             args: [
                 {
                     name: 'limit',
@@ -382,6 +470,12 @@ module.exports = Any.extend({
             method(limit) {
 
                 return this.$_addRule({ name: 'max', method: 'length', args: { limit }, operator: '<=' });
+            },
+            jsonSchema(rule, res) {
+
+                res.maxItems = rule.args.limit;
+
+                return res;
             }
         },
 
@@ -389,6 +483,12 @@ module.exports = Any.extend({
             method(limit) {
 
                 return this.$_addRule({ name: 'min', method: 'length', args: { limit }, operator: '>=' });
+            },
+            jsonSchema(rule, res) {
+
+                res.minItems = rule.args.limit;
+
+                return res;
             }
         },
 
@@ -558,6 +658,12 @@ module.exports = Any.extend({
 
                 return value;
             },
+            jsonSchema(rule, res) {
+
+                res.uniqueItems = true;
+
+                return res;
+            },
             args: ['comparator', 'options'],
             multi: true
         }

package/lib/types/binary.js

@@ -33,6 +33,14 @@ module.exports = Any.extend({
         }
     },
 
+    jsonSchema(schema, res, mode, options) {
+
+        res.type = 'string';
+        res.format = 'binary';
+
+        return res;
+    },
+
     rules: {
         encoding: {
             method(encoding) {
@@ -56,6 +64,12 @@ module.exports = Any.extend({
 
                 return helpers.error('binary.' + name, { limit: args.limit, value });
             },
+            jsonSchema(rule, res) {
+
+                res.minLength = rule.args.limit;
+                res.maxLength = rule.args.limit;
+                return res;
+            },
             args: [
                 {
                     name: 'limit',
@@ -70,6 +84,11 @@ module.exports = Any.extend({
             method(limit) {
 
                 return this.$_addRule({ name: 'max', method: 'length', args: { limit }, operator: '<=' });
+            },
+            jsonSchema(rule, res) {
+
+                res.maxLength = rule.args.limit;
+                return res;
             }
         },
 
@@ -77,6 +96,11 @@ module.exports = Any.extend({
             method(limit) {
 
                 return this.$_addRule({ name: 'min', method: 'length', args: { limit }, operator: '>=' });
+            },
+            jsonSchema(rule, res) {
+
+                res.minLength = rule.args.limit;
+                return res;
             }
         }
     },

package/lib/types/date.js

@@ -7,7 +7,9 @@ const Common = require('../common');
 const Template = require('../template');
 
 
-const internals = {};
+const internals = {
+    formats: ['iso', 'javascript', 'unix']
+};
 
 
 internals.isDate = function (value) {
@@ -48,6 +50,14 @@ module.exports = Any.extend({
         return { value, errors: error('date.format', { format }) };
     },
 
+    jsonSchema(schema, res, mode, options) {
+
+        res.type = 'string';
+        res.format = 'date-time';
+
+        return res;
+    },
+
     rules: {
 
         compare: {
@@ -78,7 +88,7 @@ module.exports = Any.extend({
         format: {
             method(format) {
 
-                assert(['iso', 'javascript', 'unix'].includes(format), 'Unknown date format', format);
+                assert(internals.formats.includes(format), 'Unknown date format', format);
 
                 return this.$_setFlag('format', format);
             }
@@ -88,6 +98,15 @@ module.exports = Any.extend({
             method(date) {
 
                 return this.$_addRule({ name: 'greater', method: 'compare', args: { date }, operator: '>' });
+            },
+            jsonSchema(rule, res) {
+
+                const date = rule.args.date;
+                if (date instanceof Date) {
+                    res['x-constraint'] = { ...res['x-constraint'], greater: date.toISOString() };
+                }
+
+                return res;
             }
         },
 
@@ -102,6 +121,15 @@ module.exports = Any.extend({
             method(date) {
 
                 return this.$_addRule({ name: 'less', method: 'compare', args: { date }, operator: '<' });
+            },
+            jsonSchema(rule, res) {
+
+                const date = rule.args.date;
+                if (date instanceof Date) {
+                    res['x-constraint'] = { ...res['x-constraint'], less: date.toISOString() };
+                }
+
+                return res;
             }
         },
 
@@ -109,6 +137,15 @@ module.exports = Any.extend({
             method(date) {
 
                 return this.$_addRule({ name: 'max', method: 'compare', args: { date }, operator: '<=' });
+            },
+            jsonSchema(rule, res) {
+
+                const date = rule.args.date;
+                if (date instanceof Date) {
+                    res['x-constraint'] = { ...res['x-constraint'], max: date.toISOString() };
+                }
+
+                return res;
             }
         },
 
@@ -116,6 +153,15 @@ module.exports = Any.extend({
             method(date) {
 
                 return this.$_addRule({ name: 'min', method: 'compare', args: { date }, operator: '>=' });
+            },
+            jsonSchema(rule, res) {
+
+                const date = rule.args.date;
+                if (date instanceof Date) {
+                    res['x-constraint'] = { ...res['x-constraint'], min: date.toISOString() };
+                }
+
+                return res;
             }
         },