monastery 1.28.0 → 1.28.1

package/docs/readme.md

@@ -71,6 +71,12 @@ $ DEBUG=monastery:info
 $ DEBUG=monastery:*
 ```
 
+To run isolated tests with Jest:
+
+```bash
+npm run dev -- -t 'Model indexes'
+```
+
 ## Contributing
 
 Coming soon...

package/docs/schema.md

@@ -173,13 +173,13 @@ You are able to define custom validation rules to use. (`this` will refer to the
 ```js
 schema.rules = {
   // Basic definition
-  isGrandMaster: function(value, ruleArgument, fieldName, model) {
+  isGrandMaster: function(value, ruleArgument, path, model) {
     return (value == 'Martin Luther')? true : false
   },
   // Full definition
   isGrandMaster: {
-    message: (value, ruleArgument, fieldName, model) => 'Only grand masters are permitted'
-    fn: function(value, ruleArgument, fieldName, model) {
+    message: (value, ruleArgument, path, model) => 'Only grand masters are permitted'
+    fn: function(value, ruleArgument, path, model) {
       return (value == 'Martin Luther' || this.age > 100)? true : false
     }
   }
@@ -214,7 +214,7 @@ schema.messages = {
     type: 'Sorry, your name needs to be a string'
   },
   'address.city': {
-    minLength: (value, ruleArgument, fieldName, model) => {
+    minLength: (value, ruleArgument, path, model) => {
       return `Is your city of residence really only ${ruleArgument} characters long?`
     }
   },

package/lib/model-validate.js

@@ -259,9 +259,10 @@ module.exports = {
     let ruleMessage = ruleMessageKey && this.messages[ruleMessageKey][ruleName]
     if (!ruleMessage) ruleMessage = rule.message
 
+
     if (ruleName !== 'required') {
       // Ignore undefined when not testing 'required'
-      if (typeof value === 'undefined') return
+      if (typeof value === 'undefined') return ////////////////////////////////////////
 
       // Ignore null if not testing required
       if (value === null && !field.isObject && !field.isArray) return

package/lib/model.js

@@ -6,10 +6,11 @@ let validate = require('./model-validate')
 let Model = module.exports = function(name, opts, manager) {
   /**
    * Setup a model (aka monk collection)
-   * Todo: convert into a promise
    * @param {string} name
    * @param {object} opts - see mongodb colleciton documentation
-   * @this Model
+   * @param {boolean} opts.waitForIndexes
+   * @this model
+   * @return Promise(model) | this
    */
   if (!(this instanceof Model)) {
     return new Model(name, opts, this)
@@ -25,10 +26,6 @@ let Model = module.exports = function(name, opts, manager) {
   opts = opts || {}
   Object.assign(this, {
     ...(opts.methods || {}),
-    name: name,
-    manager: manager,
-    error: manager.error,
-    info: manager.info,
     afterFind: opts.afterFind || [],
     afterInsert: (opts.afterInsert || []).concat(opts.afterInsertUpdate || []),
     afterUpdate: (opts.afterUpdate || []).concat(opts.afterInsertUpdate || []),
@@ -37,12 +34,16 @@ let Model = module.exports = function(name, opts, manager) {
     beforeUpdate: (opts.beforeUpdate || []).concat(opts.beforeInsertUpdate || []),
     beforeRemove: opts.beforeRemove || [],
     beforeValidate: opts.beforeValidate || [],
-    findBL: opts.findBL || ['password'],
+    error: manager.error,
+    info: manager.info,
     insertBL: opts.insertBL || [],
-    updateBL: opts.updateBL || [],
-    messages: opts.messages || {},
     fields: { ...(util.deepCopy(opts.fields) || {}) },
-    rules: { ...(opts.rules || {}) }
+    findBL: opts.findBL || ['password'],
+    manager: manager,
+    messages: opts.messages || {},
+    name: name,
+    rules: { ...(opts.rules || {}) },
+    updateBL: opts.updateBL || [],
   })
 
   // Run before model hooks
@@ -94,13 +95,13 @@ let Model = module.exports = function(name, opts, manager) {
   // Add model to manager.model
   this.manager.model[name] = this
 
-  // Ensure field indexes exist in mongodb
+  // Setup/Ensure field indexes exist in MongoDB
   let errHandler = err => {
     if (err.type == 'info') this.info(err.detail)
     else this.error(err)
   }
-  if (opts.promise) return this._setupIndexes().catch(errHandler)
-  else this._setupIndexes().catch(errHandler)
+  if (opts.waitForIndexes) return this._setupIndexes().catch(errHandler).then(() => this)
+  else this._setupIndexes().catch(errHandler) // returns this
 }
 
 Model.prototype._getFieldlist = function(fields, path) {
@@ -243,7 +244,7 @@ Model.prototype._setupIndexes = function(fields) {
    * @link https://docs.mongodb.com/manual/reference/command/createIndexes/
    * @link https://mongodb.github.io/node-mongodb-native/2.1/api/Collection.html#createIndexes
    * @param {object} <fields>
-   * @return Promise( {array} indexes | {string} error )
+   * @return Promise( {array} indexes ensured | {string} error )
    *
    * MongoDB index structures = [
    *   true =     { name: 'name_1', key: { name: 1 } },
@@ -267,6 +268,7 @@ Model.prototype._setupIndexes = function(fields) {
 
   // Find all indexes
   recurseFields(fields || model.fields, '')
+  // console.log(2, indexes, fields)
   if (hasTextIndex) indexes.push(textIndex)
   if (!indexes.length) return Promise.resolve([]) // No indexes defined
 
@@ -313,6 +315,7 @@ Model.prototype._setupIndexes = function(fields) {
     })
     .then(response => {
       model.info('db index(s) created for ' + model.name)
+      return indexes
     })
 
   function recurseFields(fields, parentPath) {

package/lib/rules.js

@@ -5,6 +5,7 @@ let validator = require('validator')
 module.exports = {
 
   required: {
+    runOnUndefined: true, // integrate
     message: 'This field is required.',
     fn: function(x) {
       if (util.isArray(x) && !x.length) return false
@@ -12,7 +13,7 @@ module.exports = {
     }
   },
 
-  // Rules below ignore null
+  // Type rules below ignore undefined
 
   'isBoolean': {
     message: 'Value was not a boolean.',
@@ -25,12 +26,6 @@ module.exports = {
       return typeof x === 'boolean'
     }
   },
-  'isNotEmptyString': {
-    message: 'Value was an empty string.',
-    fn: function(x) {
-      return x !== ''
-    }
-  },
   'isArray': {
     message: 'Value was not an array.',
     tryParse: function(x) {
@@ -132,6 +127,8 @@ module.exports = {
       return util.isObject(x) && ObjectId.isValid(x)/*x.get_inc*/? true : false
     }
   },
+
+
   'max': {
     message: (x, arg) => 'Value was greater than the configured maximum (' + arg + ')',
     fn: function(x, arg) {
@@ -146,8 +143,16 @@ module.exports = {
       return x >= arg
     }
   },
+  'isNotEmptyString': {
+    message: 'Value was an empty string.',
+    fn: function(x) {
+      return x !== ''
+    }
+  },
+
+  // Rules below ignore undefined & empty strings
+  // (e.g. an empty email field can be saved that isn't required)
 
-  // Rules below ignore null & empty strings
   'enum': {
     ignoreEmptyString: true,
     message: (x, arg) => 'Invalid enum value',
@@ -157,10 +162,10 @@ module.exports = {
       }
     }
   },
-  'hasAgreed': {
-    message: (x, arg) => 'Please agree to the terms and conditions.',
-    fn: function(x, arg) { return !x }
-  },
+  // 'hasAgreed': {
+  //   message: (x, arg) => 'Please agree to the terms and conditions.',
+  //   fn: function(x, arg) { return !x }
+  // },
   'isAfter': {
     ignoreEmptyString: true,
     message: (x, arg) => 'Value was before the configured time (' + arg + ')',

package/package.json

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

package/test/model.js

@@ -116,27 +116,77 @@ module.exports = function(monastery, opendb) {
   })
 
   test('Model indexes', async (done) => {
-    // Setup
     // Need to test different types of indexes
     let db = (await opendb(null)).db
-    let user = db.model('user', {})
-    let user2 = db.model('user2', {})
 
-    // Text index setup
-    let setupIndex1 = await user._setupIndexes({
-      name: { type: 'string', index: 'text' }
+    // Drop previously tested collections
+    if ((await db._db.listCollections().toArray()).find(o => o.name == 'userIndexRaw')) {
+      await db._db.collection('userIndexRaw').drop()
+    }
+    if ((await db._db.listCollections().toArray()).find(o => o.name == 'userIndex')) {
+      await db._db.collection('userIndex').drop()
+    }
+
+    // Unique & text index (after model initialisation, in serial)
+    let userIndexRawModel = db.model('userIndexRaw', {})
+    let setupIndex1 = await userIndexRawModel._setupIndexes({
+      email: { type: 'string', index: 'unique' },
+    })
+    let setupIndex2 = await userIndexRawModel._setupIndexes({
+      name: { type: 'string', index: 'text' },
+    })
+    await expect(db._db.collection('userIndexRaw').indexes()).resolves.toEqual([
+      { v: 2, key: { _id: 1 }, name: '_id_' },
+      { v: 2, unique: true, key: { email: 1 }, name: 'email_1' },
+      {
+        v: 2,
+        key: { _fts: 'text', _ftsx: 1 },
+        name: 'text',
+        weights: { name: 1 },
+        default_language: 'english',
+        language_override: 'language',
+        textIndexVersion: 3
+      }
+    ])
+
+    // Unique & text index
+    let userIndexModel = await db.model('userIndex', {
+      waitForIndexes: true,
+      fields: {
+        email: { type: 'string', index: 'unique' },
+        name: { type: 'string', index: 'text' },
+      }
     })
+    await expect(db._db.collection('userIndex').indexes()).resolves.toEqual([
+      { v: 2, key: { _id: 1 }, name: '_id_' },
+      { v: 2, unique: true, key: { email: 1 }, name: 'email_1' },
+      {
+        v: 2,
+        key: { _fts: 'text', _ftsx: 1 },
+        name: 'text',
+        weights: { name: 1 },
+        default_language: 'english',
+        language_override: 'language',
+        textIndexVersion: 3
+      }
+    ])
 
     // No text index change error, i.e. new Error("Index with name: text already exists with different options")
-    await expect(user._setupIndexes({
+    await expect(userIndexModel._setupIndexes({
       name: { type: 'string', index: 'text' },
       name2: { type: 'string', index: 'text' }
-    })).resolves.toEqual(undefined)
+    })).resolves.toEqual([{
+      "key": { "name": "text", "name2": "text" },
+      "name": "text",
+    }])
 
     // Text index on a different model
-    await expect(user2._setupIndexes({
-      name: { type: 'string', index: 'text' }
-    })).resolves.toEqual(undefined)
+    await expect(userIndexRawModel._setupIndexes({
+      name2: { type: 'string', index: 'text' }
+    })).resolves.toEqual([{
+      "key": {"name2": "text"},
+      "name": "text",
+    }])
 
     db.close()
     done()
@@ -147,7 +197,7 @@ module.exports = function(monastery, opendb) {
     // with text indexes are setup at the same time
     let db = (await opendb(null)).db
     await db.model('user3', {
-      promise: true,
+      waitForIndexes: true,
       fields: {
         location: {
           index: '2dsphere',