monastery 1.30.4 → 1.31.3

package/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Changelog
+
+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.31.3 (2022-02-15)
+
+
+### Bug Fixes
+
+* _callAfterFind bug ([e62472c](https://github.com/boycce/monastery/commit/e62472c191119135839b6d9e42b7f060bc7a508d))
+* .eslintrc.json ([5362585](https://github.com/boycce/monastery/commit/53625857bbf798db97eddad9385799cb1ded97e2))
+* docs ([d8f4e15](https://github.com/boycce/monastery/commit/d8f4e15913f672295cc118fda11ec23a412b4c62))
+* docs ([1a5118e](https://github.com/boycce/monastery/commit/1a5118e4b389b55d30bf987991b59638b11613a9))
+* docs ([564572c](https://github.com/boycce/monastery/commit/564572ce33dfb35fdd131e81d1dcc655f024b26e))
+* docs ([12d37d3](https://github.com/boycce/monastery/commit/12d37d3b2d0b5ec577f9ed4deb9c929c8ea52a36))
+* docs and nav links ([0eabcf0](https://github.com/boycce/monastery/commit/0eabcf0cd9a119a6ab1a07b92634e316995a2a83))
+* model-crud ([d421709](https://github.com/boycce/monastery/commit/d421709a70e6611c78e049e98268153c9bafae6d))
+* normalise afterFind ([0ab7f43](https://github.com/boycce/monastery/commit/0ab7f43f25b599e07d9ae751dc3bac8550e53c24))
+* normalised rule arguments and context ([6ba48da](https://github.com/boycce/monastery/commit/6ba48da3b9c643620cebf5442e60bd0318d6780f))
+* package scripts ([f7935af](https://github.com/boycce/monastery/commit/f7935afb0181ddb3e397bf804b34c841589dfcf0))
+* semver ([6f14909](https://github.com/boycce/monastery/commit/6f14909f4405cf26dc04a8603cc3bac232b96798))
+* standard-version ([f553b08](https://github.com/boycce/monastery/commit/f553b08445eb7dd2e85f6bb447e2bb0bc38dda34))
+* util bug, updated tests ([bec1887](https://github.com/boycce/monastery/commit/bec1887f56cb8582b606a066c913c191362a61b0))

package/lib/model-crud.js

@@ -21,14 +21,14 @@ module.exports = {
     opts = opts || {}
     opts.insert = true
     opts.model = this
-    let data = opts.data = opts.data || (opts.req? opts.req.body : {})
+    let req = opts.req
+    let data = opts.data = util.isDefined(opts.data)? opts.data : util.isDefined((req||{}).body) ? req.body : {}
     let options = util.omit(opts, [
       'data', 'insert', 'model', 'respond', 'validateUndefined', 'skipValidation', 'blacklist'
     ])
     if (cb && !util.isFunction(cb)) {
       throw new Error(`The callback passed to ${this.name}.insert() is not a function`)
     }
-
     return util.parseData(data).then(data => {
       opts.data = data
       return this.validate(data, { ...opts })
@@ -124,12 +124,16 @@ module.exports = {
           } else {
             let modelName = (path.split('.').reduce((o,i) => o[i], this.fields) ||{}).model
             if (!modelName) {
-              this.error(`The field "${path}" passed to populate is not of type
-              model. You would need to add the field option e.g. { model: 'comment' } in your schema.`)
+              this.error(
+                `The field "${path}" passed to populate is not of type model. You would ` +
+                'need to add the field option e.g. { model: \'comment\' } in your schema.'
+              )
               continue
             } else if (!this.manager.model[modelName]) {
-              this.error(`The field's model defined in your schema does not exist:
-              ${path}: { model: "${modelName}" }`)
+              this.error(
+                `The field's model defined in your schema does not exist: ${path}: ` +
+                `{ model: "${modelName}" }`
+              )
               continue
             }
             // Populate model (convert array into document & create lookup)
@@ -212,7 +216,8 @@ module.exports = {
       opts = this._queryObject(opts)
       opts.update = true
       opts.model = this
-      data = opts.data = opts.data || (opts.req? opts.req.body : null)
+      let req = opts.req
+      data = opts.data = util.isDefined(opts.data)? opts.data : util.isDefined((req||{}).body) ? req.body : undefined
       operators = util.pluck(opts, [/^\$/])
       // Operation options
       options = util.omit(opts, ['data', 'query', 'respond', 'validateUndefined', 'skipValidation', 'blacklist'])
@@ -224,23 +229,32 @@ module.exports = {
         let order = (options.sort.match(/:(-?[0-9])/) || [])[1]
         options.sort = { [name]: parseInt(order || 1) }
       }
-      if (operators['$set'] && data) {
-        throw new Error(`Please only pass options.$set or options.data to ${this.name}.update()`)
-      }
       util.parseData(data).then(d => resolve(d))
 
     }).then(data => {
       opts.data = data
-      if (util.isEmpty(operators)) return this.validate(data, { ...opts })
+      if (util.isDefined(data)) return this.validate(data, { ...opts })
+      else return Promise.resolve(data)
 
     }).then(data => {
-      if (util.isEmpty(operators) && (!data || util.isEmpty(data))) {
-        throw new Error(`No valid data passed to ${this.name}.update()`)
+      if (util.isDefined(data) && (!data || util.isEmpty(data))) {
+        throw new Error(`No valid data passed to ${this.name}.update({ data: .. })`)
+      }
+      if (!util.isDefined(data) && util.isEmpty(operators)) {
+        throw new Error(`Please pass an update operator to ${this.name}.update(), e.g. data, $unset, etc`)
       }
       return util.runSeries(this.beforeUpdate.map(f => f.bind(opts, data||{}))).then(() => data)
 
     }).then(data => {
-      if (data) operators['$set'] = data
+      if (data && operators['$set']) {
+        this.warn(`'$set' fields take precedence over the data fields for \`${this.name}.update()\``)
+      }
+      if (data || operators['$set']) {
+        operators['$set'] = {
+          ...data,
+          ...(operators['$set'] || {}),
+        }
+      }
       return this._update(opts.query, operators, options).then(output => {
         if (!output.n) return null
         let response = Object.assign(Object.create({ _output: output }), operators['$set']||{})
@@ -377,7 +391,8 @@ module.exports = {
           if (!this._pathInProjection(pathWithoutArrays, projection, true)) return
           // Ignore default
           let value = util.isFunction(schema.default)? schema.default(this.manager) : schema.default
-          util.setDeepValue(item.dataRef, path.replace(/\.0(\.|$)/g, '.$$$1'), value, false, true, true)
+          // console.log(item.dataRef)
+          util.setDeepValue(item.dataRef, path.replace(/\.0(\.|$)/g, '.$$$1'), value, true, false, true)
         })
       }
       // Collect all of the model's afterFind hooks

package/lib/model-validate.js

@@ -140,7 +140,7 @@ module.exports = {
         let value = util.isArray(fields)? data : (data||{})[fieldName]
         let indexOrFieldName = util.isArray(fields)? i : fieldName
         let path2 = `${path}.${indexOrFieldName}`.replace(/^\./, '')
-        let path3 = path2.replace(/(^|\.)[0-9]+(\.|$)/, '$2') // no numirical keys, e.g. pets.1.name
+        let path3 = path2.replace(/(^|\.)[0-9]+(\.|$)/, '$2') // no numerical keys, e.g. pets.1.name
         let isType = 'is' + util.ucFirst(schema.type)
         let isTypeRule = this.rules[isType] || rules[isType]
 
@@ -162,7 +162,7 @@ module.exports = {
         if (opts.update && schema.insertOnly) return
         // Ignore virtual fields
         if (schema.virtual) return
-        // Type cast the value if tryParse is avaliable, .e.g. isInteger.tryParse
+        // Type cast the value if tryParse is available, .e.g. isInteger.tryParse
         if (isTypeRule && util.isFunction(isTypeRule.tryParse)) {
           value = isTypeRule.tryParse.call(dataRoot, value, fieldName, this)
         }

package/lib/model.js

@@ -36,6 +36,7 @@ let Model = module.exports = function(name, opts, manager) {
     beforeValidate: opts.beforeValidate || [],
     error: manager.error,
     info: manager.info,
+    warn: manager.warn,
     insertBL: opts.insertBL || [],
     fields: { ...(util.deepCopy(opts.fields) || {}) },
     findBL: opts.findBL || ['password'],

package/package.json

@@ -2,7 +2,7 @@
   "name": "monastery",
   "description": "⛪ A straight forward MongoDB ODM built around Monk",
   "author": "Ricky Boyce",
-  "version": "1.30.4",
+  "version": "1.31.3",
   "license": "MIT",
   "repository": "github:boycce/monastery",
   "homepage": "https://boycce.github.io/monastery/",
@@ -17,14 +17,15 @@
     "mongo odm"
   ],
   "scripts": {
-    "minor": "standard-version --release-as minor && npm publish",
-    "patch": "standard-version && npm publish",
-    "test": "npm run lint && jest",
-    "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",
-    "mong": "nodemon resources/mong.js"
+    "lint": "eslint ./lib ./plugins ./test",
+    "mong": "nodemon resources/mong.js",
+    "minor": "standard-version --release-as minor && npm publish",
+    "patch": "standard-version --release-as patch && npm publish",
+    "release": "standard-version && npm publish",
+    "test": "npm run lint && jest",
+    "test-one-example": "jest -t images"
   },
   "dependencies": {
     "aws-sdk": "2.1062.0",
@@ -48,8 +49,8 @@
     "releaseCommitMessageFormat": "{{currentTag}}",
     "sign": true,
     "skip": {
-      "changelog": true,
-      "tag": true
+      "changelog": false,
+      "tag": false
     }
   }
 }

package/test/blacklisting.js

@@ -1,6 +1,6 @@
 module.exports = function(monastery, opendb) {
 
-  test('Find blacklisting', async () => {
+  test('find blacklisting', async () => {
     // Setup
     let db = (await opendb(null)).db
     let bird = db.model('bird', {
@@ -152,7 +152,7 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
-  test('Find blacklisting (default fields)', async () => {
+  test('find blacklisting (default fields)', async () => {
     // Setup
     let db = (await opendb(null)).db
     let user = db.model('user', {
@@ -223,7 +223,7 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
-  test('Find blacklisting (populate)', async () => {
+  test('find blacklisting (populate)', async () => {
     // Setup
     let db = (await opendb(null)).db
     let bird = db.model('bird', {
@@ -305,7 +305,7 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
-  test('Insert/update blacklisting (validate)', async () => {
+  test('insert update blacklisting (validate)', async () => {
     // Setup
     let db = (await opendb(null)).db
     let user = db.model('user', {

package/test/crud.js

@@ -2,11 +2,12 @@
 
 module.exports = function(monastery, opendb) {
 
-  test('Basic operator calls', async () => {
+  test('basic operator calls', async () => {
     let db = (await opendb(null)).db
     let user = db.model('user', {
-      fields: { name: { type: 'string' }},
-      beforeValidate: [(data, next) => { beforeValidateHookCalled = true; next() }]
+      fields: {
+        name: { type: 'string' },
+      },
     })
 
     // Insert one
@@ -79,60 +80,6 @@ module.exports = function(monastery, opendb) {
     let findOne3 = await user.findOne(inserted2[0]._id.toString())
     expect(findOne3).toEqual({ _id: inserted2[0]._id, name: 'Martin Luther1' })
 
-    // Update
-    let update = await user.update({
-      query: inserted._id,
-      data: { name: 'Martin Luther2' }
-    })
-    expect(update).toEqual({
-      name: 'Martin Luther2'
-    })
-
-    // Update (no/empty data object)
-    await expect(user.update({ query: inserted._id, data: {}}))
-      .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()')
-
-    // Update (no/empty data object, but has update operators
-    await expect(user.update({ query: inserted._id, $set: { name: 'bruce' }}))
-      .resolves.toEqual({ name: 'bruce' })
-
-    await expect(user.update({ query: inserted._id, $pull: { name: 'bruce' }}))
-      .rejects.toThrow('Cannot apply $pull to a non-array value') // gets passed no valid data check
-
-    // Update (data & $set)
-    await expect(user.update({ query: inserted._id, data: {}, $set: { name: 'bruce' }}))
-      .rejects.toThrow('Please only pass options.$set or options.data to user.update()')
-
-    // Update (with operators. Make sure beforeValidate isn't called)
-    var beforeValidateHookCalled = false
-    await user.update({ query: inserted._id, data: { name: 'bruce' }})
-    expect(beforeValidateHookCalled).toEqual(true)
-    beforeValidateHookCalled = false
-    await user.update({ query: inserted._id, $set: { name: 'bruce' }})
-    expect(beforeValidateHookCalled).toEqual(false)
-
-    // Update multiple
-    await user.update({
-      query: { _id: { $in: [inserted2[0]._id, inserted2[1]._id] }},
-      data: { name: 'Martin Luther3' },
-      multi: true
-    })
-    let findUpdated2 = await user.find({
-      query: { _id: { $in: [inserted2[0]._id, inserted2[1]._id] }}
-    })
-    expect(findUpdated2).toEqual([
-      {
-        _id: expect.any(Object),
-        name: 'Martin Luther3'
-      }, {
-        _id: expect.any(Object),
-        name: 'Martin Luther3'
-      }
-    ])
-
     // Remove
     let remove = await user.remove({ query: inserted._id })
     expect(remove.result).toEqual({ n: 1, ok: 1 })
@@ -140,7 +87,7 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
-  test('Insert defaults', async () => {
+  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: {
@@ -194,6 +141,65 @@ module.exports = function(monastery, opendb) {
     db2.close()
   })
 
+  test('update basics', async () => {
+    let db = (await opendb(null)).db
+    let user = db.model('user', {
+      fields: {
+        name: { type: 'string' },
+      },
+    })
+
+    // Insert
+    let inserted = await user.insert({ data: { name: 'Martin Luther' }})
+    expect(inserted).toEqual({
+      _id: expect.any(Object),
+      name: 'Martin Luther'
+    })
+
+    // Insert multiple
+    let inserted2 = await user.insert({ data: [{ name: 'Martin Luther1' }, { name: 'Martin Luther2' }]})
+    expect(inserted2).toEqual([
+      {
+        _id: expect.any(Object),
+        name: 'Martin Luther1'
+      }, {
+        _id: expect.any(Object),
+        name: 'Martin Luther2'
+      }
+    ])
+
+    // Update
+    await expect(user.update({ query: inserted._id, data: { name: 'Martin Luther2' }}))
+      .resolves.toEqual({ name: 'Martin Luther2' })
+
+    // Update (no/empty data object)
+    await expect(user.update({ query: inserted._id, data: {}}))
+      .rejects.toThrow('No valid data passed to user.update({ data: .. })')
+
+    await expect(user.update({ query: inserted._id }))
+      .rejects.toThrow('Please pass an update operator to user.update(), e.g. data, $unset, etc')
+
+    // Update multiple
+    await user.update({
+      query: { _id: { $in: [inserted2[0]._id, inserted2[1]._id] }},
+      data: { name: 'Martin Luther3' },
+      multi: true
+    })
+    let findUpdated2 = await user.find({
+      query: { _id: { $in: [inserted2[0]._id, inserted2[1]._id] }}
+    })
+    expect(findUpdated2).toEqual([
+      {
+        _id: expect.any(Object),
+        name: 'Martin Luther3'
+      }, {
+        _id: expect.any(Object),
+        name: 'Martin Luther3'
+      }
+    ])
+    db.close()
+  })
+
   test('update defaults', async () => {
     let db = (await opendb(null, { useMilliseconds: true, serverSelectionTimeoutMS: 2000 })).db
     let user = db.model('user', {
@@ -235,7 +241,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({ data: .. })')
 
     // UpdatedAt override (wont work)
     let updated4 = await user.update({
@@ -255,7 +261,51 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
-  test('Insert with id casting', async () => {
+  test('update operators', async () => {
+    let db = (await opendb(null)).db
+    let user = db.model('userOperators', {
+      fields: {
+        name: { type: 'string', minLength: 5 },
+        age: { type: 'number' },
+      },
+      beforeValidate: [(data, next) => { beforeValidateHookCalled = true; next() }]
+    })
+
+    let inserted = await user.insert({
+      data: { name: 'Bruce', age: 12 }
+    })
+
+    // No data object, but has another update operators
+    await expect(user.update({ query: inserted._id, $set: { name: 'bruce' }}))
+      .resolves.toEqual({ name: 'bruce' })
+
+    // Mixing data and $set, and $set skips validation (minLength)
+    await expect(user.update({ query: inserted._id, data: { name: 'bruce2', age: 12 }, $set: { name: 'john' }}))
+      .resolves.toEqual({ age: 12, name: 'john' })
+
+    // Two operators
+    await user.update({ query: inserted._id, $set: { name: 'john' }, $unset: { age: 1 }})
+    await expect(user.findOne({ query: inserted._id })).resolves.toEqual({
+      _id: expect.any(Object),
+      name: 'john',
+    })
+
+    // $pull on a non array (also gets passed no valid data check)
+    await expect(user.update({ query: inserted._id, $pull: { name: 'bruce' }}))
+      .rejects.toThrow('Cannot apply $pull to a non-array value')
+
+    // Non-data operators don't call beforeValidate
+    var beforeValidateHookCalled = false
+    await user.update({ query: inserted._id, data: { name: 'bruce' }})
+    expect(beforeValidateHookCalled).toEqual(true)
+    beforeValidateHookCalled = false
+    await user.update({ query: inserted._id, $set: { name: 'bruce' }})
+    expect(beforeValidateHookCalled).toEqual(false)
+
+    db.close()
+  })
+
+  test('insert with id casting', async () => {
     let db = (await opendb(null)).db
     db.model('company', { fields: {
       name: { type: 'string' }
@@ -279,56 +329,52 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
-  test('Find default field population', async () => {
+  test('find default field population', async () => {
     let db = (await opendb(null)).db
     let user = db.model('user', {
       fields: {
-        name: { type: 'string'},
-        addresses: [{ city: { type: 'string' }, country: { type: 'string' }}],
+        name: { type: 'string', default: 'Martin Luther' },
+        addresses: [{ city: { type: 'string' }, country: { type: 'string', default: 'Germany' } }],
+        address: { country:  { type: 'string', default: 'Germany' }},
         pet:  { dog: { model: 'dog' }},
         dogs: [{ model: 'dog' }], // virtual association
       }
     })
     let dog = db.model('dog', {
       fields: {
-        name: { type: 'string' },
+        name: { type: 'string', default: 'Scruff' },
         user: { model: 'user' }
       }
     })
 
-    // Insert documents and add
-    let inserted = await dog.insert({ data: {} })
-    let inserted2 = await user.insert({ data: {
+    // Default field doesn't override null
+    let nulldoc1 = await dog.insert({ data: { name: null }})
+    let nullfind1 = await dog.findOne({ query: nulldoc1._id })
+    expect(nullfind1).toEqual({ _id: nulldoc1._id, name: null })
+
+    // Default field doesn't override empty string
+    let nulldoc2 = await dog.insert({ data: { name: '' }})
+    let nullfind2 = await dog.findOne({ query: nulldoc2._id })
+    expect(nullfind2).toEqual({ _id: nulldoc2._id, name: '' })
+
+    // Default field overrides undefined
+    let nulldoc3 = await dog.insert({ data: { name: undefined }})
+    let nullfind3 = await dog.findOne({ query: nulldoc3._id })
+    expect(nullfind3).toEqual({ _id: nullfind3._id, name: 'Scruff' })
+
+    // Default field population test
+    // Note that addresses.1.country shouldn't be overriden
+    // Insert documents (without defaults)
+    let inserted = await dog._insert({})
+    let inserted2 = await user._insert({
       addresses: [
         { city: 'Frankfurt' },
         { city: 'Christchurch', country: 'New Zealand' }
       ],
       pet: { dog: inserted._id }
-    }})
-    await dog.update({
-      query: inserted._id,
-      data: { user: inserted2._id }
     })
+    await dog._update(inserted._id, { $set: { user: inserted2._id }})
 
-    // Update models
-    db.model('user', {
-      fields: {
-        name: { type: 'string', default: 'Martin Luther' },
-        addresses: [{ city: { type: 'string' }, country: { type: 'string', default: 'Germany' } }],
-        address: { country:  { type: 'string', default: 'Germany' }},
-        pet:  { dog: { model: 'dog' }},
-        dogs: [{ model: 'dog' }], // virtual association
-      }
-    })
-    db.model('dog', {
-      fields: {
-        name: { type: 'string', default: 'Scruff' },
-        user: { model: 'user' }
-      }
-    })
-
-    // Default field population test
-    // Note that addresses.1.country shouldn't be overriden
     let find1 = await user.findOne({
       query: inserted2._id,
       populate: ['pet.dog', {
@@ -369,7 +415,7 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
-  test('Hooks', async () => {
+  test('hooks', async () => {
     let db = (await opendb(null)).db
     let user = db.model('user', {
       fields: {

package/test/model.js

@@ -1,6 +1,6 @@
 module.exports = function(monastery, opendb) {
 
-  test('Model setup', async () => {
+  test('model setup', async () => {
     // Setup
     let db = (await opendb(false)).db
     let user = db.model('user', { fields: {
@@ -68,7 +68,7 @@ module.exports = function(monastery, opendb) {
     ))
   })
 
-  test('Model setup with default fields', async () => {
+  test('model setup with default fields', async () => {
     // Setup
     let db = (await opendb(false, { defaultObjects: true })).db
 
@@ -90,7 +90,7 @@ module.exports = function(monastery, opendb) {
     })
   })
 
-  test('Model setup with default objects', async () => {
+  test('model setup with default objects', async () => {
     // Setup
     let db = (await opendb(false, { defaultObjects: true })).db
     let user = db.model('user', { fields: {
@@ -115,7 +115,7 @@ module.exports = function(monastery, opendb) {
     })
   })
 
-  test('Model indexes', async () => {
+  test('model indexes', async () => {
     // Setup: Need to test different types of indexes
     let db = (await opendb(null)).db
     // Setup: Drop previously tested collections
@@ -189,7 +189,7 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
-  test('Model subdocument indexes', async () => {
+  test('model subdocument indexes', async () => {
     // Setup: Need to test different types of indexes
     let db = (await opendb(null)).db
     // Setup: Drop previously tested collections
@@ -234,7 +234,7 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
-  test('Model array indexes', async () => {
+  test('model array indexes', async () => {
     // Setup: Need to test different types of indexes
     let db = (await opendb(null)).db
     // Setup: Drop previously tested collections
@@ -279,7 +279,7 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
-  test('Model 2dsphere indexes', async () => {
+  test('model 2dsphere indexes', async () => {
     // Setup. The tested model needs to be unique as race condition issue arises when the same model
     // with text indexes are setup at the same time
     let db = (await opendb(null)).db
@@ -339,7 +339,7 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
-  test('Model findBL, findBLProject', async () => {
+  test('model findBL findBLProject', async () => {
     let db = (await opendb(null)).db
     db.model('bird', { fields: {
       name: { type: 'string' }

package/test/populate.js

@@ -1,6 +1,6 @@
 module.exports = function(monastery, opendb) {
 
-  test('Model populate', async () => {
+  test('model populate', async () => {
     // Setup
     let db = (await opendb(null)).db
     let bird = db.model('bird', { fields: {
@@ -82,7 +82,7 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
-  test('Model populate type=any', async () => {
+  test('model populate type=any', async () => {
     let db = (await opendb(null)).db
     db.model('company', { fields: {
       address: { type: 'any' }
@@ -132,7 +132,7 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
-  test('Model populate/blacklisting via $lookup', async () => {
+  test('model populate or blacklisting via $lookup', async () => {
     // Setup
     let db = (await opendb(null)).db
     let user = db.model('user', {

package/test/util.js

@@ -2,7 +2,7 @@ let util = require('../lib/util')
 
 module.exports = function(monastery, opendb) {
 
-  test('Utilities: formdata', async () => {
+  test('utilities formdata', async () => {
     expect(await util.parseFormData({
       'name': 'Martin',
       'pets[]': '',
@@ -31,7 +31,7 @@ module.exports = function(monastery, opendb) {
       .toEqual('Array items in bracket notation need array indexes "users[][\'name\']", e.g. users[0][name]')
   })
 
-  test('Utilities: isId', async () => {
+  test('utilities isId', async () => {
     let db = (await opendb(false)).db
     expect(db.isId('')).toEqual(false)
     expect(db.isId(1234)).toEqual(false)

package/test/validate.js

@@ -61,8 +61,10 @@ module.exports = function(monastery, opendb) {
 
     // 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(usernum2.validate({ amount: '' })).resolves.toEqual({ amount: null })
     await expect(usernum.validate({ amount: undefined }, { validateUndefined: false })).resolves.toEqual({})
     await expect(usernum.validate({ amount: false })).rejects.toEqual([{
       status: '400',
@@ -116,7 +118,7 @@ module.exports = function(monastery, opendb) {
     })
   })
 
-  test('Validation subdocument errors', async () => {
+  test('validation subdocument errors', async () => {
     // Setup
     let db = (await opendb(false)).db
     let user = db.model('user', { fields: {
@@ -243,7 +245,7 @@ module.exports = function(monastery, opendb) {
     })
   })
 
-  test('Validation array errors', async () => {
+  test('validation array errors', async () => {
     // Setup
     let db = (await opendb(false)).db
     let user = db.model('user', { fields: {
@@ -307,7 +309,7 @@ module.exports = function(monastery, opendb) {
       .rejects.toContainEqual(error)
   })
 
-  test('Validation getMostSpecificKeyMatchingPath', async () => {
+  test('validation getMostSpecificKeyMatchingPath', async () => {
     let fn = validate._getMostSpecificKeyMatchingPath
     let mock = {
       'cats.name': true,
@@ -339,7 +341,7 @@ module.exports = function(monastery, opendb) {
     expect(fn(mock, 'gulls.1')).toEqual('gulls.$')
   })
 
-  test('Validation default messages', async () => {
+  test('validation default messages', async () => {
     // Setup
     let db = (await opendb(false)).db
     let user = db.model('user', {
@@ -391,7 +393,7 @@ module.exports = function(monastery, opendb) {
     })
   })
 
-  test('Validation custom messages', async () => {
+  test('validation custom messages', async () => {
     // Setup
     // Todo: Setup testing for array array subdocument field messages
     let db = (await opendb(false)).db
@@ -433,7 +435,7 @@ module.exports = function(monastery, opendb) {
     })
   })
 
-  test('Validation custom messages for arrays', async () => {
+  test('validation custom messages for arrays', async () => {
     // Setup
     // Todo: Setup testing for array array subdocument field messages
     let db = (await opendb(false)).db
@@ -550,7 +552,7 @@ module.exports = function(monastery, opendb) {
     })
   })
 
-  test('Validation custom rules', async () => {
+  test('validation custom rules', async () => {
     // Setup
     let db = (await opendb(false)).db
     let user = db.model('user', {
@@ -636,7 +638,7 @@ module.exports = function(monastery, opendb) {
     }])
   })
 
-  test('Validated data', async () => {
+  test('validated data', async () => {
     // Setup
     let db = (await opendb(false)).db
     let fields = {
@@ -694,7 +696,7 @@ module.exports = function(monastery, opendb) {
       .resolves.toEqual({ animals: { dogs: [{}] }})
   })
 
-  test('Schema options', async () => {
+  test('schema options', async () => {
     // Setup
     let db = (await opendb(false)).db
     let user = db.model('user', { fields: {
@@ -735,7 +737,7 @@ module.exports = function(monastery, opendb) {
     })
   })
 
-  test('Schema default rules', async () => {
+  test('schema default rules', async () => {
     // Setup
     let db = (await opendb(false)).db
     let user = db.model('user', { fields: {
@@ -816,7 +818,7 @@ module.exports = function(monastery, opendb) {
     await expect(user.validate({ amount: 'bad' })).rejects.toContainEqual(mock2)
   })
 
-  test('Schema default objects', async () => {
+  test('schema default objects', async () => {
     let db = (await opendb(null, {
       timestamps: false,
       defaultObjects: true,
@@ -842,7 +844,7 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
-  test('Schema nullObjects', async () => {
+  test('schema nullObjects', async () => {
     let db = (await opendb(null, {
       timestamps: false,
       nullObjects: true,
@@ -868,7 +870,7 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
-  test('Validation options', async () => {
+  test('validation options', async () => {
     let db = (await opendb(false)).db
     let user = db.model('user', { fields: {
       name: { type: 'string', required: true }
@@ -953,7 +955,7 @@ module.exports = function(monastery, opendb) {
     })
   })
 
-  test('Validation hooks', async () => {
+  test('validation hooks', async () => {
     let db = (await opendb(null)).db
     let user = db.model('user', {
       fields: {

package/test/virtuals.js

@@ -1,6 +1,6 @@
 module.exports = function(monastery, opendb) {
 
-  test('Virtuals', async () => {
+  test('virtuals', async () => {
     // Setup
     let db = (await opendb(null)).db
     // Test model setup
@@ -147,7 +147,7 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
-  test('Insert/update virtuals (validate)', async () => {
+  test('insert update virtuals (validate)', async () => {
     // Setup
     let db = (await opendb(null)).db
     let user = db.model('user', {