monastery 1.31.4 → 1.32.0

package/changelog.md

@@ -2,6 +2,36 @@
 
 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.
 
+## [1.32.0](https://github.com/boycce/monastery/compare/1.31.7...1.32.0) (2022-02-28)
+
+
+### Features
+
+* added getSignedUrl(s) ([3552a4d](https://github.com/boycce/monastery/commit/3552a4d0b21c192a256a590e3ac1cb48b31c6564))
+* added image optiosn filename, and params ([353b2f0](https://github.com/boycce/monastery/commit/353b2f09ed429a5cd8d74a3b2e94493650fb52e4))
+
+### [1.31.7](https://github.com/boycce/monastery/compare/1.31.6...1.31.7) (2022-02-28)
+
+
+### Bug Fixes
+
+* refactored crud ops ([e7f3f78](https://github.com/boycce/monastery/commit/e7f3f784e123e4a66586a4d9e733d5cac477b98b))
+
+### [1.31.6](https://github.com/boycce/monastery/compare/1.31.5...1.31.6) (2022-02-25)
+
+
+### Bug Fixes
+
+* added partial unqiue index tests ([ff6f193](https://github.com/boycce/monastery/commit/ff6f1938e333407ee17895873d2b42fa5263d7e3))
+* scripts ([bc32680](https://github.com/boycce/monastery/commit/bc326809098ae24686158a0386fbbd6671d86c98))
+
+### [1.31.5](https://github.com/boycce/monastery/compare/1.31.4...1.31.5) (2022-02-15)
+
+
+### Bug Fixes
+
+* scripts ([417ba13](https://github.com/boycce/monastery/commit/417ba13c1a0862f76fadf97d6d6d063a74e196bd))
+
 ### 1.31.4 (2022-02-15)
 
 

package/docs/Gemfile

@@ -1,10 +1,4 @@
-# Old
-# source 'https://rubygems.org'
-# gem 'github-pages', group: :jekyll_plugins
-
-# Below pulls the latest remote_theme in development
 source 'https://rubygems.org'
-gem "github-docs", git: "https://github.com/boycce/github-docs"
-group :jekyll_plugins do
-  gem "jekyll-remote-theme", "~> 0.4.2"
-end
+
+# Development (strict gem versions used)
+gem 'github-pages', group: :jekyll_plugins

package/docs/_config.yml

@@ -2,6 +2,7 @@ remote_theme: boycce/github-docs
 title: Monastery
 description: A straight forward MongoDB ODM built upon MonkJS
 github_url: "https://github.com/boycce/monastery"
+port: 4001
 basedir: "docs"
 
 # Aux links for the naviation.

package/docs/image-plugin.md

@@ -26,9 +26,12 @@ Then in your model schema, e.g.
 ```js
 let user = db.model('user', { fields: {
   logo:  {
-    type: 'image',
-    formats: ['bmp', 'gif', 'jpg', 'jpeg', 'png', 'tiff'], // optional plugin rule
-    fileSize: 1000 * 1000 * 5 // optional plugin rule, size in bytes
+    type: 'image', // required
+    formats: ['bmp', 'gif', 'jpg', 'jpeg', 'png', 'tiff'],
+    filename: 'avatar',
+    filesize: 1000 * 1000 * 5, // max size in bytes
+    getSignedUrl: true, // get a s3 signed url by default after `find()`
+    params: {}, // upload params, https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html#upload-property
   },
   logos: [{
     type: 'image'
@@ -61,4 +64,3 @@ user.update({
 Due to known limitations, we are inaccurately able to validate non-binary file types (e.g. txt, svg) before uploading to S3, and rely on their file processing to remove any malicious files.
 
 ...to be continued
-

package/docs/model/find.md

@@ -15,6 +15,7 @@ Find document(s) in a collection and call related hook: `schema.afterFind`
 - [[`options.populate`](#populate)] *(array)*
 - [`options.sort`] *(string\|array\|object)*: same as the mongodb option, but allows string parsing e.g. 'name', 'name:1'
 - [`options.blacklist`] *(array\|string\|false)*: augment `schema.findBL`. `false` will remove all blacklisting
+- [`options.getSignedUrls`] *(boolean)*: get signed urls for all image objects
 - [`options.project`] *(string\|array\|object)*: return only these fields, ignores blacklisting
 - [[`any mongodb option`](http://mongodb.github.io/node-mongodb-native/3.2/api/Collection.html#find)] *(any)*
 

package/docs/{schema.md → schema/index.md}

@@ -1,6 +1,7 @@
 ---
 title: Schema
 nav_order: 4
+has_children: true
 ---
 
 # Schema
@@ -166,6 +167,24 @@ await db.user.insert({
 }
 ```
 
+Since unique indexes by default don't allow mutliple documents with `null`, you use a partial index (less performant), e.g.
+
+```js
+
+schema.fields = {
+index: {
+  name: {
+    type: 'string',
+    index: {
+      type: 'unique',
+      partialFilterExpression: {
+        email: { $type: 'string' }
+      }
+    }
+  }
+}
+```
+
 ### Custom validation rules
 
 You are able to define custom validation rules to use. (`this` will refer to the data object passed in)

package/docs/{rules.md → schema/rules.md}

@@ -1,6 +1,7 @@
 ---
 title: Rules
 nav_order: 5
+parent: Schema
 ---
 
 # Validation Rules

package/lib/model-crud.js

@@ -2,15 +2,15 @@ let util = require('./util')
 
 module.exports = {
 
-  insert: function(opts, cb) {
+  insert: async function(opts, cb) {
     /**
      * Inserts document(s) with monk after validating data & before hooks.
      * @param {object} opts
      *     @param {object|array} <opts.data> - documents to insert
      *     @param {array|string|false} <opts.blacklist> - augment schema.insertBL, `false` will remove all blacklisting
      *     @param {boolean} <opts.respond> - automatically call res.json/error (requires opts.req)
-     *     @param {array|string|false} validateUndefined - ignore all required fields during insert, or
-     *         undefined subdocument required fields that have a defined parent/grandparent during update
+     *     @param {array|string|false} validateUndefined - validates all 'required' undefined fields, true by
+     *         default, but false on update
      *     @param {array|string|true} <opts.skipValidation> - skip validation for this field name(s)
      *     @param {boolean} <opts.timestamps> - whether `createdAt` and `updatedAt` are automatically inserted
      *     @param {any} <opts.any> - any mongodb option
@@ -18,44 +18,36 @@ module.exports = {
      * @this model
      * @return promise
      */
-    opts = opts || {}
-    opts.insert = true
-    opts.model = this
-    let req = opts.req
-    let data = opts.data = util.isDefined(opts.data)? opts.data : util.isDefined((req||{}).body) ? req.body : {}
-    let options = util.omit(opts, [
-      'data', 'insert', 'model', 'respond', 'validateUndefined', 'skipValidation', 'blacklist'
-    ])
     if (cb && !util.isFunction(cb)) {
       throw new Error(`The callback passed to ${this.name}.insert() is not a function`)
     }
-    return util.parseData(data).then(data => {
-      opts.data = data
-      return this.validate(data, { ...opts })
-
-    }).then(data => {
-      return util.runSeries(this.beforeInsert.map(f => f.bind(opts, data))).then(() => data)
-
-    }).then(data => {
-      return this._insert(data, options)
-
-    }).then(data => {
-      return util.runSeries(this.afterInsert.map(f => f.bind(opts, data))).then(() => data)
-
-    // Success/error
-    }).then(data => {
-      if (cb) cb(null, data)
-      else if (opts.req && opts.respond) opts.req.res.json(data)
-      else return Promise.resolve(data)
-
-    }).catch(err => {
+    try {
+      opts = await this._queryObject(opts, 'insert')
+      let options = util.omit(opts, [
+        'data', 'insert', 'model', 'respond', 'validateUndefined', 'skipValidation', 'blacklist'
+      ])
+
+      // Validate
+      opts.data = await this.validate(opts.data||{}, { ...opts })
+
+      // Insert
+      await util.runSeries(this.beforeInsert.map(f => f.bind(opts, opts.data)))
+      let response = await this._insert(opts.data, options)
+      await util.runSeries(this.afterInsert.map(f => f.bind(opts, response)))
+
+      // Success/error
+      if (cb) cb(null, response)
+      else if (opts.req && opts.respond) opts.req.res.json(response)
+      else return Promise.resolve(response)
+
+    } catch (err) {
       if (cb) cb(err)
       else if (opts && opts.req && opts.respond) opts.req.res.error(err)
       else throw err
-    })
+    }
   },
 
-  find: function(opts, cb, one) {
+  find: async function(opts, cb, one) {
     /**
      * Finds document(s) with monk, also auto populates
      * @param {object} opts
@@ -69,19 +61,15 @@ module.exports = {
      * @this model
      * @return promise
      */
-    let options, lookups = []
     if (cb && !util.isFunction(cb)) {
       throw new Error(`The callback passed to ${this.name}.find() is not a function`)
     }
-    return new Promise((resolve, reject) => {
-      opts = this._queryObject(opts)
-      opts.one = one || opts.one
-      // Operation options
-      options = util.omit(opts, ['blacklist', 'one', 'populate', 'project', 'query', 'respond'])
-      options.sort = options.sort || { 'createdAt': -1 }
-      options.skip = Math.max(0, options.skip || 0)
-      options.limit = opts.one? 1 : parseInt(options.limit || this.manager.limit || 0)
+    try {
+      opts = await this._queryObject(opts, 'find', one)
+      let lookups = []
+      let options = util.omit(opts, ['blacklist', 'one', 'populate', 'project', 'query', 'respond'])
       options.addFields = options.addFields || {}
+
       // Project, or use blacklisting
       if (opts.project) {
         // Can be an inclusion or exclusion projection
@@ -105,14 +93,10 @@ module.exports = {
       //   options.projection.score = { $meta: 'textScore' }
       //   options.sort = { score: { $meta: 'textScore' }}
       // }
-      // Sort string passed
-      if (util.isString(options.sort)) {
-        let name = (options.sort.match(/([a-z0-9-_]+)/) || [])[0]
-        let order = (options.sort.match(/:(-?[0-9])/) || [])[1]
-        options.sort = { [name]: parseInt(order || 1) }
-      }
       // Wanting to populate?
-      if (opts.populate) {
+      if (!opts.populate) {
+        var response = await this[`_find${opts.one? 'One' : ''}`](opts.query, options)
+      } else {
         loop: for (let item of opts.populate) {
           let path = util.isObject(item)? item.as : item
           // Blacklisted?
@@ -148,7 +132,7 @@ module.exports = {
         }
         // console.log(1, options.projection)
         // console.log(2, lookups)
-        let aggreagte = [
+        let aggregate = [
           { $match: opts.query },
           { $sort: options.sort },
           { $skip: options.skip },
@@ -157,49 +141,45 @@ module.exports = {
           ...util.isEmpty(options.addFields)? [] : [{ $addFields: options.addFields }],
           { $project: options.projection }
         ]
-        var operation = this._aggregate.bind(this._collection, aggreagte)
-        this.info('aggregate', JSON.stringify(aggreagte))
-
-      // Normal operation
-      } else {
-        operation = this[opts.one? '_findOne' : '_find'].bind(this._collection, opts.query, options)
+        response = await this._aggregate(aggregate)
+        this.info('aggregate', JSON.stringify(aggregate))
       }
-      operation()
-        .then(data => resolve(data))
-        .catch(err => reject(err))
 
-    }).then(data => {
-      if (opts.one && util.isArray(data)) data = data[0]
+      if (opts.one && util.isArray(response)) response = response[0]
       // (Not using) Project works with lookup.
       // Remove blacklisted properties from joined models, because subpiplines with 'project' are slower
       // if (opts.populate) this._depreciated_removeBlacklisted(data, opts.populate, options.projection)
-      return this._processAfterFind(data, options.projection, opts)
+      response = await this._processAfterFind(response, options.projection, opts)
 
-    }).then(data => {
-      if (cb) cb(null, data)
-      else if (opts.req && opts.respond) opts.req.res.json(data)
-      else return Promise.resolve(data)
+      // Success
+      if (cb) cb(null, response)
+      else if (opts.req && opts.respond) opts.req.res.json(response)
+      else return Promise.resolve(response)
 
-    }).catch(err => {
+    } catch (err) {
       if (cb) cb(err)
       else if (opts && opts.req && opts.respond) opts.req.res.error(err)
       else throw err
-    })
+    }
   },
 
-  findOne: function(opts, cb) {
+  findOne: async function(opts, cb) {
     return this.find(opts, cb, true)
   },
 
-  update: function(opts, cb) {
+  // findOneAndUpdate: function(opts, cb) {
+  //   return this._findOneAndUpdate(opts, cb)
+  // },
+
+  update: async function(opts, cb) {
     /**
      * Updates document(s) with monk after validating data & before hooks.
      * @param {object} opts
      *     @param {object} <opts.query> - mongodb query object
      *     @param {object|array} <opts.data> - mongodb document update object(s)
      *     @param {boolean} <opts.respond> - automatically call res.json/error (requires opts.req)
-     *     @param {array|string|false} validateUndefined - ignore all required fields during insert, or
-     *         undefined subdocument required fields that have a defined parent/grandparent during update
+     *     @param {array|string|false} validateUndefined - validates all 'required' undefined fields, true by
+     *         default, but false on update
      *     @param {array|string|true} <opts.skipValidation> - skip validation for this field name(s)
      *     @param {boolean} <opts.timestamps> - whether `updatedAt` is automatically updated
      *     @param {array|string|false} <opts.blacklist> - augment schema.updateBL, `false` will remove all blacklisting
@@ -208,155 +188,140 @@ module.exports = {
      * @this model
      * @return promise(data)
      */
-    let data, options, operators
     if (cb && !util.isFunction(cb)) {
       throw new Error(`The callback passed to ${this.name}.update() is not a function`)
     }
-    return new Promise((resolve, reject) => {
-      opts = this._queryObject(opts)
-      opts.update = true
-      opts.model = this
-      let req = opts.req
-      data = opts.data = util.isDefined(opts.data)? opts.data : util.isDefined((req||{}).body) ? req.body : undefined
-      operators = util.pluck(opts, [/^\$/])
-      // Operation options
-      options = util.omit(opts, ['data', 'query', 'respond', 'validateUndefined', 'skipValidation', 'blacklist'])
-      options.sort = options.sort || { 'createdAt': -1 }
-      options.limit = parseInt(options.limit || 0)
-      // Sort string passed
-      if (util.isString(options.sort)) {
-        let name = (options.sort.match(/([a-z0-9-_]+)/) || [])[0]
-        let order = (options.sort.match(/:(-?[0-9])/) || [])[1]
-        options.sort = { [name]: parseInt(order || 1) }
+    try {
+      opts = await this._queryObject(opts, 'update')
+      let response = null
+      let operators = util.pluck(opts, [/^\$/])
+      let options = util.omit(opts, ['data', 'query', 'respond', 'validateUndefined', 'skipValidation', 'blacklist'])
+
+      // Validate
+      if (util.isDefined(opts.data)) opts.data = await this.validate(opts.data, { ...opts })
+      if (!util.isDefined(opts.data) && util.isEmpty(operators)) {
+        throw new Error(`Please pass an update operator to ${this.name}.update(), e.g. data, $unset, etc`)
       }
-      util.parseData(data).then(d => resolve(d))
-
-    }).then(data => {
-      opts.data = data
-      if (util.isDefined(data)) return this.validate(data, { ...opts })
-      else return Promise.resolve(data)
-
-    }).then(data => {
-      if (util.isDefined(data) && (!data || util.isEmpty(data))) {
+      if (util.isDefined(opts.data) && (!opts.data || util.isEmpty(opts.data))) {
         throw new Error(`No valid data passed to ${this.name}.update({ data: .. })`)
       }
-      if (!util.isDefined(data) && util.isEmpty(operators)) {
-        throw new Error(`Please pass an update operator to ${this.name}.update(), e.g. data, $unset, etc`)
-      }
-      return util.runSeries(this.beforeUpdate.map(f => f.bind(opts, data||{}))).then(() => data)
-
-    }).then(data => {
-      if (data && operators['$set']) {
+      // Hook: beforeUpdate
+      await util.runSeries(this.beforeUpdate.map(f => f.bind(opts, opts.data||{})))
+      if (opts.data && operators['$set']) {
         this.warn(`'$set' fields take precedence over the data fields for \`${this.name}.update()\``)
       }
-      if (data || operators['$set']) {
-        operators['$set'] = {
-          ...data,
-          ...(operators['$set'] || {}),
-        }
+      if (opts.data || operators['$set']) {
+        operators['$set'] = { ...opts.data, ...(operators['$set'] || {}) }
       }
-      return this._update(opts.query, operators, options).then(output => {
-        if (!output.n) return null
-        let response = Object.assign(Object.create({ _output: output }), operators['$set']||{})
-        output = data = null // Cleanup (just incase)
-        return response
-      })
+      // Update
+      let update = await this._update(opts.query, operators, options)
+      if (update.n) response = Object.assign(Object.create({ _output: update }), operators['$set']||{})
 
-    }).then(data => {
-      if (!data) return data
-      return util.runSeries(this.afterUpdate.map(f => f.bind(opts, data))).then(() => data)
+      // Hook: afterUpdate
+      if (update.n) await util.runSeries(this.afterUpdate.map(f => f.bind(opts, response)))
 
-    // Success/error
-    }).then(data => {
-      if (cb) cb(null, data)
-      else if (opts.req && opts.respond) opts.req.res.json(data)
-      else return Promise.resolve(data)
+      // Success
+      if (cb) cb(null, response)
+      else if (opts.req && opts.respond) opts.req.res.json(response)
+      else return response
 
-    }).catch(err => {
+    } catch (err) {
       if (cb) cb(err)
       else if (opts && opts.req && opts.respond) opts.req.res.error(err)
       else throw err
-    })
+    }
   },
 
-  remove: function(opts, cb) {
+  remove: async function(opts, cb) {
     /**
      * Remove document(s) with monk after before hooks.
      * @param {object} opts
      *     @param {object} <opts.query> - mongodb query object
      *     @param {boolean} <opts.respond> - automatically call res.json/error (requires opts.req)
+     *     @param {boolean=true} <opts.multi> - set to false to limit the deletion to just one document
      *     @param {any} <opts.any> - any mongodb option
      * @param {function} <cb> - execute cb(err, data) instead of responding
      * @this model
      * @return promise
      */
-    let options
     if (cb && !util.isFunction(cb)) {
       throw new Error(`The callback passed to ${this.name}.remove() is not a function`)
     }
-    return new Promise((resolve, reject) => {
-      opts = this._queryObject(opts)
-      opts.remove = true
-      opts.model = this
+    try {
+      opts = await this._queryObject(opts, 'remove')
+      let options = util.omit(opts, ['query', 'respond'])
       if (util.isEmpty(opts.query)) throw new Error('Please specify opts.query')
-      // Operation options
-      options = util.omit(opts, ['query', 'respond'])
-      options.sort = options.sort || { 'createdAt': -1 }
-      options.limit = parseInt(options.limit || 1)
-      // Sort string passed
-      if (util.isString(options.sort)) {
-        let name = (options.sort.match(/([a-z0-9-_]+)/) || [])[0]
-        let order = (options.sort.match(/:(-?[0-9])/) || [])[1]
-        options.sort = { [name]: parseInt(order || 1) }
-      }
-      util.runSeries(this.beforeRemove.map(f => f.bind(opts)))
-        .then(() => resolve())
-        .catch(e => reject(e))
-
-    }).then(() => {
-      return this._remove(opts.query, options)
 
-    }).then(data => {
-      return util.runSeries(this.afterRemove.map(f => f.bind(opts))).then(() => data)
+      // Remove
+      await util.runSeries(this.beforeRemove.map(f => f.bind(opts)))
+      let response = await this._remove(opts.query, options)
+      await util.runSeries(this.afterRemove.map(f => f.bind(response)))
 
-    // Success/error
-    }).then(data => {
-      if (cb) cb(null, data)
-      else if (opts.req && opts.respond) opts.req.res.json(data)
-      else return Promise.resolve(data)
+      // Success
+      if (cb) cb(null, response)
+      else if (opts.req && opts.respond) opts.req.res.json(response)
+      else return Promise.resolve(response)
 
-    }).catch(err => {
+    } catch (err) {
       if (cb) cb(err)
       else if (opts && opts.req && opts.respond) opts.req.res.error(err)
       else throw err
-    })
+    }
   },
 
-  _queryObject: function(opts) {
+  _queryObject: async function(opts, type, one) {
     /**
-     * Extract the query id from opts, opts.query
-     * @param {MongoId|ID string|Query object} opts
-     * @return opts
+     * Normalise options
+     * @param {MongoId|string|object} opts
+     * @param {string} type - operation type
+     * @param {boolean} one - return one document
+     * @this model
+     * @return {Promise} opts
      *
-     * opts == string|MongodID - treated as an id
+     * opts == string|MongodId - treated as an id
      * opts == undefined|null|false - throw error
      * opts.query == string|MongodID - treated as an id
      * opts.query == undefined|null|false - throw error
      */
-    let isIdType = (o) => util.isId(o) || util.isString(o)
-    if (isIdType(opts)) opts = { query: { _id: opts || '' }}
-    if (isIdType((opts||{}).query)) opts.query = { _id: opts.query || '' }
-    if (!util.isObject(opts) || !util.isObject(opts.query)) {
-      throw new Error('Please pass an object or MongoId to options.query')
-    }
-    // For security, if _id is set and undefined, throw an error
-    if (typeof opts.query._id == 'undefined' && opts.query.hasOwnProperty('_id')) {
-      throw new Error('Please pass an object or MongoId to options.query')
+
+    // Query
+    if (type != 'insert') {
+      let isIdType = (o) => util.isId(o) || util.isString(o)
+      if (isIdType(opts)) {
+        opts = { query: { _id: opts || '' }}
+      }
+      if (isIdType((opts||{}).query)) {
+        opts.query = { _id: opts.query || '' }
+      }
+      if (!util.isObject(opts) || !util.isObject(opts.query)) {
+        throw new Error('Please pass an object or MongoId to options.query')
+      }
+      // For security, if _id is set and undefined, throw an error
+      if (typeof opts.query._id == 'undefined' && opts.query.hasOwnProperty('_id')) {
+        throw new Error('Please pass an object or MongoId to options.query')
+      }
+      if (util.isId(opts.query._id)) opts.query._id = this.manager.id(opts.query._id)
+      if (isIdType(opts.query._id) || one) opts.one = true
+      opts.query = util.removeUndefined(opts.query)
+
+      // Query options
+      opts.limit = opts.one? 1 : parseInt(opts.limit || this.manager.limit || 0)
+      opts.skip = Math.max(0, opts.skip || 0)
+      opts.sort = opts.sort || { 'createdAt': -1 }
+      if (util.isString(opts.sort)) {
+        let name = (opts.sort.match(/([a-z0-9-_]+)/) || [])[0]
+        let order = (opts.sort.match(/:(-?[0-9])/) || [])[1]
+        opts.sort = { [name]: parseInt(order || 1) }
+      }
     }
-    // Remove undefined query parameters
-    opts.query = util.removeUndefined(opts.query)
-    if (util.isId(opts.query._id)) opts.query._id = this.manager.id(opts.query._id)
-    if (isIdType(opts.query._id)) opts.one = true
+
+    // Data
+    if (!opts) opts = {}
+    if (!util.isDefined(opts.data) && util.isDefined((opts.req||{}).body)) opts.data = opts.req.body
+    if (util.isDefined(opts.data)) opts.data = await util.parseData(opts.data)
+
+    opts[type] = true
+    opts.model = this
     return opts
   },
 

package/lib/model-validate.js

@@ -12,8 +12,8 @@ module.exports = {
      *     @param {boolean(false)} update - are we validating for insert or update?
      *     @param {array|string|false} blacklist - augment schema blacklist, `false` will remove all blacklisting
      *     @param {array|string} projection - only return these fields, ignores blacklist
-     *     @param {array|string|false} validateUndefined - ignore all required fields during insert, or undefined
-     *         subdocument required fields that have a defined parent/grandparent during update
+     *     @param {array|string|false} validateUndefined - validates all 'required' undefined fields, true by
+     *         default, but false on update
      *     @param {array|string|true} skipValidation - skip validation on these fields
      *     @param {boolean} timestamps - whether `createdAt` and `updatedAt` are inserted, or `updatedAt` is
      *         updated, depending on the `options.update` value
@@ -176,11 +176,11 @@ module.exports = {
         } else if (util.isSubdocument(field)) {
           // Object schema errors
           errors.push(...(verrors = this._validateRules(dataRoot, schema, value, opts, path2)))
-          // Recurse if data value is a subdocument, or when inserting, or when updating deep properties (non-root)
+          // Recurse if inserting, value is a subdocument, or a deep property (todo: not dot-notation)
           if (
-            util.isObject(value) ||
             opts.insert ||
-            ((path2||'').match(/\./) && (util.isDefined(opts.validateUndefined) ? opts.validateUndefined : true))
+            util.isObject(value) ||
+            (util.isDefined(opts.validateUndefined) ? opts.validateUndefined : (path2||'').match(/\./))
           ) {
             var res = this._validateFields(dataRoot, field, value, opts, path2)
             errors.push(...res[0])
@@ -260,13 +260,14 @@ module.exports = {
     ruleArg = ruleArg === true? undefined : ruleArg
     let rule = this.rules[ruleName] || rules[ruleName]
     let fieldName = path.match(/[^.]+$/)[0]
+    let isDeepProp = path.match(/\./) // todo: not dot-notation
     let ruleMessageKey = this._getMostSpecificKeyMatchingPath(this.messages, path)
     let ruleMessage = ruleMessageKey && this.messages[ruleMessageKey][ruleName]
-    let validateUndefined = util.isDefined(opts.validateUndefined) ? opts.validateUndefined : rule.validateUndefined
+    let validateUndefined = util.isDefined(opts.validateUndefined) ? opts.validateUndefined : opts.insert || isDeepProp
     if (!ruleMessage) ruleMessage = rule.message
 
-    // Ignore undefined (if updated root property, or ignoring)
-    if (typeof value === 'undefined' && (!validateUndefined || (opts.update && !path.match(/\./)))) return
+    // Undefined value
+    if (typeof value === 'undefined' && (!validateUndefined  || !rule.validateUndefined)) return
 
     // Ignore null (if nullObject is set on objects or arrays)
     if (value === null && (field.isObject || field.isArray) && field.nullObject) return
@@ -289,9 +290,9 @@ module.exports = {
   },
 
   _ignoredRules: [ // todo: change name? i.e. 'specialFields'
-    // Need to remove fileSize and formats..
-    'default', 'defaultOverride', 'fileSize', 'formats', 'image', 'index', 'insertOnly', 'model',
-    'nullObject', 'timestampField', 'type', 'virtual'
+    // Need to remove filesize and formats..
+    'default', 'defaultOverride', 'filename', 'filesize', 'formats', 'image', 'index', 'insertOnly',
+    'model', 'nullObject', 'params', 'getSignedUrl', 'timestampField', 'type', 'virtual'
   ]
 
 }

package/lib/model.js

@@ -188,9 +188,12 @@ Model.prototype._setupFields = function(fields) {
 
       // Rule doesn't exist
       util.forEach(field, (rule, ruleName) => {
+        if ((this.rules[ruleName] || rules[ruleName]) && this._ignoredRules.indexOf(ruleName) != -1) {
+          this.error(`The rule name "${ruleName}" for the model "${this.name}" is a reserved keyword, ignoring rule.`)
+        }
         if (!this.rules[ruleName] && !rules[ruleName] && this._ignoredRules.indexOf(ruleName) == -1) {
           // console.log(field)
-          this.error(`No rule "${ruleName}" exists for model "${this.name}". Ignoring rule.`)
+          this.error(`No rule "${ruleName}" exists for model "${this.name}", ignoring rule.`)
           delete field[ruleName]
         }
       }, this)

package/package.json

@@ -2,7 +2,7 @@
   "name": "monastery",
   "description": "⛪ A straight forward MongoDB ODM built around Monk",
   "author": "Ricky Boyce",
-  "version": "1.31.4",
+  "version": "1.32.0",
   "license": "MIT",
   "repository": "github:boycce/monastery",
   "homepage": "https://boycce.github.io/monastery/",
@@ -23,7 +23,7 @@
     "mong": "nodemon resources/mong.js",
     "minor": "standard-version --release-as minor && npm publish",
     "patch": "standard-version --release-as patch && npm publish",
-    "release": "standard-version && npm publish",
+    "release": "standard-version && npm publish && git push --tags",
     "test": "npm run lint && jest",
     "test-one-example": "jest -t images"
   },

package/plugins/images/index.js

@@ -32,7 +32,9 @@ let plugin = module.exports = {
       return
     }
 
-    // Create s3 service instance
+    // Create s3 'service' instance
+    // https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html#constructor-property
+    manager.getSignedUrl = this._getSignedUrl
     this.s3 = new S3({
       credentials: {
         accessKeyId: this.awsAccessKeyId,
@@ -71,6 +73,9 @@ let plugin = module.exports = {
       model.afterInsert.push(function(data, n) {
         plugin.addImages(this, data).then(() => n(null, data)).catch(e => n(e))
       })
+      model.afterFind.push(function(data, n) {
+        plugin.getSignedUrls(this, data).then(() => n(null, data)).catch(e => n(e))
+      })
     }
   },
 
@@ -121,14 +126,15 @@ let plugin = module.exports = {
         return Promise.all(filesArr.map(file => {
           return new Promise((resolve, reject) => {
             let uid = nanoid.nanoid()
+            let pathFilename = filesArr.imageField.filename ? '/' + filesArr.imageField.filename : ''
             let image = {
               bucket: this.awsBucket,
               date: this.manager.useMilliseconds? Date.now() : Math.floor(Date.now() / 1000),
               filename: file.name,
               filesize: file.size,
-              path: `${plugin.bucketDir}/${uid}.${file.ext}`,
+              path: `${plugin.bucketDir}/${uid}${pathFilename}.${file.ext}`,
               // sizes: ['large', 'medium', 'small'],
-              uid: uid
+              uid: uid,
             }
             this.manager.info(
               `Uploading '${image.filename}' to '${image.bucket}/${image.path}'`
@@ -141,7 +147,11 @@ let plugin = module.exports = {
                 Bucket: this.awsBucket,
                 Key: image.path,
                 Body: file.data,
-                ACL: 'public-read'
+                // The IAM permission "s3:PutObjectACL" must be included in the appropriate policy
+                ACL: 'public-read',
+                // upload params,https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html#upload-property
+                ...filesArr.imageField.params,
+
               }, (err, response) => {
                 if (err) return reject(err)
                 plugin._addImageObjectsToData(filesArr.inputPath, data, image)
@@ -161,7 +171,7 @@ let plugin = module.exports = {
       return model._update(
         idquery,
         { '$set': prunedData },
-        { 'multi': options.multi || options.create }
+        { 'multi': options.multi || options.create },
       )
 
     // If errors, remove inserted documents to prevent double ups when the user resaves.
@@ -172,6 +182,23 @@ let plugin = module.exports = {
     })
   },
 
+  getSignedUrls: async function(options, data) {
+    // Not wanting signed urls for this operation?
+    if (util.isDefined(options.getSignedUrls) && !options.getSignedUrls) return
+
+    // Find all image objects in data
+    for (let doc of util.toArray(data)) {
+      for (let imageField of options.model.imageFields) {
+        if (options.getSignedUrls || imageField.getSignedUrl) {
+          let images = plugin._findImagesInData(doc, imageField, 0, '').filter(o => o.image)
+          for (let image of images) {
+            image.image.signedUrl = this._getSignedUrl(image.image.path)
+          }
+        }
+      }
+    }
+  },
+
   keepImagePlacement: async function(options, data) {
     /**
      * Hook before update/remove
@@ -376,7 +403,7 @@ let plugin = module.exports = {
       return Promise.all(filesArr.map((file, i) => {
         return new Promise((resolve, reject) => {
           fileType.fromBuffer(file.data).then(res => {
-            let maxSize = filesArr.imageField.fileSize
+            let maxSize = filesArr.imageField.filesize
             let formats = filesArr.imageField.formats || plugin.formats
             let allowAny = util.inArray(formats, 'any')
             file.format = res? res.ext : ''
@@ -431,7 +458,10 @@ let plugin = module.exports = {
       // Image field. Test for field.image as field.type may be 'any'
       } else if (field.type == 'image' || field.image) {
         let formats = field.formats
-        let fileSize = field.fileSize
+        let filesize = field.filesize || field.fileSize // old <= v1.31.7
+        let filename = field.filename
+        let getSignedUrl = field.getSignedUrl
+        let params = { ...field.params||{} }
         // Convert image field to subdocument
         fields[fieldName] = {
           bucket: { type: 'string' },
@@ -440,13 +470,16 @@ let plugin = module.exports = {
           filesize: { type: 'number' },
           path: { type: 'string' },
           schema: { image: true, nullObject: true, isImageObject: true },
-          uid: { type: 'string' }
+          uid: { type: 'string' },
         }
         list.push({
           fullPath: path2,
           fullPathRegex: new RegExp('^' + path2.replace(/\.[0-9]+/g, '.[0-9]+').replace(/\./g, '\\.') + '$'),
           formats: formats,
-          fileSize: fileSize
+          filesize: filesize,
+          filename: filename,
+          getSignedUrl: getSignedUrl,
+          params: params,
         })
       }
     })
@@ -495,6 +528,16 @@ let plugin = module.exports = {
     }
 
     return list
-  }
+  },
+
+  _getSignedUrl: (path, expires=3600) => {
+    // https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html#getSignedUrl-property
+    let signedUrl = plugin.s3.getSignedUrl('getObject', {
+      Bucket: plugin.awsBucket,
+      Key: path,
+      Expires: expires
+    })
+    return signedUrl
+  },
 
 }

package/test/crud.js

@@ -415,6 +415,40 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
+  test('remove basics', async () => {
+    let db = (await opendb(null)).db
+    let user = db.model('user', {
+      fields: {
+        name: { type: 'string' },
+      },
+    })
+
+    // Insert multiple
+    let inserted2 = await user.insert({ data: [{ name: 'Martin' }, { name: 'Martin' }, { name: 'Martin' }]})
+    expect(inserted2).toEqual([
+      {
+        _id: expect.any(Object),
+        name: 'Martin'
+      }, {
+        _id: expect.any(Object),
+        name: 'Martin'
+      }, {
+        _id: expect.any(Object),
+        name: 'Martin'
+      }
+    ])
+
+    // Remove one
+    await expect(user.remove({ query: { name: 'Martin' }, multi: false }))
+      .resolves.toMatchObject({ deletedCount: 1, result: { n: 1, ok: 1 }})
+
+    // Remove many (default)
+    await expect(user.remove({ query: { name: 'Martin' } }))
+      .resolves.toMatchObject({ deletedCount: 2, result: { n: 2, ok: 1 }})
+
+    db.close()
+  })
+
   test('hooks', async () => {
     let db = (await opendb(null)).db
     let user = db.model('user', {

package/test/model.js

@@ -115,6 +115,29 @@ module.exports = function(monastery, opendb) {
     })
   })
 
+  test('model reserved rules', async () => {
+    // Setup
+    let db = (await opendb(false, {})).db
+    db.error = () => {} // hiding debug error
+    let user = db.model('user', {
+      fields: {
+        name: {
+          type: 'string',
+          params: {}, // reserved keyword (image plugin)
+          paramsUnreserved: {}
+        },
+      },
+      rules: {
+        params: (value) => {
+          return false // shouldn'r run
+        }
+      }
+    })
+    await expect(user.validate({ name: 'Martin' })).resolves.toMatchObject({
+      name: 'Martin',
+    })
+  })
+
   test('model indexes', async () => {
     // Setup: Need to test different types of indexes
     let db = (await opendb(null)).db
@@ -189,6 +212,55 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
+  test('model unique indexes', async () => {
+    let db = (await opendb(null)).db
+    // Setup: Drop previously tested collections
+    if ((await db._db.listCollections().toArray()).find(o => o.name == 'userUniqueIndex')) {
+      await db._db.collection('userUniqueIndex').drop()
+    }
+
+    // Partial unique indexes (allows mulitple null values)
+    await db.model('userUniqueIndex', {
+      waitForIndexes: true,
+      fields: {
+        email: {
+          type: 'string',
+          index: {
+            type: 'unique',
+            partialFilterExpression: {
+              email: { $type: 'string' }
+            }
+          }
+        },
+      }
+    })
+
+    let indexes2 = await db._db.collection('userUniqueIndex').indexes()
+    expect(indexes2[0]).toMatchObject({ v: 2, key: { _id: 1 }, name: '_id_' })
+    expect(indexes2[1]).toMatchObject({ v: 2, unique: true, key: { email: 1 }, name: 'email_1' })
+
+    await expect(db.userUniqueIndex.insert({ data: { 'email': 'ricky@orchid.co.nz' }})).resolves.toEqual({
+      _id: expect.any(Object),
+      email: 'ricky@orchid.co.nz'
+    })
+
+    await expect(db.userUniqueIndex.insert({ data: { 'email': 'ricky@orchid.co.nz' }})).rejects.toThrow(
+      /E11000 duplicate key error collection: monastery.userUniqueIndex index: email_1 dup key: {/
+    )
+
+    await expect(db.userUniqueIndex.insert({ data: { 'email': null }})).resolves.toEqual({
+      _id: expect.any(Object),
+      email: null
+    })
+
+    await expect(db.userUniqueIndex.insert({ data: { 'email': null }})).resolves.toEqual({
+      _id: expect.any(Object),
+      email: null
+    })
+
+    db.close()
+  })
+
   test('model subdocument indexes', async () => {
     // Setup: Need to test different types of indexes
     let db = (await opendb(null)).db

package/test/plugin-images.js

@@ -707,4 +707,59 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
+  test('images getSignedUrls', async () => {
+    // latest (2022.02)
+    let db = (await opendb(null, {
+      timestamps: false,
+      serverSelectionTimeoutMS: 2000,
+      imagePlugin: { awsBucket: 'fake', awsAccessKeyId: 'fake', awsSecretAccessKey: 'fake' }
+    })).db
+
+    db.model('user', { fields: {
+      photos: [{ type: 'image' }],
+      photos2: [{ type: 'image', getSignedUrl: true }],
+    }})
+
+    let image = {
+      bucket: 'test',
+      date: 1234,
+      filename: 'lion1.png',
+      filesize: 1234,
+      path: 'test/lion1.png',
+      uid: 'lion1'
+    }
+
+    let userInserted = await db.user._insert({
+      photos: [image, image],
+      photos2: [image, image],
+    })
+
+    // Find signed URL
+    await expect(db.user.findOne({ query: userInserted._id, getSignedUrls: true })).resolves.toEqual({
+      _id: expect.any(Object),
+      photos: [
+        { ...image, signedUrl: expect.stringMatching(/^https/) },
+        { ...image, signedUrl: expect.stringMatching(/^https/) },
+      ],
+      photos2: [
+        { ...image, signedUrl: expect.stringMatching(/^https/) },
+        { ...image, signedUrl: expect.stringMatching(/^https/) },
+      ]
+    })
+    // Find signed URL
+    await expect(db.user.findOne({ query: userInserted._id })).resolves.toEqual({
+      _id: expect.any(Object),
+      photos: [
+        { ...image },
+        { ...image },
+      ],
+      photos2: [
+        { ...image, signedUrl: expect.stringMatching(/^https/) },
+        { ...image, signedUrl: expect.stringMatching(/^https/) },
+      ]
+    })
+
+    db.close()
+  })
+
 }

package/test/validate.js

@@ -26,17 +26,18 @@ module.exports = function(monastery, opendb) {
       meta: { rule: 'required', model: 'user', field: 'name' }
     })
 
-    // Required error (insert, and with ignoreRequired)
-    await expect(user.validate({}, { validateUndefined: false })).resolves.toEqual({})
-    await expect(user.validate({}, { validateUndefined: false, update: true })).resolves.toEqual({})
-
     // No required error (update)
     await expect(user.validate({}, { update: true })).resolves.toEqual({})
 
     // Type error (string)
     await expect(user.validate({ name: 1 })).resolves.toEqual({ name: '1' })
     await expect(user.validate({ name: 1.123 })).resolves.toEqual({ name: '1.123' })
-    await expect(user.validate({ name: undefined }, { validateUndefined: false })).resolves.toEqual({})
+    await expect(user.validate({ name: undefined })).rejects.toContainEqual({
+      status: '400',
+      title: 'name',
+      detail: 'This field is required.',
+      meta: { rule: 'required', model: 'user', field: 'name' }
+    })
     await expect(user.validate({ name: null })).rejects.toContainEqual({
       status: '400',
       title: 'name',
@@ -65,20 +66,19 @@ module.exports = function(monastery, opendb) {
     await expect(usernum.validate({ amount: 0 })).resolves.toEqual({ amount: 0 })
     await expect(usernum.validate({ amount: '0' })).resolves.toEqual({ amount: 0 })
     await expect(usernum2.validate({ amount: '' })).resolves.toEqual({ amount: null })
-    await expect(usernum.validate({ amount: undefined }, { validateUndefined: false })).resolves.toEqual({})
     await expect(usernum.validate({ amount: false })).rejects.toEqual([{
       status: '400',
       title: 'amount',
       detail: 'Value was not a number.',
       meta: { rule: 'isNumber', model: 'usernum', field: 'amount' }
     }])
-    await expect(usernum.validate({ amount: null })).rejects.toEqual([{
+    await expect(usernum.validate({ amount: undefined })).rejects.toEqual([{
       status: '400',
       title: 'amount',
       detail: 'This field is required.',
       meta: { rule: 'required', model: 'usernum', field: 'amount' },
     }])
-    await expect(usernum.validate({ amount: null }, { validateUndefined: false })).rejects.toEqual([{
+    await expect(usernum.validate({ amount: null })).rejects.toEqual([{
       status: '400',
       title: 'amount',
       detail: 'This field is required.',
@@ -309,6 +309,41 @@ module.exports = function(monastery, opendb) {
       .rejects.toContainEqual(error)
   })
 
+  test('validation array schema errors', async () => {
+    // Setup
+    let db = (await opendb(false)).db
+    function arrayWithSchema(array, schema) {
+      array.schema = schema
+      return array
+    }
+    let user = db.model('user', { fields: {
+      animals: arrayWithSchema(
+        [{ type: 'string' }],
+        { required: true, minLength: 2 },
+      )
+    }})
+
+    // MinLength error
+    await expect(user.validate({
+      animals: [],
+    })).rejects.toContainEqual({
+      status: '400',
+      title: 'animals',
+      detail: 'This field is required.',
+      meta: { rule: 'required', model: 'user', field: 'animals' }
+    })
+
+    // MinLength error
+    await expect(user.validate({
+      animals: ['dog'],
+    })).rejects.toContainEqual({
+      status: '400',
+      title: 'animals',
+      detail: 'Value needs to contain a minimum of 2 items.',
+      meta: { rule: 'minLength', model: 'user', field: 'animals' }
+    })
+  })
+
   test('validation getMostSpecificKeyMatchingPath', async () => {
     let fn = validate._getMostSpecificKeyMatchingPath
     let mock = {
@@ -870,7 +905,7 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
-  test('validation options', async () => {
+  test('validation option skipValidation', async () => {
     let db = (await opendb(false)).db
     let user = db.model('user', { fields: {
       name: { type: 'string', required: true }
@@ -955,6 +990,66 @@ module.exports = function(monastery, opendb) {
     })
   })
 
+  test('validation option validateUndefined', async () => {
+    // ValidateUndefined runs required rules on all fields, `true` for insert, `false` for update.
+
+    // Setup
+    let db = (await opendb(false)).db
+    let user = db.model('user', { fields: {
+      date: { type: 'number' },
+      name: { type: 'string', required: true },
+    }})
+    let usernum = db.model('usernum', { fields: {
+      amount: { type: 'number', required: true }
+    }})
+    let userdeep = db.model('userdeep', { fields: {
+      date: { type: 'number' },
+      name: {
+        first: { type: 'string', required: true },
+      },
+      names: [{
+        first: { type: 'string', required: true },
+      }]
+    }})
+    let errorRequired = {
+      status: '400',
+      title: 'name',
+      detail: 'This field is required.',
+      meta: expect.any(Object),
+    }
+
+    // Required error for undefined
+    await expect(user.validate({}))
+      .rejects.toEqual([errorRequired])
+    await expect(user.validate({}, { update: true, validateUndefined: true }))
+      .rejects.toEqual([errorRequired])
+    await expect(userdeep.validate({}))
+      .rejects.toEqual([{ ...errorRequired, title: 'name.first' }])
+    await expect(userdeep.validate({ name: {} }, { update: true }))
+      .rejects.toEqual([{ ...errorRequired, title: 'name.first' }])
+    await expect(userdeep.validate({ names: [{}] }, { update: true }))
+      .rejects.toEqual([{ ...errorRequired, title: 'names.0.first' }])
+
+    // Required error for null
+    await expect(user.validate({ name: null }, { update: true }))
+      .rejects.toEqual([errorRequired])
+    await expect(usernum.validate({ amount: null }, { update: true }))
+      .rejects.toEqual([{ ...errorRequired, title: 'amount' }])
+    await expect(user.validate({ name: null }, { update: true, validateUndefined: true }))
+      .rejects.toEqual([errorRequired])
+
+    // Skip required error
+    await expect(user.validate({ name: undefined }, { validateUndefined: false })).resolves.toEqual({})
+    await expect(user.validate({}, { validateUndefined: false })).resolves.toEqual({})
+    await expect(user.validate({}, { update: true })).resolves.toEqual({})
+    await expect(user.validate({}, { update: true, validateUndefined: false })).resolves.toEqual({})
+    await expect(userdeep.validate({}, { update: true })).resolves.toEqual({})
+    await expect(userdeep.validate({ name: {} }, { update: true, validateUndefined: false }))
+      .resolves.toEqual({ name: {} })
+    await expect(userdeep.validate({ names: [{}] }, { update: true, validateUndefined: false }))
+      .resolves.toEqual({ names: [{}] })
+  })
+
   test('validation hooks', async () => {
     let db = (await opendb(null)).db
     let user = db.model('user', {