monastery 3.4.3 → 3.5.1

package/changelog.md

@@ -2,6 +2,10 @@
 
 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.
 
+### [3.5.1](https://github.com/boycce/monastery/compare/3.5.0...3.5.1) (2024-12-23)
+
+## [3.5.0](https://github.com/boycce/monastery/compare/3.4.3...3.5.0) (2024-12-20)
+
 ### [3.4.3](https://github.com/boycce/monastery/compare/3.4.2...3.4.3) (2024-08-27)
 
 ### [3.4.2](https://github.com/boycce/monastery/compare/3.4.1...3.4.2) (2024-08-24)

package/docs/definition/index.md

@@ -304,7 +304,7 @@ You are able to define custom error messages for each field rule.
 
 ### Operation hooks
 
-You are able provide an array of callbacks to these model operation hooks. If you need to throw an error asynchronously, please pass an error as the first argument to `next()`, e.g. `next(new Error('Your error here'))`. You can also access the operation details via `this` in each callback.
+You are able provide an array of promises to the following model operation hooks. `this` is the operation details.
 
 ```js
 {

package/docs/manager/index.md

@@ -6,7 +6,7 @@ has_children: true
 
 # Manager
 
-Monastery manager constructor.
+Creates a new manager instance and makes the first instance available globally via the `db`.
 
 ### Arguments
 
@@ -24,26 +24,27 @@ Monastery manager constructor.
 
 ### Returns
 
-A manager instance.
+A new manager instance.
 
 ### Example
 
 ```js
-import monastery from 'monastery'
+import db from 'monastery'
 
-const db = monastery('localhost/mydb', options)
+// this manager instance is now available via the `db` object on subsequent imports
+const manager = db.manager('localhost/mydb', options)
 // replica set
-const db = monastery('localhost/mydb,192.168.1.1')
+const manager = db.manager('localhost/mydb,192.168.1.1')
 // you can wait for the connection (which is not required before calling methods)
-const db = await monastery('localhost/mydb,192.168.1.1', { promise: true })
+const manager = await db.manager('localhost/mydb,192.168.1.1', { promise: true })
 ```
 
 You can also listen for errors or successful connection using these hooks
 ```js
