monastery 3.4.2 → 3.4.3

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.4.3](https://github.com/boycce/monastery/compare/3.4.2...3.4.3) (2024-08-27)
+
 ### [3.4.2](https://github.com/boycce/monastery/compare/3.4.1...3.4.2) (2024-08-24)
 
 ### [3.4.1](https://github.com/boycce/monastery/compare/3.4.0...3.4.1) (2024-08-09)

package/docs/manager/model.md

@@ -11,7 +11,9 @@ Sets up a model, retrieves a collection, and sets up any required indexes
 
 `name` *(string)*: name of the mongo collection
 
-[`definition`] *(object)*: [definition](../definition)
+`definition` *(object)*: [definition](../definition)
+
+`waitForIndexes` *(boolean)*: wait for indexes to be setup (returns a promise instead of a model)
 
 ### Returns
 

package/docs/manager/models.md

@@ -13,7 +13,7 @@ Setup model definitions from a folder location
 
 [`options`] *(object)*:
   - [`commonJs=false`] *(boolean)*: for old commonjs projects, you will need to set this to `true` which uses `require` instead of `import` (removed in `3.0.0`)
-  - [`waitForIndexes=false`] *(boolean)*: returns a proimse that waits for the Mongo collection indexes to be setup
+  - [`waitForIndexes=false`] *(boolean)*: wait for collection indexes to be setup
 
 ### Returns
 
@@ -39,5 +39,5 @@ export default { // Make sure the model definition is exported as the default
 ```
 
 ```js
-await db.models(__dirname + "models")
+await db.models(__dirname + 'models', { waitForIndexes: true })
 ```

package/lib/index.js

@@ -211,7 +211,7 @@ Manager.prototype.models = async function(pathname, opts) {
     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 })
+    if (waitForIndexes) out[name] = await this.model(name, definition, waitForIndexes)
     else out[name] = this.model(name, definition)
   }
   return out

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.4.3",
   "license": "MIT",
   "repository": "github:boycce/monastery",
   "homepage": "https://boycce.github.io/monastery/",

package/test/crud.js

@@ -353,10 +353,7 @@ 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 userDefinition = {
@@ -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 () => {
@@ -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 = [
@@ -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/model.js

@@ -449,12 +449,11 @@ test('model indexes basic', async () => {
 
   // Unique & text index
   let userIndexModel = await db.model('userIndex', {
-    waitForIndexes: true,
     fields: {
       email: { type: 'string', index: 'unique' },
       name: { type: 'string', index: 'text' },
     },
-  })
+  }, { waitForIndexes: true })
 
   let userIndexModelIndexes = await db.db.collection('userIndex').indexes()
   expect(userIndexModelIndexes[0]).toEqual({ 
@@ -504,7 +503,6 @@ test('model indexes unique', async () => {
 
   // Partial unique indexes (allows mulitple null values)
   await db.model('userUniqueIndex', {
-    waitForIndexes: true,
     fields: {
       email: {
         type: 'string',
@@ -516,7 +514,7 @@ test('model indexes unique', async () => {
         },
       },
     },
-  })
+  }, { waitForIndexes: true })
 
   let indexes2 = await db.db.collection('userUniqueIndex').indexes()
   expect(indexes2[0]).toEqual({ 
@@ -648,7 +646,6 @@ test('model indexes 2dsphere', async () => {
   // Setup. The tested model needs to be unique as race condition issue arises when the same model
   // with text indexes are setup at the same time
   await db.model('user99', {
-    waitForIndexes: true,
     fields: {
       location: {
         index: '2dsphere',
@@ -661,7 +658,7 @@ test('model indexes 2dsphere', async () => {
         coordinates: [{ type: 'number' }], // lat, lng
       },
     },
-  })
+  }, { waitForIndexes: true })
 
   // Schema check
   expect(db.user99.fields.location).toEqual({

package/test/plugin-images.js

@@ -778,27 +778,26 @@ test('images option getSignedUrls', async () => {
   })
 
   // Find signed URL via query option
-  // await expect(db3.user.findOne({ query: userInserted._id, getSignedUrls: true })).resolves.toEqual({
-  //   _id: expect.any(Object),
-  //   photos: [imageWithSignedUrl, imageWithSignedUrl],
-  //   photos2: [imageWithSignedUrl, imageWithSignedUrl],
-  // })
-
-  // // Find signed URL via schema option
-  // await expect(db3.user.findOne({ query: userInserted._id })).resolves.toEqual({
-  //   _id: expect.any(Object),
-  //   photos: [image, image],
-  //   photos2: [imageWithSignedUrl, imageWithSignedUrl],
-  // })
+  await expect(db3.user.findOne({ query: userInserted._id, getSignedUrls: true })).resolves.toEqual({
+    _id: expect.any(Object),
+    photos: [imageWithSignedUrl, imageWithSignedUrl],
+    photos2: [imageWithSignedUrl, imageWithSignedUrl],
+  })
+
+  // Find signed URL via schema option
+  await expect(db3.user.findOne({ query: userInserted._id })).resolves.toEqual({
+    _id: expect.any(Object),
+    photos: [image, image],
+    photos2: [imageWithSignedUrl, imageWithSignedUrl],
+  })
 
   // Works with _processAfterFind
   let rawUser = await db3.user._findOne({ _id: userInserted._id })
-  db3.user._processAfterFind(rawUser)
-  // await expect(db3.user._processAfterFind(rawUser)).resolves.toEqual({
-  //   _id: expect.any(Object),
-  //   photos: [image, image],
-  //   photos2: [imageWithSignedUrl, imageWithSignedUrl],
-  // })
+  await expect(db3.user._processAfterFind(rawUser)).resolves.toEqual({
+    _id: expect.any(Object),
+    photos: [image, image],
+    photos2: [imageWithSignedUrl, imageWithSignedUrl],
+  })
   db3.close()
 })