@nymphjs/nymph 1.0.0-beta.13 → 1.0.0-beta.130

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/HttpError.ts

@@ -0,0 +1,12 @@
+export class HttpError extends Error {
+  status?: number;
+  statusText?: string;
+
+  constructor(message: string, status?: number, statusText?: string) {
+    super(message);
+
+    this.name = 'HttpError';
+    this.status = status;
+    this.statusText = statusText;
+  }
+}

package/src/errors/InvalidStateError.ts

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

package/src/errors/MethodFailedError.ts

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

package/src/errors/QueryFailedError.ts

@@ -1,10 +1,12 @@
 export class QueryFailedError extends Error {
   private query?: string;
+  public errorCode?: number;
 
-  constructor(message: string, query?: string) {
+  constructor(message: string, query?: string, errorCode?: number) {
     super(message);
     this.name = 'QueryFailedError';
     this.query = query;
+    this.errorCode = errorCode;
   }
 
   public getQuery() {

package/src/errors/index.ts

@@ -1,15 +1,23 @@
-export * from './ClassNotAvailableError';
+export * from './ClassNotAvailableError.js';
 
-export * from './EntityConflictError';
+export * from './EntityConflictError.js';
 
-export * from './EntityInvalidDataError';
+export * from './EntityInvalidDataError.js';
 
-export * from './EntityIsSleepingReferenceError';
+export * from './EntityIsSleepingReferenceError.js';
 
-export * from './InvalidParametersError';
+export * from './EntityUniqueConstraintError.js';
 
-export * from './NotConfiguredError';
+export * from './HttpError.js';
 
-export * from './QueryFailedError';
+export * from './InvalidParametersError.js';
 
-export * from './UnableToConnectError';
+export * from './InvalidStateError.js';
+
+export * from './MethodFailedError.js';
+
+export * from './NotConfiguredError.js';
+
+export * from './QueryFailedError.js';
+
+export * from './UnableToConnectError.js';

package/src/helpers/index.ts

@@ -0,0 +1 @@
+export * from './transaction.js';

package/src/helpers/transaction.ts

@@ -0,0 +1,65 @@
+import Nymph from '../Nymph.js';
+
+/**
+ * Run a function inside of a transaction.
+ *
+ * @param nymph The instance of Nymph to start the transaction on.
+ * @param name The name of the transaction.
+ * @param fn The function that runs inside the transaction. It is passed the
+ *           transactional instance of Nymph. If it resolves, the transaction is
+ *           committed, and if it throws, the transaction is rolled back.
+ * @param finallyFn An optional function to run after the transaction is
+ *                  committed or rolled back. It is passed the original instance
+ *                  of Nymph. It SHOULD NOT throw.
+ * @returns The return value of the function.
+ */
+export async function transaction<T>(
+  nymph: Nymph,
+  name: string,
+  fn: (nymph: Nymph) => Promise<T>,
+  finallyFn?: (nymph: Nymph, committed?: boolean) => Promise<void>,
+): Promise<T> {
+  nymph.config.debugInfo('nymph:transaction', `Starting transaction ${name}`);
+  const tnymph = await nymph.startTransaction(name);
+  try {
+    const result = await fn(tnymph);
+
+    nymph.config.debugInfo(
+      'nymph:transaction',
+      `Committing transaction ${name}`,
+    );
+    if (!(await tnymph.commit(name))) {
+      throw new Error('Transaction could not be committed.');
+    }
+
+    if (finallyFn) {
+      await finallyFn(nymph, true);
+    }
+
+    return result;
+  } catch (e: any) {
+    try {
+      nymph.config.debugInfo(
+        'nymph:transaction',
+        `Rolling back transaction ${name}, reason: ${e.message}`,
+      );
+      await tnymph.rollback(name);
+    } catch (e: any) {
+      nymph.config.debugError(
+        'nymph:transaction',
+        `Rollback of transaction ${name} failed, reason: ${e.message}`,
+      );
+    }
+    if (finallyFn) {
+      try {
+        await finallyFn(nymph, false);
+      } catch (e: any) {
+        nymph.config.debugError(
+          'nymph:transaction',
+          `Finally function of transaction ${name} threw error: ${e.message}, this is a mistake and should be fixed, finally functions should never throw`,
+        );
+      }
+    }
+    throw e;
+  }
+}

package/src/index.ts

@@ -1,20 +1,22 @@
-export * from './conf';
-export * from './driver';
-export * from './errors';
+export * from './conf/index.js';
+export * from './driver/index.js';
+export * from './errors/index.js';
+export * from './decorators/index.js';
+export * from './helpers/index.js';
 
-export * from './Entity.types';
+export * from './Entity.types.js';
 
-export * from './Entity';
-import Entity from './Entity';
+export * from './Entity.js';
+import Entity from './Entity.js';
 export { Entity };
 
-export * from './Nymph.types';
+export * from './Nymph.types.js';
 
-export * from './Nymph';
-import Nymph from './Nymph';
+export * from './Nymph.js';
+import Nymph from './Nymph.js';
 export { Nymph };
 
-import nymphJoiProps from './nymphJoiProps';
+import nymphJoiProps from './nymphJoiProps.js';
 export { nymphJoiProps };
 
-export * from './utils';
+export * from './utils.js';

package/src/nymphJoiProps.ts

@@ -4,7 +4,7 @@ export default {
   guid: Joi.alternatives()
     .try(
       Joi.any().only().allow(null),
-      Joi.string().trim(false).length(24).hex()
+      Joi.string().trim(false).length(24).hex(),
     )
     .required(),
   cdate: Joi.alternatives()
@@ -18,7 +18,7 @@ export default {
       Joi.string().pattern(/[[\x01-\x1F\x7F]]/, {
         name: 'control characters',
         invert: true,
-      })
+      }),
     )
     .required(),
 };

package/src/testArtifacts.ts

@@ -1,4 +1,6 @@
-import Entity from './Entity';
+import Entity from './Entity.js';
+import { transactional } from './decorators/index.js';
+import { transaction } from './helpers/index.js';
 
 export type TestModelData = {
   name?: string;
@@ -7,6 +9,7 @@ export type TestModelData = {
   test?: string;
   array?: any[];
   match?: string;
+  search?: string;
   number?: number;
   numberString?: string;
   timestamp?: Number;
@@ -17,8 +20,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,21 +39,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;
-  }
+  constructor() {
+    super();
 
-  static factorySync(guid?: string): TestModel & TestModelData {
-    return super.factorySync(guid) as TestModel & TestModelData;
+    this.$addTag('test');
+    this.$data.boolean = true;
+    this.$data.uniques = [];
   }
 
-  constructor(guid?: string) {
-    super(guid);
-
-    if (this.guid == null) {
-      this.$addTag('test');
-      this.$data.boolean = true;
-    }
+  public async $getUniques() {
+    return this.$data.uniques ?? [];
   }
 
   public $useProtectedData() {
@@ -69,6 +69,53 @@ export class TestModel extends Entity<TestModelData> {
       this.$protectedTags = $protectedTags;
     };
   }
+
+  @transactional
+  public async $testTransactionalDecorator(throwError: boolean) {
+    this.$data.string = 'this has been changed';
+
+    if (this.$data.reference) {
+      await this.$data.reference.$wake();
+      this.$data.reference.string = 'this has been changed too';
+      await this.$data.reference.$save();
+    }
+
+    await this.$save();
+
+    if (throwError) {
+      throw Error('An error.');
+    }
+
+    return 'Success.';
+  }
+
+  public async $testTransactionHelper(throwError: boolean) {
+    return await transaction(
+      this.$nymph,
+      'test-transaction',
+      async (nymph) => {
+        this.$setNymph(nymph);
+        this.$data.string = 'this has been changed';
+
+        if (this.$data.reference) {
+          await this.$data.reference.$wake();
+          this.$data.reference.string = 'this has been changed too';
+          await this.$data.reference.$save();
+        }
+
+        await this.$save();
+
+        if (throwError) {
+          throw Error('An error.');
+        }
+
+        return 'Success.';
+      },
+      async (nymph) => {
+        this.$setNymph(nymph);
+      },
+    );
+  }
 }
 
 /**
@@ -77,12 +124,14 @@ 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;
-  }
+export type TestEmptyModelData = {};
 
-  static factorySync(guid?: string): TestBModel & TestModelData {
-    return super.factorySync(guid) as TestBModel & TestModelData;
-  }
+/**
+ * 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';
 }

package/src/testMocks.ts

@@ -1,10 +1,21 @@
 import { guid } from '@nymphjs/guid';
 
-import type Nymph from './Nymph';
-import { EntityConstructor, EntityInterface, EntityJson } from './Entity.types';
-import { Options, Selector } from './Nymph.types';
-import { ClassNotAvailableError } from './errors';
-import Entity from './Entity';
+import type Nymph from './Nymph.js';
+import type { EntityInstanceType, EntityObjectType } from './Entity.js';
+import type {
+  EntityConstructor,
+  EntityInterface,
+  EntityJson,
+} from './Entity.types.js';
+import { Options, Selector } from './Nymph.types.js';
+import { ClassNotAvailableError, EntityConflictError } from './errors/index.js';
+import Entity from './Entity.js';
+import {
+  classNamesToEntityConstructors,
+  entitiesToReferences,
+  entityConstructorsToClassNames,
+  referencesToEntities,
+} from './utils.js';
 
 const entities: { [k: string]: EntityJson } = {};
 
@@ -15,43 +26,64 @@ export class MockNymphDriver {
     this.nymph = nymph;
   }
 
-  public getEntitySync<T extends EntityConstructor = EntityConstructor>(
+  public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> & { return: 'guid' },
     ...selectors: Selector[]
-  ): string | null;
-  public getEntitySync<T extends EntityConstructor = EntityConstructor>(
+  ): Promise<string | null>;
+  public async getEntity<T extends EntityConstructor = EntityConstructor>(
+    options: Options<T> & { return: 'object' },
+    ...selectors: Selector[]
+  ): Promise<EntityObjectType<T> | null>;
+  public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T>,
     ...selectors: Selector[]
-  ): ReturnType<T['factorySync']> | null;
-  public getEntitySync<T extends EntityConstructor = EntityConstructor>(
+  ): Promise<EntityInstanceType<T> | null>;
+  public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> & { return: 'guid' },
-    guid: string
-  ): string | null;
-  public getEntitySync<T extends EntityConstructor = EntityConstructor>(
+    guid: string,
+  ): Promise<string | null>;
+  public async getEntity<T extends EntityConstructor = EntityConstructor>(
+    options: Options<T> & { return: 'object' },
+    guid: string,
+  ): Promise<EntityObjectType<T> | null>;
+  public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T>,
-    guid: string
-  ): ReturnType<T['factorySync']> | null;
-  public getEntitySync<T extends EntityConstructor = EntityConstructor>(
+    guid: string,
+  ): Promise<EntityInstanceType<T> | null>;
+  public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> = {},
     ...selectors: Selector[] | string[]
-  ): ReturnType<T['factorySync']> | string | null {
+  ): Promise<EntityInstanceType<T> | EntityObjectType<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;
     entity.cdate = entityJson.cdate;
     entity.mdate = entityJson.mdate;
     entity.tags = entityJson.tags;
-    entity.$putData(entityJson.data, {});
-
-    return entity as ReturnType<T['factorySync']>;
+    entity.$putData(
+      classNamesToEntityConstructors(
+        this.nymph as unknown as Nymph,
+        referencesToEntities(
+          entityJson.data,
+          this.nymph as unknown as Nymph,
+          !!options.skipAc,
+          false,
+        ),
+        false,
+      ),
+      {},
+      'server',
+    );
+
+    return entity as EntityInstanceType<T>;
   }
 }
 
@@ -68,53 +100,79 @@ 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);
       }
+    };
+    return this.entityClasses[EntityClass.class] as 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 {
+    let key: string | null = null;
+    if (typeof className === 'string') {
+      key = className;
+    } else {
+      key = className.class;
+    }
+    if (key in this.entityClasses) {
+      return this.entityClasses[key];
     }
-    this.entityClasses[entityClass.class] = NymphEntity;
-    return NymphEntity;
+    throw new ClassNotAvailableError(`Tried to use missing class "${key}".`);
   }
 
-  public getEntityClass(className: string): EntityConstructor {
-    if (className in this.entityClasses) {
-      return this.entityClasses[className];
+  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 class: ' + className);
+    throw new ClassNotAvailableError(
+      `Tried to use missing class by etype "${etype}".`,
+    );
   }
 
   public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> & { return: 'guid' },
     ...selectors: Selector[]
   ): Promise<string | null>;
+  public async getEntity<T extends EntityConstructor = EntityConstructor>(
+    options: Options<T> & { return: 'object' },
+    ...selectors: Selector[]
+  ): Promise<EntityObjectType<T> | null>;
   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
+    guid: string,
   ): Promise<string | null>;
+  public async getEntity<T extends EntityConstructor = EntityConstructor>(
+    options: Options<T> & { return: 'object' },
+    guid: string,
+  ): Promise<EntityObjectType<T> | null>;
   public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T>,
-    guid: string
-  ): Promise<ReturnType<T['factorySync']> | null>;
+    guid: string,
+  ): 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> | EntityObjectType<T> | string | null> {
     // @ts-ignore: The selector type is correct here.
-    return this.driver.getEntitySync(options, ...selectors);
+    return await this.driver.getEntity(options, ...selectors);
   }
 
   public async saveEntity(entity: EntityInterface): Promise<boolean> {
-    const className = (entity.constructor as any).class as string;
-
     if (entity.guid == null) {
       entity.guid = guid();
       entity.cdate = Date.now();
@@ -122,18 +180,26 @@ export class MockNymph {
       entity.guid in entities &&
       (entity.mdate ?? 0) < (entities[entity.guid].mdate ?? 0)
     ) {
-      return false;
+      throw new EntityConflictError(
+        "Entity either doesn't exist or is newer in the DB.",
+      );
     }
 
     entity.mdate = Date.now();
 
     const entityJson: EntityJson = {
-      class: className,
+      class: entity.constructor as EntityConstructor,
       guid: entity.guid,
       cdate: entity.cdate,
       mdate: entity.mdate,
       tags: [...entity.tags],
-      data: JSON.parse(JSON.stringify(entity.$getData(true))),
+      data: JSON.parse(
+        JSON.stringify(
+          entityConstructorsToClassNames(
+            entitiesToReferences(entity.$getData(true), true),
+          ),
+        ),
+      ),
     };
 
     entities[entity.guid] = entityJson;