joi 4.6.2 → 4.9.0

package/lib/date.js

@@ -3,12 +3,15 @@
 var Any = require('./any');
 var Errors = require('./errors');
 var Hoek = require('hoek');
+var Moment = require('moment');
 
 
 // Declare internals
 
 var internals = {};
 
+internals.isoDate = /^((\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\d))$/;
+internals.invalidDate = new Date('');
 
 internals.Date = function () {
 
@@ -22,15 +25,21 @@ Hoek.inherits(internals.Date, Any);
 internals.Date.prototype._base = function (value, state, options) {
 
     var result = {
-        value: (options.convert && internals.toDate(value)) || value
+        value: (options.convert && internals.toDate(value, this._flags.format)) || value
     };
 
-    result.errors = (result.value instanceof Date && !isNaN(result.value.getTime())) ? null : Errors.create('date.base', null, state, options);
+    if (result.value instanceof Date && !isNaN(result.value.getTime())) {
+        result.errors = null;
+    }
+    else {
+        result.errors = Errors.create(this._flags.format === internals.isoDate ? 'date.isoDate' : 'date.base', null, state, options);
+    }
+
     return result;
 };
 
 
-internals.toDate = function (value) {
+internals.toDate = function (value, format) {
 
     if (value instanceof Date) {
         return value;
@@ -40,12 +49,25 @@ internals.toDate = function (value) {
         Hoek.isInteger(value)) {
 
         if (typeof value === 'string' &&
-            /^\d+$/.test(value)) {
+            /^[+-]?\d+$/.test(value)) {
 
             value = parseInt(value, 10);
         }
 
-        var date = new Date(value);
+        var date;
+        if (format) {
+            if (format === internals.isoDate) {
+                date = format.test(value) ? new Date(value) : internals.invalidDate;
+            }
+            else {
+                date = Moment(value, format, true);
+                date = date.isValid() ? date.toDate() : internals.invalidDate;
+            }
+        }
+        else {
+            date = new Date(value);
+        }
+
         if (!isNaN(date.getTime())) {
             return date;
         }
@@ -57,12 +79,17 @@ internals.toDate = function (value) {
 
 internals.Date.prototype.min = function (date) {
 
-    date = internals.toDate(date);
+    var isNow = date === 'now';
+
+    if (!isNow) {
+        date =  internals.toDate(date);
+    }
+
     Hoek.assert(date, 'Invalid date format');
 
     return this._test('min', date, function (value, state, options) {
 
-        if (value.getTime() >= date.getTime()) {
+        if (value.getTime() >= (isNow ? Date.now() : date.getTime())) {
             return null;
         }
 
@@ -73,12 +100,17 @@ internals.Date.prototype.min = function (date) {
 
 internals.Date.prototype.max = function (date) {
 
-    date = internals.toDate(date);
+    var isNow = date === 'now';
+
+    if (!isNow) {
+        date =  internals.toDate(date);
+    }
+
     Hoek.assert(date, 'Invalid date format');
 
     return this._test('max', date, function (value, state, options) {
 
-        if (value.getTime() <= date.getTime()) {
+        if (value.getTime() <= (isNow ? Date.now() : date.getTime())) {
             return null;
         }
 
@@ -86,5 +118,28 @@ internals.Date.prototype.max = function (date) {
     });
 };
 
+internals.Date.prototype.format = function (format) {
+
+    Hoek.assert(typeof format === 'string' || (Array.isArray(format) && format.every(function (f) {
+
+        return typeof f === 'string';
+    })), 'Invalid format.');
+
+    var obj = this.clone();
+    obj._flags.format = format;
+    return obj;
+};
+
+internals.Date.prototype.iso = function () {
+
+    var obj = this.clone();
+    obj._flags.format = internals.isoDate;
+    return obj;
+}
+
+internals.Date.prototype._isIsoDate = function (value) {
+
+    return internals.isoDate.test(value);
+};
 
 module.exports = new internals.Date();

package/lib/errors.js

@@ -24,7 +24,7 @@ internals.Err.prototype.toString = function () {
     var self = this;
 
     var localized = this.options.language;
-    this.context.key = this.context.key || localized.root || Language.errors.root;
+    this.context.key = localized.label || this.context.key || localized.root || Language.errors.root;
 
     var format = Hoek.reach(localized, this.type) || Hoek.reach(Language.errors, this.type);
     var hasKey = /\{\{\!?key\}\}/.test(format);
@@ -57,7 +57,7 @@ exports.process = function (errors, object) {
         var item = errors[i];
         details.push({
             message: item.toString(),
-            path: item.path || item.context.key,
+            path: internals.getPath(item),
             type: item.type
         });
     }
@@ -79,6 +79,22 @@ exports.process = function (errors, object) {
 };
 
 
+internals.getPath = function (item) {
+
+    var recursePath = function (it) {
+
+        var reachedItem = Hoek.reach(it, 'context.reason.0');
+        if (reachedItem && reachedItem.context) {
+            return recursePath(reachedItem);
+        }
+
+        return it.path;
+    };
+
+    return recursePath(item) || item.context.key;
+};
+
+
 internals.annotate = function () {
 
     var obj = Hoek.clone(this._object || {});

package/lib/index.js

@@ -113,11 +113,12 @@ internals.root = function () {
         return Cast.schema(schema);
     };
 
-    root.assert = function (value, schema) {
+    root.assert = function (value, schema, message) {
 
+        message = (message ? message + ' ' : '');
         var error = root.validate(value, schema).error;
         if (error) {
-            throw new Error(error.annotate());
+            throw new Error(message + error.annotate());
         }
     };
 

package/lib/language.js

@@ -25,7 +25,8 @@ exports.errors = {
         excludes: 'position {{pos}} contains an excluded value',
         min: 'must contain at least {{limit}} items',
         max: 'must contain less than or equal to {{limit}} items',
-        length: 'must contain {{limit}} items'
+        length: 'must contain {{limit}} items',
+        unique: 'position {{pos}} contains a duplicate value'
     },
     boolean: {
         base: 'must be a boolean'
@@ -39,7 +40,8 @@ exports.errors = {
     date: {
         base: 'must be a number of milliseconds or valid date string',
         min: 'must be larger than or equal to {{limit}}',
-        max: 'must be less than or equal to {{limit}}'
+        max: 'must be less than or equal to {{limit}}',
+        isoDate: 'must be a valid ISO 8601 date'
     },
     function: {
         base: 'must be a Function'
@@ -56,20 +58,25 @@ exports.errors = {
         xor: 'contains a conflict between exclusive peers {{peers}}',
         or: 'must contain at least one of {{peers}}',
         and: 'contains {{present}} without its required peers {{missing}}',
+        nand: '{{main}} must not exist simultaneously with {{peers}}',
         assert: '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'
-        }
+        },
+        type: 'must be an instance of {{type}}'
     },
     number: {
         base: 'must be a 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}}',
         float: 'must be a float or double',
         integer: 'must be an integer',
         negative: 'must be a negative number',
-        positive: 'must be a positive number'
+        positive: 'must be a positive number',
+        precision: 'must have no more than {{limit}} decimal places'
     },
     string: {
         base: 'must be a string',
@@ -78,13 +85,17 @@ exports.errors = {
         length: 'length must be {{limit}} characters long',
         alphanum: 'must only contain alpha-numeric characters',
         token: 'must only contain alpha-numeric and underscore characters',
-        regex: 'fails to match the required pattern',
+        regex: {
+            base: 'fails to match the required pattern',
+            name: 'fails to match the {{name}} pattern'
+        },
         email: 'must be a valid email',
         isoDate: 'must be a valid ISO 8601 date',
         guid: 'must be a valid GUID',
         hostname: 'must be a valid hostname',
         lowercase: 'must only contain lowercase characters',
         uppercase: 'must only contain uppercase characters',
-        trim: 'must not have leading or trailing whitespace'
+        trim: 'must not have leading or trailing whitespace',
+        creditCard: 'must be a credit card'
     }
 };

package/lib/number.js

@@ -68,6 +68,36 @@ internals.Number.prototype.max = function (limit) {
 };
 
 
+internals.Number.prototype.greater = function (limit) {
+
+    Hoek.assert(Hoek.isInteger(limit), 'limit must be an integer');
+
+    return this._test('greater', limit, function (value, state, options) {
+
+        if (value > limit) {
+            return null;
+        }
+
+        return Errors.create('number.greater', { limit: limit }, state, options);
+    });
+};
+
+
+internals.Number.prototype.less = function (limit) {
+
+    Hoek.assert(Hoek.isInteger(limit), 'limit must be an integer');
+
+    return this._test('less', limit, function (value, state, options) {
+
+        if (value < limit) {
+            return null;
+        }
+
+        return Errors.create('number.less', { limit: limit }, state, options);
+    });
+};
+
+
 internals.Number.prototype.integer = function () {
 
     return this._test('integer', undefined, function (value, state, options) {
@@ -103,4 +133,24 @@ internals.Number.prototype.positive = function () {
 };
 
 
+internals.precisionRx = /(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/;
+
+
+internals.Number.prototype.precision = function (limit) {
+
+    Hoek.assert(Hoek.isInteger(limit), 'limit must be an integer');
+
+    return this._test('precision', limit, function (value, state, options){
+
+        var places = value.toString().match(internals.precisionRx);
+        var decimals = Math.max((places[1] ? places[1].length : 0) - (places[2] ? parseInt(places[2], 10) : 0), 0);
+        if (decimals <= limit) {
+            return null;
+        }
+
+        return Errors.create('number.precision', {limit: limit}, state, options);
+    });
+};
+
+
 module.exports = new internals.Number();

package/lib/object.js

@@ -55,11 +55,21 @@ internals.Object.prototype._base = function (value, state, options) {
         return finish();
     }
 
+    // Skip if there are no other rules to test
+
+    if (!this._inner.renames.length &&
+        !this._inner.dependencies.length &&
+        !this._inner.children &&                    // null allows any keys
+        !this._inner.patterns.length) {
+
+        target = value;
+        return finish();
+    }
+
     // Ensure target is a local copy (parsed) or shallow copy
 
     if (target === value) {
-        target = {};
-        target.__proto__ = Object.getPrototypeOf(value);
+        target = Object.create(Object.getPrototypeOf(value));
         var valueKeys = Object.keys(value);
         for (var t = 0, tl = valueKeys.length; t < tl; ++t) {
             target[valueKeys[t]] = value[valueKeys[t]];
@@ -320,13 +330,15 @@ internals.Object.prototype.max = function (limit) {
 };
 
 
-internals.Object.prototype.pattern = function (regex, schema) {
+internals.Object.prototype.pattern = function (pattern, schema) {
 
-    Hoek.assert(regex instanceof RegExp, 'Invalid regular expression');
+    Hoek.assert(pattern instanceof RegExp, 'Invalid regular expression');
     Hoek.assert(schema !== undefined, 'Invalid rule');
 
+    pattern = new RegExp(pattern.source, pattern.ignoreCase ? 'i' : undefined);         // Future version should break this and forbid unsupported regex flags
+
     var obj = this.clone();
-    obj._inner.patterns.push({ regex: regex, rule: Cast.schema(schema) });
+    obj._inner.patterns.push({ regex: pattern, rule: Cast.schema(schema) });
     return obj;
 };
 
@@ -364,6 +376,13 @@ internals.Object.prototype.and = function () {
 };
 
 
+internals.Object.prototype.nand = function () {
+
+    var peers = Hoek.flatten(Array.prototype.slice.call(arguments));
+    return this._dependency('nand', null, peers);
+};
+
+
 internals.renameDefaults = {
     alias: false,                   // Keep old value in place
     multiple: false,                // Allow renaming multiple keys into the same target
@@ -504,6 +523,25 @@ internals.and = function (value, peers, parent, state, options) {
 };
 
 
+internals.nand = function (value, peers, parent, state, options) {
+
+    var present = [];
+    for (var i = 0, il = peers.length; i < il; ++i) {
+        var peer = peers[i];
+        if (parent.hasOwnProperty(peer) &&
+            parent[peer] !== undefined) {
+
+            present.push(peer);
+        }
+    }
+
+    var values = Hoek.clone(peers);
+    var main = values.splice(0,1);
+    var allPresent = (present.length === peers.length);
+    return allPresent ? Errors.create('object.nand', { main: main, peers: values }, state, options) : null;
+};
+
+
 internals.Object.prototype.describe = function (shallow) {
 
     var description = Any.prototype.describe.call(this);
@@ -522,6 +560,15 @@ internals.Object.prototype.describe = function (shallow) {
         description.dependencies = Hoek.clone(this._inner.dependencies);
     }
 
+    if (this._inner.patterns.length) {
+        description.patterns = [];
+
+        for (var p = 0, pl = this._inner.patterns.length; p < pl; ++p) {
+            var pattern = this._inner.patterns[p];
+            description.patterns.push({ regex: pattern.regex.toString(), rule: pattern.rule.describe() });
+        }
+    }
+
     return description;
 };
 
@@ -530,6 +577,7 @@ internals.Object.prototype.assert = function (ref, schema, message) {
 
     ref = Cast.ref(ref);
     Hoek.assert(ref.isContext || ref.depth > 1, 'Cannot use assertions for root level references - use direct key rules instead');
+    message = message || 'pass the assertion test';
 
     var cast = Cast.schema(schema);
 
@@ -545,4 +593,20 @@ internals.Object.prototype.assert = function (ref, schema, message) {
 };
 
 
+internals.Object.prototype.type = function (constructor, name) {
+
+    Hoek.assert(typeof constructor === 'function', 'type must be a constructor function');
+    name = name || constructor.name;
+
+    return this._test('type', name, function (value, state, options) {
+
+        if (value instanceof constructor) {
+            return null;
+        }
+
+        return Errors.create('object.type', { type: name }, state, options);
+    });
+};
+
+
 module.exports = new internals.Object();

package/lib/string.js

@@ -4,9 +4,9 @@ var Net = require('net');
 var Hoek = require('hoek');
 var Isemail = require('isemail');
 var Any = require('./any');
+var JoiDate = require('./date');
 var Errors = require('./errors');
 
-
 // Declare internals
 
 var internals = {};
@@ -85,6 +85,27 @@ internals.String.prototype.max = function (limit, encoding) {
 };
 
 
+internals.String.prototype.creditCard = function () {
+
+    return this._test('creditCard', undefined, function (value, state, options) {
+
+        var i = value.length;
+        var sum = 0;
+        var mul = 1;
+        var char;
+
+        while (i--) {
+            char = value.charAt(i) * mul;
+            sum += char - (char > 9) * 9;
+            mul ^= 3;
+        }
+
+        var check =  (sum % 10 === 0) && (sum > 0);
+        return check ? null : Errors.create('string.creditCard', null, state, options);
+    });
+};
+
+
 internals.String.prototype.length = function (limit, encoding) {
 
     Hoek.assert(Hoek.isInteger(limit) && limit >= 0, 'limit must be a positive integer');
@@ -102,17 +123,19 @@ internals.String.prototype.length = function (limit, encoding) {
 };
 
 
-internals.String.prototype.regex = function (pattern) {
+internals.String.prototype.regex = function (pattern, name) {
 
     Hoek.assert(pattern instanceof RegExp, 'pattern must be a RegExp');
 
+    pattern = new RegExp(pattern.source, pattern.ignoreCase ? 'i' : undefined);         // Future version should break this and forbid unsupported regex flags
+
     return this._test('regex', pattern, function (value, state, options) {
 
         if (pattern.test(value)) {
             return null;
         }
 
-        return Errors.create('string.regex', null, state, options);
+        return Errors.create((name ? 'string.regex.name' : 'string.regex.base'), { name: name }, state, options);
     });
 };
 
@@ -158,11 +181,9 @@ internals.String.prototype.email = function () {
 
 internals.String.prototype.isoDate = function () {
 
-    var regex = /^(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))$/;
-
     return this._test('isoDate', undefined, function (value, state, options) {
 
-        if (regex.test(value)) {
+        if (JoiDate._isIsoDate(value)) {
             return null;
         }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "joi",
   "description": "Object schema validation",
-  "version": "4.6.2",
+  "version": "4.9.0",
   "repository": "git://github.com/hapijs/joi",
   "main": "index",
   "keywords": [
@@ -14,10 +14,12 @@
   "dependencies": {
     "hoek": "^2.2.x",
     "topo": "1.x.x",
-    "isemail": "1.x.x"
+    "isemail": "1.x.x",
+    "moment": "2.x.x"
   },
   "devDependencies": {
-    "lab": "3.x.x"
+    "code": "1.x.x",
+    "lab": "5.x.x"
   },
   "scripts": {
     "test": "make test-cov"

package/test/alternatives.js

@@ -1,6 +1,7 @@
 // Load modules
 
 var Lab = require('lab');
+var Code = require('code');
 var Joi = require('..');
 var Helper = require('./helper');
 
@@ -12,11 +13,12 @@ var internals = {};
 
 // Test shortcuts
 
-var expect = Lab.expect;
-var before = Lab.before;
-var after = Lab.after;
-var describe = Lab.experiment;
-var it = Lab.test;
+var lab = exports.lab = Lab.script();
+var before = lab.before;
+var after = lab.after;
+var describe = lab.describe;
+var it = lab.it;
+var expect = Code.expect;
 
 
 describe('alternatives', function () {
@@ -25,7 +27,7 @@ describe('alternatives', function () {
 
         Joi.alternatives().validate('a', function (err, value) {
 
-            expect(err).to.exist;
+            expect(err).to.exist();
             expect(err.message).to.equal('value not matching any of the allowed alternatives');
             done();
         });
@@ -35,7 +37,7 @@ describe('alternatives', function () {
 
         Joi.alternatives().validate(undefined, function (err, value) {
 
-            expect(err).to.not.exist;
+            expect(err).to.not.exist();
             done();
         });
     });
@@ -51,7 +53,7 @@ describe('alternatives', function () {
 
         schema.validate({ a: '5' }, function (err, value) {
 
-            expect(err).to.not.exist;
+            expect(err).to.not.exist();
             expect(value.a).to.equal(5);
             done();
         });
@@ -68,7 +70,7 @@ describe('alternatives', function () {
 
         schema.validate({ a: '5' }, function (err, value) {
 
-            expect(err).to.not.exist;
+            expect(err).to.not.exist();
             expect(value.a).to.equal(5);
             done();
         });
@@ -86,7 +88,7 @@ describe('alternatives', function () {
         var input = { a: { b: 'any', d: 'string' } };
         schema.validate(input, function (err, value) {
 
-            expect(err).to.not.exist;
+            expect(err).to.not.exist();
             expect(value.a.b).to.equal('any');
             done();
         });