monastery 3.0.4 → 3.0.6

package/.eslintrc.json

@@ -9,6 +9,7 @@
   ],
   "globals": {
     // jest globals
+    "jest": true,
     "test": true,
     "expect": true,
     "afterAll": true,

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.6](https://github.com/boycce/monastery/compare/3.0.5...3.0.6) (2024-04-29)
+
+### [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)

package/docs/readme.md

@@ -87,9 +87,11 @@ You can view MongoDB's [compatibility table here](https://www.mongodb.com/docs/d
   - Removed callback functions on all model methods, you can use the returned promise instead
   - model.update() now returns the following _update property: `{ acknowledged: true, matchedCount: 1, modifiedCount: 1, upsertedCount: 0, upsertedId: null }` instead of `{ n: 1, nModified: 1, ok: 1 }`
   - model.remove() now returns `{ acknowledged: true, deletedCount: 1 }`, instead of `{ results: {n:1, ok:1} }`
-  - Models are now added to db.models instead of db.model, e.g. db.models.user
-  - MongoDB connection can be found here db.db changed from db._db
   - model._indexes() now returns collection._indexes() not collection._indexInformation()
+  - db.model.* moved to db.models.*
+  - db._client moved to db.client
+  - db._db moved to db.db
+  - db.catch/then() moved to db.onError/db.onOpen()
 
 ## Roadmap
 

package/lib/index.js

@@ -215,7 +215,7 @@ Manager.prototype.onError = function(fn) {
       resolve(err)
     })
   }).then((err) => {
-    fn(err)
+    return fn(err)
   })
 }
 
@@ -226,6 +226,9 @@ Manager.prototype.onOpen = function(fn) {
    * @return {Promise(manager)}
    */
   return new Promise((resolve, reject) => {
+    if (this._state == 'open') {
+      resolve(this)
+    }
     this.on('open', () => {
       resolve(this)
     })
@@ -233,7 +236,7 @@ Manager.prototype.onOpen = function(fn) {
       reject(err)
     })
   }).then((err) => { // If `then` is not chained, the error will be thrown, detached!
-    fn(err)
+    return fn(err)
   })
 }
 

package/lib/model-crud.js

