monastery 1.28.4 → 1.30.1

package/lib/rules.js

@@ -5,6 +5,8 @@ let validator = require('validator')
 module.exports = {
 
   required: {
+    validateUndefined: true,
+    validateEmptyString: true,
     message: 'This field is required.',
     fn: function(x) {
       if (util.isArray(x) && !x.length) return false
@@ -12,9 +14,10 @@ module.exports = {
     }
   },
 
-  // Rules below ignore null
+  // Type rules below ignore undefined (default for custom model rules)
 
   'isBoolean': {
+    validateEmptyString: true,
     message: 'Value was not a boolean.',
     tryParse: function(x) {
       if (typeof x === 'string' && x === 'true') return true
@@ -25,19 +28,13 @@ module.exports = {
       return typeof x === 'boolean'
     }
   },
-  'isNotEmptyString': {
-    message: 'Value was an empty string.',
-    fn: function(x) {
-      return x !== ''
-    }
-  },
   'isArray': {
+    validateEmptyString: true,
     message: 'Value was not an array.',
     tryParse: function(x) {
       if (x === '') return null
       if (!util.isString(x)) return x
-      try { var parsed = JSON.parse(x) }
-      catch (e) { return x }
+      try { var parsed = JSON.parse(x) } catch (e) { return x }
       return Array.isArray(parsed)? parsed : x
     },
     fn: function(x) {
@@ -45,25 +42,26 @@ module.exports = {
     }
   },
   'isDate': {
+    validateEmptyString: true,
     message: 'Value was not a unix timestamp.',
     tryParse: function(x) {
-      if (util.isString(x) && x.match(/^[\+-]?[0-9]+$/)) return x // keep string nums intact
+      if (util.isString(x) && x.match(/^[+-]?[0-9]+$/)) return x // keep string nums intact
       return isNaN(parseInt(x))? x : parseInt(x)
     },
     fn: function(x) {
-      if (util.isString(x) && x.match(/^[\+-]?[0-9]+$/)) return true
+      if (util.isString(x) && x.match(/^[+-]?[0-9]+$/)) return true
       return typeof x === 'number' && (parseInt(x) === x)
     }
   },
   'isImageObject': {
+    validateEmptyString: true,
     message: 'Invalid image value',
     messageLong: 'Image fields need to either be null, undefined, file, or an object containing the following '
       + 'fields \'{ bucket, date, filename, filesize, path, uid }\'',
     tryParse: function(x) {
       if (x === '') return null
       if (!util.isString(x)) return x
-      try { var parsed = JSON.parse(x) }
-      catch (e) { return x }
+      try { var parsed = JSON.parse(x) } catch (e) { return x }
       return parsed !== null && typeof parsed === 'object' && !(parsed instanceof Array)? parsed : x
     },
     fn: function(x) {
@@ -72,34 +70,36 @@ module.exports = {
     }
   },
   'isInteger': {
+    validateEmptyString: true,
     message: 'Value was not an integer.',
     tryParse: function(x) {
-      if (util.isString(x) && x.match(/^[\+-][0-9]+$/)) return x // keep string nums intact
+      if (util.isString(x) && x.match(/^[+-][0-9]+$/)) return x // keep string nums intact
       return isNaN(parseInt(x)) || (!x && x!==0) || x===true? x : parseInt(x)
     },
     fn: function(x) {
-      if (util.isString(x) && x.match(/^[\+-]?[0-9]+$/)) return true
+      if (util.isString(x) && x.match(/^[+-]?[0-9]+$/)) return true
       return typeof x === 'number' && (parseInt(x) === x)
     }
   },
   'isNumber': {
+    validateEmptyString: true,
     message: 'Value was not a number.',
     tryParse: function(x) {
-      if (util.isString(x) && x.match(/^[\+-][0-9]+$/)) return x // keep string nums intact
+      if (util.isString(x) && x.match(/^[+-][0-9]+$/)) return x // keep string nums intact
       return isNaN(Number(x)) || (!x && x!==0) || x===true? x : Number(x)
     },
     fn: function(x) {
-      if (util.isString(x) && x.match(/^[\+-][0-9]+$/)) return true
+      if (util.isString(x) && x.match(/^[+-][0-9]+$/)) return true
       return typeof x === 'number'
     }
   },
   'isObject': {
+    validateEmptyString: true,
     message: 'Value was not an object.',
     tryParse: function(x) {
       if (x === '') return null
       if (!util.isString(x)) return x
-      try { var parsed = JSON.parse(x) }
-      catch (e) { return x }
+      try { var parsed = JSON.parse(x) } catch (e) { return x }
       return parsed !== null && typeof parsed === 'object' && !(parsed instanceof Array)? parsed : x
     },
     fn: function(x) {
@@ -107,18 +107,21 @@ module.exports = {
     }
   },
   'isString': {
+    validateEmptyString: true,
     message: 'Value was not a string.',
     fn: function(x) {
       return typeof x === 'string'
     }
   },
   'isAny': {
+    validateEmptyString: true,
     message: '',
     fn: function(x) {
       return true
     }
   },
   'isId': {
+    validateEmptyString: true,
     message: 'Value was not a valid ObjectId.',
     tryParse: function(x) {
       // Try and parse value to a mongodb ObjectId
@@ -133,6 +136,7 @@ module.exports = {
     }
   },
   'max': {
+    validateEmptyString: true,
     message: (x, arg) => 'Value was greater than the configured maximum (' + arg + ')',
     fn: function(x, arg) {
       if (typeof x !== 'number') { throw new Error ('Value was not a number.') }
@@ -140,16 +144,25 @@ module.exports = {
     }
   },
   'min': {
+    validateEmptyString: true,
     message: (x, arg) => 'Value was less than the configured minimum (' + arg + ')',
     fn: function(x, arg) {
       if (typeof x !== 'number') { throw new Error ('Value was not a number.') }
       return x >= arg
     }
   },
+  'isNotEmptyString': {
+    validateEmptyString: true,
+    message: 'Value was an empty string.',
+    fn: function(x) {
+      return x !== ''
+    }
+  },
+
+  // Rules below ignore undefined, & empty strings
+  // (e.g. an empty email field can be saved that isn't required)
 
-  // Rules below ignore null & empty strings
   'enum': {
-    ignoreEmptyString: true,
     message: (x, arg) => 'Invalid enum value',
     fn: function(x, arg) {
       for (let item of arg) {
@@ -157,62 +170,51 @@ module.exports = {
       }
     }
   },
-  'hasAgreed': {
-    message: (x, arg) => 'Please agree to the terms and conditions.',
-    fn: function(x, arg) { return !x }
-  },
+  // 'hasAgreed': {
+  //   message: (x, arg) => 'Please agree to the terms and conditions.',
+  //   fn: function(x, arg) { return !x }
+  // },
   'isAfter': {
-    ignoreEmptyString: true,
     message: (x, arg) => 'Value was before the configured time (' + arg + ')',
     fn: function(x, arg) { return validator.isAfter(x, arg) }
   },
   'isBefore': {
-    ignoreEmptyString: true,
     message: (x, arg) => 'Value was after the configured time (' + arg + ')',
     fn: function(x, arg) { return validator.isBefore(x, arg) }
   },
   'isCreditCard': {
-    ignoreEmptyString: true,
     message: 'Value was not a valid credit card.',
     fn: function(x, arg) { return validator.isCreditCard(x, arg) }
   },
   'isEmail': {
-    ignoreEmptyString: true,
     message: 'Please enter a valid email address.',
     fn: function(x, arg) { return validator.isEmail(x, arg) }
   },
   'isHexColor': {
-    ignoreEmptyString: true,
     message: 'Value was not a valid hex color.',
     fn: function(x, arg) { return validator.isHexColor(x, arg) }
   },
   'isIn': {
-    ignoreEmptyString: true,
     message: (x, arg) => 'Value was not in the configured whitelist (' + arg.join(', ') + ')',
     fn: function(x, arg) { return validator.isIn(x, arg) }
   },
   'isIP': {
-    ignoreEmptyString: true,
     message: 'Value was not a valid IP address.',
     fn: function(x, arg) { return validator.isIP(x, arg) }
   },
   'isNotIn': {
-    ignoreEmptyString: true,
     message: (x, arg) => 'Value was in the configured blacklist (' + arg.join(', ') + ')',
     fn: function(x, arg) { return !validator.isIn(x, arg) }
   },
   'isURL': {
-    ignoreEmptyString: true,
     message: 'Value was not a valid URL.',
     fn: function(x, arg) { return validator.isURL(x, arg === true? undefined : arg) }
   },
   'isUUID': {
-    ignoreEmptyString: true,
     message: 'Value was not a valid UUID.',
     fn: function(x, arg) { return validator.isUUID(x) }
   },
   'minLength': {
-    ignoreEmptyString: true,
     message: function(x, arg) {
       if (typeof x === 'string') return 'Value needs to be at least ' + arg + ' characters long.'
       else return 'Value needs to contain a minimum of ' + arg + ' items.'
@@ -224,7 +226,6 @@ module.exports = {
     }
   },
   'maxLength': {
-    ignoreEmptyString: true,
     message: function(x, arg) {
       if (typeof x === 'string') return 'Value was longer than the configured maximum length (' + arg + ')'
       else return 'Value cannot contain more than ' + arg + ' items.'
@@ -236,7 +237,6 @@ module.exports = {
     }
   },
   'regex': {
-    ignoreEmptyString: true,
     message: (x, arg) => 'Value did not match the configured regular expression (' + arg + ')',
     fn: function(x, arg) {
       if (util.isRegex(arg)) return validator.matches(x, arg)

package/lib/util.js

@@ -9,7 +9,7 @@ module.exports = {
     for (let key in obj) {
       let v = obj[key]
       if (this.isId(v)) obj2[key] = v.toString()
-      else obj2[key] = (typeof v === "object")? this.deepCopy(v) : v
+      else obj2[key] = (typeof v === 'object')? this.deepCopy(v) : v
     }
     return obj2
   },
@@ -165,7 +165,7 @@ module.exports = {
      * @param {object}
      */
     for (let key in obj) {
-      if (key.indexOf(".") !== -1) recurse(key, obj[key], obj)
+      if (key.indexOf('.') !== -1) recurse(key, obj[key], obj)
     }
     return obj
     function recurse(str, val, obj) {
@@ -199,8 +199,12 @@ module.exports = {
      */
     return new Promise(res => {
       for (let key in obj) {
-        if (key.match(/\[\]\[/i)) throw `Array items in bracket notation need array indexes "${key}", e.g. users[0][name]`
-        if (key.indexOf("[") !== -1) setup(key)
+        if (key.match(/\[\]\[/i)) {
+          throw `Array items in bracket notation need array indexes "${key}", e.g. users[0][name]`
+        }
+        if (key.indexOf('[') !== -1) {
+          setup(key)
+        }
       }
       res(obj)
     })
@@ -241,7 +245,7 @@ module.exports = {
   removeUndefined: (variable) => {
     // takes an array or object
     if (Array.isArray(variable)) {
-      for (let l=variable.length; i--;) {
+      for (let i=variable.length; i--;) {
         if (variable[i] === undefined) variable.splice(i, 1)
       }
     } else {
@@ -308,7 +312,7 @@ module.exports = {
           target[chunks[i]] = value
         }
       } else {
-        let isArray = chunks[i+1].match(/^[0-9\$]+$/)
+        let isArray = chunks[i+1].match(/^[0-9$]+$/)
         let parentCopy = target[chunks[i]] || (isArray? [] : {})
         if (ignoreEmptyArrays && isArray && !parentCopy.length) break
         target = target[chunks[i]] = parentCopy
@@ -316,7 +320,9 @@ module.exports = {
         if (chunks[i+1] == '$') {
           for (let m=0, n=target.length; m<n; m++) {
             let newPath = chunks.slice(i+2).join('.')
-            if (newPath) this.setDeepValue(target[m], newPath, value, onlyUndefined, onlyUndefinedNull, ignoreEmptyArrays)
+            if (newPath) {
+              this.setDeepValue(target[m], newPath, value, onlyUndefined, onlyUndefinedNull, ignoreEmptyArrays)
+            }
           }
           break
         }

package/package.json

@@ -2,7 +2,7 @@
   "name": "monastery",
   "description": "⛪ A straight forward MongoDB ODM built around Monk",
   "author": "Ricky Boyce",
-  "version": "1.28.4",
+  "version": "1.30.1",
   "license": "MIT",
   "repository": "github:boycce/monastery",
   "homepage": "https://boycce.github.io/monastery/",
@@ -19,27 +19,28 @@
   "scripts": {
     "minor": "standard-version --release-as minor && npm publish",
     "patch": "standard-version && npm publish",
-    "test": "jest",
+    "test": "npm run lint && jest",
     "test-one-example": "jest -t images",
-    "dev": "DEBUG=-monastery:info jest --watchAll --runInBand --verbose=false",
+    "dev": "npm run lint & DEBUG=-monastery:info jest --watchAll --runInBand --verbose=false",
+    "lint": "eslint ./lib ./plugins ./test",
     "docs": "cd docs && bundle exec jekyll serve --livereload --livereload-port 4001"
   },
   "dependencies": {
-    "aws-sdk": "^2.742.0",
+    "aws-sdk": "2.1062.0",
     "debug": "4.1.1",
-    "file-type": "^15.0.0",
-    "monk": "^7.3.0",
-    "nanoid": "^3.1.12",
-    "validator": "^13.0.0"
+    "file-type": "15.0.0",
+    "monk": "7.3.4",
+    "nanoid": "3.2.0",
+    "validator": "13.7.0"
   },
   "devDependencies": {
-    "body-parser": "^1.19.0",
-    "eslint": "^6.8.0",
-    "express": "^4.17.1",
-    "express-fileupload": "^1.2.0",
-    "jest": "^25.3.0",
-    "standard-version": "^7.1.0",
-    "supertest": "^4.0.2"
+    "body-parser": "1.19.0",
+    "eslint": "8.7.0",
+    "express": "4.17.1",
+    "express-fileupload": "1.2.0",
+    "jest": "27.4.7",
+    "standard-version": "9.3.2",
+    "supertest": "4.0.2"
   },
   "standard-version": {
     "releaseCommitMessageFormat": "{{currentTag}}",

package/plugins/images/index.js

@@ -54,8 +54,8 @@ let plugin = module.exports = {
     model.imageFields = plugin._findAndTransformImageFields(model.fields, '')
 
     if (model.imageFields.length) {
-      // Update image fields and whitelists with the new object schema
-      // model._setupFieldsAndWhitelists(model.fields)
+      // Todo?: Update image fields and whitelists with the new object schema
+      //   model._setupFieldsAndWhitelists(model.fields)
       model.beforeUpdate.push(function(data, n) {
         plugin.removeImages(this, data).then(() => n(null, data)).catch(e => n(e))
       })
@@ -91,7 +91,9 @@ let plugin = module.exports = {
      * @param {object} options - monastery operation options {model, query, files, ..}
      * @param {object} data -
      * @param {boolean} test -
-     * @return promise
+     * @return promise(
+     *   {object} data - data object containing new S3 image-object
+     * ])
      * @this plugin
      */
     let { model, query, files } = options
@@ -155,8 +157,8 @@ let plugin = module.exports = {
       if (test) return [prunedData]
       return model._update(
         idquery,
-        { "$set": prunedData },
-        { "multi": options.multi || options.create }
+        { '$set': prunedData },
+        { 'multi': options.multi || options.create }
       )
 
     // If errors, remove inserted documents to prevent double ups when the user resaves.
@@ -167,7 +169,7 @@ let plugin = module.exports = {
     })
   },
 
-  removeImages: function(options, data, test) {
+  removeImages: async function(options, 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
@@ -179,108 +181,113 @@ let plugin = module.exports = {
      *
      * @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
+     * @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
      */
     let pre
     let preExistingImages = []
     let useCount = {}
-    if (typeof options.files == 'undefined') return new Promise(res => res())
+    if (typeof options.files == 'undefined') return
 
     // Find all documents from the same query
-    return options.model._find(options.query, options)
-      .then(docs => {
-        // Find all pre-existing image objects in documents
-        for (let doc of util.toArray(docs)) { //x2
-          for (let imageField of options.model.imageFields) { //x5
-            let images = plugin._findImagesInData(doc, imageField, 0, '').filter(o => o.image)
-            for (let image of images) {
-              preExistingImages.push(image)
-              useCount[image.image.uid] = (useCount[image.image.uid] || 0) + 1
-            }
-          }
+    let docs = await options.model._find(options.query, options)
+
+    // Find all pre-existing image objects in documents
+    for (let doc of util.toArray(docs)) { //x2
+      for (let imageField of options.model.imageFields) { //x5
+        let images = plugin._findImagesInData(doc, imageField, 0, '').filter(o => o.image)
+        for (let image of images) {
+          preExistingImages.push(image)
+          useCount[image.image.uid] = (useCount[image.image.uid] || 0) + 1
         }
+      }
+    }
 
-        // console.log(1, useCount, preExistingImages)
+    // console.log(1, useCount, preExistingImages)
 
-        // Assign pre-existing images within undefined deep objects and missing array items to null
-        // ignore undefined root images
-        let dataFilled = util.deepCopy(data)
-        for (let key in dataFilled) {
-          for (let pre of preExistingImages) {
-            if (!pre.dataPath.match(new RegExp('^' + key + '(\\.|$)'))) continue
-            util.setDeepValue(dataFilled, pre.dataPath, null, true)
-          }
-        }
+    // Assign pre-existing images within undefined deep objects and missing array items to null,
+    // ignore undefined root images
+    let dataFilled = util.deepCopy(data)
+    for (let key in dataFilled) {
+      for (let pre of preExistingImages) {
+        if (!pre.dataPath.match(new RegExp('^' + key + '(\\.|$)'))) continue
+        util.setDeepValue(dataFilled, pre.dataPath, null, true)
+      }
+    }
+    // console.log(dataFilled)
 
-        // Loop all schema image fields
-        for (let imageField of options.model.imageFields) { //x5
-          let images = plugin._findImagesInData(dataFilled, imageField, 0, '')
-          if (!images.length) continue
-          // console.log(images)
+    // Check upload errors and find valid uploaded images
+    let files = await plugin._findValidImages(options.files || {}, options.model)
 
-          // Data contains null images that once had a pre-existing image
-          for (let image of images) {
-            if (image.image == null && (pre = preExistingImages.find(o => o.dataPath == image.dataPath))) {
-              useCount[pre.image.uid]--
-            }
-          }
+    // Loop all schema image fields
+    for (let imageField of options.model.imageFields) { //x5
+      let images = plugin._findImagesInData(dataFilled, imageField, 0, '')
+      if (!images.length) continue
+      // console.log(images)
 
-          // Data contains valid (pre-existing) image-objects? And are we overriding a pre-existing image?
-          for (let image of images) {
-            if (image.image != null) {
-              let pre = preExistingImages.find(o => o.dataPath == image.dataPath)
-              if (typeof useCount[image.image.uid] == 'undefined') {
-                throw `The passed image object for '${image.dataPath}' does not match any pre-existing
-                  images saved on this document.`
-              } else if (pre && pre.image.uid != image.image.uid) {
-                useCount[pre.image.uid]--
-                useCount[image.image.uid]++
-              } else if (!pre) {
-                useCount[image.image.uid]++
-              }
-            }
-          }
+      // Data contains null images that once had a pre-existing image
+      for (let image of images) {
+        if (image.image == null && (pre = preExistingImages.find(o => o.dataPath == image.dataPath))) {
+          useCount[pre.image.uid]--
         }
-        // Check upload errors and find valid uploaded images. If any file is overriding a
-        // pre-existing image, push to unused
-        return plugin._findValidImages(options.files || {}, options.model).then(files => {
+      }
+
+      // Loop images found in the data
+      for (let image of images) {
+        if (image.image != null) {
+          let preExistingImage = preExistingImages.find(o => o.dataPath == image.dataPath)
+          // valid image-object?
+          if (typeof useCount[image.image.uid] == 'undefined') {
+            throw `The passed image object for '${image.dataPath}' does not match any pre-existing
+              images saved on this document.`
+          // Different image from prexisting image
+          } else if (preExistingImage && preExistingImage.image.uid != image.image.uid) {
+            useCount[preExistingImage.image.uid]--
+            useCount[image.image.uid]++
+          // No pre-existing image found
+          } else if (!preExistingImage) {
+            useCount[image.image.uid]++
+          }
+          // Any file overriding this image?
           for (let filesArray of files) {
-            if (pre = preExistingImages.find(o => o.dataPath == filesArray.inputPath)) {
-              useCount[pre.image.uid]--
+            if (image.dataPath == filesArray.inputPath) {
+              useCount[image.image.uid]--
             }
           }
-        })
-
-      }).then(() => {
-        // Retrieve all the unused files
-        let unused = []
-        // console.log(3, useCount)
-        for (let key in useCount) {
-          if (useCount[key] > 0) continue
-          let pre = preExistingImages.find(o => o.image.uid == key)
-          unused.push(
-            // original key can have a different extension
-            { Key: pre.image.path },
-            { Key: `small/${key}.jpg` },
-            { Key: `medium/${key}.jpg` },
-            { Key: `large/${key}.jpg` }
-          )
-          this.manager.info(
-            `Removing '${pre.image.filename}' from '${pre.image.bucket}/${pre.image.path}'`
-          )
         }
-        if (test) return Promise.resolve([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.
-        if (!unused.length) return
-        return new Promise((resolve, reject) => {
-          plugin.s3.deleteObjects({ Bucket: plugin.awsBucket, Delete: { Objects: unused }}, (err, data) => {
-            if (err) reject(err)
-            resolve()
-          })
-        })
+      }
+    }
+
+    // Retrieve all the unused files
+    // console.log(3, useCount)
+    let unused = []
+    for (let key in useCount) {
+      if (useCount[key] > 0) continue
+      let pre = preExistingImages.find(o => o.image.uid == key)
+      unused.push(
+        // original key can have a different extension
+        { Key: pre.image.path },
+        { Key: `small/${key}.jpg` },
+        { Key: `medium/${key}.jpg` },
+        { Key: `large/${key}.jpg` }
+      )
+      this.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.
+    if (!unused.length) return
+    await new Promise((resolve, reject) => {
+      plugin.s3.deleteObjects({ Bucket: plugin.awsBucket, Delete: { Objects: unused }}, (err, data) => {
+        if (err) reject(err)
+        resolve()
       })
+    })
   },
 
   _addImageObjectsToData: function(path, data, image) {
@@ -380,7 +387,7 @@ let plugin = module.exports = {
     let list = []
     util.forEach(fields, (field, fieldName) => {
       let path2 = `${path}.${fieldName}`.replace(/^\./, '')
-      let schema = field.schema || {}
+      // let schema = field.schema || {}
 
       // Subdocument field
       if (util.isSubdocument(field)) {//schema.isObject