Merge pull request #104 from sam-n-johnston/feat/use-name-in-description-and-bugfix

Author: fernyettheplant

README.md

@@ -23,6 +23,7 @@ If the plugin is being useful in your company and/or project and want to keep th
 
 ## Requirements
 
+- [serverless](https://github.com/serverless/serverless)
 - [serverless-offline](https://github.com/dherault/serverless-offline)
 - [serverless-step-functions plugin](https://github.com/serverless-operations/serverless-step-functions)
 - [serverless-webpack (optional)](https://github.com/serverless-heaven/serverless-webpack)
@@ -67,16 +68,16 @@ plugins:
 
 ## State Types Supported
 
-| States | Notes |
-| ------ | ------ |
-| ***Task*** | Retry/Catch now supported!, `Timeout` and `Heartbeat` are not supported yet. |
-| ***Choice*** | ✅ |
-| ***Wait***  | ✅ |
-| ***Parallel*** | Not Supported at all yet. |
-| ***Pass*** | ✅ |
-| ***Fail***| ✅ |
-| ***Succeed***|✅|
-| ***Map*** | Basic Support ✅ |
+| States         | Notes                                                                              |
+| -------------- | ---------------------------------------------------------------------------------- |
+| **_Task_**     | Basic Retry/Catch now supported!, `Timeout` and `Heartbeat` are not supported yet. |
+| **_Choice_**   | ✅                                                                                 |
+| **_Wait_**     | ✅                                                                                 |
+| **_Parallel_** | Not Supported at all yet.                                                          |
+| **_Pass_**     | ✅                                                                                 |
+| **_Fail_**     | ✅                                                                                 |
+| **_Succeed_**  | ✅                                                                                 |
+| **_Map_**      | Not Supported at all yet.                                                          |
 
 ## Credits and inspiration
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fernthedev/serverless-offline-step-functions",
-  "version": "1.0.0-alpha.13",
+  "version": "1.0.0-alpha.14",
   "description": "Serverless Offline Plugin to Support Step Functions for Local Development",
   "main": "dist/main.js",
   "types": "dist/main.d.ts",

src/StateMachine/StateMachine.ts

@@ -0,0 +1,20 @@
+import { StateMachineDefinition, StateMachineDescription } from '../types/StateMachineDescription';
+
+export class StateMachine {
+  private constructor(
+    private readonly _stateMachineKey: string,
+    private readonly _stateMachineDescription: StateMachineDescription,
+  ) {}
+
+  public static create(stateMachineKey: string, stateMachineDescription: StateMachineDescription): StateMachine {
+    return new StateMachine(stateMachineKey, stateMachineDescription);
+  }
+
+  public get definition(): StateMachineDefinition {
+    return this._stateMachineDescription.definition;
+  }
+
+  public get name(): string {
+    return this._stateMachineDescription.name || this._stateMachineKey;
+  }
+}

src/StateMachine/StateMachines.ts

@@ -0,0 +1,21 @@
+import { StateMachinesDescription } from '../types/StateMachineDescription';
+import { StateMachine } from './StateMachine';
+
+export class StateMachines {
+  private constructor(private readonly _stateMachines: StateMachine[]) {}
+
+  public static create(stateMachines: StateMachinesDescription): StateMachines {
+    const stateMachineTupleArray = Object.entries(stateMachines);
+    const stateMachineArray = stateMachineTupleArray.map(([key, val]) => StateMachine.create(key, val));
+
+    return new StateMachines(stateMachineArray);
+  }
+
+  public getStateMachineBy(name: string): StateMachine {
+    return this._stateMachines.filter((val) => val.name === name)[0];
+  }
+
+  public get stateMachines(): StateMachine[] {
+    return this._stateMachines;
+  }
+}

src/StateMachineExecutor.ts

@@ -1,4 +1,3 @@
-import type { StateMachine } from './types/StateMachine';
 import type { StateDefinition, TaskStateDefinition } from './types/State';
 
 import { StateTypeExecutorFactory } from './stateTasks/StateTypeExecutorFactory';
@@ -7,6 +6,7 @@ import { Logger } from './utils/Logger';
 import { Context } from './Context/Context';
 import { StateContext } from './Context/StateContext';
 import { ContextToJson } from './Context/ContextToJson';
+import { StateMachine } from './StateMachine/StateMachine';
 import { isJsonByteLengthValid } from './utils/isJsonByteLengthValid';
 
 export type ExecuteType = () => Promise<ExecuteType | string | void>;
@@ -40,7 +40,7 @@ export class StateMachineExecutor {
 
       this.logger.debug(`StateMachineExecutor - execute1 - ${stateExecutorOutput}`);
 
-      if (isJsonByteLengthValid(stateExecutorOutput.json)) {
+      if (!isJsonByteLengthValid(stateExecutorOutput.json)) {
         this.logger.error(
           `The state/task '${this.context.State.Name}' returned a result with a size exceeding the maximum number of bytes service limit.`,
         );

src/StateProcessor.ts

@@ -87,7 +87,12 @@ export class StateProcessor {
     return JSON.stringify(input);
   }
 
-  public static processOutputPath(json: string, outputPath?: string): string {
+  public static processOutputPath(json?: string, outputPath?: string): string {
+    // TODO: check if AWS throws or skips this
+    if (!json) {
+      throw new Error('Output JSON of lambda was undefined');
+    }
+
     const result = JSONPath({
       path: outputPath || '$',
       json: JSON.parse(json),

src/StepFunctionSimulatorServer.ts

@@ -2,14 +2,14 @@ import { createHttpTerminator, HttpTerminator } from 'http-terminator';
 import express, { Express, Request, Response } from 'express';
 import type { StepFunctions } from 'aws-sdk';
 
-import type { StateMachines } from './types/StateMachine';
 import type { StateDefinition } from './types/State';
 import { ExecuteType, StateMachineExecutor } from './StateMachineExecutor';
 import { Logger } from './utils/Logger';
 import { StateMachineContext } from './Context/StateMachineContext';
 import { ExecutionContext } from './Context/ExecutionContext';
 import { Context } from './Context/Context';
 import { StateContext } from './Context/StateContext';
+import { StateMachines } from './StateMachine/StateMachines';
 
 export type StepFunctionSimulatorServerOptions = {
   port: number;
@@ -21,11 +21,13 @@ export class StepFunctionSimulatorServer {
   private httpTerminator?: HttpTerminator;
   // TODO: Move State Machines and type it
   private options: StepFunctionSimulatorServerOptions;
+  private stateMachines: StateMachines;
   private readonly logger: Logger;
   private pendingStateMachineExecutions: { [key: string]: ExecuteType } = {};
 
   constructor(options: StepFunctionSimulatorServerOptions) {
     this.options = options;
+    this.stateMachines = this.options.stateMachines;
     this.logger = Logger.getInstance();
     this.express = express();
     this.setupMiddlewares();
@@ -97,10 +99,12 @@ export class StepFunctionSimulatorServer {
 
     const executionInput: StepFunctions.Types.StartExecutionInput = req.body;
     const stateMachineContext = StateMachineContext.create(executionInput.stateMachineArn);
-    const stateMachineToExecute = this.options.stateMachines[stateMachineContext.Name];
+    const stateMachineToExecute = this.stateMachines.getStateMachineBy(stateMachineContext.Name);
 
     if (!stateMachineToExecute) {
-      return res.status(500);
+      const message = `No state machine with name ${stateMachineContext.Name} exists in the serverless`;
+      this.logger.error(message);
+      return res.status(200).send({ message });
     }
 
     const executionContext = ExecutionContext.create(stateMachineContext, executionInput.input);

src/main.ts

@@ -10,6 +10,8 @@ import { Logger } from './utils/Logger';
 import { MapStateDefinition, StateDefinition, TaskStateDefinition } from './types/State';
 import { StateType } from './stateTasks/StateType';
 import { EnvVarResolver } from './utils/EnvVarResolver';
+import { StateMachines } from './StateMachine/StateMachines';
+import { StateMachinesDescription } from './types/StateMachineDescription';
 
 class ServerlessOfflineStepFunctionsPlugin {
   public hooks?: ServerlessOfflineHooks;
@@ -62,13 +64,19 @@ class ServerlessOfflineStepFunctionsPlugin {
     envVarResolver.injectGlobalEnvVars();
 
     // Get Handler and Path of the Local Functions
-    const definedStateMachines = this.serverless.service.initialServerlessConfig?.stepFunctions?.stateMachines;
+    const definedStateMachines: StateMachinesDescription = this.serverless.service.initialServerlessConfig
+      ?.stepFunctions?.stateMachines;
 
-    this.resolveHandlers(definedStateMachines);
+    const stateMachines = StateMachines.create(definedStateMachines);
+
+    if (!stateMachines) {
+      throw new Error('No step machines defined');
+    }
+    this.resolveHandlers(stateMachines);
 
     this.stepFunctionSimulatorServer = new StepFunctionSimulatorServer({
       port: this.options?.port || 8014,
-      stateMachines: definedStateMachines,
+      stateMachines,
     });
   }
 
@@ -149,14 +157,12 @@ class ServerlessOfflineStepFunctionsPlugin {
     }
   }
 
-  private resolveHandlers(definedStateMachines: any) {
-    const definedStateMachinesArr = Object.entries(definedStateMachines);
-
+  private resolveHandlers(definedStateMachines: StateMachines) {
     // Per StateMachine
-    for (const [stateMachineName, stateMachineOptions] of definedStateMachinesArr) {
-      const states: [string, StateDefinition][] = Object.entries((stateMachineOptions as any).definition.States);
+    for (const stateMachine of definedStateMachines.stateMachines) {
+      const states: [string, StateDefinition][] = Object.entries(stateMachine.definition.States);
 
-      this.setStateInfo(states, stateMachineName);
+      this.setStateInfo(states, stateMachine.name);
     }
   }
 }

src/stateTasks/executors/MapExecutor.ts

@@ -4,9 +4,10 @@ import type { MapStateDefinition } from '../../types/State';
 
 import { Context } from '../../Context/Context';
 import { ExecuteType, StateMachineExecutor } from '../../StateMachineExecutor';
-import { StateMachine } from '../../types/StateMachine';
 import { StateContext } from '../../Context/StateContext';
 import { StateProcessor } from '../../StateProcessor';
+import { StateMachineDescription } from '../../types/StateMachineDescription';
+import { StateMachine } from '../../StateMachine/StateMachine';
 
 export class MapExecutor extends StateTypeExecutor {
   private pendingStateMachineExecutions: { [key: string]: ExecuteType } = {};
@@ -16,10 +17,12 @@ export class MapExecutor extends StateTypeExecutor {
     stateDefinition: MapStateDefinition,
     inputJson: string | undefined,
   ): Promise<StateExecutorOutput> {
-    const stateMachine: StateMachine = {
-      name: stateDefinition.Comment || '',
+    const stateMachineDescription: StateMachineDescription = {
+      name: stateDefinition.Comment,
       definition: stateDefinition.Iterator,
     };
+
+    const stateMachine = StateMachine.create(stateMachineDescription.name || '', stateMachineDescription);
     // TODO: Extract common logic from StepFunctionSimulatorServer
     // TODO: Make nested Maps work
     // TODO: Make the waitForTaskToken work in Map & nested maps

src/types/State.ts

@@ -1,4 +1,4 @@
-import type { StateMachineDefinition } from './StateMachine';
+import type { StateMachineDefinition } from './StateMachineDescription';
 import { StateType } from '../stateTasks/StateType';
 import { StatesErrors } from './StatesErrors';
 

src/types/StateMachine.ts renamed to src/types/StateMachineDescription.ts

@@ -7,12 +7,12 @@ export type StateMachineDefinition = {
   };
 };
 
-export type StateMachine = {
-  name: string;
+export type StateMachineDescription = {
+  name?: string;
   definition: StateMachineDefinition;
 };
 
 // TODO: Temporal, move to Serverless type
-export type StateMachines = {
-  [key: string]: StateMachine;
+export type StateMachinesDescription = {
+  [key: string]: StateMachineDescription;
 };