@nymphjs/nymph 1.0.0-beta.57 → 1.0.0-beta.59

package/src/driver/NymphDriver.ts

@@ -5,7 +5,9 @@ import strtotime from 'locutus/php/datetime/strtotime';
 import { guid } from '@nymphjs/guid';
 
 import type Nymph from '../Nymph';
-import {
+import type { Selector, Options, FormattedSelector } from '../Nymph.types';
+import Entity, { type EntityInstanceType } from '../Entity';
+import type {
   EntityConstructor,
   EntityData,
   EntityInterface,
@@ -13,7 +15,6 @@ import {
   SerializedEntityData,
 } from '../Entity.types';
 import { InvalidParametersError, UnableToConnectError } from '../errors';
-import { Selector, Options, FormattedSelector } from '../Nymph.types';
 import { xor } from '../utils';
 
 // from: https://stackoverflow.com/a/6969486/664915
@@ -97,11 +98,11 @@ export default abstract class NymphDriver {
   abstract getEntities<T extends EntityConstructor = EntityConstructor>(
     options?: Options<T>,
     ...selectors: Selector[]
-  ): Promise<ReturnType<T['factorySync']>[]>;
+  ): Promise<EntityInstanceType<T>[]>;
   abstract getEntities<T extends EntityConstructor = EntityConstructor>(
     options?: Options<T>,
     ...selectors: Selector[]
-  ): Promise<ReturnType<T['factorySync']>[] | string[] | number>;
+  ): Promise<EntityInstanceType<T>[] | string[] | number>;
   abstract getUID(name: string): Promise<number | null>;
   abstract import(filename: string, transaction?: boolean): Promise<boolean>;
   abstract newUID(name: string): Promise<number | null>;
@@ -662,12 +663,12 @@ export default abstract class NymphDriver {
 
   protected iterateSelectorsForQuery(
     selectors: FormattedSelector[],
-    callback: (
-      key: string,
-      value: any,
-      typeIsOr: boolean,
-      typeIsNot: boolean,
-    ) => string,
+    callback: (data: {
+      key: string;
+      value: any;
+      typeIsOr: boolean;
+      typeIsNot: boolean;
+    }) => string,
   ) {
     const queryParts = [];
     for (const curSelector of selectors) {
@@ -680,7 +681,7 @@ export default abstract class NymphDriver {
         if (key === 'type') {
           continue;
         }
-        let curQuery = callback(key, value, typeIsOr, typeIsNot);
+        let curQuery = callback({ key, value, typeIsOr, typeIsNot });
         if (curQuery) {
           if (curSelectorQuery) {
             curSelectorQuery += typeIsOr ? ' OR ' : ' AND ';
@@ -699,11 +700,11 @@ export default abstract class NymphDriver {
   protected getEntitiesRowLike<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> & { return: 'count' },
     selectors: Selector[],
-    performQueryCallback: (
-      options: Options<T>,
-      formattedSelectors: FormattedSelector[],
-      etype: string,
-    ) => {
+    performQueryCallback: (data: {
+      options: Options<T>;
+      selectors: FormattedSelector[];
+      etype: string;
+    }) => {
       result: any;
     },
     rowFetchCallback: () => any,
@@ -723,11 +724,11 @@ export default abstract class NymphDriver {
   protected getEntitiesRowLike<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> & { return: 'guid' },
     selectors: Selector[],
-    performQueryCallback: (
-      options: Options<T>,
-      formattedSelectors: FormattedSelector[],
-      etype: string,
-    ) => {
+    performQueryCallback: (data: {
+      options: Options<T>;
+      selectors: FormattedSelector[];
+      etype: string;
+    }) => {
       result: any;
     },
     rowFetchCallback: () => any,
@@ -747,11 +748,11 @@ export default abstract class NymphDriver {
   protected getEntitiesRowLike<T extends EntityConstructor = EntityConstructor>(
     options: Options<T>,
     selectors: Selector[],
-    performQueryCallback: (
-      options: Options<T>,
-      formattedSelectors: FormattedSelector[],
-      etype: string,
-    ) => {
+    performQueryCallback: (data: {
+      options: Options<T>;
+      selectors: FormattedSelector[];
+      etype: string;
+    }) => {
       result: any;
     },
     rowFetchCallback: () => any,
@@ -767,15 +768,18 @@ export default abstract class NymphDriver {
       name: string;
       svalue: string;
     },
-  ): { result: any; process: () => ReturnType<T['factorySync']>[] | Error };
+  ): {
+    result: any;
+    process: () => EntityInstanceType<T>[] | Error;
+  };
   protected getEntitiesRowLike<T extends EntityConstructor = EntityConstructor>(
     options: Options<T>,
     selectors: Selector[],
-    performQueryCallback: (
-      options: Options<T>,
-      formattedSelectors: FormattedSelector[],
-      etype: string,
-    ) => {
+    performQueryCallback: (data: {
+      options: Options<T>;
+      selectors: FormattedSelector[];
+      etype: string;
+    }) => {
       result: any;
     },
     rowFetchCallback: () => any,
@@ -793,7 +797,7 @@ export default abstract class NymphDriver {
     },
   ): {
     result: any;
-    process: () => ReturnType<T['factorySync']>[] | string[] | number | Error;
+    process: () => EntityInstanceType<T>[] | string[] | number | Error;
   } {
     if (!this.isConnected()) {
       throw new UnableToConnectError('not connected to DB');
@@ -811,7 +815,7 @@ export default abstract class NymphDriver {
       }
     }
 
-    let entities: ReturnType<T['factorySync']>[] | string[] = [];
+    let entities: EntityInstanceType<T>[] | string[] = [];
     let count = 0;
     const EntityClass =
       options.class ?? (this.nymph.getEntityClass('Entity') as T);
@@ -833,7 +837,7 @@ export default abstract class NymphDriver {
         (Object.keys(selectors[0]).length === 2 ||
           (Object.keys(selectors[0]).length === 3 && 'tag' in selectors[0]))
       ) {
-        const entity = this.pullCache<ReturnType<T['factorySync']>>(
+        const entity = this.pullCache<EntityInstanceType<T>>(
           selectors[0]['guid'],
           EntityClass.class,
           !!options.skipAc,
@@ -871,11 +875,11 @@ export default abstract class NymphDriver {
         const [options, ...selectors] = qref;
         this.nymph.runQueryCallbacks(options, selectors);
       }
-      const { result } = performQueryCallback(
+      const { result } = performQueryCallback({
         options,
-        formattedSelectors.selectors,
+        selectors: formattedSelectors.selectors,
         etype,
-      );
+      });
 
       return {
         result,
@@ -915,9 +919,7 @@ export default abstract class NymphDriver {
                 // Make sure that $row is incremented :)
                 row = rowFetchCallback();
               }
-              const entity = EntityClass.factorySync() as ReturnType<
-                T['factorySync']
-              >;
+              const entity = EntityClass.factorySync() as EntityInstanceType<T>;
               entity.$nymph = this.nymph;
               if (options.skipAc != null) {
                 entity.$useSkipAc(!!options.skipAc);
@@ -957,24 +959,26 @@ export default abstract class NymphDriver {
 
   protected async saveEntityRowLike(
     entity: EntityInterface,
-    saveNewEntityCallback: (
-      entity: EntityInterface,
-      guid: string,
-      tags: string[],
-      data: EntityData,
-      sdata: SerializedEntityData,
-      cdate: number,
-      etype: string,
-    ) => Promise<boolean>,
-    saveExistingEntityCallback: (
-      entity: EntityInterface,
-      guid: string,
-      tags: string[],
-      data: EntityData,
-      sdata: SerializedEntityData,
-      mdate: number,
-      etype: string,
-    ) => Promise<boolean>,
+    saveNewEntityCallback: (data: {
+      entity: EntityInterface;
+      guid: string;
+      tags: string[];
+      data: EntityData;
+      sdata: SerializedEntityData;
+      uniques: string[];
+      cdate: number;
+      etype: string;
+    }) => Promise<boolean>,
+    saveExistingEntityCallback: (data: {
+      entity: EntityInterface;
+      guid: string;
+      tags: string[];
+      data: EntityData;
+      sdata: SerializedEntityData;
+      uniques: string[];
+      mdate: number;
+      etype: string;
+    }) => Promise<boolean>,
     startTransactionCallback: (() => Promise<void>) | null = null,
     commitTransactionCallback:
       | ((success: boolean) => Promise<boolean>)
@@ -985,6 +989,7 @@ export default abstract class NymphDriver {
     const tags = difference(entity.tags, ['']);
     const data = entity.$getData();
     const sdata = entity.$getSData();
+    const uniques = await entity.$getUniques();
     const EntityClass = entity.constructor as EntityConstructor;
     const etype = EntityClass.ETYPE;
     if (startTransactionCallback) {
@@ -994,15 +999,16 @@ export default abstract class NymphDriver {
     if (entity.guid == null) {
       const cdate = mdate;
       const newId = guid();
-      success = await saveNewEntityCallback(
+      success = await saveNewEntityCallback({
         entity,
-        newId,
+        guid: newId,
         tags,
         data,
         sdata,
+        uniques,
         cdate,
         etype,
-      );
+      });
       if (success) {
         entity.guid = newId;
         entity.cdate = cdate;
@@ -1013,15 +1019,16 @@ export default abstract class NymphDriver {
       if (this.nymph.config.cache) {
         this.cleanCache(entity.guid);
       }
-      success = await saveExistingEntityCallback(
+      success = await saveExistingEntityCallback({
         entity,
-        entity.guid,
+        guid: entity.guid,
         tags,
         data,
         sdata,
+        uniques,
         mdate,
         etype,
-      );
+      });
       if (success) {
         entity.mdate = mdate;
       }
@@ -1051,7 +1058,7 @@ export default abstract class NymphDriver {
    * @param useSkipAc Whether to tell the entity to use skip_ac.
    * @returns The entity or null if it's not cached.
    */
-  protected pullCache<T extends EntityInterface = EntityInterface>(
+  protected pullCache<T extends Entity>(
     guid: string,
     className: string,
     useSkipAc = false,
@@ -1125,7 +1132,7 @@ export default abstract class NymphDriver {
       // Find which entity has been accessed the least.
       const least =
         Object.entries(this.entityCount)
-          .sort(([guidA, countA], [guidB, countB]) => countA - countB)
+          .sort(([_guidA, countA], [_guidB, countB]) => countA - countB)
           .pop()?.[0] ?? null;
       if (least == null) {
         // This should never happen.

package/src/driver/testArtifacts.ts

@@ -3,6 +3,7 @@ import strtotime from 'locutus/php/datetime/strtotime';
 import { guid } from '@nymphjs/guid';
 
 import type Nymph from '../Nymph';
+import { EntityUniqueConstraintError } from '../errors';
 import {
   TestBModel as TestBModelClass,
   TestModel as TestModelClass,
@@ -10,7 +11,7 @@ import {
   TestEmptyModel as TestEmptyModelClass,
 } from '../testArtifacts';
 
-export function QueriesTest(
+export function EntitiesTest(
   nymph: Nymph,
   it: (name: string, fn: () => void) => void,
 ) {
@@ -1804,6 +1805,106 @@ These hats are absolutely fantastic.`;
 
     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: any) {
+      expect(e).toBeInstanceOf(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);
+    }
+  });
 }
 
 export function UIDTest(

package/src/errors/EntityUniqueConstraintError.ts

@@ -0,0 +1,6 @@
+export class EntityUniqueConstraintError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'EntityUniqueConstraintError';
+  }
+}

package/src/errors/index.ts

@@ -6,6 +6,8 @@ export * from './EntityInvalidDataError';
 
 export * from './EntityIsSleepingReferenceError';
 
+export * from './EntityUniqueConstraintError';
+
 export * from './InvalidParametersError';
 
 export * from './InvalidStateError';

package/src/testArtifacts.ts

@@ -17,8 +17,10 @@ export type TestModelData = {
     [k: string]: TestModel & TestModelData;
   };
   parent?: TestModel & TestModelData;
-  // For Import/Export Tests.
+  // For import/export tests.
   index?: string;
+  // For uniqueness tests.
+  uniques?: string[];
 };
 
 /**
@@ -34,19 +36,16 @@ export class TestModel extends Entity<TestModelData> {
   protected $protectedTags = ['test', 'notag'];
   protected $allowlistTags? = ['newtag'];
 
-  static async factory(guid?: string): Promise<TestModel & TestModelData> {
-    return (await super.factory(guid)) as TestModel & TestModelData;
-  }
-
-  static factorySync(): TestModel & TestModelData {
-    return super.factorySync() as TestModel & TestModelData;
-  }
-
   constructor() {
     super();
 
     this.$addTag('test');
     this.$data.boolean = true;
+    this.$data.uniques = [];
+  }
+
+  public async $getUniques() {
+    return this.$data.uniques ?? [];
   }
 
   public $useProtectedData() {
@@ -75,14 +74,6 @@ export class TestModel extends Entity<TestModelData> {
 export class TestBModel extends TestModel {
   static ETYPE = 'test_b_model';
   static class = 'TestBModel';
-
-  static async factory(guid?: string): Promise<TestBModel & TestModelData> {
-    return (await super.factory(guid)) as TestBModel & TestModelData;
-  }
-
-  static factorySync(): TestBModel & TestModelData {
-    return super.factorySync() as TestBModel & TestModelData;
-  }
 }
 
 export type TestEmptyModelData = {};
@@ -93,14 +84,4 @@ export type TestEmptyModelData = {};
 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(): TestEmptyModel & TestEmptyModelData {
-    return super.factorySync() as TestEmptyModel & TestEmptyModelData;
-  }
 }

package/src/testMocks.ts

@@ -1,7 +1,12 @@
 import { guid } from '@nymphjs/guid';
 
 import type Nymph from './Nymph';
-import { EntityConstructor, EntityInterface, EntityJson } from './Entity.types';
+import type { EntityInstanceType } from './Entity';
+import type {
+  EntityConstructor,
+  EntityInterface,
+  EntityJson,
+} from './Entity.types';
 import { Options, Selector } from './Nymph.types';
 import { ClassNotAvailableError } from './errors';
 import Entity from './Entity';
@@ -22,7 +27,7 @@ export class MockNymphDriver {
   public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T>,
     ...selectors: Selector[]
-  ): Promise<ReturnType<T['factorySync']> | null>;
+  ): Promise<EntityInstanceType<T> | null>;
   public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> & { return: 'guid' },
     guid: string,
@@ -30,19 +35,19 @@ export class MockNymphDriver {
   public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T>,
     guid: string,
-  ): Promise<ReturnType<T['factorySync']> | null>;
+  ): Promise<EntityInstanceType<T> | null>;
   public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> = {},
     ...selectors: Selector[] | string[]
-  ): Promise<ReturnType<T['factorySync']> | string | null> {
+  ): Promise<EntityInstanceType<T> | string | null> {
     const guid =
       typeof selectors[0] === 'string' ? selectors[0] : selectors[0].guid;
     if (!options || !guid || typeof guid !== 'string' || !(guid in entities)) {
       return null;
     }
 
-    const entity: EntityInterface = (
-      (options.class as T) ?? this.nymph.getEntityClass('Entity')
+    const entity = (
+      (options.class ?? this.nymph.getEntityClass('Entity')) as T
     ).factorySync();
     const entityJson = entities[guid];
     entity.guid = guid;
@@ -51,7 +56,7 @@ export class MockNymphDriver {
     entity.tags = entityJson.tags;
     entity.$putData(entityJson.data, {});
 
-    return entity as ReturnType<T['factorySync']>;
+    return entity as EntityInstanceType<T>;
   }
 }
 
@@ -68,21 +73,20 @@ export class MockNymph {
     this.Entity = this.addEntityClass(Entity);
   }
 
-  public addEntityClass<T extends EntityConstructor>(entityClass: T): T {
+  public addEntityClass<T extends EntityConstructor>(EntityClass: T): T {
     const nymph = this;
-    class NymphEntity extends entityClass {
+    this.entityClasses[EntityClass.class] = class extends EntityClass {
       static nymph: Nymph = nymph as unknown as Nymph;
 
       constructor(...args: any[]) {
         super(...args);
       }
-    }
-    this.entityClasses[entityClass.class] = NymphEntity;
-    return NymphEntity;
+    };
+    return this.entityClasses[EntityClass.class] as T;
   }
 
-  public getEntityClass<T extends EntityConstructor>(className: T): T;
   public getEntityClass(className: string): EntityConstructor;
+  public getEntityClass<T extends EntityConstructor>(className: T): T;
   public getEntityClass<T extends EntityConstructor = EntityConstructor>(
     className: T | string,
   ): T | EntityConstructor {
@@ -95,7 +99,18 @@ export class MockNymph {
     if (key in this.entityClasses) {
       return this.entityClasses[key];
     }
-    throw new ClassNotAvailableError('Tried to use class: ' + key);
+    throw new ClassNotAvailableError(`Tried to use missing class "${key}".`);
+  }
+
+  public getEntityClassByEtype(etype: string): EntityConstructor {
+    for (const EntityClass of Object.values(this.entityClasses)) {
+      if (EntityClass.ETYPE === etype) {
+        return EntityClass;
+      }
+    }
+    throw new ClassNotAvailableError(
+      `Tried to use missing class by etype "${etype}".`,
+    );
   }
 
   public async getEntity<T extends EntityConstructor = EntityConstructor>(
@@ -105,7 +120,7 @@ export class MockNymph {
   public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T>,
     ...selectors: Selector[]
-  ): Promise<ReturnType<T['factorySync']> | null>;
+  ): Promise<EntityInstanceType<T> | null>;
   public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> & { return: 'guid' },
     guid: string,
@@ -113,11 +128,11 @@ export class MockNymph {
   public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T>,
     guid: string,
-  ): Promise<ReturnType<T['factorySync']> | null>;
+  ): Promise<EntityInstanceType<T> | null>;
   public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> = {},
     ...selectors: Selector[] | string[]
-  ): Promise<ReturnType<T['factorySync']> | string | null> {
+  ): Promise<EntityInstanceType<T> | string | null> {
     // @ts-ignore: The selector type is correct here.
     return await this.driver.getEntity(options, ...selectors);
   }