monastery 1.32.5 → 1.35.0

package/lib/model-validate.js

@@ -6,21 +6,19 @@ module.exports = {
   validate: function(data, opts, cb) {
     /**
      * Validates a model
-     * @param {instance} model
      * @param {object} data
      * @param {object} <opts>
-     *     @param {boolean(false)} update - are we validating for insert or update?
-     *     @param {array|string|false} blacklist - augment schema blacklist, `false` will remove all blacklisting
-     *     @param {array|string} projection - only return these fields, ignores blacklist
-     *     @param {array|string|false} validateUndefined - validates all 'required' undefined fields, true by
-     *         default, but false on update
-     *     @param {array|string|true} skipValidation - skip validation on these fields
-     *     @param {boolean} timestamps - whether `createdAt` and `updatedAt` are inserted, or `updatedAt` is
+     *     @param {array|string|false} <opts.blacklist> - augment insertBL/updateBL, `false` will remove blacklisting
+     *     @param {array|string} <opts.project> - return only these fields, ignores blacklisting
+     *     @param {array|string|true} <opts.skipValidation> - skip validation on these fields
+     *     @param {boolean} <opts.timestamps> - whether `createdAt` and `updatedAt` are inserted, or `updatedAt` is
      *         updated, depending on the `options.update` value
+     *     @param {boolean(false)} <opts.update> - are we validating for insert or update? todo: change to `type`
+     *     @param {array|string|false} <opts.validateUndefined> - validates all 'required' undefined fields, true by
+     *         default, but false on update
      * @param {function} <cb> - instead of returning a promise
-     * @this model
-
      * @return promise(errors[] || pruned data{})
+     * @this model
      */
 
     // Optional cb and opts
@@ -31,41 +29,12 @@ module.exports = {
     data = util.deepCopy(data)
     opts = opts || {}
     opts.insert = !opts.update
-    opts.action = opts.update? 'update' : 'insert'
-    opts.skipValidation = opts.skipValidation === true? true : util.toArray(opts.skipValidation||[])
+    opts.action = opts.update ? 'update' : 'insert'
+    opts.skipValidation = opts.skipValidation === true ? true : util.toArray(opts.skipValidation||[])
 
-    // Blacklist
-    if (opts.blacklist) {
-      let whitelist = []
-      let blacklist = [ ...this[`${opts.action}BL`] ]
-      if (typeof opts.blacklist === 'string') {
-        opts.blacklist = opts.blacklist.trim().split(/\s+/)
-      }
-      // Auguemnt the schema blacklist
-      for (let _path of opts.blacklist) {
-        let path = _path.replace(/^-/, '')
-        if (_path.match(/^-/)) whitelist.push(path)
-        else blacklist.push(path)
-      }
-      // Remove whitelisted/negated fields
-      blacklist = blacklist.filter(o => !whitelist.includes(o))
-      // Remove any deep blacklisted fields that have a whitelisted parent specified.
-      // E.g remove ['deep.deep2.deep3'] if ['deep'] exists in the whitelist
-      for (let i=blacklist.length; i--;) {
-        let split = blacklist[i].split('.')
-        for (let j=split.length; j--;) {
-          if (split.length > 1) split.pop()
-          else continue
-          if (whitelist.includes(split.join())) {
-            blacklist.splice(i, 1)
-            break
-          }
-        }
-      }
-      opts.blacklist = blacklist
-    } else {
-      opts.blacklist = [ ...this[`${opts.action}BL`] ]
-    }
+    // Get projection
+    if (opts.project) opts.projection = this._getProjectionFromProject(opts.project)
+    else opts.projection = this._getProjectionFromBlacklist(opts.action, opts.blacklist)
 
     // Run before hook, then recurse through the model's fields
     return util.runSeries(this.beforeValidate.map(f => f.bind(opts, data))).then(() => {
@@ -140,7 +109,7 @@ module.exports = {
         let value = util.isArray(fields)? data : (data||{})[fieldName]
         let indexOrFieldName = util.isArray(fields)? i : fieldName
         let path2 = `${path}.${indexOrFieldName}`.replace(/^\./, '')
-        let path3 = path2.replace(/(^|\.)[0-9]+(\.|$)/, '$2') // no numerical keys, e.g. pets.1.name
+        let path3 = path2.replace(/(^|\.)[0-9]+(\.|$)/, '$2') // no numerical keys, e.g. pets.1.name = pets.name
         let isType = 'is' + util.ucFirst(schema.type)
         let isTypeRule = this.rules[isType] || rules[isType]
 
@@ -157,7 +126,7 @@ module.exports = {
         }
 
         // Ignore blacklisted
-        if (opts.blacklist.indexOf(path3) >= 0 && !schema.defaultOverride) return
+        if (this._pathBlacklisted(path3, opts.projection) && !schema.defaultOverride) return
         // Ignore insert only
         if (opts.update && schema.insertOnly) return
         // Ignore virtual fields
@@ -218,8 +187,8 @@ module.exports = {
      * @param {object} field - field schema
      * @param {string} path - full field path
      * @param {object} opts - original validate() options
-     * @this model
      * @return {array} errors
+     * @this model
      */
     let errors = []
     if (opts.skipValidation === true) return []

package/lib/model.js

@@ -9,8 +9,8 @@ let Model = module.exports = function(name, opts, manager) {
    * @param {string} name
    * @param {object} opts - see mongodb colleciton documentation
    * @param {boolean} opts.waitForIndexes
-   * @this model
    * @return Promise(model) | this
+   * @this model
    */
   if (!(this instanceof Model)) {
     return new Model(name, opts, this)
@@ -69,12 +69,8 @@ let Model = module.exports = function(name, opts, manager) {
   }, this)
 
   // Extend default fields with passed in fields and check for invalid fields
-  this.fields = Object.assign({}, this._timestampFields, this.fields)
-  this._setupFieldsAndWhitelists(this.fields)
-
-  //   console.log(0, this.fieldlist)
-  //   console.log(0, this.findBL)
-  //   console.log(0, this.findBLProject)
+  this._setupFields(this.fields = Object.assign({}, this._timestampFields, this.fields))
+  this.fieldsFlattened = this._getFieldsFlattened(this.fields, '') // test output?
 
   // Extend model with monk collection actions
   this._collection = manager.get? manager.get(name, { castIds: false }) : null
@@ -107,52 +103,24 @@ let Model = module.exports = function(name, opts, manager) {
   else this._setupIndexes().catch(errHandler) // returns this
 }
 
-Model.prototype._getFieldlist = function(fields, path) {
-  /**
-   * Get all field paths (without array indices, handy for blacklisting)
-   * @param {object|array} fields - subdocument or array
-   * @param {string} path
-   * @return {array} e.g. ['name', 'pets.dog']
-   */
-  let list = []
-  util.forEach(fields, function(field, fieldName) {
-    // Don't append array indexes to the new path e.g. '0.'
-    let newPath = util.isArray(fields)? path : path + fieldName + '.'
-    if (fieldName == 'schema') {
-      return
-    /*} else if (this.findBL.includes(newPath.replace(/\.$/, ''))) {
-      return*/
-    } else if (util.isArray(field)) {
-      list = list.concat(this._getFieldlist(field, newPath))
-    } else if (util.isSubdocument(field)) {
-      list = list.concat(this._getFieldlist(field, newPath))
-    } else {
-      list.push(newPath.replace(/\.$/, ''))
-    }
-  }, this)
-  return list
-}
-
 Model.prototype._getFieldsFlattened = function(fields, path) {
   /**
    * Flatten fields
-   * @param {object|array} fields - subdocument or array
+   * @param {object|array} fields - can be a nested subdocument or array
    * @param {string} path
-   * @return {object} e.g. ['name', 'pets.dog']
+   * @return {object} e.g. {'name': Schema, 'pets.dog': Schema}
    */
   let obj = {}
   util.forEach(fields, function(field, fieldName) {
-    let newPath = path + fieldName + '.'
+    let newPath = /*util.isArray(fields)? path : */path + fieldName + '.'
     if (fieldName == 'schema') {
       return
     } else if (util.isArray(field)) {
       Object.assign(obj, this._getFieldsFlattened(field, newPath))
     } else if (util.isSubdocument(field)) {
       Object.assign(obj, this._getFieldsFlattened(field, newPath))
-    } else if (fieldName != 'createdAt' && fieldName != 'updatedAt') {
-      if (util.isDefined(field.default)) {
-        obj[newPath.replace(/\.$/, '')] = field
-      }
+    } else {
+      obj[newPath.replace(/\.$/, '')] = field
     }
   }, this)
   return obj
@@ -234,19 +202,6 @@ Model.prototype._setupFields = function(fields) {
   }, this)
 },
 
-Model.prototype._setupFieldsAndWhitelists = function(fields, path) {
-  /**
-   * Setup fields and retrieve a handy schema field list. This can be called mulitple times.
-   * Note: the project fields are only required when finding with projections.
-   * @param {object} fields - can be a nested subdocument or array
-   * @param {string} <path>
-   */
-  this._setupFields(fields)
-  this.fieldlist = this._getFieldlist(fields, path || '')
-  this.defaultFieldsFlattened = this._getFieldsFlattened(fields, path || '') // test output?
-  this.findBLProject = this.findBL.reduce((o, v) => { (o[v] = 0); return o }, {})
-},
-
 Model.prototype._setupIndexes = function(fields, opts={}) {
   /**
    * Creates indexes for the model (multikey, and sub-document supported)

package/package.json

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

package/plugins/images/index.js

@@ -56,8 +56,8 @@ let plugin = module.exports = {
     model.imageFields = plugin._findAndTransformImageFields(model.fields, '')
 
     if (model.imageFields.length) {
-      // Todo?: Update image fields and whitelists with the new object schema
-      //   model._setupFieldsAndWhitelists(model.fields)
+      // Todo?: Update image fields / blacklists with the new object schema
+      //   model._setupFields(model.fields)/model._getFieldsFlattened(model.fields)
       model.beforeValidate.push(function(data, n) {
         plugin.keepImagePlacement(this, data).then(() => n(null, data)).catch(e => n(e))
       })

package/test/blacklisting.js

@@ -1,6 +1,6 @@
 module.exports = function(monastery, opendb) {
 
-  test('find blacklisting', async () => {
+  test('find blacklisting basic', async () => {
     // Setup
     let db = (await opendb(null)).db
     let bird = db.model('bird', {
@@ -93,9 +93,7 @@ module.exports = function(monastery, opendb) {
       }
     }})
 
-    // Note: testing mongodb projections
-
-    // Test initial blacklist
+    // initial blacklist
     let find1 = await user.findOne({
       query: user1._id
     })
@@ -109,50 +107,214 @@ module.exports = function(monastery, opendb) {
       deepModel: { myBird: bird1._id }
     })
 
-    // Test augmented blacklist
+    // augmented blacklist
     let find2 = await user.findOne({
       query: user1._id,
       blacklist: ['pet', 'pet', 'deep', 'deepModel', '-dog', '-animals.cat']
     })
-    expect(find2).toEqual({
+    let customBlacklist
+    expect(find2).toEqual((customBlacklist = {
       _id: user1._id,
       dog: 'Bruce',
       list: [44, 54],
       pets: [{ name: 'Pluto' }, { name: 'Milo' }],
       animals: { dog: 'Max', cat: 'Ginger' }
-    })
+    }))
 
-    // Test positive projection
+    // blacklist string
     let find3 = await user.findOne({
       query: user1._id,
-      project: ['dog', 'list', 'pets.age']
-    })
-    expect(find3).toEqual({
-      _id: user1._id,
-      dog: 'Bruce',
-      list: [44, 54],
-      pets: [{ age: 5 }, { age: 4 }]
+      blacklist: 'pet pet deep deepModel -dog -animals.cat'
     })
+    expect(find3).toEqual(customBlacklist)
 
-    // Test negative projection
-    let find5 = await user.findOne({
-      query: user1._id,
-      project: [
-        '-list', '-hiddenDeepModel', '-pet', '-pet', '-pets', '-deep', '-deeper', '-deepModel',
-        '-dog', '-animals.cat'
+    // blacklist removal
+    let find4 = await 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', {
+      fields: {
+        dog: { type: 'string' },
+        bird1: { model: 'bird' },
+        bird2: { model: 'bird' },
+        bird3: { model: 'bird' },
+        bird4: { model: 'bird' },
+        bird5: { 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)
       ]
     })
-    expect(find5).toEqual({
+    let bird1 = await bird.insert({
+      data: {
+        name: 'ponyo',
+        height: 40,
+        sub: {},
+        wing: { size: 1, sizes: { one: 1, two: 1 }}
+      }
+    })
+    let userData = {
+      dog: 'Bruce',
+      bird1: bird1._id,
+      bird2: bird1._id,
+      bird3: bird1._id,
+      bird4: bird1._id,
+      bird5: bird1._id
+    }
+    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 },
+    })
+    // Test bird2
+    expect(await user.findOne({ query: user1._id, populate: ['bird2'] })).toEqual({
+      ...userData,
       _id: user1._id,
-      animals: { dog: 'Max' },
-      hiddenList: [12, 23],
-      hiddenPets: [{ name: 'secretPet' }]
+      bird2: { ...bird1Base, height: 40, 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 bird4
+    expect(await user.findOne({ query: user1._id, populate: ['bird4'] })).toEqual({
+      ...userData,
+      _id: user1._id,
+      bird4: { ...bird1Base, name: 'ponyo', height: 40 },
+    })
+    // Test bird5
+    expect(await user.findOne({ query: user1._id, populate: ['bird5'] })).toEqual({
+      ...userData,
+      _id: user1._id,
+      bird5: { ...bird1Base, name: 'ponyo', height: 40 },
+    })
+    // blacklist removal
+    expect(await user.findOne({ query: user1._id, blacklist: false, populate: ['bird1'] })).toEqual({
+      ...user1,
+      bird1: { ...bird1Base, height: 40, name: 'ponyo', wing: { size: 1, sizes: { one: 1, two: 1 }} },
+    })
+
+    db.close()
+  })
+
+  test('find blacklisting getProjection', async () => {
+    let db = (await opendb(null)).db
+    // Setup
+    db.model('bird', {
+      fields: {
+        age: { type: 'number' },
+        name: { type: 'string' },
+        wing: {
+          size: { type: 'number' },
+        },
+      },
+      findBL: ['age', 'wing']
+    })
+    db.model('user', {
+      fields: {
+        name: { type: 'string' },
+        bird1: { model: 'bird' },
+      },
+    })
+    // default
+    expect(db.user._getProjectionFromBlacklist('find')).toEqual({
+      'bird1.wing': 0,
+      'bird1.age': 0,
+      'password': 0,
+    })
+    // blacklist /w invalid field (which goes through)
+    expect(db.user._getProjectionFromBlacklist('find', ['name', 'invalidfield'])).toEqual({
+      'bird1.wing': 0,
+      'bird1.age': 0,
+      'invalidfield': 0,
+      'name': 0,
+      'password': 0,
+    })
+    // whitelist
+    expect(db.user._getProjectionFromBlacklist('find', ['-password', '-bird1.age'])).toEqual({
+      'bird1.wing': 0,
+    })
+    // whitelist parent
+    expect(db.user._getProjectionFromBlacklist('find', ['-bird1'])).toEqual({
+      'password': 0,
+    })
+    // whitelist parent, then blacklist child
+    expect(db.user._getProjectionFromBlacklist('find', ['-bird1', 'bird1.name'])).toEqual({
+      'password': 0,
+      'bird1.name': 0,
     })
+    // the model's blacklists are applied after deep model's
+    db.user.findBL = ['-bird1.age']
+    expect(db.user._getProjectionFromBlacklist('find')).toEqual({
+      'bird1.wing': 0,
+    })
+    // custom blacklists are applied after the model's, which are after deep model's
+    db.user.findBL = ['-bird1.age']
+    expect(db.user._getProjectionFromBlacklist('find', ['bird1'])).toEqual({
+      'bird1': 0,
+    })
+    // blacklisted parent with a blacklisted child
+    expect(db.user._getProjectionFromBlacklist('find', ['bird1', 'bird1.wing'])).toEqual({
+      'bird1': 0,
+    })
+    // A mess of things
+    expect(db.user._getProjectionFromBlacklist('find', ['-bird1', 'bird1.wing', '-bird1.wing','bird1.wing.size'])).toEqual({
+      'bird1.wing.size': 0,
+    })
+    // blacklisted parent with a whitelisted child (expect blacklist expansion in future version?)
+    // expect(db.user._getProjectionFromBlacklist('find', ['bird1', '-bird1.wing'])).toEqual({
+    //   'bird1.age': 0,
+    //   'bird1.name': 0,
+    // })
 
     db.close()
   })
 
-  test('find blacklisting (default fields)', async () => {
+  test('find project basic', async () => {
+    // Test mongodb native project option
     // Setup
     let db = (await opendb(null)).db
     let user = db.model('user', {
@@ -184,7 +346,6 @@ module.exports = function(monastery, opendb) {
     let find1 = await user.findOne({
       query: user1._id,
       project: ['animal.name', 'animals.name']
-      //blacklist: ['animal.color', 'animals']
     })
     expect(find1).toEqual({
       _id: user1._id,
@@ -209,98 +370,84 @@ module.exports = function(monastery, opendb) {
       ]
     })
 
-    // Test exclusion blacklist
-    let find3 = await user.findOne({
-      query: user1._id,
-      blacklist: ['animal.color', 'animals', 'color']
-    })
-    expect(find3).toEqual({
-      _id: user1._id,
-      name: 'Bruce',
-      animal: { name: 'max' }
-    })
-
     db.close()
   })
 
-  test('find blacklisting (populate)', async () => {
+  test('find project population', async () => {
+    // Test mongodb native project option
     // Setup
     let db = (await opendb(null)).db
     let bird = db.model('bird', {
       fields: {
         name: { type: 'string' },
         age: { type: 'number' },
+        height: { type: 'number' },
         color: { type: 'string', default: 'red' },
         sub: {
           color: { type: 'string', default: 'red' },
         }
-      }
+      },
+      findBL: ['age'],
     })
     let user = db.model('user', {
       fields: {
         dog: { type: 'string' },
-        myBird: { model: 'bird' },
-        myBird2: { model: 'bird' }
+        bird: { model: 'bird' },
+        bird2: { model: 'bird' },
+        bird3: { model: 'bird' },
       },
+      findBL: [
+        // allll these should be ignored.....?/////
+        'bird.name',                             // bird.name & bird.age blacklisted
+        '-bird2', 'bird2.name',                  // bird2.name blacklisted
+        'bird3.name', '-bird3', 'bird3.height',  // bird3.height blacklisted
+      ]
     })
     let bird1 = await bird.insert({ data: {
       name: 'ponyo',
       age: 3,
-      sub: {}
+      height: 40,
+      sub: {},
     }})
     let user1 = await user.insert({ data: {
       dog: 'Bruce',
-      myBird: bird1._id,
-      myBird2: bird1._id
+      bird: bird1._id,
+      bird2: bird1._id,
+      bird3: bird1._id,
     }})
 
-    // Test project
+    // project
     let find1 = await user.findOne({
       query: user1._id,
-      populate: ['myBird', 'myBird2'],
-      project: ['myBird.age', 'myBird2']
+      populate: ['bird', 'bird2'],
+      project: ['bird.age', 'bird2'],
     })
     expect(find1).toEqual({
       _id: user1._id,
-      myBird: { age: 3 },
-      myBird2: { _id: bird1._id, age: 3, name: 'ponyo', color: 'red', sub: { color: 'red' }},
+      bird: { age: 3 },
+      bird2: { _id: bird1._id, age: 3, name: 'ponyo', height: 40, color: 'red', sub: { color: 'red' }},
     })
 
-    // Test project (different project details)
+    // project (different project details)
     let find2 = await user.findOne({
       query: user1._id,
-      populate: ['myBird', 'myBird2'],
-      project: ['myBird', 'myBird2.age']
-    })
-    expect(find2).toEqual({
-      _id: user1._id,
-      myBird: { _id: bird1._id, age: 3, name: 'ponyo', color: 'red', sub: { color: 'red' }},
-      myBird2: { age: 3 },
-    })
-
-    // Test blacklisting
-    let find22 = await user.findOne({
-      query: user1._id,
-      populate: ['myBird', 'myBird2'],
-      blacklist: ['dog', 'myBird2.name', 'myBird2._id']
+      populate: ['bird', 'bird2'],
+      project: ['bird', 'bird2.height'],
     })
-    expect(find22).toEqual({
+    let customProject
+    expect(find2).toEqual((customProject={
       _id: user1._id,
-      myBird: { _id: bird1._id, age: 3, name: 'ponyo', color: 'red', sub: { color: 'red' }},
-      myBird2: { age: 3, color: 'red', sub: { color: 'red' }}
-    })
+      bird: { _id: bird1._id, age: 3, name: 'ponyo', height: 40, color: 'red', sub: { color: 'red' }},
+      bird2: { height: 40 },
+    }))
 
-    // Test blacklisting overrides
+    // project string
     let find3 = await user.findOne({
       query: user1._id,
-      populate: ['myBird', 'myBird2'],
-      blacklist: ['dog', 'myBird2.name', 'myBird2._id', '-myBird2']
-    })
-    expect(find3).toEqual({
-      _id: user1._id,
-      myBird: { _id: bird1._id, age: 3, name: 'ponyo', color: 'red', sub: { color: 'red' }},
-      myBird2: { _id: bird1._id, age: 3, name: 'ponyo', color: 'red', sub: { color: 'red' }}
+      populate: ['bird', 'bird2'],
+      project: 'bird bird2.height',
     })
+    expect(find3).toEqual(customProject)
 
     db.close()
   })
@@ -385,7 +532,8 @@ module.exports = function(monastery, opendb) {
         '-deep' // blacklist a parent
       ],
     })
-    expect(user2).toEqual({
+    let customBlacklist
+    expect(user2).toEqual((customBlacklist = {
       list: [44, 54],
       dog: 'Bruce',
       pet: 'Freddy',
@@ -401,6 +549,36 @@ module.exports = function(monastery, opendb) {
           }
         }
       }
+    }))
+
+    // Blacklist string
+    let user3 = await user.validate(doc1, {
+      blacklist: '-dog -animals.dog pets.name -hiddenList -deep'
+    })
+    expect(user3).toEqual(customBlacklist)
+
+    // Blacklist removal
+    let user4 = await user.validate(doc1, { blacklist: false })
+    expect(user4).toEqual(doc1)
+
+    // Project whitelist
+    let user5 = await user.validate(doc1, {
+      project: [
+        'dog',
+        'pets.name',
+        'deep'
+      ],
+    })
+    expect(user5).toEqual({
+      dog: 'Bruce',
+      pets: [ {name: 'Pluto'}, {name: 'Milo'} ],
+      deep: {
+        deep2: {
+          deep3: {
+            deep4: 'hideme'
+          }
+        }
+      }
     })
     db.close()
   })