monastery 3.0.3 → 3.0.5

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.0.5](https://github.com/boycce/monastery/compare/3.0.4...3.0.5) (2024-04-29)
+
+### [3.0.4](https://github.com/boycce/monastery/compare/3.0.3...3.0.4) (2024-04-29)
+
 ### [3.0.3](https://github.com/boycce/monastery/compare/3.0.2...3.0.3) (2024-04-28)
 
 ### [3.0.2](https://github.com/boycce/monastery/compare/3.0.1...3.0.2) (2024-04-28)

package/docs/manager/index.md

@@ -30,24 +30,22 @@ A manager instance.
 
 ```js
 import monastery from 'monastery'
-const db = monastery('localhost/mydb', options)
-```
-
-```js
-import monastery from 'monastery'
-const db = monastery('localhost/mydb,192.168.1.1') // replica set
-```
 
-```js
- // You can wait for the connection (which is not required before calling methods)
-import monastery from 'monastery'
+const db = monastery('localhost/mydb', options)
+// replica set
+const db = monastery('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 })
 ```
 
+You can also listen for errors or successful connection using these hooks
 ```js
-// You can listen for connection errors using our `catch` hook
-import monastery from 'monastery'
-const db = monastery('localhost/mydb,192.168.1.1').catch(err => {})
+db.onOpen((manager) => {
+  // manager.client is connected...
+})
+db.onError((err) => {
+  // connection error
+})
 ```
 
 ### Properties
@@ -57,11 +55,12 @@ const db = monastery('localhost/mydb,192.168.1.1').catch(err => {})
 
 ### Methods
 
-- `manager.catch(Function)`: Catches connection errors
 - `manager.id(<String|ObjectId>)`: Create or convert a valid MongoDB ObjectId string into an ObjectId
 - `manager.isId(String|ObjectId)`: Checks if the passed variable is a valid MongoDB ObjectId or ObjectId string
 - `manager.model()`: [see model](./model.html)
 - `manager.models()`: [see models](./models.html)
+- `manager.onError(Function)`: Catches connection errors
+- `manager.onOpen(Function)`: Triggers on successful connection
 
 ### Dates
 

package/lib/index.js

@@ -44,6 +44,7 @@ function Manager(uri, opts) {
   }, {})
 
   // Add properties
+  this.uri = uri
   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 ? '' : '*'))
@@ -53,11 +54,11 @@ function Manager(uri, opts) {
   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)
+  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 = uri
+    this.client = this.uri
   }
 
   // Listen to MongoDB events
@@ -93,17 +94,6 @@ Manager.prototype.arrayWithSchema = function(array, schema) {
   return array
 }
 
-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
@@ -214,10 +204,46 @@ Manager.prototype.models = async function(pathname, waitForIndexes) {
   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}
+   * @return {Promise(manager)}
    */
   try {
     this._state = 'opening'
@@ -232,8 +258,8 @@ Manager.prototype.open = async function() {
     if (this.listeners('error').length > 0) {
       this.emit('error', err)
     }
-    if (!this.catching) {
-      throw err
+    if (this.opts.promise || this.listeners('error').length == 0) {
+      throw new Error(err)
     }
   }
 }

package/package.json

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

package/test/index.test.js

@@ -10,6 +10,8 @@
  *   - expect().toEqual:  strict deep match
  *   - expect().toMatchObject:  received object can have random properties (try not to use since its not strict)
  *   - expect.objectContaining:
+ *   - try/catch blocks: don't use - it doesn't work with resolves/rejects
+ *   - promise testing: await expect(PromiseHere).resolves.toEqual
  */
 
 /* Run tests sequentially */
@@ -19,7 +21,6 @@ require('./collection.js')
 require('./model.js')
 require('./crud.js')
 require('./blacklisting.js')
-
 require('./populate.js')
 require('./validate.js')
 require('./plugin-images.js')

package/test/manager.js

@@ -16,33 +16,66 @@ test('manager > uri error', async () => {
   expect(() => monastery('', {})).toThrow('No connection URI provided.')
 })
 
-test('manager > catch', async () => {
+test('manager > onError', async () => {
   // Bad port (thrown by MongoDB)
-  const db = monastery('localhost:1234/monastery', { serverSelectionTimeoutMS: 1000 }).catch((err) => {
-    expect(err.message).toEqual('connect ECONNREFUSED 127.0.0.1:1234')
+  const db = monastery('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')
+  expect(isAPromise).toEqual(true)
+  db.close()
+})
+
+test('manager > onOpen', async () => {
+  const db = monastery('localhost/monastery', { serverSelectionTimeoutMS: 500 })
+
+  let manager1
+  await db.onOpen((res) => { manager1 = res })
+  expect(manager1.open).toEqual(expect.any(Function))
+
+  // Wait until after the client has been connected
+  await new Promise((resolve, reject) => {
+    setTimeout(() => {
+      resolve()
+    }, 1000)
   })
-  // the manager is still retuned
-  expect(db?.open).toEqual(expect.any(Function))
+
+  // This should still run after the client has been connected
+  let manager2
+  let isAPromise
+  await db.onOpen((res) => { manager2 = res }).then(() => { isAPromise = true })
+  expect(manager2.open).toEqual(expect.any(Function))
+  expect(isAPromise).toEqual(true)
+  db.close()
+})
+
+test('manager > onOpen error', async () => {
+  // Bad port (thrown by MongoDB)
+  let manager
+  const db = monastery('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))
   db.close()
 })
 
 test('manager > return a promise', async () => {
-  const db = await monastery('localhost/monastery', { serverSelectionTimeoutMS: 2000, promise: true })
+  const db = await monastery('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: 1000, promise: true }))
+  await expect(monastery('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: 2000, promise: true })
+  const db = await monastery(mongoClient, { serverSelectionTimeoutMS: 500, promise: true })
   expect(db).toEqual(expect.any(Object))
   expect(db.client).toEqual(expect.any(Object))
-  expect(db.catch).toEqual(expect.any(Function))
+  expect(db.isId).toEqual(expect.any(Function))
   db.close()
 })
 
@@ -68,7 +101,7 @@ test('manager > events', async () => {
 })
 
 test('Manager > get collection', async () => {
-  const manager = monastery('localhost/monastery', { serverSelectionTimeoutMS: 2000 })
+  const manager = monastery('localhost/monastery', { serverSelectionTimeoutMS: 500 })
   // Basic aggregate command
   expect(await manager.get('non-collection').aggregate([], {})).toEqual([])
   // Basic find command