monastery 1.28.3 → 1.30.0

package/lib/rules.js

@@ -5,7 +5,8 @@ let validator = require('validator')
 module.exports = {
 
   required: {
-    runOnUndefined: true, // integrate
+    validateUndefined: true,
+    validateEmptyString: true,
     message: 'This field is required.',
     fn: function(x) {
       if (util.isArray(x) && !x.length) return false
@@ -13,9 +14,10 @@ module.exports = {
     }
   },
 
-  // Type rules below ignore undefined
+  // 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
@@ -27,12 +29,12 @@ module.exports = {
     }
   },
   '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) {
@@ -40,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) {
@@ -67,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) {
@@ -102,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
@@ -127,9 +135,8 @@ module.exports = {
       return util.isObject(x) && ObjectId.isValid(x)/*x.get_inc*/? true : false
     }
   },
-
-
   '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.') }
@@ -137,6 +144,7 @@ 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.') }
@@ -144,17 +152,17 @@ module.exports = {
     }
   },
   'isNotEmptyString': {
+    validateEmptyString: true,
     message: 'Value was an empty string.',
     fn: function(x) {
       return x !== ''
     }
   },
 
-  // Rules below ignore undefined & empty strings
+  // Rules below ignore undefined, & empty strings
   // (e.g. an empty email field can be saved that isn't required)
 
   'enum': {
-    ignoreEmptyString: true,
     message: (x, arg) => 'Invalid enum value',
     fn: function(x, arg) {
       for (let item of arg) {
@@ -167,57 +175,46 @@ module.exports = {
   //   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.'
@@ -229,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.'
@@ -241,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.3",
+  "version": "1.30.0",
   "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",
-    "debug": "^4.1.1",
-    "file-type": "^15.0.0",
-    "monk": "^7.3.0",
-    "nanoid": "^3.1.12",
-    "validator": "^13.0.0"
+    "aws-sdk": "2.1062.0",
+    "debug": "4.1.1",
+    "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

@@ -155,8 +155,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.
@@ -246,7 +246,7 @@ let plugin = module.exports = {
         // pre-existing image, push to unused
         return plugin._findValidImages(options.files || {}, options.model).then(files => {
           for (let filesArray of files) {
-            if (pre = preExistingImages.find(o => o.dataPath == filesArray.inputPath)) {
+            if ((pre = preExistingImages.find(o => o.dataPath == filesArray.inputPath))) {
               useCount[pre.image.uid]--
             }
           }
@@ -380,7 +380,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

package/test/blacklisting.js

@@ -1,6 +1,6 @@
 module.exports = function(monastery, opendb) {
 
-  test('Find blacklisting', async (done) => {
+  test('Find blacklisting', async () => {
     // Setup
     let db = (await opendb(null)).db
     let bird = db.model('bird', {
@@ -150,10 +150,9 @@ module.exports = function(monastery, opendb) {
     })
 
     db.close()
-    done()
   })
 
-  test('Find blacklisting (default fields)', async (done) => {
+  test('Find blacklisting (default fields)', async () => {
     // Setup
     let db = (await opendb(null)).db
     let user = db.model('user', {
@@ -222,10 +221,9 @@ module.exports = function(monastery, opendb) {
     })
 
     db.close()
-    done()
   })
 
-  test('Find blacklisting (populate)', async (done) => {
+  test('Find blacklisting (populate)', async () => {
     // Setup
     let db = (await opendb(null)).db
     let bird = db.model('bird', {
@@ -305,10 +303,9 @@ module.exports = function(monastery, opendb) {
     })
 
     db.close()
-    done()
   })
 
-  test('Insert/update blacklisting (validate)', async (done) => {
+  test('Insert/update blacklisting (validate)', async () => {
     // Setup
     let db = (await opendb(null)).db
     let user = db.model('user', {
@@ -406,7 +403,6 @@ module.exports = function(monastery, opendb) {
       }
     })
     db.close()
-    done()
   })
 
 }

package/test/crud.js

@@ -1,8 +1,8 @@
-let util = require('../lib/util')
+// let util = require('../lib/util')
 
 module.exports = function(monastery, opendb) {
 
-  test('Basic operator calls', async (done) => {
+  test('Basic operator calls', async () => {
     let db = (await opendb(null)).db
     let user = db.model('user', {
       fields: { name: { type: 'string' }},
@@ -53,13 +53,14 @@ module.exports = function(monastery, opendb) {
     expect(find6).toEqual({ _id: inserted2[0]._id, name: 'Martin Luther1' })
 
     // Missing parameters
-    await expect(user.find()).rejects.toThrow(`Please pass an object or MongoId to options.query`)
-    await expect(user.find(undefined)).rejects.toThrow(`Please pass an object or MongoId to options.query`)
-    await expect(user.find({})).rejects.toThrow(`Please pass an object or MongoId to options.query`)
-    await expect(user.find({ query: null })).rejects.toThrow(`Please pass an object or MongoId to options.query`)
-    await expect(user.find({ query: undefined })).rejects.toThrow(`Please pass an object or MongoId to options.query`)
-    await expect(user.find({ query: { _id: undefined }})).rejects.toThrow(`Please pass an object or MongoId to options.query`)
-    await expect(user.find(1)).rejects.toThrow(`Please pass an object or MongoId to options.query`)
+    await expect(user.find()).rejects.toThrow('Please pass an object or MongoId to options.query')
+    await expect(user.find(undefined)).rejects.toThrow('Please pass an object or MongoId to options.query')
+    await expect(user.find({})).rejects.toThrow('Please pass an object or MongoId to options.query')
+    await expect(user.find({ query: null })).rejects.toThrow('Please pass an object or MongoId to options.query')
+    await expect(user.find({ query: undefined })).rejects.toThrow('Please pass an object or MongoId to options.query')
+    await expect(user.find({ query: { _id: undefined }}))
+      .rejects.toThrow('Please pass an object or MongoId to options.query')
+    await expect(user.find(1)).rejects.toThrow('Please pass an object or MongoId to options.query')
 
     // Bad MongoID
     await expect(user.find({ query: '' })).resolves.toEqual(null)
@@ -89,10 +90,10 @@ module.exports = function(monastery, opendb) {
 
     // Update (no/empty data object)
     await expect(user.update({ query: inserted._id, data: {}}))
-      .rejects.toThrow(`No valid data passed to user.update()`)
+      .rejects.toThrow('No valid data passed to user.update()')
 
     await expect(user.update({ query: inserted._id }))
-      .rejects.toThrow(`No valid data passed to user.update()`)
+      .rejects.toThrow('No valid data passed to user.update()')
 
     // Update (no/empty data object, but has update operators
     await expect(user.update({ query: inserted._id, $set: { name: 'bruce' }}))
@@ -114,7 +115,7 @@ module.exports = function(monastery, opendb) {
     expect(beforeValidateHookCalled).toEqual(false)
 
     // Update multiple
-    let updated2 = await user.update({
+    await user.update({
       query: { _id: { $in: [inserted2[0]._id, inserted2[1]._id] }},
       data: { name: 'Martin Luther3' },
       multi: true
@@ -137,10 +138,9 @@ module.exports = function(monastery, opendb) {
     expect(remove.result).toEqual({ n: 1, ok: 1 })
 
     db.close()
-    done()
   })
 
-  test('Insert defaults', async (done) => {
+  test('Insert defaults', async () => {
     let db = (await opendb(null, { defaultObjects: true, serverSelectionTimeoutMS: 2000 })).db
     let db2 = (await opendb(null, { useMilliseconds: true, serverSelectionTimeoutMS: 2000 })).db
     let user = db.model('user', { fields: {
@@ -192,10 +192,9 @@ module.exports = function(monastery, opendb) {
 
     db.close()
     db2.close()
-    done()
   })
 
-  test('update defaults', async (done) => {
+  test('update defaults', async () => {
     let db = (await opendb(null, { useMilliseconds: true, serverSelectionTimeoutMS: 2000 })).db
     let user = db.model('user', {
       fields: {
@@ -236,7 +235,7 @@ module.exports = function(monastery, opendb) {
       query: inserted._id,
       data: {},
       timestamps: false
-    })).rejects.toThrow(`No valid data passed to user.update()`)
+    })).rejects.toThrow('No valid data passed to user.update()')
 
     // UpdatedAt override (wont work)
     let updated4 = await user.update({
@@ -254,12 +253,11 @@ module.exports = function(monastery, opendb) {
     expect(updated5.updatedAt).toEqual(1)
 
     db.close()
-    done()
   })
 
-  test('Insert with id casting', async (done) => {
+  test('Insert with id casting', async () => {
     let db = (await opendb(null)).db
-    let company = db.model('company', { fields: {
+    db.model('company', { fields: {
       name: { type: 'string' }
     }})
     let user = db.model('user', { fields: {
@@ -279,10 +277,9 @@ module.exports = function(monastery, opendb) {
     })
 
     db.close()
-    done()
   })
 
-  test('Find default field population', async (done) => {
+  test('Find default field population', async () => {
     let db = (await opendb(null)).db
     let user = db.model('user', {
       fields: {
@@ -308,7 +305,7 @@ module.exports = function(monastery, opendb) {
       ],
       pet: { dog: inserted._id }
     }})
-    let updated = await dog.update({
+    await dog.update({
       query: inserted._id,
       data: { user: inserted2._id }
     })
@@ -370,10 +367,9 @@ module.exports = function(monastery, opendb) {
     })
 
     db.close()
-    done()
   })
 
-  test('Hooks', async (done) => {
+  test('Hooks', async () => {
     let db = (await opendb(null)).db
     let user = db.model('user', {
       fields: {
@@ -412,8 +408,8 @@ module.exports = function(monastery, opendb) {
     let userDoc = await user.insert({ data: { first: 'Martin', last: 'Luther' }})
 
     // Catch insert (a)synchronous errors thrown in function or through `next(err)`
-    await expect(user.insert({ data: { first: '' } })).rejects.toThrow(`beforeInsert error 1..`)
-    await expect(user.insert({ data: { first: 'Martin' } })).rejects.toThrow(`beforeInsert error 2..`)
+    await expect(user.insert({ data: { first: '' } })).rejects.toThrow('beforeInsert error 1..')
+    await expect(user.insert({ data: { first: 'Martin' } })).rejects.toThrow('beforeInsert error 2..')
     await expect(user.insert({ data: { first: 'Martin', last: 'Luther' } })).resolves.toEqual({
       _id: expect.any(Object),
       first: 'Martin',
@@ -421,15 +417,17 @@ module.exports = function(monastery, opendb) {
     })
 
     // Catch update (a)synchronous errors thrown in function or through `next(err)`
-    await expect(user.update({ query: userDoc._id, data: { first: '' } })).rejects.toThrow(`beforeUpdate error 1..`)
-    await expect(user.update({ query: userDoc._id, data: { first: 'Martin' } })).rejects.toThrow(`beforeUpdate error 2..`)
+    await expect(user.update({ query: userDoc._id, data: { first: '' } }))
+      .rejects.toThrow('beforeUpdate error 1..')
+    await expect(user.update({ query: userDoc._id, data: { first: 'Martin' } }))
+      .rejects.toThrow('beforeUpdate error 2..')
     await expect(user.update({ query: userDoc._id, data: { first: 'Martin', last: 'Luther' } })).resolves.toEqual({
       first: 'Martin',
       last: 'Luther'
     })
 
     // Catch remove synchronous errors through `next(err)`
-    await expect(user.remove({ query: userDoc._id })).rejects.toThrow(`beforeRemove error..`)
+    await expect(user.remove({ query: userDoc._id })).rejects.toThrow('beforeRemove error..')
 
     // After find continues series
     await expect(user.find({ query: userDoc._id })).resolves.toEqual({
@@ -439,7 +437,6 @@ module.exports = function(monastery, opendb) {
     })
 
     db.close()
-    done()
   })
 
 }