@nymphjs/nymph 1.0.0-beta.3 → 1.0.0-beta.30

package/src/Nymph.types.ts

@@ -9,18 +9,31 @@ export type NymphEventType =
   | 'beforeGetEntities'
   | 'beforeSaveEntity'
   | 'afterSaveEntity'
+  | 'failedSaveEntity'
   | 'beforeDeleteEntity'
   | 'afterDeleteEntity'
+  | 'failedDeleteEntity'
   | 'beforeDeleteEntityByID'
   | 'afterDeleteEntityByID'
+  | 'failedDeleteEntityByID'
   | 'beforeNewUID'
   | 'afterNewUID'
+  | 'failedNewUID'
   | 'beforeSetUID'
   | 'afterSetUID'
+  | 'failedSetUID'
   | 'beforeRenameUID'
   | 'afterRenameUID'
+  | 'failedRenameUID'
   | 'beforeDeleteUID'
-  | 'afterDeleteUID';
+  | 'afterDeleteUID'
+  | 'failedDeleteUID'
+  | 'beforeStartTransaction'
+  | 'afterStartTransaction'
+  | 'beforeCommitTransaction'
+  | 'afterCommitTransaction'
+  | 'beforeRollbackTransaction'
+  | 'afterRollbackTransaction';
 export type NymphConnectCallback = (
   nymph: Nymph,
   result: Promise<boolean>
@@ -63,6 +76,10 @@ export type NymphAfterSaveEntityCallback = (
   nymph: Nymph,
   result: Promise<boolean>
 ) => Promise<void>;
+export type NymphFailedSaveEntityCallback = (
+  nymph: Nymph,
+  error: any
+) => Promise<void>;
 export type NymphBeforeDeleteEntityCallback = (
   nymph: Nymph,
   entity: EntityInterface
@@ -71,6 +88,10 @@ export type NymphAfterDeleteEntityCallback = (
   nymph: Nymph,
   result: Promise<boolean>
 ) => Promise<void>;
+export type NymphFailedDeleteEntityCallback = (
+  nymph: Nymph,
+  error: any
+) => Promise<void>;
 export type NymphBeforeDeleteEntityByIDCallback = (
   nymph: Nymph,
   guid: string,
@@ -80,6 +101,10 @@ export type NymphAfterDeleteEntityByIDCallback = (
   nymph: Nymph,
   result: Promise<boolean>
 ) => Promise<void>;
+export type NymphFailedDeleteEntityByIDCallback = (
+  nymph: Nymph,
+  error: any
+) => Promise<void>;
 export type NymphBeforeNewUIDCallback = (
   nymph: Nymph,
   name: string
@@ -88,6 +113,10 @@ export type NymphAfterNewUIDCallback = (
   nymph: Nymph,
   result: Promise<number | null>
 ) => Promise<void>;
+export type NymphFailedNewUIDCallback = (
+  nymph: Nymph,
+  error: any
+) => Promise<void>;
 export type NymphBeforeSetUIDCallback = (
   nymph: Nymph,
   name: string,
@@ -97,6 +126,10 @@ export type NymphAfterSetUIDCallback = (
   nymph: Nymph,
   result: Promise<boolean>
 ) => Promise<void>;
+export type NymphFailedSetUIDCallback = (
+  nymph: Nymph,
+  error: any
+) => Promise<void>;
 export type NymphBeforeRenameUIDCallback = (
   nymph: Nymph,
   oldName: string,
@@ -106,6 +139,10 @@ export type NymphAfterRenameUIDCallback = (
   nymph: Nymph,
   result: Promise<boolean>
 ) => Promise<void>;
+export type NymphFailedRenameUIDCallback = (
+  nymph: Nymph,
+  error: any
+) => Promise<void>;
 export type NymphBeforeDeleteUIDCallback = (
   nymph: Nymph,
   name: string
@@ -114,13 +151,44 @@ export type NymphAfterDeleteUIDCallback = (
   nymph: Nymph,
   result: Promise<boolean>
 ) => Promise<void>;
+export type NymphFailedDeleteUIDCallback = (
+  nymph: Nymph,
+  error: any
+) => Promise<void>;
+export type NymphBeforeStartTransactionCallback = (
+  nymph: Nymph,
+  name: string
+) => Promise<void>;
+export type NymphAfterStartTransactionCallback = (
+  nymph: Nymph,
+  name: string,
+  result: Nymph
+) => Promise<void>;
+export type NymphBeforeCommitTransactionCallback = (
+  nymph: Nymph,
+  name: string
+) => Promise<void>;
+export type NymphAfterCommitTransactionCallback = (
+  nymph: Nymph,
+  name: string,
+  result: boolean
+) => Promise<void>;
+export type NymphBeforeRollbackTransactionCallback = (
+  nymph: Nymph,
+  name: string
+) => Promise<void>;
+export type NymphAfterRollbackTransactionCallback = (
+  nymph: Nymph,
+  name: string,
+  result: boolean
+) => Promise<void>;
 
 export type Options<T extends EntityConstructor = EntityConstructor> = {
   class?: T;
   limit?: number;
   offset?: number;
   reverse?: boolean;
-  sort?: 'cdate' | 'mdate';
+  sort?: 'cdate' | 'mdate' | string;
   return?: 'entity' | 'guid' | 'count';
   source?: string;
   skipCache?: boolean;

package/src/driver/NymphDriver.ts

@@ -54,7 +54,18 @@ export default abstract class NymphDriver {
    */
   private putDataCounter = 0;
 
+  /**
+   * This is used internally by Nymph. Don't call it yourself.
+   *
+   * @returns A clone of this instance.
+   */
+  abstract clone(): NymphDriver;
+
+  /**
+   * Connect to the data store.
+   */
   abstract connect(): Promise<boolean>;
+
   abstract isConnected(): boolean;
   abstract startTransaction(name: string): Promise<Nymph>;
   abstract commit(name: string): Promise<boolean>;
@@ -66,7 +77,12 @@ export default abstract class NymphDriver {
   ): Promise<boolean>;
   abstract deleteEntityByID(guid: string, className?: string): Promise<boolean>;
   abstract deleteUID(name: string): Promise<boolean>;
+
+  /**
+   * Disconnect from the data store.
+   */
   abstract disconnect(): Promise<boolean>;
+
   protected abstract exportEntities(
     writeLine: (line: string) => void
   ): Promise<void>;
@@ -609,10 +625,9 @@ export default abstract class NymphDriver {
           for (let i = 0; i < tmpArr.length; i++) {
             const name = tmpArr[i][0];
             const [qrefOptions, ...qrefSelectors] = tmpArr[i][1];
-            const QrefEntityClass =
-              typeof qrefOptions.class === 'string'
-                ? this.nymph.getEntityClass(qrefOptions.class)
-                : qrefOptions.class ?? this.nymph.getEntityClass('Entity');
+            const QrefEntityClass = qrefOptions.class
+              ? this.nymph.getEntityClass(qrefOptions.class)
+              : this.nymph.getEntityClass('Entity');
             const newOptions = {
               ...qrefOptions,
               class: QrefEntityClass,

package/src/driver/testArtifacts.ts

@@ -3,16 +3,22 @@ import strtotime from 'locutus/php/datetime/strtotime';
 import { guid } from '@nymphjs/guid';
 
 import type Nymph from '../Nymph';
-import { TestBModel, TestModel, TestModelData } from '../testArtifacts';
+import {
+  TestBModel as TestBModelClass,
+  TestModel as TestModelClass,
+  TestModelData,
+  TestEmptyModel as TestEmptyModelClass,
+} from '../testArtifacts';
 
 export function QueriesTest(
   nymph: Nymph,
   it: (name: string, fn: () => void) => void
 ) {
-  nymph.addEntityClass(TestModel);
-  nymph.addEntityClass(TestBModel);
+  const TestModel = nymph.addEntityClass(TestModelClass);
+  const TestBModel = nymph.addEntityClass(TestBModelClass);
+  const TestEmptyModel = nymph.addEntityClass(TestEmptyModelClass);
 
-  let testEntity: TestModel & TestModelData;
+  let testEntity: TestModelClass & TestModelData;
   let testGuid: string;
   let refGuid: string;
   let createdMultiple = false;
@@ -35,7 +41,10 @@ export function QueriesTest(
 
 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();
@@ -43,7 +52,7 @@ This one's zip code is 92064.`;
     expect(testEntity.guid).not.toBeNull();
     testGuid = testEntity.guid as string;
 
-    const entityReferenceTest: TestModel & TestModelData = new TestModel();
+    const entityReferenceTest: TestModelClass & TestModelData = new TestModel();
     entityReferenceTest.string = 'wrong';
     entityReferenceTest.timestamp = strtotime('-2 days') * 1000;
     expect(await entityReferenceTest.$save()).toEqual(true);
@@ -59,7 +68,7 @@ This one's zip code is 92064.`;
     testEntity = nymph.driver.getEntitySync(
       { class: TestModel },
       testGuid
-    ) as TestModel & TestModelData;
+    ) as TestModelClass & TestModelData;
     expect(testEntity).toBeInstanceOf(TestModel);
     expect(testEntity.guid).toEqual(testGuid);
 
@@ -67,7 +76,7 @@ This one's zip code is 92064.`;
     testEntity = (await nymph.getEntity(
       { class: TestModel },
       testGuid
-    )) as TestModel & TestModelData;
+    )) as TestModelClass & TestModelData;
     expect(testEntity).toBeInstanceOf(TestModel);
     expect(testEntity.guid).toEqual(testGuid);
   }
@@ -80,6 +89,8 @@ This one's zip code is 92064.`;
       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);
@@ -104,6 +115,13 @@ This one's zip code is 92064.`;
     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();
 
@@ -191,12 +209,12 @@ This one's zip code is 92064.`;
     testEntity = (await transaction.getEntity(
       { class: TestModel },
       testGuid
-    )) as TestModel & TestModelData;
+    )) as TestModelClass & TestModelData;
 
     expect(testEntity.guid).toEqual(testGuid);
 
-    // Start a new transaction.
-    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.
@@ -207,7 +225,7 @@ This one's zip code is 92064.`;
     expect(await testEntity.$save()).toEqual(true);
 
     // Commit the transaction.
-    await transaction.commit('test');
+    await transaction.commit('test.1');
     testEntity.$nymph = nymph;
 
     // Verify not in a transaction.
@@ -1633,26 +1651,23 @@ 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']) {
+    for (const sort of ['cdate', 'mdate'] as ('cdate' | 'mdate')[]) {
       // Retrieving entities sorted...
-      let resultEntities = await nymph.getEntities({
-        class: TestModel,
-        sort: sort as 'cdate' | 'mdate',
-      });
+      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 as 'cdate' | 'mdate']
-        ).toBeGreaterThan(resultEntities[i][sort as 'cdate' | 'mdate'] ?? 0);
+        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 as 'cdate' | 'mdate',
+        sort,
         return: 'guid',
       });
       expect(resultGuids.length).toBeGreaterThan(100);
@@ -1663,43 +1678,114 @@ This one's zip code is 92064.`;
       // Retrieving entities reverse sorted...
       resultEntities = await nymph.getEntities({
         class: TestModel,
-        sort: sort as 'cdate' | 'mdate',
+        sort,
         reverse: true,
       });
       expect(resultEntities.length).toBeGreaterThan(100);
       for (let i = 0; i < resultEntities.length - 1; i++) {
-        expect(resultEntities[i + 1][sort as 'cdate' | 'mdate']).toBeLessThan(
-          resultEntities[i][sort as 'cdate' | 'mdate'] ?? 0
+        expect(resultEntities[i + 1][sort]).toBeLessThan(
+          resultEntities[i][sort] ?? 0
         );
       }
 
       // And again with other selectors.
       // Retrieving entities sorted...
       resultEntities = await nymph.getEntities(
-        { class: TestModel, sort: sort as 'cdate' | 'mdate' },
+        { 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 as 'cdate' | 'mdate']
-        ).toBeGreaterThan(resultEntities[i][sort as 'cdate' | 'mdate'] ?? 0);
+        expect(resultEntities[i + 1][sort]).toBeGreaterThan(
+          resultEntities[i][sort] ?? 0
+        );
       }
 
       // Retrieving entities reverse sorted...
       resultEntities = await nymph.getEntities(
-        { class: TestModel, sort: sort as 'cdate' | 'mdate', reverse: true },
+        { 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 as 'cdate' | 'mdate']).toBeLessThan(
-          resultEntities[i][sort as 'cdate' | 'mdate'] ?? 0
+        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();
 
@@ -1728,9 +1814,6 @@ export function UIDTest(
   nymph: Nymph,
   it: (name: string, fn: () => void) => void
 ) {
-  nymph.addEntityClass(TestModel);
-  nymph.addEntityClass(TestBModel);
-
   it('delete old test data', async () => {
     expect(await nymph.deleteUID('TestUID')).toEqual(true);
     expect(await nymph.deleteUID('NewUID')).toEqual(true);
@@ -1772,8 +1855,8 @@ export function ExportImportTest(
   nymph: Nymph,
   it: (name: string, fn: () => void) => void
 ) {
-  nymph.addEntityClass(TestModel);
-  nymph.addEntityClass(TestBModel);
+  const TestModel = nymph.addEntityClass(TestModelClass);
+  const TestBModel = nymph.addEntityClass(TestBModelClass);
 
   async function deleteTestData() {
     let all = await nymph.getEntities({ class: TestModel });

package/src/testArtifacts.ts

@@ -86,3 +86,23 @@ export class TestBModel extends TestModel {
     return super.factorySync(guid) as TestBModel & TestModelData;
   }
 }
+
+export type TestEmptyModelData = {};
+
+/**
+ * This class is a test class that extends the Entity class.
+ */
+export class TestEmptyModel extends Entity<TestEmptyModelData> {
+  static ETYPE = 'test_empty_model';
+  static class = 'TestEmptyModel';
+
+  static async factory(
+    guid?: string
+  ): Promise<TestEmptyModel & TestEmptyModelData> {
+    return (await super.factory(guid)) as TestEmptyModel & TestEmptyModelData;
+  }
+
+  static factorySync(guid?: string): TestEmptyModel & TestEmptyModelData {
+    return super.factorySync(guid) as TestEmptyModel & TestEmptyModelData;
+  }
+}

package/src/testMocks.ts

@@ -59,26 +59,43 @@ export class MockNymph {
   private entityClasses: { [k: string]: EntityConstructor } = {};
   public driver: MockNymphDriver;
   public Tilmeld: any = undefined;
+  public Entity: typeof Entity;
 
   public constructor() {
     this.driver = new MockNymphDriver(this);
 
     // class NymphEntity extends Entity {}
-    this.addEntityClass(Entity);
+    this.Entity = this.addEntityClass(Entity);
   }
 
-  public addEntityClass(entityClass: EntityConstructor) {
-    this.entityClasses[entityClass.class] = entityClass;
-    entityClass.nymph = this as unknown as Nymph;
+  public addEntityClass<T extends EntityConstructor>(entityClass: T): T {
+    const nymph = this;
+    class NymphEntity extends entityClass {
+      static nymph: Nymph = nymph as unknown as Nymph;
+
+      constructor(...args: any[]) {
+        super(...args);
+      }
+    }
+    this.entityClasses[entityClass.class] = NymphEntity;
+    return NymphEntity;
   }
 
-  public getEntityClass(className: string): EntityConstructor {
-    if (className in this.entityClasses) {
-      const EntityClass = this.entityClasses[className];
-      EntityClass.nymph = this as unknown as Nymph;
-      return EntityClass;
+  public getEntityClass<T extends EntityConstructor>(className: T): T;
+  public getEntityClass(className: string): EntityConstructor;
+  public getEntityClass<T extends EntityConstructor = EntityConstructor>(
+    className: T | string
+  ): T | EntityConstructor {
+    let key: string | null = null;
+    if (typeof className === 'string') {
+      key = className;
+    } else {
+      key = className.class;
+    }
+    if (key in this.entityClasses) {
+      return this.entityClasses[key];
     }
-    throw new ClassNotAvailableError('Tried to use class: ' + className);
+    throw new ClassNotAvailableError('Tried to use class: ' + key);
   }
 
   public async getEntity<T extends EntityConstructor = EntityConstructor>(

package/src/utils.ts

@@ -17,7 +17,8 @@ export function uniqueStrings(array: string[]) {
 
 export function classNamesToEntityConstructors(
   nymph: Nymph,
-  selectors: Selector[]
+  selectors: Selector[],
+  enforceRestEnabledFlag = false
 ): Selector[] {
   const newSelectors: Selector[] = [];
 
@@ -45,22 +46,35 @@ export function classNamesToEntityConstructors(
         for (let i = 0; i < tmpArr.length; i++) {
           const name = tmpArr[i][0];
           const [qrefOptions, ...selectors] = tmpArr[i][1];
-          const QrefEntityClass =
-            typeof qrefOptions.class === 'string'
-              ? nymph.getEntityClass(qrefOptions.class)
-              : qrefOptions.class ?? nymph.getEntityClass('Entity');
+          const QrefEntityClass = qrefOptions.class
+            ? nymph.getEntityClass(qrefOptions.class)
+            : nymph.getEntityClass('Entity');
+          if (enforceRestEnabledFlag && !QrefEntityClass.restEnabled) {
+            throw new Error('Not accessible.');
+          }
           const options = { ...qrefOptions, class: QrefEntityClass };
           if (!newSelector[key]) {
             newSelector[key] = [];
           }
           (newSelector[key] as [string, [Options, ...Selector[]]][]).push([
             name,
-            [options, ...classNamesToEntityConstructors(nymph, selectors)],
+            [
+              options,
+              ...classNamesToEntityConstructors(
+                nymph,
+                selectors,
+                enforceRestEnabledFlag
+              ),
+            ],
           ]);
         }
       } else if (key === 'selector' || key === '!selector') {
         const tmpArr = (Array.isArray(value) ? value : [value]) as Selector[];
-        newSelector[key] = classNamesToEntityConstructors(nymph, tmpArr);
+        newSelector[key] = classNamesToEntityConstructors(
+          nymph,
+          tmpArr,
+          enforceRestEnabledFlag
+        );
       } else {
         // @ts-ignore: ts doesn't know what value is here.
         newSelector[key] = value;