monastery 1.41.0 → 1.41.2

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.2](https://github.com/boycce/monastery/compare/1.41.1...1.41.2) (2023-10-04)
+
+### [1.41.1](https://github.com/boycce/monastery/compare/1.41.0...1.41.1) (2023-04-17)
+
 ## [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)

package/docs/definition/index.md

@@ -43,15 +43,20 @@ Model definition object.
     pets: [{ // array of embedded documents
       name: { type: 'string' },
       type: { type: 'string' },
-    }]
-    // You can add a rule on the embedded document or array using the following structure
-    pets: {
-      type: [{
+    }],
+    // You can add a rule on an embedded-document/array using the following structure
+    address: {
+      name: { type: 'string' },
+      type: { type: 'string' },
+      schema: { minLength: 1 },
+    },
+    pets: db.arrayWithSchema(
+      [{
         name: { type: 'string' },
         type: { type: 'string' },
       }],
-      minLength: 1,
-    }
+      { minLength: 1 },
+    )
   }
 }
 ```

package/docs/manager/index.md

@@ -30,15 +30,18 @@ A monk manager instance with additional Monastery methods, i.e. `model` `models`
 ### Example
 
 ```js
-const db = require('monastery')('localhost/mydb', options)
+import monastery from 'monastery'
+const db = monastery('localhost/mydb', options)
 ```
 
 ```js
-const db = require('monastery')('localhost/mydb,192.168.1.1') // replica set
+import monastery from 'monastery'
+const db = monastery('localhost/mydb,192.168.1.1') // replica set
 ```
 
 ```js
