monastery 1.32.2 → 1.32.5

package/changelog.md

@@ -2,6 +2,22 @@
 
 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.5](https://github.com/boycce/monastery/compare/1.32.4...1.32.5) (2022-03-21)
+
+
+### Bug Fixes
+
+* dates not enforcing numbers ([d5a2a53](https://github.com/boycce/monastery/commit/d5a2a533f497b3c9e50cbeb66407cf9bc08dd2e4))
+
+### [1.32.4](https://github.com/boycce/monastery/compare/1.32.3...1.32.4) (2022-03-07)
+
+### [1.32.3](https://github.com/boycce/monastery/compare/1.32.2...1.32.3) (2022-03-07)
+
+
+### Bug Fixes
+
+* fileSize warning ([3824b23](https://github.com/boycce/monastery/commit/3824b23883fad508e081d2a2bce1c340ec2775dc))
+
 ### [1.32.2](https://github.com/boycce/monastery/compare/1.32.1...1.32.2) (2022-03-04)
 
 

package/lib/model-validate.js

@@ -291,7 +291,7 @@ module.exports = {
 
   _ignoredRules: [ // todo: change name? i.e. 'specialFields'
     // Need to remove filesize and formats..
-    'default', 'defaultOverride', 'filename', 'filesize', 'formats', 'image', 'index', 'insertOnly',
+    'default', 'defaultOverride', 'filename', 'filesize', 'fileSize', 'formats', 'image', 'index', 'insertOnly',
     'model', 'nullObject', 'params', 'getSignedUrl', 'timestampField', 'type', 'virtual'
   ]
 

package/lib/rules.js

@@ -1,3 +1,4 @@
+// Todo: remove stringnums in date/number/integer rules
 let ObjectId = require('mongodb').ObjectId
 let util = require('./util')
 let validator = require('validator')
@@ -48,12 +49,12 @@ module.exports = {
     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)
+      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
-      return typeof x === 'number' && (parseInt(x) === x)
+      if (util.isString(x) && x.match(/^[+-][0-9]+$/)) return true
+      return typeof x === 'number'
     }
   },
   isImageObject: {
@@ -78,10 +79,10 @@ module.exports = {
     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)
+      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)
     }
   },
@@ -91,7 +92,7 @@ module.exports = {
     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)
+      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

package/package.json

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

package/test/crud.js

@@ -3,6 +3,7 @@
 module.exports = function(monastery, opendb) {
 
   test('basic operator calls', async () => {
+    // Todo: take out and group query/id parsing tests
     let db = (await opendb(null)).db
     let user = db.model('user', {
       fields: {
@@ -53,20 +54,23 @@ module.exports = function(monastery, opendb) {
     let find6 = await user.find(inserted2[0]._id.toString())
     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')
-
-    // Bad MongoID
-    await expect(user.find({ query: '' })).resolves.toEqual(null)
-    await expect(user.find('bad-id')).resolves.toEqual(null)
+    // Bad ids
+    let badIdOrQuery = 'Please pass an object or MongoId to options.query'
+    await expect(user.find()).rejects.toThrow(badIdOrQuery)
+    await expect(user.find(1)).rejects.toThrow(badIdOrQuery)
+    await expect(user.find(null)).rejects.toThrow(badIdOrQuery)
+    await expect(user.find(undefined)).rejects.toThrow(badIdOrQuery)
+    await expect(user.find({})).rejects.toThrow(badIdOrQuery)
+    await expect(user.find({ query: null })).rejects.toThrow(badIdOrQuery)
+    await expect(user.find({ query: undefined })).rejects.toThrow(badIdOrQuery)
+    await expect(user.find({ query: { _id: undefined }})).rejects.toThrow(badIdOrQuery)
+
+    // Parseable
     await expect(user.find('')).resolves.toEqual(null)
+    await expect(user.find('invalid-id')).resolves.toEqual(null)
+    await expect(user.find({ query: '' })).resolves.toEqual(null)
+    await expect(user.find({ query: { _id: '' }})).resolves.toEqual(null)
+    await expect(user.find({ query: { _id: null }})).resolves.toEqual([]) // should throw error
 
     // FindOne (query id)
     let findOne = await user.findOne({ query: inserted._id })

package/test/plugin-images.js

@@ -417,7 +417,7 @@ module.exports = function(monastery, opendb) {
         imageSvgBad:  { type: 'image' },
         imageSvgGood: { type: 'image', formats: ['svg'] },
         imageSvgAny:  { type: 'image', formats: ['any'] },
-        imageSize1:   { type: 'image', fileSize: 1000 * 100 },
+        imageSize1:   { type: 'image', filesize: 1000 * 100 },
         imageSize2:   { type: 'image' },
       }})
 

package/test/validate.js

@@ -1,3 +1,5 @@
+// Todo: split out basic 'type' tests
+
 let validate = require('../lib/model-validate')
 
 module.exports = function(monastery, opendb) {
@@ -51,21 +53,55 @@ module.exports = function(monastery, opendb) {
       meta: { rule: 'isString', model: 'user', field: 'name' }
     })
 
+
     // 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({
+    let userdate = db.model('userdate', { fields: { amount: { type: 'date', required: true }}})
+    let userdate2 = db.model('userdate2', { fields: { amount: { type: 'date' }}})
+    await expect(userdate.validate({ amount: 0 })).resolves.toEqual({ amount: 0 })
+    await expect(userdate.validate({ amount: '0' })).resolves.toEqual({ amount: 0 })
+    await expect(userdate.validate({ amount: '1646778655000' })).resolves.toEqual({ amount: 1646778655000 })
+    await expect(userdate2.validate({ amount: '' })).resolves.toEqual({ amount: null })
+    await expect(userdate2.validate({ amount: null })).resolves.toEqual({ amount: null })
+    await expect(userdate.validate({ amount: 'badnum' })).rejects.toEqual([{
       status: '400',
-      title: 'date',
+      title: 'amount',
       detail: 'Value was not a unix timestamp.',
-      meta: { rule: 'isDate', model: 'user', field: 'date' }
-    })
+      meta: { rule: 'isDate', model: 'userdate', field: 'amount' }
+    }])
+    await expect(userdate.validate({ amount: false })).rejects.toEqual([{
+      status: '400',
+      title: 'amount',
+      detail: 'Value was not a unix timestamp.',
+      meta: { rule: 'isDate', model: 'userdate', field: 'amount' }
+    }])
+    await expect(userdate.validate({ amount: undefined })).rejects.toEqual([{
+      status: '400',
+      title: 'amount',
+      detail: 'This field is required.',
+      meta: { rule: 'required', model: 'userdate', field: 'amount' },
+    }])
+    await expect(userdate.validate({ amount: null })).rejects.toEqual([{
+      status: '400',
+      title: 'amount',
+      detail: 'This field is required.',
+      meta: { rule: 'required', model: 'userdate', field: 'amount' },
+    }])
+
 
     // Type error (number)
     let usernum = db.model('usernum', { fields: { amount: { type: 'number', required: true }}})
     let usernum2 = db.model('usernum2', { fields: { amount: { type: 'number' }}})
     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: '1646778655000' })).resolves.toEqual({ amount: 1646778655000 })
     await expect(usernum2.validate({ amount: '' })).resolves.toEqual({ amount: null })
+    await expect(usernum2.validate({ amount: null })).resolves.toEqual({ amount: null })
+    await expect(usernum.validate({ amount: 'badnum' })).rejects.toEqual([{
+      status: '400',
+      title: 'amount',
+      detail: 'Value was not a number.',
+      meta: { rule: 'isNumber', model: 'usernum', field: 'amount' }
+    }])
     await expect(usernum.validate({ amount: false })).rejects.toEqual([{
       status: '400',
       title: 'amount',