monastery 3.3.0 → 3.4.0

package/test/crud.js

@@ -663,7 +663,7 @@ test('update operators', async () => {
   expect(beforeValidateHookCalled).toEqual(false)
 })
 
-test('update mixing formData', async() => {
+test('update mixing data structures (bracket notation and objects)', async() => {
   // Mixing data
   let consignment = db.model('consignment', {
     fields: {
@@ -1373,4 +1373,131 @@ test('hooks > async and next conflict', async () => {
   expect(logSpy).toHaveBeenCalledWith('Monastery user.afterFind error: you cannot return a promise AND call next()')
 
   db2.close()
+})
+
+test('hooks > option skipHooks', async () => {
+  let user = db.model('user_crud_skiphooks', {
+    fields: {
+      name: { type: 'string' },
+    },
+    beforeInsert: [async (data) => {
+      data.name = 'Hooked ' + data.name
+      return data
+    }],
+    beforeUpdate: [async (data) => {
+      data.name = 'Hooked ' + data.name
+      return data
+    }],
+  })
+
+  // Insert with hooks
+  let inserted = await user.insert({ data: { name: 'Martin Luther' } })
+  expect(inserted).toEqual({
+    _id: expect.any(Object),
+    name: 'Hooked Martin Luther',
+  })
+
+  // Update with hooks (use $set in this case)
+  let updated = await user.update({
+    query: inserted._id,
+    $set: { name: 'Updated Name' },
+  })
+  expect(updated).toEqual({
+    name: 'Hooked Updated Name',
+  })
+
+  // Insert with skipHooks option
+  let insertedSkipHooks = await user.insert({
+    data: { name: 'Skipped Hooks Name' },
+    skipHooks: true,
+  })
+  expect(insertedSkipHooks).toEqual({
+    _id: expect.any(Object),
+    name: 'Skipped Hooks Name',
+  })
+
+  // Update with skipHooks option
+  let updatedSkipHooks = await user.update({
+    query: inserted._id,
+    $set: { name: 'Skipped Hooks Name Updated' },
+    skipHooks: true,
+  })
+  expect(updatedSkipHooks).toEqual({
+    name: 'Skipped Hooks Name Updated',
+  })
+})
+
+test('update set and unset with option skipValidation', async () => {
+  const db2 = monastery('127.0.0.1/monastery', { timestamps: false })
+  let user = db2.model('user_set_and_unset', { 
+    fields: {
+      profile: {
+        name: { type: 'string', required: true },
+        age: { type: 'number' },
+      },
+    },
+  })
+
+  // Insert a document to update
+  let inserted = await user.insert({ data: { profile: { name: 'John Doe', age: 30 } } })
+  let userId = inserted._id
+  let error = (detail, title) => [{ 
+    detail: detail, 
+    title: title || expect.any(String), 
+    meta: expect.any(Object), 
+    status: '400',
+  }]
+
+  // --- $set/data ---
+
+  // $set with skipValidation: undefined (true)
+  const u1 = { query: userId, $set: { 'profile.age': 'not a number' } }
+  await expect(user.update(u1)).resolves.toEqual({ 'profile.age': 'not a number' })
+  await expect(user.findOne(userId)).resolves.toEqual({ _id: userId, profile: { name: 'John Doe', age: 'not a number' } })
+
+  // data with skipValidation: undefined (false)
+  const u11 = { query: userId, data: { 'profile.age': 'not a number' } }
+  await expect(user.update(u11)).rejects.toEqual(error('Value was not a number.', 'profile.age'))
+
+  for (let key of ['$set', 'data']) {
+    // $set with skipValidation: true
+    const u2 = { query: userId, [key]: { 'profile.age': 'not a number2' }, skipValidation: true }
+    await expect(user.update(u2)).resolves.toEqual({ 'profile.age': 'not a number2' })
+
+    // $set with skipValidation: false
+    const u3 = { query: userId, [key]: { 'profile.age': '8' }, skipValidation: false }
+    await expect(user.update(u3)).resolves.toEqual({ 'profile.age': 8 })
+    await expect(user.findOne(userId)).resolves.toEqual({ _id: userId, profile: { name: 'John Doe', age: 8 } })
+
+    // $set error with skipValidation: false
+    const u4 = { query: userId, [key]: { 'profile.age': 'not a number' }, skipValidation: false }
+    await expect(user.update(u4)).rejects.toEqual(error('Value was not a number.', 'profile.age'))
+
+    // $set error with skipValidation: ['profile']
+    const u6 = { query: userId, [key]: { 'profile.age': 'not a number4' }, skipValidation: ['profile'] }
+    await expect(user.update(u6)).resolves.toEqual({ 'profile.age': 'not a number4' })
+  }
+
+  // --- $unset ---
+
+  // $unset with skipValidation: undefined
+  const u7 = { query: userId, $unset: { 'profile.age': '' } }
+  await expect(user.update(u7)).resolves.toEqual({}) // returns empty object
+  await expect(user.findOne(userId)).resolves.toEqual({ _id: userId, profile: { name: 'John Doe' } })
+
+  // $unset error with skipValidation: false
+  const u9 = { query: userId, $unset: { 'profile.name': '' }, skipValidation: false }
+  await expect(user.update(u9)).rejects.toEqual(error('This field is required.', 'profile.name'))
+  await expect(user.findOne(userId)).resolves.toEqual({ _id: userId, profile: { name: 'John Doe' } })
+
+  // $unset error with skipValidation: ['profile.name']
+  const u10 = { query: userId, $unset: { 'profile.name': '' }, skipValidation: ['profile.name'] }
+  await expect(user.update(u10)).resolves.toEqual({}) // returns empty object
+  await expect(user.findOne(userId)).resolves.toEqual({ _id: userId, profile: {} }) /////////unseeeet
+
+  // $unset with skipValidation: true
+  await expect(user.update({ query: userId, $set: { 'profile.name': 'John Doe2' } })) // add age back
+  const u8 = { query: userId, $unset: { 'profile.name': '' }, skipValidation: true }
+  await expect(user.update(u8)).resolves.toEqual({})
+  await expect(user.findOne(userId)).resolves.toEqual({ _id: userId, profile: {} })
 })

package/test/util.js

@@ -1,32 +1,247 @@
 const util = require('../lib/util.js')
 const monastery = require('../lib/index.js')
 
-test('util > formdata', async () => {
-  expect(await util.parseFormData({
+test('util > parseDotNotation', async () => {
+  const input = {
     'name': 'Martin',
-    'pets[]': '',
-    'deep[companyLogo]': 'a',
-    'deep[companyLogos][0]': 'b',
-    'deep[companyLogos2][0][logo]':'c',
-    'deep[companyLogos2][1][logo]': '',
-    'users[0][first]': 'Martin',
-    'users[0][last]': 'Luther',
-    'users[1][first]': 'Bruce',
-    'users[1][last]': 'Lee',
-  })).toEqual({
+    'deep.companyLogo1': 'a',
+    // not dot notation
+    'specialInstructions': [
+      {
+        text: 'POD added by driver',
+        createdAt: 1653603212886,
+        updatedByName: 'Paul Driver 3',
+        importance: 'low',
+      }, {
+        text: 'filler',
+        createdAt: 1653601752472,
+        updatedByName: 'Paul',
+        importance: 'low',
+      },
+    ],
+    // Fields below are not dot notation, but should still be kept, in order.
+    'specialInstructions[0][text]': 'filler',
+    'specialInstructions[0][createdAt]': 1653601752472,
+    'specialInstructions[0][updatedByName]': 'Paul',
+    'specialInstructions[0][importance]': 'low',
+    // should override above
+    'deep': {
+      companyLogo2: 'b',
+      companyLogo3: 'b',
+    },
+    // should be added into above
+    'deep.companyLogo3': 'c',
+    'deep.companyLogos.0.logo': 'd',
+    'deep.companyLogos.1.logo': 'e',
+    'deep.companyLogos.2': 'f',
+  }
+  const output = {
     name: 'Martin',
-    pets: expect.any(Array),
-    deep: {
-      companyLogo: 'a',
-      companyLogos: ['b'],
-      companyLogos2: [{ logo: 'c' }, { logo: '' }],
+    deep: { // object first seen here
+      companyLogo2: 'b',
+      companyLogo3: 'c',
+      companyLogos: [{ logo: 'd' }, { logo: 'e' }, 'f'],
     },
-    users: [
-      { 'first': 'Martin', 'last': 'Luther' },
-      { 'first': 'Bruce', 'last': 'Lee' },
+    specialInstructions: [
+      {
+        text: 'POD added by driver',
+        createdAt: 1653603212886,
+        updatedByName: 'Paul Driver 3',
+        importance: 'low',
+      }, {
+        text: 'filler',
+        createdAt: 1653601752472,
+        updatedByName: 'Paul',
+        importance: 'low',
+      },
     ],
-  })
-  expect(() => util.parseFormData({ 'users[][\'name\']': 'Martin' })).toThrow(
+    'specialInstructions[0][text]': 'filler',
+    'specialInstructions[0][createdAt]': 1653601752472,
+    'specialInstructions[0][updatedByName]': 'Paul',
+    'specialInstructions[0][importance]': 'low',
+  }
+
+  // parseDotNotation output
+  expect(util.parseDotNotation(input)).toEqual(output)
+
+  // expected order of keys
+  expect(Object.keys(output)).toEqual([
+    'name',
+    'deep',
+    'specialInstructions',
+    'specialInstructions[0][text]',
+    'specialInstructions[0][createdAt]',
+    'specialInstructions[0][updatedByName]',
+    'specialInstructions[0][importance]',
+  ])
+
+})
+
+test('util > parseBracketNotation', async () => {
+  const input = {
+    'name': 'Martin',
+    // 'pets[]': '', // <-- no longer supported
+    'deep[companyLogo1]': 'a',
+    // not dot notation
+    'specialInstructions': [
+      {
+        text: 'POD added by driver',
+        createdAt: 1653603212886,
+        updatedByName: 'Paul Driver 3',
+        importance: 'low',
+      }, {
+        text: 'filler',
+        createdAt: 1653601752472,
+        updatedByName: 'Paul',
+        importance: 'low',
+      },
+    ],
+    // Fields below are not bracket notation, but should still be kept, in order.
+    'specialInstructions.0.text': 'filler',
+    'specialInstructions.0.createdAt': 1653601752472,
+    'specialInstructions.0.updatedByName': 'Paul',
+    'specialInstructions.0.importance': 'low',
+    // should override above
+    'deep': {
+      companyLogo2: 'b',
+      companyLogo3: 'b',
+    },
+    // should be added into above
+    'deep[companyLogo3]': 'c',
+    'deep[companyLogos][0][logo]': 'd',
+    'deep[companyLogos][1][logo]': 'e',
+    'deep[companyLogos][2]': 'f',
+  }
+  const output = {
+    name: 'Martin',
+    // pets: expect.any(Array),
+    deep: { // object first seen here
+      companyLogo2: 'b',
+      companyLogo3: 'c',
+      companyLogos: [{ logo: 'd' }, { logo: 'e' }, 'f'],
+    },
+    specialInstructions: [
+      {
+        text: 'POD added by driver',
+        createdAt: 1653603212886,
+        updatedByName: 'Paul Driver 3',
+        importance: 'low',
+      }, {
+        text: 'filler',
+        createdAt: 1653601752472,
+        updatedByName: 'Paul',
+        importance: 'low',
+      },
+    ],
+    'specialInstructions.0.text': 'filler',
+    'specialInstructions.0.createdAt': 1653601752472,
+    'specialInstructions.0.updatedByName': 'Paul',
+    'specialInstructions.0.importance': 'low',
+  }
+
+  // parseBracketNotation output
+  expect(util.parseBracketNotation(input)).toEqual(output)
+
+  // expected order of keys
+  expect(Object.keys(output)).toEqual([
+    'name',
+    'deep',
+    'specialInstructions',
+    'specialInstructions.0.text',
+    'specialInstructions.0.createdAt',
+    'specialInstructions.0.updatedByName',
+    'specialInstructions.0.importance',
+  ])
+
+  expect(() => util.parseBracketNotation({ 'users[][\'name\']': 'Martin' })).toThrow(
+    'Monastery: Array items in bracket notation need array indexes "users[][\'name\']", e.g. users[0][name]'
+  )
+})
+
+test('util > parseBracketToDotNotation', async () => {
+  const input = {
+    'name': 'Martin',
+    'deep[companyLogo1]': 'a',
+    // not dot notation
+    'specialInstructions': [
+      {
+        text: 'POD added by driver',
+        createdAt: 1653603212886,
+        updatedByName: 'Paul Driver 3',
+        importance: 'low',
+      }, {
+        text: 'filler',
+        createdAt: 1653601752472,
+        updatedByName: 'Paul',
+        importance: 'low',
+      },
+    ],
+    // Fields below are not bracket notation, but should still be kept, in order.
+    'specialInstructions.0.text': 'filler',
+    'specialInstructions.0.createdAt': 1653601752472,
+    'specialInstructions.0.updatedByName': 'Paul',
+    'specialInstructions.0.importance': 'low',
+    // should NOT override above
+    'deep': {
+      companyLogo2: 'b',
+      companyLogo3: 'b',
+    },
+    // should NOT be added into above
+    'deep[companyLogo3]': 'c',
+    'deep[companyLogos][0][logo]': 'd',
+    'deep[companyLogos][1][logo]': 'e',
+    'deep[companyLogos][2]': 'f',
+  }
+  const output = {
+    name: 'Martin',
+    'deep.companyLogo1': 'a',
+    specialInstructions: [
+      {
+        text: 'POD added by driver',
+        createdAt: 1653603212886,
+        updatedByName: 'Paul Driver 3',
+        importance: 'low',
+      }, {
+        text: 'filler',
+        createdAt: 1653601752472,
+        updatedByName: 'Paul',
+        importance: 'low',
+      },
+    ],
+    'specialInstructions.0.text': 'filler',
+    'specialInstructions.0.createdAt': 1653601752472,
+    'specialInstructions.0.updatedByName': 'Paul',
+    'specialInstructions.0.importance': 'low',
+    'deep': {
+      companyLogo2: 'b',
+      companyLogo3: 'b',
+    },
+    'deep.companyLogo3': 'c',
+    'deep.companyLogos.0.logo': 'd',
+    'deep.companyLogos.1.logo': 'e',
+    'deep.companyLogos.2': 'f',
+  }
+
+  // parseBracketToDotNotation output
+  expect(util.parseBracketToDotNotation(input)).toEqual(output)
+
+  // expected order of keys
+  expect(Object.keys(output)).toEqual([
+    'name',
+    'deep.companyLogo1',
+    'specialInstructions',
+    'specialInstructions.0.text',
+    'specialInstructions.0.createdAt',
+    'specialInstructions.0.updatedByName',
+    'specialInstructions.0.importance',
+    'deep',
+    'deep.companyLogo3',
+    'deep.companyLogos.0.logo',
+    'deep.companyLogos.1.logo',
+    'deep.companyLogos.2',
+  ])
+
+  expect(() => util.parseBracketToDotNotation({ 'users[][\'name\']': 'Martin' })).toThrow(
     'Monastery: Array items in bracket notation need array indexes "users[][\'name\']", e.g. users[0][name]'
   )
 })

package/test/validate.js

@@ -300,7 +300,7 @@ test('validation subdocument errors', async () => {
     ])
   )
 
-  // Insert: Ignore required subdocument property with a defined parent
+  // Insert: Required subdocument property is ignored with a parent/grandparent specificed
   await expect(user.validate({ animals: {} }, { validateUndefined: false })).resolves.toEqual({
     animals: {},
   })
@@ -1181,8 +1181,85 @@ test('validation option validateUndefined', async () => {
     .resolves.toEqual({ names: [{}] })
 })
 
-test('validation hooks', async () => {
-  let user = db.model('user', {
+test('validation update dot notation', async () => {
+  // Only updates the fields that are passed in the data object, similar to $set. They don't 
+  // remove subdocument fields that are not present in the data object.
+  const user = db.model('user_partialUpdate1', {
+    fields: {
+      name: { type: 'string' },
+      address: {
+        city: { type: 'string' },
+        country: { type: 'string' },
+      },
+    },
+  })
+  const user2 = db.model('user_partialUpdate2', {
+    fields: {
+      name: { type: 'string' },
+      address: {
+        city: { type: 'string' },
+        country: { type: 'string', required: true },
+      },
+      books: [{
+        title: { type: 'string', required: true },
+        pages: {
+          count: { type: 'number', required: true },
+        },
+      }],
+    },
+  })
+
+  // Partial validate
+  const validated1 = await user.validate({ 
+    'address.city': 'Berlin2',
+    'address': { city: 'Berlin' }, // preserved
+  })
+  expect(validated1).toEqual({ 
+    'address': { city: 'Berlin' }, 
+    'address.city': 'Berlin2',
+  })
+
+   /// { partialUpdate: true }
+
+  // Order of fields, normal objects are ordered first
+  expect(Object.keys(validated1)).toEqual(['address', 'address.city'])
+
+  // validate (update) throws required error for deep field (as normal)
+  await expect(user2.validate({ 'address': { city: 'Berlin' }}, { update: true }))
+    .rejects.toEqual(expect.any(Array))
+
+  // validate (update) works with dot notatation paths
+  await expect(user2.validate({ 'address.city': 'Berlin2' }, { update: true }))
+    .resolves.toEqual({ 'address.city': 'Berlin2' })
+
+  // validate (insert) still throws required errors, even with dot notatation paths
+  await expect(user2.validate({ 'address.city': 'Berlin2' }))
+    .rejects.toEqual(expect.any(Array))
+
+  // validate (update) works with dot notation array paths, and validates data
+  await expect(user2.validate({ 'books.0.pages.count': '1' }, { update: true }))
+    .resolves.toEqual({ 'books.0.pages.count': 1 })
+
+  // validate (update) works with positional array paths
+  await expect(user2.validate({ 'books.$.pages.count': '2' }, { update: true }))
+    .resolves.toEqual({ 'books.$.pages.count': 2 })
+
+  // Non-field dot notation paths removed
+  await expect(user2.validate({ 'books.0.badfield': 2 }, { update: true }))
+    .resolves.toEqual({})
+
+  // validate (update) should continue on throwing validation errors for dot notation array paths with subdocument values
+  await expect(user2.validate({ 'books.$.pages': {} }, { update: true }))
+    .rejects.toEqual([{
+      'detail': 'This field is required.',
+      'meta': { 'detailLong': undefined, 'field': 'count', 'model': 'user_partialUpdate2', 'rule': 'required' },
+      'status': '400',
+      'title': 'books.$.pages.count',
+    }])
+})
+
+test('validation hooks and option skipHooks', async () => {
+  let user = db.model('user_validation_hooks', {
     fields: {
       first: { type: 'string'},
       last: { type: 'string'},
@@ -1204,6 +1281,7 @@ test('validation hooks', async () => {
   // Catch validate (a)synchronous errors thrown in function or through `next(err)`
   await expect(user.validate({ first: '' })).rejects.toThrow('beforeValidate error 1..')
   await expect(user.validate({ first: 'Martin' })).rejects.toThrow('beforeValidate error 2..')
+  await expect(user.validate({ first: 'Martin' }, { skipHooks: true })).resolves.toEqual({ first: 'Martin' })
   await expect(user.validate({ first: 'Martin', last: 'Luther' })).resolves.toEqual({
     first: 'Martin',
     last: 'Luther',
@@ -1212,6 +1290,10 @@ test('validation hooks', async () => {
   // Catch insert (a)synchronous errors thrown in function or through `next(err)`
   await expect(user.insert({ data: { first: '' } })).rejects.toThrow('beforeValidate error 1..')
   await expect(user.insert({ data: { first: 'Martin' } })).rejects.toThrow('beforeValidate error 2..')
+  await expect(user.insert({ data: { first: 'Martin' }, skipHooks: true })).resolves.toEqual({
+    _id: expect.any(Object),
+    first: 'Martin',
+  })
   await expect(user.insert({ data: { first: 'Martin', last: 'Luther' } })).resolves.toEqual({
     _id: expect.any(Object),
     first: 'Martin',
@@ -1223,6 +1305,8 @@ test('validation hooks', async () => {
     .rejects.toThrow('beforeValidate error 1..')
   await expect(user.update({ query: userDoc._id, data: { first: 'Martin' } }))
     .rejects.toThrow('beforeValidate error 2..')
+  await expect(user.update({ query: userDoc._id, data: { first: 'Martin' }, skipHooks: true }))
+    .resolves.toEqual({ first: 'Martin' })
   await expect(user.update({ query: userDoc._id, data: { first: 'Martin', last: 'Luther' } }))
     .resolves.toEqual({
       first: 'Martin',