monastery 1.32.5 → 1.35.0

package/test/crud.js

@@ -391,7 +391,10 @@ module.exports = function(monastery, opendb) {
     expect(find1).toEqual({
       _id: inserted2._id,
       name: 'Martin Luther',
-      addresses: [{ city: 'Frankfurt', country: 'Germany' }, { city: 'Christchurch', country: 'New Zealand' }],
+      addresses: [
+        { city: 'Frankfurt', country: 'Germany' },
+        { city: 'Christchurch', country: 'New Zealand' }
+      ],
       address: { country: 'Germany' },
       pet: { dog: { _id: inserted._id, name: 'Scruff', user: inserted2._id }},
       dogs: [{ _id: inserted._id, name: 'Scruff', user: inserted2._id }]
@@ -407,6 +410,7 @@ module.exports = function(monastery, opendb) {
         as: 'dogs'
       }],
       blacklist: ['address', 'addresses.country', 'dogs.name']
+      // ^ great test (address should cancel addresses if not stopping at the .)
     })
     expect(find2).toEqual({
       _id: inserted2._id,

package/test/model.js

@@ -411,169 +411,4 @@ module.exports = function(monastery, opendb) {
     db.close()
   })
 
-  test('model findBL findBLProject', async () => {
-    let db = (await opendb(null)).db
-    db.model('bird', { fields: {
-      name: { type: 'string' }
-    }})
-    let user = db.model('user', {
-      findBL: [
-        'pets.hiddenAge',
-        'animals.hiddenCat',
-        'hiddenDog',
-        'hiddenPets',
-        'hiddenList',
-        'deep.deep2.hiddenDeep3',
-        'hiddenDeeper',
-        'hiddenDeepModel',
-        'hiddenDeepModels'
-      ],
-      fields: {
-        list: [{ type: 'number' }],
-        pet: { type: 'string' },
-        anyPet: { type: 'any' },
-        pets: [{ name: { type: 'string'}, hiddenAge: { type: 'number'} }],
-        animals: {
-          dog: { type: 'string' },
-          hiddenCat: { type: 'string' }
-        },
-        deep: {
-          deep2: {
-            hiddenDeep3: {
-              deep4: { type: 'string' }
-            }
-          }
-        },
-        deepModel: {
-          myBird: { model: 'bird' }
-        },
-        deepModel2: {
-          myBird: { model: 'bird' }
-        },
-        hiddenDog: { type: 'string' },
-        hiddenPets: [{
-          name: { type: 'string'}
-        }],
-        hiddenList: [{ type: 'number'}],
-        hiddenDeeper: {
-          deeper2: {
-            deeper3: {
-              deeper4: { type: 'string' }
-            }
-          }
-        },
-        hiddenDeepModel: {
-          myBird: { model: 'bird' }
-        },
-        hiddenDeepModels: [{ model: 'bird' }]
-      }
-    })
-
-    // Test find whitelist
-    // expect(user.fieldlist.filter(o => !user.findBL.includes(o))).toEqual([
-    //   'list',
-    //   'pet',
-    //   'anyPet',
-    //   'pets.name',
-    //   'animals.dog',
-    //   'deepModel.myBird',
-    //   'deepModel2.myBird'
-    // ])
-
-    // Test findBLProject
-    expect(user.findBLProject).toEqual({
-      'pets.hiddenAge': 0,
-      'animals.hiddenCat': 0,
-      'hiddenDog': 0,
-      'hiddenPets': 0,
-      'hiddenList': 0,
-      'deep.deep2.hiddenDeep3': 0,
-      'hiddenDeeper': 0,
-      'hiddenDeepModel': 0,
-      'hiddenDeepModels': 0
-    })
-
-    // Test inclusion of deep model blacklists
-    var findBLProject = user._addDeepBlacklists(user.findBLProject, [
-      'deepModel.myBird',
-      'hiddenDeepModel.myBird',
-      'hiddenDeepModels',
-      {
-        // raw $lookup object
-        as: 'deepModel2.myBird'
-      }
-    ])
-    expect(findBLProject).toEqual({
-      'pets.hiddenAge': 0,
-      'animals.hiddenCat': 0,
-      'hiddenDog': 0,
-      'hiddenPets': 0,
-      'hiddenList': 0,
-      'deep.deep2.hiddenDeep3': 0,
-      'hiddenDeeper': 0,
-      'hiddenDeepModel': 0,
-      'hiddenDeepModels': 0,
-      // Deep model blacklists
-      'deepModel.myBird.password': 0,
-      'deepModel2.myBird.password': 0
-    })
-
-    // Test whitelisting
-    expect(user._addBlacklist(findBLProject, ['-pets', '-deep.deep2.hiddenDeep3'])).toEqual({
-      // 'pets.hiddenAge': 0,
-      // 'deep.deep2.hiddenDeep3': 0,
-      'animals.hiddenCat': 0,
-      'hiddenDog': 0,
-      'hiddenPets': 0,
-      'hiddenList': 0,
-      'hiddenDeeper': 0,
-      'hiddenDeepModel': 0,
-      'hiddenDeepModels': 0,
-      // Deep model blacklists
-      'deepModel.myBird.password': 0,
-      'deepModel2.myBird.password': 0
-    })
-
-    // Test aggregate with projection exclusions. This is mainly to test how $lookup reacts
-    let bird1 = await db.bird.insert({ data: { name: 'bird1' } })
-    let bird2 = await db.bird.insert({ data: { name: 'bird2' } })
-    let user1 = await db.user.insert({ data: {
-      pet: 'carla',
-      pets: [{ name: 'carla', hiddenAge: 12 }, { name: 'sparky', hiddenAge: 14 }],
-      anyPet: { hi: 1234 },
-      hiddenDeepModel: { myBird: bird1._id },
-      hiddenDeepModels: [bird1._id, bird2._id]
-    }})
-    let res = await db.user._aggregate([
-      { $match: { _id: user1._id } },
-      { $lookup: {
-        from: 'bird',
-        localField: 'hiddenDeepModel.myBird',
-        foreignField: '_id',
-        as: 'hiddenDeepModel.myBird'
-      }},
-      { $lookup: {
-        from: 'bird',
-        localField: 'hiddenDeepModels',
-        foreignField: '_id',
-        as: 'hiddenDeepModels'
-      }},
-      { $project: {
-        'anyPet': 0,
-        'pets.hiddenAge': 0,
-        'hiddenDeepModel.myBird': 0,
-        'hiddenDeepModels.name': 0,
-      }}
-    ])
-    expect(res[0]).toEqual({
-      _id: user1._id,
-      pet: 'carla',
-      pets: [ { name: 'carla' }, { name: 'sparky' } ],
-      hiddenDeepModel: {},
-      hiddenDeepModels: [ { _id: bird1._id }, { _id: bird2._id } ]
-    })
-
-    db.close()
-  })
-
 }

package/test/util.js

@@ -39,4 +39,11 @@ module.exports = function(monastery, opendb) {
     expect(db.isId('5ff50fe955da2c00170de734')).toEqual(true)
   })
 
+  test('utilities arrayWithSchema', async () => {
+    let db = (await opendb(false)).db
+    let res = db.arrayWithSchema([{ name: { type: 'string' }}], { minLength: 1 })
+    expect(res).toContainEqual({ name: { type: 'string' }})
+    expect(res.schema).toEqual({ minLength: 1 })
+  })
+
 }