monastery 3.5.9 → 3.5.10

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.5.10](https://github.com/boycce/monastery/compare/3.5.9...3.5.10) (2026-02-02)
+
 ### [3.5.9](https://github.com/boycce/monastery/compare/3.5.8...3.5.9) (2025-12-23)
 
 ### [3.5.8](https://github.com/boycce/monastery/compare/3.5.6...3.5.8) (2025-12-23)

package/lib/manager.js

@@ -37,10 +37,10 @@ function Manager(uri, opts, parent) {
   if (typeof opts.logLevel == 'undefined') opts.logLevel = 2
 
   // opts: separate out monastery options
-  const mongoOpts = Object.keys(opts||{}).reduce((acc, key) => {
+  const mongoOpts = Object.keys(opts || {}).reduce((acc, key) => {
     if (![
       'databaseName', 'defaultObjects', 'logLevel', 'imagePlugin', 'limit', 'noDefaults', 'nullObjects',
-      'promise', 'timestamps', 'useMilliseconds',
+      'promise', 'timestamps', 'useMilliseconds', 'forJest',
     ].includes(key)) {
       acc[key] = opts[key]
     }
@@ -57,6 +57,7 @@ function Manager(uri, opts, parent) {
   that.collections = {}
   that._openQueue = []
   that.emitter = new EventEmitter()
+  that.forJest = opts.forJest || false
 
   // 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) {
@@ -283,9 +284,11 @@ Manager.prototype.open = async function() {
    * @return {Promise(manager)}
    */
   try {
+    this.openTimestamp = Date.now()
     this._state = 'opening'
     this.db = this.client.db()
     await this.client.connect() // now optional since db().command() will auto-connect
+    if (!this.forJest) this.info(`Connected to MongoDB in ${Date.now() - this.openTimestamp}ms`)
     this.emitter.emit(this._state = 'open', this)
     return this
 

package/lib/model.js

@@ -346,7 +346,25 @@ Model.prototype._setupIndexes = async function(fields, opts={}) {
   const collection = this.collection
 
   // Get the collections indexes
-  const existingIndexes = await collection.indexes() // returns [] if collection doesn't exist
+  let existingIndexes = []
+  try {
+    existingIndexes = await collection.indexes() // returns [] if collection doesn't exist
+  } catch (err) {
+    // Show a succinct error message for timeout errors, which is due to onOpen() timing out.
+    if (err.message.match(/Server selection timed out after/)) {
+      const msg = `Unable to create an index on the '${model.name||''}' model, the server selection has timed out already.`
+      if (model.manager.forJest) throw new Error(msg)
+      else this.error(msg)
+      return []
+    } else if (err.message.match(/Topology is closed/)) {
+      const msg = `Unable to create an index on the '${model.name||''}' model, the 'Topology is closed'. Bad connection URL?`
+      if (model.manager.forJest) throw new Error(msg)
+      else this.error(msg)
+      return []
+    } else {
+      throw err
+    }
+  }
 
   // Remove any existing text index that has different options as createIndexes will throws error about this
   if (existingIndexes.length) {

package/package.json

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

package/test/manager.js

@@ -59,6 +59,17 @@ test('manager > onOpen error', async () => {
   db.close()
 })
 
+test('manager > onOpen timeout error', async () => {
+  // Bad connection url, which will hang and timeout after 100ms
+  // Related: test/model.js > model index timeout topology closed
+  let manager
+  const db = monastery.manager('google.com', { serverSelectionTimeoutMS:100, logLevel: 3 }) // should hang
+  await expect(db.onOpen((res) => { manager = res })).rejects.toThrow('Server selection timed out after 100 ms')
+  expect(manager).toEqual(undefined)
+  expect(db).toEqual(expect.any(Object))
+  db.close()
+})
+
 test('manager > return a promise', async () => {
   const db = await monastery.manager('localhost/monastery', { serverSelectionTimeoutMS: 500, promise: true })
   expect(db).toEqual(expect.any(Object))
@@ -110,9 +121,9 @@ test('Manager > get collection', async () => {
 })
 
 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 })
+  const db1 = monastery.manager('localhost/monastery', { logLevel: 5, forJest: true })
+  const db2 = monastery.manager('localhost/monastery', { logLevel: 6, forJest: true })
+  const db3 = monastery.manager('localhost/monastery', { logLevel: 7, forJest: true })
 
   expect(monastery.opts.logLevel).not.toEqual(6) // default manager
   expect(db2.opts.logLevel).not.toEqual(db1.opts.logLevel)

package/test/model.js

@@ -495,6 +495,27 @@ test('model indexes basic', async () => {
   }])
 })
 
+test('model index timeout topology closed', async () => {
+  // 1. For a invalid URL, while a connection is still opening, we should expect a 
+  // 'topology is closed' error when trying to create an index.
+  // 2. For valid connection URL, we should expect a 'server selection timed out' error (which we can't reproduce in tests)
+  const db2 = monastery.manager('google.com', { logLevel: 3, serverSelectionTimeoutMS: 50, forJest: true })
+  // Attempt to use the collection while the connection is still opening.
+  const userIndexErrModel = db2.model('userIndexErr', { 
+    fields: {
+      age: { type: 'number' },
+      name: { type: 'string' },
+    },
+  })
+  expect(
+    userIndexErrModel._setupIndexes({ age: { type: 'number', index: 'text' }, name: { type: 'string', index: 'text' } })
+  ).rejects.toThrow('Unable to create an index on the \'userIndexErr\' model, the \'Topology is closed\'. Bad connection URL?')
+  await expect(
+    db2.onOpen((res) => { })
+  ).rejects.toThrow('Server selection timed out after 50 ms')
+  db2.close()
+})
+
 test('model indexes unique', async () => {
   // Setup: Drop previously tested collections
   if ((await db.db.listCollections().toArray()).find(o => o.name == 'userUniqueIndex')) {