monastery 3.0.21 → 3.0.22

package/changelog.md

@@ -2,6 +2,8 @@
 
 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.22](https://github.com/boycce/monastery/compare/3.0.21...3.0.22) (2024-05-08)
+
 ### [3.0.21](https://github.com/boycce/monastery/compare/3.0.20...3.0.21) (2024-05-07)
 
 ### [3.0.20](https://github.com/boycce/monastery/compare/3.0.19...3.0.20) (2024-05-05)

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.call(this, this.beforeInsert.map(f => f.bind(opts, data)), 'beforeInsert')
+    data = await util.runSeries.call(this, this.beforeInsert.map(f => f.bind(opts)), 'beforeInsert', data)
     let response = await this._insert(data, util.omit(opts, this._queryOptions))
-    await util.runSeries.call(this, this.afterInsert.map(f => f.bind(opts, response)), 'afterInsert')
+    response = await util.runSeries.call(this, this.afterInsert.map(f => f.bind(opts)), 'afterInsert', response)
 
     // Success/error
     if (opts.req && opts.respond) opts.req.res.json(response)
@@ -283,7 +283,8 @@ Model.prototype.update = async function (opts, type='update') {
     }
 
     // Hook: beforeUpdate (has access to original, non-validated opts.data)
-    await util.runSeries.call(this, this.beforeUpdate.map(f => f.bind(opts, data||{})), 'beforeUpdate')
+    data = data || {}
+    data = await util.runSeries.call(this, this.beforeUpdate.map(f => f.bind(opts)), 'beforeUpdate', data)
 
     if (data && operators['$set']) {
       this.info(`'$set' fields take precedence over the data fields for \`${this.name}.${type}()\``)
@@ -314,7 +315,7 @@ Model.prototype.update = async function (opts, type='update') {
 
     // Hook: afterUpdate (doesn't have access to validated data)
     if (response) {
-      await util.runSeries.call(this, this.afterUpdate.map(f => f.bind(opts, response)), 'afterUpdate')
+      response = await util.runSeries.call(this, this.afterUpdate.map(f => f.bind(opts)), 'afterUpdate', response)
     }
 
     // Hook: afterFind if findOneAndUpdate
@@ -561,7 +562,7 @@ Model.prototype._pathBlacklisted = function (path, projection, matchDeepWhitelis
   return inclusion? true : false
 }
 
-Model.prototype._processAfterFind = function (data, projection={}, afterFindContext={}) {
+Model.prototype._processAfterFind = async function (data, projection={}, afterFindContext={}) {
   /**
    * Todo: Maybe make this method public?
    * Recurses through fields that are models and populates missing default-fields and calls model.afterFind([fn,..])
@@ -576,16 +577,26 @@ Model.prototype._processAfterFind = function (data, projection={}, afterFindCont
    */
   // Recurse down from the parent model, ending with the parent model as the parent afterFind hook may
   // want to manipulate any populated models
-  let callbackSeries = []
+  let seriesGroups = []
   let models = this.manager.models
-  let parent = util.toArray(data).map(o => ({ dataRef: o, dataPath: '', dataFieldName: '', modelName: this.name }))
-  let modelFields = this._recurseAndFindModels(data).concat(parent)
+  let isArray = util.isArray(data)
+  if (!isArray) data = [data]
+  let modelFields = this
+    ._recurseAndFindModels(data)
+    .concat(data.map((o, i) => ({
+      dataRefParent: data,
+      dataRefKey: i,
+      dataPath: '', 
+      dataFieldName: '', 
+      modelName: this.name,
+    })))
 
   // Loop found model/deep-model data objects, and populate missing default-fields and call afterFind on each
   for (let item of modelFields) {
+    const dataRef = item.dataRefParent[item.dataRefKey]
     // Populate missing default fields if data !== null
     // NOTE: maybe only call functions if default is being set.. fine for now
-    if (item.dataRef) {
+    if (dataRef) {
       for (const localSchemaFieldPath in models[item.modelName].fieldsFlattened) {
         const schema = models[item.modelName].fieldsFlattened[localSchemaFieldPath]
         if (!util.isDefined(schema.default) || localSchemaFieldPath.match(/^\.?(createdAt|updatedAt)$/)) continue
@@ -601,25 +612,37 @@ Model.prototype._processAfterFind = function (data, projection={}, afterFindCont
 
         // Set default value
         const value = util.isFunction(schema.default) ? schema.default(this.manager) : schema.default
-        util.setDeepValue(item.dataRef, localSchemaFieldPath.replace(/\.0(\.|$)/g, '.$$$1'), value, true, false, true)
+        util.setDeepValue(dataRef, localSchemaFieldPath.replace(/\.0(\.|$)/g, '.$$$1'), value, true, false, true)
       }
     }
     // Collect all of the model's afterFind hooks
-    for (let fn of models[item.modelName].afterFind) {
-      callbackSeries.push(fn.bind(afterFindContext, item.dataRef))
+    if (models[item.modelName].afterFind.length) {
+      seriesGroups.push(
+        (async (_item) => {
+          const _modelName = _item.modelName
+          const _model = models[_modelName]
+          const _opts = { ...afterFindContext, afterFindName: _modelName }
+          const _dataRef = _item.dataRefParent[_item.dataRefKey]
+          _item.dataRefParent[_item.dataRefKey] = (
+            await util.runSeries.call(_model, _model.afterFind.map(f => f.bind(_opts)), 'afterFind', _dataRef)
+          )
+        }).bind(null, item)
+      )
     }
   }
-  return util.runSeries.call(this, callbackSeries, 'afterFind').then(() => data)
+  for (let item of seriesGroups) await item()
+  return isArray ? data : data[0]
 }
 
 Model.prototype._recurseAndFindModels = function (dataArr, dataParentPath='', modelPaths) {
   /**
-   * Returns a flattened list of models fields
+   * Returns a flattened list of models fields, sorted by depth
    * @param {object|array} dataArr
    * @param {string} <dataParentPath>
    * @this Model
    * @return [{
-   *   dataRef: { *fields here* },
+   *   dataRefParent: { *fields here* },
+   *   dataRefKey: 'fieldName',
    *   dataPath: 'usersNewCompany',
    *   dataFieldName: usersNewCompany,
    *   modelName: company
@@ -667,7 +690,8 @@ Model.prototype._recurseAndFindModels = function (dataArr, dataParentPath='', mo
       // Array of data models (schema field can be either a single or array of models, due to custom $lookup's)
       } else if (pathMatch && util.isObject(data[key])) {
         out.push({
-          dataRef: data[key],
+          dataRefParent: data,
+          dataRefKey: key,
           dataPath: dataPath,
           dataFieldName: key,
           modelName: this.fieldsFlattened[modelPath.k].model,
@@ -677,7 +701,8 @@ Model.prototype._recurseAndFindModels = function (dataArr, dataParentPath='', mo
       } else if (pathMatch && util.isObject(data[key][0])) {
         for (let i=0, l=data[key].length; i<l; i++) {
           out.push({
-            dataRef: data[key][i],
+            dataRefParent: data[key],
+            dataRefKey: i,
             dataPath: dataPath + '.' + i,
             dataFieldName: key,
             modelName: this.fieldsFlattened[modelPath.k].model,
@@ -687,6 +712,9 @@ Model.prototype._recurseAndFindModels = function (dataArr, dataParentPath='', mo
     }
   }
 
+  // Sort by dataPath length so that nested models are processed first
+  // note: this shouldn't matter anyway since we can't currently have nested populated models
+  out = out.sort((a, b) => b.dataPath.split('.').length - a.dataPath.split('.').length)
   return out
 }
 

package/lib/model-validate.js

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

package/lib/util.js

@@ -311,20 +311,21 @@ module.exports = {
     return variable
   },
 
-  runSeries: function(tasks, hookName, cb) {
+  runSeries: function(tasks, hookName, data) {
     /*
-     * Runs functions in series and calls the cb when done
+     * Runs functions in series
      * @param {function(err, result)[]} tasks - array of functions
      * @param {string} <hookName> - e.g. 'afterFind'
+     * @param {any} data - data to pass to the first function
      * @param {function(err, results[])} <cb>
      * @return promise
      * @this Model
      * @source https://github.com/feross/run-series
      */
     let current = 0
-    let results = []
     let isSync = true
-    let caller = hookName == 'afterFind' ? 'afterFind' : this.name + '.' + hookName
+    let caller = (this.afterFindName || this.name) + '.' + hookName
+    let lastDefinedResult = data
 
     return new Promise((res, rej) => {
       const next = (i, err, result) => { // aka next(err, data)
@@ -333,8 +334,8 @@ module.exports = {
           return
         }
         current++
-        results.push(result)
-        if (!err && current < tasks.length) callTask(current)
+        if (!err && typeof result !== 'undefined') lastDefinedResult = result
+        if (!err && current < tasks.length) callTask(current, lastDefinedResult)
         else done(err)
       }
       const done = (err) => {
@@ -342,13 +343,13 @@ module.exports = {
         else end(err)
       }
       const end = (err) => {
-        if (cb) cb(err, results)
         if (err) rej(err)
-        else res(results)
+        else res(lastDefinedResult)
       }
-      const callTask = (i) => {
+      const callTask = (i, data) => {
         const next2 = next.bind(null, i)
-        const res = tasks[i](next2)
+        const args = hookName.match(/remove/i)? [next2] : [data, next2]
+        const res = tasks[i](...args)
         if (res instanceof Promise) {
           res.then((result) => next2(null, result)).catch((e) => next2(e))
         }
@@ -356,7 +357,7 @@ module.exports = {
       
       // Start
       if (!tasks.length) done(null)
-      else callTask(current)
+      else callTask(current, lastDefinedResult)
       
       isSync = false
     })

package/package.json

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

package/test/crud.js

@@ -687,7 +687,7 @@ test('count defaults', async () => {
     .resolves.toEqual(2)
 })
 
-test('hooks', async () => {
+test('hooks > basic', async () => {
   let user = db.model('user', {
     fields: {
       first: { type: 'string'},
@@ -774,6 +774,123 @@ test('hooks', async () => {
   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 = [
+    async (data) => {
+      return // ignored
+    },
+    async (data) => {
+      data.first = 'Martin11'
+    },
+    async (data) => {
+      expect(data.first).toEqual('Martin11')
+      return { ...data, first: 'Martin' }
+    },
+    async (data) => {
+      expect(data.first).toEqual('Martin')
+      return  // ignored
+    },
+  ]
+  const afterFindAsync = [
+    async (data) => {
+      return // ignored
+    },
+    async (data) => {
+      bookCount++
+      if (data.bookNumber) data.bookNumber += (1 + bookCount)
+      else data.first = 'Martin2'
+    },
+    async (data) => {
+      if (data.bookNumber) {
+        expect(data).toEqual({ _id: expect.any(Object), bookNumber: 11 + bookCount })
+        return { _id: 1, bookNumber: 11 + bookCount }
+      } else {
+        expect(data).toEqual({ _id: expect.any(Object), first: 'Martin2', books: data.books })
+        return { _id: 2, books: data.books }
+      }
+    },
+    async (data) => {
+      if (data._id == 1) expect(data).toEqual({ _id: 1, bookNumber: 11 + bookCount })
+      else expect(data).toEqual({ _id: 2, books: data.books })
+      return  // ignored
+    },
+  ]
+  const afterFindCallback = [
+    (data, next) => {
+      next() // ignored
+    },
+    (data, next) => {
+      bookCount++
+      if (data.bookNumber) data.bookNumber += (1 + bookCount)
+      else data.first = 'Martin2'
+      next()
+    },
+    (data, next) => {
+      if (data.bookNumber) {
+        expect(data).toEqual({ _id: expect.any(Object), bookNumber: 11 + bookCount })
+        next(null, { _id: 1, bookNumber: 11 + bookCount })
+      } else {
+        expect(data).toEqual({ _id: expect.any(Object), first: 'Martin2', books: data.books })
+        next(null, { _id: 2, books: data.books })
+      }
+    },
+    (data, next) => {
+      if (data._id == 1) expect(data).toEqual({ _id: 1, bookNumber: 11 + bookCount })
+      else expect(data).toEqual({ _id: 2, books: data.books })
+      next()  // ignored
+    },
+  ]
+
+  // Async
+  db.model('book', {
+    fields: { bookNumber: { type: 'number'} },
+    afterFind: afterFindAsync,
+  })
+  db.model('user', {
+    fields: { first: { type: 'string'}, books: [{ model: 'book' }] },
+    afterInsert: afterInsertAsync,
+    afterFind: afterFindAsync,
+  })
+  let bookDoc = await db.book.insert({ data: { bookNumber: 10 }})
+  let bookDoc2 = await db.book.insert({ data: { bookNumber: 10 }})
+  let userDoc = await db.user.insert({ data: { first: 'Martin0', books: [bookDoc._id, bookDoc2._id]}})
+
+  // AfterInsert async
+  expect(userDoc).toEqual({
+    _id: expect.any(Object),
+    first: 'Martin',
+    books: [bookDoc._id, bookDoc2._id],
+  })
+
+  // AfterFind async
+  await expect(db.user.find({ query: userDoc._id, populate: ['books'] })).resolves.toEqual({ 
+    _id: 2,
+    books: [
+      { _id: 1, bookNumber: 12 },
+      { _id: 1, bookNumber: 13 },
+    ],
+  })
+
+  // AfterFind callback/next
+  db.model('book', {
+    fields: { bookNumber: { type: 'number'} },
+    afterFind: afterFindCallback,
+  })
+  db.model('user', {
+    fields: { first: { type: 'string'}, books: [{ model: 'book' }] },
+    afterFind: afterFindCallback,
+  })
+  await expect(db.user.find({ query: userDoc._id, populate: ['books'] })).resolves.toEqual({ 
+    _id: 2,
+    books: [
+      { _id: 1, bookNumber: 15 },
+      { _id: 1, bookNumber: 16 },
+    ],
+  })
+
+})
+
 test('hooks > async', async () => {
   let user = db.model('user', {
     fields: {
@@ -954,19 +1071,19 @@ test('hooks > async and next conflict', async () => {
 
   // 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()')
+  expect(logSpy).toHaveBeenCalledWith('Monastery user.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()')
+  expect(logSpy).toHaveBeenCalledWith('Monastery user.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()')
+  expect(logSpy).toHaveBeenCalledWith('Monastery user.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()')
+  expect(logSpy).toHaveBeenCalledWith('Monastery user.afterFind error: you cannot return a promise AND call next()')
 
   await expect(user5.find({ query: user5Doc._id })).rejects.toThrow('An async error occurred with Martin3')
-  expect(logSpy).toHaveBeenCalledWith('Monastery afterFind error: you cannot return a promise AND call next()')
+  expect(logSpy).toHaveBeenCalledWith('Monastery user.afterFind error: you cannot return a promise AND call next()')
 
   db2.close()
 })