monastery 1.40.3 → 1.40.5

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.
 
+### [1.40.5](https://github.com/boycce/monastery/compare/1.40.4...1.40.5) (2023-02-22)
+
+### [1.40.4](https://github.com/boycce/monastery/compare/1.40.3...1.40.4) (2022-12-21)
+
 ### [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)

package/docs/image-plugin.md

@@ -43,7 +43,7 @@ let user = db.model('user', {
 })
 ```
 
-Then when inserting or updating a document you need to set `files` to an obkect containing containing your parsed files, [express-fileupload](https://github.com/richardgirges/express-fileupload) works great with an express setup, e.g.
+Then when inserting or updating a document you need to set `options.files` to an object containing your parsed files, [express-fileupload](https://github.com/richardgirges/express-fileupload) works great with an express setup, e.g.
 
 ```js
 user.update({
@@ -53,7 +53,13 @@ user.update({
 })
 ```
 
-When updating, you need to make sure you always pass all of your image objects again back into `data` since any images not found will be removed automatically from your S3 bucket. A nice way to handle image/non-image updates is by appending `?files=true` to your API route calls, e.g.
+### Updating documents
+
+When updating a document with `options.files`, you need to make sure to **always** include previously uploaded file objects in `options.data` otherwise these will be removed automatically from your S3 bucket (via a comparsion check against your previous document). 
+
+You can reuse the image objects (e.g. `{ bucket, data, uid, ... }`) for other file field values on the same document. You can't however copy image objects across documents and collections.
+
+You can skip all file processing by not defining `options.files`. A nice way to sepearte file and non-file updates is by appending ?files=true to your API route calls, e.g.
 
 ```js
 user.update({

package/docs/readme.md

@@ -95,17 +95,12 @@ 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
--
+- Remove leading forward slashes from custom image paths (AWS adds this as a seperate folder)
 
 ## Versions
 

package/lib/model-crud.js

@@ -89,37 +89,13 @@ module.exports = {
           if (util.isObject(item)) {
             lookups.push({ $lookup: item })
           } else {
-            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
+            let modelName = (path.split('.').reduce((o,i) => o[i], this.fields) ||{}).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}: ` +
@@ -127,11 +103,8 @@ module.exports = {
               )
               continue
             }
-            // Convert array into a document for non-array targets
-            if (!arrayTarget) {
-              (opts.addFields = opts.addFields || {})[path] = { '$arrayElemAt': [ '$' + path, 0 ] }
-            }
-            // Create lookup
+            // Populate model (convert array into document & create lookup)
+            (opts.addFields = opts.addFields || {})[path] = { '$arrayElemAt': [ '$' + path, 0 ] }
             lookups.push({ $lookup: {
               from: modelName,
               localField: path,
@@ -529,9 +502,6 @@ 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.3",
+  "version": "1.40.5",
   "license": "MIT",
   "repository": "github:boycce/monastery",
   "homepage": "https://boycce.github.io/monastery/",

package/plugins/images/index.js

@@ -322,7 +322,8 @@ let plugin = module.exports = {
           // valid image-object?
           if (typeof useCount[image.image.uid] == 'undefined') {
             throw `The passed image object for '${image.dataPath}' does not match any pre-existing
-              images saved on this document.`
+              images saved on this document. Make sure that this image dosen't come from another document or 
+              collection, and is indeed saved on this document.`
           // Different image from prexisting image
           } else if (preExistingImage && preExistingImage.image.uid != image.image.uid) {
             useCount[preExistingImage.image.uid]--

package/test/crud.js

@@ -460,7 +460,6 @@ 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
       }
     })
@@ -490,20 +489,18 @@ 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 },
-      pets: { dog: [dog1._id, dog2._id]},
+      pet: { dog: dog1._id }
     })
     await db.dog._update(dog1._id, { $set: { user: user1._id }})
 
     let find1 = await db.user.findOne({
       query: user1._id,
-      populate: ['pet.dog', 'pets.dog', {
+      populate: ['pet.dog', {
         from: 'dog',
         localField: '_id',
         foreignField: 'user',
@@ -519,25 +516,19 @@ 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', 'pets.dog', {
+      populate: ['pet.dog', {
         from: 'dog',
         localField: '_id',
         foreignField: 'user',
-        as: 'dogs',
+        as: 'dogs'
       }],
-      blacklist: ['address', 'addresses.country', 'pets.dog.name', 'dogs.name'],
+      blacklist: ['address', 'addresses.country', 'dogs.name']
       // ^ great test (address should cancel addresses if not stopping at the .)
     })
     expect(find2).toEqual({
@@ -545,20 +536,14 @@ 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 }],
-      pets: {
-        dog: [
-          { _id: dog1._id, user: user1._id }, //////////////////get this working
-          { _id: dog2._id },
-        ]
-      },
+      dogs: [{ _id: dog1._id, user: user1._id }]
     })
 
     db.close()
   })
 
   test('findOneAndUpdate general', async () => {
-    // todo: test all findOneAndUpdate options (e.g. array population)
+    // todo: test all findOneAndUpdate options
     // todo: test find & update hooks
     let db = (await opendb(null)).db
     let dog = db.model('dog', {

package/test/populate.js

@@ -82,78 +82,6 @@ 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: {