-require('monastery')('localhost/mydb,192.168.1.1').then((db) => {
+import monastery from 'monastery'
+monastery('localhost/mydb,192.168.1.1').then((db) => {
   // db is the connected instance of the Manager
 }).catch((err) => {
   // error connecting to the database

package/docs/manager/models.md

@@ -9,7 +9,7 @@ Setup model definitions from a folder location
 
 ### Arguments
 
-`path` *(string)*: path to model definitions, the filenames are used as the corresponding model name.
+`path` *(string)*: path to model definitions, the filenames are used as the corresponding model name. Make sure the model definition is exported as the default
 
 ### Returns
 
@@ -23,7 +23,7 @@ db.model.{model-name}
 
 ```js
 // ./models/user.js
-export default {
+export default { // Make sure the model definition is exported as the default
   fields: {
     name: { type: 'string', required: true },
     email: { type: 'email', required: true, index: 'unique' }

package/docs/readme.md

@@ -24,9 +24,11 @@ $ npm install --save monastery
 ## Usage
 
 ```javascript
+import monastery from 'monastery'
+
 // Initialise a monastery manager
-const db = require('monastery')('localhost/mydb')
-// const db = require('monastery')('user:pass@localhost:port/mydb')
+const db = monastery('localhost/mydb')
+// const db = monastery('user:pass@localhost:port/mydb')
 
 // Define a model
 db.model('user', {
@@ -101,6 +103,7 @@ Coming soon...
 - 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)
+- double check await db.model.remove({ query: idfromparam }) doesnt cause issues for null, undefined or '', but continue to allow {}
 
 ## Versions
 

package/lib/index.js

@@ -93,9 +93,17 @@ let models = async function(pathname, waitForIndexes) {
   }
   let filenames = fs.readdirSync(pathname)
   for (let filename of filenames) {
-    let filepath = path.join(pathname, filename)
-    let definition = (await import(filepath)).default
+    // Ignore folders
+    if (!filename.match(/\.[cm]?js$/)) continue
     let name = filename.replace('.js', '')
+    let filepath = path.join(pathname, filename)
+    // We can't use require() here since we need to be able to import both CJS and ES6 modules
+    let definition = (await import(filepath))?.default
+    // When a commonJS project uses babel (e.g. `nodemon -r @babel/register`, similar to `-r esm`), import() 
+    // will return ES6 model definitions in another nested `default` object
+    if (definition?.default) definition = definition.default
+    if (!definition) throw new Error(`The model definition for '${name}' must export a default object`)
+    // Wait for indexes to be created?
     if (waitForIndexes) out[name] = await this.model(name, { ...definition, waitForIndexes })
     else out[name] = this.model(name, definition)
   }

package/lib/model.js

@@ -14,16 +14,18 @@ let Model = module.exports = function(name, opts, manager) {
    */
   if (!(this instanceof Model)) {
     return new Model(name, opts, this)
-
   } else if (!name) {
     throw 'No model name defined'
-
   } else if (name.match(/^_/)) {
     throw 'Model names cannot start with an underscore'
+  } else if (!opts) {
+    throw `No model definition passed for "${name}"`
+  } else if (!opts.fields) {
+    throw `We couldn't find ${name}.fields in the model definition, the model maybe setup ` 
+      + `or exported incorrectly:\n${JSON.stringify(opts, null, 2)}`
   }
 
   // Add schema options
-  opts = opts || {}
   Object.assign(this, {
     ...(opts.methods || {}),
     afterFind: opts.afterFind || [],
@@ -131,25 +133,6 @@ 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

package/lib/util.js

@@ -109,6 +109,8 @@ module.exports = {
 
   isSubdocument: function(value) {
     /**
+     * "are all fields objects/arrays?"
+     * 
      * Is the value a subdocument which contains more fields? Or a just a field definition?
      * @param {object} value - object to check
      *   E.g. isSubdocument = {

package/package.json

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

package/test/model.js

@@ -13,7 +13,7 @@ module.exports = function(monastery, opendb) {
     }})
 
     // no fields defined
-    expect(db.model('user2').fields).toEqual({
+    expect(db.model('user2', { fields: {} }).fields).toEqual({
       createdAt: {
          default: expect.any(Function),
          insertOnly: true,
@@ -68,64 +68,12 @@ 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
 
     // Default fields
-    expect(db.model('user2').fields).toEqual({
+    expect(db.model('user2', { fields: {} }).fields).toEqual({
       createdAt: {
         default: expect.any(Function),
         insertOnly: true,
@@ -167,6 +115,52 @@ module.exports = function(monastery, opendb) {
     })
   })
 
+  test('model setup with schema', async () => {
+    // Setup
+    let db = (await opendb(false)).db
+    let objectSchemaTypeRef = { name: { type: 'string', minLength: 5 } }
+    let user = db.model('user', { 
+      fields: {
+        pet: { ...objectSchemaTypeRef, schema: { virtual: true }}, 
+        pets: db.arrayWithSchema(
+          [objectSchemaTypeRef],
+          { virtual: true },
+        ),
+      }
+    })
+    // Object with schema
+    expect(user.fields.pet).toEqual({
+      name: {
+        type: 'string', 
+        isString: true,
+        minLength: 5,
+      },
+      schema: {
+        type: 'object', 
+        isObject: true,
+        virtual: true,
+      },
+    })
+    // Array with schema
+    expect(user.fields.pets[0]).toEqual({
+      name: {
+        type: 'string', 
+        isString: true,
+        minLength: 5,
+      },
+      schema: {
+        type: 'object', 
+        isObject: true,
+      },
+    })
+    expect(user.fields.pets.schema).toEqual({
+      type: 'array', 
+      isArray: true,
+      virtual: true,
+    })
+  })
+
+
   test('model reserved rules', async () => {
     // Setup
     let db = (await opendb(false, { hideErrors: true })).db // hide debug error
@@ -201,7 +195,7 @@ module.exports = function(monastery, opendb) {
     }
 
     // Unique & text index (after model initialisation, in serial)
-    let userIndexRawModel = db.model('userIndexRaw', {})
+    let userIndexRawModel = db.model('userIndexRaw', {fields: {}})
     await userIndexRawModel._setupIndexes({
       email: { type: 'string', index: 'unique' },
     })

package/test/monk.js

@@ -4,8 +4,8 @@ module.exports = function(monastery, opendb) {
     // Setup
     let db = (await opendb(false)).db
     let monkdb = require('monk')(':badconnection', () => {})
-    db.model('user', {})
-    let modelNamedConnected = db.model('connected', {})
+    db.model('user', { fields: {} })
+    let modelNamedConnected = db.model('connected', { fields: {} })
 
     // Any of our monastery properties already exist on the manager?
     for (let name of ['connected', 'debug', 'log', 'model', 'models']) {