monastery 1.27.2 → 1.28.2

package/docs/readme.md

@@ -71,6 +71,12 @@ $ DEBUG=monastery:info
 $ DEBUG=monastery:*
 ```
 
+To run isolated tests with Jest:
+
+```bash
+npm run dev -- -t 'Model indexes'
+```
+
 ## Contributing
 
 Coming soon...

package/docs/schema.md

@@ -173,13 +173,13 @@ You are able to define custom validation rules to use. (`this` will refer to the
 ```js
 schema.rules = {
   // Basic definition
-  isGrandMaster: function(value, ruleArgument, fieldName, model) {
+  isGrandMaster: function(value, ruleArgument, path, model) {
     return (value == 'Martin Luther')? true : false
   },
   // Full definition
   isGrandMaster: {
-    message: (value, ruleArgument, fieldName, model) => 'Only grand masters are permitted'
-    fn: function(value, ruleArgument, fieldName, model) {
+    message: (value, ruleArgument, path, model) => 'Only grand masters are permitted'
+    fn: function(value, ruleArgument, path, model) {
       return (value == 'Martin Luther' || this.age > 100)? true : false
     }
   }
@@ -209,17 +209,39 @@ You are able to define custom error messages for each validation rule.
 
 ```js
 schema.messages = {
-  "name": {
+  'name': {
     required: 'Sorry, even a monk cannot be nameless'
-    type: 'Sorry, your name needs to be a string, like it is so'
+    type: 'Sorry, your name needs to be a string'
   },
-  "address.city": {
-    minLength: (value, ruleArgument, fieldName, model) => {
+  'address.city': {
+    minLength: (value, ruleArgument, path, model) => {
       return `Is your city of residence really only ${ruleArgument} characters long?`
     }
   },
-  "pets.[].name": {
-    required: `Your pet's name needs to be a string, like it is so.`
+  // You can assign custom error messages for all subdocument fields in an array
+  // e.g. pets = [{ name: { type: 'string' }}]
+  'pets.name': {
+    required: `Your pet's name needs to be a string.`
+  }
+  // To target a specific array item
+  'pets.0.name': {
+    required: `You first pet needs a name`
+  }
+  // You can also target any rules set on the array or sub arrays
+  // e.g.
+  // let arrayWithSchema = (array, schema) => { array.schema = schema; return array }
+  // petGroups = arrayWithSchema(
+  //   [arrayWithSchema(
+  //     [{ name: { type: 'string' }}],
+  //     { minLength: 1 }
+  //   )],
+  //   { minLength: 1 }
+  // )
+  'petGroups': {
+    minLength: `Please add at least one pet pet group.`
+  }
+  'petGroups.$': {
+    minLength: `Please add at least one pet into your pet group.`
   }
 }
 ```
@@ -265,7 +287,7 @@ let schema = {
 
   afterFind: [function(data) {// Synchronous
     data = data || {}
-    data.name = data.firstName + " " + data.lastName
+    data.name = data.firstName + ' ' + data.lastName
   }]
 }
 

package/lib/model-validate.js

@@ -85,6 +85,34 @@ module.exports = {
     })
   },
 
+  _getMostSpecificKeyMatchingPath: function(object, path) {
+    /**
+     * Get all possible array variation matches from the object, and return the most specifc key
+     * @param {object} object - e.g. { 'pets.1.name', 'pets.$.name', 'pets.name', .. }
+     * @path  {string} path - must be a specifc path, e.g. 'pets.1.name'
+     * @return most specific key in object
+     *
+     * 1. Get all viable messages keys, e.g. (key)dogs.$ == (path)dogs.1
+     * 2. Order array key list by scoring, i.e. [0-9]=2, $=1, ''=0
+     * 3. Return first
+     */
+    let keys = []
+    let pathExpand = path.replace(/\.([0-9]+)/g, '(.$1|.\\$|)').replace(/\./g, '\\.')
+    let pathreg = new RegExp(`^${pathExpand}$`)
+
+    for (let key in object) {
+      if (key.match(pathreg)) {
+        let score = (key.match(/\.[0-9]+/g)||[]).length * 1001
+        score += (key.match(/\.\$/g)||[]).length * 1000
+        keys.push({ score: score, key: key })
+      }
+    }
+
+    if (!keys.length) return
+    else if (keys.length == 1) return keys[0].key
+    return keys.sort((a, b) => a.score - b.score).reverse()[0].key // descending
+  },
+
   _validateFields: function(dataRoot, fields, data, opts, path) {
     /**
      * Recurse through and retrieve any errors and valid data
@@ -223,17 +251,18 @@ module.exports = {
 
   _validateRule: function(dataRoot, ruleName, field, ruleArg, value, path) {
     //this.debug(path, field, ruleName, ruleArg, value)
-    path = path.replace(/^\./, '[]')
+    // Remove [] from the message path, and simply ignore non-numeric children to test for all array items
     ruleArg = ruleArg === true? undefined : ruleArg
     let rule = this.rules[ruleName] || rules[ruleName]
     let fieldName = path.match(/[^\.]+$/)[0]
-    let ruleMessagePath = path.replace(/\.[0-9]+(\.|$)/g, '.[]$1')
-    let ruleMessage = this.messages[ruleMessagePath] && this.messages[ruleMessagePath][ruleName]
+    let ruleMessageKey = this._getMostSpecificKeyMatchingPath(this.messages, path)
+    let ruleMessage = ruleMessageKey && this.messages[ruleMessageKey][ruleName]
     if (!ruleMessage) ruleMessage = rule.message
 
+
     if (ruleName !== 'required') {
       // Ignore undefined when not testing 'required'
-      if (typeof value === 'undefined') return
+      if (typeof value === 'undefined') return ////////////////////////////////////////
 
       // Ignore null if not testing required
       if (value === null && !field.isObject && !field.isArray) return
@@ -246,9 +275,9 @@ module.exports = {
     if (value === '' && rule.ignoreEmptyString) return
 
     // Rule failed
-    if (!rule.fn.call(dataRoot, value, ruleArg, fieldName, this)) return {
+    if (!rule.fn.call(dataRoot, value, ruleArg, path, this)) return {
       detail: util.isFunction(ruleMessage)
-        ? ruleMessage.call(dataRoot, value, ruleArg, fieldName, this)
+        ? ruleMessage.call(dataRoot, value, ruleArg, path, this)
         : ruleMessage,
       meta: { rule: ruleName, model: this.name, field: fieldName, detailLong: rule.messageLong },
       status: '400',

package/lib/model.js

@@ -6,10 +6,11 @@ let validate = require('./model-validate')
 let Model = module.exports = function(name, opts, manager) {
   /**
    * Setup a model (aka monk collection)
-   * Todo: convert into a promise
    * @param {string} name
    * @param {object} opts - see mongodb colleciton documentation
-   * @this Model
+   * @param {boolean} opts.waitForIndexes
+   * @this model
+   * @return Promise(model) | this
    */
   if (!(this instanceof Model)) {
     return new Model(name, opts, this)
@@ -25,10 +26,6 @@ let Model = module.exports = function(name, opts, manager) {
   opts = opts || {}
   Object.assign(this, {
     ...(opts.methods || {}),
-    name: name,
-    manager: manager,
-    error: manager.error,
-    info: manager.info,
     afterFind: opts.afterFind || [],
     afterInsert: (opts.afterInsert || []).concat(opts.afterInsertUpdate || []),
     afterUpdate: (opts.afterUpdate || []).concat(opts.afterInsertUpdate || []),
@@ -37,12 +34,16 @@ let Model = module.exports = function(name, opts, manager) {
     beforeUpdate: (opts.beforeUpdate || []).concat(opts.beforeInsertUpdate || []),
     beforeRemove: opts.beforeRemove || [],
     beforeValidate: opts.beforeValidate || [],
-    findBL: opts.findBL || ['password'],
+    error: manager.error,
+    info: manager.info,
     insertBL: opts.insertBL || [],
-    updateBL: opts.updateBL || [],
-    messages: opts.messages || {},
     fields: { ...(util.deepCopy(opts.fields) || {}) },
-    rules: { ...(opts.rules || {}) }
+    findBL: opts.findBL || ['password'],
+    manager: manager,
+    messages: opts.messages || {},
+    name: name,
+    rules: { ...(opts.rules || {}) },
+    updateBL: opts.updateBL || [],
   })
 
   // Run before model hooks
@@ -94,13 +95,13 @@ let Model = module.exports = function(name, opts, manager) {
   // Add model to manager.model
   this.manager.model[name] = this
 
-  // Ensure field indexes exist in mongodb
+  // Setup/Ensure field indexes exist in MongoDB
   let errHandler = err => {
     if (err.type == 'info') this.info(err.detail)
     else this.error(err)
   }
-  if (opts.promise) return this._setupIndexes().catch(errHandler)
-  else this._setupIndexes().catch(errHandler)
+  if (opts.waitForIndexes) return this._setupIndexes().catch(errHandler).then(() => this)
+  else this._setupIndexes().catch(errHandler) // returns this
 }
 
 Model.prototype._getFieldlist = function(fields, path) {
@@ -243,7 +244,7 @@ Model.prototype._setupIndexes = function(fields) {
    * @link https://docs.mongodb.com/manual/reference/command/createIndexes/
    * @link https://mongodb.github.io/node-mongodb-native/2.1/api/Collection.html#createIndexes
    * @param {object} <fields>
-   * @return Promise( {array} indexes | {string} error )
+   * @return Promise( {array} indexes ensured | {string} error )
    *
    * MongoDB index structures = [
    *   true =     { name: 'name_1', key: { name: 1 } },
@@ -267,6 +268,7 @@ Model.prototype._setupIndexes = function(fields) {
 
   // Find all indexes
   recurseFields(fields || model.fields, '')
+  // console.log(2, indexes, fields)
   if (hasTextIndex) indexes.push(textIndex)
   if (!indexes.length) return Promise.resolve([]) // No indexes defined
 
@@ -313,6 +315,7 @@ Model.prototype._setupIndexes = function(fields) {
     })
     .then(response => {
       model.info('db index(s) created for ' + model.name)
+      return indexes
     })
 
   function recurseFields(fields, parentPath) {

package/lib/rules.js

@@ -5,6 +5,7 @@ let validator = require('validator')
 module.exports = {
 
   required: {
+    runOnUndefined: true, // integrate
     message: 'This field is required.',
     fn: function(x) {
       if (util.isArray(x) && !x.length) return false
@@ -12,7 +13,7 @@ module.exports = {
     }
   },
 
-  // Rules below ignore null
+  // Type rules below ignore undefined
 
   'isBoolean': {
     message: 'Value was not a boolean.',
@@ -25,12 +26,6 @@ module.exports = {
       return typeof x === 'boolean'
     }
   },
-  'isNotEmptyString': {
-    message: 'Value was an empty string.',
-    fn: function(x) {
-      return x !== ''
-    }
-  },
   'isArray': {
     message: 'Value was not an array.',
     tryParse: function(x) {
@@ -74,8 +69,8 @@ module.exports = {
   'isInteger': {
     message: 'Value was not an integer.',
     tryParse: function(x) {
-      if (util.isString(x) && x.match(/^[\+-]?[0-9]+$/)) return x // keep string nums intact
-      return isNaN(parseInt(x)) || x===true || x===false || x===''? x : parseInt(x)
+      if (util.isString(x) && x.match(/^[\+-][0-9]+$/)) return x // keep string nums intact
+      return isNaN(parseInt(x)) || (!x && x!==0) || x===true? x : parseInt(x)
     },
     fn: function(x) {
       if (util.isString(x) && x.match(/^[\+-]?[0-9]+$/)) return true
@@ -86,7 +81,7 @@ module.exports = {
     message: 'Value was not a number.',
     tryParse: function(x) {
       if (util.isString(x) && x.match(/^[\+-][0-9]+$/)) return x // keep string nums intact
-      return isNaN(Number(x)) || x===true || x===false || x===''? x : Number(x)
+      return isNaN(Number(x)) || (!x && x!==0) || x===true? x : Number(x)
     },
     fn: function(x) {
       if (util.isString(x) && x.match(/^[\+-][0-9]+$/)) return true
@@ -132,6 +127,8 @@ module.exports = {
       return util.isObject(x) && ObjectId.isValid(x)/*x.get_inc*/? true : false
     }
   },
+
+
   'max': {
     message: (x, arg) => 'Value was greater than the configured maximum (' + arg + ')',
     fn: function(x, arg) {
@@ -146,8 +143,16 @@ module.exports = {
       return x >= arg
     }
   },
+  'isNotEmptyString': {
+    message: 'Value was an empty string.',
+    fn: function(x) {
+      return x !== ''
+    }
+  },
+
+  // Rules below ignore undefined & empty strings
+  // (e.g. an empty email field can be saved that isn't required)
 
-  // Rules below ignore null & empty strings
   'enum': {
     ignoreEmptyString: true,
     message: (x, arg) => 'Invalid enum value',
@@ -157,10 +162,10 @@ module.exports = {
       }
     }
   },
-  'hasAgreed': {
-    message: (x, arg) => 'Please agree to the terms and conditions.',
-    fn: function(x, arg) { return !x }
-  },
+  // 'hasAgreed': {
+  //   message: (x, arg) => 'Please agree to the terms and conditions.',
+  //   fn: function(x, arg) { return !x }
+  // },
   'isAfter': {
     ignoreEmptyString: true,
     message: (x, arg) => 'Value was before the configured time (' + arg + ')',

package/package.json

@@ -2,7 +2,7 @@
   "name": "monastery",
   "description": "⛪ A straight forward MongoDB ODM built around Monk",
   "author": "Ricky Boyce",
-  "version": "1.27.2",
+  "version": "1.28.2",
   "license": "MIT",
   "repository": "github:boycce/monastery",
   "homepage": "https://boycce.github.io/monastery/",

package/test/model.js

@@ -116,27 +116,76 @@ module.exports = function(monastery, opendb) {
   })
 
   test('Model indexes', async (done) => {
-    // Setup
     // Need to test different types of indexes
     let db = (await opendb(null)).db
-    let user = db.model('user', {})
-    let user2 = db.model('user2', {})
 
-    // Text index setup
-    let setupIndex1 = await user._setupIndexes({
-      name: { type: 'string', index: 'text' }
+    // Drop previously tested collections
+    if ((await db._db.listCollections().toArray()).find(o => o.name == 'userIndexRaw')) {
+      await db._db.collection('userIndexRaw').drop()
+    }
+    if ((await db._db.listCollections().toArray()).find(o => o.name == 'userIndex')) {
+      await db._db.collection('userIndex').drop()
+    }
+
+    // Unique & text index (after model initialisation, in serial)
+    let userIndexRawModel = db.model('userIndexRaw', {})
+    let setupIndex1 = await userIndexRawModel._setupIndexes({
+      email: { type: 'string', index: 'unique' },
+    })
+    let setupIndex2 = await userIndexRawModel._setupIndexes({
+      name: { type: 'string', index: 'text' },
+    })
+    let indexes = await db._db.collection('userIndexRaw').indexes()
+    expect(indexes[0]).toMatchObject({ v: 2, key: { _id: 1 }, name: '_id_' })
+    expect(indexes[1]).toMatchObject({ v: 2, unique: true, key: { email: 1 }, name: 'email_1' })
+    expect(indexes[2]).toMatchObject({
+      v: 2,
+      key: { _fts: 'text', _ftsx: 1 },
+      name: 'text',
+      weights: { name: 1 },
+      default_language: 'english',
+      language_override: 'language',
+      textIndexVersion: 3
+    })
+
+    // Unique & text index
+    let userIndexModel = await db.model('userIndex', {
+      waitForIndexes: true,
+      fields: {
+        email: { type: 'string', index: 'unique' },
+        name: { type: 'string', index: 'text' },
+      }
+    })
+
+    let indexes2 = await db._db.collection('userIndex').indexes()
+    expect(indexes2[0]).toMatchObject({ v: 2, key: { _id: 1 }, name: '_id_' })
+    expect(indexes2[1]).toMatchObject({ v: 2, unique: true, key: { email: 1 }, name: 'email_1' })
+    expect(indexes2[2]).toMatchObject({
+      v: 2,
+      key: { _fts: 'text', _ftsx: 1 },
+      name: 'text',
+      weights: { name: 1 },
+      default_language: 'english',
+      language_override: 'language',
+      textIndexVersion: 3
     })
 
     // No text index change error, i.e. new Error("Index with name: text already exists with different options")
-    await expect(user._setupIndexes({
+    await expect(userIndexModel._setupIndexes({
       name: { type: 'string', index: 'text' },
       name2: { type: 'string', index: 'text' }
-    })).resolves.toEqual(undefined)
+    })).resolves.toEqual([{
+      "key": { "name": "text", "name2": "text" },
+      "name": "text",
+    }])
 
     // Text index on a different model
-    await expect(user2._setupIndexes({
-      name: { type: 'string', index: 'text' }
-    })).resolves.toEqual(undefined)
+    await expect(userIndexRawModel._setupIndexes({
+      name2: { type: 'string', index: 'text' }
+    })).resolves.toEqual([{
+      "key": {"name2": "text"},
+      "name": "text",
+    }])
 
     db.close()
     done()
@@ -147,7 +196,7 @@ module.exports = function(monastery, opendb) {
     // with text indexes are setup at the same time
     let db = (await opendb(null)).db
     await db.model('user3', {
-      promise: true,
+      waitForIndexes: true,
       fields: {
         location: {
           index: '2dsphere',

package/test/validate.js

@@ -1,3 +1,5 @@
+let validate = require('../lib/model-validate')
+
 module.exports = function(monastery, opendb) {
 
   test('Validation basic errors', async () => {
@@ -227,7 +229,40 @@ module.exports = function(monastery, opendb) {
       .rejects.toContainEqual(error)
   })
 
-  test('Validation messages', async () => {
+  test('Validation getMostSpecificKeyMatchingPath', async () => {
+    let fn = validate._getMostSpecificKeyMatchingPath
+    let mock = {
+      'cats.name': true,
+      'cats.name': true,
+
+      'dogs.name': true,
+      'dogs.$.name': true,
+
+      'pigs.name': true,
+      'pigs.$.name': true,
+      'pigs.1.name': true,
+      'pigs.2.name': true,
+
+      'gulls.$': true,
+      'gulls.$.$': true,
+      'gulls.name': true,
+      'gulls.$.name': true,
+    }
+    // subdocument
+    expect(fn(mock, 'cats.name')).toEqual('cats.name')
+    // array subdocuments
+    expect(fn(mock, 'cats.1.name')).toEqual('cats.name')
+    expect(fn(mock, 'dogs.1.name')).toEqual('dogs.$.name')
+    expect(fn(mock, 'dogs.2.name')).toEqual('dogs.$.name')
+    expect(fn(mock, 'pigs.1.name')).toEqual('pigs.1.name')
+    expect(fn(mock, 'pigs.2.name')).toEqual('pigs.2.name')
+    expect(fn(mock, 'pigs.3.name')).toEqual('pigs.$.name')
+    // array
+    expect(fn(mock, 'gulls.1.2')).toEqual('gulls.$.$')
+    expect(fn(mock, 'gulls.1')).toEqual('gulls.$')
+  })
+
+  test('Validation default messages', async () => {
     // Setup
     let db = (await opendb(false)).db
     let user = db.model('user', {
@@ -238,66 +273,236 @@ module.exports = function(monastery, opendb) {
         animals: [{
           name: { type: 'string', minLength: 4 }
         }]
+      }
+    })
+
+    let mock = {
+      status: '400',
+      title: 'name',
+      detail: 'Value needs to be at least 4 characters long.',
+      meta: { rule: 'minLength', model: 'user', field: 'name' }
+    }
+
+    // basic error
+    await expect(user.validate({ name: 'ben' })).rejects.toContainEqual(
+      mock
+    )
+
+    // subdocument error
+    await expect(user.validate({ dog: { name: 'ben' } })).rejects.toContainEqual({
+      ...mock,
+      title: 'dog.name'
+    })
+
+    // array error
+    await expect(user.validate({ dogNames: ['ben'] })).rejects.toContainEqual({
+      ...mock,
+      title: 'dogNames.0',
+      meta: { ...mock.meta, field: '0' }
+    })
+
+    // subdocument in an array error
+    await expect(user.validate({ animals: [{ name: 'ben' }] })).rejects.toContainEqual({
+      ...mock,
+      title: 'animals.0.name'
+    })
+
+    // subdocument in an array error (different index)
+    await expect(user.validate({ animals: [{ name: 'carla' }, { name: 'ben' }] })).rejects.toContainEqual({
+      ...mock,
+      title: 'animals.1.name'
+    })
+  })
+
+  test('Validation custom messages', async () => {
+    // Setup
+    // Todo: Setup testing for array array subdocument field messages
+    let db = (await opendb(false)).db
+    let arrayWithSchema = (array, schema) => { array.schema = schema; return array }
+    let user = db.model('user', {
+      fields: {
+        name: { type: 'string', minLength: 4 },
+        dog: { name: { type: 'string', minLength: 4 }},
+        dogNames: [{ type: 'string', minLength: 4 }],
       },
       messages: {
         'name': { minLength: 'Oops min length is 4' },
         'dog.name': { minLength: 'Oops min length is 4' },
-        'dogNames.[]': { minLength: 'Oops min length is 4' },
-        'animals.[].name': { minLength: 'Oops min length is 4' }
+        'dogNames': { minLength: 'Oops min length is 4' },
       }
     })
 
-    // Basic error
-    await expect(user.validate({
-      name: 'ben'
-    })).rejects.toContainEqual({
+    let mock = {
       status: '400',
       title: 'name',
       detail: 'Oops min length is 4',
       meta: { rule: 'minLength', model: 'user', field: 'name' }
-    })
+    }
 
+    // basic error
+    await expect(user.validate({ name: 'ben' })).rejects.toContainEqual(
+      mock
+    )
     // subdocument error
-    await expect(user.validate({
-      dog: { name: 'ben' }
-    })).rejects.toContainEqual({
-      status: '400',
-      title: 'dog.name',
-      detail: 'Oops min length is 4',
-      meta: { rule: 'minLength', model: 'user', field: 'name' }
+    await expect(user.validate({ dog: { name: 'ben' } })).rejects.toContainEqual({
+      ...mock,
+      title: 'dog.name'
     })
-
     // array error
-    await expect(user.validate({
-      dogNames: ['ben']
-    })).rejects.toContainEqual({
+    await expect(user.validate({ dogNames: ['ben'] })).rejects.toContainEqual({
+      ...mock,
+      title: 'dogNames.0',
+      meta: { ...mock.meta, field: '0' }
+    })
+  })
+
+  test('Validation custom messages for arrays', async () => {
+    // Setup
+    // Todo: Setup testing for array array subdocument field messages
+    let db = (await opendb(false)).db
+    let arrayWithSchema = (array, schema) => { array.schema = schema; return array }
+    let user = db.model('user', {
+      fields: {
+        dogNames: arrayWithSchema([
+          arrayWithSchema([{ type: 'string' }], { minLength: 1 })
+        ], { minLength: 1 }),
+        catNames: [{
+          name: { type: 'string', minLength: 4 }
+        }],
+        pigNames: [[{
+          name: { type: 'string', minLength: 4 },
+        }]],
+      },
+      messages: {
+        'dogNames': { minLength: 'add one dog name' },
+        'dogNames.$': { minLength: 'add one sub dog name' },
+
+        'catNames.name': { minLength: 'min length error (name)' },
+        'catNames.1.name': { minLength: 'min length error (1)' },
+        'catNames.2.name': { minLength: 'min length error (2)' },
+
+        'pigNames.name': { minLength: 'min length error (name)' },
+        'pigNames.$.name': { minLength: 'min length error ($)' },
+        'pigNames.1.name': { minLength: 'min length error (1)' },
+        'pigNames.2.name': { minLength: 'min length error (2)' },
+        'pigNames.0.2.name': { minLength: 'min length error (deep 0 2)' },
+        'pigNames.$.2.name': { minLength: 'min length error (deep $ 2)' },
+      }
+    })
+
+    // Empty array
+    await expect(user.validate({ dogNames: [] })).rejects.toContainEqual({
+      status: '400',
+      title: 'dogNames',
+      detail: 'add one dog name',
+      meta: { rule: 'minLength', model: 'user', field: 'dogNames' }
+    })
+    // Empty sub array
+    await expect(user.validate({ dogNames: [['carla']] })).resolves.toEqual({ dogNames: [['carla']] })
+    await expect(user.validate({ dogNames: [[]] })).rejects.toContainEqual({
       status: '400',
       title: 'dogNames.0',
-      detail: 'Oops min length is 4',
+      detail: 'add one sub dog name',
       meta: { rule: 'minLength', model: 'user', field: '0' }
     })
 
-    // subdocument in an array error
-    await expect(user.validate({
-      animals: [{ name: 'ben' }]
-    })).rejects.toContainEqual({
+
+    // array-subdocument-field error (loose match)
+    await expect(user.validate({ catNames: [{ name: 'ben' }] })).rejects.toContainEqual({
       status: '400',
-      title: 'animals.0.name',
-      detail: 'Oops min length is 4',
+      title: 'catNames.0.name',
+      detail: 'min length error (name)',
+      meta: { rule: 'minLength', model: 'user', field: 'name' }
+    })
+    // array-subdocument-1-field error
+    await expect(user.validate({ catNames: [{ name: 'carla' }, { name: 'ben' }] })).rejects.toContainEqual({
+      status: '400',
+      title: 'catNames.1.name',
+      detail: 'min length error (1)',
+      meta: { rule: 'minLength', model: 'user', field: 'name' }
+    })
+    // array-subdocument-2-field error
+    await expect(user.validate({ catNames: [{ name: 'carla' }, { name: 'carla' }, { name: 'ben' }] })).rejects.toContainEqual({
+      status: '400',
+      title: 'catNames.2.name',
+      detail: 'min length error (2)',
       meta: { rule: 'minLength', model: 'user', field: 'name' }
     })
 
-    // subdocument in an array error (different index)
-    await expect(user.validate({
-      animals: [{ name: 'carla' }, { name: 'ben' }]
-    })).rejects.toContainEqual({
+
+    // array-subdocument-field error (loose $ match)
+    await expect(user.validate({ pigNames: [[{ name: 'ben' }]] })).rejects.toContainEqual({
       status: '400',
-      title: 'animals.1.name',
-      detail: 'Oops min length is 4',
+      title: 'pigNames.0.0.name',
+      detail: 'min length error ($)',
+      meta: { rule: 'minLength', model: 'user', field: 'name' }
+    })
+    // array-subdocument-1-field error
+    await expect(user.validate({ pigNames: [[{ name: 'carla' }, { name: 'ben' }]] })).rejects.toContainEqual({
+      status: '400',
+      title: 'pigNames.0.1.name',
+      detail: 'min length error (1)',
+      meta: { rule: 'minLength', model: 'user', field: 'name' }
+    })
+    // array-subdocument-0-2-field error
+    await expect(user.validate({ pigNames: [[{ name: 'carla' }, { name: 'carla' }, { name: 'ben' }]] })).rejects.toContainEqual({
+      status: '400',
+      title: 'pigNames.0.2.name',
+      detail: 'min length error (deep 0 2)',
+      meta: { rule: 'minLength', model: 'user', field: 'name' }
+    })
+    // array-subdocument-2-0-field error (fallback)
+    await expect(user.validate({ pigNames: [[],[],[{ name: 'carla' },{ name: 'carla' },{ name: 'ben' }]] })).rejects.toContainEqual({
+      status: '400',
+      title: 'pigNames.2.2.name',
+      detail: 'min length error (deep $ 2)',
+      meta: { rule: 'minLength', model: 'user', field: 'name' }
+    })
+    // array-subdocument-2-0-field error (lower fallback)
+    await expect(user.validate({ pigNames: [[],[],[{ name: 'ben' }]] })).rejects.toContainEqual({
+      status: '400',
+      title: 'pigNames.2.0.name',
+      detail: 'min length error (2)',
       meta: { rule: 'minLength', model: 'user', field: 'name' }
     })
   })
 
+  test('Validation custom rules', async () => {
+    // Setup
+    let db = (await opendb(false)).db
+    let user = db.model('user', {
+      fields: {
+        name: { type: 'string', bigName: 8 },
+        animals: [{
+          name: { type: 'string', bigName: 8 }
+        }]
+      },
+      rules: {
+        bigName: function(value, ruleArg) {
+          return value.length >= ruleArg
+        }
+      }
+    })
+
+    // Basic field
+    await expect(user.validate({ name: 'benjamin' })).resolves.toEqual({ name: 'benjamin' })
+    await expect(user.validate({ name: 'ben' })).rejects.toContainEqual({
+      status: '400',
+      title: 'name',
+      detail: 'Invalid data property for rule "bigName".',
+      meta: { rule: 'bigName', model: 'user', field: 'name' }
+    })
+
+    // subdocument in an array
+    await expect(user.validate({ animals: [{ name: 'benjamin' }] })).resolves.toEqual({ animals: [{ name: 'benjamin' }] })
+    await expect(user.validate({ animals: [{ name: 'ben' }] })).rejects.toContainEqual({
+      status: '400',
+      title: 'animals.0.name',
+      detail: 'Invalid data property for rule "bigName".',
+      meta: { rule: 'bigName', model: 'user', field: 'name' }
+    })
+  })
+
   test('Validated data', async () => {
     // Setup
     let db = (await opendb(false)).db
@@ -399,18 +604,20 @@ module.exports = function(monastery, opendb) {
     })
   })
 
-  test('Schema rules', async () => {
+  test('Schema default rules', async () => {
     // Setup
     let db = (await opendb(false)).db
     let user = db.model('user', { fields: {
       name: { type: 'string', minLength: 7 },
       email: { type: 'string', isEmail: true },
-      names: { type: 'string', enum: ['Martin', 'Luther'] }
+      names: { type: 'string', enum: ['Martin', 'Luther'] },
+      amount: { type: 'number' },
     }})
     let user2 = db.model('user', { fields: {
       amount: { type: 'number', required: true },
     }})
 
+
     // MinLength
     await expect(user.validate({ name: 'Martin Luther' })).resolves.toEqual({name: 'Martin Luther'})
     await expect(user.validate({ name: 'Carl' })).rejects.toContainEqual({
@@ -450,18 +657,33 @@ module.exports = function(monastery, opendb) {
       }
     })
 
+    // Number valid
+    await expect(user2.validate({ amount: 0 })).resolves.toEqual({ amount: 0 }) // required
+    await expect(user.validate({ amount: '0' })).resolves.toEqual({ amount: 0 }) // required
+    await expect(user.validate({ amount: undefined })).resolves.toEqual({})  // not required
+    await expect(user.validate({ amount: null })).resolves.toEqual({ amount: null }) // not required
+
     // Number required
-    await expect(user2.validate({ amount: 0 })).resolves.toEqual({ amount: 0 })
-    await expect(user2.validate({ amount: '' })).rejects.toContainEqual({
+    let mock1 = {
       detail: 'This field is required.',
       status: '400',
       title: 'amount',
-      meta: {
-        model: 'user',
-        field: 'amount',
-        rule: 'required'
-      }
-    })
+      meta: { model: 'user', field: 'amount', rule: 'required' }
+    }
+    await expect(user2.validate({})).rejects.toContainEqual(mock1)
+    await expect(user2.validate({ amount: '' })).rejects.toContainEqual(mock1)
+    await expect(user2.validate({ amount: undefined })).rejects.toContainEqual(mock1)
+    await expect(user2.validate({ amount: null })).rejects.toContainEqual(mock1)
+
+    // Number invalid
+    let mock2 = {
+      detail: 'Value was not a number.',
+      status: '400',
+      title: 'amount',
+      meta: { model: 'user', field: 'amount', rule: 'isNumber' }
+    }
+    await expect(user.validate({ amount: false })).rejects.toContainEqual(mock2)
+    await expect(user.validate({ amount: 'bad' })).rejects.toContainEqual(mock2)
   })
 
   test('Schema default objects', async (done) => {