monastery 2.2.2 → 3.0.0

package/lib/model.js

@@ -1,13 +1,11 @@
-let crud = require('./model-crud.js')
-let rules = require('./rules.js')
-let util = require('./util.js')
-let validate = require('./model-validate.js')
+const rules = require('./rules.js')
+const util = require('./util.js')
 
-let Model = module.exports = function(name, opts, manager) {
+function Model(name, opts, manager) {
   /**
-   * Setup a model (aka monk collection)
+   * Setup a model
    * @param {string} name
-   * @param {object} opts - see mongodb colleciton documentation
+   * @param {object} opts - see mongodb collection documentation
    * @param {boolean} opts.waitForIndexes
    * @return Promise(model) | this
    * @this model
@@ -112,26 +110,22 @@ let Model = module.exports = function(name, opts, manager) {
   this._setupFields(this.fields = Object.assign({}, this._defaultFields, this.fields))
   this.fieldsFlattened = this._getFieldsFlattened(this.fields, '') // test output?
 
-  // 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')
-  }
-  for (let key in (this._collection || {})) {
-    if (key.match(/^manager$|^options$|^_|^middlewares$|^name$/)) continue
-    this['_' + key] = this._collection[key].bind(this._collection)
+  // Get collection, and extend model with collection methods
+  this.collection = this.manager.get(name, { castIds: false })
+  for (let key in Object.getPrototypeOf(this.collection||{})) {
+    this['_' + key] = this.collection[key].bind(this.collection)
   }
 
   // Add model to manager
-  if (typeof this.manager[name] === 'undefined' || typeof this.manager.model[name] !== 'undefined') {
-    this.manager[name] = this
-  } else {
+  if (typeof this.manager[name] !== 'undefined' && typeof this.manager.models[name] === 'undefined') {
     this.warn(`Your model name '${name}' is conflicting with an builtin manager property, you are only able to
-    access this model via \`db.model.${name}\``)
+    access this model via \`db.models.${name}\``)
+  } else {
+    this.manager[name] = this
   }
 
-  // Add model to manager.model
-  this.manager.model[name] = this
+  // Add model to manager.models
+  this.manager.models[name] = this
 
   // Setup/Ensure field indexes exist in MongoDB
   let errHandler = err => {
@@ -212,8 +206,8 @@ Model.prototype._setupFields = function(fields) {
 
     // Fields be an array
     } else if (util.isArray(field)) {
-      let arrayDefault = this.manager.defaultObjects? () => [] : undefined
-      let nullObject = this.manager.nullObjects
+      let arrayDefault = this.manager.opts.defaultObjects? () => [] : undefined
+      let nullObject = this.manager.opts.nullObjects
       let virtual = field.length == 1 && (field[0]||{}).virtual ? true : undefined
       field.schema = {
         type: 'array',
@@ -221,14 +215,14 @@ Model.prototype._setupFields = function(fields) {
         default: arrayDefault,
         nullObject: nullObject,
         virtual: virtual,
-        ...(field.schema || {})
+        ...(field.schema || {}),
       }
       this._setupFields(field)
 
     // Fields can be a subdocument, e.g. user.pet = { name: {}, ..}
     } else if (util.isSubdocument(field)) {
-      let objectDefault = this.manager.defaultObjects? () => ({}) : undefined
-      let nullObject = this.manager.nullObjects
+      let objectDefault = this.manager.opts.defaultObjects? () => ({}) : undefined
+      let nullObject = this.manager.opts.nullObjects
       let index2dsphere = util.isSubdocument2dsphere(field)
       field.schema = field.schema || {}
       if (index2dsphere) {
@@ -240,21 +234,20 @@ Model.prototype._setupFields = function(fields) {
         isObject: true, 
         default: objectDefault, 
         nullObject: nullObject, 
-        ...field.schema 
+        ...field.schema, 
       }
       this._setupFields(field)
     }
   }, this)
 },
 
-Model.prototype._setupIndexes = function(fields, opts={}) {
+Model.prototype._setupIndexes = async function(fields, opts={}) {
   /**
    * Creates indexes for the model (multikey, and sub-document supported)
+   * Note: the collection be created beforehand???
    * Note: only one text index per model(collection) is allowed due to mongodb limitations
-   * @link https://docs.mongodb.com/manual/reference/command/createIndexes/
-   * @link https://mongodb.github.io/node-mongodb-native/2.1/api/Collection.html#createIndexes
    * @param {object} <fields>
-   * @return Promise( {array} indexes ensured | {string} error )
+   * @return Promise( {array} indexes ensured ) || error
    *
    * MongoDB index structures = [
    *   true =     { name: 'name_1', key: { name: 1 } },
@@ -264,73 +257,61 @@ Model.prototype._setupIndexes = function(fields, opts={}) {
    *   ..
    * ]
    */
-  let collection
   let hasTextIndex = false
   let indexes = []
   let model = this
   let textIndex = { name: 'text', key: {} }
 
   // No db defined
-  if (!(model.manager._state || '').match(/^open/)) {
-    let error = {
-      type: 'info',
-      detail: `Skipping createIndex on the '${model.name}' model, no mongodb connection found.`
-    }
-    return Promise.reject(error)
+  if (!model.manager?._state?.match(/^open/)) {
+    throw new Error(`Skipping createIndex on the '${model.name||''}' model, no mongodb connection found.`)
   }
 
   // Find all indexes
   recurseFields(fields || model.fields, '')
   // console.log(2, indexes, fields)
   if (hasTextIndex) indexes.push(textIndex)
-  if (opts.dryRun) return Promise.resolve(indexes || [])
-  if (!indexes.length) return Promise.resolve([]) // No indexes defined
+  if (opts.dryRun) return indexes || []
+  if (!indexes.length) return [] // No indexes defined
 
   // Create indexes
-  return (model.manager._state == 'open'? new Promise(res => res()) : model.manager)
-    .then(data => {
-      // Collection exist?
-      collection = model.manager._db.collection(model.name)
-      return model.manager._db.listCollections({ name: model.name }).toArray()
-    })
-    .then(collections => {
-      // Get the collection's indexes
-      if (collections.length > 0) return collection.indexes()
-      else return Promise.resolve([])
-    })
-    .then(existingIndexes => {
-      // Remove any existing text index that has different options as createIndexes will throws error about this
-      let indexNames = []
-      if (!existingIndexes.length) return new Promise(res => res())
-      // console.log(0, textIndex)
-      // console.log(1, existingIndexes, indexes)
-      // Todo: Remove unused index names
+  // As of MongoDB 5 we no longer need to wait for the connection to be open
+  //   await (model.manager._state == 'open' ? new Promise(res => res()) : model.manager).then()....
+
+  // Get collection
+  const collection = this.collection
+
+  // Get the collections indexes
+  const existingIndexes = await collection.indexes() // returns [] if collection doesn't exist
 
-      for (let existingIndex of existingIndexes) {
-        if (!existingIndex.textIndexVersion) continue
-        for (let index of indexes) {
-          let fieldsInTextIndex1 = Object.keys(existingIndex.weights).sort().join()
-          let fieldsInTextIndex2 = Object.keys(index.key).sort().join()
-          if (existingIndex.name == index.name && fieldsInTextIndex1 !== fieldsInTextIndex2) {
-            model.info(`Text index options are different for '${existingIndex.name}', removing old text index`)
-            indexNames.push(existingIndex.name)
-            break
+  // Remove any existing text index that has different options as createIndexes will throws error about this
+  if (existingIndexes.length) {
+    // console.log(0, textIndex)
+    // console.log(1, existingIndexes, indexes)
+    // Todo: Remove unused index names
+    const textIndexNames = []
+    for (let existingIndex of existingIndexes) {
+      if (!existingIndex.textIndexVersion) continue
+      for (let index of indexes) {
+        let fieldsInTextIndex1 = Object.keys(existingIndex.weights).sort().join()
+        let fieldsInTextIndex2 = Object.keys(index.key).sort().join()
+        if (existingIndex.name == index.name && fieldsInTextIndex1 !== fieldsInTextIndex2) {
+          model.info(`Text index options are different for '${existingIndex.name}', removing old text index`)
+          if (!textIndexNames.includes(existingIndex.name)) {
+            textIndexNames.push(existingIndex.name)
           }
         }
       }
+    }
+    for (let name of textIndexNames) {
+      await collection.dropIndex(name)
+    }
+  }
 
-      if (indexNames.length > 1) return collection.dropIndex(indexNames)
-      else if (indexNames.length) return collection.dropIndex(indexNames[0])
-      else return new Promise(res => res())
-    })
-    .then(() => {
-      // Ensure/create indexes
-      return collection.createIndexes(indexes)
-    })
-    .then(response => {
-      model.info('db index(s) created for ' + model.name)
-      return indexes
-    })
+  // create indexes
+  await collection.createIndexes(indexes)
+  model.info('db index(s) created for ' + model.name)
+  return indexes
 
   function recurseFields(fields, parentPath) {
     util.forEach(fields, (field, name) => {
@@ -362,29 +343,27 @@ Model.prototype._setupIndexes = function(fields, opts={}) {
 Model.prototype._defaultFields = {
   _id: {
     insertOnly: true,
-    type: 'id'
+    type: 'id',
   },
   createdAt: {
     default: function(fieldName, model) {
-      return model.manager.useMilliseconds? Date.now() : Math.floor(Date.now() / 1000)
+      return model.manager.opts.useMilliseconds? Date.now() : Math.floor(Date.now() / 1000)
     },
     insertOnly: true,
     timestampField: true,
-    type: 'integer'
+    type: 'integer',
   },
   updatedAt: {
     default: function(fieldName, model) {
-      return model.manager.useMilliseconds? Date.now() : Math.floor(Date.now() / 1000)
+      return model.manager.opts.useMilliseconds? Date.now() : Math.floor(Date.now() / 1000)
     },
     timestampField: true,
-    type: 'integer'
-  }
+    type: 'integer',
+  },
 }
 
-for (let key in crud) {
-  Model.prototype[key] = crud[key]
-}
+module.exports = Model
 
-for (let key in validate) {
-  Model.prototype[key] = validate[key]
-}
+// Extend Model prototype
+require('./model-crud.js')
+require('./model-validate.js')

package/lib/rules.js

@@ -1,6 +1,7 @@
 // Todo: remove stringnums in date/number/integer rules
-let ObjectId = require('mongodb').ObjectId
-let util = require('./util.js')
+const ObjectId = require('mongodb').ObjectId
+const util = require('./util.js')
+const validator = require('validator')
 
 module.exports = {
 
@@ -12,7 +13,7 @@ module.exports = {
     fn: function(x) {
       if (util.isArray(x) && !x.length) return false
       return x || x === 0 || x === false? true : false
-    }
+    },
   },
 
   // "Type" rules below ignore undefined and null
@@ -28,7 +29,7 @@ module.exports = {
     },
     fn: function(x) {
       return typeof x === 'boolean'
-    }
+    },
   },
   isArray: {
     validateEmptyString: true,
@@ -41,7 +42,7 @@ module.exports = {
     },
     fn: function(x) {
       return Array.isArray(x)
-    }
+    },
   },
   isDate: {
     validateEmptyString: true,
@@ -54,7 +55,7 @@ module.exports = {
     fn: function(x) {
       if (util.isString(x) && x.match(/^[+-][0-9]+$/)) return true
       return typeof x === 'number'
-    }
+    },
   },
   isImageObject: {
     validateEmptyString: true,
@@ -70,7 +71,7 @@ module.exports = {
     fn: function(x) {
       let isObject = x !== null && typeof x === 'object' && !(x instanceof Array)
       if (isObject && x.bucket && x.date && x.filename && typeof x.filesize != 'undefined' && x.path && x.uid) return true
-    }
+    },
   },
   isInteger: {
     validateEmptyString: true,
@@ -83,7 +84,7 @@ module.exports = {
     fn: function(x) {
       if (util.isString(x) && x.match(/^[+-][0-9]+$/)) return true
       return typeof x === 'number' && (parseInt(x) === x)
-    }
+    },
   },
   isNumber: {
     validateEmptyString: true,
@@ -96,7 +97,7 @@ module.exports = {
     fn: function(x) {
       if (util.isString(x) && x.match(/^[+-][0-9]+$/)) return true
       return typeof x === 'number'
-    }
+    },
   },
   isObject: {
     validateEmptyString: true,
@@ -109,7 +110,7 @@ module.exports = {
     },
     fn: function(x) {
       return x !== null && typeof x === 'object' && !(x instanceof Array)
-    }
+    },
   },
   isString: {
     validateEmptyString: true,
@@ -120,14 +121,14 @@ module.exports = {
     },
     fn: function(x) {
       return typeof x === 'string'
-    }
+    },
   },
   isAny: {
     validateEmptyString: true,
     message: '',
     fn: function(x) {
       return true
-    }
+    },
   },
   isId: {
     validateEmptyString: true,
@@ -135,14 +136,14 @@ module.exports = {
     tryParse: function(x) {
       // Try and parse value to a mongodb ObjectId
       if (x === '') return null
-      if (util.isString(x) && ObjectId.isValid(x)) return ObjectId(x)
+      if (util.isString(x) && ObjectId.isValid(x)) return new ObjectId(x)
       else return x
     },
     fn: function(x) {
       // Must be a valid mongodb ObjectId
       if (x === null) return true
       return util.isObject(x) && ObjectId.isValid(x)/*x.get_inc*/? true : false
-    }
+    },
   },
 
   /* "Number" rules below ignore undefined and null */
@@ -152,14 +153,14 @@ module.exports = {
     fn: function(x, arg) {
       if (typeof x !== 'number') { throw new Error ('Value was not a number.') }
       return x <= arg
-    }
+    },
   },
   min: {
     message: (x, arg) => 'Value was less than the configured minimum (' + arg + ')',
     fn: function(x, arg) {
       if (typeof x !== 'number') { throw new Error ('Value was not a number.') }
       return x >= arg
-    }
+    },
   },
 
   /* "String" rules below ignore undefined, null, and empty strings */
@@ -170,54 +171,54 @@ module.exports = {
       for (let item of arg) {
         if (x === item + '') return true
       }
-    }
+    },
   },
   isAfter: {
     message: (x, arg) => 'Value was before the configured time (' + arg + ')',
-    fn: function(x, arg) { return require('validator').isAfter(x, arg) }
+    fn: function(x, arg) { return validator.isAfter(x, arg) },
   },
   isBefore: {
     message: (x, arg) => 'Value was after the configured time (' + arg + ')',
-    fn: function(x, arg) { return require('validator').isBefore(x, arg) }
+    fn: function(x, arg) { return validator.isBefore(x, arg) },
   },
   isCreditCard: {
     message: 'Value was not a valid credit card.',
-    fn: function(x, arg) { return require('validator').isCreditCard(x, arg) }
+    fn: function(x, arg) { return validator.isCreditCard(x, arg) },
   },
   isEmail: {
     message: 'Please enter a valid email address.',
-    fn: function(x, arg) { return require('validator').isEmail(x, arg) }
+    fn: function(x, arg) { return validator.isEmail(x, arg) },
   },
   isHexColor: {
     message: 'Value was not a valid hex color.',
-    fn: function(x, arg) { return require('validator').isHexColor(x, arg) }
+    fn: function(x, arg) { return validator.isHexColor(x, arg) },
   },
   isIn: {
     message: (x, arg) => 'Value was not in the configured whitelist (' + arg.join(', ') + ')',
-    fn: function(x, arg) { return require('validator').isIn(x, arg) }
+    fn: function(x, arg) { return validator.isIn(x, arg) },
   },
   isIP: {
     message: 'Value was not a valid IP address.',
-    fn: function(x, arg) { return require('validator').isIP(x, arg) }
+    fn: function(x, arg) { return validator.isIP(x, arg) },
   },
   isNotEmptyString: {
     validateEmptyString: true,
     message: 'Value was an empty string.',
     fn: function(x) {
       return x !== ''
-    }
+    },
   },
   isNotIn: {
     message: (x, arg) => 'Value was in the configured blacklist (' + arg.join(', ') + ')',
-    fn: function(x, arg) { return !require('validator').isIn(x, arg) }
+    fn: function(x, arg) { return !validator.isIn(x, arg) },
   },
   isURL: {
     message: 'Value was not a valid URL.',
-    fn: function(x, arg) { return require('validator').isURL(x, arg === true? undefined : arg) }
+    fn: function(x, arg) { return validator.isURL(x, arg === true? undefined : arg) },
   },
   isUUID: {
     message: 'Value was not a valid UUID.',
-    fn: function(x, arg) { return require('validator').isUUID(x) }
+    fn: function(x, arg) { return validator.isUUID(x) },
   },
   minLength: {
     message: function(x, arg) {
@@ -226,9 +227,9 @@ module.exports = {
     },
     fn: function(x, arg) {
       if (typeof x !== 'string' && !util.isArray(x)) throw new Error ('Value was not a string or an array.')
-      else if (typeof x === 'string') return require('validator').isLength(x, arg)
+      else if (typeof x === 'string') return validator.isLength(x, arg)
       else return x.length >= arg
-    }
+    },
   },
   maxLength: {
     message: function(x, arg) {
@@ -237,16 +238,16 @@ module.exports = {
     },
     fn: function(x, arg) {
       if (typeof x !== 'string' && !util.isArray(x)) throw new Error ('Value was not a string or an array.')
-      else if (typeof x === 'string') return require('validator').isLength(x, 0, arg)
+      else if (typeof x === 'string') return validator.isLength(x, 0, arg)
       else return x.length <= arg
-    }
+    },
   },
   regex: {
     message: (x, arg) => 'Value did not match the configured regular expression (' + arg + ')',
     fn: function(x, arg) {
-      if (util.isRegex(arg)) return require('validator').matches(x, arg)
+      if (util.isRegex(arg)) return validator.matches(x, arg)
       throw new Error('This rule expects a regular expression to be configured, but instead got the '
         + typeof arg + ' `' + arg + '`.')
-    }
-  }
+    },
+  },
 }

