@nymphjs/nymph 1.0.0-beta.5 → 1.0.0-beta.50

package/dist/driver/testArtifacts.js

@@ -9,8 +9,9 @@ const strtotime_1 = __importDefault(require("locutus/php/datetime/strtotime"));
 const guid_1 = require("@nymphjs/guid");
 const testArtifacts_1 = require("../testArtifacts");
 function QueriesTest(nymph, it) {
-    nymph.addEntityClass(testArtifacts_1.TestModel);
-    nymph.addEntityClass(testArtifacts_1.TestBModel);
+    const TestModel = nymph.addEntityClass(testArtifacts_1.TestModel);
+    const TestBModel = nymph.addEntityClass(testArtifacts_1.TestBModel);
+    const TestEmptyModel = nymph.addEntityClass(testArtifacts_1.TestEmptyModel);
     let testEntity;
     let testGuid;
     let refGuid;
@@ -19,7 +20,7 @@ function QueriesTest(nymph, it) {
         if (testGuid != null) {
             return;
         }
-        testEntity = await testArtifacts_1.TestModel.factory();
+        testEntity = await TestModel.factory();
         testEntity.name = 'Entity Test ' + new Date().toLocaleString();
         testEntity.null = null;
         testEntity.string = 'test';
@@ -28,14 +29,17 @@ function QueriesTest(nymph, it) {
 
 This one's email address is nice_hat-wednesday+newyork@im-a-hat.hat.
 This one's phone number is (555) 555-1818.
-This one's zip code is 92064.`;
+This one's zip code is 92064.
+This one's favorite emojis are 🔥❤️😊😂⭐🤔
+
+These hats are absolutely fantastic.`;
         testEntity.number = 30;
         testEntity.numberString = '30';
         testEntity.timestamp = Date.now();
         expect(await testEntity.$save()).toEqual(true);
         expect(testEntity.guid).not.toBeNull();
         testGuid = testEntity.guid;
-        const entityReferenceTest = new testArtifacts_1.TestModel();
+        const entityReferenceTest = new TestModel();
         entityReferenceTest.string = 'wrong';
         entityReferenceTest.timestamp = (0, strtotime_1.default)('-2 days') * 1000;
         expect(await entityReferenceTest.$save()).toEqual(true);
@@ -45,19 +49,17 @@ This one's zip code is 92064.`;
         expect(await testEntity.$save()).toEqual(true);
         entityReferenceTest.test = 'good';
         expect(await entityReferenceTest.$save()).toEqual(true);
-        testEntity = nymph.driver.getEntitySync({ class: testArtifacts_1.TestModel }, testGuid);
-        expect(testEntity).toBeInstanceOf(testArtifacts_1.TestModel);
-        expect(testEntity.guid).toEqual(testGuid);
-        testEntity = (await nymph.getEntity({ class: testArtifacts_1.TestModel }, testGuid));
-        expect(testEntity).toBeInstanceOf(testArtifacts_1.TestModel);
+        testEntity = (await nymph.getEntity({ class: TestModel }, testGuid));
+        expect(testEntity).toBeInstanceOf(TestModel);
         expect(testEntity.guid).toEqual(testGuid);
     }
     async function createMultipleTestEntities() {
         if (!createdMultiple) {
             createdMultiple = true;
             for (let i = 0; i < 100; i++) {
-                const testEntity = await testArtifacts_1.TestModel.factory();
+                const testEntity = await TestModel.factory();
                 testEntity.name = `Multi Test ${i}`;
+                testEntity.number = 100 - i;
                 testEntity.$removeTag('test');
                 testEntity.$addTag('multiTest');
                 expect(await testEntity.$save()).toEqual(true);
@@ -66,17 +68,22 @@ This one's zip code is 92064.`;
         }
     }
     it('delete old test data', async () => {
-        let all = await nymph.getEntities({ class: testArtifacts_1.TestModel });
+        let all = await nymph.getEntities({ class: TestModel });
         expect(Array.isArray(all)).toEqual(true);
         for (const cur of all) {
             expect(await cur.$delete()).toEqual(true);
         }
-        all = await nymph.getEntities({ class: testArtifacts_1.TestModel });
+        all = await nymph.getEntities({ class: TestModel });
         expect(all.length).toEqual(0);
     });
     it('create entity', async () => {
         await createTestEntities();
     });
+    it("doesn't create empty entity", async () => {
+        const testEntity = await TestEmptyModel.factory();
+        expect(await testEntity.$save()).toBeFalsy();
+        expect(testEntity.guid).toBeNull();
+    });
     it('update mdate on save', async () => {
         await createTestEntities();
         const oldMdate = testEntity.mdate ?? Infinity;
@@ -89,11 +96,11 @@ This one's zip code is 92064.`;
     });
     it('by guid', async () => {
         await createTestEntities();
-        let resultEntity = await nymph.getEntity({ class: testArtifacts_1.TestModel }, testGuid);
+        let resultEntity = await nymph.getEntity({ class: TestModel }, testGuid);
         expect(testEntity.$is(resultEntity)).toEqual(true);
-        resultEntity = await testArtifacts_1.TestModel.factory(testGuid);
+        resultEntity = await TestModel.factory(testGuid);
         expect(testEntity.$is(resultEntity)).toEqual(true);
-        resultEntity = await nymph.getEntity({ class: testArtifacts_1.TestModel }, (0, guid_1.guid)());
+        resultEntity = await nymph.getEntity({ class: TestModel }, (0, guid_1.guid)());
         expect(testEntity.$is(resultEntity)).toEqual(false);
     });
     it('transactions', async () => {
@@ -116,18 +123,18 @@ This one's zip code is 92064.`;
         testEntity.$nymph = transaction;
         expect(await transaction.inTransaction()).toEqual(true);
         expect(await testEntity.$delete()).toEqual(true);
-        const resultEntity = await transaction.getEntity({ class: testArtifacts_1.TestModel }, testGuid);
+        const resultEntity = await transaction.getEntity({ class: TestModel }, testGuid);
         expect(resultEntity).toBeNull();
         await transaction.rollback('test');
         expect(await transaction.inTransaction()).toEqual(false);
-        testEntity = (await transaction.getEntity({ class: testArtifacts_1.TestModel }, testGuid));
+        testEntity = (await transaction.getEntity({ class: TestModel }, testGuid));
         expect(testEntity.guid).toEqual(testGuid);
-        transaction = await nymph.startTransaction('test');
+        transaction = await nymph.startTransaction('test.1');
         testEntity.$nymph = transaction;
         expect(await transaction.inTransaction()).toEqual(true);
         testEntity.string = 'fish';
         expect(await testEntity.$save()).toEqual(true);
-        await transaction.commit('test');
+        await transaction.commit('test.1');
         testEntity.$nymph = nymph;
         expect(await transaction.inTransaction()).toEqual(false);
         await testEntity.$refresh();
@@ -138,7 +145,7 @@ This one's zip code is 92064.`;
     it('options', async () => {
         await createTestEntities();
         const resultEntities = await nymph.getEntities({
-            class: testArtifacts_1.TestModel,
+            class: TestModel,
             reverse: true,
             offset: 1,
             limit: 1,
@@ -149,174 +156,174 @@ This one's zip code is 92064.`;
     });
     it('guid and tags', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntity({ class: testArtifacts_1.TestModel }, { type: '&', guid: testGuid, tag: 'test' });
+        const resultEntity = await nymph.getEntity({ class: TestModel }, { type: '&', guid: testGuid, tag: 'test' });
         expect(testEntity.$is(resultEntity)).toEqual(true);
     });
     it('or selector', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntity({ class: testArtifacts_1.TestModel }, { type: '|', guid: [testGuid, (0, guid_1.guid)()] });
+        const resultEntity = await nymph.getEntity({ class: TestModel }, { type: '|', guid: [testGuid, (0, guid_1.guid)()] });
         expect(testEntity.$is(resultEntity)).toEqual(true);
     });
     it('wrong or selector', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntity({ class: testArtifacts_1.TestModel }, { type: '|', guid: [(0, guid_1.guid)(), (0, guid_1.guid)()] });
+        const resultEntity = await nymph.getEntity({ class: TestModel }, { type: '|', guid: [(0, guid_1.guid)(), (0, guid_1.guid)()] });
         expect(testEntity.$is(resultEntity)).toEqual(false);
     });
     it('not guid', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', '!guid': (0, guid_1.guid)(), tag: 'test' });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', '!guid': (0, guid_1.guid)(), tag: 'test' });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('not tags', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', guid: testGuid, '!tag': ['barbecue', 'pickles'] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', guid: testGuid, '!tag': ['barbecue', 'pickles'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('guid and wrong tags', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntity({ class: testArtifacts_1.TestModel }, { type: '&', guid: testGuid, tag: ['pickles'] });
+        const resultEntity = await nymph.getEntity({ class: TestModel }, { type: '&', guid: testGuid, tag: ['pickles'] });
         expect(resultEntity).toBeNull();
     });
     it('tags', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', tag: 'test' });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test' });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('wrong tags', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', tag: 'pickles' });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'pickles' });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('inclusive tags', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '|', tag: ['pickles', 'test', 'barbecue'] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '|', tag: ['pickles', 'test', 'barbecue'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('wrong inclusive tags', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '|', tag: ['pickles', 'barbecue'] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '|', tag: ['pickles', 'barbecue'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('mixed tags', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', tag: 'test' }, { type: '|', tag: ['pickles', 'test', 'barbecue'] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test' }, { type: '|', tag: ['pickles', 'test', 'barbecue'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('wrong inclusive mixed tags', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', tag: 'test' }, { type: '|', tag: ['pickles', 'barbecue'] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test' }, { type: '|', tag: ['pickles', 'barbecue'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('wrong exclusive mixed tags', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', tag: 'pickles' }, { type: '|', tag: ['test', 'barbecue'] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'pickles' }, { type: '|', tag: ['test', 'barbecue'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('defined', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', defined: 'string' });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', defined: 'string' });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('not defined', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', tag: 'test', '!defined': 'pickles' });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test', '!defined': 'pickles' });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('defined in a not and clause', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '!&', defined: 'pickles' }, { type: '&', tag: 'test' });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '!&', defined: 'pickles' }, { type: '&', tag: 'test' });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('equal', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', equal: ['string', 'test'] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', equal: ['string', 'test'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('not equal', async () => {
         await createTestEntities();
-        const referenceEntity = await testArtifacts_1.TestModel.factory(refGuid);
+        const referenceEntity = await TestModel.factory(refGuid);
         expect(referenceEntity.guid).toEqual(refGuid);
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', tag: 'test', '!equal': ['string', 'wrong'] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test', '!equal': ['string', 'wrong'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
         expect(referenceEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('like', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', like: ['string', 't_s%'] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', like: ['string', 't_s%'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('not like', async () => {
         await createTestEntities();
-        const referenceEntity = await testArtifacts_1.TestModel.factory(refGuid);
+        const referenceEntity = await TestModel.factory(refGuid);
         expect(referenceEntity.guid).toEqual(refGuid);
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', tag: 'test', '!like': ['string', 'wr_n%'] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test', '!like': ['string', 'wr_n%'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
         expect(referenceEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('ilike', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', ilike: ['string', 'T_s%'] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', ilike: ['string', 'T_s%'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('not ilike', async () => {
         await createTestEntities();
-        const referenceEntity = await testArtifacts_1.TestModel.factory(refGuid);
+        const referenceEntity = await TestModel.factory(refGuid);
         expect(referenceEntity.guid).toEqual(refGuid);
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', tag: 'test', '!ilike': ['string', 'wr_n%'] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test', '!ilike': ['string', 'wr_n%'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
         expect(referenceEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('like with wrong case', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', like: ['string', 'T_s%'] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', like: ['string', 'T_s%'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('tags and equal', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', tag: 'test', equal: ['string', 'test'] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test', equal: ['string', 'test'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('wrong tags right equal', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', tag: 'pickles', equal: ['string', 'test'] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'pickles', equal: ['string', 'test'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('right tags wrong equal', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', tag: 'test', equal: ['string', 'pickles'] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test', equal: ['string', 'pickles'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('wrong tags wrong equal', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', tag: 'pickles', equal: ['string', 'pickles'] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'pickles', equal: ['string', 'pickles'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('contain', async () => {
         await createTestEntities();
-        let resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', contain: ['array', 'values'] });
+        let resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', contain: ['array', 'values'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', contain: ['string', 'test'] });
+        resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', contain: ['string', 'test'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('not contain', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', tag: 'test' }, { type: '!&', contain: ['array', 'pickles'] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test' }, { type: '!&', contain: ['array', 'pickles'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('wrong contain', async () => {
         await createTestEntities();
-        let resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', contain: ['array', 'pickles'] });
+        let resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', contain: ['array', 'pickles'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', contain: ['string', 'pickles'] });
+        resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', contain: ['string', 'pickles'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('match', async () => {
         await createTestEntities();
-        let resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', match: ['match', '.*'] });
+        let resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', match: ['match', '.*'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', tag: 'test', match: ['match', 'Edward McCheese'] });
+        resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test', match: ['match', 'Edward McCheese'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', tag: 'test' }, {
+        resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test' }, {
             type: '|',
             match: [
                 ['string', '[0-9]'],
@@ -324,13 +331,13 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '&',
             tag: 'test',
             match: ['match', '[-a-zA-Z0-9+_]+@[-a-zA-Z0-9_]+.[-a-zA-Z0-9_]{2,4}'],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '&',
             tag: 'test',
             match: ['match', '\\([0-9]{3}\\) [0-9]{3}-[0-9]{4}'],
@@ -339,16 +346,16 @@ This one's zip code is 92064.`;
     });
     it('imatch', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', tag: 'test', imatch: ['match', 'edward mccheese'] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test', imatch: ['match', 'edward mccheese'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('wrong match', async () => {
         await createTestEntities();
-        let resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', match: ['match', 'Q'] });
+        let resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', match: ['match', 'Q'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', tag: 'pickle', match: ['match', '.*'] });
+        resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'pickle', match: ['match', '.*'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             match: [
                 ['string', '[0-9]'],
@@ -359,17 +366,17 @@ This one's zip code is 92064.`;
     });
     it('match wrong case', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', tag: 'test', match: ['match', 'edward mccheese'] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test', match: ['match', 'edward mccheese'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('match and equal inclusive', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', tag: 'test' }, { type: '|', equal: ['string', 'pickles'], match: ['string', 'test'] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test' }, { type: '|', equal: ['string', 'pickles'], match: ['string', 'test'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('greater than', async () => {
         await createTestEntities();
-        let resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        let resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gt: [
                 ['number', 30],
@@ -377,7 +384,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gt: [
                 ['number', 31],
@@ -385,7 +392,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gt: [
                 ['number', 29],
@@ -393,7 +400,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gt: [
                 ['numberString', 30],
@@ -401,7 +408,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gt: [
                 ['numberString', 31],
@@ -409,7 +416,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gt: [
                 ['numberString', 29],
@@ -420,7 +427,7 @@ This one's zip code is 92064.`;
     });
     it('greater than or equal', async () => {
         await createTestEntities();
-        let resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        let resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gte: [
                 ['number', 30],
@@ -428,7 +435,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gte: [
                 ['number', 31],
@@ -436,7 +443,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gte: [
                 ['number', 29],
@@ -444,7 +451,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gte: [
                 ['numberString', 30],
@@ -452,7 +459,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gte: [
                 ['numberString', 31],
@@ -460,7 +467,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gte: [
                 ['numberString', 29],
@@ -471,7 +478,7 @@ This one's zip code is 92064.`;
     });
     it('less than', async () => {
         await createTestEntities();
-        let resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        let resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lt: [
                 ['number', 30],
@@ -479,7 +486,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lt: [
                 ['number', 31],
@@ -487,7 +494,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lt: [
                 ['number', 29],
@@ -495,7 +502,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lt: [
                 ['numberString', 30],
@@ -503,7 +510,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lt: [
                 ['numberString', 31],
@@ -511,7 +518,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lt: [
                 ['numberString', 29],
@@ -522,7 +529,7 @@ This one's zip code is 92064.`;
     });
     it('less than or equal', async () => {
         await createTestEntities();
-        let resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        let resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lte: [
                 ['number', 30],
@@ -530,7 +537,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lte: [
                 ['number', 31],
@@ -538,7 +545,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lte: [
                 ['number', 29],
@@ -546,7 +553,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lte: [
                 ['numberString', 30],
@@ -554,7 +561,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lte: [
                 ['numberString', 31],
@@ -562,7 +569,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lte: [
                 ['numberString', 29],
@@ -573,31 +580,31 @@ This one's zip code is 92064.`;
     });
     it('not inequality', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', tag: 'test' }, { type: '!&', gte: ['number', 60] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test' }, { type: '!&', gte: ['number', 60] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('wrong inequality', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', lte: ['number', 29.99] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', lte: ['number', 29.99] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('greater than cdate', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', tag: 'test', gt: ['cdate', (testEntity.cdate ?? 0) - 120] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test', gt: ['cdate', (testEntity.cdate ?? 0) - 120] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('wrong cdate', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', tag: 'test', gte: ['cdate', (testEntity.cdate ?? 0) + 1] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test', gte: ['cdate', (testEntity.cdate ?? 0) + 1] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('time selector', async () => {
         await createTestEntities();
-        const referenceEntity = await testArtifacts_1.TestModel.factory(refGuid);
-        let resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', gt: ['timestamp', null, '-1 day'] });
+        const referenceEntity = await TestModel.factory(refGuid);
+        let resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', gt: ['timestamp', null, '-1 day'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
         expect(referenceEntity.$inArray(resultEntity)).toEqual(false);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gt: [
                 ['timestamp', null, '-1 day'],
@@ -606,54 +613,56 @@ This one's zip code is 92064.`;
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
         expect(referenceEntity.$inArray(resultEntity)).toEqual(false);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', gt: ['timestamp', null, '-3 days'] });
+        resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', gt: ['timestamp', null, '-3 days'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
         expect(referenceEntity.$inArray(resultEntity)).toEqual(true);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', gt: ['cdate', null, '-1 day'] });
+        resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', gt: ['cdate', null, '-1 day'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
         expect(referenceEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('wrong time selector', async () => {
         await createTestEntities();
-        const referenceEntity = await testArtifacts_1.TestModel.factory(refGuid);
-        let resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', tag: 'test', gt: ['timestamp', null, '+1 day'] });
+        const referenceEntity = await TestModel.factory(refGuid);
+        let resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test', gt: ['timestamp', null, '+1 day'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
         expect(referenceEntity.$inArray(resultEntity)).toEqual(false);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', tag: 'test', lt: ['timestamp', null, '-3 days'] });
+        resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test', lt: ['timestamp', null, '-3 days'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
         expect(referenceEntity.$inArray(resultEntity)).toEqual(false);
-        resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', tag: 'test', gt: ['cdate', null, '+1 day'] });
+        resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test', gt: ['cdate', null, '+1 day'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
         expect(referenceEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('references', async () => {
         await createTestEntities();
+        await testEntity.reference?.$wake();
         expect(testEntity.reference?.test).toEqual('good');
+        await Promise.all(testEntity.refArray?.map((e) => e.$wake()) || []);
         expect(testEntity.refArray?.[0].test).toEqual('good');
     });
     it('ref', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', ref: ['reference', refGuid] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', ref: ['reference', refGuid] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('not ref', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', tag: 'test' }, { type: '!&', ref: ['reference', (0, guid_1.guid)()] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test' }, { type: '!&', ref: ['reference', (0, guid_1.guid)()] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('wrong ref', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', ref: ['reference', (0, guid_1.guid)()] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', ref: ['reference', (0, guid_1.guid)()] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('nonexistent ref', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', ref: ['pickle', refGuid] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', ref: ['pickle', refGuid] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('inclusive ref', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             ref: [
                 ['reference', refGuid],
@@ -664,7 +673,7 @@ This one's zip code is 92064.`;
     });
     it('wrong inclusive ref', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             ref: [
                 ['reference', (0, guid_1.guid)()],
@@ -675,12 +684,12 @@ This one's zip code is 92064.`;
     });
     it('ref in an array', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', ref: ['refArray', refGuid] });
+        const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', ref: ['refArray', refGuid] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('wrong ref in an array', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '&',
             ref: [
                 ['refArray', refGuid],
@@ -691,7 +700,7 @@ This one's zip code is 92064.`;
     });
     it('logic operations', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '&',
             '!ref': [
                 ['refArray', (0, guid_1.guid)()],
@@ -727,34 +736,34 @@ This one's zip code is 92064.`;
     });
     it('count return', async () => {
         await createTestEntities();
-        const result = await nymph.getEntities({ class: testArtifacts_1.TestModel });
+        const result = await nymph.getEntities({ class: TestModel });
         const resultCount = await nymph.getEntities({
-            class: testArtifacts_1.TestModel,
+            class: TestModel,
             return: 'count',
         });
         expect(resultCount).toBeGreaterThanOrEqual(1);
         expect(resultCount).toEqual(result.length);
-        const resultSelectors = await nymph.getEntities({ class: testArtifacts_1.TestModel }, { type: '&', ref: ['reference', refGuid] });
-        const resultSelectorsCount = await nymph.getEntities({ class: testArtifacts_1.TestModel, return: 'count' }, { type: '&', ref: ['reference', refGuid] });
+        const resultSelectors = await nymph.getEntities({ class: TestModel }, { type: '&', ref: ['reference', refGuid] });
+        const resultSelectorsCount = await nymph.getEntities({ class: TestModel, return: 'count' }, { type: '&', ref: ['reference', refGuid] });
         expect(resultSelectorsCount).toBeGreaterThanOrEqual(1);
         expect(resultSelectorsCount).toEqual(resultSelectors.length);
         const resultSelectorsLimit = await nymph.getEntities({
-            class: testArtifacts_1.TestModel,
+            class: TestModel,
             limit: 1,
             return: 'count',
         });
         expect(resultSelectorsLimit).toEqual(1);
         const resultSelectorsSingle = await nymph.getEntity({
-            class: testArtifacts_1.TestModel,
+            class: TestModel,
             return: 'count',
         });
         expect(resultSelectorsSingle).toEqual(1);
-        const resultSelectorsEmpty = await nymph.getEntities({ class: testArtifacts_1.TestModel, return: 'count' }, { type: '&', ref: ['reference', (0, guid_1.guid)()] });
+        const resultSelectorsEmpty = await nymph.getEntities({ class: TestModel, return: 'count' }, { type: '&', ref: ['reference', (0, guid_1.guid)()] });
         expect(resultSelectorsEmpty).toEqual(0);
     });
     it('guid return', async () => {
         await createTestEntities();
-        const resultGuid = await nymph.getEntities({ class: testArtifacts_1.TestModel, return: 'guid' }, {
+        const resultGuid = await nymph.getEntities({ class: TestModel, return: 'guid' }, {
             type: '&',
             '!ref': [
                 ['refArray', (0, guid_1.guid)()],
@@ -790,7 +799,7 @@ This one's zip code is 92064.`;
     });
     it('deep selector', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '&',
             '!ref': [
                 ['refArray', (0, guid_1.guid)()],
@@ -830,7 +839,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
-        const resultEntity2 = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        const resultEntity2 = await nymph.getEntities({ class: TestModel }, {
             type: '&',
             '!ref': [
                 ['refArray', (0, guid_1.guid)()],
@@ -870,7 +879,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity2)).toEqual(true);
-        const resultEntity3 = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        const resultEntity3 = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             selector: [
                 {
@@ -882,7 +891,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity3)).toEqual(true);
-        const resultEntity4 = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        const resultEntity4 = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             selector: [
                 {
@@ -902,7 +911,7 @@ This one's zip code is 92064.`;
         expect(testEntity.$inArray(resultEntity4)).toEqual(true);
     });
     it('wrong deep selector', async () => {
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '&',
             selector: [
                 {
@@ -917,62 +926,59 @@ This one's zip code is 92064.`;
     });
     it('qref', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '&',
             qref: [
                 'reference',
-                [{ class: testArtifacts_1.TestModel }, { type: '&', equal: ['test', 'good'] }],
+                [{ class: TestModel }, { type: '&', equal: ['test', 'good'] }],
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('not qref', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '&',
             '!qref': [
                 'reference',
-                [{ class: testArtifacts_1.TestModel }, { type: '&', equal: ['test', 'pickles'] }],
+                [{ class: TestModel }, { type: '&', equal: ['test', 'pickles'] }],
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('wrong qref class', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '&',
             qref: [
                 'reference',
-                [{ class: testArtifacts_1.TestBModel }, { type: '&', equal: ['test', 'good'] }],
+                [{ class: TestBModel }, { type: '&', equal: ['test', 'good'] }],
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('wrong qref data', async () => {
         await createTestEntities();
-        const resultEntity = await nymph.getEntities({ class: testArtifacts_1.TestModel }, {
+        const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '&',
             qref: [
                 'reference',
-                [{ class: testArtifacts_1.TestModel }, { type: '&', equal: ['test', 'pickles'] }],
+                [{ class: TestModel }, { type: '&', equal: ['test', 'pickles'] }],
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
-    it('sort option', async () => {
+    it('cdate and mdate sort option', async () => {
         await createMultipleTestEntities();
         for (const sort of ['cdate', 'mdate']) {
-            let resultEntities = await nymph.getEntities({
-                class: testArtifacts_1.TestModel,
-                sort: sort,
-            });
+            let resultEntities = await nymph.getEntities({ class: TestModel, sort });
             expect(resultEntities.length).toBeGreaterThan(100);
             for (let i = 0; i < resultEntities.length - 1; i++) {
                 expect(resultEntities[i + 1][sort]).toBeGreaterThan(resultEntities[i][sort] ?? 0);
             }
             let resultGuids = await nymph.getEntities({
-                class: testArtifacts_1.TestModel,
-                sort: sort,
+                class: TestModel,
+                sort,
                 return: 'guid',
             });
             expect(resultGuids.length).toBeGreaterThan(100);
@@ -980,43 +986,84 @@ This one's zip code is 92064.`;
                 expect(resultGuids[i]).toEqual(resultEntities[i].guid);
             }
             resultEntities = await nymph.getEntities({
-                class: testArtifacts_1.TestModel,
-                sort: sort,
+                class: TestModel,
+                sort,
                 reverse: true,
             });
             expect(resultEntities.length).toBeGreaterThan(100);
             for (let i = 0; i < resultEntities.length - 1; i++) {
                 expect(resultEntities[i + 1][sort]).toBeLessThan(resultEntities[i][sort] ?? 0);
             }
-            resultEntities = await nymph.getEntities({ class: testArtifacts_1.TestModel, sort: sort }, { type: '&', match: ['name', '^Multi Test '] });
+            resultEntities = await nymph.getEntities({ class: TestModel, sort }, { type: '&', match: ['name', '^Multi Test '] });
             expect(resultEntities.length).toEqual(100);
             for (let i = 0; i < resultEntities.length - 1; i++) {
                 expect(resultEntities[i + 1][sort]).toBeGreaterThan(resultEntities[i][sort] ?? 0);
             }
-            resultEntities = await nymph.getEntities({ class: testArtifacts_1.TestModel, sort: sort, reverse: true }, { type: '&', match: ['name', '^Multi Test '] });
+            resultEntities = await nymph.getEntities({ class: TestModel, sort, reverse: true }, { type: '&', match: ['name', '^Multi Test '] });
             expect(resultEntities.length).toEqual(100);
             for (let i = 0; i < resultEntities.length - 1; i++) {
                 expect(resultEntities[i + 1][sort]).toBeLessThan(resultEntities[i][sort] ?? 0);
             }
         }
     });
+    it('property sort option', async () => {
+        await createMultipleTestEntities();
+        let resultEntities = await nymph.getEntities({
+            class: TestModel,
+            sort: 'number',
+        });
+        expect(resultEntities.length).toBeGreaterThan(100);
+        for (let i = 0; i < resultEntities.length - 1; i++) {
+            expect(resultEntities[i + 1].number ?? Infinity).toBeGreaterThanOrEqual(resultEntities[i].number ?? 0);
+        }
+        let resultGuids = await nymph.getEntities({
+            class: TestModel,
+            sort: 'number',
+            return: 'guid',
+        });
+        expect(resultGuids.length).toBeGreaterThan(100);
+        for (let i = 0; i < resultGuids.length - 1; i++) {
+            expect(resultGuids[i]).toEqual(resultEntities[i].guid);
+        }
+        resultEntities = await nymph.getEntities({
+            class: TestModel,
+            sort: 'number',
+            reverse: true,
+        });
+        expect(resultEntities.length).toBeGreaterThan(100);
+        for (let i = 0; i < resultEntities.length - 1; i++) {
+            expect(resultEntities[i + 1].number ?? 0).toBeLessThanOrEqual(resultEntities[i].number ?? Infinity);
+        }
+        resultEntities = await nymph.getEntities({ class: TestModel, sort: 'number' }, { type: '&', match: ['name', '^Multi Test '] });
+        expect(resultEntities.length).toEqual(100);
+        for (let i = 0; i < resultEntities.length - 1; i++) {
+            expect(resultEntities[i + 1].number ?? Infinity).toBeGreaterThan(resultEntities[i].number ?? 0);
+            expect(resultEntities[i].name).toEqual(`Multi Test ${100 - (resultEntities[i].number ?? 0)}`);
+        }
+        resultEntities = await nymph.getEntities({ class: TestModel, sort: 'number', reverse: true }, { type: '&', match: ['name', '^Multi Test '] });
+        expect(resultEntities.length).toEqual(100);
+        for (let i = 0; i < resultEntities.length - 1; i++) {
+            expect(resultEntities[i + 1].number ?? 0).toBeLessThan(resultEntities[i].number ?? Infinity);
+            expect(resultEntities[i].name).toEqual(`Multi Test ${100 - (resultEntities[i].number ?? 0)}`);
+        }
+    });
     it('delete reference', async () => {
         await createTestEntities();
+        await testEntity.reference?.$wake();
         expect(await testEntity.reference?.$delete()).toEqual(true);
+        await Promise.all(testEntity.refArray?.map((e) => e.$wake()) || []);
         expect(testEntity.reference?.guid).toBeNull();
     });
     it('delete', async () => {
         await createTestEntities();
         expect(await testEntity.$delete()).toEqual(true);
         expect(testEntity.guid).toBeNull();
-        const entity = await nymph.getEntity({ class: testArtifacts_1.TestModel }, { type: '&', guid: testGuid });
+        const entity = await nymph.getEntity({ class: TestModel }, { type: '&', guid: testGuid });
         expect(entity).toBeNull();
     });
 }
 exports.QueriesTest = QueriesTest;
 function UIDTest(nymph, it) {
-    nymph.addEntityClass(testArtifacts_1.TestModel);
-    nymph.addEntityClass(testArtifacts_1.TestBModel);
     it('delete old test data', async () => {
         expect(await nymph.deleteUID('TestUID')).toEqual(true);
         expect(await nymph.deleteUID('NewUID')).toEqual(true);
@@ -1049,22 +1096,22 @@ function UIDTest(nymph, it) {
 }
 exports.UIDTest = UIDTest;
 function ExportImportTest(nymph, it) {
-    nymph.addEntityClass(testArtifacts_1.TestModel);
-    nymph.addEntityClass(testArtifacts_1.TestBModel);
+    const TestModel = nymph.addEntityClass(testArtifacts_1.TestModel);
+    const TestBModel = nymph.addEntityClass(testArtifacts_1.TestBModel);
     async function deleteTestData() {
-        let all = await nymph.getEntities({ class: testArtifacts_1.TestModel });
+        let all = await nymph.getEntities({ class: TestModel });
         expect(Array.isArray(all)).toEqual(true);
         for (const cur of all) {
             expect(await cur.$delete()).toEqual(true);
         }
-        all = await nymph.getEntities({ class: testArtifacts_1.TestModel });
+        all = await nymph.getEntities({ class: TestModel });
         expect(all.length).toEqual(0);
-        all = await nymph.getEntities({ class: testArtifacts_1.TestBModel });
+        all = await nymph.getEntities({ class: TestBModel });
         expect(Array.isArray(all)).toEqual(true);
         for (const cur of all) {
             expect(await cur.$delete()).toEqual(true);
         }
-        all = await nymph.getEntities({ class: testArtifacts_1.TestBModel });
+        all = await nymph.getEntities({ class: TestBModel });
         expect(all.length).toEqual(0);
         expect(await nymph.deleteUID('TestUID')).toEqual(true);
         expect(await nymph.deleteUID('TestUID2')).toEqual(true);
@@ -1072,8 +1119,8 @@ function ExportImportTest(nymph, it) {
     async function checkEntityDataAndCount() {
         expect(await nymph.getUID('TestUID')).toEqual(2);
         expect(await nymph.getUID('TestUID2')).toEqual(1);
-        const models = await nymph.getEntities({ class: testArtifacts_1.TestModel });
-        const bmodels = await nymph.getEntities({ class: testArtifacts_1.TestBModel });
+        const models = await nymph.getEntities({ class: TestModel });
+        const bmodels = await nymph.getEntities({ class: TestBModel });
         expect(models.length).toEqual(30);
         expect(bmodels.length).toEqual(10);
         const all = [...models, ...bmodels];
@@ -1084,9 +1131,11 @@ function ExportImportTest(nymph, it) {
                 expect(model.array).toEqual(['full', 'of', 'values', 500]);
                 expect(model.number).toEqual(30);
                 expect(model.timestamp).toBeGreaterThanOrEqual((0, strtotime_1.default)('-2 minutes'));
+                await model.reference?.$wake();
                 expect(model.reference?.guid).not.toBeNull();
                 expect(model.reference?.string).toEqual('another');
                 expect(model.reference?.index?.match(/^\d+b$/)).toBeTruthy();
+                await Promise.all(model.refArray?.map((e) => e.$wake()) || []);
                 expect(model.refArray?.[0].guid).not.toBeNull();
                 expect(model.refArray?.[0].guid).toEqual(model.reference?.guid);
             }
@@ -1100,7 +1149,7 @@ function ExportImportTest(nymph, it) {
         expect(await nymph.newUID('TestUID')).toEqual(2);
         expect(await nymph.newUID('TestUID2')).toEqual(1);
         for (let i = 0; i < 20; i++) {
-            const EntityClass = i < 15 ? testArtifacts_1.TestModel : testArtifacts_1.TestBModel;
+            const EntityClass = i < 15 ? TestModel : TestBModel;
             const testEntity = await EntityClass.factory();
             testEntity.name = 'Entity Test ' + new Date().toLocaleString();
             testEntity.null = null;
@@ -1128,8 +1177,8 @@ function ExportImportTest(nymph, it) {
     it('import data', async () => {
         expect(await nymph.getUID('TestUID')).toBeNull();
         expect(await nymph.getUID('TestUID2')).toBeNull();
-        const models = await nymph.getEntities({ class: testArtifacts_1.TestModel });
-        const bmodels = await nymph.getEntities({ class: testArtifacts_1.TestBModel });
+        const models = await nymph.getEntities({ class: TestModel });
+        const bmodels = await nymph.getEntities({ class: TestBModel });
         expect(models.length).toEqual(0);
         expect(bmodels.length).toEqual(0);
         expect(await nymph.import(__dirname + '/testentityexport.nex')).toEqual(true);