Merge pull request #37 from sam-n-johnston/feat/add-catchers

[2] Feat/add catchers

Author: fernyettheplant

src/stateTasks/executors/TaskExecutor.ts

@@ -9,6 +9,8 @@ import { StateInfoHandler } from '../../StateInfoHandler';
 import { StateProcessor } from '../../StateProcessor';
 import { Context } from '../../Context/Context';
 import { Retriers } from '../../types/Retriers';
+import { Catchers } from '../../types/Catchers';
+import { StatesErrors } from '../../types/StatesErrors';
 
 export class TaskExecutor extends StateTypeExecutor {
   public async execute(
@@ -31,11 +33,17 @@ export class TaskExecutor extends StateTypeExecutor {
 
     // eslint-disable-next-line @typescript-eslint/ban-types
     let output: any;
-    if (stateDefinition.Retry) {
-      const retrier = Retriers.create(stateDefinition.Retry);
-      output = await retrier.retry(functionLambda[stateInfo.handlerName].bind(this, input, context));
-    } else {
-      output = await functionLambda[stateInfo.handlerName](input, context);
+    try {
+      if (stateDefinition.Retry) {
+        const retrier = Retriers.create(stateDefinition.Retry);
+        output = await retrier.retry(() => functionLambda[stateInfo.handlerName](input, context));
+      } else {
+        output = await functionLambda[stateInfo.handlerName](input, context);
+      }
+    } catch (error) {
+      this.removeEnvVarsLambdaSpecific(stateInfo.environment);
+
+      return this.dealWithError(stateDefinition, error, input);
     }
 
     this.removeEnvVarsLambdaSpecific(stateInfo.environment);
@@ -56,7 +64,33 @@ export class TaskExecutor extends StateTypeExecutor {
     return false;
   }
 
-  private processInput(json: string | undefined, stateDefinition: TaskStateDefinition, context: Context): any {
+  private dealWithError(stateDefinition: TaskStateDefinition, error: Error, input: Record<string, unknown>) {
+    if (!stateDefinition.Catch) {
+      throw error;
+    }
+
+    const catchers = Catchers.create(stateDefinition.Catch);
+    const catcher = catchers.getCatcherBasedOn([StatesErrors.TaskFailed, StatesErrors.All]);
+
+    if (!catcher) {
+      throw error;
+    }
+
+    const output = { message: error.message, stack: error.stack };
+    const outputJson = StateProcessor.processResultPath(input, output, catcher.ResultPath);
+
+    return {
+      Next: catcher.Next,
+      End: stateDefinition.End,
+      json: outputJson,
+    };
+  }
+
+  private processInput(
+    json: string | undefined,
+    stateDefinition: TaskStateDefinition,
+    context: Context,
+  ): StateExecutorOutput {
     const proccessedInputJson = StateProcessor.processInputPath(json, stateDefinition.InputPath);
 
     let output = proccessedInputJson;

src/types/Catcher.ts

@@ -0,0 +1,30 @@
+import { TaskCatchRule } from './State';
+import { StatesErrors } from './StatesErrors';
+
+export class Catcher {
+  private constructor(
+    private readonly _ErrorEquals: StatesErrors[],
+    private readonly _Next: string,
+    private readonly _ResultPath?: string,
+  ) {}
+
+  public static create(taskCatchRule: TaskCatchRule): Catcher {
+    return new Catcher(taskCatchRule.ErrorEquals, taskCatchRule.Next, taskCatchRule.ResultPath);
+  }
+
+  get Next(): string {
+    return this._Next;
+  }
+
+  get ErrorEquals(): StatesErrors[] {
+    return this._ErrorEquals;
+  }
+
+  get ResultPath(): string | undefined {
+    return this._ResultPath;
+  }
+
+  public includesSomeOf(statesErrors: StatesErrors[]): boolean {
+    return statesErrors.some((statesError) => this.ErrorEquals.includes(statesError));
+  }
+}

src/types/Catchers.ts

@@ -0,0 +1,24 @@
+import { Catcher } from './Catcher';
+import { TaskCatchRule } from './State';
+import { StatesErrors } from './StatesErrors';
+
+export class Catchers {
+  private constructor(private readonly _catchers: Catcher[]) {}
+
+  public static create(taskCatchRules: TaskCatchRule[]): Catchers {
+    const catchers = taskCatchRules.map((taskCatchRule) => {
+      return Catcher.create(taskCatchRule);
+    });
+    return new Catchers(catchers);
+  }
+
+  public getCatcherBasedOn(statesErrors: StatesErrors[]): Catcher | undefined {
+    const catcher = this._catchers.find((catcher) => {
+      return catcher.includesSomeOf(statesErrors);
+    });
+    if (!catcher) {
+      return;
+    }
+    return catcher;
+  }
+}

src/types/Retrier.ts

@@ -1,12 +1,5 @@
 import { TaskRetryRule } from './State';
-
-export enum StatesErrors {
-  DataLimitExceeded = 'States.DataLimitExceeded',
-  Runtime = 'States.Runtime',
-  Timeout = 'States.Timeout',
-  TaskFailed = 'States.TaskFailed',
-  Permissions = 'States.Permissions',
-}
+import { StatesErrors } from './StatesErrors';
 
 export class Retrier {
   private currentNumberOfRetries = 0;
@@ -31,15 +24,22 @@ export class Retrier {
   }
 
   async retry(fn: () => any): Promise<any> {
+    let output: unknown;
     try {
-      return await fn();
+      output = await fn();
+      return output;
     } catch (error) {
       if (this.currentNumberOfRetries < this._MaxAttempts) {
         this.currentNumberOfRetries++;
-        return await new Promise((resolve) => {
+        return await new Promise((resolve, reject) => {
           setTimeout(async () => {
             this.currentIntervalSeconds = this.currentIntervalSeconds * this._BackoffRate;
-            return resolve(await this.retry(fn));
+            try {
+              const output = await this.retry(fn);
+              return resolve(output);
+            } catch (error) {
+              return reject(error);
+            }
           }, this.currentIntervalSeconds * 1000);
         });
       } else {

src/types/Retriers.ts

@@ -1,5 +1,6 @@
-import { Retrier, StatesErrors } from './Retrier';
+import { Retrier } from './Retrier';
 import { TaskRetryRule } from './State';
+import { StatesErrors } from './StatesErrors';
 
 export class Retriers {
   private constructor(private readonly _retriers: Retrier[]) {}

src/types/State.ts

@@ -1,6 +1,6 @@
 import type { StateMachineDefinition } from './StateMachine';
 import { StateType } from '../stateTasks/StateType';
-import { StatesErrors } from './Retrier';
+import { StatesErrors } from './StatesErrors';
 
 export type StateInfo = {
   handlerPath: string;

src/types/StatesErrors.ts

@@ -0,0 +1,8 @@
+export enum StatesErrors {
+  All = 'States.ALL',
+  DataLimitExceeded = 'States.DataLimitExceeded',
+  Runtime = 'States.Runtime',
+  Timeout = 'States.Timeout',
+  TaskFailed = 'States.TaskFailed',
+  Permissions = 'States.Permissions',
+}

tests/src/Retrier.test.ts

@@ -1,4 +1,5 @@
-import { Retrier, StatesErrors } from '../../src/types/Retrier';
+import { Retrier } from '../../src/types/Retrier';
+import { StatesErrors } from '../../src/types/StatesErrors';
 
 describe('Retrier', () => {
   describe('when the function succeeds', () => {