-db.onOpen((manager) => {
+manager.onOpen((manager) => {
   // manager.client is connected...
 })
-db.onError((err) => {
+manager.onError((err) => {
   // connection error
 })
 ```

package/docs/readme.md

@@ -35,10 +35,10 @@ $ npm install --save monastery
 ## Usage
 
 ```javascript
-import monastery from 'monastery'
+import db from 'monastery'
 
 // Initialize a monastery manager
-const db = monastery('localhost/mydb')
+db.manager('localhost/mydb')
 
 // Define a model
 db.model('user', {
@@ -96,6 +96,7 @@ You can view MongoDB's [compatibility table here](https://www.mongodb.com/docs/d
   - db.catch/then() moved to db.onError/db.onOpen()
   - next() is now redundant when returning promises from hooks, e.g. `afterFind: [async (data) => {...}]`
   - deep paths in data, e.g. `books[].title` are now validated, and don't replace the whole object, e.g. `books`
+  - `db()` moved to `db.manager()`
 
 ## v2 Breaking Changes
 

package/lib/index.js

@@ -1,301 +1,14 @@
-/*eslint-disable max-len*/
-const fs = require('fs')
-const debug = require('debug')
-const path = require('path')
-const EventEmitter = require('events').EventEmitter
-const inherits = require('util').inherits
-const { MongoClient } = require('mongodb')
-const Collection = require('./collection.js')
-const imagePluginFile = require('../plugins/images/index.js')
-const Model = require('./model.js')
+const Manager = require('./manager')
 const rules = require('./rules.js')
-const util = require('./util.js')
 
-function Manager(uri, opts) {
-  /**
-   * Constructs a new manager which contains a new MongoDB client
-   * 
-   * @param {String|Array|Object} uri - MongoDB connection URI string / replica set, or reuse a MongoClient instance
-   * @param {Object} opts -
-   *   {String} <opts.databaseName> - the name of the database
-   *   {Boolean} <opts.promise(manager)> - return a promise
-   * 
-   * @return {Connection|Promise}
-   * @link https://www.mongodb.com/docs/drivers/node/v5.9/quick-reference/
-   * @link https://mongodb.github.io/node-mongodb-native/ (all versions)
-   */
-  if (!opts) opts = {}
-  if (!(this instanceof Manager)) return new Manager(uri, opts)
-
-  // opts: timestamps
-  if (typeof opts.defaultFields != 'undefined') throw Error('opts.defaultFields has been depreciated, use opts.timestamps')
-  if (typeof opts.timestamps == 'undefined') opts.timestamps = true
-
-  // opts: logLevel
-  if (typeof opts.logLevel == 'undefined') opts.logLevel = 2
-
-  // opts: separate out monastery options
-  const mongoOpts = Object.keys(opts||{}).reduce((acc, key) => {
-    if (
-      ![
-        'databaseName', 'defaultObjects', 'logLevel', 'imagePlugin', 'limit', 'noDefaults', 'nullObjects',
-        'promise', 'timestamps', 'useMilliseconds',
-      ].includes(key)) {
-        acc[key] = opts[key]
-    }
-    return acc
-  }, {})
-
-  // Add properties
-  this.uri = uri
-  this.error = debug('monastery:error' + (opts.logLevel > 0 ? '*' : ''))
-  this.warn = debug('monastery:warn' + (opts.logLevel > 1 ? '*' : ''))
-  this.info = debug('monastery:info' + (opts.logLevel > 2 ? '*' : ''))
-  this.opts = opts
-  this.beforeModel = []
-  this.collections = {}
-  this._openQueue = []
-
-  // If there is no DEBUG= environment variable, we will need to force the debugs on (due to bug on debug@4.3.4)
-  if (!debug.namespaces) {
-    if (opts.logLevel > 0) this.error.enabled = true
-    if (opts.logLevel > 1) this.warn.enabled = true
-    if (opts.logLevel > 2) this.info.enabled = true
-  }
-  
-  // Create a new MongoDB Client
-  if (typeof this.uri == 'string' || Array.isArray(this.uri)) {
-    this.uri = this.connectionString(this.uri, opts.databaseName)
-    this.client = new MongoClient(this.uri, mongoOpts)
-  } else {
-    this.client = this.uri
-  }
-
-  // Listen to MongoDB events
-  for (let eventName of ['close', 'error', 'timeout']) {
-    this.client.on(eventName, (e) => this.emit(eventName, e))
-  }
-
-  // Listen to custom open event
-  this.on('open', () => {
-    // wait for all the on('open') events to get called first
-    setTimeout(() => {
-      for (let item of this._openQueue) {
-        item()
-      }
-    })
-  })
-
-  // Initiate any plugins
-  if (opts.imagePlugin) {
-    imagePluginFile.setup(this, util.isObject(opts.imagePlugin) ? opts.imagePlugin : {})
-  }
-
-  // Expose the last manager
-  module.exports.manager = this
-
-  // Connect to the database
-  if (opts.promise) return this.open()
-  else this.open()
-}
-
-Manager.prototype.arrayWithSchema = function(array, schema) {
-  array.schema = schema
-  return array
-}
-
-Manager.prototype.close = async function() {
-  /**
-   * Close the database connection, gracefully
-   */
-  const _close = async () => {
-    this.emit(this._state = 'closing')
-    await this.client.close()
-    this.emit(this._state = 'close')
-  }
-  if (this._state == 'open') {
-    return await _close()
-
-  } else if (this._state == 'opening') {
-    return new Promise((resolve) => {
-      this._openQueue.push(() => _close().then(resolve))
-    })
-
-  } else if (this._state == 'close' || this._state == 'closing') {
-    return
-  }
-}
-
-Manager.prototype.command = function(...args) {
-  /**
-   * Run a raw MongoDB command
-   */
-  return this.db.command(...args)
-}
-
-Manager.prototype.connectionString = function(uri, databaseName) {
-  /**
-   * get the connection string
-   * @param {string|array} uri
-   * @param {string} <databaseName>
-   * @return {string}
-   */
-  if (!uri) {
-    throw Error('No connection URI provided.')
-  }
-  // uri: array, sort out the connection string
-  if (util.isArray(uri)) {
-    if (!databaseName) {
-      for (var i=0, l=uri.length; i<l; i++) {
-        if (!databaseName) databaseName = uri[i].replace(/([^\/])+\/?/, '') // eslint-disable-line
-        uri[i] = uri[i].replace(/\/.*/, '')
-      }
-    }
-    uri = uri.join(',') + '/' + databaseName
-  }
-  // uri: string, sort out the connection string
-  if (typeof uri === 'string') {
-    if (!/^mongodb(\+srv)?:\/\//.test(uri)) {
-      uri = 'mongodb://' + uri
-    }
-  }
-  return uri
-}
-
-Manager.prototype.get = function(name, options) {
-  /**
-   * Returns a MongoDB collection
-   * @param {String} name
-   * @param {Object} [options] - options to pass to the collection
-   * @return {MongoDB Collection}
-   */
-  if (!this.collections[name] || (options||{}).cache === false) {
-    delete (options||{}).cache
-    this.collections[name] = new Collection(this, name, options)
-  }
-  return this.collections[name]
-}
-
-Manager.prototype.id = function(str) {
-  return util.id(str)
-}
-
-Manager.prototype.isId = function(value) {
-  return util.isId(value)
-}
-
-Manager.prototype.models = async function(pathname, opts) {
-  /**
-   * Setup model definitions from a folder location
-   * @param {string} pathname
-   * @param {object} opts:
-   *   @param {boolean} opts.waitForIndexes - Wait for indexes to be created?
-   * @return {Promise(object)} - e.g. { user: , article: , .. }
-   * @this Manager
-   */
-  let out = {}
-  let { waitForIndexes } = opts || {}
-  if (!pathname || typeof pathname !== 'string') {
-    throw 'The path must be a valid pathname'
-  }
-  let filenames = fs.readdirSync(pathname)
-  for (let filename of filenames) {
-    // Ignore folders
-    if (!filename.match(/\.[cm]?js$/)) continue
-    let name = filename.replace('.js', '')
-    let filepath = path.join(pathname, filename)
-    // We can't use require() here since we need to be able to import both CJS and ES6 modules
-    let definition = ((await import(filepath))||{}).default
-    // When a commonJS project uses babel (e.g. `nodemon -r @babel/register`, similar to `-r esm`), import() 
-    // will return ES6 model definitions in another nested `default` object
-    if (definition && definition.default) definition = definition.default
-    if (!definition) throw new Error(`The model definition for '${name}' must export a default object`)
-    // Wait for indexes to be created?
-    if (waitForIndexes) out[name] = await this.model(name, definition, waitForIndexes)
-    else out[name] = this.model(name, definition)
-  }
-  return out
-}
-
-Manager.prototype.onError = function(fn) {
-  /**
-   * Called when an error occurs when trying to connect to the MongoClient.
-   * @param {Function} fn
-   * @return {Promise}
-   */
-  return new Promise((resolve, reject) => {
-    this.on('error', (err) => {
-      resolve(err)
-    })
-  }).then((err) => {
-    return fn(err)
-  })
-}
-
-Manager.prototype.onOpen = function(fn) {
-  /**
-   * Called when a successful MongoClient connection has been made.
-   * @param {Function} fn
-   * @return {Promise(manager)}
-   */
-  return new Promise((resolve, reject) => {
-    if (this._state == 'open') {
-      resolve(this)
-    }
-    this.on('open', () => {
-      resolve(this)
-    })
-    this.on('error', (err) => {
-      reject(err)
-    })
-  }).then((err) => { // If `then` is not chained, the error will be thrown, detached!
-    return fn(err)
-  })
-}
-
-Manager.prototype.open = async function() {
-  /**
-   * Connect to the database
-   * @return {Promise(manager)}
-   */
-  try {
-    this._state = 'opening'
-    this.db = this.client.db()
-    await this.client.connect() // now optional since db().command() will auto-connect
-    this.emit(this._state = 'open', this)
-    return this
-
-  } catch (err) {
-    this._state = 'closed'
-    // Only emit the error if there are listeners, since it will throw an unhandled error
-    if (this.listeners('error').length > 0) {
-      this.emit('error', err)
-    }
-    if (this.opts.promise || this.listeners('error').length == 0) {
-      throw new Error(err)
-    }
-  }
-}
-
-Manager.prototype.parseData = function(obj, parseBracketToDotNotation, parseDotNotation) {
-  return util.parseData(obj, parseBracketToDotNotation, parseDotNotation)
-}
-
-Manager.prototype.model = Model
-Manager.prototype.getSignedUrl = imagePluginFile.getSignedUrl
-Manager.prototype._getSignedUrl = () => { 
-  throw new Error('monastery._getSignedUrl() has been moved to monastery.getSignedUrl()')
-}
-
-inherits(Manager, EventEmitter)
-module.exports = Manager
+// Exports
+module.exports = new Manager('init')
+module.exports.arrayWithSchema = Manager.prototype.arrayWithSchema
+module.exports.getSignedUrl = Manager.prototype.getSignedUrl
 module.exports.id = Manager.prototype.id
 module.exports.isId = Manager.prototype.isId
-module.exports.arrayWithSchema = Manager.prototype.arrayWithSchema
-module.exports.parseData = Manager.prototype.parseData
 module.exports.parseBracketNotation = Manager.prototype.parseBracketNotation
 module.exports.parseBracketToDotNotation = Manager.prototype.parseBracketToDotNotation
+module.exports.parseData = Manager.prototype.parseData
 module.exports.parseDotNotation = Manager.prototype.parseDotNotation
-module.exports.getSignedUrl = Manager.prototype.getSignedUrl
-module.exports.manager = null
 module.exports.rules = rules

package/lib/manager.js

@@ -0,0 +1,303 @@
+const fs = require('fs')
+const debug = require('debug')
+const path = require('path')
+const EventEmitter = require('events').EventEmitter
+const { MongoClient } = require('mongodb')
+const Collection = require('./collection.js')
+const imagePluginFile = require('../plugins/images/index.js')
+const Model = require('./model.js')
+const util = require('./util.js')
+
+let hasDefaultManager = false
+
+function Manager(uri, opts, parent) {
+  /**
+   * Constructs a new manager which contains a new MongoDB client
+   * 
+   * @param {String|Array|Object} uri - MongoDB connection URI string / replica set, or reuse a MongoClient instance
+   * @param {Object} opts -
+   *   {String} <opts.databaseName> - the name of the database
+   *   {Boolean} <opts.promise(manager)> - return a promise
+   * 
+   * @return {Connection|Promise}
+   * @link https://www.mongodb.com/docs/drivers/node/v5.9/quick-reference/
+   * @link https://mongodb.github.io/node-mongodb-native/ (all versions)
+   */
+  const that = (!hasDefaultManager && parent) ? parent : this
+
+  if (!opts) opts = {}
+  if (!(this instanceof Manager)) return new Manager(uri, opts)
+  if (uri == 'init') return
+
+  // opts: timestamps
+  if (typeof opts.defaultFields != 'undefined') throw Error('opts.defaultFields has been depreciated, use opts.timestamps')
+  if (typeof opts.timestamps == 'undefined') opts.timestamps = true
+
+  // opts: logLevel
+  if (typeof opts.logLevel == 'undefined') opts.logLevel = 2
+
+  // opts: separate out monastery options
+  const mongoOpts = Object.keys(opts||{}).reduce((acc, key) => {
+    if (![
+      'databaseName', 'defaultObjects', 'logLevel', 'imagePlugin', 'limit', 'noDefaults', 'nullObjects',
+      'promise', 'timestamps', 'useMilliseconds',
+    ].includes(key)) {
+      acc[key] = opts[key]
+    }
+    return acc
+  }, {})
+
+  // Add properties
+  that.uri = uri
+  that.error = debug('monastery:error' + (opts.logLevel >= 1 ? '*' : ''))
+  that.warn = debug('monastery:warn' + (opts.logLevel >= 2 ? '*' : ''))
+  that.info = debug('monastery:info' + (opts.logLevel >= 3 ? '*' : ''))
+  that.opts = opts
+  that.beforeModel = []
+  that.collections = {}
+  that._openQueue = []
+  that.emitter = new EventEmitter()
+
+  // If there is no DEBUG= environment variable, we will need to force the debugs on (due to bug on debug@4.3.4)
+  if (!debug.namespaces) {
+    if (opts.logLevel >= 1) that.error.enabled = true
+    if (opts.logLevel >= 2) that.warn.enabled = true
+    if (opts.logLevel >= 3) that.info.enabled = true
+  }
+  
+  // Create a new MongoDB Client
+  if (typeof that.uri == 'string' || Array.isArray(that.uri)) {
+    that.uri = that.connectionString(that.uri, opts.databaseName)
+    that.client = new MongoClient(that.uri, mongoOpts)
+  } else {
+    that.client = that.uri
+  }
+
+  // Listen to MongoDB events
+  for (let eventName of ['close', 'error', 'timeout']) {
+    that.client.on(eventName, (e) => that.emitter.emit(eventName, e))
+  }
+
+  // Listen to custom open event
+  that.emitter.on('open', () => {
+    // wait for all the on('open') events to get called first
+    setTimeout(() => {
+      for (let item of that._openQueue) {
+        item()
+      }
+    })
+  })
+
+  // Initiate any plugins
+  if (opts.imagePlugin) {
+    imagePluginFile.setup(that, util.isObject(opts.imagePlugin) ? opts.imagePlugin : {})
+  }
+
+  // Update the parent manager with the new manager
+  if (!hasDefaultManager && parent) hasDefaultManager = true
+  if (opts.promise) return that.open()
+  else that.open()
+}
+
+Manager.prototype.manager = function(uri, opts) {
+  return new Manager(uri, opts, this)
+}
+
+Manager.prototype.arrayWithSchema = function(array, schema) {
+  array.schema = schema
+  return array
+}
+
+Manager.prototype.close = async function() {
+  /**
+   * Close the database connection, gracefully
+   */
+  const _close = async () => {
+    this.emitter.emit(this._state = 'closing')
+    await this.client.close()
+    this.emitter.emit(this._state = 'close')
+  }
+  if (this._state == 'open') {
+    return await _close()
+
+  } else if (this._state == 'opening') {
+    return new Promise((resolve) => {
+      this._openQueue.push(() => _close().then(resolve))
+    })
+
+  } else if (this._state == 'close' || this._state == 'closing') {
+    return
+  }
+}
+
+Manager.prototype.command = function(...args) {
+  /**
+   * Run a raw MongoDB command
+   */
+  return this.db.command(...args)
+}
+
+Manager.prototype.connectionString = function(uri, databaseName) {
+  /**
+   * get the connection string
+   * @param {string|array} uri
+   * @param {string} <databaseName>
+   * @return {string}
+   */
+  if (!uri) {
+    throw Error('No connection URI provided.')
+  }
+  // uri: array, sort out the connection string
+  if (util.isArray(uri)) {
+    if (!databaseName) {
+      for (var i=0, l=uri.length; i<l; i++) {
+        if (!databaseName) databaseName = uri[i].replace(/([^\/])+\/?/, '') // eslint-disable-line
+        uri[i] = uri[i].replace(/\/.*/, '')
+      }
+    }
+    uri = uri.join(',') + '/' + databaseName
+  }
+  // uri: string, sort out the connection string
+  if (typeof uri === 'string') {
+    if (!/^mongodb(\+srv)?:\/\//.test(uri)) {
+      uri = 'mongodb://' + uri
+    }
+  }
+  return uri
+}
+
+Manager.prototype.get = function(name, options) {
+  /**
+   * Returns a MongoDB collection
+   * @param {String} name
+   * @param {Object} [options] - options to pass to the collection
+   * @return {MongoDB Collection}
+   */
+  if (!this.collections[name] || (options||{}).cache === false) {
+    delete (options||{}).cache
+    this.collections[name] = new Collection(this, name, options)
+  }
+  return this.collections[name]
+}
+
+Manager.prototype.id = function(str) {
+  return util.id(str)
+}
+
+Manager.prototype.isId = function(value) {
+  return util.isId(value)
+}
+
+Manager.prototype.models = async function(pathname, opts) {
+  /**
+   * Setup model definitions from a folder location
+   * @param {string} pathname
+   * @param {object} opts:
+   *   @param {boolean} opts.waitForIndexes - Wait for indexes to be created?
+   *   @param {boolean} opts.skipIfExists - Skip if the model already exists?
+   * @return {Promise(object)} - e.g. { user: , article: , .. }
+   * @this Manager
+   */
+  let out = {}
+  let { waitForIndexes } = opts || {}
+  if (!pathname || typeof pathname !== 'string') {
+    throw 'The path must be a valid pathname'
+  }
+  if (!fs.existsSync(pathname)) {
+    this.warn(`The models path ${pathname} does not exist`)
+    return out
+  }
+  let filenames = fs.readdirSync(pathname)
+  for (let filename of filenames) {
+    // Ignore folders
+    if (!filename.match(/\.[cm]?js$/)) continue
+    let name = filename.replace('.js', '')
+    let filepath = path.join(pathname, filename)
+    // Skip
+    if (opts.skipIfExists && this.models[name]) continue
+    // We can't use require() here since we need to be able to import both CJS and ES6 modules
+    let definition = ((await import(filepath))||{}).default
+    // When a commonJS project uses babel (e.g. `nodemon -r @babel/register`, similar to `-r esm`), import() 
+    // will return ES6 model definitions in another nested `default` object
+    if (definition && definition.default) definition = definition.default
+    if (!definition) throw new Error(`The model definition for '${name}' must export a default object`)
+    // Wait for indexes to be created?
+    if (waitForIndexes) out[name] = await this.model(name, definition, waitForIndexes)
+    else out[name] = this.model(name, definition)
+  }
+  return out
+}
+
+Manager.prototype.onError = function(fn) {
+  /**
+   * Called when an error occurs when trying to connect to the MongoClient.
+   * @param {Function} fn
+   * @return {Promise}
+   */
+  return new Promise((resolve, reject) => {
+    this.emitter.on('error', (err) => {
+      resolve(err)
+    })
+  }).then((err) => {
+    return fn(err)
+  })
+}
+
+Manager.prototype.onOpen = function(fn) {
+  /**
+   * Called when a successful MongoClient connection has been made.
+   * @param {Function} fn
+   * @return {Promise(manager)}
+   */
+  return new Promise((resolve, reject) => {
+    if (this._state == 'open') {
+      resolve(this)
+    }
+    this.emitter.on('open', () => {
+      resolve(this)
+    })
+    this.emitter.on('error', (err) => {
+      reject(err)
+    })
+  }).then((err) => { // If `then` is not chained, the error will be thrown, detached!
+    return fn(err)
+  })
+}
+
+Manager.prototype.open = async function() {
+  /**
+   * Connect to the database
+   * @return {Promise(manager)}
+   */
+  try {
+    this._state = 'opening'
+    this.db = this.client.db()
+    await this.client.connect() // now optional since db().command() will auto-connect
+    this.emitter.emit(this._state = 'open', this)
+    return this
+
+  } catch (err) {
+    this._state = 'closed'
+    // Only emit the error if there are listeners, since it will throw an unhandled error
+    if (this.emitter.listeners('error').length > 0) {
+      this.emitter.emit('error', err)
+    }
+    if (this.opts.promise || this.emitter.listeners('error').length == 0) {
+      throw new Error(err)
+    }
+  }
+}
+
+Manager.prototype.parseData = function(obj, parseBracketToDotNotation, parseDotNotation) {
+  return util.parseData(obj, parseBracketToDotNotation, parseDotNotation)
+}
+
+Manager.prototype.model = Model
+
+Manager.prototype.getSignedUrl = imagePluginFile.getSignedUrl
+
+Manager.prototype._getSignedUrl = () => { 
+  throw new Error('monastery._getSignedUrl() has been moved to monastery.getSignedUrl()')
+}
+
+module.exports = Manager

package/lib/model.js

@@ -9,7 +9,7 @@ function Model(name, definition, waitForIndexes, manager) {
    * @param {boolean} waitForIndexes - wait for indexes to be created before returning (returns a promise)
    * 
    * @return model or Promise(model)
-   * @this manager
+   * @this Manager | Model
    */
   if (!(this instanceof Model)) {
     return new Model(name, definition, waitForIndexes, this)
@@ -27,7 +27,11 @@ function Model(name, definition, waitForIndexes, manager) {
       ', e.g. { schema: { strict: false }}'
   } else if (!util.isSubdocument(definition.fields) && !util.isEmpty(definition.fields)) {
     throw `The ${name}.fields object should be a valid document, e.g. { name: { type: 'string' }}`
-  }
+  } 
+  // else if (manager.models[name]) {
+  //   manager.warn(`The model '${name}' already exists, skipping model setup.`)
+  //   return manager.models[name]
+  // }
 
   // Add schema options
   Object.assign(this, {

package/package.json

@@ -2,7 +2,7 @@
   "name": "monastery",
   "description": "⛪ A simple, straightforward MongoDB ODM",
   "author": "Ricky Boyce",
-  "version": "3.4.3",
+  "version": "3.5.1",
   "license": "MIT",
   "repository": "github:boycce/monastery",
   "homepage": "https://boycce.github.io/monastery/",

package/test/blacklisting.js

@@ -4,7 +4,7 @@ const bird = require('./mock/blacklisting.js').bird
 const user = require('./mock/blacklisting.js').user
 
 let db
-beforeAll(async () => { db = monastery('127.0.0.1/monastery', { timestamps: false }) })
+beforeAll(async () => { db = monastery.manager('127.0.0.1/monastery', { timestamps: false }) })
 afterAll(async () => { db.close() })
 
 test('find blacklisting basic', async () => {

package/test/collection.js

@@ -5,7 +5,7 @@ const util = require('../lib/util.js')
 // Setup/destroy
 let db, userCol, indexCol, indexDropCol
 beforeAll(async () => {
-  db = monastery('127.0.0.1/monastery')
+  db = monastery.manager('127.0.0.1/monastery')
   userCol = db.get('users-' + Date.now())
   indexCol = db.get('index-' + Date.now())
   indexDropCol = db.get('index-' + Date.now())

package/test/comparison.js

@@ -2,7 +2,7 @@ const monastery = require('../lib/index.js')
 const mongoose = require('mongoose') // very slow initialisation
 
 test('comparison insert', async () => {
-  const db = monastery('127.0.0.1/monastery', { timestamps: false }) 
+  const db = monastery.manager('127.0.0.1/monastery', { timestamps: false }) 
   const Test1 = db.model('Test1', { fields: {
     raw: {
       words: [{
@@ -70,7 +70,7 @@ test('comparison validate', async () => {
       })),
     }
   }
-  const db = monastery('127.0.0.1/monastery', { timestamps: false }) 
+  const db = monastery.manager('127.0.0.1/monastery', { timestamps: false }) 
   const Test1 = db.model('Test1', { fields: {
     raw: {
       words: [{

package/test/crud.js

@@ -2,11 +2,11 @@
 const monastery = require('../lib/index.js')
 
 let db
-beforeAll(async () => { db = monastery('127.0.0.1/monastery', { timestamps: false }) })
+beforeAll(async () => { db = monastery.manager('127.0.0.1/monastery', { timestamps: false }) })
 afterAll(async () => { db.close() })
 
 test('insert basics', async () => {
-  let db2 = monastery('127.0.0.1/monastery', { timestamps: false }) 
+  let db2 = monastery.manager('127.0.0.1/monastery', { timestamps: false }) 
   let user = db2.model('user', { fields: {
     name: { type: 'string' },
     names: [{ type: 'string' }],
@@ -52,7 +52,7 @@ test('insert basics', async () => {
 })
 
 test('insert option defaultObjects', async () => {
-  let db2 = monastery('127.0.0.1/monastery', { 
+  let db2 = monastery.manager('127.0.0.1/monastery', { 
     defaultObjects: true, 
     timestamps: false, 
     imagePlugin: {
@@ -97,7 +97,7 @@ test('insert option defaultObjects', async () => {
 })
 
 test('insert option timestamps', async () => {
-  let db2 = monastery('127.0.0.1/monastery', { timestamps: true })
+  let db2 = monastery.manager('127.0.0.1/monastery', { timestamps: true })
   let schema = { 
     fields: {
       name: { type: 'string' },
@@ -355,7 +355,7 @@ test('find default field population with option noDefaults', async () => {
   async function setup(noDefaults) {
     // @returns {Object} {dog, user, dog1Doc, dog2Doc, user1Doc}
     // similar to "find default field population"
-    const db = monastery('127.0.0.1/monastery', { noDefaults: noDefaults, timestamps: false })
+    const db = monastery.manager('127.0.0.1/monastery', { noDefaults: noDefaults, timestamps: false })
     const userDefinition = {
       fields: {
         name: { type: 'string', default: 'Martin Luther' },
@@ -577,7 +577,7 @@ test('update general', async () => {
 })
 
 test('update defaults', async () => {
-  const db2 = monastery('127.0.0.1/monastery', { useMilliseconds: true })
+  const db2 = monastery.manager('127.0.0.1/monastery', { useMilliseconds: true })
   let user = db2.model('user', {
     fields: {
       name: { type: 'string' },
@@ -1276,7 +1276,7 @@ test('hooks > async', async () => {
 })
 
 test('hooks > async and next conflict', async () => {
-  const db2 = monastery('127.0.0.1/monastery', { timestamps: false })
+  const db2 = monastery.manager('127.0.0.1/monastery', { timestamps: false })
   let user1 = db2.model('user', {
     fields: { age: { type: 'number'} },
     afterFind: [
@@ -1441,7 +1441,7 @@ test('hooks > option skipHooks', async () => {
 })
 
 test('update set and unset with option skipValidation', async () => {
-  const db2 = monastery('127.0.0.1/monastery', { timestamps: false })
+  const db2 = monastery.manager('127.0.0.1/monastery', { timestamps: false })
   let user = db2.model('user_set_and_unset', { 
     fields: {
       profile: {

package/test/manager.js

@@ -2,23 +2,23 @@ const { MongoClient } = require('mongodb')
 const monastery = require('../lib/index.js')
 
 test('manager > basics', async () => {
-  const manager = monastery('localhost/monastery', { serverSelectionTimeoutMS: 2000 })
+  const db = monastery.manager('localhost/monastery', { serverSelectionTimeoutMS: 2000 })
   // Manager is exposed
-  expect(manager).toEqual(monastery.manager)
+  expect(monastery.uri).toEqual(expect.any(String))
   // Basic find command
-  expect(await manager.db.collection('non-collection').findOne({})).toEqual(null)
+  expect(await db.db.collection('non-collection').findOne({})).toEqual(null)
   // Raw MongoDB ping command
-  expect(await manager.command({ ping: 1 })).toMatchObject({ ok: 1 }) // cluster connections return extra fields
-  manager.close()
+  expect(await db.command({ ping: 1 })).toMatchObject({ ok: 1 }) // cluster connections return extra fields
+  db.close()
 })
 
 test('manager > uri error', async () => {
-  expect(() => monastery('', {})).toThrow('No connection URI provided.')
+  expect(() => monastery.manager('', {})).toThrow('No connection URI provided.')
 })
 
 test('manager > onError', async () => {
   // Bad port (thrown by MongoDB)
-  const db = monastery('localhost:1234/monastery', { serverSelectionTimeoutMS: 500 })
+  const db = monastery.manager('localhost:1234/monastery', { serverSelectionTimeoutMS: 500 })
   let error, isAPromise
   await db.onError((res) => { error = res.message }).then(() => { isAPromise = true })
   expect(error).toEqual('connect ECONNREFUSED 127.0.0.1:1234')
@@ -27,7 +27,7 @@ test('manager > onError', async () => {
 })
 
 test('manager > onOpen', async () => {
-  const db = monastery('localhost/monastery', { serverSelectionTimeoutMS: 500 })
+  const db = monastery.manager('localhost/monastery', { serverSelectionTimeoutMS: 500 })
 
   let manager1
   await db.onOpen((res) => { manager1 = res })
@@ -52,7 +52,7 @@ test('manager > onOpen', async () => {
 test('manager > onOpen error', async () => {
   // Bad port (thrown by MongoDB)
   let manager
-  const db = monastery('localhost:1234/monastery', { serverSelectionTimeoutMS: 500 })
+  const db = monastery.manager('localhost:1234/monastery', { serverSelectionTimeoutMS: 500 })
   await expect(db.onOpen((res) => { manager = res })).rejects.toThrow('connect ECONNREFUSED 127.0.0.1:1234')
   expect(manager).toEqual(undefined)
   expect(db).toEqual(expect.any(Object))
@@ -60,19 +60,19 @@ test('manager > onOpen error', async () => {
 })
 
 test('manager > return a promise', async () => {
-  const db = await monastery('localhost/monastery', { serverSelectionTimeoutMS: 500, promise: true })
+  const db = await monastery.manager('localhost/monastery', { serverSelectionTimeoutMS: 500, promise: true })
   expect(db).toEqual(expect.any(Object))
   db.close()
 })
 
 test('manager > return a promise with uri error', async () => {
-  await expect(monastery('badlocalhost/monastery', { serverSelectionTimeoutMS: 500, promise: true }))
+  await expect(monastery.manager('badlocalhost/monastery', { serverSelectionTimeoutMS: 500, promise: true }))
     .rejects.toThrow('getaddrinfo EAI_AGAIN badlocalhost')
 })
 
 test('manager > reuse MongoDB Client', async () => {
   const mongoClient = new MongoClient('mongodb://localhost/monastery', {})
-  const db = await monastery(mongoClient, { serverSelectionTimeoutMS: 500, promise: true })
+  const db = await monastery.manager(mongoClient, { serverSelectionTimeoutMS: 500, promise: true })
   expect(db).toEqual(expect.any(Object))
   expect(db.client).toEqual(expect.any(Object))
   expect(db.isId).toEqual(expect.any(Function))
@@ -83,11 +83,11 @@ test('manager > events', async () => {
   // note: jests tests only wait for 5s
   function eventTester(db, eventName) {
     return new Promise((resolve) => {
-      db.on(eventName, () => resolve(true))
+      db.emitter.on(eventName, () => resolve(true))
     })
   }
   // Triggers on opening/open
-  const db = monastery('localhost/monastery', { serverSelectionTimeoutMS: 2000 })
+  const db = monastery.manager('localhost/monastery', { serverSelectionTimeoutMS: 2000 })
   expect(db._state).toEqual('opening')
   // Start waiting for the following events
   const promises = Promise.all([
@@ -101,10 +101,24 @@ test('manager > events', async () => {
 })
 
 test('Manager > get collection', async () => {
-  const manager = monastery('localhost/monastery', { serverSelectionTimeoutMS: 500 })
+  const db = monastery.manager('localhost/monastery', { serverSelectionTimeoutMS: 500 })
   // Basic aggregate command
-  expect(await manager.get('non-collection').aggregate([], {})).toEqual([])
+  expect(await db.get('non-collection').aggregate([], {})).toEqual([])
   // Basic find command
-  expect(await manager.get('non-collection').find({})).toEqual([])
-  manager.close()
+  expect(await db.get('non-collection').find({})).toEqual([])
+  db.close()
+})
+
+test('Manager > multiple managers', async () => {
+  const db1 = monastery.manager('localhost/monastery', { logLevel: 5 })
+  const db2 = monastery.manager('localhost/monastery', { logLevel: 6 })
+  const db3 = monastery.manager('localhost/monastery', { logLevel: 7 })
+
+  expect(monastery.opts.logLevel).not.toEqual(6) // default manager
+  expect(db2.opts.logLevel).not.toEqual(db1.opts.logLevel)
+  expect(db3.opts.logLevel).not.toEqual(db2.opts.logLevel)
+
+  db1.close()
+  db2.close()
+  db3.close()
 })

package/test/model.js

@@ -3,11 +3,11 @@ const Model = require('../lib/model.js')
 const monastery = require('../lib/index.js')
 
 let db
-beforeAll(async () => { db = monastery('127.0.0.1/monastery') })
+beforeAll(async () => { db = monastery.manager('127.0.0.1/monastery') })
 afterAll(async () => { db.close() })
 
 test('model > model on manager', async () => {
-  const db2 = monastery('127.0.0.1', { logLevel: 0 })
+  const db2 = monastery.manager('127.0.0.1', { logLevel: 0 })
   db2.model('user', { fields: {} })
   let modelNamedConflict = db2.model('open', { fields: {} })
 
@@ -132,7 +132,7 @@ test('model setup basics', async () => {
 })
 
 test('model setup with default objects', async () => {
-  const db2 = monastery('127.0.0.1/monastery', { defaultObjects: true })
+  const db2 = monastery.manager('127.0.0.1/monastery', { defaultObjects: true })
   let user = db2.model('user', { fields: {
     name: { type: 'string' },
     pets: [{ type: 'string' }],
@@ -376,7 +376,7 @@ test('model setup with messages', async () => {
 
 test('model setup with reserved and invalid rules', async () => {
   // Setup
-  const db2 = monastery('127.0.0.1/monastery', { logLevel: 0 })
+  const db2 = monastery.manager('127.0.0.1/monastery', { logLevel: 0 })
   let user = db2.model('user-model', {
     fields: {
       name: {

package/test/plugin-images.js

@@ -7,14 +7,14 @@ const imagePluginFakeOpts = { awsBucket: 'fake', awsRegion: 'fake', awsAccessKey
 let db
 afterAll(async () => { db.close() })
 beforeAll(async () => { 
-  db = monastery('127.0.0.1/monastery', {
+  db = monastery.manager('127.0.0.1/monastery', {
     timestamps: false, 
     imagePlugin: imagePluginFakeOpts,
   }) 
 })
 
 test('images no initialisation', async () => {
-  const db2 = monastery('127.0.0.1/monastery', { timestamps: false })
+  const db2 = monastery.manager('127.0.0.1/monastery', { timestamps: false })
   db2.model('company', {
     fields: {
       logo: { type: 'image' },
@@ -666,7 +666,7 @@ test('images option defaults', async () => {
 })
 
 test('images options formats & filesizes', async () => {
-  const db3 = monastery('127.0.0.1/monastery', {
+  const db3 = monastery.manager('127.0.0.1/monastery', {
     timestamps: false, 
     imagePlugin: { 
       ...imagePluginFakeOpts,
@@ -745,7 +745,7 @@ test('images options formats & filesizes', async () => {
 
 test('images option getSignedUrls', async () => {
   // latest (2022.02)
-  const db3 = monastery('127.0.0.1/monastery', {
+  const db3 = monastery.manager('127.0.0.1/monastery', {
     timestamps: false, 
     imagePlugin: { 
       ...imagePluginFakeOpts,
@@ -802,7 +802,7 @@ test('images option getSignedUrls', async () => {
 })
 
 test('images options awsAcl, awsBucket, metadata, params, path', async () => {
-  const db3 = monastery('127.0.0.1/monastery', {
+  const db3 = monastery.manager('127.0.0.1/monastery', {
     timestamps: false, 
     imagePlugin: { 
       ...imagePluginFakeOpts,
@@ -902,7 +902,7 @@ test('images options awsAcl, awsBucket, metadata, params, path', async () => {
 
 test('images option depreciations', async () => {
   // testing (filename bucketDir)
-  const db3 = monastery('127.0.0.1/monastery', {
+  const db3 = monastery.manager('127.0.0.1/monastery', {
     logLevel: 1,
     timestamps: false, 
     imagePlugin: { 

package/test/populate.js

@@ -1,7 +1,7 @@
 const monastery = require('../lib/index.js')
 
 let db
-beforeAll(async () => { db = monastery('127.0.0.1/monastery', { timestamps: false }) })
+beforeAll(async () => { db = monastery.manager('127.0.0.1/monastery', { timestamps: false }) })
 afterAll(async () => { db.close() })
 
 test('model populate', async () => {

package/test/util.js

@@ -254,7 +254,7 @@ test('util > isId', async () => {
   expect(util.isId({})).toEqual(false)
   expect(util.isId(['5ff50fe955da2c00170de734'])).toEqual(false)
   expect(util.isId('5ff50fe955da2c00170de734')).toEqual(true)
-  expect(util.isId(monastery.prototype.id())).toEqual(true)
+  expect(util.isId(monastery.id())).toEqual(true)
 })
 
 test('util > isHex24', async () => {
@@ -265,12 +265,12 @@ test('util > isHex24', async () => {
   expect(util.isHex24({})).toEqual(false)
   expect(util.isHex24(['5ff50fe955da2c00170de734'])).toEqual(false)
   expect(util.isHex24('5ff50fe955da2c00170de734')).toEqual(true)
-  expect(util.isHex24(monastery.prototype.id())).toEqual(true)
+  expect(util.isHex24(monastery.id())).toEqual(true)
 })
 
 
 test('util > arrayWithSchema', async () => {
-  let res = monastery.prototype.arrayWithSchema([{ name: { type: 'string' }}], { minLength: 1 })
+  let res = monastery.arrayWithSchema([{ name: { type: 'string' }}], { minLength: 1 })
   expect(res).toContainEqual({ name: { type: 'string' }})
   expect(res.schema).toEqual({ minLength: 1 })
 })

package/test/validate.js

@@ -3,7 +3,7 @@ const monastery = require('../lib/index.js')
 const Model = require('../lib/model.js')
 
 let db
-beforeAll(async () => { db = monastery('127.0.0.1/monastery', { timestamps: false }) })
+beforeAll(async () => { db = monastery.manager('127.0.0.1/monastery', { timestamps: false }) })
 afterAll(async () => { db.close() })
 
 test('validation basic errors', async () => {
@@ -171,7 +171,7 @@ test('validation type any', async () => {
 })
 
 test('validation schema with reserved and invalid rules', async () => {
-  const db2 = monastery('127.0.0.1/monastery', { logLevel: 0 })
+  const db2 = monastery.manager('127.0.0.1/monastery', { logLevel: 0 })
   let user = db2.model('user-model', {
     fields: {
       sub: {
@@ -972,7 +972,7 @@ test('schema options default', async () => {
 })
 
 test('schema options objects', async () => {
-  const db2 = monastery('127.0.0.1/monastery', { nullObjects: true, timestamps: false })
+  const db2 = monastery.manager('127.0.0.1/monastery', { nullObjects: true, timestamps: false })
   let user = db2.model('user', {
     fields: {
       location: {
@@ -998,7 +998,7 @@ test('schema options objects', async () => {
 })
 
 test('validate defaultObjects', async () => {
-  const db2 = monastery('127.0.0.1/monastery', { defaultObjects: true, timestamps: false })
+  const db2 = monastery.manager('127.0.0.1/monastery', { defaultObjects: true, timestamps: false })
   // let base = { names: [], animals: { dogs: [] }}
   let user = db2.model('user', { fields: {
     name: { type: 'string' },
@@ -1018,7 +1018,7 @@ test('validate defaultObjects', async () => {
 })
 
 test('validate nullObjects', async () => {
-  const db2 = monastery('127.0.0.1/monastery', { nullObjects: true, timestamps: false })
+  const db2 = monastery.manager('127.0.0.1/monastery', { nullObjects: true, timestamps: false })
   let user = db2.model('user', { fields: {
     names: [{ type: 'string' }],
     animals: {

package/test/virtuals.js

@@ -1,7 +1,7 @@
 const monastery = require('../lib/index.js')
 
 let db
-beforeAll(async () => { db = monastery('127.0.0.1/monastery', { timestamps: false }) })
+beforeAll(async () => { db = monastery.manager('127.0.0.1/monastery', { timestamps: false }) })
 afterAll(async () => { db.close() })
 
 test('virtuals', async () => {