add sort order to validations

fixes #48

Author: jquense

src/array.js

@@ -72,7 +72,7 @@ inherits(ArraySchema, MixedSchema, {
           return value
         }
 
-        let result = value.map((item, key) => {
+        let validations = value.map((item, key) => {
           var path  = (options.path || '') + '[' + key + ']'
 
           // object._validate note for isStrict explanation
@@ -84,11 +84,11 @@ inherits(ArraySchema, MixedSchema, {
           return true
         })
 
-        result = endEarly
-          ? Promise.all(result).catch(scopeError(value))
-          : collectErrors(result, value, options.path, errors)
+        validations = endEarly
+          ? Promise.all(validations).catch(scopeError(value))
+          : collectErrors({ validations, value, errors, path: options.path })
 
-        return result.then(() => value)
+        return validations.then(() => value)
       })
   },
 

src/mixed.js

@@ -16,14 +16,17 @@ let notEmpty = value => !isAbsent(value);
 function runValidations(validations, endEarly, value, path) {
   return endEarly
     ? Promise.all(validations)
-    : _.collectErrors(validations, value, path)
+    : _.collectErrors({ validations, value, path })
 }
 
 function extractTestParams(name, message, test, useCallback) {
   var opts = name;
 
   if (typeof message === 'function')
-    test = message, message = locale.default;
+    test = message, message = locale.default, name = null;
+
+  if (typeof name === 'function')
+    test = name, message = locale.default, name = null;
 
   if (typeof name === 'string' || name === null)
     opts = { name, test, message, useCallback, exclusive: false }

src/object.js

@@ -6,6 +6,7 @@ var MixedSchema = require('./mixed')
   , split = require('property-expr').split
   , Ref = require('./util/reference')
   , c = require('case')
+  , sortByFields = require('./util/sortByFields')
   , {
     isObject
   , transform
@@ -21,12 +22,12 @@ c.type('altCamel', function(str) {
   return idx === 0 ? result : (str.substr(0, idx) + result)
 })
 
-
 let scopeError = value => err => {
       err.value = value
       throw err
     }
 
+
 module.exports = ObjectSchema
 
 function ObjectSchema(spec) {
@@ -135,7 +136,7 @@ inherits(ObjectSchema, MixedSchema, {
           return value
         }
 
-        let result = this._nodes.map((key) => {
+        let validations = this._nodes.map((key) => {
           var path  = (opts.path ?  (opts.path + '.') : '') + key
             , field = this.fields[key]
             , innerOptions = { ...opts, key, path, parent: value };
@@ -153,11 +154,14 @@ inherits(ObjectSchema, MixedSchema, {
           return true
         })
 
-        result = endEarly
-          ? Promise.all(result).catch(scopeError(value))
-          : collectErrors(result, value, opts.path, errors)
+        validations = endEarly
+          ? Promise.all(validations).catch(scopeError(value))
+          : collectErrors({ validations, value, errors,
+              path: opts.path,
+              sort: sortByFields(this)
+            })
 
-        return result.then(() => value)
+        return validations.then(() => value)
       })
   },
 

src/util/_.js

@@ -19,16 +19,21 @@ function settled(promises){
   return Promise.all(promises.map(settle))
 }
 
-function collectErrors(promises, value, path, errors = []){
+function collectErrors({ validations, value, path, errors = [], sort }){
   // unwrap aggregate errors
   errors = errors.inner && errors.inner.length
     ? errors.inner : [].concat(errors)
 
-  return settled(promises).then( results => {
-    errors = results.reduce(
-      (arr, r) => !r.fulfilled ? arr.concat(r.value) : arr, errors)
+  return settled(validations).then(results => {
+    let nestedErrors = results
+      .filter(r => !r.fulfilled)
+      .reduce((arr, r) => arr.concat(r.value), [])
 
-    if ( errors.length )
+    if (sort) nestedErrors.sort(sort)
+    //show parent errors after the nested ones: name.first, name
+    errors = nestedErrors.concat(errors)
+
+    if (errors.length)
       throw new ValidationError(errors, value, path)
   })
 }

src/util/sortByFields.js

@@ -0,0 +1,20 @@
+
+
+function findIndex(arr, err) {
+  let idx = Infinity;
+  arr.some((key, ii) => {
+    if (err.path.indexOf(key) !== -1) {
+      idx = ii
+      return true
+    }
+  });
+
+  return idx
+}
+
+module.exports = function sortByFields(schema) {
+  let keys = Object.keys(schema.fields);
+  return (a, b) => {
+    return findIndex(keys, a) - findIndex(keys, b)
+  }
+}

test/array.js

@@ -138,7 +138,7 @@ describe('Array types', function(){
           err.value.should.eql([{ str: '' }])
 
           err.errors.length.should.equal(2)
-          err.errors.should.eql(['oops', '[0].str is a required field'])
+          err.errors.should.eql(['[0].str is a required field', 'oops' ])
         })
     ])
   })

test/object.js

@@ -482,11 +482,28 @@ describe('Object types', function(){
         .then(function(err) {
           err.value.should.eql({ nest: { str: '' } })
           err.errors.length.should.equal(2)
-          err.errors.should.eql(['oops', 'nest.str is a required field'])
+          err.errors.should.eql(['nest.str is a required field', 'oops'])
         })
     ])
   })
 
+  it('should sort errors by insertion order', async () => {
+    var inst = object({
+      foo: string().test('foo', function() {
+        return new Promise(resolve => setTimeout(() => resolve(false), 10))
+      }),
+      bar: string().required()
+    })
+
+    let err = await inst.validate(
+      { foo: 'foo', bar: null },
+      { abortEarly: false }).should.rejected;
+
+    err.errors.should.eql([
+      'foo is invalid',
+      'bar is a required field'
+    ])
+  })
 
   it('should respect recursive', function(){
     var inst = object({