monastery 3.5.0 → 3.5.2

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.2](https://github.com/boycce/monastery/compare/3.5.1...3.5.2) (2025-01-22)
+
+### [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)

package/lib/index.js

@@ -1,26 +1,8 @@
 const Manager = require('./manager')
-const inherits = require('util').inherits
 const rules = require('./rules.js')
 
-function Monastery() {
-  let hasDefaultManager = false
-
-  this.manager = function(uri, opts) {
-    const manager = new Manager(uri, opts)
-    // Inherit the default manager onto Monastery once
-    if (!hasDefaultManager) {
-      hasDefaultManager = true
-      Object.assign(this, manager)
-    }
-    return manager
-  }
-}
-
-// Inherit Manager prototypes onto Monastery
-inherits(Monastery, Manager)
-
 // Exports
-module.exports = new Monastery()
+module.exports = new Manager('init')
 module.exports.arrayWithSchema = Manager.prototype.arrayWithSchema
 module.exports.getSignedUrl = Manager.prototype.getSignedUrl
 module.exports.id = Manager.prototype.id

package/lib/manager.js

@@ -2,14 +2,15 @@ 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) {
+let hasDefaultManager = false
+
+function Manager(uri, opts, parent) {
   /**
    * Constructs a new manager which contains a new MongoDB client
    * 
@@ -22,8 +23,11 @@ function Manager(uri, opts) {
    * @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')
@@ -34,51 +38,51 @@ function Manager(uri, opts) {
 
   // 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]
+    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 = []
+  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 > 0) this.error.enabled = true
-    if (opts.logLevel > 1) this.warn.enabled = true
-    if (opts.logLevel > 2) this.info.enabled = true
+    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 this.uri == 'string' || Array.isArray(this.uri)) {
-    this.uri = this.connectionString(this.uri, opts.databaseName)
-    this.client = new MongoClient(this.uri, mongoOpts)
+  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 {
-    this.client = this.uri
+    that.client = that.uri
   }
 
   // Listen to MongoDB events
   for (let eventName of ['close', 'error', 'timeout']) {
-    this.client.on(eventName, (e) => this.emit(eventName, e))
+    that.client.on(eventName, (e) => that.emitter.emit(eventName, e))
   }
 
   // Listen to custom open event
-  this.on('open', () => {
+  that.emitter.on('open', () => {
     // wait for all the on('open') events to get called first
     setTimeout(() => {
-      for (let item of this._openQueue) {
+      for (let item of that._openQueue) {
         item()
       }
     })
@@ -86,12 +90,17 @@ function Manager(uri, opts) {
 
   // Initiate any plugins
   if (opts.imagePlugin) {
-    imagePluginFile.setup(this, util.isObject(opts.imagePlugin) ? opts.imagePlugin : {})
+    imagePluginFile.setup(that, util.isObject(opts.imagePlugin) ? opts.imagePlugin : {})
   }
 
-  // Connect to the database
-  if (opts.promise) return this.open()
-  else this.open()
+  // 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) {
@@ -104,9 +113,9 @@ Manager.prototype.close = async function() {
    * Close the database connection, gracefully
    */
   const _close = async () => {
-    this.emit(this._state = 'closing')
+    this.emitter.emit(this._state = 'closing')
     await this.client.close()
-    this.emit(this._state = 'close')
+    this.emitter.emit(this._state = 'close')
   }
   if (this._state == 'open') {
     return await _close()
@@ -179,26 +188,33 @@ Manager.prototype.isId = function(value) {
   return util.isId(value)
 }
 
-Manager.prototype.models = async function(pathname, opts) {
+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 || {}
+  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() 
@@ -219,7 +235,11 @@ Manager.prototype.onError = function(fn) {
    * @return {Promise}
    */
   return new Promise((resolve, reject) => {
-    this.on('error', (err) => {
+    if (!this.emitter) {
+      reject(new Error('Emitter not found! This can happen if two seperate monastery packages are imported into the ' +
+        'same project. E.g. the first package initializes the manager, and the second package tries to use it.'))
+    }
+    this.emitter.on('error', (err) => {
       resolve(err)
     })
   }).then((err) => {
@@ -234,13 +254,17 @@ Manager.prototype.onOpen = function(fn) {
    * @return {Promise(manager)}
    */
   return new Promise((resolve, reject) => {
+    if (!this.emitter) {
+      reject(new Error('Emitter not found! This can happen if two seperate monastery packages are imported into the ' +
+        'same project. E.g. the first package initializes the manager, and the second package tries to use it.'))
+    }
     if (this._state == 'open') {
       resolve(this)
     }
-    this.on('open', () => {
+    this.emitter.on('open', () => {
       resolve(this)
     })
-    this.on('error', (err) => {
+    this.emitter.on('error', (err) => {
       reject(err)
     })
   }).then((err) => { // If `then` is not chained, the error will be thrown, detached!
@@ -257,16 +281,16 @@ Manager.prototype.open = async function() {
     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)
+    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.listeners('error').length > 0) {
-      this.emit('error', err)
+    if (this.emitter.listeners('error').length > 0) {
+      this.emitter.emit('error', err)
     }
-    if (this.opts.promise || this.listeners('error').length == 0) {
+    if (this.opts.promise || this.emitter.listeners('error').length == 0) {
       throw new Error(err)
     }
   }
@@ -284,6 +308,4 @@ Manager.prototype._getSignedUrl = () => {
   throw new Error('monastery._getSignedUrl() has been moved to monastery.getSignedUrl()')
 }
 
-inherits(Manager, EventEmitter)
-
 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.5.0",
+  "version": "3.5.2",
   "license": "MIT",
   "repository": "github:boycce/monastery",
   "homepage": "https://boycce.github.io/monastery/",

package/test/manager.js

@@ -83,7 +83,7 @@ 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
@@ -108,3 +108,17 @@ test('Manager > get collection', async () => {
   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()
+})