monastery 1.36.0 → 1.36.1

package/changelog.md

@@ -2,6 +2,13 @@
 
 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.
 
+### [1.36.1](https://github.com/boycce/monastery/compare/1.36.0...1.36.1) (2022-04-16)
+
+
+### Bug Fixes
+
+* findOneAndUpdate population, blacklisting, etc ([19c4fc9](https://github.com/boycce/monastery/commit/19c4fc96d8c94d9dd68af2a74af693c8dc7a4c17))
+
 ## [1.36.0](https://github.com/boycce/monastery/compare/1.35.0...1.36.0) (2022-04-15)
 
 

package/docs/readme.md

@@ -83,7 +83,7 @@ Coming soon...
 
 ## Roadmap
 
-- Add FindOneAndUpdate
+- ~~Add FindOneAndUpdate~~
 - Add before/afterInsertUpdate
 - Bug: Setting an object literal on an ID field ('model') saves successfully
 - Population within array items
@@ -95,8 +95,8 @@ Coming soon...
 - Remove ACL default 'public read'
 - ~~Public db.arrayWithSchema method~~
 - Global after/before hooks
-- Split away from Monk (unless updated)
 - docs: Make the implicit ID query conversion more apparent
+- Split away from Monk (unless updated)
 
 ## Special Thanks
 

package/lib/model-crud.js

@@ -24,14 +24,13 @@ module.exports = {
     }
     try {
       opts = await this._queryObject(opts, 'insert')
-      let custom = ['blacklist', 'data', 'insert', 'model', 'respond', 'skipValidation',  'validateUndefined']
 
       // Validate
-      let data = await this.validate(opts.data || {}, { ...opts })
+      let data = await this.validate(opts.data || {}, opts) // was { ...opts }
 
       // Insert
       await util.runSeries(this.beforeInsert.map(f => f.bind(opts, data)))
-      let response = await this._insert(data, util.omit(opts, custom))
+      let response = await this._insert(data, util.omit(opts, this._queryOptions))
       await util.runSeries(this.afterInsert.map(f => f.bind(opts, response)))
 
       // Success/error
@@ -64,9 +63,8 @@ module.exports = {
       throw new Error(`The callback passed to ${this.name}.find() is not a function`)
     }
     try {
-      opts = await this._queryObject(opts, 'find', one)
-      let custom = ['blacklist', 'model', 'one', 'populate', 'project', 'query', 'respond']
       let lookups = []
+      opts = await this._queryObject(opts, 'find', one)
 
       // Get projection
       if (opts.project) opts.projection = this._getProjectionFromProject(opts.project)
@@ -80,7 +78,7 @@ module.exports = {
 
       // Wanting to populate?
       if (!opts.populate) {
-        var response = await this[`_find${opts.one? 'One' : ''}`](opts.query, util.omit(opts, custom))
+        var response = await this[`_find${opts.one? 'One' : ''}`](opts.query, util.omit(opts, this._queryOptions))
       } else {
         loop: for (let item of opts.populate) {
           let path = util.isObject(item)? item.as : item
@@ -157,18 +155,14 @@ module.exports = {
      * Find and update document(s) with monk, also auto populates
      * @param {object} opts
      *     @param {array|string|false} <opts.blacklist> - augment findBL/updateBL, `false` will remove all blacklisting
-     *     @param {array|string|false} <opts.blacklistFind> - augment findBL, `false` will remove all blacklisting
      *     @param {array} <opts.populate> - find population, see docs
      *     @param {array|string} <opts.project> - return only these fields, ignores blacklisting
-     *     @param {array|string} <opts.projectFind> - return only these fields, ignores blacklisting
      *     @param {object} <opts.query> - mongodb query object
      *     @param {boolean} <opts.respond> - automatically call res.json/error (requires opts.req)
      *     @param {any} <any mongodb option>
      *
      *     Update options:
      *     @param {object|array} opts.data - mongodb document update object(s)
-     *     @param {array|string|false} <opts.blacklistUpdate> - augment updateBL, `false` will remove all blacklisting
-     *     @param {array|string} <opts.projectUpdate> - return only these fields, ignores blacklisting
      *     @param {array|string|true} <opts.skipValidation> - skip validation for this field name(s)
      *     @param {boolean} <opts.timestamps> - whether `updatedAt` is automatically updated
      *     @param {array|string|false} <opts.validateUndefined> - validates all 'required' undefined fields, true by
@@ -228,37 +222,49 @@ module.exports = {
       let data = opts.data
       let response = null
       let operators = util.pick(opts, [/^\$/])
-      let custom = [
-        'blacklist', 'data', 'model', 'one', 'populate', 'project', 'query', 'respond', 'skipValidation',
-        'validateUndefined'
-      ]
 
       // Validate
-      if (util.isDefined(data)) data = await this.validate(opts.data, { ...opts })
+      if (util.isDefined(data)) {
+        data = await this.validate(opts.data, opts) // was {...opts}
+      }
       if (!util.isDefined(data) && util.isEmpty(operators)) {
         throw new Error(`Please pass an update operator to ${this.name}.${type}(), e.g. data, $unset, etc`)
       }
       if (util.isDefined(data) && (!data || util.isEmpty(data))) {
         throw new Error(`No valid data passed to ${this.name}.${type}({ data: .. })`)
       }
+
       // Hook: beforeUpdate (has access to original, non-validated opts.data)
       await util.runSeries(this.beforeUpdate.map(f => f.bind(opts, data||{})))
+
       if (data && operators['$set']) {
         this.warn(`'$set' fields take precedence over the data fields for \`${this.name}.${type}()\``)
       }
       if (data || operators['$set']) {
         operators['$set'] = { ...data, ...(operators['$set'] || {}) }
       }
-      // Just peform a normal update if we need to populate a findOneAndUpdate
-      if (opts.populate && type == 'findOneAndUpdate') type ='update'
+
+      // findOneAndUpdate, get 'find' projection
+      if (type == 'findOneAndUpdate') {
+        if (opts.project) opts.projection = this._getProjectionFromProject(opts.project)
+        else opts.projection = this._getProjectionFromBlacklist('find', opts.blacklist)
+        // Just peform a normal update if we need to populate a findOneAndUpdate
+        if (opts.populate) type = 'update'
+      }
+
       // Update
-      let update = await this['_' + type](opts.query, operators, util.omit(opts, custom))
+      let update = await this['_' + type](opts.query, operators, util.omit(opts, this._queryOptions))
       if (type == 'findOneAndUpdate') response = update
       else if (update.n) response = Object.assign(Object.create({ _output: update }), operators['$set']||{})
 
       // Hook: afterUpdate (doesn't have access to validated data)
       if (response) await util.runSeries(this.afterUpdate.map(f => f.bind(opts, response)))
 
+      // Hook: afterFind if findOneAndUpdate
+      if (response && type == 'findOneAndUpdate') {
+        response = await this._processAfterFind(response, opts.projection, opts)
+      }
+
       // Success
       if (cb) cb(null, response)
       else if (opts.req && opts.respond) opts.req.res.json(response)
@@ -288,12 +294,11 @@ module.exports = {
     }
     try {
       opts = await this._queryObject(opts, 'remove')
-      let custom =  ['model', 'query', 'respond']
       if (util.isEmpty(opts.query)) throw new Error('Please specify opts.query')
 
       // Remove
       await util.runSeries(this.beforeRemove.map(f => f.bind(opts)))
-      let response = await this._remove(opts.query, util.omit(opts, custom))
+      let response = await this._remove(opts.query, util.omit(opts, this._queryOptions))
       await util.runSeries(this.afterRemove.map(f => f.bind(response)))
 
       // Success
@@ -626,4 +631,11 @@ module.exports = {
     }, this)
   },
 
+  _queryOptions: [
+    // todo: remove type properties
+    'blacklist', 'data', 'find', 'findOneAndUpdate', 'insert', 'model', 'one', 'populate', 'project',
+    'projectionValidate', 'query', 'remove', 'req', 'respond', 'skipValidation', 'type', 'update',
+    'validateUndefined',
+  ],
+
 }

package/lib/model-validate.js

@@ -36,8 +36,8 @@ module.exports = {
       opts.skipValidation = opts.skipValidation === true ? true : util.toArray(opts.skipValidation||[])
 
       // Get projection
-      if (opts.project) opts.projection = this._getProjectionFromProject(opts.project)
-      else opts.projection = this._getProjectionFromBlacklist(opts.update ? 'update' : 'insert', opts.blacklist)
+      if (opts.project) opts.projectionValidate = this._getProjectionFromProject(opts.project)
+      else opts.projectionValidate = this._getProjectionFromBlacklist(opts.update ? 'update' : 'insert', opts.blacklist)
 
       // Hook: beforeValidate
       await util.runSeries(this.beforeValidate.map(f => f.bind(opts, data)))
@@ -132,7 +132,7 @@ module.exports = {
         }
 
         // Ignore blacklisted
-        if (this._pathBlacklisted(path3, opts.projection) && !schema.defaultOverride) return
+        if (this._pathBlacklisted(path3, opts.projectionValidate) && !schema.defaultOverride) return
         // Ignore insert only
         if (opts.update && schema.insertOnly) return
         // Ignore virtual fields

package/package.json

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

package/test/blacklisting.js

@@ -1,104 +1,25 @@
+let bird = require('./mock/blacklisting').bird
+let user = require('./mock/blacklisting').user
+let util = require('../lib/util')
+
 module.exports = function(monastery, opendb) {
 
   test('find blacklisting basic', async () => {
     // Setup
     let db = (await opendb(null)).db
-    let bird = db.model('bird', {
-      fields: {
-        name: { type: 'string' },
-      }
-    })
-    let user = db.model('user', {
-      fields: {
-        list: [{ type: 'number' }],
-        dog: { type: 'string' },
-        pet: { type: 'string' },
-        pets: [{
-          name: { type: 'string'},
-          age: { type: 'number'}
-        }],
-        animals: {
-          cat: { type: 'string' },
-          dog: { type: 'string' }
-        },
-        hiddenPets: [{
-          name: { type: 'string'}
-        }],
-        hiddenList: [{ type: 'number'}],
-        deep: {
-          deep2: {
-            deep3: {
-              deep4: { type: 'string' }
-            }
-          }
-        },
-        deeper: {
-          deeper2: {
-            deeper3: {
-              deeper4: { type: 'string' }
-            }
-          }
-        },
-        deepModel: {
-          myBird: { model: 'bird' }
-        },
-        hiddenDeepModel: {
-          myBird: { model: 'bird' }
-        }
-      },
-      findBL: [
-        'dog',
-        'animals.cat',
-        'pets.age',
-        'hiddenPets',
-        'hiddenList',
-        'deep.deep2.deep3',
-        'deeper',
-        'hiddenDeepModel'
-      ],
-    })
-    let bird1 = await bird.insert({ data: { name: 'ponyo' }})
-    let user1 = await user.insert({ data: {
-      list: [44, 54],
-      dog: 'Bruce',
-      pet: 'Freddy',
-      pets: [{ name: 'Pluto', age: 5 }, { name: 'Milo', age: 4 }],
-      animals: {
-        cat: 'Ginger',
-        dog: 'Max'
-      },
-      hiddenPets: [{
-        name: 'secretPet'
-      }],
-      hiddenList: [12, 23],
-      deep: {
-        deep2: {
-          deep3: {
-            deep4: 'hideme'
-          }
-        }
-      },
-      deeper: {
-        deeper2: {
-          deeper3: {
-            deeper4: 'hideme'
-          }
-        }
-      },
-      deepModel: {
-        myBird: bird1._id
-      },
-      hiddenDeepModel: {
-        myBird: bird1._id
-      }
-    }})
+    db.model('bird', bird.schema())
+    db.model('user', user.schema())
+
+    let bird1 = await db.bird.insert({ data: bird.mock() })
+    let user1 = await db.user.insert({ data: user.mock(bird1) })
 
     // initial blacklist
-    let find1 = await user.findOne({
+    let find1 = await db.user.findOne({
       query: user1._id
     })
     expect(find1).toEqual({
       _id: user1._id,
+      bird: bird1._id,
       list: [44, 54],
       pet: 'Freddy',
       pets: [{ name: 'Pluto' }, { name: 'Milo' }],
@@ -108,13 +29,14 @@ module.exports = function(monastery, opendb) {
     })
 
     // augmented blacklist
-    let find2 = await user.findOne({
+    let find2 = await db.user.findOne({
       query: user1._id,
       blacklist: ['pet', 'pet', 'deep', 'deepModel', '-dog', '-animals.cat']
     })
     let customBlacklist
     expect(find2).toEqual((customBlacklist = {
       _id: user1._id,
+      bird: bird1._id,
       dog: 'Bruce',
       list: [44, 54],
       pets: [{ name: 'Pluto' }, { name: 'Milo' }],
@@ -122,119 +44,84 @@ module.exports = function(monastery, opendb) {
     }))
 
     // blacklist string
-    let find3 = await user.findOne({
+    let find3 = await db.user.findOne({
       query: user1._id,
       blacklist: 'pet pet deep deepModel -dog -animals.cat'
     })
     expect(find3).toEqual(customBlacklist)
 
     // blacklist removal
-    let find4 = await user.findOne({ query: user1._id, blacklist: false })
+    let find4 = await db.user.findOne({ query: user1._id, blacklist: false })
     expect(find4).toEqual(user1)
 
     db.close()
   })
 
   test('find blacklisting population', async () => {
-    // inprogresss
     // Setup
-    let db = monastery('localhost/monastery', {
-      timestamps: false,
-      serverSelectionTimeoutMS: 2000,
-    })
-    let bird = db.model('bird', {
-      fields: {
-        color: { type: 'string', default: 'red' },
-        height: { type: 'number' },
-        name: { type: 'string' },
-        sub: {
-          color: { type: 'string', default: 'red' },
-        },
-        subs: [{
-          color: { type: 'string', default: 'red'},
-        }],
-        wing: {
-          size: { type: 'number' },
-          sizes: {
-            one: { type: 'number' },
-            two: { type: 'number' },
-          }
-        },
-      },
-      findBL: ['wing']
-    })
-    let user = db.model('user', {
+    let db = (await opendb(null)).db
+    db.model('bird', bird.schema())
+    db.model('user', {
       fields: {
         dog: { type: 'string' },
-        bird1: { model: 'bird' },
-        bird2: { model: 'bird' },
-        bird3: { model: 'bird' },
-        bird4: { model: 'bird' },
-        bird5: { model: 'bird' },
+        bird: { model: 'bird' },
       },
-      findBL: [
-        'bird1.name',                                 // bird1.name & bird1.wing blacklisted
-        '-bird2', 'bird2.name',                       // bird2.name blacklisted
-        'bird3.name', '-bird3', 'bird3.height',       // bird3.height blacklisted
-        '-bird4.wing.sizes.one', '-bird4.wing.size',  // ignored
-        // bird4.wing.sizes.two blacklisted (expand in future verion)
-        '-bird5.wing.sizes.one',                      // bird5.wing.sizes.one ignored, wing blacklisted
-        // bird5.wing.sizes.two, wing.size blacklisted (expand in future verion)
-      ]
     })
-    let bird1 = await bird.insert({
-      data: {
-        name: 'ponyo',
-        height: 40,
-        sub: {},
-        wing: { size: 1, sizes: { one: 1, two: 1 }}
-      }
-    })
-    let userData = {
+
+    let bird1 = await db.bird.insert({ data: bird.mock() })
+    let user1 = await db.user.insert({ data: {
       dog: 'Bruce',
-      bird1: bird1._id,
-      bird2: bird1._id,
-      bird3: bird1._id,
-      bird4: bird1._id,
-      bird5: bird1._id
+      bird: bird1._id,
+    }})
+
+    let bird1Base = {
+      _id: bird1._id,
+      color: 'red',
+      sub: { color: 'red' }
     }
-    let user1 = await user.insert({ data: userData })
-    let bird1Base = { _id: bird1._id, color: 'red', sub: { color: 'red' }}
 
-    // Test bird1
-    expect(await user.findOne({ query: user1._id, populate: ['bird1'] })).toEqual({
-      ...userData,
-      _id: user1._id,
-      bird1: { ...bird1Base, height: 40 },
+    // 'bird1.name',                                 // bird1.name & bird1.wing blacklisted
+    // '-bird2', 'bird2.name',                       // bird2.name blacklisted
+    // 'bird3.name', '-bird3', 'bird3.height',       // bird3.height blacklisted
+    // '-bird4.wing.sizes.one', '-bird4.wing.size',  // ignored
+    //        bird4.wing.sizes.two blacklisted (expand in future verion)
+    // '-bird5.wing.sizes.one',                      // bird5.wing.sizes.one ignored, wing blacklisted
+    //        bird5.wing.sizes.two, wing.size blacklisted (expand in future verion)
+
+    // test 1
+    db.user.findBL = ['bird.name']
+    expect(await db.user.findOne({ query: user1._id, populate: ['bird'] })).toEqual({
+      ...user1,
+      bird: { ...bird1Base, height: 12 },
     })
-    // Test bird2
-    expect(await user.findOne({ query: user1._id, populate: ['bird2'] })).toEqual({
-      ...userData,
-      _id: user1._id,
-      bird2: { ...bird1Base, height: 40, wing: { size: 1, sizes: { one: 1, two: 1 }} },
+    // test 2
+    db.user.findBL = ['-bird', 'bird.name']
+    expect(await db.user.findOne({ query: user1._id, populate: ['bird'] })).toEqual({
+      ...user1,
+      bird: { ...bird1Base, height: 12, wing: { size: 1, sizes: { one: 1, two: 1 }} },
     })
-    // Test bird3
-    expect(await user.findOne({ query: user1._id, populate: ['bird3'] })).toEqual({
-      ...userData,
-      _id: user1._id,
-      bird3: { ...bird1Base, name: 'ponyo', wing: { size: 1, sizes: { one: 1, two: 1 }} },
+    // test 3
+    db.user.findBL = ['bird.name', '-bird', 'bird.height']
+    expect(await db.user.findOne({ query: user1._id, populate: ['bird'] })).toEqual({
+      ...user1,
+      bird: { ...bird1Base, name: 'Ponyo', wing: { size: 1, sizes: { one: 1, two: 1 }} },
     })
-    // Test bird4
-    expect(await user.findOne({ query: user1._id, populate: ['bird4'] })).toEqual({
-      ...userData,
-      _id: user1._id,
-      bird4: { ...bird1Base, name: 'ponyo', height: 40 },
+    // test 4
+    db.user.findBL = ['-bird.wing.sizes.one', '-bird.wing.size']
+    expect(await db.user.findOne({ query: user1._id, populate: ['bird'] })).toEqual({
+      ...user1,
+      bird: { ...bird1Base, name: 'Ponyo', height: 12 },
     })
-    // Test bird5
-    expect(await user.findOne({ query: user1._id, populate: ['bird5'] })).toEqual({
-      ...userData,
-      _id: user1._id,
-      bird5: { ...bird1Base, name: 'ponyo', height: 40 },
+    // test 5
+    db.user.findBL = ['-bird.wing.sizes.one']
+    expect(await db.user.findOne({ query: user1._id, populate: ['bird'] })).toEqual({
+      ...user1,
+      bird: { ...bird1Base, name: 'Ponyo', height: 12 },
     })
     // blacklist removal
-    expect(await user.findOne({ query: user1._id, blacklist: false, populate: ['bird1'] })).toEqual({
+    expect(await db.user.findOne({ query: user1._id, blacklist: false, populate: ['bird'] })).toEqual({
       ...user1,
-      bird1: { ...bird1Base, height: 40, name: 'ponyo', wing: { size: 1, sizes: { one: 1, two: 1 }} },
+      bird: { ...bird1Base, height: 12, name: 'Ponyo', wing: { size: 1, sizes: { one: 1, two: 1 }} },
     })
 
     db.close()
@@ -583,4 +470,72 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
+  test('findOneAndUpdate blacklisting general', async () => {
+    // todo: test all findOneAndUpdate options
+    // todo: test find & update hooks
+    let db = (await opendb(null)).db
+    db.model('bird', bird.schema())
+    db.model('user', user.schema())
+
+    let bird1 = await db.bird.insert({ data: bird.mock() })
+    let user1 = await db.user.insert({ data: user.mock(bird1) })
+
+    // augmented blacklist
+    let find2 = await db.user.findOneAndUpdate({
+      query: user1._id,
+      data: { dog: 'Bruce2', pet: 'Freddy2' }, // pet shouldn't update
+      blacklist: ['pet', 'deep', 'deepModel', '-dog', '-animals.cat'],
+    })
+    expect(find2).toEqual({
+      _id: user1._id,
+      bird: bird1._id,
+      dog: 'Bruce2',
+      list: [44, 54],
+      pets: [{ name: 'Pluto' }, { name: 'Milo' }],
+      animals: { dog: 'Max', cat: 'Ginger' },
+    })
+    expect(await db.user.findOne({ query: user1._id, project: ['pet'] })).toEqual({
+      _id: user1._id,
+      pet: 'Freddy',
+    })
+
+    db.close()
+  })
+
+  test('findOneAndUpdate blacklisting populate', async () => {
+    let db = (await opendb(null)).db
+    db.model('bird', bird.schema())
+    db.model('user', user.schema())
+
+    let bird1 = await db.bird.insert({ data: bird.mock() })
+    let user1 = await db.user.insert({ data: user.mock(bird1) })
+
+    // augmented blacklist
+    let find2 = await db.user.findOneAndUpdate({
+      query: user1._id,
+      data: { dog: 'Bruce2', pet: 'Freddy2' }, // pet shouldn't update
+      blacklist: [
+        'pet', 'deep', 'deepModel', '-dog', '-animals.cat',
+        'bird.name', '-bird', 'bird.height' // <- populated model
+      ],
+      populate: ['bird'],
+    })
+    expect(find2).toEqual({
+      _id: user1._id,
+      bird: {
+        ...util.omit(bird1, ['height']),
+      },
+      dog: 'Bruce2',
+      list: [44, 54],
+      pets: [{ name: 'Pluto' }, { name: 'Milo' }],
+      animals: { dog: 'Max', cat: 'Ginger' },
+    })
+    expect(await db.user.findOne({ query: user1._id, project: ['pet'] })).toEqual({
+      _id: user1._id,
+      pet: 'Freddy',
+    })
+
+    db.close()
+  })
+
 }

package/test/crud.js

@@ -145,7 +145,7 @@ module.exports = function(monastery, opendb) {
     db2.close()
   })
 
-  test('update basics', async () => {
+  test('update general', async () => {
     let db = (await opendb(null)).db
     let user = db.model('user', {
       fields: {
@@ -423,9 +423,9 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
-  test('findOneAndUpdate basics', async () => {
+  test('findOneAndUpdate general', async () => {
     // todo: test all findOneAndUpdate options
-
+    // todo: test find & update hooks
     let db = (await opendb(null)).db
     let dog = db.model('dog', {
       fields: {
@@ -478,7 +478,7 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
-  test('remove basics', async () => {
+  test('remove general', async () => {
     let db = (await opendb(null)).db
     let user = db.model('userRemove', {
       fields: {

package/test/mock/blacklisting.js

@@ -0,0 +1,122 @@
+module.exports.bird = {
+  schema: function() {
+    return {
+      fields: {
+        color: { type: 'string', default: 'red' },
+        height: { type: 'number' },
+        name: { type: 'string' },
+        sub: {
+          color: { type: 'string', default: 'red' },
+        },
+        wing: {
+          size: { type: 'number' },
+          sizes: {
+            one: { type: 'number' },
+            two: { type: 'number' },
+          }
+        },
+      },
+      findBL: ['wing'],
+    }
+  },
+  mock: function() {
+    return {
+      height: 12,
+      name: 'Ponyo',
+      sub: {},
+      wing: { size: 1, sizes: { one: 1, two: 1 }},
+    }
+  },
+}
+
+module.exports.user = {
+  schema: function() {
+    return {
+      fields: {
+        bird: { model: 'bird' },
+        list: [{ type: 'number' }],
+        dog: { type: 'string' },
+        pet: { type: 'string' },
+        pets: [{
+          name: { type: 'string'},
+          age: { type: 'number'}
+        }],
+        animals: {
+          cat: { type: 'string' },
+          dog: { type: 'string' }
+        },
+        hiddenPets: [{
+          name: { type: 'string'}
+        }],
+        hiddenList: [{ type: 'number'}],
+        deep: {
+          deep2: {
+            deep3: {
+              deep4: { type: 'string' }
+            }
+          }
+        },
+        deeper: {
+          deeper2: {
+            deeper3: {
+              deeper4: { type: 'string' }
+            }
+          }
+        },
+        deepModel: {
+          myBird: { model: 'bird' }
+        },
+        hiddenDeepModel: {
+          myBird: { model: 'bird' }
+        },
+      },
+      findBL: [
+        'dog',
+        'animals.cat',
+        'pets.age',
+        'hiddenPets',
+        'hiddenList',
+        'deep.deep2.deep3',
+        'deeper',
+        'hiddenDeepModel',
+      ],
+    }
+  },
+  mock: function(bird1) {
+    return {
+      bird: bird1._id,
+      list: [44, 54],
+      dog: 'Bruce',
+      pet: 'Freddy',
+      pets: [{ name: 'Pluto', age: 5 }, { name: 'Milo', age: 4 }],
+      animals: {
+        cat: 'Ginger',
+        dog: 'Max'
+      },
+      hiddenPets: [{
+        name: 'secretPet'
+      }],
+      hiddenList: [12, 23],
+      deep: {
+        deep2: {
+          deep3: {
+            deep4: 'hideme'
+          }
+        }
+      },
+      deeper: {
+        deeper2: {
+          deeper3: {
+            deeper4: 'hideme'
+          }
+        }
+      },
+      deepModel: {
+        myBird: bird1._id
+      },
+      hiddenDeepModel: {
+        myBird: bird1._id
+      }
+    }
+  },
+}