@nymphjs/nymph 1.0.0-beta.6 → 1.0.0-beta.61

package/dist/driver/testArtifacts.js

@@ -3,23 +3,28 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExportImportTest = exports.UIDTest = exports.QueriesTest = void 0;
+exports.ExportImportTest = exports.UIDTest = exports.EntitiesTest = void 0;
 const fs_1 = __importDefault(require("fs"));
 const strtotime_1 = __importDefault(require("locutus/php/datetime/strtotime"));
 const guid_1 = require("@nymphjs/guid");
+const errors_1 = require("../errors");
 const testArtifacts_1 = require("../testArtifacts");
-function QueriesTest(nymph, it) {
+function EntitiesTest(nymph, it) {
     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;
     let createdMultiple = false;
+    // The entities created by this function are required by many of the tests.
     async function createTestEntities() {
         if (testGuid != null) {
             return;
         }
+        // Creating entity...
         testEntity = await TestModel.factory();
+        // Saving entity...
         testEntity.name = 'Entity Test ' + new Date().toLocaleString();
         testEntity.null = null;
         testEntity.string = 'test';
@@ -28,7 +33,10 @@ 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();
@@ -45,22 +53,25 @@ 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: TestModel }, testGuid);
-        expect(testEntity).toBeInstanceOf(TestModel);
-        expect(testEntity.guid).toEqual(testGuid);
+        // Test asynchronous getEntity.
         testEntity = (await nymph.getEntity({ class: TestModel }, testGuid));
         expect(testEntity).toBeInstanceOf(TestModel);
         expect(testEntity.guid).toEqual(testGuid);
     }