@@ -48,9 +48,9 @@ Model.prototype.insert = async function (opts) {
     let data = await this.validate(opts.data || {}, opts) // was { ...opts }
 
     // Insert
-    await util.runSeries(this.beforeInsert.map(f => f.bind(opts, data)))
+    await util.runSeries(this.beforeInsert.map(f => f.bind(opts, data)), `${this.name}.beforeInsert`)
     let response = await this._insert(data, util.omit(opts, this._queryOptions))
-    await util.runSeries(this.afterInsert.map(f => f.bind(opts, response)))
+    await util.runSeries(this.afterInsert.map(f => f.bind(opts, response)), `${this.name}.afterInsert`)
 
     // Success/error
     if (opts.req && opts.respond) opts.req.res.json(response)
@@ -267,7 +267,7 @@ Model.prototype.update = async function (opts, type='update') {
     }
 
     // Hook: beforeUpdate (has access to original, non-validated opts.data)
-    await util.runSeries(this.beforeUpdate.map(f => f.bind(opts, data||{})))
+    await util.runSeries(this.beforeUpdate.map(f => f.bind(opts, data||{})), `${this.name}.beforeUpdate`)
 
     if (data && operators['$set']) {
       this.info(`'$set' fields take precedence over the data fields for \`${this.name}.${type}()\``)
@@ -297,7 +297,9 @@ Model.prototype.update = async function (opts, type='update') {
     }
 
     // Hook: afterUpdate (doesn't have access to validated data)
-    if (response) await util.runSeries(this.afterUpdate.map(f => f.bind(opts, response)))
+    if (response) {
+      await util.runSeries(this.afterUpdate.map(f => f.bind(opts, response)), `${this.name}.afterUpdate`)
+    }
 
     // Hook: afterFind if findOneAndUpdate
     if (response && type == 'findOneAndUpdate') {
@@ -329,9 +331,9 @@ Model.prototype.remove = async function (opts) {
     opts = await this._queryObject(opts, 'remove')
 
     // Remove
-    await util.runSeries(this.beforeRemove.map(f => f.bind(opts)))
+    await util.runSeries(this.beforeRemove.map(f => f.bind(opts)), `${this.name}.beforeRemove`)
     let response = await this._remove(opts.query, util.omit(opts, this._queryOptions))
-    await util.runSeries(this.afterRemove.map(f => f.bind(response)))
+    await util.runSeries(this.afterRemove.map(f => f.bind(response)), `${this.name}.afterRemove`)
 
     // Success
     if (opts.req && opts.respond) opts.req.res.json(response)
@@ -589,7 +591,7 @@ Model.prototype._processAfterFind = function (data, projection={}, afterFindCont
       callbackSeries.push(fn.bind(afterFindContext, item.dataRef))
     }
   }
-  return util.runSeries(callbackSeries).then(() => data)
+  return util.runSeries(callbackSeries, 'afterFind').then(() => data)
 }
 
 Model.prototype._recurseAndFindModels = function (parentPath, schemaFields, dataArr) {

package/lib/model-validate.js

@@ -29,7 +29,8 @@ Model.prototype.validate = async function (data, opts) {
   else opts.projectionValidate = this._getProjectionFromBlacklist(opts.update ? 'update' : 'insert', opts.blacklist)
 
   // Hook: beforeValidate
-  await util.runSeries(this.beforeValidate.map(f => f.bind(opts, data)))
+
+  await util.runSeries(this.beforeValidate.map(f => f.bind(opts, data)), `${this.name}.beforeValidate`)
 
   // Recurse and validate fields
   let response = util.toArray(data).map(item => {

package/lib/util.js

@@ -309,10 +309,11 @@ module.exports = {
     return variable
   },
 
-  runSeries: function(tasks, cb) {
+  runSeries: function(tasks, info, cb) {
     /*
      * Runs functions in series and calls the cb when done
      * @param {function(err, result)[]} tasks - array of functions
+     * @param {object} <info> - data to pass to the error
      * @param {function(err, results[])} <cb>
      * @return promise
      * @source https://github.com/feross/run-series
@@ -322,9 +323,10 @@ module.exports = {
     let isSync = true
 
     return new Promise((res, rej) => {
-      function each(i, err, result) { // aka next(err, data)
-        if (i == current + 1) {
-          throw new Error('Hook error: you cannot return a promise and call next()')
+      function next(i, err, result) { // aka next(err, data)
+        if (i !== current) {
+          console.error(`Monastery ${info} error: you cannot return a promise AND call next()`)
+          return
         }
         results.push(result)
         if (!err && ++current < tasks.length) callTask(current)
@@ -340,10 +342,10 @@ module.exports = {
         else res(results)
       }
       function callTask(i) {
-        const each2 = each.bind(null, i)
-        const res = tasks[i](each2)
+        const next2 = next.bind(null, i)
+        const res = tasks[i](next2)
         if (res instanceof Promise) {
-          res.then((result) => each2(null, result)).catch(each2)
+          res.then((result) => next2(null, result)).catch(next2)
         }
       }
       

package/package.json

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

package/test/crud.js

@@ -856,4 +856,94 @@ test('hooks > async', async () => {
   // Third async hook throws an error
   await expect(user.find({ query: user3Doc._id }))
     .rejects.toThrow('An async error occurred with Martin3')
+})
+
+test('hooks > async and next conflict', async () => {
+  let user1 = db.model('user', {
+    fields: { age: { type: 'number'} },
+    afterFind: [
+      async (data, next) => {
+        const promise = await new Promise((resolve, reject) => {
+          if (data.age === 0) {
+            setTimeout(() => {
+              data.age = data.age + 1
+              resolve(data)
+            }, 100)
+          } else {
+            resolve(data)
+          }
+        })
+        next() // should console an error after waiting for the promise to finish
+        return promise
+      },
+      async (data, next) => {
+        data.age = data.age + 1
+      },
+    ],
+  })
+  let user2 = db.model('user2', {
+    fields: { age: { type: 'number'} },
+    afterFind: [
+      async (data, next) => {
+        await new Promise((resolve, reject) => {
+          setTimeout(() => {
+            data.age = data.age + 1
+            resolve(data)
+          }, 100)
+        })
+        next() // should console an error after waiting for the promise to finish, without returning a promise
+      },
+      async (data, next) => {
+        data.age = data.age + 1
+      },
+    ],
+  })
+  let user3 = db.model('user3', {
+    fields: { age: { type: 'number'} },
+    afterFind: [
+      async (data, next) => {
+        next() // should console an error for empty promise
+      },
+      async (data, next) => {
+        data.age = data.age + 1
+      },
+    ],
+  })
+  let user4 = db.model('user3', {
+    fields: { age: { type: 'number'} },
+    afterFind: [
+      async (data, next) => {
+        return await new Promise((resolve, reject) => {
+          setTimeout(() => {
+            data.age = data.age + 1
+            next() // should console an error
+            resolve(data)
+          }, 100)
+        })
+      },
+      async (data, next) => {
+        data.age = data.age + 1
+      },
+    ],
+  })
+  let user1Doc = await user1.insert({ data: { age: 0 } })
+  let user2Doc = await user2.insert({ data: { age: 0 } })
+  let user3Doc = await user3.insert({ data: { age: 0 } })
+  let user4Doc = await user4.insert({ data: { age: 0 } })
+
+  const logSpy = jest.spyOn(console, 'error').mockImplementation(() => {})
+
+  // Only increment twice
+  await expect(user1.find({ query: user1Doc._id })).resolves.toEqual({ _id: expect.any(Object), age: 2 })
+  expect(logSpy).toHaveBeenCalledWith('Monastery afterFind error: you cannot return a promise AND call next()')
+
+  await expect(user2.find({ query: user2Doc._id })).resolves.toEqual({ _id: expect.any(Object), age: 2 })
+  expect(logSpy).toHaveBeenCalledWith('Monastery afterFind error: you cannot return a promise AND call next()')
+
+  await expect(user3.find({ query: user3Doc._id })).resolves.toEqual({ _id: expect.any(Object), age: 2 })
+  expect(logSpy).toHaveBeenCalledWith('Monastery afterFind error: you cannot return a promise AND call next()')
+
+  await expect(user4.find({ query: user4Doc._id })).resolves.toEqual({ _id: expect.any(Object), age: 2 })
+  expect(logSpy).toHaveBeenCalledWith('Monastery afterFind error: you cannot return a promise AND call next()')
+
 })

package/test/manager.js

@@ -18,18 +18,34 @@ test('manager > uri error', async () => {
 
 test('manager > onError', async () => {
   // Bad port (thrown by MongoDB)
-  let error
   const db = monastery('localhost:1234/monastery', { serverSelectionTimeoutMS: 500 })
-  await db.onError((res) => { error = res.message })
+  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 () => {
-  let manager
   const db = monastery('localhost/monastery', { serverSelectionTimeoutMS: 500 })
-  await db.onOpen((res) => { manager = res })
-  expect(manager.open).toEqual(expect.any(Function))
+
+  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)
+  })
+
+  // 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()
 })