monastery 1.40.2 → 1.40.3

package/changelog.md

@@ -2,6 +2,8 @@
 
 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.40.3](https://github.com/boycce/monastery/compare/1.40.2...1.40.3) (2022-12-21)
+
 ### [1.40.2](https://github.com/boycce/monastery/compare/1.40.1...1.40.2) (2022-12-15)
 
 ### [1.40.1](https://github.com/boycce/monastery/compare/1.40.0...1.40.1) (2022-12-14)

package/docs/readme.md

@@ -95,11 +95,17 @@ Coming soon...
 - Automatic embedded document ids/createdAt/updatedAt fields
 - ~~Ability to change ACL default on the manager~~
 - ~~Public db.arrayWithSchema method~~
+- ~~Added support for array population~~
+- Change population warnings into errors
 - Global after/before hooks
 - before hooks can receive a data array, remove this
 - docs: Make the implicit ID query conversion more apparent
 - Split away from Monk (unless updated)
 - Add a warning if an invalid model is referenced in jthe schema
+- Allow rules on image types, e.g. `required`
+- test importing of models
+- Docs: model.methods
+-
 
 ## Versions
 

package/lib/index.js

@@ -1,8 +1,9 @@
 let fs = require('fs')
 let debug = require('debug')
 let monk = require('monk')
-let util = require('./util')
 let path = require('path')
+let rules = require('./rules')
+let util = require('./util')
 
 // Apply monk monkey patches
 monk.manager.prototype.open = require('./monk-monkey-patches').open
@@ -72,6 +73,8 @@ module.exports = function(uri, opts, fn) {
   return manager
 }
 
+module.exports.rules = rules
+
 let arrayWithSchema = function(array, schema) {
   array.schema = schema
   return array

package/lib/model-crud.js

@@ -89,13 +89,37 @@ module.exports = {
           if (util.isObject(item)) {
             lookups.push({ $lookup: item })
           } else {
-            let modelName = (path.split('.').reduce((o,i) => o[i], this.fields) ||{}).model
+            let arrayTarget
+            let arrayCount = 0
+            let schema = path.split('.').reduce((o, i) => {
+              if (util.isArray(o[i])) {
+                arrayCount++
+                arrayTarget = true
+                return o[i][0]
+              } else {
+                arrayTarget = false
+                return o[i]
+              }
+            }, this.fields)
+            let modelName = (schema||{}).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.'
               )
               continue
+            } else if (arrayCount > 1) {
+              this.error(
+                `You cannot populate on array's nested in array's: ${path}: ` +
+                `{ model: "${modelName}" }`
+              )
+              continue
+            } else if (arrayCount == 1 && !arrayTarget) {
+              this.error(
+                `You cannot populate within an array of sub-documents: ${path}: ` +
+                `{ model: "${modelName}" }`
+              )
+              continue
             } else if (!this.manager.model[modelName]) {
               this.error(
                 `The field's model defined in your schema does not exist: ${path}: ` +
@@ -103,8 +127,11 @@ module.exports = {
               )
               continue
             }
-            // Populate model (convert array into document & create lookup)
-            (opts.addFields = opts.addFields || {})[path] = { '$arrayElemAt': [ '$' + path, 0 ] }
+            // Convert array into a document for non-array targets
+            if (!arrayTarget) {
+              (opts.addFields = opts.addFields || {})[path] = { '$arrayElemAt': [ '$' + path, 0 ] }
+            }
+            // Create lookup
             lookups.push({ $lookup: {
               from: modelName,
               localField: path,
@@ -502,6 +529,9 @@ module.exports = {
     let parentModelData = util.toArray(data).map(o => ({ modelName: this.name, dataRef: o }))
     let modelData = this._recurseAndFindModels(this.fields, data).concat(parentModelData)
 
+    // Need to remove ////////////////// make sure blacklist default fields on populated arrays dont show
+    console.log(modelData)
+
     // Loop found model/deep-model data objects, and populate missing default-fields and call afterFind on each
     for (let item of modelData) {
       // Populate missing default fields if data !== null

package/package.json

@@ -2,7 +2,7 @@
   "name": "monastery",
   "description": "⛪ A straight forward MongoDB ODM built around Monk",
   "author": "Ricky Boyce",
-  "version": "1.40.2",
+  "version": "1.40.3",
   "license": "MIT",
   "repository": "github:boycce/monastery",
   "homepage": "https://boycce.github.io/monastery/",

package/test/crud.js

@@ -460,6 +460,7 @@ module.exports = function(monastery, opendb) {
         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
       }
     })
@@ -489,18 +490,20 @@ module.exports = function(monastery, opendb) {
     // Note that addresses.1.country shouldn't be overridden
     // Insert documents (without defaults)
     let dog1 = await db.dog._insert({})
+    let dog2 = await db.dog._insert({})
     let user1 = await db.user._insert({
       addresses: [
         { city: 'Frankfurt' },
         { city: 'Christchurch', country: 'New Zealand' }
       ],
-      pet: { dog: dog1._id }
+      pet: { dog: dog1._id },
+      pets: { dog: [dog1._id, dog2._id]},
     })
     await db.dog._update(dog1._id, { $set: { user: user1._id }})
 
     let find1 = await db.user.findOne({
       query: user1._id,
-      populate: ['pet.dog', {
+      populate: ['pet.dog', 'pets.dog', {
         from: 'dog',
         localField: '_id',
         foreignField: 'user',
@@ -516,19 +519,25 @@ module.exports = function(monastery, opendb) {
       ],
       address: { country: 'Germany' },
       pet: { dog: { _id: dog1._id, name: 'Scruff', user: user1._id }},
+      pets: {
+        dog: [
+          { _id: dog1._id, name: 'Scruff', user: user1._id },
+          { _id: dog2._id, name: 'Scruff' },
+        ]
+      },
       dogs: [{ _id: dog1._id, name: 'Scruff', user: user1._id }]
     })
 
     // Blacklisted default field population test
     let find2 = await db.user.findOne({
       query: user1._id,
-      populate: ['pet.dog', {
+      populate: ['pet.dog', 'pets.dog', {
         from: 'dog',
         localField: '_id',
         foreignField: 'user',
-        as: 'dogs'
+        as: 'dogs',
       }],
-      blacklist: ['address', 'addresses.country', 'dogs.name']
+      blacklist: ['address', 'addresses.country', 'pets.dog.name', 'dogs.name'],
       // ^ great test (address should cancel addresses if not stopping at the .)
     })
     expect(find2).toEqual({
@@ -536,14 +545,20 @@ module.exports = function(monastery, opendb) {
       name: 'Martin Luther',
       addresses: [{ city: 'Frankfurt' }, { city: 'Christchurch' }],
       pet: { dog: { _id: dog1._id, name: 'Scruff', user: user1._id }},
-      dogs: [{ _id: dog1._id, user: user1._id }]
+      dogs: [{ _id: dog1._id, user: user1._id }],
+      pets: {
+        dog: [
+          { _id: dog1._id, user: user1._id }, //////////////////get this working
+          { _id: dog2._id },
+        ]
+      },
     })
 
     db.close()
   })
 
   test('findOneAndUpdate general', async () => {
-    // todo: test all findOneAndUpdate options
+    // todo: test all findOneAndUpdate options (e.g. array population)
     // todo: test find & update hooks
     let db = (await opendb(null)).db
     let dog = db.model('dog', {

package/test/populate.js

@@ -82,6 +82,78 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
+  test('model populate array', async () => {
+    // Setup
+    let db = (await opendb(null)).db
+    let bird = db.model('bird', { fields: {
+      name: { type: 'string' }
+    }})
+    let user = db.model('user', { fields: {
+      birds: [{ model: 'bird' }],
+      animal: { birds: [{ model: 'bird' }] },
+      animals: [{ bird: { model: 'bird' }, num: { type: 'number' } }],
+    }})
+    let bird1 = await bird.insert({ data: { name: 'ponyo' }})
+    let bird2 = await bird.insert({ data: { name: 'jack' }})
+    let bird3 = await bird.insert({ data: { name: 'sophie' }})
+    let user1 = await user.insert({ data: {
+      birds: [bird1._id, bird2._id],
+      animal: { birds: [bird1._id, bird2._id] },
+      animals: [{ bird: bird1._id, num: 1 }, { bird: bird3._id, num: 2 }],
+    }})
+
+    // Array
+    let find1 = await user.findOne({ query: user1._id, populate: ['birds'] })
+    expect(find1).toEqual({
+      _id: user1._id,
+      birds: [
+        { _id: bird1._id, name: 'ponyo' },
+        { _id: bird2._id, name: 'jack' },
+      ],
+      animal: {
+        birds: [bird1._id, bird2._id],
+      },
+      animals: [
+        { bird: bird1._id, num: 1 },
+        { bird: bird3._id, num: 2 },
+      ],
+    })
+
+    // Nested array
+    let find2 = await user.findOne({ query: user1._id, populate: ['animal.birds'] })
+    expect(find2).toEqual({
+      _id: user1._id,
+      birds: [bird1._id, bird2._id],
+      animal: {
+        birds: [
+          { _id: bird1._id, name: 'ponyo' },
+          { _id: bird2._id, name: 'jack' },
+        ],
+      },
+      animals: [
+        { bird: bird1._id, num: 1 },
+        { bird: bird3._id, num: 2 },
+      ],
+    })
+
+    // modelId within an array of subdocuments (won't populate, but show a debug error)
+    user.error = () => {} // hide debug error
+    let find3 = await user.findOne({ query: user1._id, populate: ['animals.bird'] })
+    expect(find3).toEqual({
+      _id: user1._id,
+      birds: [bird1._id, bird2._id],
+      animal: {
+        birds: [bird1._id, bird2._id],
+      },
+      animals: [
+        { bird: bird1._id, num: 1 },
+        { bird: bird3._id, num: 2 },
+      ],
+    })
+
+    db.close()
+  })
+
   test('model populate type=any', async () => {
     let db = (await opendb(null)).db
     db.model('company', { fields: {