monastery 3.2.1 → 3.4.0

package/test/crud.js

@@ -337,41 +337,112 @@ test('find default field blacklisted', async () => {
   })
 })
 
-test('find default field population with noDefaults', async () => {
-  // similar to "find default field population"
-  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' }},
-      pets:  { dog: [{ model: 'dog' }]},
-      dogs: [{ model: 'dog' }], // virtual association
-    },
+test('find default field population with option noDefaults', async () => {
+  async function setup(noDefaults) {
+    /**
+     * Setup
+     * @returns {Object} {dog, user, dog1Doc, dog2Doc, user1Doc}
+     */
+    // similar to "find default field population"
+    const db = monastery('127.0.0.1/monastery', { noDefaults: noDefaults, timestamps: false })
+    const userDefinition = {
+      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' }},
+        pets:  { dog: [{ model: 'dog' }]},
+        dogs: [{ model: 'dog' }], // virtual association
+      },
+    }
+    const dogDefinition = {
+      fields: {
+        name: { type: 'string', default: 'Scruff' },
+        user: { model: 'user' },
+      },
+    }
+    const user = db.model('user', userDefinition)
+    const dog = db.model('dog', dogDefinition)
+
+    // Default field population test
+    // Insert documents (without defaults)
+    let dog1Doc = await dog._insert({})
+    let dog2Doc = await dog._insert({})
+    let user1Doc = await user._insert({
+      addresses: [
+        { city: 'Frankfurt' },
+        { city: 'Christchurch', country: 'New Zealand' },
+      ],
+      pet: { dog: dog1Doc._id },
+      pets: { dog: [dog1Doc._id, dog2Doc._id]},
+    })
+    await dog._update(dog1Doc._id, { $set: { user: user1Doc._id }})
+    return { db, dog, user, dog1Doc, dog2Doc, user1Doc }
+  }
+
+  const s1 = await setup()
+
+  // Test noDefaults = true
+  const find1 = await s1.db.user.findOne({
+    query: s1.user1Doc._id,
+    populate: ['pet.dog', 'pets.dog', {
+      from: 'dog',
+      localField: '_id',
+      foreignField: 'user',
+      as: 'dogs',
+    }],
+    noDefaults: true,
   })
-  db.model('dog', {
-    fields: {
-      name: { type: 'string', default: 'Scruff' },
-      user: { model: 'user' },
+  expect(find1).toEqual({
+    _id: s1.user1Doc._id,
+    addresses: [
+      { city: 'Frankfurt' },
+      { city: 'Christchurch', country: 'New Zealand' },
+    ],
+    pet: { dog: { _id: s1.dog1Doc._id, user: s1.user1Doc._id }},
+    pets: {
+      dog: [
+        { _id: s1.dog1Doc._id, user: s1.user1Doc._id },
+        { _id: s1.dog2Doc._id },
+      ],
     },
+    dogs: [{ _id: s1.dog1Doc._id, user: s1.user1Doc._id }],
   })
 
-  // Default field population test
-  // Insert documents (without defaults)
-  let dog1 = await db.dog._insert({})
-  let dog2 = await db.dog._insert({})
-  let user1 = await db.user._insert({
+  // Test noDefaults = ['dogs', 'pet.dog']
+  const find2 = await s1.db.user.findOne({
+    query: s1.user1Doc._id,
+    populate: ['pet.dog', 'pets.dog', {
+      from: 'dog',
+      localField: '_id',
+      foreignField: 'user',
+      as: 'dogs',
+    }],
+    noDefaults: ['dogs', 'pet.dog'],
+  })
+  expect(find2).toEqual({
+    _id: s1.user1Doc._id,
+    name: 'Martin Luther',
     addresses: [
-      { city: 'Frankfurt' },
+      { city: 'Frankfurt', country: 'Germany' },
       { city: 'Christchurch', country: 'New Zealand' },
     ],
-    pet: { dog: dog1._id },
-    pets: { dog: [dog1._id, dog2._id]},
+    address: { country: 'Germany' },
+    pet: { dog: { _id: s1.dog1Doc._id, user: s1.user1Doc._id }}, // should not have a default name
+    pets: {
+      dog: [
+        { _id: s1.dog1Doc._id, name: 'Scruff', user: s1.user1Doc._id },
+        { _id: s1.dog2Doc._id, name: 'Scruff' },
+      ],
+    },
+    dogs: [{ _id: s1.dog1Doc._id, user: s1.user1Doc._id }], // should not have a default name
   })
-  await db.dog._update(dog1._id, { $set: { user: user1._id }})
 
-  let find1 = await db.user.findOne({
-    query: user1._id,
+  const s2 = await setup(['dogs'])
+
+  // Test noDefaults = true overrides manager option noDefaults = ['dogs']
+  const find3 = await s2.db.user.findOne({
+    query: s2.user1Doc._id,
     populate: ['pet.dog', 'pets.dog', {
       from: 'dog',
       localField: '_id',
@@ -380,50 +451,48 @@ test('find default field population with noDefaults', async () => {
     }],
     noDefaults: true,
   })
-
-  expect(find1).toEqual({
-    _id: user1._id,
+  expect(find3).toEqual({
+    _id: s2.user1Doc._id,
     addresses: [
       { city: 'Frankfurt' },
       { city: 'Christchurch', country: 'New Zealand' },
     ],
-    pet: { dog: { _id: dog1._id, user: user1._id }},
+    pet: { dog: { _id: s2.dog1Doc._id, user: s2.user1Doc._id }},
     pets: {
       dog: [
-        { _id: dog1._id, user: user1._id },
-        { _id: dog2._id },
+        { _id: s2.dog1Doc._id, user: s2.user1Doc._id },
+        { _id: s2.dog2Doc._id },
       ],
     },
-    dogs: [{ _id: dog1._id, user: user1._id }],
+    dogs: [{ _id: s2.dog1Doc._id, user: s2.user1Doc._id }],
   })
 
-  let find2 = await db.user.findOne({
-    query: user1._id,
+  // Test manager option noDefaults = ['dogs']
+  const find4 = await s2.db.user.findOne({
+    query: s2.user1Doc._id,
     populate: ['pet.dog', 'pets.dog', {
       from: 'dog',
       localField: '_id',
       foreignField: 'user',
       as: 'dogs',
     }],
-    noDefaults: ['dogs', 'pet.dog'],
   })
-
-  expect(find2).toEqual({
-    _id: user1._id,
+  expect(find4).toEqual({
+    _id: s2.user1Doc._id,
     name: 'Martin Luther',
     addresses: [
       { city: 'Frankfurt', country: 'Germany' },
       { city: 'Christchurch', country: 'New Zealand' },
     ],
     address: { country: 'Germany' },
-    pet: { dog: { _id: dog1._id, user: user1._id }},
+    pet: { dog: { _id: s2.dog1Doc._id, user: s2.user1Doc._id, name: 'Scruff' }},
     pets: {
       dog: [
-        { _id: dog1._id, name: 'Scruff', user: user1._id },
-        { _id: dog2._id, name: 'Scruff' },
+        { _id: s2.dog1Doc._id, name: 'Scruff', user: s2.user1Doc._id },
+        { _id: s2.dog2Doc._id, name: 'Scruff' },
       ],
     },
-    dogs: [{ _id: dog1._id, user: user1._id }],
+    dogs: [{ _id: s2.dog1Doc._id, user: s2.user1Doc._id }], // should not have a default name
   })
 })
 
@@ -594,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: {
@@ -1304,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]'
   )
 })