feat: Update StateMachineStage to use definitionBody instead of d…

…eprecated `definition` (#372)

* update definition -> definitionBody

* adding tests and updating props in stages

.projenrc.js

@@ -1,6 +1,6 @@
 const { awscdk, javascript, release, DependencyType } = require("projen");
 
-const CDK_VERSION = "2.80.0";
+const CDK_VERSION = "2.85.0";
 
 const project = new awscdk.AwsCdkConstructLibrary({
   author: "AWS Professional Services",

src/pipelines/stage.ts

@@ -163,10 +163,40 @@ export abstract class DataStage extends Stage {
   }
 }
 
+function getDefinitionBody(definition?: sfn.IChainable | string, definitionFile?: string): sfn.DefinitionBody {
+  if (definition && definitionFile) {
+    throw new Error("Only one of 'definition' or 'definitionFile' should be provided.");
+  }
+  if (!definition && !definitionFile) {
+    throw new Error("One of 'definition' or 'definitionFile' must be provided.");
+  }
+
+  if (definitionFile) {
+    return sfn.DefinitionBody.fromFile(definitionFile, {});
+  } else {
+    if (typeof definition == "string") {
+      return sfn.DefinitionBody.fromString(definition);
+    }
+    if (definition) {
+      return sfn.DefinitionBody.fromChainable(definition);
+    }
+  }
+  throw new Error("Not able to create a definition body.");
+}
+
 /**
  * Properties of a state machine stage.
  */
 export interface StateMachineStageProps extends StageProps {
+  /**
+   * Steps for the state machine.
+   * Can either be provided as 'sfn.IChainable' or a JSON string.
+   */
+  readonly definition?: sfn.IChainable | string;
+  /**
+   * File containing a JSON definition for the state machine.
+   */
+  readonly definitionFile?: string;
   /**
    * Input of the state machine.
    */
@@ -223,13 +253,12 @@ export abstract class StateMachineStage extends DataStage {
 
   /**
    * Constructs a state machine from the definition.
-   * @param definition Steps for the state machine.
    * @param props State machine stage properties.
    * @returns Dictionary with event pattern, targets and state machine construct.
    */
-  protected createStateMachine(definition: sfn.IChainable, props: StateMachineStageProps): CreateStateMachineResult {
+  protected createStateMachine(props: StateMachineStageProps): CreateStateMachineResult {
     const stateMachine = new sfn.StateMachine(this, "State Machine", {
-      definition: definition,
+      definitionBody: getDefinitionBody(props.definition, props.definitionFile),
       stateMachineName: props.stateMachineName,
     });
 

src/stages/appflow-ingestion.ts

@@ -105,7 +105,7 @@ export class AppFlowIngestionStage extends StateMachineStage {
       eventPattern: this.eventPattern,
       targets: this.targets,
       stateMachine: this.stateMachine,
-    } = this.createStateMachine(definition, props));
+    } = this.createStateMachine({ definition: definition, ...props }));
     this.stateMachine.addToRolePolicy(
       new iam.PolicyStatement({
         effect: iam.Effect.ALLOW,

src/stages/athena-sql.ts

@@ -102,7 +102,10 @@ export class AthenaSQLStage extends StateMachineStage {
 
     const definition = athenaQueryExec.next(new sfn.Succeed(this, "Success"));
 
-    ({ eventPattern: this.eventPattern, stateMachine: this.stateMachine } = this.createStateMachine(definition, props));
+    ({ eventPattern: this.eventPattern, stateMachine: this.stateMachine } = this.createStateMachine({
+      definition: definition,
+      ...props,
+    }));
     this.targets = [
       new eventsTargets.SfnStateMachine(this.stateMachine, {
         input: props.queryString

src/stages/databrew-transform.ts

@@ -192,7 +192,7 @@ export class DataBrewTransformStage extends StateMachineStage {
       eventPattern: this.eventPattern,
       targets: this.targets,
       stateMachine: this.stateMachine,
-    } = this.createStateMachine(definition, props));
+    } = this.createStateMachine({ definition: definition, ...props }));
   }
 
   private createDefaultDataBrewJobRole(): iam.Role {

src/stages/glue-transform.ts

@@ -131,7 +131,7 @@ export class GlueTransformStage extends StateMachineStage {
       eventPattern: this.eventPattern,
       targets: this.targets,
       stateMachine: this.stateMachine,
-    } = this.createStateMachine(definition, props));
+    } = this.createStateMachine({ definition: definition, ...props }));
   }
 
   private getGlueJob(scope: Construct, id: string, props: GlueTransformStageProps): glue_alpha.IJob {

src/stages/mwaa-trigger-dags.ts

@@ -95,7 +95,7 @@ export class MWAATriggerDagsStage extends StateMachineStage {
       eventPattern: this.eventPattern,
       targets: this.targets,
       stateMachine: this.stateMachine,
-    } = this.createStateMachine(definition, props));
+    } = this.createStateMachine({ definition: definition, ...props }));
   }
 
   private buildLambdas(): MWAALambdasResult {

src/stages/redshift-data-api.ts

@@ -102,7 +102,10 @@ export class RedshiftDataApiStage extends StateMachineStage {
           .otherwise(wait),
       );
 
-    ({ eventPattern: this.eventPattern, stateMachine: this.stateMachine } = this.createStateMachine(definition, props));
+    ({ eventPattern: this.eventPattern, stateMachine: this.stateMachine } = this.createStateMachine({
+      definition: definition,
+      ...props,
+    }));
     this.stateMachine.addToRolePolicy(
       new iam.PolicyStatement({
         effect: iam.Effect.ALLOW,

test/base-stack.test.ts

@@ -333,7 +333,7 @@ test("Test Permissions Boundary Creation and Usage in BaseStack", () => {
   const stackTemplate = Template.fromStack(stack);
   stackTemplate.hasResourceProperties("AWS::IAM::Role", {
     PermissionsBoundary: {
-      Ref: "DDKDefaultPermissionsBoundary6721F63A",
+      "Fn::ImportValue": "my-bootstrap-stack:ExportsOutputRefDDKDefaultPermissionsBoundary6721F63A9C9C311E",
     },
   });
 });

test/sfn-stage.test.ts

@@ -0,0 +1,56 @@
+import * as cdk from "aws-cdk-lib";
+import * as events from "aws-cdk-lib/aws-events";
+import * as sfn from "aws-cdk-lib/aws-stepfunctions";
+import { Construct } from "constructs";
+
+import { StateMachineStage, StateMachineStageProps } from "../src";
+
+class TestSFNStage extends StateMachineStage {
+  readonly targets?: events.IRuleTarget[];
+  readonly eventPattern?: events.EventPattern;
+  readonly stateMachine: sfn.StateMachine;
+
+  constructor(scope: Construct, id: string, props: StateMachineStageProps) {
+    super(scope, id, props);
+    ({
+      eventPattern: this.eventPattern,
+      targets: this.targets,
+      stateMachine: this.stateMachine,
+    } = this.createStateMachine({
+      definition: props.definition,
+      definitionFile: props.definitionFile,
+      ...props,
+    }));
+  }
+}
+
+test("State Machine Stage Definition File", () => {
+  const stack = new cdk.Stack();
+  new TestSFNStage(stack, "MySFN", {
+    definitionFile: "./test/test-sfn-config.json",
+  });
+});
+
+test("State Machine Stage Definition String", () => {
+  const stack = new cdk.Stack();
+  new TestSFNStage(stack, "MySFN", {
+    definition: '{"StartAt":"Pass","States":{"Pass":{"Type":"Pass","End":true}}}',
+  });
+});
+
+test("SFN No Definition", () => {
+  const stack = new cdk.Stack();
+  expect(() => {
+    new TestSFNStage(stack, "MySFN", {});
+  }).toThrowError("One of 'definition' or 'definitionFile' must be provided.");
+});
+
+test("SFN Redundant Definitions", () => {
+  const stack = new cdk.Stack();
+  expect(() => {
+    new TestSFNStage(stack, "MySFN", {
+      definition: '{"StartAt":"Pass","States":{"Pass":{"Type":"Pass","End":true}}}',
+      definitionFile: "./test/test-sfn-config.json",
+    });
+  }).toThrowError("Only one of 'definition' or 'definitionFile' should be provided.");
+});