monastery 1.31.4 → 1.31.6

package/changelog.md

@@ -2,6 +2,21 @@
 
 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.6](https://github.com/boycce/monastery/compare/1.31.5...1.31.6) (2022-02-25)
+
+
+### Bug Fixes
+
+* added partial unqiue index tests ([ff6f193](https://github.com/boycce/monastery/commit/ff6f1938e333407ee17895873d2b42fa5263d7e3))
+* scripts ([bc32680](https://github.com/boycce/monastery/commit/bc326809098ae24686158a0386fbbd6671d86c98))
+
+### [1.31.5](https://github.com/boycce/monastery/compare/1.31.4...1.31.5) (2022-02-15)
+
+
+### Bug Fixes
+
+* scripts ([417ba13](https://github.com/boycce/monastery/commit/417ba13c1a0862f76fadf97d6d6d063a74e196bd))
+
 ### 1.31.4 (2022-02-15)
 
 

package/docs/schema.md

@@ -166,6 +166,24 @@ await db.user.insert({
 }
 ```
 
+Since unique indexes by default don't allow mutliple documents with `null`, you use a partial index (less performant), e.g.
+
+```js
+
+schema.fields = {
+index: {
+  name: {
+    type: 'string',
+    index: {
+      type: 'unique',
+      partialFilterExpression: {
+        email: { $type: 'string' }
+      }
+    }
+  }
+}
+```
+
 ### Custom validation rules
 
 You are able to define custom validation rules to use. (`this` will refer to the data object passed in)

package/lib/model-crud.js

@@ -9,8 +9,8 @@ module.exports = {
      *     @param {object|array} <opts.data> - documents to insert
      *     @param {array|string|false} <opts.blacklist> - augment schema.insertBL, `false` will remove all blacklisting
      *     @param {boolean} <opts.respond> - automatically call res.json/error (requires opts.req)
-     *     @param {array|string|false} validateUndefined - ignore all required fields during insert, or
-     *         undefined subdocument required fields that have a defined parent/grandparent during update
+     *     @param {array|string|false} validateUndefined - validates all 'required' undefined fields, true by
+     *         default, but false on update
      *     @param {array|string|true} <opts.skipValidation> - skip validation for this field name(s)
      *     @param {boolean} <opts.timestamps> - whether `createdAt` and `updatedAt` are automatically inserted
      *     @param {any} <opts.any> - any mongodb option
@@ -198,8 +198,8 @@ module.exports = {
      *     @param {object} <opts.query> - mongodb query object
      *     @param {object|array} <opts.data> - mongodb document update object(s)
      *     @param {boolean} <opts.respond> - automatically call res.json/error (requires opts.req)
-     *     @param {array|string|false} validateUndefined - ignore all required fields during insert, or
-     *         undefined subdocument required fields that have a defined parent/grandparent during update
+     *     @param {array|string|false} validateUndefined - validates all 'required' undefined fields, true by
+     *         default, but false on update
      *     @param {array|string|true} <opts.skipValidation> - skip validation for this field name(s)
      *     @param {boolean} <opts.timestamps> - whether `updatedAt` is automatically updated
      *     @param {array|string|false} <opts.blacklist> - augment schema.updateBL, `false` will remove all blacklisting

package/lib/model-validate.js

@@ -12,8 +12,8 @@ module.exports = {
      *     @param {boolean(false)} update - are we validating for insert or update?
      *     @param {array|string|false} blacklist - augment schema blacklist, `false` will remove all blacklisting
      *     @param {array|string} projection - only return these fields, ignores blacklist
-     *     @param {array|string|false} validateUndefined - ignore all required fields during insert, or undefined
-     *         subdocument required fields that have a defined parent/grandparent during update
+     *     @param {array|string|false} validateUndefined - validates all 'required' undefined fields, true by
+     *         default, but false on update
      *     @param {array|string|true} skipValidation - skip validation on these fields
      *     @param {boolean} timestamps - whether `createdAt` and `updatedAt` are inserted, or `updatedAt` is
      *         updated, depending on the `options.update` value
@@ -176,11 +176,11 @@ module.exports = {
         } else if (util.isSubdocument(field)) {
           // Object schema errors
           errors.push(...(verrors = this._validateRules(dataRoot, schema, value, opts, path2)))
-          // Recurse if data value is a subdocument, or when inserting, or when updating deep properties (non-root)
+          // Recurse if inserting, value is a subdocument, or a deep property (todo: not dot-notation)
           if (
-            util.isObject(value) ||
             opts.insert ||
-            ((path2||'').match(/\./) && (util.isDefined(opts.validateUndefined) ? opts.validateUndefined : true))
+            util.isObject(value) ||
+            (util.isDefined(opts.validateUndefined) ? opts.validateUndefined : (path2||'').match(/\./))
           ) {
             var res = this._validateFields(dataRoot, field, value, opts, path2)
             errors.push(...res[0])
@@ -260,13 +260,14 @@ module.exports = {
     ruleArg = ruleArg === true? undefined : ruleArg
     let rule = this.rules[ruleName] || rules[ruleName]
     let fieldName = path.match(/[^.]+$/)[0]
+    let isDeepProp = path.match(/\./) // todo: not dot-notation
     let ruleMessageKey = this._getMostSpecificKeyMatchingPath(this.messages, path)
     let ruleMessage = ruleMessageKey && this.messages[ruleMessageKey][ruleName]
-    let validateUndefined = util.isDefined(opts.validateUndefined) ? opts.validateUndefined : rule.validateUndefined
+    let validateUndefined = util.isDefined(opts.validateUndefined) ? opts.validateUndefined : opts.insert || isDeepProp
     if (!ruleMessage) ruleMessage = rule.message
 
-    // Ignore undefined (if updated root property, or ignoring)
-    if (typeof value === 'undefined' && (!validateUndefined || (opts.update && !path.match(/\./)))) return
+    // Undefined value
+    if (typeof value === 'undefined' && (!validateUndefined  || !rule.validateUndefined)) return
 
     // Ignore null (if nullObject is set on objects or arrays)
     if (value === null && (field.isObject || field.isArray) && field.nullObject) return

package/package.json

@@ -2,7 +2,7 @@
   "name": "monastery",
   "description": "⛪ A straight forward MongoDB ODM built around Monk",
   "author": "Ricky Boyce",
-  "version": "1.31.4",
+  "version": "1.31.6",
   "license": "MIT",
   "repository": "github:boycce/monastery",
   "homepage": "https://boycce.github.io/monastery/",
@@ -23,7 +23,7 @@
     "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",
+    "release": "standard-version && npm publish && git push --tags",
     "test": "npm run lint && jest",
     "test-one-example": "jest -t images"
   },

package/test/model.js

@@ -189,6 +189,55 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
+  test('model unique indexes', async () => {
+    let db = (await opendb(null)).db
+    // Setup: Drop previously tested collections
+    if ((await db._db.listCollections().toArray()).find(o => o.name == 'userUniqueIndex')) {
+      await db._db.collection('userUniqueIndex').drop()
+    }
+
+    // Partial unique indexes (allows mulitple null values)
+    await db.model('userUniqueIndex', {
+      waitForIndexes: true,
+      fields: {
+        email: {
+          type: 'string',
+          index: {
+            type: 'unique',
+            partialFilterExpression: {
+              email: { $type: 'string' }
+            }
+          }
+        },
+      }
+    })
+
+    let indexes2 = await db._db.collection('userUniqueIndex').indexes()
+    expect(indexes2[0]).toMatchObject({ v: 2, key: { _id: 1 }, name: '_id_' })
+    expect(indexes2[1]).toMatchObject({ v: 2, unique: true, key: { email: 1 }, name: 'email_1' })
+
+    await expect(db.userUniqueIndex.insert({ data: { 'email': 'ricky@orchid.co.nz' }})).resolves.toEqual({
+      _id: expect.any(Object),
+      email: 'ricky@orchid.co.nz'
+    })
+
+    await expect(db.userUniqueIndex.insert({ data: { 'email': 'ricky@orchid.co.nz' }})).rejects.toThrow(
+      /E11000 duplicate key error collection: monastery.userUniqueIndex index: email_1 dup key: {/
+    )
+
+    await expect(db.userUniqueIndex.insert({ data: { 'email': null }})).resolves.toEqual({
+      _id: expect.any(Object),
+      email: null
+    })
+
+    await expect(db.userUniqueIndex.insert({ data: { 'email': null }})).resolves.toEqual({
+      _id: expect.any(Object),
+      email: null
+    })
+
+    db.close()
+  })
+
   test('model subdocument indexes', async () => {
     // Setup: Need to test different types of indexes
     let db = (await opendb(null)).db

package/test/validate.js

@@ -26,17 +26,18 @@ module.exports = function(monastery, opendb) {
       meta: { rule: 'required', model: 'user', field: 'name' }
     })
 
-    // Required error (insert, and with ignoreRequired)
-    await expect(user.validate({}, { validateUndefined: false })).resolves.toEqual({})
-    await expect(user.validate({}, { validateUndefined: false, update: true })).resolves.toEqual({})
-
     // No required error (update)
     await expect(user.validate({}, { update: true })).resolves.toEqual({})
 
     // Type error (string)
     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: undefined })).rejects.toContainEqual({
+      status: '400',
+      title: 'name',
+      detail: 'This field is required.',
+      meta: { rule: 'required', model: 'user', field: 'name' }
+    })
     await expect(user.validate({ name: null })).rejects.toContainEqual({
       status: '400',
       title: 'name',
@@ -65,20 +66,19 @@ module.exports = function(monastery, opendb) {
     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',
       title: 'amount',
       detail: 'Value was not a number.',
       meta: { rule: 'isNumber', model: 'usernum', field: 'amount' }
     }])
-    await expect(usernum.validate({ amount: null })).rejects.toEqual([{
+    await expect(usernum.validate({ amount: undefined })).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([{
+    await expect(usernum.validate({ amount: null })).rejects.toEqual([{
       status: '400',
       title: 'amount',
       detail: 'This field is required.',
@@ -309,6 +309,41 @@ module.exports = function(monastery, opendb) {
       .rejects.toContainEqual(error)
   })
 
+  test('validation array schema errors', async () => {
+    // Setup
+    let db = (await opendb(false)).db
+    function arrayWithSchema(array, schema) {
+      array.schema = schema
+      return array
+    }
+    let user = db.model('user', { fields: {
+      animals: arrayWithSchema(
+        [{ type: 'string' }],
+        { required: true, minLength: 2 },
+      )
+    }})
+
+    // MinLength error
+    await expect(user.validate({
+      animals: [],
+    })).rejects.toContainEqual({
+      status: '400',
+      title: 'animals',
+      detail: 'This field is required.',
+      meta: { rule: 'required', model: 'user', field: 'animals' }
+    })
+
+    // MinLength error
+    await expect(user.validate({
+      animals: ['dog'],
+    })).rejects.toContainEqual({
+      status: '400',
+      title: 'animals',
+      detail: 'Value needs to contain a minimum of 2 items.',
+      meta: { rule: 'minLength', model: 'user', field: 'animals' }
+    })
+  })
+
   test('validation getMostSpecificKeyMatchingPath', async () => {
     let fn = validate._getMostSpecificKeyMatchingPath
     let mock = {
@@ -870,7 +905,7 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
-  test('validation options', async () => {
+  test('validation option skipValidation', async () => {
     let db = (await opendb(false)).db
     let user = db.model('user', { fields: {
       name: { type: 'string', required: true }
@@ -955,6 +990,66 @@ module.exports = function(monastery, opendb) {
     })
   })
 
+  test('validation option validateUndefined', async () => {
+    // ValidateUndefined runs required rules on all fields, `true` for insert, `false` for update.
+
+    // Setup
+    let db = (await opendb(false)).db
+    let user = db.model('user', { fields: {
+      date: { type: 'number' },
+      name: { type: 'string', required: true },
+    }})
+    let usernum = db.model('usernum', { fields: {
+      amount: { type: 'number', required: true }
+    }})
+    let userdeep = db.model('userdeep', { fields: {
+      date: { type: 'number' },
+      name: {
+        first: { type: 'string', required: true },
+      },
+      names: [{
+        first: { type: 'string', required: true },
+      }]
+    }})
+    let errorRequired = {
+      status: '400',
+      title: 'name',
+      detail: 'This field is required.',
+      meta: expect.any(Object),
+    }
+
+    // Required error for undefined
+    await expect(user.validate({}))
+      .rejects.toEqual([errorRequired])
+    await expect(user.validate({}, { update: true, validateUndefined: true }))
+      .rejects.toEqual([errorRequired])
+    await expect(userdeep.validate({}))
+      .rejects.toEqual([{ ...errorRequired, title: 'name.first' }])
+    await expect(userdeep.validate({ name: {} }, { update: true }))
+      .rejects.toEqual([{ ...errorRequired, title: 'name.first' }])
+    await expect(userdeep.validate({ names: [{}] }, { update: true }))
+      .rejects.toEqual([{ ...errorRequired, title: 'names.0.first' }])
+
+    // Required error for null
+    await expect(user.validate({ name: null }, { update: true }))
+      .rejects.toEqual([errorRequired])
+    await expect(usernum.validate({ amount: null }, { update: true }))
+      .rejects.toEqual([{ ...errorRequired, title: 'amount' }])
+    await expect(user.validate({ name: null }, { update: true, validateUndefined: true }))
+      .rejects.toEqual([errorRequired])
+
+    // Skip required error
+    await expect(user.validate({ name: undefined }, { validateUndefined: false })).resolves.toEqual({})
+    await expect(user.validate({}, { validateUndefined: false })).resolves.toEqual({})
+    await expect(user.validate({}, { update: true })).resolves.toEqual({})
+    await expect(user.validate({}, { update: true, validateUndefined: false })).resolves.toEqual({})
+    await expect(userdeep.validate({}, { update: true })).resolves.toEqual({})
+    await expect(userdeep.validate({ name: {} }, { update: true, validateUndefined: false }))
+      .resolves.toEqual({ name: {} })
+    await expect(userdeep.validate({ names: [{}] }, { update: true, validateUndefined: false }))
+      .resolves.toEqual({ names: [{}] })
+  })
+
   test('validation hooks', async () => {
     let db = (await opendb(null)).db
     let user = db.model('user', {