monastery 3.0.23 → 3.1.0

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.
 
+## [3.1.0](https://github.com/boycce/monastery/compare/3.0.23...3.1.0) (2024-05-27)
+
 ### [3.0.23](https://github.com/boycce/monastery/compare/3.0.22...3.0.23) (2024-05-25)
 
 ### [3.0.22](https://github.com/boycce/monastery/compare/3.0.21...3.0.22) (2024-05-08)

package/lib/model-validate.js

@@ -91,6 +91,7 @@ Model.prototype._validateFields = function (dataRoot, fields, data, opts, parent
   let timestamps = util.isDefined(opts.timestamps) ? opts.timestamps : this.manager.opts.timestamps
   let dataArray = util.forceArray(data)
   let data2 = fieldsIsArray ? [] : {}
+  let notStrict = fields.schema.strict === false
 
   for (let i=0, l=dataArray.length; i<l; i++) {
     const item = dataArray[i]
@@ -172,6 +173,15 @@ Model.prototype._validateFields = function (dataRoot, fields, data, opts, parent
       }
       // if (!parentPath && fieldName == 'categories') console.timeEnd(fieldName)
     }
+
+    // Add any extra fields that are not in the schema. Item maybe false when inserting (from recursing above)
+    if (notStrict && !fieldsIsArray && item) {
+      const allDataKeys = Object.keys(item)
+      for (let m=0, n=allDataKeys.length; m<n; m++) {
+        const key = allDataKeys[m]
+        if (!fieldsArray.includes(key)) data2[key] = item[key]
+      }
+    }
   }
 
   // Normalise array indexes and return
@@ -266,5 +276,5 @@ Model.prototype._ignoredRules = [
   // todo: need to remove filesize and formats..
   'awsAcl', 'awsBucket', 'default', 'defaultOverride', 'filename', 'filesize', 'fileSize', 'formats',
   'image', 'index', 'insertOnly', 'model', 'nullObject', 'params', 'path', 'getSignedUrl', 'timestampField',
-  'type', 'isType', 'isSchema', 'virtual',
+  'type', 'isType', 'isSchema', 'virtual', 'strict',
 ]

package/lib/model.js

