monastery 1.40.4 → 1.41.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.
 
+## [1.41.0](https://github.com/boycce/monastery/compare/1.40.5...1.41.0) (2023-04-16)
+
+### [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)

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/model/remove.md

@@ -13,6 +13,7 @@ Remove document(s) in a collection and calls model hooks: `beforeRemove`,  `afte
 
 - `query` *(object\|id)*: [`MongoDB query document`](https://www.mongodb.com/docs/v4.4/tutorial/query-documents/), or id
 - [`sort`] *(string\|object\|array)*: same as the mongodb option, but  allows for string parsing e.g. 'name', 'name:1'
+- [`multi`] *(boolean)*: set to false remove only the first document that match the query criteria
 - [[`any mongodb option`](http://mongodb.github.io/node-mongodb-native/3.2/api/Collection.html#remove)] *(any)*
 
 [`callback`] *(function)*: pass instead of return a promise

package/docs/readme.md

@@ -100,6 +100,7 @@ Coming soon...
 - 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
+- Remove leading forward slashes from custom image paths (AWS adds this as a seperate folder)
 
 ## Versions
 

package/lib/model.js

@@ -131,6 +131,25 @@ Model.prototype._setupFields = function(fields) {
    * @param {object|array} fields - subsdocument or array
    */
   util.forEach(fields, function(field, fieldName) {
+    // Preprocess type objects
+    if (util.isSchema(field) && typeof field.type == 'object') {
+      if (field.schema) {
+        this.error(`Field "${fieldName}.schema" on model "${this.name}" is ignored when using `
+        + 'object types, simply define the schema fields alongside field.type.')
+        delete fields[fieldName]
+        return
+      }
+      if (util.isSchema(field.type)) {
+        this.error(`"${fieldName}.type" on model "${this.name}" is a schema object, it must be either a ` 
+        + 'string, subdocument or array')
+        delete fields[fieldName]
+        return
+      }
+      let fieldCache = field
+      field = fields[fieldName] = field.type
+      field.schema = util.omit(fieldCache, ['type'])
+    }
+    
     // Schema field
     if (util.isSchema(field)) {
       // No image schema pre-processing done yet by a plugin
@@ -195,7 +214,13 @@ Model.prototype._setupFields = function(fields) {
         field.schema.index = index2dsphere
         delete field.index
       }
-      field.schema = { type: 'object', isObject: true, default: objectDefault, nullObject: nullObject, ...field.schema }
+      field.schema = { 
+        type: 'object', 
+        isObject: true, 
+        default: objectDefault, 
+        nullObject: nullObject, 
+        ...field.schema 
+      }
       this._setupFields(field)
     }
   }, this)

package/package.json

@@ -2,7 +2,7 @@
   "name": "monastery",
   "description": "⛪ A straight forward MongoDB ODM built around Monk",
   "author": "Ricky Boyce",
-  "version": "1.40.4",
+  "version": "1.41.0",
   "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/model.js

@@ -68,6 +68,58 @@ module.exports = function(monastery, opendb) {
     ))
   })
 
+  test('model setup with type object', async () => {
+    // Setup
+    let db = (await opendb(false)).db
+    let user = db.model('user', { fields: {
+      name: { 
+        type: { cat: { type: 'string' }}, // subdocument
+        minLength: 4,
+      },
+      name2: { 
+        type: [{ type: 'string' }], // array
+        minLength: 4,
+      },
+    }})
+
+    // subdocument object type
+    expect(user.fields.name).toEqual({
+      cat: { isString: true, type: 'string' },
+      schema: { isObject: true, type: 'object', minLength: 4 }
+    })
+    // array object type
+    expect(JSON.stringify(user.fields.name2)).toEqual(JSON.stringify(
+      [{ type: 'string', isString: true }]
+    ))
+    expect(user.fields.name2.schema).toEqual({ 
+      type: 'array', 
+      isArray: true,
+      minLength: 4,
+    })
+  })
+
+  test('model setup with invalid schema type object', async () => {
+    // Setup
+    let db = (await opendb(false, { hideErrors: true })).db // hide debug error
+    let user = db.model('user', { fields: {
+      // valid subdocument
+      name: { 
+        type: { type: 'string' },
+      },
+      // schema with invlaid object type
+      name2: { 
+        type: { type: 'string' },
+        minLength: 10,
+      },
+    }})
+
+    expect(user.fields.name).toEqual({
+      type: { isString: true, type: 'string' },
+      schema: { isObject: true, type: 'object' },
+    })
+    expect(user.fields.name2).toEqual(undefined)
+  })
+
   test('model setup with default fields', async () => {
     // Setup
     let db = (await opendb(false, { defaultObjects: true })).db