monastery 3.0.22 → 3.1.0

package/test/model.js

@@ -21,102 +21,116 @@ test('model > model on manager', async () => {
   db2.close()
 })
 
-test('model setup', 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: {
         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: {
+    },
+    updatedAt: {
+      schema: {
         default: expect.any(Function),
         isInteger: true,
+        isSchema: true,
+        isType: 'isInteger',
         timestampField: true,
         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(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).toEqual({ type: 'string', isString: true })
+  expect(user.fields.name.schema)
+    .toEqual({ type: 'string', isString: true, isSchema: true, isType: 'isString' })
 
-  // Image field
-  expect(user.fields.logo).toEqual({ type: 'any', isAny: true, image: true })
+  // Image field (not processed by plugin)
+  expect(user.fields.logo.schema)
+    .toEqual({ type: 'any', isAny: true, image: true, isSchema: true, isType: 'isAny' })
 
   // Array field
-  expect(user.fields.pets).toContainEqual({ type: 'string', isString: true })
+  expect(user.fields.pets)
+    .toContainEqual({ schema: { type: 'string', isString: true, isType: 'isString', isSchema: true } })
 
   // Array schema
-  expect(user.fields.pets.schema).toEqual({ type: 'array', isArray: true })
+  expect(user.fields.pets.schema)
+    .toEqual({ type: 'array', isArray: true, isSchema: true, isType: 'isArray' })
 
   // Subdocument field and schema
   expect(user.fields.colors).toEqual({
-    red: { isString: true, type: 'string' },
-    schema: { isObject: true, type: 'object' },
+    red: { schema: { isString: true, type: 'string', isSchema: true, isType: 'isString' }},
+    schema: { isObject: true, type: 'object', isSchema: true, isType: 'isObject' },
   })
 
   // Array array field (no array properties)
   expect(JSON.stringify(user.fields.points)).toEqual(JSON.stringify(
-    [[{ type: 'number', isNumber: true }]]
+    [[{
+      schema: { type: 'number', isType: 'isNumber', isNumber: true, isSchema: true },
+    }]]
   ))
 
   // Array array schema
-  expect(user.fields.points.schema).toEqual({ type: 'array', isArray: true })
-  expect(user.fields.points[0].schema).toEqual({ type: 'array', isArray: true })
+  expect(user.fields.points.schema).toEqual({ type: 'array', isArray: true, isSchema: true, isType: 'isArray' })
+  expect(user.fields.points[0].schema).toEqual({ type: 'array', isArray: true, isSchema: true, isType: 'isArray' })
 
   // Array array subdocument field (no array properties)
   expect(JSON.stringify(user.fields.points2)).toEqual(JSON.stringify(
     [[{
-      x: { type: 'number', isNumber: true },
-      schema: { type: 'object', isObject: true },
+      x: { 
+        schema: { type: 'number', isType: 'isNumber', isNumber: true, isSchema: true },
+      },
+      schema: { type: 'object', isObject: true, isSchema: true, isType: 'isObject' },
     }]]
   ))
 })
 
-test('model setup with default fields', async () => {
-  // Default fields
-  expect(db.model('user2', { fields: {} }).fields).toEqual({
-    _id: {
-      insertOnly: true,
-      isId: true,
-      type: 'id',
-    },
-    createdAt: {
-      default: expect.any(Function),
-      insertOnly: true,
-      isInteger: true,
-      timestampField: true,
-      type: 'integer',
-    },
-    updatedAt: {
-      default: expect.any(Function),
-      isInteger: true,
-      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: {
@@ -131,13 +145,28 @@ test('model setup with default objects', async () => {
   expect(user.fields.pets.schema).toEqual({
     type: 'array',
     isArray: true,
+    isSchema: true,
+    isType: 'isArray',
     default: expect.any(Function),
   })
 
   // Subdocument field and schema
   expect(user.fields.colors).toEqual({
-    red: { isString: true, type: 'string' },
-    schema: { isObject: true, type: 'object', default: expect.any(Function) },
+    red: { 
+      schema: {
+        isString: true, 
+        type: 'string',
+        isSchema: true,
+        isType: 'isString',
+      },
+    },
+    schema: { 
+      isObject: true, 
+      type: 'object', 
+      isSchema: true,
+      isType: 'isObject',
+      default: expect.any(Function),
+    },
   })
   db2.close()
 })
@@ -157,35 +186,67 @@ test('model setup with schema', async () => {
   // Object with schema
   expect(user.fields.pet).toEqual({
     name: {
-      type: 'string', 
-      isString: true,
-      minLength: 5,
+      schema: {
+        type: 'string', 
+        isString: true,
+        isSchema: true,
+        isType: 'isString',
+        minLength: 5,
+      },
     },
     schema: {
       type: 'object', 
       isObject: true,
+      isSchema: true,
+      isType: 'isObject',
       virtual: true,
     },
   })
   // Array with schema
   expect(user.fields.pets[0]).toEqual({
     name: {
-      type: 'string', 
-      isString: true,
-      minLength: 5,
+      schema: {
+        type: 'string', 
+        isString: true,
+        isSchema: true,
+        isType: 'isString',
+        minLength: 5,
+      },
     },
     schema: {
       type: 'object', 
       isObject: true,
+      isSchema: true,
+      isType: 'isObject',
     },
   })
   expect(user.fields.pets.schema).toEqual({
     type: 'array', 
     isArray: true,
+    isSchema: true,
+    isType: 'isArray',
     virtual: true,
   })
 })
 
+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: {
@@ -313,15 +374,15 @@ test('model setup with messages', async () => {
   })
 })
 
-test('model 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: {
@@ -330,15 +391,20 @@ test('model 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()
 })
 
-test('model indexes', async () => {
+test('model indexes basic', async () => {
   // Setup: Need to test different types of indexes
   // Setup: Drop previously tested collections
   const allCollections = await db.db.listCollections().toArray()
@@ -430,7 +496,7 @@ test('model indexes', async () => {
   }])
 })
 
-test('model unique indexes', async () => {
+test('model indexes unique', async () => {
   // Setup: Drop previously tested collections
   if ((await db.db.listCollections().toArray()).find(o => o.name == 'userUniqueIndex')) {
     await db.db.collection('userUniqueIndex').drop()
@@ -494,7 +560,7 @@ test('model unique indexes', async () => {
   })
 })
 
-test('model subdocument indexes', async () => {
+test('model indexes subdocument', async () => {
   // Setup: Need to test different types of indexes
   // Setup: Drop previously tested collections
   if ((await db.db.listCollections().toArray()).find(o => o.name == 'userIndexSubdoc')) {
@@ -536,7 +602,7 @@ test('model subdocument indexes', async () => {
   }])
 })
 
-test('model array indexes', async () => {
+test('model indexes array', async () => {
   // Setup: Need to test different types of indexes
   // Setup: Drop previously tested collections
   if ((await db.db.listCollections().toArray()).find(o => o.name == 'userIndexArray')) {
@@ -578,7 +644,7 @@ test('model array indexes', async () => {
   }])
 })
 
-test('model 2dsphere indexes', async () => {
+test('model indexes 2dsphere', async () => {
   // Setup. The tested model needs to be unique as race condition issue arises when the same model
   // with text indexes are setup at the same time
   await db.model('user99', {
@@ -599,24 +665,40 @@ test('model 2dsphere indexes', async () => {
 
   // Schema check
   expect(db.user99.fields.location).toEqual({
-    type: { type: 'string', default: 'Point', isString: true },
     coordinates: expect.any(Array),
+    type: { 
+      schema: { 
+        default: 'Point', 
+        isSchema: true,
+        isString: true,
+        isType: 'isString', 
+        type: 'string', 
+      },
+    },
     schema: {
-      default: undefined,
       index: '2dsphere',
       isObject: true,
-      nullObject: undefined,
+      isSchema: true,
+      isType: 'isObject', 
       type: 'object',
     },
   })
   expect(db.user99.fields.location2).toEqual({
-    type: { type: 'string', default: 'Point', isString: true },
     coordinates: expect.any(Array),
+    type: {
+      schema: {
+        type: 'string', 
+        default: 'Point', 
+        isSchema: true,
+        isString: true,
+        isType: 'isString', 
+      },
+    },
     schema: {
-      default: undefined,
       index: { type: '2dsphere' },
       isObject: true,
-      nullObject: undefined,
+      isSchema: true,
+      isType: 'isObject', 
       type: 'object',
     },
   })

package/test/plugin-images.js

@@ -40,9 +40,13 @@ test('images no initialisation', async () => {
 
   // schema
   expect(db2.company.fields.logo).toEqual({
-    image: true,
-    isAny: true,
-    type: 'any',
+    schema: {
+      image: true,
+      isAny: true,
+      isSchema: true,
+      isType: 'isAny',
+      type: 'any',
+    },
   })
 
   // found company
@@ -63,27 +67,45 @@ test('images no initialisation', async () => {
 })
 
 test('images initialisation', async () => {
-  let user = db.model('user', { fields: {
-    logo: { type: 'image' },
-    logos: [{ type: 'image' }],
-    users: [{ logo: { type: 'image' } }],
-  }})
+  let user = db.model('user', { 
+    fields: {
+      logo: { type: 'image' },
+      logos: [{ type: 'image' }],
+      users: [{ logo: { type: 'image' } }],
+    },
+  })
 
   // Initialisation success
   expect(db.opts.imagePlugin).toEqual(imagePluginFakeOpts)
 
+  function schemaForType(type) {
+    return {
+      schema: {
+        type: type, 
+        isType: `is${util.ucFirst(type)}`, 
+        [`is${util.ucFirst(type)}`]: true, 
+        isSchema: true,
+      },
+    }
+  }
   let expected = {
-    bucket: { type: 'string', isString: true },
-    date: { type: 'number', isNumber: true },
-    filename: { type: 'string', isString: true },
-    filesize: { type: 'number', isNumber: true },
-    metadata: { type: 'any', isAny: true },
-    path: { type: 'string', isString: true },
+    bucket: schemaForType('string'),
+    date: schemaForType('number'),
+    filename: schemaForType('string'),
+    filesize: schemaForType('number'),
+    metadata: schemaForType('any'),
+    path: schemaForType('string'),
+    uid: schemaForType('string'),
     schema: {
-      type: 'object', isObject: true, image: true, nullObject: true, default: undefined,
+      type: 'object', 
+      isObject: true,
+      isSchema: true,
+      isType: 'isObject',
+      nullObject: true,
+      // Image rules
+      image: true, 
       isImageObject: true,
     },
-    uid: { type: 'string', isString: true },
   }
 
   // Logo schema

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: {

package/test/virtuals.js

@@ -20,8 +20,8 @@ test('virtuals', async () => {
       name: { type: 'string' },
     },
   })
-  expect(user.fields.name.virtual).toEqual(undefined)
-  expect(user.fields.myBirds[0].virtual).toEqual(true)
+  expect(user.fields.name.schema.virtual).toEqual(undefined)
+  expect(user.fields.myBirds[0].schema.virtual).toEqual(true)
   expect(user.fields.myBirds.schema.virtual).toEqual(true)
 
   // Test insert/update/validate