@nymphjs/nymph 1.0.0-beta.120 → 1.0.0-beta.122

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

@@ -14,6 +14,8 @@ export * from './InvalidParametersError.js';
 
 export * from './InvalidStateError.js';
 
+export * from './MethodFailedError.js';
+
 export * from './NotConfiguredError.js';
 
 export * from './QueryFailedError.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) => 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);
+    }
+
+    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);
+      } 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,6 +1,8 @@
 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.js';
 

package/src/testArtifacts.ts

@@ -1,4 +1,6 @@
 import Entity from './Entity.js';
+import { transactional } from './decorators/index.js';
+import { transaction } from './helpers/index.js';
 
 export type TestModelData = {
   name?: string;
@@ -67,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);
+      },
+    );
+  }
 }
 
 /**

package/src/testMocks.ts

@@ -8,7 +8,7 @@ import type {
   EntityJson,
 } from './Entity.types.js';
 import { Options, Selector } from './Nymph.types.js';
-import { ClassNotAvailableError } from './errors/index.js';
+import { ClassNotAvailableError, EntityConflictError } from './errors/index.js';
 import Entity from './Entity.js';
 
 const entities: { [k: string]: EntityJson } = {};
@@ -163,7 +163,9 @@ 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();