monastery 3.4.2 → 3.5.0

package/lib/manager.js

@@ -0,0 +1,289 @@
+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 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 : {})
+  }
+
+  // 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

package/lib/model.js

@@ -1,58 +1,59 @@
 const rules = require('./rules.js')
 const util = require('./util.js')
 
-function Model(name, opts, manager) {
+function Model(name, definition, waitForIndexes, manager) {
   /**
    * Setup a model
    * @param {string} name
-   * @param {object} opts - see mongodb collection documentation
-   * @param {boolean} opts.waitForIndexes
-   * @return Promise(model) | this
-   * @this model
+   * @param {object} definition - model definition
+   * @param {boolean} waitForIndexes - wait for indexes to be created before returning (returns a promise)
+   * 
+   * @return model or Promise(model)
+   * @this manager
    */
   if (!(this instanceof Model)) {
-    return new Model(name, opts, this)
+    return new Model(name, definition, waitForIndexes, this)
   } else if (!name) {
     throw 'No model name defined'
   } else if (name.match(/^_/)) {
     throw 'Model names cannot start with an underscore'
-  } else if (!opts) {
+  } else if (!definition) {
     throw `No model definition passed for "${name}"`
-  } else if (!opts.fields) {
+  } else if (!definition.fields) {
     throw `We couldn't find ${name}.fields in the model definition, the model maybe setup ` 
-      + `or exported incorrectly:\n${JSON.stringify(opts, null, 2)}`
-  } else if (!util.isSubdocument(opts.fields) && opts.fields.type == 'any') {
+      + `or exported incorrectly:\n${JSON.stringify(definition, null, 2)}`
+  } else if (!util.isSubdocument(definition.fields) && definition.fields.type == 'any') {
     throw `Instead of using { type: 'any' } for ${name}.fields, please use the new 'strict' definition rule` +
       ', e.g. { schema: { strict: false }}'
-  } else if (!util.isSubdocument(opts.fields) && !util.isEmpty(opts.fields)) {
+  } 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' }}`
   }
 
   // Add schema options
   Object.assign(this, {
-    ...(opts.methods || {}),
-    afterFind: opts.afterFind || [],
-    afterInsert: (opts.afterInsert || []).concat(opts.afterInsertUpdate || []),
-    afterUpdate: (opts.afterUpdate || []).concat(opts.afterInsertUpdate || []),
-    afterRemove: opts.afterRemove || [],
-    beforeInsert: (opts.beforeInsert || []).concat(opts.beforeInsertUpdate || []),
-    beforeUpdate: (opts.beforeUpdate || []).concat(opts.beforeInsertUpdate || []),
-    beforeRemove: opts.beforeRemove || [],
-    beforeValidate: opts.beforeValidate || [],
+    ...(definition.methods || {}),
+    afterFind: definition.afterFind || [],
+    afterInsert: (definition.afterInsert || []).concat(definition.afterInsertUpdate || []),
+    afterUpdate: (definition.afterUpdate || []).concat(definition.afterInsertUpdate || []),
+    afterRemove: definition.afterRemove || [],
+    beforeInsert: (definition.beforeInsert || []).concat(definition.beforeInsertUpdate || []),
+    beforeUpdate: (definition.beforeUpdate || []).concat(definition.beforeInsertUpdate || []),
+    beforeRemove: definition.beforeRemove || [],
+    beforeValidate: definition.beforeValidate || [],
     error: manager.error,
     info: manager.info,
     warn: manager.warn,
-    insertBL: opts.insertBL
-      ? !opts.insertBL.includes('_id') && !opts.insertBL.includes('-_id') ? ['_id'].concat(opts.insertBL) : opts.insertBL
-      : ['_id'],
-    fields: { ...(util.deepCopy(opts.fields) || {}) },
-    findBL: opts.findBL || ['password'], // todo: password should be removed
+    insertBL: !definition.insertBL 
+      ? ['_id'] : !definition.insertBL.includes('_id') && !definition.insertBL.includes('-_id')
+      ? ['_id'].concat(definition.insertBL) : definition.insertBL,
+    fields: { ...(util.deepCopy(definition.fields) || {}) },
+    findBL: definition.findBL || ['password'], // todo: password should be removed
     manager: manager,
-    messages: opts.messages || {},
-    messagesLen: Object.keys(opts.messages || {}).length > 0,
+    messages: definition.messages || {},
+    messagesLen: Object.keys(definition.messages || {}).length > 0,
     name: name,
-    rules: { ...(opts.rules || {}) },
-    updateBL: opts.updateBL || [],
+    rules: { ...(definition.rules || {}) },
+    updateBL: definition.updateBL || [],
   })
 
   // Sort messages by specifity first, then we can just return the first match
@@ -140,7 +141,7 @@ function Model(name, opts, manager) {
     if (err.type == 'info') this.info(err.detail)
     else this.error(err)
   }
-  if (opts.waitForIndexes) return this._setupIndexes().catch(errHandler).then(() => this)
+  if (waitForIndexes) return this._setupIndexes().catch(errHandler).then(() => this)
   else this._setupIndexes().catch(errHandler) // returns this
 }
 
@@ -446,4 +447,4 @@ module.exports = Model
 
 // Extend Model prototype
 require('./model-crud.js')
-require('./model-validate.js')
+require('./model-validate.js')

package/package.json

@@ -2,7 +2,7 @@
   "name": "monastery",
   "description": "⛪ A simple, straightforward MongoDB ODM",
   "author": "Ricky Boyce",
-  "version": "3.4.2",
+  "version": "3.5.0",
   "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' },
@@ -353,12 +353,9 @@ test('find default field blacklisted', async () => {
 
 test('find default field population with option noDefaults', async () => {
   async function setup(noDefaults) {
-    /**
-     * Setup
-     * @returns {Object} {dog, user, dog1Doc, dog2Doc, user1Doc}
-     */
+    // @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' },
@@ -508,6 +505,9 @@ test('find default field population with option noDefaults', async () => {
     },
     dogs: [{ _id: s2.dog1Doc._id, user: s2.user1Doc._id }], // should not have a default name
   })
+
+  s1.db.close()
+  s2.db.close()
 })
 
 test('update general', async () => {
@@ -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' },
@@ -1074,7 +1074,6 @@ test('hooks > basic', async () => {
   await expect(user2.update({ query: userDoc2._id, data: { first: 'MM'  } })).resolves.toEqual({ first: 'MM' })
   await expect(user2.update({ query: userDoc2._id, data: { first: 'M', bad: true } })).rejects.toThrow('error2')
 })
-
 test('hooks > chained values', async () => {
   let bookCount = 0
   const afterInsertAsync = [
@@ -1277,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: [
@@ -1442,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: {
@@ -1514,4 +1513,6 @@ test('update set and unset with option skipValidation', async () => {
   const u8 = { query: userId, $unset: { 'profile.name': '' }, skipValidation: true }
   await expect(user.update(u8)).resolves.toEqual({})
   await expect(user.findOne(userId)).resolves.toEqual({ _id: userId, profile: {} })
+
+  db2.close()
 })

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))
@@ -87,7 +87,7 @@ test('manager > events', async () => {
     })
   }
   // 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,10 @@ 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()
 })