monastery 1.33.0 → 1.36.0

package/lib/model-validate.js

@@ -3,88 +3,63 @@ let rules = require('./rules')
 
 module.exports = {
 
-  validate: function(data, opts, cb) {
+  validate: async 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
-    if (util.isFunction(opts)) { cb = opts; opts = undefined }
+    if (util.isFunction(opts)) {
+      cb = opts; opts = undefined
+    }
     if (cb && !util.isFunction(cb)) {
       throw new Error(`The callback passed to ${this.name}.validate() is not a function`)
     }
-    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||[])
+    try {
+      data = util.deepCopy(data)
+      opts = opts || {}
+      opts.update = opts.update || opts.findOneAndUpdate
+      opts.insert = !opts.update
+      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.update ? 'update' : 'insert', opts.blacklist)
+
+      // Hook: beforeValidate
+      await util.runSeries(this.beforeValidate.map(f => f.bind(opts, data)))
 
-    // Run before hook, then recurse through the model's fields
-    return util.runSeries(this.beforeValidate.map(f => f.bind(opts, data))).then(() => {
-      return util.toArray(data).map(item => {
+      // Recurse and validate fields
+      let response = util.toArray(data).map(item => {
         let validated = this._validateFields(item, this.fields, item, opts, '')
         if (validated[0].length) throw validated[0]
         else return validated[1]
       })
 
-    // Success/error
-    }).then(data2 => {
-      let response = util.isArray(data)? data2 : data2[0]
+      // Single document?
+      response = util.isArray(data)? response : response[0]
+
+      // Success/error
       if (cb) cb(null, response)
       else return Promise.resolve(response)
 
-    }).catch(errs => {
-      if (cb) cb(errs)
-      else throw errs
-    })
+    } catch (e) {
+      if (cb) cb(e)
+      else throw e
+    }
   },
 
   _getMostSpecificKeyMatchingPath: function(object, path) {
@@ -140,7 +115,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 +132,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 +193,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)
@@ -72,7 +72,7 @@ let Model = module.exports = function(name, opts, manager) {
   this._setupFields(this.fields = Object.assign({}, this._timestampFields, this.fields))
   this.fieldsFlattened = this._getFieldsFlattened(this.fields, '') // test output?
 
-  // Extend model with monk collection actions
+  // Extend model with monk collection queries
   this._collection = manager.get? manager.get(name, { castIds: false }) : null
   if (!this._collection) {
     this.info('There is no mongodb connection, a lot of the monk/monastery methods will be unavailable')
@@ -83,8 +83,7 @@ let Model = module.exports = function(name, opts, manager) {
   }
 
   // Add model to manager
-  if (typeof this.manager[name] === 'undefined'
-      || typeof this.manager.model[name] !== 'undefined') {
+  if (typeof this.manager[name] === 'undefined' || typeof this.manager.model[name] !== 'undefined') {
     this.manager[name] = this
   } else {
     this.warn(`Your model name '${name}' is conflicting, you are only able to

package/lib/monk-monkey-patches.js

@@ -0,0 +1,73 @@
+let MongoClient = require('mongodb').MongoClient
+
+module.exports.open = function(uri, opts, fn) {
+  /*
+   * Monkey patch to remove db event listener warnings
+   * @todo remove when monk is removed
+   * @see https://www.mongodb.com/community/forums/t/node-44612-deprecationwarning-listening-to-events-on-
+       the-db-class-has-been-deprecated-and-will-be-removed-in-the-next-major-version/15849/4
+   */
+  var STATE = {
+    CLOSED: 'closed',
+    OPENING: 'opening',
+    OPEN: 'open'
+  }
+  MongoClient.connect(uri, opts, function (err, client) {
+    // this = Manager
+    if (err) {
+      this._state = STATE.CLOSED
+      this.emit('error-opening', err)
+    } else {
+      this._state = STATE.OPEN
+
+      this._client = client
+      this._db = client.db()
+
+      // set up events
+      var self = this
+      ;['authenticated', 'close', 'error', 'parseError', 'timeout'].forEach(function (eventName) {
+        self._client.on(eventName, function (e) {
+          self.emit(eventName, e)
+        })
+      })
+
+      this.emit('open', this._db)
+    }
+    if (fn) {
+      fn(err, this)
+    }
+  }.bind(this))
+}
+
+module.exports.findOneAndUpdate = function(query, update, opts, fn) {
+  /*
+   * Monkey patch to use returnDocument
+   * @todo remove when monk is removed
+   * @see https://github.com/Automattic/monk/blob/master/lib/collection.js#L265
+   */
+  // this = model
+  if (typeof opts === 'function') {
+    fn = opts
+    opts = {}
+  }
+  return this._dispatch(function findOneAndUpdate(args) {
+    var method = 'findOneAndUpdate'
+    if (typeof (args.options || {}).returnDocument === 'undefined') {
+      args.options.returnDocument = 'after'
+    }
+    if (args.options.replaceOne | args.options.replace) {
+      method = 'findOneAndReplace'
+    }
+    return args.col[method](args.query, args.update, args.options)
+      .then(function (doc) {
+        if (doc && typeof doc.value !== 'undefined') {
+          return doc.value
+        }
+        if (doc.ok && doc.lastErrorObject && doc.lastErrorObject.n === 0) {
+          return null
+        }
+        return doc
+      })
+  })({options: opts, query: query, update: update, callback: fn}, 'findOneAndUpdate')
+}
+

package/lib/util.js

@@ -140,14 +140,13 @@ module.exports = {
     return typeof value === 'undefined'
   },
 
-  omit: function(obj, keys) {
-    let target = {}
-    for (let i in obj) {
-      if (keys.indexOf(i) >= 0) continue
-      if (!Object.prototype.hasOwnProperty.call(obj, i)) continue
-      target[i] = obj[i]
+  omit: function(obj, fields) {
+    const shallowCopy = Object.assign({}, obj)
+    for (let i=0; i<fields.length; i+=1) {
+      const key = fields[i]
+      delete shallowCopy[key]
     }
-    return target
+    return shallowCopy
   },
 
   parseData: function(obj) {
@@ -228,21 +227,24 @@ module.exports = {
     }
   },
 
-  pluck: function(obj, keys) {
-    let target = {}
-    for (let prop in obj) {
-      let match
-      if (!Object.prototype.hasOwnProperty.call(obj, prop)) continue
-      for (let key of keys) {
-        if (this.isString(key) && key == prop) match = true
-        else if (this.isRegex(key) && prop.match(key)) match = true
+  pick: function(obj, keys) {
+    // Similiar to underscore.pick
+    // @param {string[] | regex[]} keys
+    if (!this.isObject(obj) && !this.isFunction(obj)) return {}
+    keys = this.toArray(keys)
+    let res = {}
+    for (let key of keys) {
+      if (this.isString(key) && obj.hasOwnProperty(key)) res[key] = obj[key]
+      if (this.isRegex(key)) {
+        for (let key2 in obj) {
+          if (obj.hasOwnProperty(key2) && key2.match(key)) res[key2] = obj[key2]
+        }
       }
-      if (match) target[prop] = obj[prop]
     }
-    return target
+    return res
   },
 
-  removeUndefined: (variable) => {
+  removeUndefined: function(variable) {
     // takes an array or object
     if (Array.isArray(variable)) {
       for (let i=variable.length; i--;) {

package/package.json

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

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,7 +93,7 @@ module.exports = function(monastery, opendb) {
       }
     }})
 
-    // Test initial blacklist
+    // initial blacklist
     let find1 = await user.findOne({
       query: user1._id
     })
@@ -107,18 +107,30 @@ 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' }
+    }))
+
+    // blacklist string
+    let find3 = await 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 })
+    expect(find4).toEqual(user1)
 
     db.close()
   })
@@ -219,6 +231,11 @@ module.exports = function(monastery, opendb) {
       _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()
   })
@@ -243,13 +260,13 @@ module.exports = function(monastery, opendb) {
       },
     })
     // default
-    expect(db.user._getBlacklistProjection('find')).toEqual({
+    expect(db.user._getProjectionFromBlacklist('find')).toEqual({
       'bird1.wing': 0,
       'bird1.age': 0,
       'password': 0,
     })
     // blacklist /w invalid field (which goes through)
-    expect(db.user._getBlacklistProjection('find', ['name', 'invalidfield'])).toEqual({
+    expect(db.user._getProjectionFromBlacklist('find', ['name', 'invalidfield'])).toEqual({
       'bird1.wing': 0,
       'bird1.age': 0,
       'invalidfield': 0,
@@ -257,38 +274,38 @@ module.exports = function(monastery, opendb) {
       'password': 0,
     })
     // whitelist
-    expect(db.user._getBlacklistProjection('find', ['-password', '-bird1.age'])).toEqual({
+    expect(db.user._getProjectionFromBlacklist('find', ['-password', '-bird1.age'])).toEqual({
       'bird1.wing': 0,
     })
     // whitelist parent
-    expect(db.user._getBlacklistProjection('find', ['-bird1'])).toEqual({
+    expect(db.user._getProjectionFromBlacklist('find', ['-bird1'])).toEqual({
       'password': 0,
     })
     // whitelist parent, then blacklist child
-    expect(db.user._getBlacklistProjection('find', ['-bird1', 'bird1.name'])).toEqual({
+    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._getBlacklistProjection('find')).toEqual({
+    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._getBlacklistProjection('find', ['bird1'])).toEqual({
+    expect(db.user._getProjectionFromBlacklist('find', ['bird1'])).toEqual({
       'bird1': 0,
     })
     // blacklisted parent with a blacklisted child
-    expect(db.user._getBlacklistProjection('find', ['bird1', 'bird1.wing'])).toEqual({
+    expect(db.user._getProjectionFromBlacklist('find', ['bird1', 'bird1.wing'])).toEqual({
       'bird1': 0,
     })
     // A mess of things
-    expect(db.user._getBlacklistProjection('find', ['-bird1', 'bird1.wing', '-bird1.wing','bird1.wing.size'])).toEqual({
+    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._getBlacklistProjection('find', ['bird1', '-bird1.wing'])).toEqual({
+    // expect(db.user._getProjectionFromBlacklist('find', ['bird1', '-bird1.wing'])).toEqual({
     //   'bird1.age': 0,
     //   'bird1.name': 0,
     // })
@@ -296,7 +313,7 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
-  test('find project', async () => {
+  test('find project basic', async () => {
     // Test mongodb native project option
     // Setup
     let db = (await opendb(null)).db
@@ -370,14 +387,14 @@ module.exports = function(monastery, opendb) {
           color: { type: 'string', default: 'red' },
         }
       },
-      findBL: ['age']
+      findBL: ['age'],
     })
     let user = db.model('user', {
       fields: {
         dog: { type: 'string' },
         bird: { model: 'bird' },
         bird2: { model: 'bird' },
-        bird3: { model: 'bird' }
+        bird3: { model: 'bird' },
       },
       findBL: [
         // allll these should be ignored.....?/////
@@ -390,38 +407,47 @@ module.exports = function(monastery, opendb) {
       name: 'ponyo',
       age: 3,
       height: 40,
-      sub: {}
+      sub: {},
     }})
     let user1 = await user.insert({ data: {
       dog: 'Bruce',
       bird: bird1._id,
       bird2: bird1._id,
-      bird3: bird1._id
+      bird3: bird1._id,
     }})
 
-    // Test project
+    // project
     let find1 = await user.findOne({
       query: user1._id,
       populate: ['bird', 'bird2'],
-      project: ['bird.age', 'bird2']
+      project: ['bird.age', 'bird2'],
     })
     expect(find1).toEqual({
       _id: user1._id,
       bird: { age: 3 },
-      bird2: { _id: bird1._id, age: 3, name: 'ponyo', height: 40, color: 'red', sub: { color: 'red' }}
+      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: ['bird', 'bird2'],
-      project: ['bird', 'bird2.height']
+      project: ['bird', 'bird2.height'],
     })
-    expect(find2).toEqual({
+    let customProject
+    expect(find2).toEqual((customProject={
       _id: user1._id,
       bird: { _id: bird1._id, age: 3, name: 'ponyo', height: 40, color: 'red', sub: { color: 'red' }},
       bird2: { height: 40 },
+    }))
+
+    // project string
+    let find3 = await user.findOne({
+      query: user1._id,
+      populate: ['bird', 'bird2'],
+      project: 'bird bird2.height',
     })
+    expect(find3).toEqual(customProject)
 
     db.close()
   })
@@ -506,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',
@@ -522,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()
   })

package/test/crud.js

@@ -423,14 +423,72 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
-  test('remove basics', async () => {
+  test('findOneAndUpdate basics', async () => {
+    // todo: test all findOneAndUpdate options
+
     let db = (await opendb(null)).db
+    let dog = db.model('dog', {
+      fields: {
+        name: { type: 'string', default: 'Scruff' },
+      }
+    })
     let user = db.model('user', {
+      fields: {
+        name: { type: 'string', default: 'Martin' },
+        dog: { model: 'dog' },
+      }
+    })
+
+    // Returns omitted field after update, i.e. dog
+    let dog1 = await dog.insert({ data: {} })
+    let user1 = await user.insert({ data: { dog: dog1._id }})
+    expect(await user.findOneAndUpdate({ query: { _id: user1._id }, data: { name: 'Martin2' }})).toEqual({
+      _id: user1._id,
+      name: 'Martin2',
+      dog: dog1._id,
+    })
+
+    // Returns omitted field requiring population after update, i.e. dog
+    expect(await user.findOneAndUpdate({
+      query: { _id: user1._id },
+      data: { name: 'Martin2' },
+      populate: ['dog'],
+    })).toEqual({
+      _id: user1._id,
+      name: 'Martin2',
+      dog: {
+        _id: dog1._id,
+        name: 'Scruff'
+      },
+    })
+
+    // Error finding document to update
+    expect(await user.findOneAndUpdate({
+      query: { _id: db.id() },
+      data: { name: 'Martin2' },
+    })).toEqual(null)
+
+    // Error finding document to update (populate)
+    expect(await user.findOneAndUpdate({
+      query: { _id: db.id() },
+      data: { name: 'Martin2' },
+      populate: ['dog'],
+    })).toEqual(null)
+
+    db.close()
+  })
+
+  test('remove basics', async () => {
+    let db = (await opendb(null)).db
+    let user = db.model('userRemove', {
       fields: {
         name: { type: 'string' },
       },
     })
 
+    // Clear (incase of failed a test)
+    user._remove({}, { multi: true })
+
     // Insert multiple
     let inserted2 = await user.insert({ data: [{ name: 'Martin' }, { name: 'Martin' }, { name: 'Martin' }]})
     expect(inserted2).toEqual([

package/test/monk.js

@@ -1,6 +1,6 @@
 module.exports = function(monastery, opendb) {
 
-  test('Monk confilicts', async () => {
+  test('Monk conflicts', async () => {
     // Setup
     let db = (await opendb(false)).db
     let monkdb = require('monk')(':badconnection', () => {})

package/test/util.js

@@ -39,4 +39,11 @@ module.exports = function(monastery, opendb) {
     expect(db.isId('5ff50fe955da2c00170de734')).toEqual(true)
   })
 
+  test('utilities arrayWithSchema', async () => {
+    let db = (await opendb(false)).db
+    let res = db.arrayWithSchema([{ name: { type: 'string' }}], { minLength: 1 })
+    expect(res).toContainEqual({ name: { type: 'string' }})
+    expect(res.schema).toEqual({ minLength: 1 })
+  })
+
 }