@nymphjs/nymph 1.0.0-beta.2 → 1.0.0-beta.21

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>
@@ -29,12 +42,22 @@ export type NymphDisconnectCallback = (
   nymph: Nymph,
   result: Promise<boolean>
 ) => Promise<void>;
-/** The NymphQueryCallback will be called on both top level and qref queries. */
+/**
+ * The NymphQueryCallback will be called on both top level and qref queries.
+ *
+ * This is the only callback that is not asynchronous.
+ *
+ * This also isn't necessarily run on every "query". It is run before a database
+ * query for an entity, but it is not run during PubSub entity change
+ * propagation. Therefore, it shouldn't do anything _entity_ specific, instead
+ * it should be _query_ specific. For example, throw an error if the user is not
+ * permitted to run the query at all.
+ */
 export type NymphQueryCallback = (
   nymph: Nymph,
   options: Options,
   selectors: FormattedSelector[]
-) => Promise<void>;
+) => void;
 export type NymphBeforeGetEntityCallback = (
   nymph: Nymph,
   options: Options,
@@ -53,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
@@ -61,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,
@@ -70,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
@@ -78,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,
@@ -87,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,
@@ -96,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
@@ -104,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>;
@@ -283,7 +299,7 @@ export default abstract class NymphDriver {
     guid: string | null = null,
     tags: string[] | null = null
   ) {
-    const formattedSelectors = this.formatSelectors(selectors);
+    const formattedSelectors = this.formatSelectors(selectors).selectors;
 
     for (const curSelector of formattedSelectors) {
       const type = curSelector.type;
@@ -575,8 +591,12 @@ export default abstract class NymphDriver {
   public formatSelectors(
     selectors: Selector[],
     options: Options = {}
-  ): FormattedSelector[] {
+  ): {
+    selectors: FormattedSelector[];
+    qrefs: [Options, ...FormattedSelector[]][];
+  } {
     const newSelectors: FormattedSelector[] = [];
+    const qrefs: [Options, ...FormattedSelector[]][] = [];
 
     for (const curSelector of selectors) {
       const newSelector: FormattedSelector = {
@@ -615,13 +635,18 @@ export default abstract class NymphDriver {
               source: options.source,
             };
             const newSelectors = this.formatSelectors(qrefSelectors, options);
-            this.nymph.runQueryCallbacks(newOptions, newSelectors);
-            formatArr[i] = [name, [newOptions, ...newSelectors]];
+            qrefs.push(
+              [newOptions, ...newSelectors.selectors],
+              ...newSelectors.qrefs
+            );
+            formatArr[i] = [name, [newOptions, ...newSelectors.selectors]];
           }
           newSelector[key] = formatArr;
         } else if (key === 'selector' || key === '!selector') {
           const tmpArr = (Array.isArray(value) ? value : [value]) as Selector[];
-          newSelector[key] = this.formatSelectors(tmpArr, options);
+          const newSelectors = this.formatSelectors(tmpArr, options);
+          newSelector[key] = newSelectors.selectors;
+          qrefs.push(...newSelectors.qrefs);
         } else if (!Array.isArray(value)) {
           // @ts-ignore: ts doesn't know what value is here.
           newSelector[key] = [[value]];
@@ -655,7 +680,7 @@ export default abstract class NymphDriver {
       newSelectors.push(newSelector);
     }
 
-    return newSelectors;
+    return { selectors: newSelectors, qrefs };
   }
 
   protected iterateSelectorsForQuery(
@@ -774,7 +799,7 @@ export default abstract class NymphDriver {
       name: string;
       svalue: string;
     }
-  ): { result: any; process: () => number };
+  ): { result: any; process: () => number | Error };
   protected getEntitesRowLike<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> & { return: 'guid' },
     selectors: Selector[],
@@ -798,7 +823,7 @@ export default abstract class NymphDriver {
       name: string;
       svalue: string;
     }
-  ): { result: any; process: () => string[] };
+  ): { result: any; process: () => string[] | Error };
   protected getEntitesRowLike<T extends EntityConstructor = EntityConstructor>(
     options: Options<T>,
     selectors: Selector[],
@@ -822,7 +847,7 @@ export default abstract class NymphDriver {
       name: string;
       svalue: string;
     }
-  ): { result: any; process: () => ReturnType<T['factorySync']>[] };
+  ): { result: any; process: () => ReturnType<T['factorySync']>[] | Error };
   protected getEntitesRowLike<T extends EntityConstructor = EntityConstructor>(
     options: Options<T>,
     selectors: Selector[],
@@ -848,7 +873,7 @@ export default abstract class NymphDriver {
     }
   ): {
     result: any;
-    process: () => ReturnType<T['factorySync']>[] | string[] | number;
+    process: () => ReturnType<T['factorySync']>[] | string[] | number | Error;
   } {
     if (!this.isConnected()) {
       throw new UnableToConnectError('not connected to DB');
@@ -918,78 +943,95 @@ export default abstract class NymphDriver {
       }
     }
 
-    const formattedSelectors = this.formatSelectors(selectors, options);
-    this.nymph.runQueryCallbacks(options, formattedSelectors);
-    const { result } = performQueryCallback(options, formattedSelectors, etype);
+    try {
+      const formattedSelectors = this.formatSelectors(selectors, options);
+      this.nymph.runQueryCallbacks(options, formattedSelectors.selectors);
+      for (let qref of formattedSelectors.qrefs) {
+        const [options, ...selectors] = qref;
+        this.nymph.runQueryCallbacks(options, selectors);
+      }
+      const { result } = performQueryCallback(
+        options,
+        formattedSelectors.selectors,
+        etype
+      );
 
-    return {
-      result,
-      process: () => {
-        let row = rowFetchCallback();
-        if (options.return === 'count') {
-          while (row != null) {
-            count += getCountCallback(row);
-            row = rowFetchCallback();
-          }
-        } else if (options.return === 'guid') {
-          while (row != null) {
-            (entities as string[]).push(getGUIDCallback(row));
-            row = rowFetchCallback();
-          }
-        } else {
-          while (row != null) {
-            const guid = getGUIDCallback(row);
-            const tagsAndDates = getTagsAndDatesCallback(row);
-            const tags = tagsAndDates.tags;
-            const cdate = tagsAndDates.cdate;
-            const mdate = tagsAndDates.mdate;
-            let dataNameAndSValue = getDataNameAndSValueCallback(row);
-            // Data.
-            const data: EntityData = {};
-            // Serialized data.
-            const sdata: SerializedEntityData = {};
-            if (dataNameAndSValue.name !== '') {
-              // This do will keep going and adding the data until the
-              // next entity is reached. $row will end on the next entity.
-              do {
-                dataNameAndSValue = getDataNameAndSValueCallback(row);
-                sdata[dataNameAndSValue.name] = dataNameAndSValue.svalue;
-                row = rowFetchCallback();
-              } while (row != null && getGUIDCallback(row) === guid);
-            } else {
-              // Make sure that $row is incremented :)
+      return {
+        result,
+        process: () => {
+          let row = rowFetchCallback();
+          if (options.return === 'count') {
+            while (row != null) {
+              count += getCountCallback(row);
               row = rowFetchCallback();
             }
-            const entity = EntityClass.factorySync() as ReturnType<
-              T['factorySync']
-            >;
-            entity.$nymph = this.nymph;
-            if (options.skipAc != null) {
-              entity.$useSkipAc(!!options.skipAc);
-            }
-            entity.guid = guid;
-            entity.cdate = cdate;
-            entity.mdate = mdate;
-            entity.tags = tags;
-            this.putDataCounter++;
-            if (this.putDataCounter == 100) {
-              throw new Error('Infinite loop detected in Entity loading.');
+          } else if (options.return === 'guid') {
+            while (row != null) {
+              (entities as string[]).push(getGUIDCallback(row));
+              row = rowFetchCallback();
             }
-            entity.$putData(data, sdata);
-            this.putDataCounter--;
-            if (this.nymph.config.cache) {
-              this.pushCache(guid, cdate, mdate, tags, data, sdata);
+          } else {
+            while (row != null) {
+              const guid = getGUIDCallback(row);
+              const tagsAndDates = getTagsAndDatesCallback(row);
+              const tags = tagsAndDates.tags;
+              const cdate = tagsAndDates.cdate;
+              const mdate = tagsAndDates.mdate;
+              let dataNameAndSValue = getDataNameAndSValueCallback(row);
+              // Data.
+              const data: EntityData = {};
+              // Serialized data.
+              const sdata: SerializedEntityData = {};
+              if (dataNameAndSValue.name !== '') {
+                // This do will keep going and adding the data until the
+                // next entity is reached. $row will end on the next entity.
+                do {
+                  dataNameAndSValue = getDataNameAndSValueCallback(row);
+                  sdata[dataNameAndSValue.name] = dataNameAndSValue.svalue;
+                  row = rowFetchCallback();
+                } while (row != null && getGUIDCallback(row) === guid);
+              } else {
+                // Make sure that $row is incremented :)
+                row = rowFetchCallback();
+              }
+              const entity = EntityClass.factorySync() as ReturnType<
+                T['factorySync']
+              >;
+              entity.$nymph = this.nymph;
+              if (options.skipAc != null) {
+                entity.$useSkipAc(!!options.skipAc);
+              }
+              entity.guid = guid;
+              entity.cdate = cdate;
+              entity.mdate = mdate;
+              entity.tags = tags;
+              this.putDataCounter++;
+              if (this.putDataCounter == 100) {
+                throw new Error('Infinite loop detected in Entity loading.');
+              }
+              entity.$putData(data, sdata);
+              this.putDataCounter--;
+              if (this.nymph.config.cache) {
+                this.pushCache(guid, cdate, mdate, tags, data, sdata);
+              }
+              // @ts-ignore: ts doesn't know the return type here.
+              entities.push(entity);
             }
-            // @ts-ignore: ts doesn't know the return type here.
-            entities.push(entity);
           }
-        }
 
-        freeResultCallback();
+          freeResultCallback();
 
-        return options.return === 'count' ? count : entities;
-      },
-    };
+          return options.return === 'count' ? count : entities;
+        },
+      };
+    } catch (e: any) {
+      return {
+        result: Promise.resolve(e),
+        process: () => {
+          return e;
+        },
+      };
+    }
   }
 
   protected async saveEntityRowLike(

package/src/driver/testArtifacts.ts

@@ -3,16 +3,20 @@ 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,
+} 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);
 
-  let testEntity: TestModel & TestModelData;
+  let testEntity: TestModelClass & TestModelData;
   let testGuid: string;
   let refGuid: string;
   let createdMultiple = false;
@@ -43,7 +47,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 +63,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 +71,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 +84,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);
@@ -191,7 +197,7 @@ 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);
 
@@ -1633,26 +1639,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 +1666,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 +1802,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 +1843,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 });