monastery 1.42.2 → 2.1.0

package/changelog.md

@@ -2,6 +2,10 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [2.1.0](https://github.com/boycce/monastery/compare/1.42.2...2.1.0) (2024-04-05)
+
+## [2.0.0](https://github.com/boycce/monastery/compare/1.42.2...2.0.0) (2023-12-06)
+
 ### [1.42.2](https://github.com/boycce/monastery/compare/1.42.1...1.42.2) (2023-10-31)
 
 ### [1.42.1](https://github.com/boycce/monastery/compare/1.42.0...1.42.1) (2023-10-09)

package/docs/definition/index.md

@@ -283,12 +283,12 @@ You are able to define custom error messages for each field rule.
       }
     },
     // Assign custom error messages for arrays
+    // e.g. pets = [{ name: { type: 'string' }}]
     'pets': {
       minLength: `Please add at least one pet pet group.`
     },
     // You can assign custom error messages for all fields on embedded documents in an array
-    // e.g. pets = [{ name: { type: 'string' }}]
-    'pets.name': {
+    'pets.$.name': {
       required: `Your pet's name needs to be a string.`
     },
     // To target a specific array item

package/docs/image-plugin.md

@@ -12,6 +12,7 @@ To use the default image plugin shipped with monastery, you need to use the opti
     imagePlugin: {
       awsAcl: 'public-read', // default
       awsBucket: 'your-bucket-name',
+      awsRegion: undefined, // required when using getSignedUrl (e.g. 's3-ap-southeast-2')
       awsAccessKeyId: 'your-key-here',
       awsSecretAccessKey: 'your-key-here',
       filesize: undefined, // default (max filesize in bytes)

package/docs/readme.md

@@ -105,6 +105,7 @@ Coming soon...
 - Remove leading forward slashes from custom image paths (AWS adds this as a seperate folder)
 - double check await db.model.remove({ query: idfromparam }) doesnt cause issues for null, undefined or '', but continue to allow {}
 - ~~can't insert/update model id (maybe we can allow this and add _id to default insert/update blacklists)~~
+- timstamps are blacklisted by default (instead of the `timestamps` opt), and can be switched off via blacklisting
 
 ## Versions
 

package/lib/model-validate.js

@@ -65,29 +65,18 @@ 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', .. }
+     * @param {object} object - messages, 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 })
+    let key
+    for (let k in object) {
+      if (path.match(object[k].regex)) {
+        key = k
+        break
       }
     }