+    // The entities created by this function are required by many of the tests.
     async function createMultipleTestEntities() {
         if (!createdMultiple) {
             createdMultiple = true;
+            // Creating 100 entities...
             for (let i = 0; i < 100; i++) {
                 const testEntity = await TestModel.factory();
                 testEntity.name = `Multi Test ${i}`;
+                // Reverse the number for sort testing.
+                testEntity.number = 100 - i;
                 testEntity.$removeTag('test');
                 testEntity.$addTag('multiTest');
                 expect(await testEntity.$save()).toEqual(true);
+                // Pause for a few milliseconds so the cdate and mdate can be sorted.
                 await new Promise((res) => setTimeout(() => res(1), 5));
             }
         }
@@ -77,6 +88,11 @@ This one's zip code is 92064.`;
     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,15 +105,19 @@ This one's zip code is 92064.`;
     });
     it('by guid', async () => {
         await createTestEntities();
+        // Retrieving entity by GUID...
         let resultEntity = await nymph.getEntity({ class: TestModel }, testGuid);
         expect(testEntity.$is(resultEntity)).toEqual(true);
+        // Using class constructor...
         resultEntity = await TestModel.factory(testGuid);
         expect(testEntity.$is(resultEntity)).toEqual(true);
+        // Testing wrong GUID...
         resultEntity = await nymph.getEntity({ class: TestModel }, (0, guid_1.guid)());
         expect(testEntity.$is(resultEntity)).toEqual(false);
     });
     it('transactions', async () => {
         await createTestEntities();
+        // Verify not in a transaction.
         expect(await nymph.inTransaction()).toEqual(false);
         let transaction = await nymph.startTransaction('test');
         testEntity.$nymph = transaction;
@@ -106,37 +126,56 @@ This one's zip code is 92064.`;
             await transaction.rollback('test');
             return;
         }
+        // Change a value in the test entity.
         testEntity.string = 'bad value';
         expect(await testEntity.$save()).toEqual(true);
+        // Rollback the transaction.
         await transaction.rollback('test');
+        // Verify not in a transaction.
         expect(await transaction.inTransaction()).toEqual(false);
+        // Verify the value is correct.
         await testEntity.$refresh();
         expect(testEntity.string).toEqual('test');
+        // Start a new transaction.
         transaction = await nymph.startTransaction('test');
         testEntity.$nymph = transaction;
+        // Verify in a transaction.
         expect(await transaction.inTransaction()).toEqual(true);
+        // Delete the entity.
         expect(await testEntity.$delete()).toEqual(true);
         const resultEntity = await transaction.getEntity({ class: TestModel }, testGuid);
         expect(resultEntity).toBeNull();
+        // Rollback the transaction.
         await transaction.rollback('test');
+        // Verify not in a transaction.
         expect(await transaction.inTransaction()).toEqual(false);
+        // Verify it's back.
         testEntity = (await transaction.getEntity({ class: TestModel }, testGuid));
         expect(testEntity.guid).toEqual(testGuid);
-        transaction = await nymph.startTransaction('test');
+        // Start a new transaction with a dot in the name.
+        transaction = await nymph.startTransaction('test.1');
         testEntity.$nymph = transaction;
+        // Verify in a transaction.
         expect(await transaction.inTransaction()).toEqual(true);
+        // Make a change.
         testEntity.string = 'fish';
         expect(await testEntity.$save()).toEqual(true);
-        await transaction.commit('test');
+        // Commit the transaction.
+        await transaction.commit('test.1');
         testEntity.$nymph = nymph;
+        // Verify not in a transaction.
         expect(await transaction.inTransaction()).toEqual(false);
+        // Verify the value is correct.
         await testEntity.$refresh();
         expect(testEntity.string).toEqual('fish');
+        // Finally, change it back.
         testEntity.string = 'test';
         expect(await testEntity.$save()).toEqual(true);
+        // TODO: nested transactions
     });
     it('options', async () => {
         await createTestEntities();
+        // Testing entity order, offset, limit...
         const resultEntities = await nymph.getEntities({
             class: TestModel,
             reverse: true,
@@ -149,86 +188,103 @@ This one's zip code is 92064.`;
     });
     it('guid and tags', async () => {
         await createTestEntities();
+        // Retrieving entity by GUID and tags...
         const resultEntity = await nymph.getEntity({ class: TestModel }, { type: '&', guid: testGuid, tag: 'test' });
         expect(testEntity.$is(resultEntity)).toEqual(true);
     });
     it('or selector', async () => {
         await createTestEntities();
+        // Retrieving entity by GUID and tags...
         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();
+        // Retrieving entity by GUID and tags...
         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();
+        // Retrieving entity by !GUID...
         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();
+        // Retrieving entity by !tags...
         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();
+        // Testing GUID and wrong tags...
         const resultEntity = await nymph.getEntity({ class: TestModel }, { type: '&', guid: testGuid, tag: ['pickles'] });
         expect(resultEntity).toBeNull();
     });
     it('tags', async () => {
         await createTestEntities();
+        // Retrieving entity by tags...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test' });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('wrong tags', async () => {
         await createTestEntities();
+        // Testing wrong tags...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'pickles' });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('inclusive tags', async () => {
         await createTestEntities();
+        // Retrieving entity by tags inclusively...
         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();
+        // Testing wrong inclusive tags...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '|', tag: ['pickles', 'barbecue'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('mixed tags', async () => {
         await createTestEntities();
+        // Retrieving entity by mixed tags...
         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();
+        // Testing wrong inclusive mixed tags...
         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();
+        // Testing wrong exclusive mixed tags...
         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();
+        // Retrieving entity by defined...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', defined: 'string' });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('not defined', async () => {
         await createTestEntities();
+        // Retrieving entity by !defined...
         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();
+        // Retrieving entity by defined in not and clause...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '!&', defined: 'pickles' }, { type: '&', tag: 'test' });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('equal', async () => {
         await createTestEntities();
+        // Retrieving entity by equal...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', equal: ['string', 'test'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
@@ -236,12 +292,14 @@ This one's zip code is 92064.`;
         await createTestEntities();
         const referenceEntity = await TestModel.factory(refGuid);
         expect(referenceEntity.guid).toEqual(refGuid);
+        // Retrieving entity by !equal...
         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();
+        // Retrieving entity by like...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', like: ['string', 't_s%'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
@@ -249,12 +307,14 @@ This one's zip code is 92064.`;
         await createTestEntities();
         const referenceEntity = await TestModel.factory(refGuid);
         expect(referenceEntity.guid).toEqual(refGuid);
+        // Retrieving entity by !like...
         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();
+        // Retrieving entity by ilike...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', ilike: ['string', 'T_s%'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
@@ -262,56 +322,68 @@ This one's zip code is 92064.`;
         await createTestEntities();
         const referenceEntity = await TestModel.factory(refGuid);
         expect(referenceEntity.guid).toEqual(refGuid);
+        // Retrieving entity by !ilike...
         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();
+        // Retrieving entity by like...
         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();
+        // Retrieving entity by tags and equal...
         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();
+        // Testing wrong tags and right equal...
         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();
+        // Testing right tags and wrong equal...
         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();
+        // Testing wrong tags and wrong equal...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'pickles', equal: ['string', 'pickles'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('contain', async () => {
         await createTestEntities();
+        // Retrieving entity by contain...
         let resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', contain: ['array', 'values'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
+        // Retrieving entity by contain with full match...
         resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', contain: ['string', 'test'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('not contain', async () => {
         await createTestEntities();
+        // Retrieving entity by !contain...
         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();
+        // Testing wrong contain...
         let resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', contain: ['array', 'pickles'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
+        // Testing wrong contain...
         resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', contain: ['string', 'pickles'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('match', async () => {
         await createTestEntities();
+        // Retrieving entity by regex match...
         let resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', match: ['match', '.*'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
         resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test', match: ['match', 'Edward McCheese'] });
@@ -339,11 +411,13 @@ This one's zip code is 92064.`;
     });
     it('imatch', async () => {
         await createTestEntities();
+        // Retrieving entity by regex match...
         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();
+        // Testing wrong regex match...
         let resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', match: ['match', 'Q'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
         resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'pickle', match: ['match', '.*'] });
@@ -359,16 +433,19 @@ This one's zip code is 92064.`;
     });
     it('match wrong case', async () => {
         await createTestEntities();
+        // Retrieving entity by regex match...
         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();
+        // Retrieving entity by regex + equal inclusively...
         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();
+        // Retrieving entity by inequality...
         let resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gt: [
@@ -377,6 +454,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gt: [
@@ -385,6 +463,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gt: [
@@ -393,6 +472,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gt: [
@@ -401,6 +481,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gt: [
@@ -409,6 +490,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gt: [
@@ -420,6 +502,7 @@ This one's zip code is 92064.`;
     });
     it('greater than or equal', async () => {
         await createTestEntities();
+        // Retrieving entity by inequality...
         let resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gte: [
@@ -428,6 +511,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gte: [
@@ -436,6 +520,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gte: [
@@ -444,6 +529,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gte: [
@@ -452,6 +538,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gte: [
@@ -460,6 +547,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gte: [
@@ -471,6 +559,7 @@ This one's zip code is 92064.`;
     });
     it('less than', async () => {
         await createTestEntities();
+        // Retrieving entity by inequality...
         let resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lt: [
@@ -479,6 +568,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lt: [
@@ -487,6 +577,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lt: [
@@ -495,6 +586,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lt: [
@@ -503,6 +595,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lt: [
@@ -511,6 +604,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lt: [
@@ -522,6 +616,7 @@ This one's zip code is 92064.`;
     });
     it('less than or equal', async () => {
         await createTestEntities();
+        // Retrieving entity by inequality...
         let resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lte: [
@@ -530,6 +625,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lte: [
@@ -538,6 +634,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lte: [
@@ -546,6 +643,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lte: [
@@ -554,6 +652,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lte: [
@@ -562,6 +661,7 @@ This one's zip code is 92064.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lte: [
@@ -573,30 +673,36 @@ This one's zip code is 92064.`;
     });
     it('not inequality', async () => {
         await createTestEntities();
+        // Retrieving entity by !inequality...
         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();
+        // Testing wrong inequality...
         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();
+        // Retrieving entity by time...
         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();
+        // Testing wrong time...
         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 TestModel.factory(refGuid);
+        // Retrieving entity by relative time...
         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);
+        // Retrieving entity by relative time inclusively...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gt: [
@@ -606,9 +712,11 @@ This one's zip code is 92064.`;
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
         expect(referenceEntity.$inArray(resultEntity)).toEqual(false);
+        // Retrieving entity by relative time...
         resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', gt: ['timestamp', null, '-3 days'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
         expect(referenceEntity.$inArray(resultEntity)).toEqual(true);
+        // Retrieving entity by relative time...
         resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', gt: ['cdate', null, '-1 day'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
         expect(referenceEntity.$inArray(resultEntity)).toEqual(true);
@@ -616,43 +724,55 @@ This one's zip code is 92064.`;
     it('wrong time selector', async () => {
         await createTestEntities();
         const referenceEntity = await TestModel.factory(refGuid);
+        // Retrieving entity by relative time...
         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);
+        // Retrieving entity by relative time...
         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);
+        // Retrieving entity by relative time...
         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();
+        // Testing referenced entities...
+        await testEntity.reference?.$wake();
         expect(testEntity.reference?.test).toEqual('good');
+        // Testing referenced entity arrays...
+        await Promise.all(testEntity.refArray?.map((e) => e.$wake()) || []);
         expect(testEntity.refArray?.[0].test).toEqual('good');
     });
     it('ref', async () => {
         await createTestEntities();
+        // Retrieving entity by reference...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', ref: ['reference', refGuid] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('not ref', async () => {
         await createTestEntities();
+        // Retrieving entity by !reference...
         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();
+        // Testing wrong reference...
         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();
+        // Testing non-existent reference...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', ref: ['pickle', refGuid] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('inclusive ref', async () => {
         await createTestEntities();
+        // Retrieving entity by inclusive reference...
         const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             ref: [
@@ -664,6 +784,7 @@ This one's zip code is 92064.`;
     });
     it('wrong inclusive ref', async () => {
         await createTestEntities();
+        // Testing wrong inclusive reference...
         const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             ref: [
@@ -675,11 +796,13 @@ This one's zip code is 92064.`;
     });
     it('ref in an array', async () => {
         await createTestEntities();
+        // Retrieving entity by array reference...
         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();
+        // Testing wrong array reference...
         const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '&',
             ref: [
@@ -691,6 +814,7 @@ This one's zip code is 92064.`;
     });
     it('logic operations', async () => {
         await createTestEntities();
+        // Testing logic operations...
         const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '&',
             '!ref': [
@@ -728,6 +852,7 @@ This one's zip code is 92064.`;
     it('count return', async () => {
         await createTestEntities();
         const result = await nymph.getEntities({ class: TestModel });
+        // Testing count return...
         const resultCount = await nymph.getEntities({
             class: TestModel,
             return: 'count',
@@ -735,25 +860,30 @@ This one's zip code is 92064.`;
         expect(resultCount).toBeGreaterThanOrEqual(1);
         expect(resultCount).toEqual(result.length);
         const resultSelectors = await nymph.getEntities({ class: TestModel }, { type: '&', ref: ['reference', refGuid] });
+        // Testing count return with selectors...
         const resultSelectorsCount = await nymph.getEntities({ class: TestModel, return: 'count' }, { type: '&', ref: ['reference', refGuid] });
         expect(resultSelectorsCount).toBeGreaterThanOrEqual(1);
         expect(resultSelectorsCount).toEqual(resultSelectors.length);
+        // Testing count return with limit...
         const resultSelectorsLimit = await nymph.getEntities({
             class: TestModel,
             limit: 1,
             return: 'count',
         });
         expect(resultSelectorsLimit).toEqual(1);
+        // Testing count return with limit...
         const resultSelectorsSingle = await nymph.getEntity({
             class: TestModel,
             return: 'count',
         });
         expect(resultSelectorsSingle).toEqual(1);
+        // Testing empty count...
         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();
+        // Testing guid return using logic operations...
         const resultGuid = await nymph.getEntities({ class: TestModel, return: 'guid' }, {
             type: '&',
             '!ref': [
@@ -790,6 +920,7 @@ This one's zip code is 92064.`;
     });
     it('deep selector', async () => {
         await createTestEntities();
+        // Testing deep selectors...
         const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '&',
             '!ref': [
@@ -902,6 +1033,7 @@ This one's zip code is 92064.`;
         expect(testEntity.$inArray(resultEntity4)).toEqual(true);
     });
     it('wrong deep selector', async () => {
+        // Testing wrong deep selectors...
         const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '&',
             selector: [
@@ -917,6 +1049,7 @@ This one's zip code is 92064.`;
     });
     it('qref', async () => {
         await createTestEntities();
+        // Retrieving entity by qref...
         const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '&',
             qref: [
@@ -928,6 +1061,7 @@ This one's zip code is 92064.`;
     });
     it('not qref', async () => {
         await createTestEntities();
+        // Retrieving entity by !qref...
         const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '&',
             '!qref': [
@@ -939,6 +1073,7 @@ This one's zip code is 92064.`;
     });
     it('wrong qref class', async () => {
         await createTestEntities();
+        // Testing wrong qref...
         const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '&',
             qref: [
@@ -950,6 +1085,7 @@ This one's zip code is 92064.`;
     });
     it('wrong qref data', async () => {
         await createTestEntities();
+        // Testing wrong qref...
         const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '&',
             qref: [
@@ -959,61 +1095,188 @@ This one's zip code is 92064.`;
         });
         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: TestModel,
-                sort: sort,
-            });
+            // Retrieving entities sorted...
+            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);
             }
+            // And test the same with guid return...
             let resultGuids = await nymph.getEntities({
                 class: TestModel,
-                sort: sort,
+                sort,
                 return: 'guid',
             });
             expect(resultGuids.length).toBeGreaterThan(100);
             for (let i = 0; i < resultGuids.length - 1; i++) {
                 expect(resultGuids[i]).toEqual(resultEntities[i].guid);
             }
+            // Retrieving entities reverse sorted...
             resultEntities = await nymph.getEntities({
                 class: TestModel,
-                sort: sort,
+                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: TestModel, sort: sort }, { type: '&', match: ['name', '^Multi Test '] });
+            // And again with other selectors.
+            // Retrieving entities sorted...
+            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: TestModel, sort: sort, reverse: true }, { type: '&', match: ['name', '^Multi Test '] });
+            // Retrieving entities reverse sorted...
+            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();
+        // Retrieving entities sorted...
+        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);
+        }
+        // And test the same with guid return...
+        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);
+        }
+        // Retrieving entities reverse sorted...
+        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);
+        }
+        // And again with other selectors.
+        // Retrieving entities sorted...
+        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)}`);
+        }
+        // Retrieving entities reverse sorted...
+        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();
+        // Deleting referenced entities...
+        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();
+        // Deleting entity...
         expect(await testEntity.$delete()).toEqual(true);
         expect(testEntity.guid).toBeNull();
         const entity = await nymph.getEntity({ class: TestModel }, { type: '&', guid: testGuid });
         expect(entity).toBeNull();
     });
+    it('allows non-duplicate unique strings', async () => {
+        // Creating entity...
+        const uniqueEntityA = await TestModel.factory();
+        uniqueEntityA.name = 'Entity Test ' + new Date().toLocaleString();
+        uniqueEntityA.uniques = ['test a'];
+        // Saving entity...
+        expect(await uniqueEntityA.$save()).toEqual(true);
+        expect(uniqueEntityA.guid).not.toBeNull();
+        // Creating entity...
+        const uniqueEntityB = await TestModel.factory();
+        uniqueEntityB.name = 'Entity Test ' + new Date().toLocaleString();
+        uniqueEntityB.uniques = ['test b'];
+        // Saving entity...
+        expect(await uniqueEntityB.$save()).toEqual(true);
+        expect(uniqueEntityB.guid).not.toBeNull();
+        expect(uniqueEntityA.guid).not.toEqual(uniqueEntityB.guid);
+        expect(await uniqueEntityA.$delete()).toEqual(true);
+        expect(await uniqueEntityB.$delete()).toEqual(true);
+    });
+    it('throws on duplicate unique strings', async () => {
+        // Creating entity...
+        const uniqueEntityA = await TestModel.factory();
+        uniqueEntityA.name = 'Entity Test ' + new Date().toLocaleString();
+        uniqueEntityA.uniques = ['test a'];
+        // Saving entity...
+        expect(await uniqueEntityA.$save()).toEqual(true);
+        expect(uniqueEntityA.guid).not.toBeNull();
+        // Creating entity...
+        const uniqueEntityB = await TestModel.factory();
+        uniqueEntityB.name = 'Entity Test ' + new Date().toLocaleString();
+        uniqueEntityB.uniques = ['test a'];
+        // Saving entity...
+        try {
+            await uniqueEntityB.$save();
+            throw Error("Shouldn't get past the uniqueness check.");
+        }
+        catch (e) {
+            expect(e).toBeInstanceOf(errors_1.EntityUniqueConstraintError);
+        }
+        expect(uniqueEntityB.guid).toBeNull();
+        expect(await uniqueEntityA.$delete()).toEqual(true);
+    });
+    it('allows duplicate unique string if first transaction is rolled back', async () => {
+        // Creating transaction entity...
+        const tnymphA = await nymph.startTransaction('test-unique-a');
+        const TestModelA = tnymphA.getEntityClass(TestModel);
+        const uniqueEntityA = await TestModelA.factory();
+        uniqueEntityA.name = 'Entity Test ' + new Date().toLocaleString();
+        uniqueEntityA.uniques = ['test a'];
+        // Saving entity...
+        expect(await uniqueEntityA.$save()).toEqual(true);
+        expect(uniqueEntityA.guid).not.toBeNull();
+        // Rolling back transaction...
+        expect(await tnymphA.rollback('test-unique-a')).toEqual(true);
+        // Creating transaction entity...
+        const tnymphB = await nymph.startTransaction('test-unique-b');
+        const TestModelB = tnymphB.getEntityClass(TestModel);
+        const uniqueEntityB = await TestModelB.factory();
+        uniqueEntityB.name = 'Entity Test ' + new Date().toLocaleString();
+        uniqueEntityB.uniques = ['test a'];
+        // Saving entity...
+        expect(await uniqueEntityB.$save()).toEqual(true);
+        expect(uniqueEntityB.guid).not.toBeNull();
+        expect(uniqueEntityA.guid).not.toEqual(uniqueEntityB.guid);
+        expect(await tnymphB.commit('test-unique-b')).toEqual(true);
+        const uniqueEntityACheck = await nymph.getEntity({ class: TestModel }, { type: '&', guid: uniqueEntityA.guid ?? '' });
+        expect(uniqueEntityACheck).toBeNull();
+        const uniqueEntityBCheck = await nymph.getEntity({ class: TestModel }, { type: '&', guid: uniqueEntityB.guid ?? '' });
+        expect(uniqueEntityBCheck).not.toBeNull();
+        if (uniqueEntityBCheck != null) {
+            expect(await uniqueEntityBCheck.$delete()).toEqual(true);
+        }
+    });
 }
-exports.QueriesTest = QueriesTest;
+exports.EntitiesTest = EntitiesTest;
 function UIDTest(nymph, it) {
     it('delete old test data', async () => {
         expect(await nymph.deleteUID('TestUID')).toEqual(true);
@@ -1082,9 +1345,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);
             }
@@ -1099,7 +1364,9 @@ function ExportImportTest(nymph, it) {
         expect(await nymph.newUID('TestUID2')).toEqual(1);
         for (let i = 0; i < 20; i++) {
             const EntityClass = i < 15 ? TestModel : TestBModel;
+            // Creating entity...
             const testEntity = await EntityClass.factory();
+            // Saving entity...
             testEntity.name = 'Entity Test ' + new Date().toLocaleString();
             testEntity.null = null;
             testEntity.string = 'test';