monastery 3.2.0 → 3.3.0

package/changelog.md

@@ -2,6 +2,10 @@
 
 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.
 
+## [3.3.0](https://github.com/boycce/monastery/compare/3.2.1...3.3.0) (2024-08-07)
+
+### [3.2.1](https://github.com/boycce/monastery/compare/3.2.0...3.2.1) (2024-08-05)
+
 ## [3.2.0](https://github.com/boycce/monastery/compare/3.1.0...3.2.0) (2024-07-17)
 
 ### [3.1.1](https://github.com/boycce/monastery/compare/3.1.0...3.1.1) (2024-05-27)

package/docs/manager/index.md

@@ -13,11 +13,12 @@ Monastery manager constructor.
 `uri` *(string\|array)*: A [mongo connection string URI](https://www.mongodb.com/docs/v5.0/reference/connection-string/). Replica sets can be an array or comma separated.
 
 [`options`] *(object)*:
-  - [`defaultObjects=false`] *(boolean)*: when [inserting](../model/insert.html#defaults-example), undefined embedded documents and arrays are defined
-  - [`logLevel=2`] *(number)*: 1=errors, 2=warnings, 3=info. You can also use the debug environment variable `DEBUG=monastery:info`
+  - [`defaultObjects=false`] *(boolean)*: when [inserting](../model/insert.html#defaults-example), undefined embedded documents and arrays are defined.
+  - [`logLevel=2`] *(number)*: 1=errors, 2=warnings, 3=info. You can also use the debug environment variable `DEBUG=monastery:info`.
+  - [`noDefaults`] *(boolean\|string\|array)*: after find operations, don't add defaults for any matching paths, e.g. ['pet.name']. You can override this per operation.
   - [`nullObjects=false`] *(boolean)*: embedded documents and arrays can be set to null or an empty string (which gets converted to null). You can override this per field via `nullObject: true`.
-  - [`promise=false`] *(boolean)*: return a promise instead of the manager instance
-  - [`timestamps=true`] *(boolean)*: whether to use [`createdAt` and `updatedAt`](../definition), this can be overridden per operation
+  - [`promise=false`] *(boolean)*: return a promise instead of the manager instance.
+  - [`timestamps=true`] *(boolean)*: whether to use [`createdAt` and `updatedAt`](../definition), this can be overridden per operation.
   - [`useMilliseconds=false`] *(boolean)*: by default the `createdAt` and `updatedAt` fields that get created automatically use unix timestamps in seconds, set this to true to use milliseconds instead.
   - [`mongo options`](https://mongodb.github.io/node-mongodb-native/5.9/interfaces/MongoClientOptions.html)...
 

package/docs/model/update.md

@@ -22,7 +22,17 @@ Update document(s) in a collection and calls model hooks: `beforeUpdate`,  `afte
 
 ### Returns
 
-A promise
+`{Promise<Object>}` A promise that resolves to an object with the updated fields.
+ 
+You can also access the native MongoDB output via `result._output`, a prototype property:
+```js
+{
+  acknowledged: true,
+  modifiedCount: 1,
+  matchedCount: 1,
+  ...
+}
+```
 
 ### Example
 

package/lib/index.js

@@ -38,7 +38,7 @@ function Manager(uri, opts) {
   const mongoOpts = Object.keys(opts||{}).reduce((acc, key) => {
     if (
       ![
-        'databaseName', 'defaultObjects', 'logLevel', 'imagePlugin', 'limit', 'nullObjects',
+        'databaseName', 'defaultObjects', 'logLevel', 'imagePlugin', 'limit', 'noDefaults', 'nullObjects',
         'promise', 'timestamps', 'useMilliseconds',
       ].includes(key)) {
         acc[key] = opts[key]

package/lib/model-crud.js

@@ -531,6 +531,9 @@ Model.prototype._queryObject = async function (opts, type, _one) {
       let order = (opts.sort.match(/:(-?[0-9])/) || [])[1]
       opts.sort = { [name]: parseInt(order || 1) }
     }
+    if (typeof opts.noDefaults == 'undefined' && typeof this.manager.opts.noDefaults != 'undefined') {
+      opts.noDefaults = this.manager.opts.noDefaults
+    }
     if (util.isString(opts.noDefaults)) {
       opts.noDefaults = [opts.noDefaults]
     }   

package/lib/model-validate.js

@@ -140,6 +140,7 @@ Model.prototype._validateFields = function (dataRoot, fields, data, opts, parent
       // Field is a subdocument
       if (schema.isObject) {
         // Object schema errors
+        let res
         const verrors = this._validateRules(dataRoot, schema, value, opts, path)
         if (verrors.length) errors.push(...verrors)
         // Recurse if inserting, value is a subdocument, or a deep property (todo: not dot-notation)
@@ -148,21 +149,22 @@ Model.prototype._validateFields = function (dataRoot, fields, data, opts, parent
           util.isObject(value) ||
           (util.isDefined(opts.validateUndefined) ? opts.validateUndefined : (path||'').indexOf('.') !== -1)
         ) {
-          var res = this._validateFields(dataRoot, field, value, opts, path, path2)
+          res = this._validateFields(dataRoot, field, value, opts, path, path2)
           if (res[0].length) errors.push(...res[0])
         }
         if (util.isDefined(value) && !verrors.length) {
-          data2[indexOrFieldName] = res? res[1] : value
+          data2[indexOrFieldName] = res ? res[1] : value
         }
 
       // Field is an array
       } else if (schema.isArray) {
         // Array schema errors
+        let res2
         const verrors = this._validateRules(dataRoot, schema, value, opts, path)
         if (verrors.length) errors.push(...verrors)
         // Data value is array too
         if (util.isArray(value)) {
-          var res2 = this._validateFields(dataRoot, field, value, opts, path, path2)
+          res2 = this._validateFields(dataRoot, field, value, opts, path, path2)
           if (res2[0].length) errors.push(...res2[0])
         }
         if (util.isDefined(value) && !verrors.length) {
@@ -209,6 +211,8 @@ Model.prototype._validateRules = function (dataRoot, fieldSchema, value, opts, p
   if (opts.skipValidation === true) return []
 
   // Skip validation for a field, takes in to account if a parent has been skipped.
+  // Todo: Maybe we can use model-crud:blacklisted logic? But just allow it to skip all [0-9] paths via '$'
+  // if (!parentPath && fieldName == 'categories') console.timeEnd(i + ' - ' + m + ' - ' + fieldName + ' - 1')/////
   if (opts.skipValidation.length) {
     //console.log(path, field, opts)
     let pathChunks = path.split('.')

package/package.json

@@ -2,7 +2,7 @@
   "name": "monastery",
   "description": "⛪ A simple, straightforward MongoDB ODM",
   "author": "Ricky Boyce",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "license": "MIT",
   "repository": "github:boycce/monastery",
   "homepage": "https://boycce.github.io/monastery/",

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
   })
 })