joi 14.2.0 → 17.2.0

package/lib/values.js

@@ -0,0 +1,263 @@
+'use strict';
+
+const Assert = require('@hapi/hoek/lib/assert');
+const DeepEqual = require('@hapi/hoek/lib/deepEqual');
+
+const Common = require('./common');
+
+
+const internals = {};
+
+
+module.exports = internals.Values = class {
+
+    constructor(values, refs) {
+
+        this._values = new Set(values);
+        this._refs = new Set(refs);
+        this._lowercase = internals.lowercases(values);
+
+        this._override = false;
+    }
+
+    get length() {
+
+        return this._values.size + this._refs.size;
+    }
+
+    add(value, refs) {
+
+        // Reference
+
+        if (Common.isResolvable(value)) {
+            if (!this._refs.has(value)) {
+                this._refs.add(value);
+
+                if (refs) {                     // Skipped in a merge
+                    refs.register(value);
+                }
+            }
+
+            return;
+        }
+
+        // Value
+
+        if (!this.has(value, null, null, false)) {
+            this._values.add(value);
+
+            if (typeof value === 'string') {
+                this._lowercase.set(value.toLowerCase(), value);
+            }
+        }
+    }
+
+    static merge(target, source, remove) {
+
+        target = target || new internals.Values();
+
+        if (source) {
+            if (source._override) {
+                return source.clone();
+            }
+
+            for (const item of [...source._values, ...source._refs]) {
+                target.add(item);
+            }
+        }
+
+        if (remove) {
+            for (const item of [...remove._values, ...remove._refs]) {
+                target.remove(item);
+            }
+        }
+
+        return target.length ? target : null;
+    }
+
+    remove(value) {
+
+        // Reference
+
+        if (Common.isResolvable(value)) {
+            this._refs.delete(value);
+            return;
+        }
+
+        // Value
+
+        this._values.delete(value);
+
+        if (typeof value === 'string') {
+            this._lowercase.delete(value.toLowerCase());
+        }
+    }
+
+    has(value, state, prefs, insensitive) {
+
+        return !!this.get(value, state, prefs, insensitive);
+    }
+
+    get(value, state, prefs, insensitive) {
+
+        if (!this.length) {
+            return false;
+        }
+
+        // Simple match
+
+        if (this._values.has(value)) {
+            return { value };
+        }
+
+        // Case insensitive string match
+
+        if (typeof value === 'string' &&
+            value &&
+            insensitive) {
+
+            const found = this._lowercase.get(value.toLowerCase());
+            if (found) {
+                return { value: found };
+            }
+        }
+
+        if (!this._refs.size &&
+            typeof value !== 'object') {
+
+            return false;
+        }
+
+        // Objects
+
+        if (typeof value === 'object') {
+            for (const item of this._values) {
+                if (DeepEqual(item, value)) {
+                    return { value: item };
+                }
+            }
+        }
+
+        // References
+
+        if (state) {
+            for (const ref of this._refs) {
+                const resolved = ref.resolve(value, state, prefs, null, { in: true });
+                if (resolved === undefined) {
+                    continue;
+                }
+
+                const items = !ref.in || typeof resolved !== 'object'
+                    ? [resolved]
+                    : Array.isArray(resolved) ? resolved : Object.keys(resolved);
+
+                for (const item of items) {
+                    if (typeof item !== typeof value) {
+                        continue;
+                    }
+
+                    if (insensitive &&
+                        value &&
+                        typeof value === 'string') {
+
+                        if (item.toLowerCase() === value.toLowerCase()) {
+                            return { value: item, ref };
+                        }
+                    }
+                    else {
+                        if (DeepEqual(item, value)) {
+                            return { value: item, ref };
+                        }
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
+
+    override() {
+
+        this._override = true;
+    }
+
+    values(options) {
+
+        if (options &&
+            options.display) {
+
+            const values = [];
+
+            for (const item of [...this._values, ...this._refs]) {
+                if (item !== undefined) {
+                    values.push(item);
+                }
+            }
+
+            return values;
+        }
+
+        return Array.from([...this._values, ...this._refs]);
+    }
+
+    clone() {
+
+        const set = new internals.Values(this._values, this._refs);
+        set._override = this._override;
+        return set;
+    }
+
+    concat(source) {
+
+        Assert(!source._override, 'Cannot concat override set of values');
+
+        const set = new internals.Values([...this._values, ...source._values], [...this._refs, ...source._refs]);
+        set._override = this._override;
+        return set;
+    }
+
+    describe() {
+
+        const normalized = [];
+
+        if (this._override) {
+            normalized.push({ override: true });
+        }
+
+        for (const value of this._values.values()) {
+            normalized.push(value && typeof value === 'object' ? { value } : value);
+        }
+
+        for (const value of this._refs.values()) {
+            normalized.push(value.describe());
+        }
+
+        return normalized;
+    }
+};
+
+
+internals.Values.prototype[Common.symbols.values] = true;
+
+
+// Aliases
+
+internals.Values.prototype.slice = internals.Values.prototype.clone;
+
+
+// Helpers
+
+internals.lowercases = function (from) {
+
+    const map = new Map();
+
+    if (from) {
+        for (const value of from) {
+            if (typeof value === 'string') {
+                map.set(value.toLowerCase(), value);
+            }
+        }
+    }
+
+    return map;
+};

package/package.json

@@ -1,31 +1,36 @@
 {
-  "name": "joi",
-  "description": "Object schema validation",
-  "version": "14.2.0",
-  "homepage": "https://github.com/hapijs/joi",
-  "repository": "git://github.com/hapijs/joi",
-  "main": "lib/index.js",
-  "keywords": [
-    "hapi",
-    "schema",
-    "validation"
-  ],
-  "dependencies": {
-    "hoek": "6.x.x",
-    "isemail": "3.x.x",
-    "topo": "3.x.x"
-  },
-  "devDependencies": {
-    "code": "5.x.x",
-    "hapitoc": "1.x.x",
-    "lab": "18.x.x"
-  },
-  "scripts": {
-    "test": "lab -t 100 -a code -L",
-    "test-debug": "lab -a code",
-    "test-cov-html": "lab -r html -o coverage.html -a code",
-    "toc": "hapitoc && node docs/check-errors-list.js",
-    "version": "npm run toc && git add API.md README.md"
-  },
-  "license": "BSD-3-Clause"
+    "name": "joi",
+    "description": "Object schema validation",
+    "version": "17.2.0",
+    "repository": "git://github.com/sideway/joi",
+    "main": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "browser": "dist/joi-browser.min.js",
+    "files": [
+        "lib/**/*",
+        "dist/*"
+    ],
+    "keywords": [
+        "schema",
+        "validation"
+    ],
+    "dependencies": {
+        "@hapi/address": "^4.1.0",
+        "@hapi/formula": "^2.0.0",
+        "@hapi/hoek": "^9.0.0",
+        "@hapi/pinpoint": "^2.0.0",
+        "@hapi/topo": "^5.0.0"
+    },
+    "devDependencies": {
+        "@hapi/bourne": "2.x.x",
+        "@hapi/code": "8.x.x",
+        "@hapi/lab": "23.x.x",
+        "@hapi/joi-legacy-test": "npm:@hapi/joi@15.x.x"
+    },
+    "scripts": {
+        "prepublishOnly": "cd browser && npm install && npm run build",
+        "test": "lab -t 100 -a @hapi/code -L -Y",
+        "test-cov-html": "lab -r html -o coverage.html -a @hapi/code"
+    },
+    "license": "BSD-3-Clause"
 }

package/CHANGELOG.md

@@ -1,3 +0,0 @@
-Breaking changes are documented using GitHub issues, see [issues labeled "release notes"](https://github.com/hapijs/joi/issues?q=is%3Aissue+label%3A%22release+notes%22).
-
-If you want changes of a specific minor or patch release, you can browse the [GitHub milestones](https://github.com/hapijs/joi/milestones?state=closed&direction=asc&sort=due_date).

package/LICENSE

@@ -1,25 +0,0 @@
-Copyright (c) 2012-2018, Project contributors
-Copyright (c) 2012-2014, Walmart
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-    * The names of any contributors may not be used to endorse or promote
-      products derived from this software without specific prior written
-      permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS AND CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/lib/cast.js

@@ -1,64 +0,0 @@
-'use strict';
-
-// Load modules
-
-const Hoek = require('hoek');
-const Ref = require('./ref');
-
-// Type modules are delay-loaded to prevent circular dependencies
-
-
-// Declare internals
-
-const internals = {};
-
-
-exports.schema = function (Joi, config) {
-
-    if (config !== undefined && config !== null && typeof config === 'object') {
-
-        if (config.isJoi) {
-            return config;
-        }
-
-        if (Array.isArray(config)) {
-            return Joi.alternatives().try(config);
-        }
-
-        if (config instanceof RegExp) {
-            return Joi.string().regex(config);
-        }
-
-        if (config instanceof Date) {
-            return Joi.date().valid(config);
-        }
-
-        return Joi.object().keys(config);
-    }
-
-    if (typeof config === 'string') {
-        return Joi.string().valid(config);
-    }
-
-    if (typeof config === 'number') {
-        return Joi.number().valid(config);
-    }
-
-    if (typeof config === 'boolean') {
-        return Joi.boolean().valid(config);
-    }
-
-    if (Ref.isRef(config)) {
-        return Joi.valid(config);
-    }
-
-    Hoek.assert(config === null, 'Invalid schema content:', config);
-
-    return Joi.valid(null);
-};
-
-
-exports.ref = function (id) {
-
-    return Ref.isRef(id) ? id : Ref.create(id);
-};

package/lib/language.js

@@ -1,166 +0,0 @@
-'use strict';
-
-// Load modules
-
-
-// Declare internals
-
-const internals = {};
-
-
-exports.errors = {
-    root: 'value',
-    key: '"{{!label}}" ',
-    messages: {
-        wrapArrays: true
-    },
-    any: {
-        unknown: 'is not allowed',
-        invalid: 'contains an invalid value',
-        empty: 'is not allowed to be empty',
-        required: 'is required',
-        allowOnly: 'must be one of {{valids}}',
-        default: 'threw an error when running default method'
-    },
-    alternatives: {
-        base: 'not matching any of the allowed alternatives',
-        child: null
-    },
-    array: {
-        base: 'must be an array',
-        includes: 'at position {{pos}} does not match any of the allowed types',
-        includesSingle: 'single value of "{{!label}}" does not match any of the allowed types',
-        includesOne: 'at position {{pos}} fails because {{reason}}',
-        includesOneSingle: 'single value of "{{!label}}" fails because {{reason}}',
-        includesRequiredUnknowns: 'does not contain {{unknownMisses}} required value(s)',
-        includesRequiredKnowns: 'does not contain {{knownMisses}}',
-        includesRequiredBoth: 'does not contain {{knownMisses}} and {{unknownMisses}} other required value(s)',
-        excludes: 'at position {{pos}} contains an excluded value',
-        excludesSingle: 'single value of "{{!label}}" contains an excluded value',
-        hasKnown: 'does not contain at least one required match for type "{{!patternLabel}}"',
-        hasUnknown: 'does not contain at least one required match',
-        min: 'must contain at least {{limit}} items',
-        max: 'must contain less than or equal to {{limit}} items',
-        length: 'must contain {{limit}} items',
-        ordered: 'at position {{pos}} fails because {{reason}}',
-        orderedLength: 'at position {{pos}} fails because array must contain at most {{limit}} items',
-        ref: 'references "{{ref}}" which is not a positive integer',
-        sparse: 'must not be a sparse array',
-        unique: 'position {{pos}} contains a duplicate value'
-    },
-    boolean: {
-        base: 'must be a boolean'
-    },
-    binary: {
-        base: 'must be a buffer or a string',
-        min: 'must be at least {{limit}} bytes',
-        max: 'must be less than or equal to {{limit}} bytes',
-        length: 'must be {{limit}} bytes'
-    },
-    date: {
-        base: 'must be a number of milliseconds or valid date string',
-        strict: 'must be a valid date',
-        min: 'must be larger than or equal to "{{limit}}"',
-        max: 'must be less than or equal to "{{limit}}"',
-        less: 'must be less than "{{limit}}"',
-        greater: 'must be greater than "{{limit}}"',
-        isoDate: 'must be a valid ISO 8601 date',
-        timestamp: {
-            javascript: 'must be a valid timestamp or number of milliseconds',
-            unix: 'must be a valid timestamp or number of seconds'
-        },
-        ref: 'references "{{ref}}" which is not a date'
-    },
-    function: {
-        base: 'must be a Function',
-        arity: 'must have an arity of {{n}}',
-        minArity: 'must have an arity greater or equal to {{n}}',
-        maxArity: 'must have an arity lesser or equal to {{n}}',
-        ref: 'must be a Joi reference',
-        class: 'must be a class'
-    },
-    lazy: {
-        base: '!!schema error: lazy schema must be set',
-        schema: '!!schema error: lazy schema function must return a schema'
-    },
-    object: {
-        base: 'must be an object',
-        child: '!!child "{{!child}}" fails because {{reason}}',
-        min: 'must have at least {{limit}} children',
-        max: 'must have less than or equal to {{limit}} children',
-        length: 'must have {{limit}} children',
-        allowUnknown: '!!"{{!child}}" is not allowed',
-        with: '!!"{{mainWithLabel}}" missing required peer "{{peerWithLabel}}"',
-        without: '!!"{{mainWithLabel}}" conflict with forbidden peer "{{peerWithLabel}}"',
-        missing: 'must contain at least one of {{peersWithLabels}}',
-        xor: 'contains a conflict between exclusive peers {{peersWithLabels}}',
-        oxor: 'contains a conflict between optional exclusive peers {{peersWithLabels}}',
-        and: 'contains {{presentWithLabels}} without its required peers {{missingWithLabels}}',
-        nand: '!!"{{mainWithLabel}}" must not exist simultaneously with {{peersWithLabels}}',
-        assert: '!!"{{ref}}" validation failed because "{{ref}}" failed to {{message}}',
-        rename: {
-            multiple: 'cannot rename child "{{from}}" because multiple renames are disabled and another key was already renamed to "{{to}}"',
-            override: 'cannot rename child "{{from}}" because override is disabled and target "{{to}}" exists',
-            regex: {
-                multiple: 'cannot rename children {{from}} because multiple renames are disabled and another key was already renamed to "{{to}}"',
-                override: 'cannot rename children {{from}} because override is disabled and target "{{to}}" exists'
-            }
-        },
-        type: 'must be an instance of "{{type}}"',
-        schema: 'must be a Joi instance'
-    },
-    number: {
-        base: 'must be a number',
-        unsafe: 'must be a safe number',
-        min: 'must be larger than or equal to {{limit}}',
-        max: 'must be less than or equal to {{limit}}',
-        less: 'must be less than {{limit}}',
-        greater: 'must be greater than {{limit}}',
-        integer: 'must be an integer',
-        negative: 'must be a negative number',
-        positive: 'must be a positive number',
-        precision: 'must have no more than {{limit}} decimal places',
-        ref: 'references "{{ref}}" which is not a number',
-        multiple: 'must be a multiple of {{multiple}}',
-        port: 'must be a valid port'
-    },
-    string: {
-        base: 'must be a string',
-        min: 'length must be at least {{limit}} characters long',
-        max: 'length must be less than or equal to {{limit}} characters long',
-        length: 'length must be {{limit}} characters long',
-        alphanum: 'must only contain alpha-numeric characters',
-        token: 'must only contain alpha-numeric and underscore characters',
-        regex: {
-            base: 'with value "{{!value}}" fails to match the required pattern: {{pattern}}',
-            name: 'with value "{{!value}}" fails to match the {{name}} pattern',
-            invert: {
-                base: 'with value "{{!value}}" matches the inverted pattern: {{pattern}}',
-                name: 'with value "{{!value}}" matches the inverted {{name}} pattern'
-            }
-        },
-        email: 'must be a valid email',
-        uri: 'must be a valid uri',
-        uriRelativeOnly: 'must be a valid relative uri',
-        uriCustomScheme: 'must be a valid uri with a scheme matching the {{scheme}} pattern',
-        isoDate: 'must be a valid ISO 8601 date',
-        guid: 'must be a valid GUID',
-        hex: 'must only contain hexadecimal characters',
-        hexAlign: 'hex decoded representation must be byte aligned',
-        base64: 'must be a valid base64 string',
-        dataUri: 'must be a valid dataUri string',
-        hostname: 'must be a valid hostname',
-        normalize: 'must be unicode normalized in the {{form}} form',
-        lowercase: 'must only contain lowercase characters',
-        uppercase: 'must only contain uppercase characters',
-        trim: 'must not have leading or trailing whitespace',
-        creditCard: 'must be a credit card',
-        ref: 'references "{{ref}}" which is not a number',
-        ip: 'must be a valid ip address with a {{cidr}} CIDR',
-        ipVersion: 'must be a valid ip address of one of the following versions {{version}} with a {{cidr}} CIDR'
-    },
-    symbol: {
-        base: 'must be a symbol',
-        map: 'must be one of {{map}}'
-    }
-};