@@ -21,6 +21,11 @@ function Model(name, opts, manager) {
   } 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)}`
+  } else if (!util.isSubdocument(opts.fields) && opts.fields.type == 'any') {
+    throw `Instead of using { type: 'any' } for ${name}.fields, please use the new 'strict' definition rule` +
+      ', e.g. { schema: { strict: false }}'
+  } else if (!util.isSubdocument(opts.fields) && !util.isEmpty(opts.fields)) {
+    throw `The ${name}.fields object should be a valid document, e.g. { name: { type: 'string' }}`
   }
 
   // Add schema options
@@ -107,7 +112,9 @@ function Model(name, opts, manager) {
   }, this)
 
   // Extend default fields with passed in fields and check for invalid fields
-  this._setupFields(this.fields = Object.assign({}, this._defaultFields, this.fields))
+  this._setupFields(
+    this.fields = util.isSchema(this.fields) ? this.fields : Object.assign({}, this._defaultFields, this.fields)
+  )
   this.fieldsFlattened = this._getFieldsFlattened(this.fields, '') // test output?
   this.modelFieldsArray = this._getModelFieldsArray()
 
@@ -173,11 +180,14 @@ Model.prototype._getModelFieldsArray = function() {
   }, [])
 },
 
-Model.prototype._setupFields = function(fields) {
+Model.prototype._setupFields = function(fields, isSub) {
   /**
    * Check for invalid rules on a field object, and set field.isType
    * @param {object|array} fields - subsdocument or array
    */
+  // We need to allow the processing of the root schema object
+  if (!isSub) fields = { fields }
+  
   util.forEach(fields, function(field, fieldName) {
     // Schema field
     if (fieldName == 'schema') return
@@ -214,17 +224,8 @@ Model.prototype._setupFields = function(fields) {
         isSchema: true,
       }
 
-      // Rule doesn't exist
-      for (let ruleName in field.schema) {
-        if ((this.rules[ruleName] || rules[ruleName]) && this._ignoredRules.indexOf(ruleName) != -1) {
-          this.error(`The rule name "${ruleName}" for the model "${this.name}" is a reserved keyword, ignoring rule.`)
-        }
-        if (!this.rules[ruleName] && !rules[ruleName] && this._ignoredRules.indexOf(ruleName) == -1) {
-          // console.log(field.schema)
-          this.error(`No rule "${ruleName}" exists for model "${this.name}", ignoring rule.`)
-          delete field.schema[ruleName]
-        }
-      }
+      // Remove invalid rules
+      this._removeInvalidRules(field)
 
     // Misused schema property
     } else if (fieldName == 'schema' || fieldName == 'isSchema') {
@@ -233,6 +234,7 @@ Model.prototype._setupFields = function(fields) {
 
     // Fields be an array
     } else if (util.isArray(field)) {
+      this._removeInvalidRules(field)
       field.schema = util.removeUndefined({
         type: 'array',
         isArray: true,
@@ -243,7 +245,7 @@ Model.prototype._setupFields = function(fields) {
         virtual: field.length == 1 && (field[0] || {}).virtual ? true : undefined,
         ...(field.schema || {}),
       })
-      this._setupFields(field)
+      this._setupFields(field, true)
 
     // Fields can be a subdocument, e.g. user.pet = { name: {}, ..}
     } else if (util.isSubdocument(field)) {
@@ -253,6 +255,7 @@ Model.prototype._setupFields = function(fields) {
         field.schema.index = index2dsphere
         delete field.index
       }
+      this._removeInvalidRules(field)
       field.schema = util.removeUndefined({ 
         type: 'object', 
         isObject: true, 
@@ -262,11 +265,33 @@ Model.prototype._setupFields = function(fields) {
         nullObject: this.manager.opts.nullObjects, 
         ...field.schema, 
       })
-      this._setupFields(field)
+      this._setupFields(field, true)
     }
   }, this)
 },
 
+Model.prototype._removeInvalidRules = function(field) {
+  /**
+   * Remove invalid rules on a field object
+   * @param {object} field
+   * @return {object} field
+   **/
+  for (let ruleName in (field||{}).schema) {
+    const ruleFn = this.rules[ruleName] || rules[ruleName]
+    // Rule doesn't exist
+    if (!ruleFn && this._ignoredRules.indexOf(ruleName) == -1) {
+      // console.log(field.schema)
+      this.error(`No rule "${ruleName}" exists for model "${this.name}", ignoring rule.`)
+      delete field.schema[ruleName]
+    }
+    // Reserved rule
+    if (this.rules[ruleName] && this._ignoredRules.indexOf(ruleName) != -1) {
+      this.error(`The rule "${ruleName}" for the model "${this.name}" is a reserved keyword, ignoring custom rule function.`)
+    }
+  }
+  return field
+},
+
 Model.prototype._setupIndexes = async function(fields, opts={}) {
   /**
    * Creates indexes for the model (multikey, and sub-document supported)
@@ -294,7 +319,7 @@ Model.prototype._setupIndexes = async function(fields, opts={}) {
   }
 
   // Process custom 'unprocessed' fields
-  if (fields && !fields[Object.keys(fields)[0]].schema) {
+  if (fields && !(fields[Object.keys(fields)[0]].schema||{}).isSchema) {
     fields = util.deepCopy(fields)
     this._setupFields(fields)
     // console.dir(fields, { depth: null })

package/package.json

@@ -2,7 +2,7 @@
   "name": "monastery",
   "description": "⛪ A simple, straightforward MongoDB ODM",
   "author": "Ricky Boyce",
-  "version": "3.0.23",
+  "version": "3.1.0",
   "license": "MIT",
   "repository": "github:boycce/monastery",
   "homepage": "https://boycce.github.io/monastery/",

package/test/model.js

@@ -21,18 +21,8 @@ test('model > model on manager', async () => {
   db2.close()
 })
 
-test('model setup basics', async () => {
-  // Setup
-  let user = db.model('user', { fields: {
-    name: { type: 'string' },
-    pets: [{ type: 'string' }],
-    colors: { red: { type: 'string' } },
-    points: [[{ type: 'number' }]],
-    points2: [[{ x: { type: 'number' } }]],
-    logo: { type: 'image' },
-  }})
-
-  // no fields defined
+test('model setup with default fields', async () => {
+  // Default fields
   expect(db.model('user2', { fields: {} }).fields).toEqual({
     _id: {
       schema: {
@@ -64,12 +54,39 @@ test('model setup basics', async () => {
         type: 'integer',
       },
     },
+    schema: {
+      isObject: true,
+      isSchema: true,
+      isType: 'isObject',
+      type: 'object',
+    },
+  })
+})
+
+test('model setup basics', async () => {
+  // Setup
+  let user = db.model('user', { 
+    fields: {
+      name: { type: 'string' },
+      pets: [{ type: 'string' }],
+      colors: { red: { type: 'string' } },
+      points: [[{ type: 'number' }]],
+      points2: [[{ x: { type: 'number' } }]],
+      logo: { type: 'image' },
+    },
   })
 
   // Has model name
   expect(user.name)
     .toEqual('user')
 
+  // Expect to throw an error
+  expect(() => db.model('user', { fields: { type: 'any' } }))
+    .toThrow(
+      'Instead of using { type: \'any\' } for user.fields, please use the new \'strict\' definition rule, '
+      + 'e.g. { schema: { strict: false }}'
+    )
+
   // Basic field
   expect(user.fields.name.schema)
     .toEqual({ type: 'string', isString: true, isSchema: true, isType: 'isString' })
@@ -114,42 +131,6 @@ test('model setup basics', async () => {
   ))
 })
 
-test('model setup with default fields', async () => {
-  // Default fields
-  expect(db.model('user2', { fields: {} }).fields).toEqual({
-    _id: {
-      schema: {
-        insertOnly: true,
-        isId: true,
-        isSchema: true,
-        isType: 'isId',
-        type: 'id',
-      },
-    },
-    createdAt: {
-      schema: {
-        default: expect.any(Function),
-        insertOnly: true,
-        isInteger: true,
-        isSchema: true,
-        isType: 'isInteger',
-        timestampField: true,
-        type: 'integer',
-      },
-    },
-    updatedAt: {
-      schema: {
-        default: expect.any(Function),
-        isInteger: true,
-        isSchema: true,
-        isType: 'isInteger',
-        timestampField: true,
-        type: 'integer',
-      },
-    },
-  })
-})
-
 test('model setup with default objects', async () => {
   const db2 = monastery('127.0.0.1/monastery', { defaultObjects: true })
   let user = db2.model('user', { fields: {
@@ -248,6 +229,24 @@ test('model setup with schema', async () => {
   })
 })
 
+test('model setup with schema on root', async () => {
+  // Expect to throw an error
+  expect(() => db.model('user', { fields: { name: 'string' } }))
+    .toThrow('The user.fields object should be a valid document, e.g. { name: { type: \'string\' }}')
+
+  // root has schema
+  expect(db.model('user', { fields: { name: { type: 'string' } } }).fields.schema)
+    .toEqual({ type: 'object', isObject: true, isSchema: true, isType: 'isObject' })
+
+  // root has custom schema
+  expect(db.model('user', { fields: { schema: { nullObject: true } } }).fields.schema)
+    .toEqual({ type: 'object', isObject: true, isSchema: true, isType: 'isObject', nullObject: true })
+
+  // strict mode off
+  expect(db.model('user', { fields: { schema: { strict: false } } }).fields.schema)
+    .toEqual({ type: 'object', isObject: true, isSchema: true, isType: 'isObject', strict: false })
+})
+
 test('model setup with messages', async () => {
   let user = db.model('user', {
     fields: {
@@ -375,15 +374,15 @@ test('model setup with messages', async () => {
   })
 })
 
-test('model setup reserved rules', async () => {
+test('model setup with reserved and invalid rules', async () => {
   // Setup
   const db2 = monastery('127.0.0.1/monastery', { logLevel: 0 })
   let user = db2.model('user-model', {
     fields: {
       name: {
         type: 'string',
-        params: {}, // reserved keyword (image plugin)
-        paramsUnreserved: {},
+        params: {}, // reserved keyword (image plugin) 
+        invalidRule: {}, // no rule function found
       },
     },
     rules: {
@@ -392,10 +391,15 @@ test('model setup reserved rules', async () => {
       },
     },
   })
-  await expect(user.validate({ name: 'Martin' })).resolves.toEqual({
-    name: 'Martin',
-    createdAt: expect.any(Number),
-    updatedAt: expect.any(Number),
+  expect(user.fields.name).toEqual({
+    schema: {
+      type: 'string',
+      isString: true,
+      isSchema: true,
+      isType: 'isString',
+      params: {}, // still included
+      // invalidRule: {}, should be removed
+    },
   })
   db2.close()
 })

package/test/validate.js

@@ -154,6 +154,87 @@ test('validation basic errors', async () => {
   })
 })
 
+test('validation type any', async () => {
+  let user1 = db.model('user', { 
+    fields: { 
+      name: { type: 'any' },
+    },
+  })
+  // Any type on field
+  await expect(user1.validate({ name: 'benjamin' })).resolves.toEqual({ name: 'benjamin' })
+  await expect(user1.validate({ name: 1 })).resolves.toEqual({ name: 1 })
+  await expect(user1.validate({ name: null })).resolves.toEqual({ name: null })
+  await expect(user1.validate({ name: true })).resolves.toEqual({ name: true })
+  await expect(user1.validate({ name: false })).resolves.toEqual({ name: false })
+  await expect(user1.validate({ name: [1, 2] })).resolves.toEqual({ name: [1, 2] })
+  await expect(user1.validate({ name: { first: 1 } })).resolves.toEqual({ name: { first: 1 } })
+})
+
+test('validation schema with reserved and invalid rules', async () => {
+  const db2 = monastery('127.0.0.1/monastery', { logLevel: 0 })
+  let user = db2.model('user-model', {
+    fields: {
+      sub: {
+        name: {
+          type: 'string',
+          default: true, // reserved keyword
+          invalidRule: {}, // no rule function found
+          validRule: true,
+        },
+      },
+    },
+    rules: {
+      default: (value) => { // function shouldn't run (i.e. value still is 'Martin')
+        return false
+      },
+      validRule: (value) => {
+        if (value === 'Martin') return true
+      },
+    },
+  })
+  await expect(user.validate({ sub: { name: 'Martin' } })).resolves.toEqual({
+    createdAt: expect.any(Number),
+    updatedAt: expect.any(Number),
+    sub: {
+      name: 'Martin',
+    },
+  })
+  db2.close()
+})
+
+test('validation strict false', async () => {
+  let user1 = db.model('user', { 
+    fields: {
+      name: { type: 'string' },
+    },
+  })
+  // strict on (default)
+  let inserted1 = await user1.insert({ data: { nonDefinedField: 1 } })
+  expect(inserted1).toEqual({
+    _id: inserted1._id,
+  })
+  let user2 = db.model('user', { 
+    fields: {
+      name: { type: 'string' },
+      sub: {
+        name: { type: 'string' },
+        schema: { strict: false },
+      },
+      subArray: [{
+        name: { type: 'string' },
+        schema: { strict: false },
+      }],
+      schema: { strict: false },
+    },
+  })
+  // strict off
+  let inserted2 = await user2.insert({ data: { nonDefinedField: 1 } })
+  expect(inserted2).toEqual({
+    _id: inserted2._id,
+    nonDefinedField: 1,
+  })
+})
+
 test('validation subdocument errors', async () => {
   let user = db.model('user', { fields: {
     animals: {