monastery 3.4.1 → 3.4.3

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.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)
 
 ## [3.4.0](https://github.com/boycce/monastery/compare/3.3.0...3.4.0) (2024-08-09)

package/docs/definition/index.md

@@ -17,13 +17,14 @@ Model definition object.
 - [Custom field rules](#custom-field-rules)
 - [Custom error messages](#custom-error-messages)
 - [Operation hooks](#operation-hooks)
+- [Methods](#methods)
 - [Full example](#full-example)
 
 ### Fields
 
 1. Fields can either be a field-type, embedded document, or an array of field-types or embedded documents
 2. Field-types are recognised by having a `type` property defined as a string
-3. Field-types can contain [custom](#custom-field-rules) and [default field rules](./rules), e.g. `{ minLength: 2 }`
+3. Field-types can contain [custom](#custom-field-rules) and [default field rules](./field-rules), e.g. `{ minLength: 2 }`
 4. Field-types can contain [field options](#field-options).
 
 ```js
@@ -61,7 +62,7 @@ Model definition object.
 }
 ```
 
-The fields below implicitly get assigned and take presidence over any input data when [`manager.timestamps`](./manager) is true (default). You can override the `timestamps` value per operation, e.g. `db.user.update({ ..., timestamps: false})`. These fields use unix timestamps in seconds (by default), but can be configured to use use milliseconds via the manager [`useMilliseconds` ](./manager) option.
+The fields below implicitly get assigned and take presidence over any input data when [`manager.timestamps`](../manager) is true (default). You can override the `timestamps` value per operation, e.g. `db.user.update({ ..., timestamps: false})`. These fields use unix timestamps in seconds (by default), but can be configured to use use milliseconds via the manager [`useMilliseconds` ](../manager) option.
 
 ```js
 {
@@ -307,19 +308,44 @@ You are able provide an array of callbacks to these model operation hooks. If yo
 
 ```js
 {
-  afterFind: [function(data, next) {}],
-  afterInsert: [function(data, next) {}],
-  afterInsertUpdate: [function(data, next) {}],
-  afterUpdate: [function(data, next) {}],
-  afterRemove: [function(next) {}],
-  beforeInsert: [function(data, next) {}],
-  beforeInsertUpdate: [function(data, next) {}],
-  beforeUpdate: [function(data, next) {}],
-  beforeRemove: [function(next) {}],
-  beforeValidate: [function(data, next) {}],
+  // Model hooks
+  afterFind: [await function(data) {}],
+  afterInsert: [await function(data) {}],
+  afterInsertUpdate: [await function(data) {}],
+  afterUpdate: [await function(data) {}],
+  afterRemove: [await function() {}],
+  beforeInsert: [await function(data) {}],
+  beforeInsertUpdate: [await function(data) {}],
+  beforeUpdate: [await function(data) {}],
+  beforeRemove: [await function() {}],
+  beforeValidate: [await function(data) {}],
+
+  // You can also return an object which will be passed to the next hook in the chain, or if it's the last hook, returned as the result:
+  afterFind: [await function(data) {
+    data.age = 30
+    return data
+  }],
 }
 ```
 
+### Methods
+
+You are able define reusable methods in the definition which is handy for storing related functions.
+
+```js
+// Method definition
+{
+  methods: {
+    getAge: function () {
+      return 30
+    },
+  }
+}
+
+// Above can be called directly from the model via:
+db.user.getAge()
+```
+
 ### Definition example
 
 ```js

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
@@ -282,7 +282,10 @@ Manager.prototype.parseData = function(obj, parseBracketToDotNotation, parseDotN
 }
 
 Manager.prototype.model = Model
-Manager.prototype.getSignedUrl = Manager.prototype._getSignedUrl = imagePluginFile.getSignedUrl
+Manager.prototype.getSignedUrl = imagePluginFile.getSignedUrl
+Manager.prototype._getSignedUrl = () => { 
+  throw new Error('monastery._getSignedUrl() has been moved to monastery.getSignedUrl()')
+}
 
 inherits(Manager, EventEmitter)
 module.exports = Manager

package/lib/model-crud.js

@@ -676,7 +676,7 @@ Model.prototype._processAfterFind = async function (data, projection={}, afterFi
         (async (_item) => {
           const _modelName = _item.modelName
           const _model = models[_modelName]
-          const _opts = { ...afterFindContext, afterFindName: _modelName }
+          const _opts = { ...afterFindContext, model: _model }
           const _dataRef = _item.dataRefParent[_item.dataRefKey]
           _item.dataRefParent[_item.dataRefKey] = (
             await _model._callHooks('afterFind', _dataRef, _opts)

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
 }
 
@@ -405,19 +406,19 @@ Model.prototype._setupIndexes = async function(fields, opts={}) {
   }
 }
 
-Model.prototype._callHooks = async function(hookName, data, opts) {
+Model.prototype._callHooks = async function(hookName, data, hookContext) {
   /**
    * Calls hooks in series
    * 
    * @param {string} hookName - e.g. 'beforeValidate'
-   * @param {object} opts - operation options, e.g. { data, skipValidation, ... }
    * @param {any} arg - data to pass to the first function
+   * @param {object} hookContext - operation options, e.g. { data, skipValidation, ... }
    * 
    * @return {any} - the result of the last function
    * @this model
    */
-  if (opts.skipHooks) return data
-  return await util.runSeries.call(this, this[hookName].map(f => f.bind(opts)), hookName, data)
+  if (hookContext.skipHooks) return data
+  return await util.runSeries.call(this, this[hookName].map(f => f.bind(hookContext)), hookName, data)
 }
 
 Model.prototype._defaultFields = {
@@ -446,4 +447,4 @@ module.exports = Model
 
 // Extend Model prototype
 require('./model-crud.js')
-require('./model-validate.js')
+require('./model-validate.js')

package/lib/util.js

@@ -371,7 +371,7 @@ module.exports = {
      **/
     let current = 0
     let isSync = true
-    let caller = (this.afterFindName || this.name) + '.' + hookName
+    let caller = this.name + '.' + hookName
     let lastDefinedResult = data
 
     return new Promise((res, rej) => {

package/package.json

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

package/plugins/images/index.js

@@ -13,7 +13,6 @@ let plugin = module.exports = {
      *
      * @param {object} monastery manager instance
      * @param {options} options - plugin options
-     * @this plugin
      */
 
     // Depreciation warnings
@@ -23,19 +22,21 @@ let plugin = module.exports = {
     }
 
     // Settings
-    this.awsAcl = options.awsAcl || 'public-read' // default
-    this.awsBucket = options.awsBucket
-    this.awsAccessKeyId = options.awsAccessKeyId
-    this.awsSecretAccessKey = options.awsSecretAccessKey
-    this.awsRegion = options.awsRegion
-    this.bucketDir = options.bucketDir || 'full' // depreciated > 1.36.2
-    this.filesize = options.filesize
-    this.formats = options.formats || ['bmp', 'gif', 'jpg', 'jpeg', 'png', 'tiff']
-    this.getSignedUrlOption = options.getSignedUrl
-    this.manager = manager
-    this.metadata = options.metadata ? util.deepCopy(options.metadata) : undefined,
-    this.params = options.params ? util.deepCopy(options.params) : {},
-    this.path = options.path || function (uid, basename, ext, file) { return `full/${uid}.${ext}` }
+    manager.imagePlugin = {
+      _s3Client: null,
+      awsAcl: options.awsAcl || 'public-read', // default
+      awsBucket: options.awsBucket,
+      awsAccessKeyId: options.awsAccessKeyId,
+      awsSecretAccessKey: options.awsSecretAccessKey,
+      awsRegion: options.awsRegion,
+      bucketDir: options.bucketDir || 'full', // depreciated > 1.36.2
+      filesize: options.filesize,
+      formats: options.formats || ['bmp', 'gif', 'jpg', 'jpeg', 'png', 'tiff'],
+      getSignedUrlOption: options.getSignedUrl,
+      metadata: options.metadata ? util.deepCopy(options.metadata) : undefined,
+      params: options.params ? util.deepCopy(options.params) : {},
+      path: options.path || function (uid, basename, ext, file) { return `full/${uid}.${ext}` },
+    }
 
     if (!options.awsBucket || !options.awsAccessKeyId || !options.awsSecretAccessKey) {
       throw new Error('Monastery imagePlugin: awsRegion, awsBucket, awsAccessKeyId, or awsSecretAccessKey is not defined')
@@ -48,21 +49,21 @@ let plugin = module.exports = {
     // v2: https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html#constructor-property
     // v3: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/
     // v3 examples: https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/javascript_s3_code_examples.html
-    this.getS3Client = (useRegion) => {
+    manager.imagePlugin.getS3Client = (useRegion) => {
       const { S3 } = require('@aws-sdk/client-s3')
       const key  = '_s3Client'// useRegion ? '_s3ClientRegional' : '_s3Client'
-      return this[key] || (this[key] = new S3({
+      return manager.imagePlugin[key] || (manager.imagePlugin[key] = new S3({
         // ...(region: useRegion ? this.awsRegion : undefined,
-        region: this.awsRegion, // if region is missing it throws an error, but only in production...
+        region: manager.imagePlugin.awsRegion, // if region is missing it throws an error, but only in production...
         credentials: {
-          accessKeyId: this.awsAccessKeyId,
-          secretAccessKey: this.awsSecretAccessKey,
+          accessKeyId: manager.imagePlugin.awsAccessKeyId,
+          secretAccessKey: manager.imagePlugin.awsSecretAccessKey,
         },
       }))
     }
 
     // Add before model hook
-    manager.beforeModel.push(this.setupModel.bind(this))
+    manager.beforeModel.push(plugin.setupModel)
   },
 
   setupModel: function(model) {
@@ -70,35 +71,35 @@ let plugin = module.exports = {
      * Cache all model image paths for a model and add monastery operation hooks
      * Todo: need to test the model hook arguement signatures here
      * @param {object} model
-     * @this plugin
+     * @this {object} - null
      */
-    model.imageFields = plugin._findAndTransformImageFields(model.fields, '')
+    model.imageFields = plugin._findAndTransformImageFields.call(model, model.fields, '')
 
     if (model.imageFields.length) {
       // Todo?: Update image fields / blacklists with the new object schema
       //   model._setupFields(model.fields)/model._getFieldsFlattened(model.fields)
       model.beforeValidate.push(function(data, n) {
-        plugin.keepImagePlacement(this, data).then(() => n(null, data)).catch(e => n(e))
+        plugin.keepImagePlacement.call(this, data).then(() => n(null, data)).catch(e => n(e))
       })
       model.beforeUpdate.push(function(data, n) {
-        plugin.removeImages(this, data).then(() => n(null, data)).catch(e => n(e))
+        plugin.removeImages.call(this, data).then(() => n(null, data)).catch(e => n(e))
       })
       model.beforeRemove.push(function(n) {
-        plugin.removeImages(this, {}).then(() => n(null, {})).catch(e => n(e))
+        plugin.removeImages.call(this, {}).then(() => n(null, {})).catch(e => n(e))
       })
       model.afterUpdate.push(function(data, n) {
-        plugin.addImages(this, data).then(() => n(null, data)).catch(e => n(e))
+        plugin.addImages.call(this, data).then(() => n(null, data)).catch(e => n(e))
       })
       model.afterInsert.push(function(data, n) {
-        plugin.addImages(this, data).then(() => n(null, data)).catch(e => n(e))
+        plugin.addImages.call(this, data).then(() => n(null, data)).catch(e => n(e))
       })
       model.afterFind.push(function(data, n) {
-        plugin.getSignedUrls.call(model, this, data).then(() => n(null, data)).catch(e => n(e))
+        plugin.getSignedUrls.call(this, data).then(() => n(null, data)).catch(e => n(e))
       })
     }
   },
 
-  addImages: function(options, data, test) {
+  addImages: function(data, test) {
     /**
      * Hooked after create/update
      * Uploads viable images and saves their details on the model. AWS Lambda takes
@@ -115,19 +116,20 @@ let plugin = module.exports = {
      * 2mb: 1864ms, 1164ms
      * 0.1mb: 480ms
      *
-     * @param {object} options - monastery operation options {model, query, files, ..}
      * @param {object} data -
      * @param {boolean} test -
+     * 
      * @return promise(
      *   {object} data - data object containing new S3 image-object
      * ])
-     * @this plugin
+     * @this {object} - monastery operation options {model, query, files, create, multi }
      */
-    let { model, query, files } = options
+    const { model, query, files, create, multi } = this
+    const imagePlugin = model.manager.imagePlugin
     if (!files) return Promise.resolve([])
 
     // Build an ID query from query/data. Inserts add _id to the data automatically.
-    let idquery = query && query._id? query : { _id: data._id }
+    const idquery = query && query._id? query : { _id: data._id }
 
     // We currently don't support an array of data objects.
     if (util.isArray(data)) {
@@ -144,32 +146,32 @@ let plugin = module.exports = {
     }
 
     // Find valid images and upload to S3, and update data with image objects
-    return plugin._findValidImages(files, model).then(files => {
+    return plugin._findValidImages.call(model, files).then(files => {
       return Promise.all(files.map(filesArr => {
         return Promise.all(filesArr.map(file => {
           return new Promise((resolve, reject) => {
             let uid = require('nanoid').nanoid()
-            let path = filesArr.imageField.path || plugin.path
+            let path = filesArr.imageField.path || imagePlugin.path
             let image = {
-              bucket: filesArr.imageField.awsBucket || plugin.awsBucket,
-              date: plugin.manager.opts.useMilliseconds? Date.now() : Math.floor(Date.now() / 1000),
+              bucket: filesArr.imageField.awsBucket || imagePlugin.awsBucket,
+              date: model.manager.opts.useMilliseconds? Date.now() : Math.floor(Date.now() / 1000),
               filename: file.name,
               filesize: file.size,
-              metadata: filesArr.imageField.metadata || plugin.metadata,
+              metadata: filesArr.imageField.metadata || imagePlugin.metadata,
               path: path(uid, file.name, file.ext, file),
               uid: uid,
             }
             let s3Options = {
               // ACL: Some IAM permissions "s3:PutObjectACL" must be included in the policy
               // params: https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html#upload-property
-              ACL: filesArr.imageField.awsAcl || plugin.awsAcl,
+              ACL: filesArr.imageField.awsAcl || imagePlugin.awsAcl,
               Body: file.data,
               Bucket: image.bucket,
               Key: image.path,
               Metadata: image.metadata,
-              ...(filesArr.imageField.params || plugin.params),
+              ...(filesArr.imageField.params || imagePlugin.params),
             }
-            plugin.manager.info(
+            model.manager.info(
               `Uploading '${image.filename}' to '${image.bucket}/${image.path}'`
             )
             if (test) {
@@ -178,7 +180,7 @@ let plugin = module.exports = {
             } else {
               const { Upload } = require('@aws-sdk/lib-storage')
               const upload = new Upload({
-                client: plugin.getS3Client(),
+                client: imagePlugin.getS3Client(),
                 params: s3Options,
               })
               // upload.on('httpUploadProgress', (progress) => {
@@ -206,44 +208,74 @@ let plugin = module.exports = {
       return model._update(
         idquery,
         { '$set': prunedData },
-        { 'multi': options.multi || options.create }
+        { 'multi': multi || create }
       )
 
     // If errors, remove inserted documents to prevent double ups when the user resaves.
     // We are pretty much trying to emulate a db transaction.
     }).catch(err => {
-      if (options.create) model._remove(idquery)
+      if (create) model._remove(idquery)
       throw err
     })
   },
 
-  getSignedUrls: async function(options, data) {
+  getSignedUrl: async function(path, expires=3600, bucket) {
+    /**
+     * @param {string} path - aws file path
+     * @param {number} <expires> - seconds
+     * @param {string} <bucket>
+     * 
+     * @return {promise} signedUrl
+     * @see v2: https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html#getSignedUrl-property
+     * @see v3: https://github.com/aws/aws-sdk-js-v3/blob/main/UPGRADING.md#s3-presigned-url
+     * 
+     * @this manager
+     */
+    const { imagePlugin } = this
+    if (!imagePlugin) {
+      throw new Error(
+        'You must call getSignedUrl() with a manager as the context. The manager also needs to have the imagePlugin setup too, ' +
+        'e.g. `monastery(..., { imagePlugin })`'
+      )
+    }
+    const { GetObjectCommand } = require('@aws-sdk/client-s3')
+    const params = { Bucket: bucket || imagePlugin.awsBucket, Key: path }
+    const command = new GetObjectCommand(params)
+    let signedUrl = await getSignedUrl(imagePlugin.getS3Client(true), command, { expiresIn: expires })
+    // console.log(signedUrl)
+    return signedUrl
+  },
+
+  getSignedUrls: async function(data) {
     /**
      * Get signed urls for all image objects in data
-     * @param {object} options - monastery operation options {model, query, files, ..}
+     * 
      * @param {object} data
+     * 
      * @return promise() - mutates data
-     * @this model
+     * @this {object} - monastery operation options {model, query, files, ..}
      */
     // Not wanting signed urls for this operation?
-    if (util.isDefined(options.getSignedUrls) && !options.getSignedUrls) return
+    const { getSignedUrls, model } = this
+    const imagePlugin = model.manager.imagePlugin
+    if (util.isDefined(getSignedUrls) && !getSignedUrls) return
 
     // Find all image objects in data
     for (let doc of util.toArray(data)) {
-      for (let imageField of this.imageFields) {
-        if (options.getSignedUrls
-            || (util.isDefined(imageField.getSignedUrl) ? imageField.getSignedUrl : plugin.getSignedUrlOption)) {
+      for (let imageField of model.imageFields) {
+        if (getSignedUrls
+            || (util.isDefined(imageField.getSignedUrl) ? imageField.getSignedUrl : imagePlugin.getSignedUrlOption)) {
           let images = plugin._findImagesInData(doc, imageField, 0, '').filter(o => o.image)
           // todo: we could do this in parallel
           for (let image of images) {
-            image.image.signedUrl = await plugin.getSignedUrl(image.image.path, 3600, imageField.awsBucket)
+            image.image.signedUrl = await plugin.getSignedUrl.call(model.manager, image.image.path, 3600, imageField.awsBucket)
           }
         }
       }
     }
   },
 
-  keepImagePlacement: async function(options, data) {
+  keepImagePlacement: async function(data) {
     /**
      * Hook before update/remove
      * Since monastery removes undefined array items on validate, we need to convert any
@@ -254,22 +286,22 @@ let plugin = module.exports = {
      * req.body  = 'photos[0]' : undefined || non existing (set to null)
      * req.files = 'photos[0]' : { ...binary }
      *
-     * @param {object} options - monastery operation options {query, model, files, multi, ..}
      * @return promise
-     * @this plugin
+     * @this {object} - monastery operation options {query, model, files, multi, ..}
      */
-    if (typeof options.files == 'undefined') return
+    const { model, files } = this
+    if (typeof files == 'undefined') return
     // Check upload errors and find valid uploaded images
-    let files = await plugin._findValidImages(options.files || {}, options.model)
+    let validFiles = await plugin._findValidImages.call(model, files || {})
     // Set undefined primative-array items to null where files are located
-    for (let filesArray of files) {
-      if (filesArray.inputPath.match(/\.[0-9]+$/)) {
-        util.setDeepValue(data, filesArray.inputPath, null, true, false, true)
+    for (let item of validFiles) {
+      if (item.inputPath.match(/\.[0-9]+$/)) {
+        util.setDeepValue(data, item.inputPath, null, true, false, true)
       }
     }
   },
 
-  removeImages: async function(options, data, test) {
+  removeImages: async function(data, test) {
     /**
      * Hook before update/remove
      * Removes images not found in data, this means you will need to pass the image objects to every update operation
@@ -280,24 +312,25 @@ let plugin = module.exports = {
      * 3. delete leftovers from S3
      *
      * @ref https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html#deleteObjects-property
-     * @param {object} options - monastery operation options {query, model, files, multi, ..}
      * @return promise([
      *   {object} useCount - images that wont be removed, e.g. { lion1: 1 }
      *   {array} unused - S3 image uris to be removed,  e.g. [{ Key: 'small/lion1.jpg' }, ..]
      * ])
-     * @this plugin
+     * @this {object} - monastery operation options {query, model, files, multi, ..}
      */
     let pre
-    let preExistingImages = []
-    let useCount = {}
-    if (typeof options.files == 'undefined') return
+    const preExistingImages = []
+    const useCount = {}
+    const { model, files, query } = this
+    const imagePlugin = model.manager.imagePlugin
+    if (typeof files == 'undefined') return
 
     // Find all documents from the same query
-    let docs = await options.model._find(options.query, options)
+    const docs = await model._find(query, this)
 
     // Find all pre-existing image objects in documents
     for (let doc of util.toArray(docs)) { //x2
-      for (let imageField of options.model.imageFields) { //x5
+      for (let imageField of model.imageFields) { //x5
         let images = plugin._findImagesInData(doc, imageField, 0, '').filter(o => o.image)
         for (let image of images) {
           preExistingImages.push(image)
@@ -320,10 +353,10 @@ let plugin = module.exports = {
     // console.log(dataFilled)
 
     // Check upload errors and find valid uploaded images
-    let files = await plugin._findValidImages(options.files || {}, options.model)
+    let validFiles = await plugin._findValidImages.call(model, files || {})
 
     // Loop all schema image fields
-    for (let imageField of options.model.imageFields) { //x5
+    for (let imageField of model.imageFields) { //x5
       let images = plugin._findImagesInData(dataFilled, imageField, 0, '')
       if (!images.length) continue
       // console.log(images)
@@ -353,8 +386,8 @@ let plugin = module.exports = {
             useCount[image.image.uid]++
           }
           // Any file overriding this image?
-          for (let filesArray of files) {
-            if (image.dataPath == filesArray.inputPath) {
+          for (let item of validFiles) {
+            if (image.dataPath == item.inputPath) {
               useCount[image.image.uid]--
             }
           }
@@ -376,17 +409,17 @@ let plugin = module.exports = {
         { Key: `medium/${key}.jpg` },
         { Key: `large/${key}.jpg` }
       )
-      plugin.manager.info(
+      model.manager.info(
         `Removing '${pre.image.filename}' from '${pre.image.bucket}/${pre.image.path}'`
       )
     }
     if (test) return [useCount, unused]
     // Delete any unused images from s3. If the image is on a different bucket
-    // the file doesnt get deleted, we only delete from plugin.awsBucket.
+    // the file doesnt get deleted, we only delete from imagePlugin.awsBucket.
     if (!unused.length) return
     await new Promise((resolve, reject) => {
-      plugin.getS3Client().deleteObjects({
-        Bucket: plugin.awsBucket,
+      imagePlugin.getS3Client().deleteObjects({
+        Bucket: imagePlugin.awsBucket,
         Delete: { Objects: unused },
       }, (err, data) => {
         if (err) reject(err)
@@ -402,6 +435,7 @@ let plugin = module.exports = {
      * @param {object} data
      * @param {object} image
      * @return mutates data
+     * @this null
      */
     let chunks = path.split('.')
     let target = data
@@ -421,22 +455,24 @@ let plugin = module.exports = {
     return data
   },
 
-  _findValidImages: function(files, model) {
+  _findValidImages: function(files) {
     /**
      * Find and return valid uploaded files
      * @param {object} files - req.files
-     * @param {object} model
      * @return promise([
      *   [{..file}, .imageField, .inputPath],
      *   ..
      * ])
+     * @this model
      */
     let validFiles = []
+    const { imageFields, manager } = this
+    const imagePlugin = manager.imagePlugin
 
     // Filter valid image files by `type='image'`, convert file keys to dot notation, and force array
     for (let key in files) {
       let key2 = key.replace(/\]/g, '').replace(/\[/g, '.')
-      let imageField = model.imageFields.find(o => key2.match(o.fullPathRegex))
+      let imageField = imageFields.find(o => key2.match(o.fullPathRegex))
       if (imageField) {
         let filesArr = util.toArray(files[key])
         filesArr.imageField = imageField
@@ -452,8 +488,8 @@ let plugin = module.exports = {
       return Promise.all(filesArr.map((file, i) => {
         return new Promise((resolve, reject) => {
           require('file-type').fromBuffer(file.data).then(res => {
-            let filesize = filesArr.imageField.filesize || plugin.filesize
-            let formats = filesArr.imageField.formats || plugin.formats
+            let filesize = filesArr.imageField.filesize || imagePlugin.filesize
+            let formats = filesArr.imageField.formats || imagePlugin.formats
             let allowAny = util.inArray(formats, 'any')
             file.format = res? res.ext : ''
             file.ext = file.format || (file.name.match(/\.(.*)$/) || [])[1] || 'unknown'
@@ -488,10 +524,11 @@ let plugin = module.exports = {
      * @param {object|array} unprocessedFields - fields not yet setup
      * @param {string} path
      * @return [{}, ...]
-     * @this plugin
+     * @this model
      */
     let list = []
-    let that = this
+    const { manager } = this
+    const imagePlugin = manager.imagePlugin
     util.forEach(unprocessedFields, (field, fieldName) => {
       let path2 = `${path}.${fieldName}`.replace(/^\./, '')
       if (fieldName == 'schema') return
@@ -499,12 +536,12 @@ let plugin = module.exports = {
       // Subdocument field
       if (util.isSubdocument(field)) {
         // log(`Recurse 1: ${path2}`)
-        list = list.concat(plugin._findAndTransformImageFields(field, path2))
+        list = list.concat(plugin._findAndTransformImageFields.call(this, field, path2))
 
       // Array field
       } else if (util.isArray(field)) {
         // log(`Recurse 2: ${path2}`)
-        list = list.concat(plugin._findAndTransformImageFields(field, path2))
+        list = list.concat(plugin._findAndTransformImageFields.call(this, field, path2))
 
       // Image field. Test for field.image as field.type may be 'any'
       } else if (field.type == 'image' || field.image) {
@@ -514,8 +551,9 @@ let plugin = module.exports = {
         }
         if (field.filename) { // > v1.36.3
           this.manager.warn(`${path2}.filename has been depreciated in favour of ${path2}.path()`)
-          field.path = field.path
-            || function(uid, basename, ext, file) { return `${that.bucketDir}/${uid}/${field.filename}.${ext}` }
+          field.path = field.path || function(uid, basename, ext, file) { 
+            return `${imagePlugin.bucketDir}/${uid}/${field.filename}.${ext}` 
+          }
         }
 
         list.push({
@@ -540,7 +578,7 @@ let plugin = module.exports = {
           metadata: { type: 'any' },
           path: { type: 'string' },
           uid: { type: 'string' },
-          schema: { image: true, isImageObject: true, nullObject: true },
+          schema: { image: true, isImageObject: true, nullObject: true, default: undefined },
         }
       }
     })
@@ -555,6 +593,7 @@ let plugin = module.exports = {
      * @param {number} imageFieldChunkIndex - imageField path chunk index
      * @param {string} dataPath
      * @return [{ imageField: {}, dataPath: '', image: {} }, ..]
+     * @this null
      */
     let list = []
     let chunks = imageField.fullPath.split('.').slice(imageFieldChunkIndex)
@@ -590,27 +629,4 @@ let plugin = module.exports = {
 
     return list
   },
-
-  getSignedUrl: async (path, expires=3600, bucket) => {
-    /**
-     * @param {string} path - aws file path
-     * @param {number} <expires> - seconds
-     * @param {string} <bucket>
-     * @return {promise} signedUrl
-     * @see v2: https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html#getSignedUrl-property
-     * @see v3: https://github.com/aws/aws-sdk-js-v3/blob/main/UPGRADING.md#s3-presigned-url
-     */
-    if (!plugin.getS3Client) {
-      throw new Error(
-        'To use db.getSignedUrl(), the imagePlugin manager option must be defined, e.g. `monastery(..., { imagePlugin })`'
-      )
-    }
-    const { GetObjectCommand } = require('@aws-sdk/client-s3')
-    const params = { Bucket: bucket || plugin.awsBucket, Key: path }
-    const command = new GetObjectCommand(params)
-    let signedUrl = await getSignedUrl(plugin.getS3Client(true), command, { expiresIn: expires })
-    // console.log(signedUrl)
-    return signedUrl
-  },
-
 }

package/test/crud.js

@@ -52,19 +52,32 @@ test('insert basics', async () => {
 })
 
 test('insert option defaultObjects', async () => {
-  let db2 = monastery('127.0.0.1/monastery', { defaultObjects: true, timestamps: false })
+  let db2 = monastery('127.0.0.1/monastery', { 
+    defaultObjects: true, 
+    timestamps: false, 
+    imagePlugin: {
+      awsBucket: 'test',
+      awsRegion: 'test',
+      awsAccessKeyId: 'test',
+      awsSecretAccessKey: 'test',
+    },
+  })
   let schema = { 
     fields: {
+      avatar: { type: 'image' }, // its an object but should default to `undefined`
       name: { type: 'string' },
       names: [{ type: 'string' }],
+      animal: {
+        name: { type: 'string' },
+      },
       animals: {
         dog: { type: 'string' },
         dogs: [{ name: { type: 'string' } }],
       },
     },
   }
-  let user1 = db.model('user', schema)
-  let user2 = db2.model('user', schema)
+  let user1 = db.model('user-defaultObjects', schema)
+  let user2 = db2.model('user-defaultObjects', schema)
 
   // defaultObjects off (default)
   let inserted1 = await user1.insert({ data: {} })
@@ -76,6 +89,7 @@ test('insert option defaultObjects', async () => {
   let inserted2 = await user2.insert({ data: {} })
   expect(inserted2).toEqual({
     _id: inserted2._id,
+    animal: {},
     names: [],
     animals: { dogs: [] },
   })
@@ -339,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 = {
@@ -494,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 () => {
@@ -1060,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 = [
@@ -1500,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

@@ -158,11 +158,15 @@ test('images addImages helper functions', async () => {
 })
 
 test('images addImages', async () => {
-  let user = db.model('user', { fields: {
-    logo: { type: 'image' },
-    logos: [{ type: 'image' }],
-    users: [{ logo: { type: 'image' } }],
-  }})
+  let user = db.model('user', { 
+    fields: {
+      logo: { type: 'image' },
+      logos: [{ type: 'image' }],
+      users: [{ logo: { type: 'image' } }],
+    },
+  })
+  // console.log(db.opts, user.fields.logo)
+  // throw 'qwef'
 
   let supertest = require('supertest')
   let express = require('express')
@@ -174,7 +178,7 @@ test('images addImages', async () => {
     try {
       // Files exist
       expect(req.files.logo).toEqual(expect.any(Object))
-      let validFiles = await imagePluginFile._findValidImages(req.files, user)
+      let validFiles = await imagePluginFile._findValidImages.call(user, req.files)
       // Valid file count
       expect(validFiles).toEqual([
         expect.any(Array),
@@ -198,7 +202,7 @@ test('images addImages', async () => {
       expect(validFiles[2][0].format).toEqual('png')
       expect(validFiles[3][0].format).toEqual('png')
 
-      let response = await imagePluginFile.addImages(
+      let response = await imagePluginFile.addImages.call(
         { model: user, files: req.files, query: { _id: 1234 }},
         req.body,
         true
@@ -240,7 +244,8 @@ test('images addImages', async () => {
       })
       res.send()
     } catch (e) {
-      console.log(e.message || e)
+      console.log(e)
+      // console.log(e.message || e)
       res.status(500).send()
     }
   })
@@ -297,7 +302,7 @@ test('images removeImages', async () => {
       req.body.logos = JSON.parse(req.body.logos)
       req.body.users = JSON.parse(req.body.users)
       let options = { files: req.files, model: user, query: { _id: user1._id }}
-      let response = await imagePluginFile.removeImages(options, req.body, true)
+      let response = await imagePluginFile.removeImages.call(options, req.body, true)
       expect(response[0]).toEqual({ test1: 1, test2: 0, test3: 1, test4: 0 })
       expect(response[1]).toEqual([
         { Key: 'dir/test2.png' },
@@ -358,7 +363,7 @@ test('images removeImages with no data', async () => {
   app.post('/', async function(req, res) {
     try {
       let options = { files: req.files, model: user, query: { _id: user1._id }}
-      let response = await imagePluginFile.removeImages(options, req.body, true)
+      let response = await imagePluginFile.removeImages.call(options, req.body, true)
       expect(response[0]).toEqual({})
       expect(response[1]).toEqual([])
       res.send()
@@ -474,7 +479,7 @@ test('images reorder', async () => {
     try {
       req.body.logos = JSON.parse(req.body.logos)
       let options = { files: req.files, model: user, query: { _id: user1._id } }
-      let response = await imagePluginFile.removeImages(options, req.body, true)
+      let response = await imagePluginFile.removeImages.call(options, req.body, true)
       expect(response[0]).toEqual({ lion1: 1 })
       expect(response[1]).toEqual([])
       res.send()
@@ -526,16 +531,16 @@ test('images reorder and added image', async () => {
       expect(data.photos[1]).toEqual(image)
 
       // Remove images
-      let response = await imagePluginFile.removeImages(options, data, true)
+      let response = await imagePluginFile.removeImages.call(options, data, true)
       expect(response[0]).toEqual({ lion1: 1 }) // useCount
       expect(response[1]).toEqual([]) // unused
 
       // New file exists
-      let validFiles = await imagePluginFile._findValidImages(req.files, user)
+      let validFiles = await imagePluginFile._findValidImages.call(user, req.files)
       expect(((validFiles||[])[0]||{}).inputPath).toEqual('photos.0') // Valid inputPath
 
       // Add images
-      response = await imagePluginFile.addImages(options, data, true)
+      response = await imagePluginFile.addImages.call(options, data, true)
       expect(response[0]).toEqual({
         photos: [{
           bucket: 'fake',
@@ -592,13 +597,13 @@ test('images option defaults', async () => {
   app.use(upload({ limits: { fileSize: 1000 * 480, files: 10 }}))
 
   // Basic tests
-  expect(imagePluginFile.awsAcl).toEqual('public-read')
-  expect(imagePluginFile.filesize).toEqual(undefined)
-  expect(imagePluginFile.formats).toEqual(['bmp', 'gif', 'jpg', 'jpeg', 'png', 'tiff'])
-  expect(imagePluginFile.getSignedUrlOption).toEqual(undefined)
-  expect(imagePluginFile.metadata).toEqual(undefined)
-  expect(imagePluginFile.path).toEqual(expect.any(Function))
-  expect(imagePluginFile.params).toEqual({})
+  expect(db.imagePlugin.awsAcl).toEqual('public-read')
+  expect(db.imagePlugin.filesize).toEqual(undefined)
+  expect(db.imagePlugin.formats).toEqual(['bmp', 'gif', 'jpg', 'jpeg', 'png', 'tiff'])
+  expect(db.imagePlugin.getSignedUrlOption).toEqual(undefined)
+  expect(db.imagePlugin.metadata).toEqual(undefined)
+  expect(db.imagePlugin.path).toEqual(expect.any(Function))
+  expect(db.imagePlugin.params).toEqual({})
 
   // Images not signed
   let image
@@ -621,7 +626,7 @@ test('images option defaults', async () => {
     try {
       // Files exist
       expect(req.files.logo).toEqual(expect.any(Object))
-      let response = await imagePluginFile.addImages(
+      let response = await imagePluginFile.addImages.call(
         { model: user, files: req.files, query: { _id: 1234 }},
         req.body || {},
         true
@@ -698,20 +703,20 @@ test('images options formats & filesizes', async () => {
       delete req.files.imageSize2
       delete req.files.imageSize3
       // Ico, Webp, and imageSvgGood will throw an error first if it's not a valid type
-      await expect(imagePluginFile._findValidImages(req.files, user)).resolves.toEqual(expect.any(Array))
-      await expect(imagePluginFile._findValidImages(imageSvgBad, user)).rejects.toEqual({
+      await expect(imagePluginFile._findValidImages.call(user, req.files)).resolves.toEqual(expect.any(Array))
+      await expect(imagePluginFile._findValidImages.call(user, imageSvgBad)).rejects.toEqual({
         title: 'imageSvgBad',
         detail: 'The file format \'svg\' for \'bad.svg\' is not supported',
       })
-      await expect(imagePluginFile._findValidImages(imageSize1, user)).rejects.toEqual({
+      await expect(imagePluginFile._findValidImages.call(user, imageSize1)).rejects.toEqual({
         title: 'imageSize1',
         detail: 'The file size for \'lion1.png\' is bigger than 0.1MB.',
       })
-      await expect(imagePluginFile._findValidImages(imageSize2, user)).rejects.toEqual({
+      await expect(imagePluginFile._findValidImages.call(user, imageSize2)).rejects.toEqual({
         title: 'imageSize2',
         detail: 'The file size for \'lion2.jpg\' is bigger than 0.3MB.',
       })
-      await expect(imagePluginFile._findValidImages(imageSize3, user)).rejects.toEqual({
+      await expect(imagePluginFile._findValidImages.call(user, imageSize3)).rejects.toEqual({
         title: 'imageSize3',
         detail: 'The file size for \'house.jpg\' is too big.',
       })
@@ -833,7 +838,7 @@ test('images options awsAcl, awsBucket, metadata, params, path', async () => {
       // Files exist
       expect(req.files.optionDefaults).toEqual(expect.any(Object))
       expect(req.files.optionOverrides).toEqual(expect.any(Object))
-      let response = await imagePluginFile.addImages(
+      let response = await imagePluginFile.addImages.call(
         { model: user, files: req.files, query: { _id: 1234 }},
         req.body || {},
         true
@@ -922,7 +927,7 @@ test('images option depreciations', async () => {
     try {
       // Files exist
       expect(req.files.logo).toEqual(expect.any(Object))
-      let response = await imagePluginFile.addImages(
+      let response = await imagePluginFile.addImages.call(
         { model: user, files: req.files, query: { _id: 1234 }},
         req.body || {},
         true