-
-    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
+    return key
   },
 
   _validateFields: function(dataRoot, fields, data, opts, path) {
@@ -236,7 +225,7 @@ module.exports = {
     let rule = this.rules[ruleName] || rules[ruleName]
     let fieldName = path.match(/[^.]+$/)[0]
     let isDeepProp = path.match(/\./) // todo: not dot-notation
-    let ruleMessageKey = this._getMostSpecificKeyMatchingPath(this.messages, path)
+    let ruleMessageKey = this.messagesLen && this._getMostSpecificKeyMatchingPath(this.messages, path)
     let ruleMessage = ruleMessageKey && this.messages[ruleMessageKey][ruleName]
     let validateUndefined = util.isDefined(opts.validateUndefined) ? opts.validateUndefined : opts.insert || isDeepProp
     if (!ruleMessage) ruleMessage = rule.message

package/lib/model.js

@@ -43,14 +43,50 @@ let Model = module.exports = function(name, opts, manager) {
       ? !opts.insertBL.includes('_id') && !opts.insertBL.includes('-_id') ? ['_id'].concat(opts.insertBL) : opts.insertBL
       : ['_id'],
     fields: { ...(util.deepCopy(opts.fields) || {}) },
-    findBL: opts.findBL || ['password'],
+    findBL: opts.findBL || ['password'], // todo: password should be removed
     manager: manager,
     messages: opts.messages || {},
+    messagesLen: Object.keys(opts.messages || {}).length > 0,
     name: name,
     rules: { ...(opts.rules || {}) },
     updateBL: opts.updateBL || [],
   })
 
+  // Sort messages by specifity first, then we can just return the first match
+  this.messages = Object
+    .keys(this.messages)
+    .sort((a, b) => {
+      function getScore(key) {
+        // Make sure the keys are sorted by specifity, e.g. the most specific keys are at the top
+        // That means the variable indexes need to be sorted last, 
+        // e.g. 'gulls.1.name' is more specific than 'gulls.$.name' 
+        // e.g. 'gulls.1.name' is more specific than 'gulls.1.$'
+        // e.g. 'gulls.1.$' is more specific than 'gulls.$.1'
+        // e.g. 'gulls.1.1.$' is more specific than 'gulls.$.1.1'
+        if (!key.match(/\.\$/)) return 0
+        let score = 0
+        let parts = key.split('.')
+        for (let i = 0; i < parts.length; i++) {
+          if (parts[i] == '$') score += 100 * (100 - i) // higher score is less specific 
+        }
+        return score
+      }
+      const scoreA = getScore(a)
+      const scoreB = getScore(b)
+      // this.messages[a].score = scoreA
+      // this.messages[b].score = scoreB 
+      return scoreA > scoreB ? 1 : (scoreA < scoreB ? -1 : 0)
+    })
+    .reduce((acc, key) => {
+      // Now covert the path to a regex
+      // e.g. pets.$.names.4.first => pets\.[0-9]+\.names\.4\.first
+      this.messages[key].regex = new RegExp(`^${key.replace(/\./g, '\\.').replace(/\.\$/g, '.[0-9]+')}$`)
+      // this.messages[key].regex = new RegExp(`^${key.replace(/\.\$/g, '(.[0-9]+|.)').replace(/\./g, '\\.')}$`) 
+      // return an ordered object
+      acc[key] = this.messages[key]
+      return acc
+    }, {})
+
   // Run before model hooks
   for (let hook of this.manager.beforeModel) {
     hook(this)

package/package.json

@@ -2,7 +2,7 @@
   "name": "monastery",
   "description": "⛪ A straight forward MongoDB ODM built around Monk",
   "author": "Ricky Boyce",
-  "version": "1.42.2",
+  "version": "2.1.0",
   "license": "MIT",
   "repository": "github:boycce/monastery",
   "homepage": "https://boycce.github.io/monastery/",
@@ -21,30 +21,36 @@
     "docs": "cd docs && bundle exec jekyll serve --livereload --livereload-port 4001",
     "lint": "eslint ./lib ./plugins ./test",
     "mong": "nodemon resources/mong.js",
+    "major": "standard-version --release-as major && npm publish",
     "minor": "standard-version --release-as minor && npm publish",
     "patch": "standard-version --release-as patch && npm publish",
     "release": "standard-version && npm publish && git push --tags",
     "test": "npm run lint && jest",
-    "test-one-example": "jest -t images"
+    "test-one-example": "jest -t \"images addImages\" --watchAll"
   },
   "dependencies": {
-    "aws-sdk": "2.1062.0",
-    "debug": "4.1.1",
-    "file-type": "15.0.0",
+    "@aws-sdk/client-s3": "^3.549.0",
+    "@aws-sdk/s3-request-presigner": "^3.549.0",
+    "debug": "^4.3.4",
+    "file-type": "^16.5.4",
     "monk": "7.3.4",
     "nanoid": "3.2.0",
     "validator": "13.7.0"
   },
   "devDependencies": {
-    "body-parser": "1.19.0",
+    "body-parser": "^1.20.2",
     "eslint": "8.7.0",
-    "express": "4.17.1",
-    "express-fileupload": "1.2.0",
+    "express": "^4.19.2",
+    "express-fileupload": "^1.5.0",
     "jest": "27.4.7",
-    "nodemon": "2.0.15",
+    "nodemon": "^3.1.0",
     "standard-version": "9.3.2",
     "supertest": "4.0.2"
   },
+  "engines": {
+    "node": ">=14",
+    "npm": ">=6"
+  },
   "standard-version": {
     "infile": "changelog.md",
     "releaseCommitMessageFormat": "{{currentTag}}",

package/plugins/images/index.js

@@ -1,5 +1,6 @@
 // requiring: nanoid, file-type, aws-sdk/clients/s3
-let util = require('../../lib/util')
+const { getSignedUrl } = require('@aws-sdk/s3-request-presigner')
+const util = require('../../lib/util')
 
 let plugin = module.exports = {
 
@@ -26,6 +27,7 @@ let plugin = module.exports = {
     this.awsBucket = options.awsBucket
     this.awsAccessKeyId = options.awsAccessKeyId
     this.awsSecretAccessKey = options.awsSecretAccessKey
+    this.awsRegion = options.awsRegion
     this.bucketDir = options.bucketDir || 'full' // depreciated > 1.36.2
     this.filesize = options.filesize
     this.formats = options.formats || ['bmp', 'gif', 'jpg', 'jpeg', 'png', 'tiff']
@@ -42,10 +44,14 @@ let plugin = module.exports = {
     }
 
     // Create s3 'service' instance (defer require since it takes 120ms to load)
-    // https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html#constructor-property
+    // v2: https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html#constructor-property
+    // v3: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/
+    // v3 examples: https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/javascript_s3_code_examples.html
     manager._getSignedUrl = this._getSignedUrl
-    this.s3 = () => {
-      return this._s3 || (this._s3 = new (require('aws-sdk/clients/s3'))({
+    this.getS3Client = () => {
+      const { S3 } = require('@aws-sdk/client-s3')
+      return this._s3Client || (this._s3Client = new S3({
+        region: this.awsRegion,
         credentials: {
           accessKeyId: this.awsAccessKeyId,
           secretAccessKey: this.awsSecretAccessKey
@@ -168,7 +174,7 @@ let plugin = module.exports = {
               plugin._addImageObjectsToData(filesArr.inputPath, data, image)
               resolve(s3Options)
             } else {
-              plugin.s3().upload(s3Options, (err, response) => {
+              plugin.getS3Client().upload(s3Options, (err, response) => {
                 if (err) return reject(err)
                 plugin._addImageObjectsToData(filesArr.inputPath, data, image)
                 resolve(s3Options)
@@ -203,7 +209,7 @@ let plugin = module.exports = {
      * Get signed urls for all image objects in data
      * @param {object} options - monastery operation options {model, query, files, ..}
      * @param {object} data
-     * @return promise(data)
+     * @return promise() - mutates data
      * @this model
      */
     // Not wanting signed urls for this operation?
@@ -215,8 +221,9 @@ let plugin = module.exports = {
         if (options.getSignedUrls
             || (util.isDefined(imageField.getSignedUrl) ? imageField.getSignedUrl : plugin.getSignedUrl)) {
           let images = plugin._findImagesInData(doc, imageField, 0, '').filter(o => o.image)
+          // todo: we could do this in parallel
           for (let image of images) {
-            image.image.signedUrl = plugin._getSignedUrl(image.image.path, 3600, imageField.awsBucket)
+            image.image.signedUrl = await plugin._getSignedUrl(image.image.path, 3600, imageField.awsBucket)
           }
         }
       }
@@ -365,7 +372,7 @@ let plugin = module.exports = {
     // the file doesnt get deleted, we only delete from plugin.awsBucket.
     if (!unused.length) return
     await new Promise((resolve, reject) => {
-      plugin.s3().deleteObjects({
+      plugin.getS3Client().deleteObjects({
         Bucket: plugin.awsBucket,
         Delete: { Objects: unused }
       }, (err, data) => {
@@ -571,18 +578,23 @@ let plugin = module.exports = {
     return list
   },
 
-  _getSignedUrl: (path, expires=3600, bucket) => {
+  _getSignedUrl: async (path, expires=3600, bucket) => {
     /**
      * @param {string} path - aws file path
      * @param {number} <expires> - seconds
      * @param {number} <bucket>
-     * @see https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html#getSignedUrl-property
+     * @return {promise} signedUrl
+     * @see v2: https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html#getSignedUrl-property
+     * @see v3: https://github.com/aws/aws-sdk-js-v3/blob/main/UPGRADING.md#s3-presigned-url
      */
-    let signedUrl = plugin.s3().getSignedUrl('getObject', {
-      Bucket: bucket || plugin.awsBucket,
-      Expires: expires,
-      Key: path,
-    })
+    if (!plugin.awsRegion) {
+      throw 'Monastery requires config.awsRegion to be defined when using getSignedUrl\'s'
+    }
+    const { GetObjectCommand } = require('@aws-sdk/client-s3')
+    const params = { Bucket: bucket || plugin.awsBucket, Key: path }
+    const command = new GetObjectCommand(params)
+    let signedUrl = await getSignedUrl(plugin.getS3Client(), command, { expiresIn: expires })
+    // console.log(signedUrl)
     return signedUrl
   },
 

package/test/model.js

@@ -170,6 +170,134 @@ module.exports = function(monastery, opendb) {
     })
   })
 
+  test('model setup with messages', async () => {
+    // Setup
+    let db = (await opendb(false)).db
+    let user = db.model('user', {
+      fields: {
+        name: { type: 'string' },
+      },
+      messages: {
+        // these are sorted when trhe model's initialised
+        'cats.name': {},       
+
+        'dogs.name': {},       
+        'dogs.$.name': {},     
+        'dogs.1.name': {},     
+        'dogs.$': {},          
+        'dogs.1': {},          
+
+        'pigs.name': {},       
+        'pigs.$.name': {},     
+        'pigs.1.name': {},     
+        'pigs.2.name': {},     
+
+        'gulls.$.1.$': {},     
+        'gulls.1.$.1': {},     
+        'gulls.$': {},         
+        'gulls.$.$': {},       
+        'gulls.$.$.1': {},     
+        'gulls.$.1': {},       
+        'gulls.1.$': {},       
+        'gulls.1.1': {},       
+        'gulls.1.1.$': {},     
+        'gulls.name': {},      
+        'gulls.$.name': {},    
+      },
+    })
+    // Object with schema
+    // console.log(user.messages)
+    expect(Object.keys(user.messages)).toEqual([
+      'cats.name',
+      'dogs.name',
+      'dogs.1.name',
+      'dogs.1',
+      'pigs.name',
+      'pigs.1.name',
+      'pigs.2.name',
+      'gulls.1.1',
+      'gulls.name',
+      'gulls.1.1.$',
+      'gulls.1.$.1',
+      'gulls.1.$',
+      'dogs.$.name',
+      'dogs.$',
+      'pigs.$.name',
+      'gulls.$',
+      'gulls.$.1',
+      'gulls.$.name',
+      'gulls.$.1.$',
+      'gulls.$.$',
+      'gulls.$.$.1',
+    ])
+
+    expect(user.messages).toEqual({
+      // these are sorted in model initialisation
+      'cats.name': {
+        'regex': /^cats\.name$/,
+      },
+      'dogs.$': {
+        'regex': /^dogs\.[0-9]+$/,
+      },
+      'dogs.$.name': {
+        'regex': /^dogs\.[0-9]+\.name$/,
+      },
+      'dogs.1': {
+        'regex': /^dogs\.1$/,
+      },
+      'dogs.1.name': {
+        'regex': /^dogs\.1\.name$/,
+      },
+      'dogs.name': {
+        'regex': /^dogs\.name$/,
+      },
+      'gulls.$': {
+        'regex': /^gulls\.[0-9]+$/,
+      },
+      'gulls.$.$': {
+        'regex': /^gulls\.[0-9]+\.[0-9]+$/,
+      },
+      'gulls.$.$.1': {
+        'regex': /^gulls\.[0-9]+\.[0-9]+\.1$/,
+      },
+      'gulls.$.1': {
+        'regex': /^gulls\.[0-9]+\.1$/,
+      },
+      'gulls.$.1.$': {
+        'regex': /^gulls\.[0-9]+\.1\.[0-9]+$/,
+      },
+      'gulls.$.name': {
+        'regex': /^gulls\.[0-9]+\.name$/,
+      },
+      'gulls.1.$': {
+        'regex': /^gulls\.1\.[0-9]+$/,
+      },
+      'gulls.1.$.1': {
+        'regex': /^gulls\.1\.[0-9]+\.1$/,
+      },
+      'gulls.1.1': {
+        'regex': /^gulls\.1\.1$/,
+      },
+      'gulls.1.1.$': {
+        'regex': /^gulls\.1\.1\.[0-9]+$/,
+      },
+      'gulls.name': {
+        'regex': /^gulls\.name$/,
+      },
+      'pigs.$.name': {
+        'regex': /^pigs\.[0-9]+\.name$/,
+      },
+      'pigs.1.name': {
+        'regex': /^pigs\.1\.name$/,
+      },
+      'pigs.2.name': {
+        'regex': /^pigs\.2\.name$/,
+      },
+      'pigs.name': {
+        'regex': /^pigs\.name$/,
+      },
+    })
+  }),
 
   test('model reserved rules', async () => {
     // Setup

package/test/plugin-images.js

@@ -803,6 +803,7 @@ module.exports = function(monastery, opendb) {
         awsBucket: 'fake',
         awsAccessKeyId: 'fake',
         awsSecretAccessKey: 'fake',
+        awsRegion: 's3-ap-southeast-2',
         getSignedUrl: true,
       },
     })).db

package/test/validate.js

@@ -381,35 +381,43 @@ module.exports = function(monastery, opendb) {
   })
 
   test('validation getMostSpecificKeyMatchingPath', async () => {
-    let fn = validate._getMostSpecificKeyMatchingPath
-    let mock = {
-      'cats.name': true,
-
-      'dogs.name': true,
-      'dogs.$.name': true,
-
-      'pigs.name': true,
-      'pigs.$.name': true,
-      'pigs.1.name': true,
-      'pigs.2.name': true,
+    let db = (await opendb(false)).db
+    let user = db.model('user', {
+      fields: {
+        name: { type: 'string' },
+      },
+      messages: {
+        // these are sorted when trhe model's initialised
+        'cats.name': {},
+  
+        'dogs.name': {},
+        'dogs.$.name': {},
+  
+        'pigs.name': {},
+        'pigs.$.name': {},
+        'pigs.1.name': {},
+        'pigs.2.name': {},
+  
+        'gulls.$': {},
+        'gulls.$.$': {},
+        'gulls.name': {},
+        'gulls.$.name': {},
+      },
+    })
 
-      'gulls.$': true,
-      'gulls.$.$': true,
-      'gulls.name': true,
-      'gulls.$.name': true,
-    }
+    let fn = validate._getMostSpecificKeyMatchingPath
     // subdocument
-    expect(fn(mock, 'cats.name')).toEqual('cats.name')
+    expect(fn(user.messages, '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')
+    // expect(fn(user.messages, 'cats.1.name')).toEqual('cats.name') // no longer matches
+    expect(fn(user.messages, 'dogs.1.name')).toEqual('dogs.$.name')
+    expect(fn(user.messages, 'dogs.2.name')).toEqual('dogs.$.name')
+    expect(fn(user.messages, 'pigs.1.name')).toEqual('pigs.1.name')
+    expect(fn(user.messages, 'pigs.2.name')).toEqual('pigs.2.name')
+    expect(fn(user.messages, 'pigs.3.name')).toEqual('pigs.$.name')
     // array
-    expect(fn(mock, 'gulls.1.2')).toEqual('gulls.$.$')
-    expect(fn(mock, 'gulls.1')).toEqual('gulls.$')
+    expect(fn(user.messages, 'gulls.1.2')).toEqual('gulls.$.$')
+    expect(fn(user.messages, 'gulls.1')).toEqual('gulls.$')
   })
 
   test('validation default messages', async () => {
@@ -478,7 +486,7 @@ module.exports = function(monastery, opendb) {
       messages: {
         'name': { minLength: 'Oops min length is 4' },
         'dog.name': { minLength: 'Oops min length is 4' },
-        'dogNames': { minLength: 'Oops min length is 4' },
+        'dogNames.$': { minLength: 'Oops min length is 4' },
       }
     })
 
@@ -519,24 +527,26 @@ module.exports = function(monastery, opendb) {
         catNames: [{
           name: { type: 'string', minLength: 4 }
         }],
-        pigNames: [[{
-          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.$.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)' },
+        // 'pigNames.$.$.name': { minLength: 'min length error (name)' },
+        'pigNames.$.$.name': { minLength: 'min length error ($ $)' },   // catches 
+        'pigNames.$.1.name': { minLength: 'min length error ($ 1)' },   
+        'pigNames.2.$.name': { minLength: 'min length error (2 $)' },
+        'pigNames.0.2.name': { minLength: 'min length error (0 2)' },
+        'pigNames.$.2.name': { minLength: 'min length error ($ 2)' },
       }
     })
 
@@ -587,7 +597,7 @@ module.exports = function(monastery, opendb) {
     .rejects.toContainEqual({
       status: '400',
       title: 'pigNames.0.0.name',
-      detail: 'min length error ($)',
+      detail: 'min length error ($ $)',
       meta: { rule: 'minLength', model: 'user', field: 'name' }
     })
     // array-subdocument-1-field error
@@ -595,7 +605,14 @@ module.exports = function(monastery, opendb) {
     .rejects.toContainEqual({
       status: '400',
       title: 'pigNames.0.1.name',
-      detail: 'min length error (1)',
+      detail: 'min length error ($ 1)',
+      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' }
     })
     // array-subdocument-0-2-field error
@@ -603,22 +620,15 @@ module.exports = function(monastery, opendb) {
     .rejects.toContainEqual({
       status: '400',
       title: 'pigNames.0.2.name',
-      detail: 'min length error (deep 0 2)',
+      detail: 'min length error (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' }]] }))
+    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)',
+      title: 'pigNames.1.2.name',
+      detail: 'min length error ($ 2)',
       meta: { rule: 'minLength', model: 'user', field: 'name' }
     })
   })