monastery 1.30.3 → 1.30.4

package/lib/model-validate.js

@@ -266,13 +266,16 @@ module.exports = {
     if (!ruleMessage) ruleMessage = rule.message
 
     // Ignore undefined (if updated root property, or ignoring)
-    if ((!validateUndefined || (opts.update && !path.match(/\./))) && typeof value === 'undefined') return
+    if (typeof value === 'undefined' && (!validateUndefined || (opts.update && !path.match(/\./)))) 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 null (if nullObject is set on objects or arrays)
+    if (value === null && (field.isObject || field.isArray) && field.nullObject) return
+
+    // Ignore null
+    if (value === null && !(field.isObject || field.isArray) && !rule.validateNull) return
 
     // Ignore empty strings
-    if (!rule.validateEmptyString && value === '') return
+    if (value === '' && !rule.validateEmptyString) 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.validateNull == 'undefined') formattedRule.validateNull = true
       if (typeof formattedRule.validateEmptyString == 'undefined') formattedRule.validateEmptyString = true
       this.rules[ruleName] = formattedRule
     }

package/lib/rules.js

@@ -5,7 +5,8 @@ let validator = require('validator')
 module.exports = {
 
   required: {
-    validateUndefined: true,
+    validateUndefined: true, // (false for custom rules)
+    validateNull: true,
     validateEmptyString: true,
     message: 'This field is required.',
     fn: function(x) {
@@ -14,12 +15,13 @@ module.exports = {
     }
   },
 
-  // Type rules below ignore undefined (default for custom model rules)
+  // "Type" rules below ignore undefined and null
 
-  'isBoolean': {
+  isBoolean: {
     validateEmptyString: true,
     message: 'Value was not a boolean.',
     tryParse: function(x) {
+      if (x === '') return null
       if (typeof x === 'string' && x === 'true') return true
       else if (typeof x === 'string' && x === 'false') return false
       else return x
@@ -28,7 +30,7 @@ module.exports = {
       return typeof x === 'boolean'
     }
   },
-  'isArray': {
+  isArray: {
     validateEmptyString: true,
     message: 'Value was not an array.',
     tryParse: function(x) {
@@ -41,10 +43,11 @@ module.exports = {
       return Array.isArray(x)
     }
   },
-  'isDate': {
+  isDate: {
     validateEmptyString: true,
     message: 'Value was not a unix timestamp.',
     tryParse: function(x) {
+      if (x === '') return null
       if (util.isString(x) && x.match(/^[+-]?[0-9]+$/)) return x // keep string nums intact
       return isNaN(parseInt(x))? x : parseInt(x)
     },
@@ -53,7 +56,7 @@ module.exports = {
       return typeof x === 'number' && (parseInt(x) === x)
     }
   },
-  'isImageObject': {
+  isImageObject: {
     validateEmptyString: true,
     message: 'Invalid image value',
     messageLong: 'Image fields need to either be null, undefined, file, or an object containing the following '
@@ -69,10 +72,11 @@ module.exports = {
       if (isObject && x.bucket && x.date && x.filename && x.filesize && x.path && x.uid) return true
     }
   },
-  'isInteger': {
+  isInteger: {
     validateEmptyString: true,
     message: 'Value was not an integer.',
     tryParse: function(x) {
+      if (x === '') return null
       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)
     },
@@ -81,10 +85,11 @@ module.exports = {
       return typeof x === 'number' && (parseInt(x) === x)
     }
   },
-  'isNumber': {
+  isNumber: {
     validateEmptyString: true,
     message: 'Value was not a number.',
     tryParse: function(x) {
+      if (x === '') return null
       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)
     },
@@ -93,7 +98,7 @@ module.exports = {
       return typeof x === 'number'
     }
   },
-  'isObject': {
+  isObject: {
     validateEmptyString: true,
     message: 'Value was not an object.',
     tryParse: function(x) {
@@ -106,21 +111,25 @@ module.exports = {
       return x !== null && typeof x === 'object' && !(x instanceof Array)
     }
   },
-  'isString': {
+  isString: {
     validateEmptyString: true,
     message: 'Value was not a string.',
+    tryParse: function(x) {
+      if (typeof x === 'number') return x + ''
+      else return x
+    },
     fn: function(x) {
       return typeof x === 'string'
     }
   },
-  'isAny': {
+  isAny: {
     validateEmptyString: true,
     message: '',
     fn: function(x) {
       return true
     }
   },
-  'isId': {
+  isId: {
     validateEmptyString: true,
     message: 'Value was not a valid ObjectId.',
     tryParse: function(x) {
@@ -135,34 +144,27 @@ module.exports = {
       return util.isObject(x) && ObjectId.isValid(x)/*x.get_inc*/? true : false
     }
   },
-  'max': {
-    validateEmptyString: true,
+
+  /* "Number" rules below ignore undefined and null */
+
+  max: {
     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.') }
       return x <= arg
     }
   },
-  'min': {
-    validateEmptyString: true,
+  min: {
     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)
+  /* "String" rules below ignore undefined, null, and empty strings */
 
-  'enum': {
+  enum: {
     message: (x, arg) => 'Invalid enum value',
     fn: function(x, arg) {
       for (let item of arg) {
@@ -170,51 +172,54 @@ module.exports = {
       }
     }
   },
-  // 'hasAgreed': {
-  //   message: (x, arg) => 'Please agree to the terms and conditions.',
-  //   fn: function(x, arg) { return !x }
-  // },
-  'isAfter': {
+  isAfter: {
     message: (x, arg) => 'Value was before the configured time (' + arg + ')',
     fn: function(x, arg) { return validator.isAfter(x, arg) }
   },
-  'isBefore': {
+  isBefore: {
     message: (x, arg) => 'Value was after the configured time (' + arg + ')',
     fn: function(x, arg) { return validator.isBefore(x, arg) }
   },
-  'isCreditCard': {
+  isCreditCard: {
     message: 'Value was not a valid credit card.',
     fn: function(x, arg) { return validator.isCreditCard(x, arg) }
   },
-  'isEmail': {
+  isEmail: {
     message: 'Please enter a valid email address.',
     fn: function(x, arg) { return validator.isEmail(x, arg) }
   },
-  'isHexColor': {
+  isHexColor: {
     message: 'Value was not a valid hex color.',
     fn: function(x, arg) { return validator.isHexColor(x, arg) }
   },
-  'isIn': {
+  isIn: {
     message: (x, arg) => 'Value was not in the configured whitelist (' + arg.join(', ') + ')',
     fn: function(x, arg) { return validator.isIn(x, arg) }
   },
-  'isIP': {
+  isIP: {
     message: 'Value was not a valid IP address.',
     fn: function(x, arg) { return validator.isIP(x, arg) }
   },
-  'isNotIn': {
+  isNotEmptyString: {
+    validateEmptyString: true,
+    message: 'Value was an empty string.',
+    fn: function(x) {
+      return x !== ''
+    }
+  },
+  isNotIn: {
     message: (x, arg) => 'Value was in the configured blacklist (' + arg.join(', ') + ')',
     fn: function(x, arg) { return !validator.isIn(x, arg) }
   },
-  'isURL': {
+  isURL: {
     message: 'Value was not a valid URL.',
     fn: function(x, arg) { return validator.isURL(x, arg === true? undefined : arg) }
   },
-  'isUUID': {
+  isUUID: {
     message: 'Value was not a valid UUID.',
     fn: function(x, arg) { return validator.isUUID(x) }
   },
-  'minLength': {
+  minLength: {
     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.'
@@ -225,7 +230,7 @@ module.exports = {
       else return x.length >= arg
     }
   },
-  'maxLength': {
+  maxLength: {
     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 +241,7 @@ module.exports = {
       else return x.length <= arg
     }
   },
-  'regex': {
+  regex: {
     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.30.3",
+  "version": "1.30.4",
   "license": "MIT",
   "repository": "github:boycce/monastery",
   "homepage": "https://boycce.github.io/monastery/",
@@ -23,7 +23,8 @@
     "test-one-example": "jest -t images",
     "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"
+    "docs": "cd docs && bundle exec jekyll serve --livereload --livereload-port 4001",
+    "mong": "nodemon resources/mong.js"
   },
   "dependencies": {
     "aws-sdk": "2.1062.0",
@@ -39,6 +40,7 @@
     "express": "4.17.1",
     "express-fileupload": "1.2.0",
     "jest": "27.4.7",
+    "nodemon": "2.0.15",
     "standard-version": "9.3.2",
     "supertest": "4.0.2"
   },

package/test/validate.js

@@ -2,7 +2,7 @@ let validate = require('../lib/model-validate')
 
 module.exports = function(monastery, opendb) {
 
-  test('Validation basic errors', async () => {
+  test('validation basic errors', async () => {
     // Setup
     let db = (await opendb(false)).db
     let user = db.model('user', { fields: {
@@ -19,7 +19,7 @@ module.exports = function(monastery, opendb) {
       detail: 'This field is required.',
       meta: { rule: 'required', model: 'user', field: 'name' }
     })
-    await expect(user.validate({ name : '' }, { validateUndefined: false })).rejects.toContainEqual({
+    await expect(user.validate({ name : '' })).rejects.toContainEqual({
       status: '400',
       title: 'name',
       detail: 'This field is required.',
@@ -34,7 +34,16 @@ module.exports = function(monastery, opendb) {
     await expect(user.validate({}, { update: true })).resolves.toEqual({})
 
     // Type error (string)
-    await expect(user.validate({ name: 1 })).rejects.toContainEqual({
+    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: null })).rejects.toContainEqual({
+      status: '400',
+      title: 'name',
+      detail: 'This field is required.',
+      meta: { rule: 'required', model: 'user', field: 'name' }
+    })
+    await expect(user.validate({ name: true })).rejects.toContainEqual({
       status: '400',
       title: 'name',
       detail: 'Value was not a string.',
@@ -42,6 +51,7 @@ module.exports = function(monastery, opendb) {
     })
 
     // Type error (date)
+    await expect(user.validate({ name: 'a', date: null })).resolves.toEqual({ name: 'a', date: null })
     await expect(user.validate({ name: 'a', date: 'fe' })).rejects.toContainEqual({
       status: '400',
       title: 'date',
@@ -49,6 +59,30 @@ module.exports = function(monastery, opendb) {
       meta: { rule: 'isDate', model: 'user', field: 'date' }
     })
 
+    // Type error (number)
+    let usernum = db.model('usernum', { fields: { amount: { type: 'number', required: true }}})
+    await expect(usernum.validate({ amount: 0 })).resolves.toEqual({ amount: 0 })
+    await expect(usernum.validate({ amount: '0' })).resolves.toEqual({ amount: 0 })
+    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([{
+      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([{
+      status: '400',
+      title: 'amount',
+      detail: 'This field is required.',
+      meta: { rule: 'required', model: 'usernum', field: 'amount' },
+    }])
+
     // Type error (array)
     await expect(user.validate({ name: 'a', colors: 1 })).rejects.toContainEqual({
       status: '400',
@@ -224,7 +258,7 @@ module.exports = function(monastery, opendb) {
 
     // Type error within an array (string)
     await expect(user.validate({
-      animals: { cats: [1] }
+      animals: { cats: [true] }
     })).rejects.toContainEqual({
       status: '400',
       title: 'animals.cats.0',
@@ -239,7 +273,7 @@ module.exports = function(monastery, opendb) {
       detail: 'This field is required.',
       meta: { rule: 'required', model: 'user', field: 'color' }
     }
-    await expect(user.validate({ animals: { dogs: [{ name: 'sparky', color: 1 }] }}))
+    await expect(user.validate({ animals: { dogs: [{ name: 'sparky', color: false }] }}))
       .rejects.toContainEqual({
         ...error,
         detail: 'Value was not a string.',
@@ -623,16 +657,9 @@ module.exports = function(monastery, opendb) {
     // Ignores invalid data
     await expect(user.validate({ badprop: true, schema: {} })).resolves.toEqual({})
 
-    // 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' })
+    await expect(user.validate({ name: null })).resolves.toEqual({ name: null })
 
     // Array data
     await expect(user.validate({ names: ['blue'] })).resolves.toEqual({ names: ['blue'] })
@@ -652,12 +679,7 @@ module.exports = function(monastery, opendb) {
 
     // Subdocument property data (null)
     await expect(user.validate({ animals: { dog: null }}))
-      .rejects.toEqual([{
-        'detail': 'Value was not a string.',
-        'meta': {'detailLong': undefined, 'field': 'dog', 'model': 'user', 'rule': 'isString'},
-        'status': '400',
-        'title': 'animals.dog',
-      }])
+      .resolves.toEqual({ animals: { dog: null }})
 
     // Subdocument property data (unknown data)
     await expect(user.validate({ animals: { dog: 'sparky', cat: 'grumpy' } }))
@@ -766,15 +788,10 @@ module.exports = function(monastery, opendb) {
     })
 
     // Number valid
-    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 })).rejects.toEqual([{ // type error
-      'detail': 'Value was not a number.',
-      'meta': { 'field': 'amount', 'model': 'user', 'rule': 'isNumber'},
-      'status': '400',
-      'title': 'amount'
-    }])
+    await expect(user2.validate({ amount: 0 })).resolves.toEqual({ amount: 0 })
+    await expect(user2.validate({ amount: '0' })).resolves.toEqual({ amount: 0 })
+    await expect(user.validate({ amount: undefined })).resolves.toEqual({})
+    await expect(user.validate({ amount: null })).resolves.toEqual({ amount: null })
 
     // Number required
     let mock1 = {