package/lib/util.js

@@ -1,14 +1,41 @@
-let ObjectId = require('mongodb').ObjectId
+const { ObjectId } = require('mongodb')
 
 module.exports = {
 
+  cast: function(obj) {
+    /**
+     * Applies ObjectId casting to _id fields.
+     * @param {Object} optional, query
+     * @return {Object} query
+     * @private
+     */
+    if (this.isArray(obj)) {
+      return obj.map(this.cast.bind(this))
+    }
+    if (obj && typeof obj === 'object') {
+      for (let k of Object.keys(obj)) {
+        if (k == '_id' && obj._id) {
+          if (obj._id.$in) obj._id.$in = obj._id.$in.map(this.id.bind(this))
+          else if (obj._id.$nin) obj._id.$nin = obj._id.$nin.map(this.id.bind(this))
+          else if (obj._id.$ne) obj._id.$ne = this.id(obj._id.$ne)
+          else obj._id = this.id(obj._id)
+        } else {
+          obj[k] = this.cast(obj[k])
+        }
+      }
+    }
+
+    return obj
+  },
+
   deepCopy: function(obj) {
     // Deep clones an object
+    // v3.0.0 - MongoIds now remain as objects, not strings. 
     if (!obj) return obj
     let obj2 = Array.isArray(obj)? [] : {}
     for (let key in obj) {
       let v = obj[key]
-      if (this.isId(v)) obj2[key] = v.toString()
+      if (this.isId(v)) obj2[key] = v//.toString()
       else obj2[key] = (typeof v === 'object')? this.deepCopy(v) : v
     }
     return obj2
@@ -31,6 +58,16 @@ module.exports = {
   forceArray: function(value) {
     return this.isArray(value)? value : [value]
   },
+  
+  id: function(str) {
+    /**
+     * Casts to ObjectId
+     * @param {string|ObjectId} str - string = hex string
+     * @return {ObjectId}
+     */
+    if (str == null) return new ObjectId()
+    return typeof str === 'string' ? ObjectId.createFromHexString(str) : str
+  },
 
   inArray: (array, key, value) => {
     /**
@@ -72,8 +109,8 @@ module.exports = {
 
   isId: function(value) {
     // Called from db.isId
-    // True if value is a MongoDB ObjectID() or a valid id string
-    if (this.isObject(value) && value.get_inc) return true
+    // True if value is a MongoDB ObjectId() or a valid id string
+    if (this.isObject(value) && ObjectId.isValid(value)) return true
     else if (value && this.isString(value) && ObjectId.isValid(value)) return true
     else return false
   },
@@ -91,8 +128,8 @@ module.exports = {
   },
 
   isObjectAndNotID: function(value) {
-    // A true object that is not an id, i.e. mongodb ObjectID()
-    return this.isObject(value) && !value.get_inc
+    // A true object that is not an id, i.e. mongodb ObjectId()
+    return this.isObject(value) && !ObjectId.isValid(value) // was value.get_inc
   },
 
   isRegex: function(value) {
@@ -280,15 +317,18 @@ module.exports = {
      * @return promise
      * @source https://github.com/feross/run-series
      */
-    var current = 0
-    var results = []
-    var isSync = true
+    let current = 0
+    let results = []
+    let isSync = true
 
     return new Promise((res, rej) => {
-      function each(err, result) {
+      function each(i, err, result) { // aka next(err, data)
+        if (i == current + 1) {
+          throw new Error('Hook error: you cannot return a promise and call next()')
+        }
         results.push(result)
-        if (++current >= tasks.length || err) done(err)
-        else tasks[current](each)
+        if (!err && ++current < tasks.length) callTask(current)
+        else done(err)
       }
       function done(err) {
         if (isSync) process.nextTick(() => end(err))
@@ -299,8 +339,18 @@ module.exports = {
         if (err) rej(err)
         else res(results)
       }
-      if (tasks.length) tasks[0](each)
-      else done(null)
+      function callTask(i) {
+        const each2 = each.bind(null, i)
+        const res = tasks[i](each2)
+        if (res instanceof Promise) {
+          res.then((result) => each2(null, result)).catch(each2)
+        }
+      }
+      
+      // Start
+      if (!tasks.length) done(null)
+      else callTask(current)
+      
       isSync = false
     })
   },
@@ -356,6 +406,10 @@ module.exports = {
   ucFirst: function(string) {
     if (!string) return ''
     return string.charAt(0).toUpperCase() + string.slice(1)
-  }
+  },
 
+  wait: async function(ms) {
+    return new Promise(res => setTimeout(res, ms))
+  },
+  
 }