monastery 1.28.5 → 1.29.0

package/docs/readme.md

@@ -1,6 +1,6 @@
 ![](./assets/imgs/monastery.jpg)
 
-[![NPM](https://img.shields.io/npm/v/monastery.svg)](https://www.npmjs.com/package/monastery) [![Build Status](https://travis-ci.com/boycce/monastery.svg?branch=master)](https://travis-ci.com/boycce/monastery)
+[![NPM](https://img.shields.io/npm/v/monastery.svg)](https://www.npmjs.com/package/monastery) [![Build Status](https://travis-ci.com/boycce/monastery.svg?branch=master)](https://app.travis-ci.com/github/boycce/monastery)
 
 ## Features
 

package/lib/model-validate.js

@@ -213,6 +213,7 @@ module.exports = {
      * @param {object} dataRoot - data
      * @param {object} field - field schema
      * @param {string} path - full field path
+     * @param {object} opts - original validate() options
      * @this model
      * @return {array} errors
      */
@@ -242,38 +243,32 @@ module.exports = {
 
     for (let ruleName in field) {
       if (this._ignoredRules.indexOf(ruleName) > -1) continue
-      // ignore undefined updated root properties, or
-      if (util.isUndefined(value) && ((opts.update && !path.match(/\./)) || opts.ignoreUndefined)) continue
-      let error = this._validateRule(dataRoot, ruleName, field, field[ruleName], value, path)
+      let error = this._validateRule(dataRoot, ruleName, field, field[ruleName], value, opts, path)
       if (error && ruleName == 'required') return [error] // only show the required error
       if (error) errors.push(error)
     }
     return errors
   },
 
-  _validateRule: function(dataRoot, ruleName, field, ruleArg, value, path) {
-    //this.debug(path, field, ruleName, ruleArg, value)
+  _validateRule: function(dataRoot, ruleName, field, ruleArg, value, opts, path) {
+    // this.debug(path, field, ruleName, ruleArg, value)
     // Remove [] from the message path, and simply ignore non-numeric children to test for all array items
     ruleArg = ruleArg === true? undefined : ruleArg
     let rule = this.rules[ruleName] || rules[ruleName]
     let fieldName = path.match(/[^.]+$/)[0]
     let ruleMessageKey = this._getMostSpecificKeyMatchingPath(this.messages, path)
     let ruleMessage = ruleMessageKey && this.messages[ruleMessageKey][ruleName]
+    let ignoreUndefined = util.isDefined(opts.ignoreUndefined) ? opts.ignoreUndefined : rule.ignoreUndefined
     if (!ruleMessage) ruleMessage = rule.message
 
-    if (ruleName !== 'required') {
-      // Ignore undefined when not testing 'required'
-      if (typeof value === 'undefined') return
+    // Ignore undefined (if updated root property, or ignoring)
+    if ((ignoreUndefined || (opts.update && !path.match(/\./))) && typeof value === 'undefined') return
 
-      // Ignore null if not testing required
-      if (value === null && !field.isObject && !field.isArray) return
-
-      // Ignore null if nullObject is set on objects or arrays
-      if (value === null && field.nullObject) return
-    }
+    // Ignore null (if nullObject is set on objects or arrays) (todo: change to ignoreNull)
+    if (field.nullObject && (field.isObject || field.isArray) && value === null) return
 
     // Ignore empty strings
-    if (value === '' && rule.ignoreEmptyString) return
+    if (rule.ignoreEmptyString && value === '') return
 
     // Rule failed
     if (!rule.fn.call(dataRoot, value, ruleArg, path, this)) return {

package/lib/model.js

@@ -61,6 +61,7 @@ let Model = module.exports = function(name, opts, manager) {
       // Update with formatted rule
       let formattedRule = util.isObject(rule)? rule : { fn: rule }
       if (!formattedRule.message) formattedRule.message = `Invalid data property for rule "${ruleName}".`
+      if (typeof formattedRule.ignoreUndefined == 'undefined') formattedRule.ignoreUndefined = true
       this.rules[ruleName] = formattedRule
     }
   }, this)

package/lib/rules.js

@@ -5,6 +5,7 @@ let validator = require('validator')
 module.exports = {
 
   required: {
+    ignoreUndefined: false,
     message: 'This field is required.',
     fn: function(x) {
       if (util.isArray(x) && !x.length) return false
@@ -12,9 +13,10 @@ module.exports = {
     }
   },
 
-  // Rules below ignore null
+  // Type rules below ignore undefined (default for custom model rules)
 
   'isBoolean': {
+    ignoreUndefined: true,
     message: 'Value was not a boolean.',
     tryParse: function(x) {
       if (typeof x === 'string' && x === 'true') return true
@@ -25,13 +27,8 @@ module.exports = {
       return typeof x === 'boolean'
     }
   },
-  'isNotEmptyString': {
-    message: 'Value was an empty string.',
-    fn: function(x) {
-      return x !== ''
-    }
-  },
   'isArray': {
+    ignoreUndefined: true,
     message: 'Value was not an array.',
     tryParse: function(x) {
       if (x === '') return null
@@ -44,6 +41,7 @@ module.exports = {
     }
   },
   'isDate': {
+    ignoreUndefined: 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
@@ -55,6 +53,7 @@ module.exports = {
     }
   },
   'isImageObject': {
+    ignoreUndefined: 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 }\'',
@@ -70,6 +69,7 @@ module.exports = {
     }
   },
   'isInteger': {
+    ignoreUndefined: true,
     message: 'Value was not an integer.',
     tryParse: function(x) {
       if (util.isString(x) && x.match(/^[+-][0-9]+$/)) return x // keep string nums intact
@@ -81,6 +81,7 @@ module.exports = {
     }
   },
   'isNumber': {
+    ignoreUndefined: true,
     message: 'Value was not a number.',
     tryParse: function(x) {
       if (util.isString(x) && x.match(/^[+-][0-9]+$/)) return x // keep string nums intact
@@ -92,6 +93,7 @@ module.exports = {
     }
   },
   'isObject': {
+    ignoreUndefined: true,
     message: 'Value was not an object.',
     tryParse: function(x) {
       if (x === '') return null
@@ -104,18 +106,21 @@ module.exports = {
     }
   },
   'isString': {
+    ignoreUndefined: true,
     message: 'Value was not a string.',
     fn: function(x) {
       return typeof x === 'string'
     }
   },
   'isAny': {
+    ignoreUndefined: true,
     message: '',
     fn: function(x) {
       return true
     }
   },
   'isId': {
+    ignoreUndefined: true,
     message: 'Value was not a valid ObjectId.',
     tryParse: function(x) {
       // Try and parse value to a mongodb ObjectId
@@ -130,6 +135,7 @@ module.exports = {
     }
   },
   'max': {
+    ignoreUndefined: 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,16 +143,27 @@ module.exports = {
     }
   },
   'min': {
+    ignoreUndefined: 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': {
+    ignoreUndefined: 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,
+    ignoreUndefined: true,
     message: (x, arg) => 'Invalid enum value',
     fn: function(x, arg) {
       for (let item of arg) {
@@ -154,62 +171,73 @@ 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,
+    ignoreUndefined: true,
     message: (x, arg) => 'Value was before the configured time (' + arg + ')',
     fn: function(x, arg) { return validator.isAfter(x, arg) }
   },
   'isBefore': {
     ignoreEmptyString: true,
+    ignoreUndefined: true,
     message: (x, arg) => 'Value was after the configured time (' + arg + ')',
     fn: function(x, arg) { return validator.isBefore(x, arg) }
   },
   'isCreditCard': {
     ignoreEmptyString: true,
+    ignoreUndefined: true,
     message: 'Value was not a valid credit card.',
     fn: function(x, arg) { return validator.isCreditCard(x, arg) }
   },
   'isEmail': {
     ignoreEmptyString: true,
+    ignoreUndefined: true,
     message: 'Please enter a valid email address.',
     fn: function(x, arg) { return validator.isEmail(x, arg) }
   },
   'isHexColor': {
     ignoreEmptyString: true,
+    ignoreUndefined: true,
     message: 'Value was not a valid hex color.',
     fn: function(x, arg) { return validator.isHexColor(x, arg) }
   },
   'isIn': {
     ignoreEmptyString: true,
+    ignoreUndefined: 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,
+    ignoreUndefined: true,
     message: 'Value was not a valid IP address.',
     fn: function(x, arg) { return validator.isIP(x, arg) }
   },
   'isNotIn': {
     ignoreEmptyString: true,
+    ignoreUndefined: true,
     message: (x, arg) => 'Value was in the configured blacklist (' + arg.join(', ') + ')',
     fn: function(x, arg) { return !validator.isIn(x, arg) }
   },
   'isURL': {
     ignoreEmptyString: true,
+    ignoreUndefined: true,
     message: 'Value was not a valid URL.',
     fn: function(x, arg) { return validator.isURL(x, arg === true? undefined : arg) }
   },
   'isUUID': {
     ignoreEmptyString: true,
+    ignoreUndefined: true,
     message: 'Value was not a valid UUID.',
     fn: function(x, arg) { return validator.isUUID(x) }
   },
   'minLength': {
     ignoreEmptyString: true,
+    ignoreUndefined: 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.'
@@ -222,6 +250,7 @@ module.exports = {
   },
   'maxLength': {
     ignoreEmptyString: true,
+    ignoreUndefined: 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.'
@@ -234,6 +263,7 @@ module.exports = {
   },
   'regex': {
     ignoreEmptyString: true,
+    ignoreUndefined: 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/package.json

@@ -2,7 +2,7 @@
   "name": "monastery",
   "description": "⛪ A straight forward MongoDB ODM built around Monk",
   "author": "Ricky Boyce",
-  "version": "1.28.5",
+  "version": "1.29.0",
   "license": "MIT",
   "repository": "github:boycce/monastery",
   "homepage": "https://boycce.github.io/monastery/",

package/test/validate.js

@@ -481,7 +481,7 @@ module.exports = function(monastery, opendb) {
         name: { type: 'string', bigName: 8 },
         animals: [{
           name: { type: 'string', bigName: 8 }
-        }]
+        }],
       },
       rules: {
         bigName: function(value, ruleArg) {
@@ -489,6 +489,21 @@ module.exports = function(monastery, opendb) {
         }
       }
     })
+    let user2 = db.model('user2', {
+      fields: {
+        name: { type: 'string' },
+        nickname: { type: 'string', requiredIfNoName: true },
+        age: { type: 'number', required: true },
+      },
+      rules: {
+        requiredIfNoName: {
+          ignoreUndefined: false,
+          fn: function(value, ruleArg) {
+            return value || this.name
+          }
+        }
+      }
+    })
 
     // Basic field
     await expect(user.validate({ name: 'benjamin' })).resolves.toEqual({ name: 'benjamin' })
@@ -509,6 +524,39 @@ module.exports = function(monastery, opendb) {
       detail: 'Invalid data property for rule "bigName".',
       meta: { rule: 'bigName', model: 'user', field: 'name' }
     })
+
+    // Required rule based off another field (create)
+    await expect(user2.validate({ name: 'benjamin', age: 12 })).resolves.toEqual({
+      name: 'benjamin',
+      age: 12
+    })
+    await expect(user2.validate({ nickname: 'benny', age: 12 })).resolves.toEqual({
+      nickname: 'benny',
+      age: 12
+    })
+    await expect(user2.validate({ })).rejects.toEqual([
+      {
+        'detail': 'Invalid data property for rule "requiredIfNoName".',
+        'meta': { 'field': 'nickname', 'model': 'user2', 'rule': 'requiredIfNoName'},
+        'status': '400',
+        'title': 'nickname'
+      }, {
+        'detail': 'This field is required.',
+        'meta': { 'field': 'age', 'model': 'user2', 'rule': 'required'},
+        'status': '400',
+        'title': 'age'
+      }
+    ])
+    await expect(user2.validate({  }, { ignoreUndefined: true })).resolves.toEqual({})
+
+    // Required rule based off another field (update)
+    await expect(user2.validate({ }, { update: true })).resolves.toEqual({})
+    await expect(user2.validate({ nickname: '' }, { update: true })).rejects.toEqual([{
+      'detail': 'Invalid data property for rule "requiredIfNoName".',
+      'meta': { 'field': 'nickname', 'model': 'user2', 'rule': 'requiredIfNoName'},
+      'status': '400',
+      'title': 'nickname'
+    }])
   })
 
   test('Validated data', async () => {
@@ -532,8 +580,13 @@ module.exports = function(monastery, opendb) {
     // Ignores invalid data
     await expect(user.validate({ badprop: true, schema: {} })).resolves.toEqual({})
 
-    // Allows null data
-    await expect(user.validate({ name: null })).resolves.toEqual({ name: null })
+    // Rejects null for non object/array fields
+    await expect(user.validate({ name: null })).rejects.toEqual([{
+      'detail': 'Value was not a string.',
+      'meta': {'detailLong': undefined, 'field': 'name', 'model': 'user', 'rule': 'isString'},
+      'status':'400',
+      'title': 'name'
+    }])
 
     // String data
     await expect(user.validate({ name: 'Martin Luther' })).resolves.toEqual({ name: 'Martin Luther' })
@@ -556,9 +609,14 @@ module.exports = function(monastery, opendb) {
 
     // Subdocument property data (null)
     await expect(user.validate({ animals: { dog: null }}))
-      .resolves.toEqual({ animals: { dog: null }})
-
-    // Subdocument property data (bad data)
+      .rejects.toEqual([{
+        'detail': 'Value was not a string.',
+        'meta': {'detailLong': undefined, 'field': 'dog', 'model': 'user', 'rule': 'isString'},
+        'status': '400',
+        'title': 'animals.dog',
+      }])
+
+    // Subdocument property data (unknown data)
     await expect(user.validate({ animals: { dog: 'sparky', cat: 'grumpy' } }))
       .resolves.toEqual({ animals: { dog: 'sparky' } })
 
@@ -668,7 +726,12 @@ module.exports = function(monastery, opendb) {
     await expect(user2.validate({ amount: 0 })).resolves.toEqual({ amount: 0 }) // required
     await expect(user.validate({ amount: '0' })).resolves.toEqual({ amount: 0 }) // required
     await expect(user.validate({ amount: undefined })).resolves.toEqual({})  // not required
-    await expect(user.validate({ amount: null })).resolves.toEqual({ amount: null }) // not required
+    await expect(user.validate({ amount: null })).rejects.toEqual([{ // type error
+      'detail': 'Value was not a number.',
+      'meta': { 'field': 'amount', 'model': 'user', 'rule': 'isNumber'},
+      'status': '400',
+      'title': 'amount'
+    }])
 
     // Number required
     let mock1 = {
@@ -734,6 +797,12 @@ module.exports = function(monastery, opendb) {
     }})
 
     // Subdocument data (null/string)
+    await expect(user.validate({ animals: 'notAnObject' })).rejects.toEqual([{
+      'detail': 'Value was not an object.',
+      'meta': {'detailLong': undefined, 'field': 'animals', 'model': 'user', 'rule': 'isObject'},
+      'status': '400',
+      'title': 'animals'
+    }])
     await expect(user.validate({ animals: '', names: null })).resolves.toEqual({ animals: null, names: null })
 
     db.close()