monastery 2.2.2 → 3.0.0

package/test/virtuals.js

@@ -1,250 +1,245 @@
-module.exports = function(monastery, opendb) {
+const monastery = require('../lib/index.js')
 
-  test('virtuals', async () => {
-    // Setup
-    let db = (await opendb(null)).db
-    // Test model setup
-    let bird = db.model('bird', {
-      fields: {
-        age: { type: 'number', virtual: true, default: 55 },
-        birdsOwner: { model: 'user' },
-        name: { type: 'string' },
-      }
-    })
-    let user = db.model('user', {
-      fields: {
-        myBird: { model: 'bird', virtual: true },
-        myBirds: [{ model: 'bird', virtual: true }],
-        name: { type: 'string' },
-      }
-    })
-    expect(user.fields.name.virtual).toEqual(undefined)
-    expect(user.fields.myBirds[0].virtual).toEqual(true)
-    expect(user.fields.myBirds.schema.virtual).toEqual(true)
+let db
+beforeAll(async () => { db = monastery('127.0.0.1/monastery', { timestamps: false }) })
+afterAll(async () => { db.close() })
 
-    // Test insert/update/validate
-    let user1 = await user.insert({
-      data: {
-        myBird: db.id(), // shouldnt be added
-        myBirds: [db.id()], // shouldnt be added
-        name: 'Bruce',
-      }
-    })
-    let bird1 = await bird.insert({
-      data: {
-        age: 12, // shouldnt be inserted
-        birdsOwner: user1._id,
-        name: 'Ponyo',
-      }
-    })
-    let updatedBird1 = await bird.update({
-      query: bird1._id,
-      data: {
-        age: 12, // shouldnt be added
-        birdsOwner: user1._id,
-        name: 'Ponyo2',
-      }
-    })
-    let validatedBird1 = await bird.validate({
-      age: 12, // shouldnt be included
+test('virtuals', async () => {
+  // Test model setup
+  let bird = db.model('bird', {
+    fields: {
+      age: { type: 'number', virtual: true, default: 55 },
+      birdsOwner: { model: 'user' },
+      name: { type: 'string' },
+    },
+  })
+  let user = db.model('user', {
+    fields: {
+      myBird: { model: 'bird', virtual: true },
+      myBirds: [{ model: 'bird', virtual: true }],
+      name: { type: 'string' },
+    },
+  })
+  expect(user.fields.name.virtual).toEqual(undefined)
+  expect(user.fields.myBirds[0].virtual).toEqual(true)
+  expect(user.fields.myBirds.schema.virtual).toEqual(true)
+
+  // Test insert/update/validate
+  let user1 = await user.insert({
+    data: {
+      myBird: db.id(), // shouldnt be added
+      myBirds: [db.id()], // shouldnt be added
+      name: 'Bruce',
+    },
+  })
+  let bird1 = await bird.insert({
+    data: {
+      age: 12, // shouldnt be inserted
       birdsOwner: user1._id,
       name: 'Ponyo',
-    })
-    expect(user1).toEqual({
-      _id: user1._id,
-      name: 'Bruce'
-    })
-    expect(bird1).toEqual({
-      _id: bird1._id,
-      birdsOwner: user1._id,
-      name: 'Ponyo'
-    })
-    expect(updatedBird1).toEqual({
-      birdsOwner: user1._id,
-      name: 'Ponyo2'
-    })
-    expect(validatedBird1).toEqual({
+    },
+  })
+  let updatedBird1 = await bird.update({
+    query: bird1._id,
+    data: {
+      age: 12, // shouldnt be added
       birdsOwner: user1._id,
-      name: 'Ponyo'
-    })
+      name: 'Ponyo2',
+    },
+  })
+  let validatedBird1 = await bird.validate({
+    age: 12, // shouldnt be included
+    birdsOwner: user1._id,
+    name: 'Ponyo',
+  })
+  expect(user1).toEqual({
+    _id: user1._id,
+    name: 'Bruce',
+  })
+  expect(bird1).toEqual({
+    _id: bird1._id,
+    birdsOwner: user1._id,
+    name: 'Ponyo',
+  })
+  expect(updatedBird1).toEqual({
+    birdsOwner: user1._id,
+    name: 'Ponyo2',
+  })
+  expect(validatedBird1).toEqual({
+    birdsOwner: user1._id,
+    name: 'Ponyo',
+  })
 
-    // Test find
-    let find1 = await user.findOne({
-      query: user1._id,
-      populate: [{
-        as: 'myBirds',
-        from: 'bird',
-        let: { id: '$_id' },
-        pipeline: [{
-          $match: {
-            $expr: {
-              $eq: ['$birdsOwner', '$$id']
-            }
-          }
-        }]
-      }]
-    })
-    expect(find1).toEqual({
-      _id: user1._id,
-      myBirds: [{
-        _id: bird1._id,
-        age: 55,
-        birdsOwner:  user1._id,
-        name: 'Ponyo2'
+  // Test find
+  let find1 = await user.findOne({
+    query: user1._id,
+    populate: [{
+      as: 'myBirds',
+      from: 'bird',
+      let: { id: '$_id' },
+      pipeline: [{
+        $match: {
+          $expr: {
+            $eq: ['$birdsOwner', '$$id'],
+          },
+        },
       }],
-      name: 'Bruce'
-    })
+    }],
+  })
+  expect(find1).toEqual({
+    _id: user1._id,
+    myBirds: [{
+      _id: bird1._id,
+      age: 55,
+      birdsOwner:  user1._id,
+      name: 'Ponyo2',
+    }],
+    name: 'Bruce',
+  })
 
-    // Test find is processing models for incorrect data structures
-    let find2 = await user.findOne({
-      query: user1._id,
-      populate: [{
-        // should be an object but the $lookup returns an array
-        as: 'myBird',
-        from: 'bird',
-        let: { id: '$_id' },
-        pipeline: [{
-          $match: {
-            $expr: {
-              $eq: ['$birdsOwner', '$$id']
-            }
-          }
-        }]
-      }, {
-        // should be an array but the query returns an object
-        as: 'myBirds',
-        from: 'bird',
-        let: { id: '$_id' },
-        pipeline: [{
-          $match: {
-            $expr: {
-              $eq: ['$birdsOwner', '$$id']
-            }
-          }
-        }]
+  // Test find is processing models for incorrect data structures
+  let find2 = await user.findOne({
+    query: user1._id,
+    populate: [{
+      // should be an object but the $lookup returns an array
+      as: 'myBird',
+      from: 'bird',
+      let: { id: '$_id' },
+      pipeline: [{
+        $match: {
+          $expr: {
+            $eq: ['$birdsOwner', '$$id'],
+          },
+        },
       }],
-      addFields: {
-        myBirds: { $arrayElemAt: ['$myBirds', 0] }
-      }
-    })
-    expect(find2).toEqual({
-      _id: user1._id,
-      myBird: [{
-        _id: bird1._id,
-        age: 55, // means the model was processed
-        birdsOwner: user1._id,
-        name: 'Ponyo2'
+    }, {
+      // should be an array but the query returns an object
+      as: 'myBirds',
+      from: 'bird',
+      let: { id: '$_id' },
+      pipeline: [{
+        $match: {
+          $expr: {
+            $eq: ['$birdsOwner', '$$id'],
+          },
+        },
       }],
-      myBirds: {
-        _id: bird1._id,
-        age: 55, // means the model was processed
-        birdsOwner:  user1._id,
-        name: 'Ponyo2'
-      },
-      name: 'Bruce'
-    })
-
-    db.close()
+    }],
+    addFields: {
+      myBirds: { $arrayElemAt: ['$myBirds', 0] },
+    },
+  })
+  expect(find2).toEqual({
+    _id: user1._id,
+    myBird: [{
+      _id: bird1._id,
+      age: 55, // means the model was processed
+      birdsOwner: user1._id,
+      name: 'Ponyo2',
+    }],
+    myBirds: {
+      _id: bird1._id,
+      age: 55, // means the model was processed
+      birdsOwner:  user1._id,
+      name: 'Ponyo2',
+    },
+    name: 'Bruce',
   })
+})
 
-  test('insert update virtuals (validate)', async () => {
-    // Setup
-    let db = (await opendb(null)).db
-    let user = db.model('user', {
-      fields: {
-        list: [{ type: 'number' }],
-        dog: { type: 'string' },
-        pet: { type: 'string' },
-        pets: [{ name: { type: 'string'}, age: { type: 'number'} }],
-        animals: {
-          cat: { type: 'string' },
-          dog: { type: 'string' }
-        },
-        hiddenPets: [{
-          name: { type: 'string'}
-        }],
-        hiddenList: [{ type: 'number'}],
-        deep: {
-          deep2: {
-            deep3: {
-              deep4: { type: 'string' }
-            }
-          }
-        }
-      },
-      insertBL: [
-        'dog',
-        'animals.cat',
-        'pets.age',
-        'hiddenPets',
-        'hiddenList',
-        'deep.deep2.deep3'
-      ]
-    })
-    let doc1 = {
-      list: [44, 54],
-      dog: 'Bruce',
-      pet: 'Freddy',
-      pets: [{ name: 'Pluto', age: 5 }, { name: 'Milo', age: 4 }],
+test('insert update virtuals (validate)', async () => {
+  let user = db.model('user', {
+    fields: {
+      list: [{ type: 'number' }],
+      dog: { type: 'string' },
+      pet: { type: 'string' },
+      pets: [{ name: { type: 'string'}, age: { type: 'number'} }],
       animals: {
-        cat: 'Ginger',
-        dog: 'Max'
+        cat: { type: 'string' },
+        dog: { type: 'string' },
       },
       hiddenPets: [{
-        name: 'secretPet'
+        name: { type: 'string'},
       }],
-      hiddenList: [12, 23],
+      hiddenList: [{ type: 'number'}],
       deep: {
         deep2: {
           deep3: {
-            deep4: 'hideme'
-          }
-        }
-      }
-    }
-
-    // Default insert validation
-    let user1 = await user.validate(doc1)
-    expect(user1).toEqual({
-      list: [44, 54],
-      pet: 'Freddy',
-      pets: [{ name: 'Pluto' }, { name: 'Milo' }],
-      animals: {
-        dog: 'Max'
+            deep4: { type: 'string' },
+          },
+        },
       },
-      deep: {
-        deep2: {}
-      }
-    })
-
-    // Custom blacklist (remove and add to the current schema blacklist)
-    let user2 = await user.validate(doc1, {
-      blacklist: [
-        '-dog',
-        '-animals.dog', // wrong property
-        'pets.name',
-        '-hiddenList',
-        '-deep' // blacklist a parent
-      ],
-    })
-    expect(user2).toEqual({
-      list: [44, 54],
-      dog: 'Bruce',
-      pet: 'Freddy',
-      pets: [ {}, {} ],
-      animals: {
-        dog: 'Max'
+    },
+    insertBL: [
+      'dog',
+      'animals.cat',
+      'pets.age',
+      'hiddenPets',
+      'hiddenList',
+      'deep.deep2.deep3',
+    ],
+  })
+  let doc1 = {
+    list: [44, 54],
+    dog: 'Bruce',
+    pet: 'Freddy',
+    pets: [{ name: 'Pluto', age: 5 }, { name: 'Milo', age: 4 }],
+    animals: {
+      cat: 'Ginger',
+      dog: 'Max',
+    },
+    hiddenPets: [{
+      name: 'secretPet',
+    }],
+    hiddenList: [12, 23],
+    deep: {
+      deep2: {
+        deep3: {
+          deep4: 'hideme',
+        },
       },
-      hiddenList: [12, 23],
-      deep: {
-        deep2: {
-          deep3: {
-            deep4: 'hideme'
-          }
-        }
-      }
-    })
-    db.close()
+    },
+  }
+
+  // Default insert validation
+  let user1 = await user.validate(doc1)
+  expect(user1).toEqual({
+    list: [44, 54],
+    pet: 'Freddy',
+    pets: [{ name: 'Pluto' }, { name: 'Milo' }],
+    animals: {
+      dog: 'Max',
+    },
+    deep: {
+      deep2: {},
+    },
   })
 
-}
+  // Custom blacklist (remove and add to the current schema blacklist)
+  let user2 = await user.validate(doc1, {
+    blacklist: [
+      '-dog',
+      '-animals.dog', // wrong property
+      'pets.name',
+      '-hiddenList',
+      '-deep', // blacklist a parent
+    ],
+  })
+  expect(user2).toEqual({
+    list: [44, 54],
+    dog: 'Bruce',
+    pet: 'Freddy',
+    pets: [ {}, {} ],
+    animals: {
+      dog: 'Max',
+    },
+    hiddenList: [12, 23],
+    deep: {
+      deep2: {
+        deep3: {
+          deep4: 'hideme',
+        },
+      },
+    },
+  })
+})

package/lib/monk-monkey-patches.js

@@ -1,90 +0,0 @@
-let MongoClient = require('mongodb').MongoClient
-let STATE = {
-  CLOSED: 'closed',
-  OPENING: 'opening',
-  OPEN: 'open'
-}
-
-module.exports.open = function(uri, opts, fn) {
-  /*
-   * Monkey patch to remove db event listener warnings
-   * @todo remove when monk is removed
-   * @see https://www.mongodb.com/community/forums/t/node-44612-deprecationwarning-listening-to-events-on-
-       the-db-class-has-been-deprecated-and-will-be-removed-in-the-next-major-version/15849/4
-   */
-  MongoClient.connect(uri, opts, function (err, client) {
-    // this = Manager
-    if (err) {
-      this._state = STATE.CLOSED
-      this.emit('error-opening', err)
-    } else {
-      this._state = STATE.OPEN
-
-      this._client = client
-      this._db = client.db()
-
-      // set up events
-      var self = this
-      ;['authenticated', 'close', 'error', 'parseError', 'timeout'].forEach(function (eventName) {
-        self._client.on(eventName, function (e) {
-          self.emit(eventName, e)
-        })
-      })
-
-      this.emit('open', this._db)
-    }
-    if (fn) {
-      fn(err, this)
-    }
-  }.bind(this))
-}
-
-module.exports.then = function (fn) {
-  /*
-   * Unfortuantly db.then doesn't run after the promise has been fulfilled, this fixes this issue.
-   * @see https://github.com/Automattic/monk/blob/master/lib/manager.js#L194
-   */
-  return new Promise(function (resolve, reject) {
-    if (this._state == STATE.OPEN) {
-      resolve()
-    } else if (this._state == STATE.CLOSED) {
-      reject()
-    } else {
-      this.once('open', resolve)
-      this.once('error-opening', reject)
-    }
-  }.bind(this)).then(fn.bind(null, this))
-}
-
-module.exports.findOneAndUpdate = function(query, update, opts, fn) {
-  /*
-   * Monkey patch to use returnDocument
-   * @todo remove when monk is removed
-   * @see https://github.com/Automattic/monk/blob/master/lib/collection.js#L265
-   */
-  // this = model
-  if (typeof opts === 'function') {
-    fn = opts
-    opts = {}
-  }
-  return this._dispatch(function findOneAndUpdate(args) {
-    var method = 'findOneAndUpdate'
-    if (typeof (args.options || {}).returnDocument === 'undefined') {
-      args.options.returnDocument = 'after'
-    }
-    if (args.options.replaceOne | args.options.replace) {
-      method = 'findOneAndReplace'
-    }
-    return args.col[method](args.query, args.update, args.options)
-      .then(function (doc) {
-        if (doc && typeof doc.value !== 'undefined') {
-          return doc.value
-        }
-        if (doc.ok && doc.lastErrorObject && doc.lastErrorObject.n === 0) {
-          return null
-        }
-        return doc
-      })
-  })({options: opts, query: query, update: update, callback: fn}, 'findOneAndUpdate')
-}
-

package/test/monk.js

@@ -1,40 +0,0 @@
-module.exports = function(monastery, opendb) {
-
-  test('Monk conflicts', async () => {
-    // Setup
-    let db = (await opendb(false)).db
-    let monkdb = require('monk')(':badconnection', () => {})
-    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']) {
-      expect(monkdb).not.toHaveProperty(name)
-    }
-
-    // Model without a name conflict is added to manager[model]
-    expect(db.user).toEqual(expect.any(Object))
-
-    // Model with a name conflict is only added to manager.model[name]
-    expect(db.connected).toEqual(db.connected)
-    expect(db.model.connected).toEqual(modelNamedConnected)
-
-    // Close test since monk(uri) awaits upoin a connection (Update, done not needed in latest jest)
-    // done()
-  })
-
-  test('Monastery connect with promise', (done) => {
-    let db = monastery('localhost/monastery', { serverSelectionTimeoutMS: 2000 })
-
-    db.then(db => {
-      expect(db).toEqual(expect.any(Object))
-      db.close()
-      done()
-
-    }).catch(err => {
-      console.error(err)
-      done()
-    })
-  })
-
-}

package/test/test.js

@@ -1,38 +0,0 @@
-/**
- * Todo:
- *   - Test custom model rules
- *   - Test custom messages
- *   - Test for index and unique schema fields
- *   - Test blacklisting
- *   - Test deep/array population
- *   - Test default limit
- * Notes:
- *   - expect().toEqual:  strict deep match
- *   - expect().toMatchObject:  received object can have random properties
- *   - expect.objectContaining:
- */
-
-global.oid = require('mongodb').ObjectID
-
-let monastery = require('../lib/index.js')
-let opendb = async function(uri, opts) {
-  let db = monastery(
-    uri === false? false : (uri || 'localhost/monastery'),
-    opts || { timestamps: false, serverSelectionTimeoutMS: 2000 }
-  )
-  // Wait until mongo is open
-  if (db.then) await db.then(() => {})
-  // Returning an object instead of promise
-  return { db: db }
-}
-
-/* Run tests sequentially */
-require('./util.js')(monastery, opendb)
-require('./monk.js')(monastery, opendb)
-require('./model.js')(monastery, opendb)
-require('./crud.js')(monastery, opendb)
-require('./blacklisting.js')(monastery, opendb)
-require('./populate.js')(monastery, opendb)
-require('./validate.js')(monastery, opendb)
-require('./plugin-images.js')(monastery, opendb)
-require('./virtuals.js')(monastery, opendb)