entropic-bond 1.40.5 → 1.40.7

package/lib/store/model.spec.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -21,7 +12,7 @@ describe('Model', () => {
     let model;
     let testUser;
     const rawData = () => store_1.Store.dataSource.rawData;
-    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+    beforeEach(async () => {
         store_1.Store.useDataSource(new json_data_source_1.JsonDataSource(JSON.parse(JSON.stringify(mock_data_json_1.default))));
         testUser = new test_user_1.TestUser();
         testUser.name = {
@@ -32,17 +23,17 @@ describe('Model', () => {
         testUser.age = 35;
         testUser.skills = ['lazy', 'dirty'];
         model = store_1.Store.getModel('TestUser');
-    }));
+    });
     it('should get model from class name string and class instance', () => {
         expect(store_1.Store.getModel(testUser).collectionName).toEqual(model.collectionName);
         expect(model.collectionName).toEqual('TestUser');
     });
-    it('should find document by id', () => __awaiter(void 0, void 0, void 0, function* () {
-        const user = yield model.findById('user1');
+    it('should find document by id', async () => {
+        const user = await model.findById('user1');
         expect(user).toBeInstanceOf(test_user_1.TestUser);
         expect(user.id).toEqual('user1');
         expect(user.name.firstName).toEqual('userFirstName1');
-    }));
+    });
     it('should not throw if a document id doesn\'t exists', (done) => {
         expect(() => {
             model.findById('nonExistingId')
@@ -50,18 +41,18 @@ describe('Model', () => {
                 .catch(done);
         }).not.toThrow();
     });
-    it('should return undefined if a document id doesn\'t exists', () => __awaiter(void 0, void 0, void 0, function* () {
-        expect(yield model.findById('nonExistingId')).toBeUndefined();
-    }));
-    it('should return empty array if no document matches condition', () => __awaiter(void 0, void 0, void 0, function* () {
-        expect(yield model.find().where('age', '<', 0).get()).toHaveLength(0);
-    }));
-    it('should return all documents if no where specified', () => __awaiter(void 0, void 0, void 0, function* () {
-        const docs = yield model.find().get();
+    it('should return undefined if a document id doesn\'t exists', async () => {
+        expect(await model.findById('nonExistingId')).toBeUndefined();
+    });
+    it('should return empty array if no document matches condition', async () => {
+        expect(await model.find().where('age', '<', 0).get()).toHaveLength(0);
+    });
+    it('should return all documents if no where specified', async () => {
+        const docs = await model.find().get();
         expect(docs.length).toBeGreaterThan(1);
-    }));
-    it('should write a document', () => __awaiter(void 0, void 0, void 0, function* () {
-        yield model.save(testUser);
+    });
+    it('should write a document', async () => {
+        await model.save(testUser);
         expect(rawData()['TestUser'][testUser.id]).toEqual(expect.objectContaining({
             name: {
                 firstName: 'testUserFirstName',
@@ -69,15 +60,15 @@ describe('Model', () => {
                 ancestorName: {}
             }
         }));
-    }));
-    it('should delete a document by id', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('should delete a document by id', async () => {
         expect(rawData()['TestUser']['user1']).toBeDefined();
-        yield model.delete('user1');
+        await model.delete('user1');
         expect(rawData()['TestUser']['user1']).toBeUndefined();
-    }));
+    });
     describe('Generic find', () => {
-        it('should query all admins with query object', () => __awaiter(void 0, void 0, void 0, function* () {
-            const admins = yield model.query({
+        it('should query all admins with query object', async () => {
+            const admins = await model.query({
                 operations: [{
                         property: 'admin',
                         operator: '==',
@@ -86,27 +77,27 @@ describe('Model', () => {
             });
             expect(admins[0]).toBeInstanceOf(test_user_1.TestUser);
             expect(admins).toHaveLength(2);
-        }));
-        it('should query by instance', () => __awaiter(void 0, void 0, void 0, function* () {
-            expect(yield model.query({})).toHaveLength(6);
-            expect(yield model.query({}, new test_user_1.DerivedUser())).toHaveLength(1);
-            expect(yield model.query({}, 'TestUser')).toHaveLength(5);
-        }));
-        it('should find all admins with where methods', () => __awaiter(void 0, void 0, void 0, function* () {
-            const admins = yield model.find().where('admin', '==', true).get();
+        });
+        it('should query by instance', async () => {
+            expect(await model.query({})).toHaveLength(6);
+            expect(await model.query({}, new test_user_1.DerivedUser())).toHaveLength(1);
+            expect(await model.query({}, 'TestUser')).toHaveLength(5);
+        });
+        it('should find all admins with where methods', async () => {
+            const admins = await model.find().where('admin', '==', true).get();
             expect(admins[0]).toBeInstanceOf(test_user_1.TestUser);
             expect(admins).toHaveLength(2);
-        }));
-        it('should find admins with age less than 56', () => __awaiter(void 0, void 0, void 0, function* () {
-            const admins = yield model.find()
+        });
+        it('should find admins with age less than 56', async () => {
+            const admins = await model.find()
                 .where('admin', '==', true)
                 .where('age', '<', 50)
                 .get();
             expect(admins).toHaveLength(1);
             expect(admins[0].age).toBeLessThan(50);
-        }));
-        it('should query by subproperties', () => __awaiter(void 0, void 0, void 0, function* () {
-            const users = yield model.query({
+        });
+        it('should query by subproperties', async () => {
+            const users = await model.query({
                 operations: [
                     {
                         property: 'name',
@@ -117,63 +108,63 @@ describe('Model', () => {
                 ]
             });
             expect(users[0].id).toBe('user3');
-        }));
-        it('should find by subproperties', () => __awaiter(void 0, void 0, void 0, function* () {
-            const users = yield model.find()
+        });
+        it('should find by subproperties', async () => {
+            const users = await model.find()
                 .where('name', '==', { firstName: 'userFirstName3' })
                 .get();
             expect(users[0].id).toBe('user3');
-        }));
-        it('should find by property path', () => __awaiter(void 0, void 0, void 0, function* () {
-            const users = yield model.find()
+        });
+        it('should find by property path', async () => {
+            const users = await model.find()
                 .whereDeepProp('name.firstName', '==', 'userFirstName3')
                 .get();
             expect(users[0].id).toBe('user3');
-        }));
-        it('should find by superdeep property path', () => __awaiter(void 0, void 0, void 0, function* () {
-            const users = yield model.find()
+        });
+        it('should find by superdeep property path', async () => {
+            const users = await model.find()
                 .whereDeepProp('name.ancestorName.father', '==', 'user3Father')
                 .get();
             expect(users[0].id).toEqual('user3');
-        }));
-        it('should find by swallow property path', () => __awaiter(void 0, void 0, void 0, function* () {
-            const users = yield model.find()
+        });
+        it('should find by swallow property path', async () => {
+            const users = await model.find()
                 .whereDeepProp('age', '==', 21)
                 .get();
             expect(users[0].id).toEqual('user2');
-        }));
-        it('should return the whole collection on undefined query object', () => __awaiter(void 0, void 0, void 0, function* () {
-            const users = yield model.query();
+        });
+        it('should return the whole collection on undefined query object', async () => {
+            const users = await model.query();
             expect(users).toHaveLength(6);
-        }));
-        it('should return the whole collection on empty query object', () => __awaiter(void 0, void 0, void 0, function* () {
-            const users = yield model.query({});
+        });
+        it('should return the whole collection on empty query object', async () => {
+            const users = await model.query({});
             expect(users).toHaveLength(6);
-        }));
+        });
     });
     describe('Derived classes should fit on parent collection', () => {
-        it('should save derived object in parent collection', () => __awaiter(void 0, void 0, void 0, function* () {
+        it('should save derived object in parent collection', async () => {
             const derived = new test_user_1.DerivedUser();
             derived.name = { firstName: 'Fulanito', lastName: 'Derived', ancestorName: {} };
             derived.salary = 3900;
-            yield model.save(derived);
+            await model.save(derived);
             expect(rawData()['TestUser'][derived.id]['salary']).toBe(3900);
             expect(rawData()['TestUser'][derived.id]['__className']).toEqual('DerivedUser');
-        }));
-        it('should retrieve derived object by id ', () => __awaiter(void 0, void 0, void 0, function* () {
-            const derived = yield model.findById('user4');
+        });
+        it('should retrieve derived object by id ', async () => {
+            const derived = await model.findById('user4');
             expect(derived).toBeInstanceOf(test_user_1.DerivedUser);
             expect(derived.salary).toBe(2800);
-        }));
-        it('should find instances of derived classes', () => __awaiter(void 0, void 0, void 0, function* () {
-            const derived = yield model.find().instanceOf('DerivedUser').get();
+        });
+        it('should find instances of derived classes', async () => {
+            const derived = await model.find().instanceOf('DerivedUser').get();
             expect(derived[0]).toBeInstanceOf(test_user_1.DerivedUser);
             expect(derived[0].salary).toBe(2800);
-        }));
+        });
     });
     describe('References to documents', () => {
         let ref1, ref2;
-        beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        beforeEach(async () => {
             testUser.documentRef = new test_user_1.SubClass();
             testUser.documentRef.year = 2045;
             ref1 = new test_user_1.SubClass();
@@ -187,35 +178,35 @@ describe('Model', () => {
             testUser.manyDerived = [new test_user_1.DerivedUser(), new test_user_1.DerivedUser()];
             testUser.manyDerived[0].salary = 990;
             testUser.manyDerived[1].salary = 1990;
-            yield model.save(testUser);
-        }));
-        it('should save a document as a reference', () => __awaiter(void 0, void 0, void 0, function* () {
+            await model.save(testUser);
+        });
+        it('should save a document as a reference', async () => {
             expect(rawData()['SubClass']).toBeDefined();
             expect(rawData()['SubClass'][testUser.documentRef.id]).toEqual(expect.objectContaining({
                 __className: 'SubClass',
                 year: 2045
             }));
-        }));
-        it('should read a swallow document reference', () => __awaiter(void 0, void 0, void 0, function* () {
-            const loadedUser = yield model.findById(testUser.id);
+        });
+        it('should read a swallow document reference', async () => {
+            const loadedUser = await model.findById(testUser.id);
             expect(loadedUser.documentRef).toBeInstanceOf(test_user_1.SubClass);
             expect(loadedUser.documentRef.id).toBeDefined();
             expect(loadedUser.documentRef.year).toBeUndefined();
-        }));
-        it('should fill data of swallow document reference', () => __awaiter(void 0, void 0, void 0, function* () {
-            const loadedUser = yield model.findById(testUser.id);
-            yield store_1.Store.populate(loadedUser.documentRef);
+        });
+        it('should fill data of swallow document reference', async () => {
+            const loadedUser = await model.findById(testUser.id);
+            await store_1.Store.populate(loadedUser.documentRef);
             expect(loadedUser.documentRef.id).toBeDefined();
             expect(loadedUser.documentRef.year).toBe(2045);
-        }));
+        });
         it('should save and array of references', () => {
             expect(rawData()['SubClass'][ref1.id]).toBeDefined();
             expect(rawData()['SubClass'][ref1.id]['year']).toBe(2081);
             expect(rawData()['SubClass'][ref2.id]).toBeDefined();
             expect(rawData()['SubClass'][ref2.id]['year']).toBe(2082);
         });
-        it('should read an array of references', () => __awaiter(void 0, void 0, void 0, function* () {
-            const loadedUser = yield model.findById(testUser.id);
+        it('should read an array of references', async () => {
+            const loadedUser = await model.findById(testUser.id);
             expect(loadedUser.manyRefs).toHaveLength(2);
             expect(loadedUser.manyRefs[0]).toBeInstanceOf(test_user_1.SubClass);
             expect(loadedUser.manyRefs[0].id).toEqual(testUser.manyRefs[0].id);
@@ -223,168 +214,168 @@ describe('Model', () => {
             expect(loadedUser.manyRefs[1]).toBeInstanceOf(test_user_1.SubClass);
             expect(loadedUser.manyRefs[1].id).toEqual(testUser.manyRefs[1].id);
             expect(loadedUser.manyRefs[1].year).toBeUndefined();
-        }));
-        it('should fill array of refs', () => __awaiter(void 0, void 0, void 0, function* () {
-            const loadedUser = yield model.findById(testUser.id);
-            yield store_1.Store.populate(loadedUser.manyRefs);
+        });
+        it('should fill array of refs', async () => {
+            const loadedUser = await model.findById(testUser.id);
+            await store_1.Store.populate(loadedUser.manyRefs);
             expect(loadedUser.manyRefs[0].year).toBe(2081);
             expect(loadedUser.manyRefs[1].year).toBe(2082);
-        }));
-        it('should save a reference when declared @persistentAt', () => __awaiter(void 0, void 0, void 0, function* () {
-            const loadedUser = yield model.findById(testUser.id);
+        });
+        it('should save a reference when declared @persistentAt', async () => {
+            const loadedUser = await model.findById(testUser.id);
             expect(loadedUser.derived.id).toEqual(testUser.derived.id);
             expect(loadedUser.derived.salary).toBeUndefined();
-            yield store_1.Store.populate(loadedUser.derived);
+            await store_1.Store.populate(loadedUser.derived);
             expect(loadedUser.derived.salary).toBe(1350);
             expect(loadedUser.derived.id).toBe(testUser.derived.id);
-        }));
-        it('should populate from special collection when declared with @persistentRefAt', () => __awaiter(void 0, void 0, void 0, function* () {
-            const loadedUser = yield model.findById('user6');
-            yield store_1.Store.populate(loadedUser.derived);
+        });
+        it('should populate from special collection when declared with @persistentRefAt', async () => {
+            const loadedUser = await model.findById('user6');
+            await store_1.Store.populate(loadedUser.derived);
             expect(loadedUser.derived.salary).toBe(2800);
             expect(loadedUser.derived.id).toBe('user4');
-        }));
-        it('should save a reference when declared @persistentAt as array', () => __awaiter(void 0, void 0, void 0, function* () {
-            const loadedUser = yield model.findById(testUser.id);
+        });
+        it('should save a reference when declared @persistentAt as array', async () => {
+            const loadedUser = await model.findById(testUser.id);
             expect(loadedUser.manyDerived[0].id).toEqual(testUser.manyDerived[0].id);
             expect(loadedUser.manyDerived[0].salary).toBeUndefined();
             expect(loadedUser.manyDerived[1].salary).toBeUndefined();
-            yield store_1.Store.populate(loadedUser.manyDerived);
+            await store_1.Store.populate(loadedUser.manyDerived);
             expect(loadedUser.manyDerived[0].salary).toBe(990);
             expect(loadedUser.manyDerived[0].id).toBe(testUser.manyDerived[0].id);
             expect(loadedUser.manyDerived[1].salary).toBe(1990);
             expect(loadedUser.manyDerived[1].id).toBe(testUser.manyDerived[1].id);
-        }));
-        it('should not overwrite not filled ref in collection', () => __awaiter(void 0, void 0, void 0, function* () {
-            const loadedUser = yield model.findById('user6');
-            yield model.save(loadedUser);
-            const refInCollection = yield model.findById('user4');
+        });
+        it('should not overwrite not filled ref in collection', async () => {
+            const loadedUser = await model.findById('user6');
+            await model.save(loadedUser);
+            const refInCollection = await model.findById('user4');
             expect(refInCollection.salary).toBe(2800);
-        }));
-        it('should save loaded ref with assigned new instance', () => __awaiter(void 0, void 0, void 0, function* () {
-            const loadedUser = yield model.findById('user6');
+        });
+        it('should save loaded ref with assigned new instance', async () => {
+            const loadedUser = await model.findById('user6');
             loadedUser.derived = new test_user_1.DerivedUser();
             loadedUser.derived.salary = 345;
-            yield model.save(loadedUser);
-            const refInCollection = yield model.findById(loadedUser.derived.id);
+            await model.save(loadedUser);
+            const refInCollection = await model.findById(loadedUser.derived.id);
             expect(refInCollection.salary).toBe(345);
-        }));
-        it('should save loaded ref with modified ref data', () => __awaiter(void 0, void 0, void 0, function* () {
-            const loadedUser = yield model.findById('user6');
-            yield store_1.Store.populate(loadedUser.derived);
+        });
+        it('should save loaded ref with modified ref data', async () => {
+            const loadedUser = await model.findById('user6');
+            await store_1.Store.populate(loadedUser.derived);
             loadedUser.derived.salary = 1623;
-            yield model.save(loadedUser);
-            const refInCollection = yield model.findById('user4');
+            await model.save(loadedUser);
+            const refInCollection = await model.findById('user4');
             expect(refInCollection.salary).toBe(1623);
-        }));
-        it('should find by object ref', () => __awaiter(void 0, void 0, void 0, function* () {
-            const loadedDerived = yield model.findById('user4');
-            const loadedUser = yield model.find().where('derived', '==', loadedDerived).get();
+        });
+        it('should find by object ref', async () => {
+            const loadedDerived = await model.findById('user4');
+            const loadedUser = await model.find().where('derived', '==', loadedDerived).get();
             expect(loadedUser[0].id).toEqual('user6');
-        }));
-        it('should not throw on calling populate several times on same object', () => __awaiter(void 0, void 0, void 0, function* () {
-            const loadedUser = yield model.findById('user6');
-            yield store_1.Store.populate(loadedUser.derived);
+        });
+        it('should not throw on calling populate several times on same object', async () => {
+            const loadedUser = await model.findById('user6');
+            await store_1.Store.populate(loadedUser.derived);
             expect(loadedUser.derived['_documentRef']).not.toBeDefined();
             let thrown = false;
             try {
-                yield store_1.Store.populate(loadedUser.derived);
+                await store_1.Store.populate(loadedUser.derived);
             }
             catch (err) {
                 thrown = true;
             }
             expect(thrown).toBeFalsy();
-        }));
-        it('should not throw on populating undefined instances', () => __awaiter(void 0, void 0, void 0, function* () {
-            const loadedUser = yield model.findById('user6');
+        });
+        it('should not throw on populating undefined instances', async () => {
+            const loadedUser = await model.findById('user6');
             loadedUser.derived = undefined;
             let thrown = false;
             try {
-                yield store_1.Store.populate(loadedUser.derived);
+                await store_1.Store.populate(loadedUser.derived);
             }
             catch (err) {
                 thrown = true;
             }
             expect(thrown).toBeFalsy();
-        }));
-        it('should not throw on populating non existing reference', () => __awaiter(void 0, void 0, void 0, function* () {
-            const loadedUser = yield model.findById('user6');
+        });
+        it('should not throw on populating non existing reference', async () => {
+            const loadedUser = await model.findById('user6');
             loadedUser.derived['_id'] = 'non-existing';
             let thrown = false;
             try {
-                yield store_1.Store.populate(loadedUser.derived);
+                await store_1.Store.populate(loadedUser.derived);
             }
             catch (err) {
                 thrown = true;
             }
             expect(thrown).toBeFalsy();
-        }));
-        it('should remove deleted references when populating from the returned array', () => __awaiter(void 0, void 0, void 0, function* () {
-            const loadedUser = yield model.findById(testUser.id);
+        });
+        it('should remove deleted references when populating from the returned array', async () => {
+            const loadedUser = await model.findById(testUser.id);
             const deletedId = loadedUser.manyDerived[0].id;
-            yield model.delete(deletedId);
-            const manyDerived = yield store_1.Store.populate(loadedUser.manyDerived);
+            await model.delete(deletedId);
+            const manyDerived = await store_1.Store.populate(loadedUser.manyDerived);
             expect(manyDerived[0].id).not.toBe(deletedId);
             expect(manyDerived).toHaveLength(1);
-        }));
-        it('should report if populated for single reference', () => __awaiter(void 0, void 0, void 0, function* () {
-            const loadedUser = yield model.findById('user6');
+        });
+        it('should report if populated for single reference', async () => {
+            const loadedUser = await model.findById('user6');
             expect(store_1.Store.isPopulated(loadedUser.derived)).toBeFalsy();
-            yield store_1.Store.populate(loadedUser.derived);
+            await store_1.Store.populate(loadedUser.derived);
             expect(store_1.Store.isPopulated(loadedUser.derived)).toBeTruthy();
-        }));
-        it('should report if populated for multiple references', () => __awaiter(void 0, void 0, void 0, function* () {
-            const loadedUser = yield model.findById(testUser.id);
+        });
+        it('should report if populated for multiple references', async () => {
+            const loadedUser = await model.findById(testUser.id);
             expect(store_1.Store.isPopulated(loadedUser.manyDerived)).toBeFalsy();
-            yield store_1.Store.populate(loadedUser.manyDerived);
+            await store_1.Store.populate(loadedUser.manyDerived);
             expect(store_1.Store.isPopulated(loadedUser.manyDerived)).toBeTruthy();
-        }));
+        });
     });
     describe('Operations on queries', () => {
-        it('should limit the result set', () => __awaiter(void 0, void 0, void 0, function* () {
-            const unlimited = yield model.find().get();
-            const limited = yield model.find().limit(2).get();
+        it('should limit the result set', async () => {
+            const unlimited = await model.find().get();
+            const limited = await model.find().limit(2).get();
             expect(unlimited.length).not.toBe(limited.length);
             expect(limited).toHaveLength(2);
-        }));
-        it('should sort ascending the result set', () => __awaiter(void 0, void 0, void 0, function* () {
-            const docs = yield model.find().orderBy('age').get();
+        });
+        it('should sort ascending the result set', async () => {
+            const docs = await model.find().orderBy('age').get();
             expect(docs[0].id).toEqual('user2');
             expect(docs[1].id).toEqual('user1');
-        }));
-        it('should sort descending the result set', () => __awaiter(void 0, void 0, void 0, function* () {
-            const docs = yield model.find().orderBy('age', 'desc').get();
+        });
+        it('should sort descending the result set', async () => {
+            const docs = await model.find().orderBy('age', 'desc').get();
             expect(docs[0].id).toEqual('user3');
             expect(docs[1].id).toEqual('user5');
-        }));
-        it('should sort by deep property path', () => __awaiter(void 0, void 0, void 0, function* () {
-            const docs = yield model.find().orderByDeepProp('name.firstName', 'desc').get();
+        });
+        it('should sort by deep property path', async () => {
+            const docs = await model.find().orderByDeepProp('name.firstName', 'desc').get();
             expect(docs[0].id).toEqual('user6');
             expect(docs[1].id).toEqual('user5');
-        }));
-        it('should sort by swallow property path', () => __awaiter(void 0, void 0, void 0, function* () {
-            const docs = yield model.find().orderByDeepProp('age').get();
+        });
+        it('should sort by swallow property path', async () => {
+            const docs = await model.find().orderByDeepProp('age').get();
             expect(docs[0].id).toEqual('user2');
             expect(docs[1].id).toEqual('user1');
-        }));
-        it('should count the documents in the collection', () => __awaiter(void 0, void 0, void 0, function* () {
-            expect(yield model.find().count()).toBe(6);
-        }));
+        });
+        it('should count the documents in the collection', async () => {
+            expect(await model.find().count()).toBe(6);
+        });
         describe('Data Cursors', () => {
-            beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
-                yield model.find().get(2);
-            }));
-            it('should get next result set', () => __awaiter(void 0, void 0, void 0, function* () {
-                const docs = yield model.next();
+            beforeEach(async () => {
+                await model.find().get(2);
+            });
+            it('should get next result set', async () => {
+                const docs = await model.next();
                 expect(docs).toHaveLength(2);
                 expect(docs[0].id).toEqual('user3');
-            }));
-            it('should not go beyond the end of result set', () => __awaiter(void 0, void 0, void 0, function* () {
-                yield model.next();
-                yield model.next();
-                const docs = yield model.next();
+            });
+            it('should not go beyond the end of result set', async () => {
+                await model.next();
+                await model.next();
+                const docs = await model.next();
                 expect(docs).toHaveLength(0);
-            }));
+            });
         });
     });
     describe('Utility methods', () => {
@@ -415,26 +406,26 @@ describe('Model', () => {
     });
     describe('SubCollections', () => {
         let subCollectionModel;
-        beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
-            const user = yield model.findById('user1');
+        beforeEach(async () => {
+            const user = await model.findById('user1');
             subCollectionModel = store_1.Store.getModelForSubCollection(user, 'SubClass');
-        }));
+        });
         it('should get model for subCollection', () => {
             const model = store_1.Store.getModelForSubCollection(testUser, 'SubClass');
             expect(model.collectionName).toEqual(`TestUser/${testUser.id}/SubClass`);
         });
-        it('should find subCollection document by id', () => __awaiter(void 0, void 0, void 0, function* () {
-            const subClass = yield subCollectionModel.findById('subClass1');
+        it('should find subCollection document by id', async () => {
+            const subClass = await subCollectionModel.findById('subClass1');
             expect(subClass).toBeInstanceOf(test_user_1.SubClass);
             expect(subClass.year).toBe(1326);
-        }));
-        it('should save data to subCollection', () => __awaiter(void 0, void 0, void 0, function* () {
+        });
+        it('should save data to subCollection', async () => {
             const subClass = new test_user_1.SubClass();
             subClass.year = 3452;
-            yield subCollectionModel.save(subClass);
-            const loaded = yield subCollectionModel.findById(subClass.id);
+            await subCollectionModel.save(subClass);
+            const loaded = await subCollectionModel.findById(subClass.id);
             expect(loaded.year).toBe(3452);
-        }));
+        });
     });
     it('should pass Type tests', () => {
         //@ts-expect-error