monastery 2.2.3 → 3.0.1

package/lib/index.js

@@ -1,86 +1,191 @@
-let fs = require('fs')
-let debug = require('debug')
-let monk = require('monk')
-let path = require('path')
-let rules = require('./rules.js')
-let util = require('./util.js')
-
-// Apply monk monkey patches
-monk.manager.prototype.open = require('./monk-monkey-patches.js').open
-monk.manager.prototype.then = require('./monk-monkey-patches.js').then
-monk.Collection.prototype.findOneAndUpdate = require('./monk-monkey-patches.js').findOneAndUpdate
-
-module.exports = function(uri, opts, fn) {
+/*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 rules = require('./rules.js')
+const util = require('./util.js')
+
+function Manager(uri, opts) {
   /**
-   * Constructs and augments a new monk manager
-   * @param {String|Array|Manager|false} uri:
-   *   {string|array} - monk connection URI string / replica sets (see monk)
-   *   {object} - reuse a monk manager instance
-   *   {false} - no open database connection, used in testing
-   * @param {object} opts
-   * @return monk manager
+   * 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 = {}
-  let monasteryOpts = [
-    'defaultObjects', 'hideWarnings', 'hideErrors', 'imagePlugin', 'limit', 'nullObjects',
-    'timestamps', 'useMilliseconds',
-  ]
-
-  // Note: Debug doesn't allow debuggers to be enabled by default
-  let info = debug('monastery:info')
-  let warn = debug('monastery:warn' + (opts.hideWarnings ? '' : '*'))
-  let error = debug('monastery:error' + (opts.hideErrors ? '' : '*'))
-
-  if (util.isDefined(opts.defaultFields)) {
-    warn('opts.defaultFields has been depreciated in favour of opts.timestamps')
-    opts.timestamps = opts.defaultFields
-    delete opts.defaultFields
-  }
-  if (!util.isDefined(opts.timestamps)) {
-    opts.timestamps = true
+  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: separate out monastery options
+  const mongoOpts = Object.keys(opts||{}).reduce((acc, key) => {
+    if (
+      ![
+        'databaseName', 'defaultObjects', 'hideWarnings', 'hideErrors', 'imagePlugin', 'limit', 'nullObjects',
+        'promise', 'timestamps', 'useMilliseconds',
+      ].includes(key)) {
+        acc[key] = opts[key]
+    }
+    return acc
+  }, {})
+
+  // Add properties
+  this.info = debug('monastery:info') // debug doesn't allow debuggers to be enabled by default
+  this.warn = debug('monastery:warn' + (opts.hideWarnings ? '' : '*'))
+  this.error = debug('monastery:error' + (opts.hideErrors ? '' : '*'))
+  this.opts = opts
+  this.beforeModel = []
+  this.collections = {}
+  this.models = {}
+  this._openQueue = []
+  
+  // Create a new MongoDB Client
+  if (typeof uri == 'string' || Array.isArray(uri)) {
+    uri = this.connectionString(uri, opts.databaseName)
+    this.client = new MongoClient(uri, mongoOpts)
+  } else {
+    this.client = uri
   }
 
-  // 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, ...util.omit(opts, monasteryOpts) }, fn)
-  else manager = { id: monk.id }
-
-  // Add monastery properties
-  manager.arrayWithSchema = arrayWithSchema
-  manager.beforeModel = []
-  manager.imagePluginFile = require('../plugins/images/index.js')
-  manager.isId = util.isId.bind(util)
-  manager.model = require('./model.js')
-  manager.models = models
-  manager.parseData = util.parseData.bind(util)
-  manager.info = info
-  manager.warn = warn
-  manager.error = error
-
-  // Add opts onto manager
-  for (let key of monasteryOpts) {
-    manager[key] = opts[key]
+  // 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 (manager.imagePlugin) {
-    manager.imagePluginFile.setup(manager, util.isObject(manager.imagePlugin)? manager.imagePlugin : {})
+  if (opts.imagePlugin) {
+    imagePluginFile.setup(this, util.isObject(opts.imagePlugin) ? opts.imagePlugin : {})
   }
 
-  // Catch mongodb connectivity errors
-  if (uri) manager.catch(err => manager.error(err))
-  return manager
-}
+  // Expose the last manager
+  module.exports.manager = this
 
-module.exports.rules = rules
+  // Connect to the database
+  if (opts.promise) return this.open()
+  else this.open()
+}
 
-let arrayWithSchema = function(array, schema) {
+Manager.prototype.arrayWithSchema = function(array, schema) {
   array.schema = schema
   return array
 }
 
-let models = async function(pathname, waitForIndexes) {
+Manager.prototype.catch = function(fn) {
+  /**
+   * Catch any errors that occur during the opening of the database, and still return the manager
+   * @param {Function} fn
+   * @return {Manager}
+   */
+  this.catching = true
+  this.on('error', fn)
+  return this
+}
+
+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, waitForIndexes) {
   /**
    * Setup model definitions from a folder location
    * @param {string} pathname
@@ -109,3 +214,38 @@ let models = async function(pathname, waitForIndexes) {
   }
   return out
 }
+
+Manager.prototype.open = async function() {
+  /**
+   * Connect to the database
+   * @return {Promise}
+   */
+  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.catching) {
+      throw err
+    }
+  }
+}
+
+Manager.prototype.parseData = function(obj) {
+  return util.parseData(obj)
+}
+
+Manager.prototype.model = Model
+
+inherits(Manager, EventEmitter)
+module.exports = Manager 
+module.exports.manager = null
+module.exports.rules = rules