joi 8.3.0 → 9.0.0-0

package/lib/object.js

@@ -6,6 +6,7 @@ const Hoek = require('hoek');
 const Topo = require('topo');
 const Any = require('./any');
 const Cast = require('./cast');
+const Ref = require('./ref');
 
 
 // Declare internals
@@ -217,15 +218,10 @@ internals.Object.prototype._base = function (value, state, options) {
         if (options.stripUnknown ||
             options.skipFunctions) {
 
-            const stripUnknown = options.stripUnknown
-                ? (options.stripUnknown === true ? true : !!options.stripUnknown.objects)
-                : false;
-
-
             for (let i = 0; i < unprocessedKeys.length; ++i) {
                 const key = unprocessedKeys[i];
 
-                if (stripUnknown) {
+                if (options.stripUnknown) {
                     delete target[key];
                     delete unprocessed[key];
                 }
@@ -817,4 +813,17 @@ internals.Object.prototype.type = function (constructor, name) {
 };
 
 
+internals.Object.prototype.ref = function () {
+
+    return this._test('ref', null, (value, state, options) => {
+
+        if (Ref.isRef(value)) {
+            return null;
+        }
+
+        return this.createError('function.ref', null, state, options);
+    });
+};
+
+
 module.exports = new internals.Object();

package/lib/string.js

@@ -79,16 +79,6 @@ internals.String.prototype._base = function (value, state, options) {
                 value = value.replace(replacement.pattern, replacement.replacement);
             }
         }
-
-        if (this._flags.truncate) {
-            for (let i = 0; i < this._tests.length; ++i) {
-                const test = this._tests[i];
-                if (test.name === 'max') {
-                    value = value.slice(0, test.arg);
-                    break;
-                }
-            }
-        }
     }
 
     return {
@@ -481,11 +471,4 @@ internals.String.prototype.replace = function (pattern, replacement) {
     return obj;
 };
 
-internals.String.prototype.truncate = function (enabled) {
-
-    const obj = this.clone();
-    obj._flags.truncate = enabled === undefined ? true : !!enabled;
-    return obj;
-};
-
 module.exports = new internals.String();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "joi",
   "description": "Object schema validation",
-  "version": "8.3.0",
+  "version": "9.0.0-0",
   "homepage": "https://github.com/hapijs/joi",
   "repository": "git://github.com/hapijs/joi",
   "main": "lib/index.js",
@@ -15,22 +15,21 @@
   },
   "dependencies": {
     "hoek": "4.x.x",
-    "topo": "2.x.x",
     "isemail": "2.x.x",
-    "moment": "2.x.x"
+    "items": "2.x.x",
+    "moment": "2.x.x",
+    "topo": "2.x.x"
   },
   "devDependencies": {
     "code": "2.x.x",
     "lab": "10.x.x",
-    "markdown-toc": "0.12.x",
-    "npmignore": "0.2.x"
+    "markdown-toc": "0.12.x"
   },
   "scripts": {
     "test": "lab -t 100 -a code -L",
     "test-cov-html": "lab -r html -o coverage.html -a code",
     "toc": "node generate-readme-toc.js",
-    "update-npmignore": "npmignore",
-    "version": "npm run toc && npm run update-npmignore && git add API.md README.md .npmignore"
+    "version": "npm run toc && git add API.md README.md"
   },
   "license": "BSD-3-Clause"
 }

package/test/alternatives.js

@@ -0,0 +1,490 @@
+'use strict';
+
+// Load modules
+
+const Lab = require('lab');
+const Code = require('code');
+const Joi = require('..');
+const Helper = require('./helper');
+
+
+// Declare internals
+
+const internals = {};
+
+
+// Test shortcuts
+
+const lab = exports.lab = Lab.script();
+const describe = lab.describe;
+const it = lab.it;
+const expect = Code.expect;
+
+
+describe('alternatives', () => {
+
+    it('fails when no alternatives are provided', (done) => {
+
+        Joi.alternatives().validate('a', (err, value) => {
+
+            expect(err).to.exist();
+            expect(err.message).to.equal('"value" not matching any of the allowed alternatives');
+            done();
+        });
+    });
+
+    it('allows undefined when no alternatives are provided', (done) => {
+
+        Joi.alternatives().validate(undefined, (err, value) => {
+
+            expect(err).to.not.exist();
+            done();
+        });
+    });
+
+    it('applies modifiers when higher priority converts', (done) => {
+
+        const schema = Joi.object({
+            a: [
+                Joi.number(),
+                Joi.string()
+            ]
+        });
+
+        schema.validate({ a: '5' }, (err, value) => {
+
+            expect(err).to.not.exist();
+            expect(value.a).to.equal(5);
+            done();
+        });
+    });
+
+    it('applies modifiers when lower priority valid is a match', (done) => {
+
+        const schema = Joi.object({
+            a: [
+                Joi.number(),
+                Joi.valid('5')
+            ]
+        });
+
+        schema.validate({ a: '5' }, (err, value) => {
+
+            expect(err).to.not.exist();
+            expect(value.a).to.equal(5);
+            done();
+        });
+    });
+
+    it('does not apply modifier if alternative fails', (done) => {
+
+        const schema = Joi.object({
+            a: [
+                Joi.object({ c: Joi.any(), d: Joi.number() }).rename('b', 'c'),
+                { b: Joi.any(), d: Joi.string() }
+            ]
+        });
+
+        const input = { a: { b: 'any', d: 'string' } };
+        schema.validate(input, (err, value) => {
+
+            expect(err).to.not.exist();
+            expect(value.a.b).to.equal('any');
+            done();
+        });
+    });
+
+    describe('try()', () => {
+
+        it('throws when missing alternatives', (done) => {
+
+            expect(() => {
+
+                Joi.alternatives().try();
+            }).to.throw('Cannot add other alternatives without at least one schema');
+            done();
+        });
+    });
+
+    describe('when()', () => {
+
+        it('throws on invalid ref (not string)', (done) => {
+
+            expect(() => {
+
+                Joi.alternatives().when(5, { is: 6, then: Joi.number() });
+            }).to.throw('Invalid reference: 5');
+            done();
+        });
+
+        it('validates conditional alternatives', (done) => {
+
+            const schema = {
+                a: Joi.alternatives().when('b', { is: 5, then: 'x', otherwise: 'y' })
+                                     .try('z'),
+                b: Joi.any()
+            };
+
+            Helper.validate(schema, [
+                [{ a: 'x', b: 5 }, true],
+                [{ a: 'x', b: 6 }, false],
+                [{ a: 'y', b: 5 }, false],
+                [{ a: 'y', b: 6 }, true],
+                [{ a: 'z', b: 5 }, false],
+                [{ a: 'z', b: 6 }, false]
+            ], done);
+        });
+
+        it('validates conditional alternatives (empty key)', (done) => {
+
+            const schema = {
+                a: Joi.alternatives().when('', { is: 5, then: 'x', otherwise: 'y' })
+                                     .try('z'),
+                '': Joi.any()
+            };
+
+            Helper.validate(schema, [
+                [{ a: 'x', '': 5 }, true],
+                [{ a: 'x', '': 6 }, false],
+                [{ a: 'y', '': 5 }, false],
+                [{ a: 'y', '': 6 }, true],
+                [{ a: 'z', '': 5 }, false],
+                [{ a: 'z', '': 6 }, false]
+            ], done);
+        });
+
+        it('validates only then', (done) => {
+
+            const schema = {
+                a: Joi.alternatives().when(Joi.ref('b'), { is: 5, then: 'x' })
+                                     .try('z'),
+                b: Joi.any()
+            };
+
+            Helper.validate(schema, [
+                [{ a: 'x', b: 5 }, true],
+                [{ a: 'x', b: 6 }, false],
+                [{ a: 'y', b: 5 }, false],
+                [{ a: 'y', b: 6 }, false],
+                [{ a: 'z', b: 5 }, false],
+                [{ a: 'z', b: 6 }, true]
+            ], done);
+        });
+
+        it('validates only otherwise', (done) => {
+
+            const schema = {
+                a: Joi.alternatives().when('b', { is: 5, otherwise: 'y' })
+                                     .try('z'),
+                b: Joi.any()
+            };
+
+            Helper.validate(schema, [
+                [{ a: 'x', b: 5 }, false],
+                [{ a: 'x', b: 6 }, false],
+                [{ a: 'y', b: 5 }, false],
+                [{ a: 'y', b: 6 }, true],
+                [{ a: 'z', b: 5 }, true],
+                [{ a: 'z', b: 6 }, false]
+            ], done);
+        });
+
+        it('validates when is is null', (done) => {
+
+            const schema = {
+                a: Joi.alternatives().when('b', { is: null, then: 'x', otherwise: Joi.number() }),
+                b: Joi.any()
+            };
+
+            Helper.validate(schema, [
+                [{ a: 1 }, true],
+                [{ a: 'y' }, false],
+                [{ a: 'x', b: null }, true],
+                [{ a: 'y', b: null }, false],
+                [{ a: 1, b: null }, false]
+            ], done);
+        });
+
+        it('validates when is has ref', (done) => {
+
+            const schema = {
+                a: Joi.alternatives().when('b', { is: Joi.ref('c'), then: 'x' }),
+                b: Joi.any(),
+                c: Joi.number()
+            };
+
+            Helper.validate(schema, [
+                [{ a: 'x', b: 5, c: '5' }, true],
+                [{ a: 'x', b: 5, c: '1' }, false],
+                [{ a: 'x', b: '5', c: '5' }, false],
+                [{ a: 'y', b: 5, c: 5 }, false],
+                [{ a: 'y' }, false]
+            ], done);
+        });
+
+        it('validates when then has ref', (done) => {
+
+            const schema = {
+                a: Joi.alternatives().when('b', { is: 5, then: Joi.ref('c') }),
+                b: Joi.any(),
+                c: Joi.number()
+            };
+
+            Helper.validate(schema, [
+                [{ a: 'x', b: 5, c: '1' }, false],
+                [{ a: 1, b: 5, c: '1' }, true],
+                [{ a: '1', b: 5, c: '1' }, false]
+            ], done);
+        });
+
+        it('validates when otherwise has ref', (done) => {
+
+            const schema = {
+                a: Joi.alternatives().when('b', { is: 6, otherwise: Joi.ref('c') }),
+                b: Joi.any(),
+                c: Joi.number()
+            };
+
+            Helper.validate(schema, [
+                [{ a: 'x', b: 5, c: '1' }, false],
+                [{ a: 1, b: 5, c: '1' }, true],
+                [{ a: '1', b: 5, c: '1' }, false]
+            ], done);
+        });
+
+        it('validates when empty value', (done) => {
+
+            const schema = {
+                a: Joi.alternatives().when('b', { is: true, then: Joi.required() }),
+                b: Joi.boolean().default(false)
+            };
+
+            Helper.validate(schema, [
+                [{ b: false }, true],
+                [{ b: true }, true]           // true because required() only applies to the one alternative
+            ], done);
+        });
+
+        it('validates when missing value', (done) => {
+
+            const schema = Joi.object({
+                a: Joi.alternatives().when('b', { is: 5, then: Joi.optional(), otherwise: Joi.required() }).required(),
+                b: Joi.number()
+            });
+
+            Helper.validate(schema, [
+                [{ a: 1 }, true],
+                [{}, false],
+                [{ b: 1 }, false],
+                [{ a: 1, b: 1 }, true],
+                [{ a: 1, b: 5 }, true],
+                [{ b: 5 }, false]
+            ], done);
+        });
+    });
+
+    describe('describe()', () => {
+
+        it('describes when', (done) => {
+
+            const schema = {
+                a: Joi.alternatives().when('b', { is: 5, then: 'x', otherwise: 'y' })
+                                     .try('z'),
+                b: Joi.any()
+            };
+
+            const outcome = {
+                type: 'object',
+                children: {
+                    b: {
+                        type: 'any'
+                    },
+                    a: {
+                        type: 'alternatives',
+                        alternatives: [
+                            {
+                                ref: 'ref:b',
+                                is: {
+                                    type: 'number',
+                                    flags: {
+                                        allowOnly: true,
+                                        presence: 'required'
+                                    },
+                                    valids: [5],
+                                    invalids: [Infinity, -Infinity]
+                                },
+                                then: {
+                                    type: 'string',
+                                    flags: {
+                                        allowOnly: true
+                                    },
+                                    valids: ['x'],
+                                    invalids: ['']
+                                },
+                                otherwise: {
+                                    type: 'string',
+                                    flags: {
+                                        allowOnly: true
+                                    },
+                                    valids: ['y'],
+                                    invalids: ['']
+                                }
+                            },
+                            {
+                                type: 'string',
+                                flags: {
+                                    allowOnly: true
+                                },
+                                valids: ['z'],
+                                invalids: ['']
+                            }
+                        ]
+                    }
+                }
+            };
+
+            expect(Joi.describe(schema)).to.deep.equal(outcome);
+            done();
+        });
+
+        it('describes when (only then)', (done) => {
+
+            const schema = {
+                a: Joi.alternatives().when('b', { is: 5, then: 'x' })
+                                     .try('z'),
+                b: Joi.any()
+            };
+
+            const outcome = {
+                type: 'object',
+                children: {
+                    b: {
+                        type: 'any'
+                    },
+                    a: {
+                        type: 'alternatives',
+                        alternatives: [
+                            {
+                                ref: 'ref:b',
+                                is: {
+                                    type: 'number',
+                                    flags: {
+                                        allowOnly: true,
+                                        presence: 'required'
+                                    },
+                                    valids: [5],
+                                    invalids: [Infinity, -Infinity]
+                                },
+                                then: {
+                                    type: 'string',
+                                    flags: {
+                                        allowOnly: true
+                                    },
+                                    valids: ['x'],
+                                    invalids: ['']
+                                }
+                            },
+                            {
+                                type: 'string',
+                                flags: {
+                                    allowOnly: true
+                                },
+                                valids: ['z'],
+                                invalids: ['']
+                            }
+                        ]
+                    }
+                }
+            };
+
+            expect(Joi.describe(schema)).to.deep.equal(outcome);
+            done();
+        });
+
+        it('describes when (only otherwise)', (done) => {
+
+            const schema = {
+                a: Joi.alternatives().when('b', { is: 5, otherwise: 'y' })
+                                     .try('z'),
+                b: Joi.any()
+            };
+
+            const outcome = {
+                type: 'object',
+                children: {
+                    b: {
+                        type: 'any'
+                    },
+                    a: {
+                        type: 'alternatives',
+                        alternatives: [
+                            {
+                                ref: 'ref:b',
+                                is: {
+                                    type: 'number',
+                                    flags: {
+                                        allowOnly: true,
+                                        presence: 'required'
+                                    },
+                                    valids: [5],
+                                    invalids: [Infinity, -Infinity]
+                                },
+                                otherwise: {
+                                    type: 'string',
+                                    flags: {
+                                        allowOnly: true
+                                    },
+                                    valids: ['y'],
+                                    invalids: ['']
+                                }
+                            },
+                            {
+                                type: 'string',
+                                flags: {
+                                    allowOnly: true
+                                },
+                                valids: ['z'],
+                                invalids: ['']
+                            }
+                        ]
+                    }
+                }
+            };
+
+            expect(Joi.describe(schema)).to.deep.equal(outcome);
+            done();
+        });
+
+        it('describes inherited fields (from any)', (done) => {
+
+            const schema = Joi.alternatives()
+                .try('a')
+                .description('d')
+                .example('a')
+                .meta('b')
+                .meta('c')
+                .notes('f')
+                .tags('g');
+
+            const outcome = {
+                type: 'alternatives',
+                description: 'd',
+                notes: ['f'],
+                tags: ['g'],
+                meta: ['b', 'c'],
+                examples: ['a'],
+                alternatives: [{
+                    type: 'string',
+                    flags: {
+                        allowOnly: true
+                    },
+                    valids: ['a'],
+                    invalids: ['']
+                }]
+            };
+
+            expect(Joi.describe(schema)).to.deep.equal(outcome);
+            done();
+        });
+    });
+});