monastery 1.35.0 → 1.36.0

package/changelog.md

@@ -2,12 +2,27 @@
 
 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.0](https://github.com/boycce/monastery/compare/1.35.0...1.36.0) (2022-04-15)
+
+
+### Features
+
+* added findOneAndUpdate ([60b518a](https://github.com/boycce/monastery/commit/60b518a1d09002a794e72fe3476c39c43c0c3b5e))
+
+
+### Bug Fixes
+
+* removed depreciation warnings ([6db73bb](https://github.com/boycce/monastery/commit/6db73bba7916b4c5c98a24fd03b34c0f776abb5c))
+
 ## [1.35.0](https://github.com/boycce/monastery/compare/1.34.0...1.35.0) (2022-04-08)
 
 
 ### Features
 
-* `false` removes blacklist, added tests for blacklisting/project stirng ([5999859](https://github.com/boycce/monastery/commit/599985972cc14b980148db26c03108feabf23756))
+* Blacklist `false` removes all blacklisting, added tests for blacklisting/project stirng ([5999859](https://github.com/boycce/monastery/commit/599985972cc14b980148db26c03108feabf23756))
+* Add project to insert/update/validate ([1b1eb12](https://github.com/boycce/monastery/commit/1b1eb12bc476ff82445a46489db64b37c13f9513))
+* Whitelisting a parent will remove any previously blacklisted children ([1b1eb12](https://github.com/boycce/monastery/commit/1b1eb12bc476ff82445a46489db64b37c13f9513))
+* Blacklist/project works the same across find/insert/update/validate ([1b1eb12](https://github.com/boycce/monastery/commit/1b1eb12bc476ff82445a46489db64b37c13f9513))
 
 ## [1.34.0](https://github.com/boycce/monastery/compare/1.33.0...1.34.0) (2022-04-05)
 

package/docs/readme.md

@@ -87,7 +87,7 @@ Coming soon...
 - Add before/afterInsertUpdate
 - Bug: Setting an object literal on an ID field ('model') saves successfully
 - Population within array items
-- ~~Blacklist `false` removes all blacklisting~~
+- ~~Blacklist false removes all blacklisting~~
 - ~~Add project to insert/update/validate~~
 - ~~Whitelisting a parent will remove any previously blacklisted children~~
 - ~~Blacklist/project works the same across find/insert/update/validate~~

package/lib/index.js

@@ -1,6 +1,10 @@
-let util = require('./util')
-let monk = require('monk')
 let debug = require('debug')
+let monk = require('monk')
+let util = require('./util')
+
+// Apply monk monkey patches
+monk.manager.prototype.open = require('./monk-monkey-patches').open
+monk.Collection.prototype.findOneAndUpdate = require('./monk-monkey-patches').findOneAndUpdate
 
 module.exports = function(uri, opts, fn) {
   /**
@@ -12,59 +16,51 @@ module.exports = function(uri, opts, fn) {
    * @param {object} opts
    * @return monk manager
    */
+  let monasteryOpts = [
+    'defaultObjects', 'imagePlugin', 'limit', 'nullObjects', 'timestamps', 'useMilliseconds'
+  ]
+
   if (!opts) opts = {}
   if (util.isDefined(opts.defaultFields)) {
     var depreciationWarningDefaultField = true
     opts.timestamps = opts.defaultFields
+    delete opts.defaultFields
+  }
+  if (!util.isDefined(opts.timestamps)) {
+    opts.timestamps = true
   }
-  let defaultObjects = opts.defaultObjects
-  let imagePlugin = opts.imagePlugin
-  let limit = opts.limit
-  let nullObjects = opts.nullObjects
-  let timestamps = util.isDefined(opts.timestamps)? opts.timestamps : true
-  let useMilliseconds = opts.useMilliseconds
-  delete opts.defaultFields
-  delete opts.defaultObjects
-  delete opts.imagePlugin
-  delete opts.limit
-  delete opts.nullObjects
-  delete opts.timestamps
-  delete opts.useMilliseconds
 
-  // Monk Manager instance or manager mock
+  // Monk manager instance or manager mock
   // Monk manager instances have manager._db defined which is the raw mongodb connection
   if (typeof uri === 'object') var manager = uri
-  else if (uri) manager = monk(uri, { useUnifiedTopology: true, ...opts }, fn)
+  else if (uri) manager = monk(uri, { useUnifiedTopology: true, ...util.omit(opts, monasteryOpts) }, fn)
   else manager = { id: monk.id }
 
   // Add monastery properties
-  manager.error = debug('monastery:error*')
-  manager.warn = debug('monastery:warn')
-  manager.info = debug('monastery:info')
-  manager.model = require('./model')
-  manager.models = models
-  manager.defaultObjects = defaultObjects
-  manager.imagePlugin = imagePlugin
+  manager.arrayWithSchema = arrayWithSchema
+  manager.beforeModel = []
   manager.imagePluginFile = require('../plugins/images')
   manager.isId = util.isId.bind(util)
-  manager.limit = limit
-  manager.nullObjects = nullObjects
+  manager.model = require('./model')
+  manager.models = models
   manager.parseData = util.parseData.bind(util)
-  manager.timestamps = timestamps
-  manager.useMilliseconds = useMilliseconds
-  manager.beforeModel = []
-  manager.arrayWithSchema = manager.arraySchema = (array, schema) => {
-    array.schema = schema; return array
+  manager.warn = debug('monastery:warn')
+  manager.error = debug('monastery:error*')
+  manager.info = debug('monastery:info')
+
+  // Add opts onto manager
+  for (let key of monasteryOpts) {
+    manager[key] = opts[key]
   }
 
   // Depreciation warnings
   if (depreciationWarningDefaultField) {
-    manager.error('manager.defaultFields has been depreciated in favour of manager.timestamps')
+    manager.error('opts.defaultFields has been depreciated in favour of opts.timestamps')
   }
 
   // Initiate any plugins
   if (manager.imagePlugin) {
-    manager.imagePluginFile.setup(manager, util.isObject(imagePlugin)? imagePlugin : {})
+    manager.imagePluginFile.setup(manager, util.isObject(manager.imagePlugin)? manager.imagePlugin : {})
   }
 
   // Catch mongodb connectivity errors
@@ -72,11 +68,17 @@ module.exports = function(uri, opts, fn) {
   return manager
 }
 
-function models(path) {
+let arrayWithSchema = function(array, schema) {
+  array.schema = schema
+  return array
+}
+
+let models = function(path) {
   /**
    * Setup model definitions from a folder location
    * @param {string} pathname
    * @return {object} - e.g. { user: , article: , .. }
+   * @this Manager
    */
   let models = {}
   if (!path || typeof path !== 'string') {

package/lib/model-crud.js

@@ -65,7 +65,7 @@ module.exports = {
     }
     try {
       opts = await this._queryObject(opts, 'find', one)
-      let custom = ['blacklist', 'one', 'populate', 'project', 'query', 'respond']
+      let custom = ['blacklist', 'model', 'one', 'populate', 'project', 'query', 'respond']
       let lookups = []
 
       // Get projection
@@ -152,11 +152,56 @@ module.exports = {
     return this.find(opts, cb, true)
   },
 
-  findOneAndUpdate: function(opts, cb) {
-    return this._findOneAndUpdate(opts, cb)
+  findOneAndUpdate: async function(opts, cb) {
+    /**
+     * 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
+     *         default, but false on update
+     * @param {function} <cb> - execute cb(err, data) instead of responding
+     * @return promise
+     * @this model
+     */
+
+    if (opts.populate) {
+      try {
+        // todo: add transaction flag
+        delete opts.multi
+        let update = await this.update(opts, null, 'findOneAndUpdate')
+        if (update) var response = await this.findOne(opts)
+        else response = update
+
+        // Success
+        if (cb) cb(null, response)
+        else if (opts.req && opts.respond) opts.req.res.json(response)
+        else return Promise.resolve(response)
+
+      } catch (e) {
+        if (cb) cb(e)
+        else if (opts && opts.req && opts.respond) opts.req.res.error(e)
+        else throw e
+      }
+    } else {
+      return this.update(opts, cb, 'findOneAndUpdate')
+    }
   },
 
-  update: async function(opts, cb) {
+  update: async function(opts, cb, type='update') {
     /**
      * Updates document(s) with monk after validating data & before hooks.
      * @param {object} opts
@@ -171,41 +216,48 @@ module.exports = {
      *         default, but false on update
      *     @param {any} <any mongodb option>
      * @param {function} <cb> - execute cb(err, data) instead of responding
+     * @param {function} <type> - 'update', or 'findOneAndUpdate'
      * @return promise(data)
      * @this model
      */
     if (cb && !util.isFunction(cb)) {
-      throw new Error(`The callback passed to ${this.name}.update() is not a function`)
+      throw new Error(`The callback passed to ${this.name}.${type}() is not a function`)
     }
     try {
-      opts = await this._queryObject(opts, 'update')
+      opts = await this._queryObject(opts, type)
       let data = opts.data
       let response = null
-      let operators = util.pluck(opts, [/^\$/])
-      let custom = ['blacklist', 'data', 'query', 'respond', 'skipValidation', 'validateUndefined']
+      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) && util.isEmpty(operators)) {
-        throw new Error(`Please pass an update operator to ${this.name}.update(), e.g. data, $unset, etc`)
+        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}.update({ 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}.update()\``)
+        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'
       // Update
-      let update = await this._update(opts.query, operators, util.omit(opts, custom))
-      if (update.n) response = Object.assign(Object.create({ _output: update }), operators['$set']||{})
+      let update = await this['_' + type](opts.query, operators, util.omit(opts, custom))
+      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 (update.n) await util.runSeries(this.afterUpdate.map(f => f.bind(opts, response)))
+      if (response) await util.runSeries(this.afterUpdate.map(f => f.bind(opts, response)))
 
       // Success
       if (cb) cb(null, response)
@@ -236,7 +288,7 @@ module.exports = {
     }
     try {
       opts = await this._queryObject(opts, 'remove')
-      let custom =  ['query', 'respond']
+      let custom =  ['model', 'query', 'respond']
       if (util.isEmpty(opts.query)) throw new Error('Please specify opts.query')
 
       // Remove
@@ -368,7 +420,7 @@ module.exports = {
     /**
      * Normalise options
      * @param {MongoId|string|object} opts
-     * @param {string} type - operation type
+     * @param {string} type - insert, update, find, remove, findOneAndUpdate
      * @param {boolean} one - return one document
      * @return {Promise} opts
      * @this model
@@ -397,7 +449,7 @@ module.exports = {
         throw new Error('Please pass an object or MongoId to options.query')
       }
       if (util.isId(opts.query._id)) opts.query._id = this.manager.id(opts.query._id)
-      if (isIdType(opts.query._id) || one) opts.one = true
+      if (isIdType(opts.query._id) || one || type == 'findOneAndUpdate') opts.one = true
       opts.query = util.removeUndefined(opts.query)
 
       // Query options
@@ -417,7 +469,7 @@ module.exports = {
     if (util.isDefined(opts.data)) opts.data = await util.parseData(opts.data)
 
     opts.type = type
-    opts[type] = true
+    opts[type] = true // still being included in the operation options..
     opts.model = this
     return opts
   },

package/lib/model-validate.js

@@ -3,7 +3,7 @@ let rules = require('./rules')
 
 module.exports = {
 
-  validate: function(data, opts, cb) {
+  validate: async function(data, opts, cb) {
     /**
      * Validates a model
      * @param {object} data
@@ -22,38 +22,44 @@ module.exports = {
      */
 
     // 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||[])
+
+      // Get projection
+      if (opts.project) opts.projection = this._getProjectionFromProject(opts.project)
+      else opts.projection = this._getProjectionFromBlacklist(opts.update ? 'update' : 'insert', opts.blacklist)
 
-    // Get projection
-    if (opts.project) opts.projection = this._getProjectionFromProject(opts.project)
-    else opts.projection = this._getProjectionFromBlacklist(opts.action, 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) {

package/lib/model.js

@@ -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.35.0",
+  "version": "1.36.0",
   "license": "MIT",
   "repository": "github:boycce/monastery",
   "homepage": "https://boycce.github.io/monastery/",

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', () => {})