terraconstructs 0.0.8

package/lib/aws/compute/state-machine.js

@@ -0,0 +1,392 @@
+"use strict";
+var _a, _b, _c, _d;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevel = exports.StateMachineType = exports.ChainDefinitionBody = exports.StringDefinitionBody = exports.DefinitionBody = exports.StateMachine = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const __1 = require("..");
+const state_graph_1 = require("./state-graph");
+const iam = require("../iam");
+/**
+ * A new or imported state machine.
+ */
+class StateMachineBase extends __1.AwsConstructBase {
+    /**
+     * Import a state machine
+     */
+    static fromStateMachineArn(scope, id, stateMachineArn) {
+        class Import extends StateMachineBase {
+            constructor() {
+                super(...arguments);
+                this.stateMachineArn = stateMachineArn;
+                this.grantPrincipal = new iam.UnknownPrincipal({
+                    resource: this,
+                });
+            }
+            get stateMachineOutputs() {
+                return {
+                    arn: this.stateMachineArn,
+                };
+            }
+            get outputs() {
+                return this.stateMachineOutputs;
+            }
+        }
+        return new Import(scope, id, {
+            environmentFromArn: stateMachineArn,
+        });
+    }
+    /**
+     * Import a state machine via resource name
+     */
+    static fromStateMachineName(scope, id, stateMachineName) {
+        const stateMachineArn = __1.AwsStack.ofAwsConstruct(scope).formatArn({
+            service: "states",
+            resource: "stateMachine",
+            arnFormat: __1.ArnFormat.COLON_RESOURCE_NAME,
+            resourceName: stateMachineName,
+        });
+        return this.fromStateMachineArn(scope, id, stateMachineArn);
+    }
+    get stateMachineOutputs() {
+        return {
+            arn: this.stateMachineArn,
+        };
+    }
+    get outputs() {
+        return this.stateMachineOutputs;
+    }
+    /**
+     * Grant the given identity permissions to start an execution of this state
+     * machine.
+     */
+    grantStartExecution(identity) {
+        return iam.Grant.addToPrincipal({
+            grantee: identity,
+            actions: ["states:StartExecution"],
+            resourceArns: [this.stateMachineArn],
+        });
+    }
+    /**
+     * Grant the given identity permissions to start a synchronous execution of
+     * this state machine.
+     */
+    grantStartSyncExecution(identity) {
+        return iam.Grant.addToPrincipal({
+            grantee: identity,
+            actions: ["states:StartSyncExecution"],
+            resourceArns: [this.stateMachineArn],
+        });
+    }
+    /**
+     * Grant the given identity permissions to read results from state
+     * machine.
+     */
+    grantRead(identity) {
+        iam.Grant.addToPrincipal({
+            grantee: identity,
+            actions: ["states:ListExecutions", "states:ListStateMachines"],
+            resourceArns: [this.stateMachineArn],
+        });
+        iam.Grant.addToPrincipal({
+            grantee: identity,
+            actions: [
+                "states:DescribeExecution",
+                "states:DescribeStateMachineForExecution",
+                "states:GetExecutionHistory",
+            ],
+            resourceArns: [`${this.executionArn()}:*`],
+        });
+        return iam.Grant.addToPrincipal({
+            grantee: identity,
+            actions: [
+                "states:ListActivities",
+                "states:DescribeStateMachine",
+                "states:DescribeActivity",
+            ],
+            resourceArns: ["*"],
+        });
+    }
+    /**
+     * Grant the given identity task response permissions on a state machine
+     */
+    grantTaskResponse(identity) {
+        return iam.Grant.addToPrincipal({
+            grantee: identity,
+            actions: [
+                "states:SendTaskSuccess",
+                "states:SendTaskFailure",
+                "states:SendTaskHeartbeat",
+            ],
+            resourceArns: [this.stateMachineArn],
+        });
+    }
+    /**
+     * Grant the given identity permissions on all executions of the state machine
+     */
+    grantExecution(identity, ...actions) {
+        return iam.Grant.addToPrincipal({
+            grantee: identity,
+            actions,
+            resourceArns: [`${this.executionArn()}:*`],
+        });
+    }
+    /**
+     * Grant the given identity custom permissions
+     */
+    grant(identity, ...actions) {
+        return iam.Grant.addToPrincipal({
+            grantee: identity,
+            actions,
+            resourceArns: [this.stateMachineArn],
+        });
+    }
+    /**
+     * Returns the pattern for the execution ARN's of the state machine
+     */
+    executionArn() {
+        return this.stack.formatArn({
+            resource: "execution",
+            service: "states",
+            resourceName: __1.Arn.split(this.stateMachineArn, __1.ArnFormat.COLON_RESOURCE_NAME).resourceName,
+            arnFormat: __1.ArnFormat.COLON_RESOURCE_NAME,
+        });
+    }
+}
+/**
+ * Define a StepFunctions State Machine
+ */
+class StateMachine extends StateMachineBase {
+    /**
+     * The name of the state machine
+     * @attribute
+     */
+    get stateMachineName() {
+        return this.resource.name;
+    }
+    /**
+     * The ARN of the state machine
+     */
+    get stateMachineArn() {
+        return this.resource.arn;
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        const { stateMachineName, namePrefix } = this.validateStateMachineName(props.stateMachineName, props.namePrefix);
+        this.role =
+            props.role ||
+                new iam.Role(this, "Role", {
+                    assumedBy: new iam.ServicePrincipal("states.amazonaws.com"),
+                });
+        const definitionBody = props.definitionBody;
+        this.stateMachineType = props.stateMachineType ?? StateMachineType.STANDARD;
+        let graph = undefined;
+        if (definitionBody instanceof ChainDefinitionBody) {
+            graph = new state_graph_1.StateGraph(definitionBody.chainable.startState, "State Machine definition");
+            graph.timeout = props.timeout;
+            for (const statement of graph.policyStatements) {
+                this.addToRolePolicy(statement);
+            }
+        }
+        this.resource = new provider_aws_1.sfnStateMachine.SfnStateMachine(this, "Resource", {
+            name: stateMachineName,
+            namePrefix,
+            type: props.stateMachineType ?? undefined,
+            roleArn: this.role.roleArn,
+            loggingConfiguration: props.logs
+                ? this.buildLoggingConfiguration(props.logs)
+                : undefined,
+            tracingConfiguration: this.buildTracingConfiguration(props.tracingEnabled),
+            ...definitionBody.bind(this, this.role, props, graph),
+            publish: props.publish,
+            tags: props.tags,
+            // encryptionConfiguration: buildEncryptionConfiguration(props.encryptionConfiguration),
+        });
+        if (definitionBody instanceof ChainDefinitionBody) {
+            graph.bind(this);
+        }
+        this.resource.node.addDependency(this.role);
+        this.stateMachineRevisionId = this.resource.stateMachineVersionArn;
+    }
+    /**
+     * The principal this state machine is running as
+     */
+    get grantPrincipal() {
+        return this.role.grantPrincipal;
+    }
+    /**
+     * Add the given statement to the role's policy
+     */
+    addToRolePolicy(statement) {
+        this.role.addToPrincipalPolicy(statement);
+    }
+    validateStateMachineName(stateMachineName, prefix) {
+        if (stateMachineName && prefix) {
+            throw new Error("Cannot specify both 'stateMachineName' and 'namePrefix'. Use only one.");
+        }
+        else {
+        }
+        if (!stateMachineName) {
+            return {
+                namePrefix: this.stack.uniqueResourceNamePrefix(this, {
+                    prefix: (prefix ?? this.gridUUID) + "-",
+                    allowedSpecialCharacters: "-_",
+                    maxLength: 80,
+                }),
+            };
+        }
+        else {
+            if (cdktf_1.Token.isUnresolved(stateMachineName)) {
+                // can't really validate...
+                return {
+                    stateMachineName,
+                };
+            }
+            if (stateMachineName.length < 1 || stateMachineName.length > 80) {
+                throw new Error(`State Machine name must be between 1 and 80 characters. Received: ${stateMachineName}`);
+            }
+            if (!stateMachineName.match(/^[a-z0-9\+\!\@\.\(\)\-\=\_\']+$/i)) {
+                throw new Error(`State Machine name must match "^[a-z0-9+!@.()-=_']+$/i". Received: ${stateMachineName}`);
+            }
+        }
+        return {
+            stateMachineName,
+        };
+    }
+    buildLoggingConfiguration(logOptions) {
+        // https://docs.aws.amazon.com/step-functions/latest/dg/cw-logs.html#cloudwatch-iam-policy
+        this.addToRolePolicy(new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions: [
+                "logs:CreateLogDelivery",
+                "logs:GetLogDelivery",
+                "logs:UpdateLogDelivery",
+                "logs:DeleteLogDelivery",
+                "logs:ListLogDeliveries",
+                "logs:PutResourcePolicy",
+                "logs:DescribeResourcePolicies",
+                "logs:DescribeLogGroups",
+            ],
+            resources: ["*"],
+        }));
+        return {
+            // TODO: Implement ILogGroup
+            logDestination: logOptions.logDestination,
+            includeExecutionData: logOptions.includeExecutionData,
+            level: logOptions.level || "ERROR",
+        };
+    }
+    buildTracingConfiguration(isTracing) {
+        if (isTracing === undefined) {
+            return undefined;
+        }
+        if (isTracing) {
+            this.addToRolePolicy(new iam.PolicyStatement({
+                // https://docs.aws.amazon.com/xray/latest/devguide/security_iam_id-based-policy-examples.html#xray-permissions-resources
+                // https://docs.aws.amazon.com/step-functions/latest/dg/xray-iam.html
+                actions: [
+                    "xray:PutTraceSegments",
+                    "xray:PutTelemetryRecords",
+                    "xray:GetSamplingRules",
+                    "xray:GetSamplingTargets",
+                ],
+                resources: ["*"],
+            }));
+        }
+        return {
+            enabled: isTracing,
+        };
+    }
+}
+exports.StateMachine = StateMachine;
+_a = JSII_RTTI_SYMBOL_1;
+StateMachine[_a] = { fqn: "terraconstructs.aws.compute.StateMachine", version: "0.0.8" };
+class DefinitionBody {
+    static fromString(definition) {
+        return new StringDefinitionBody(definition);
+    }
+    static fromChainable(chainable) {
+        return new ChainDefinitionBody(chainable);
+    }
+}
+exports.DefinitionBody = DefinitionBody;
+_b = JSII_RTTI_SYMBOL_1;
+DefinitionBody[_b] = { fqn: "terraconstructs.aws.compute.DefinitionBody", version: "0.0.8" };
+class StringDefinitionBody extends DefinitionBody {
+    constructor(body) {
+        super();
+        this.body = body;
+    }
+    bind(_scope, _sfnPrincipal, _sfnProps, _graph) {
+        return {
+            definition: this.body,
+        };
+    }
+}
+exports.StringDefinitionBody = StringDefinitionBody;
+_c = JSII_RTTI_SYMBOL_1;
+StringDefinitionBody[_c] = { fqn: "terraconstructs.aws.compute.StringDefinitionBody", version: "0.0.8" };
+class ChainDefinitionBody extends DefinitionBody {
+    constructor(chainable) {
+        super();
+        this.chainable = chainable;
+    }
+    bind(scope, _sfnPrincipal, sfnProps, graph) {
+        const graphJson = graph.toGraphJson();
+        return {
+            definition: __1.AwsStack.ofAwsConstruct(scope).toJsonString({
+                ...graphJson,
+                Comment: sfnProps.comment,
+            }),
+        };
+    }
+}
+exports.ChainDefinitionBody = ChainDefinitionBody;
+_d = JSII_RTTI_SYMBOL_1;
+ChainDefinitionBody[_d] = { fqn: "terraconstructs.aws.compute.ChainDefinitionBody", version: "0.0.8" };
+/**
+ * Two types of state machines are available in AWS Step Functions: EXPRESS AND STANDARD.
+ *
+ * @see https://docs.aws.amazon.com/step-functions/latest/dg/concepts-standard-vs-express.html
+ *
+ * @default STANDARD
+ */
+var StateMachineType;
+(function (StateMachineType) {
+    /**
+     * Express Workflows are ideal for high-volume, event processing workloads.
+     */
+    StateMachineType["EXPRESS"] = "EXPRESS";
+    /**
+     * Standard Workflows are ideal for long-running, durable, and auditable workflows.
+     */
+    StateMachineType["STANDARD"] = "STANDARD";
+})(StateMachineType || (exports.StateMachineType = StateMachineType = {}));
+/**
+ * Defines which category of execution history events are logged.
+ *
+ * @see https://docs.aws.amazon.com/step-functions/latest/dg/cloudwatch-log-level.html
+ *
+ * @default ERROR
+ */
+var LogLevel;
+(function (LogLevel) {
+    /**
+     * No Logging
+     */
+    LogLevel["OFF"] = "OFF";
+    /**
+     * Log everything
+     */
+    LogLevel["ALL"] = "ALL";
+    /**
+     * Log all errors
+     */
+    LogLevel["ERROR"] = "ERROR";
+    /**
+     * Log fatal errors
+     */
+    LogLevel["FATAL"] = "FATAL";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"state-machine.js","sourceRoot":"","sources":["../../../src/aws/compute/state-machine.ts"],"names":[],"mappings":"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","sourcesContent":["import { sfnStateMachine } from \"@cdktf/provider-aws\";\nimport { Token, IResolvable } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport {\n  AwsConstructBase,\n  IAwsConstruct,\n  AwsConstructProps,\n  AwsStack,\n  Arn,\n  ArnFormat,\n} from \"..\";\nimport { StateGraph } from \"./state-graph\";\nimport { IChainable } from \"./types\";\nimport { Duration } from \"../../\";\nimport * as iam from \"../iam\";\n\n/**\n * Properties for defining a State Machine\n */\nexport interface StateMachineProps extends AwsConstructProps {\n  /**\n   * The name of the state machine.\n   *\n   * To enable logging with CloudWatch Logs, the name should only contain 0-9, A-Z, a-z, - and _.\n   *\n   * Length Constraints: Minimum length of 1. Maximum length of 80.\n   *\n   * @default - Terraform will assign a random, unique suffix.\n   */\n  readonly stateMachineName?: string;\n  /**\n   * Creates a unique name beginning with the specified prefix. Conflicts with `stateMachineName`\n   *\n   * The name should only contain 0-9, A-Z, a-z, - and _\n   * Terraform Prefixes must reserve 26 characters for the terraform generated suffix.\n   *\n   * @default - GridUUID + Stack Unique Name\n   */\n  readonly namePrefix?: string;\n  /**\n   * Definition for this state machine\n   */\n  readonly definitionBody: DefinitionBody;\n  /**\n   * The execution role for the state machine service\n   *\n   * @default A role is automatically created\n   */\n  readonly role?: iam.IRole;\n  /**\n   * Maximum run time for this state machine\n   *\n   * @default No timeout\n   */\n  readonly timeout?: Duration;\n  /**\n   * Comment that describes this state machine\n   *\n   * @default - No comment\n   */\n  readonly comment?: string;\n  /**\n   * Type of the state machine\n   *\n   * @default StateMachineType.STANDARD\n   */\n  readonly stateMachineType?: StateMachineType;\n  /**\n   * Defines what execution history events are logged and where they are logged.\n   *\n   * @default No logging\n   */\n  readonly logs?: LogOptions;\n  /**\n   * Specifies whether Amazon X-Ray tracing is enabled for this state machine.\n   *\n   * @default false\n   */\n  readonly tracingEnabled?: boolean;\n  /**\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/sfn_state_machine#tags SfnStateMachine#tags}\n   */\n  readonly tags?: {\n    [key: string]: string;\n  };\n  /**\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/sfn_state_machine#publish SfnStateMachine#publish}\n   */\n  readonly publish?: boolean | IResolvable;\n}\n\nexport interface StateMachineOutputs {\n  /**\n   * State Machine arn\n   */\n  readonly arn: string;\n}\n\n/**\n * A State Machine\n */\nexport interface IStateMachine extends IAwsConstruct {\n  /** Strongly typed outputs */\n  readonly stateMachineOutputs: StateMachineOutputs;\n\n  /**\n   * The ARN of the state machine\n   * @attribute\n   */\n  readonly stateMachineArn: string;\n\n  /**\n   * Grant the given identity permissions to start an execution of this state\n   * machine.\n   *\n   * @param identity The principal\n   */\n  grantStartExecution(identity: iam.IGrantable): iam.Grant;\n\n  /**\n   * Grant the given identity permissions to start a synchronous execution of\n   * this state machine.\n   *\n   * @param identity The principal\n   */\n  grantStartSyncExecution(identity: iam.IGrantable): iam.Grant;\n\n  /**\n   * Grant the given identity read permissions for this state machine\n   *\n   * @param identity The principal\n   */\n  grantRead(identity: iam.IGrantable): iam.Grant;\n\n  /**\n   * Grant the given identity read permissions for this state machine\n   *\n   * @param identity The principal\n   */\n  grantTaskResponse(identity: iam.IGrantable): iam.Grant;\n\n  /**\n   * Grant the given identity permissions for all executions of a state machine\n   *\n   * @param identity The principal\n   * @param actions The list of desired actions\n   */\n  grantExecution(identity: iam.IGrantable, ...actions: string[]): iam.Grant;\n\n  /**\n   * Grant the given identity custom permissions\n   *\n   * @param identity The principal\n   * @param actions The list of desired actions\n   */\n  grant(identity: iam.IGrantable, ...actions: string[]): iam.Grant;\n}\n\n/**\n * A new or imported state machine.\n */\nabstract class StateMachineBase\n  extends AwsConstructBase\n  implements IStateMachine\n{\n  /**\n   * Import a state machine\n   */\n  public static fromStateMachineArn(\n    scope: Construct,\n    id: string,\n    stateMachineArn: string,\n  ): IStateMachine {\n    class Import extends StateMachineBase {\n      public get stateMachineOutputs(): StateMachineOutputs {\n        return {\n          arn: this.stateMachineArn,\n        };\n      }\n      public get outputs(): Record<string, any> {\n        return this.stateMachineOutputs;\n      }\n\n      public readonly stateMachineArn = stateMachineArn;\n      public readonly grantPrincipal = new iam.UnknownPrincipal({\n        resource: this,\n      });\n    }\n\n    return new Import(scope, id, {\n      environmentFromArn: stateMachineArn,\n    });\n  }\n\n  /**\n   * Import a state machine via resource name\n   */\n  public static fromStateMachineName(\n    scope: Construct,\n    id: string,\n    stateMachineName: string,\n  ): IStateMachine {\n    const stateMachineArn = AwsStack.ofAwsConstruct(scope).formatArn({\n      service: \"states\",\n      resource: \"stateMachine\",\n      arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n      resourceName: stateMachineName,\n    });\n    return this.fromStateMachineArn(scope, id, stateMachineArn);\n  }\n\n  public abstract readonly stateMachineArn: string;\n  public get stateMachineOutputs(): StateMachineOutputs {\n    return {\n      arn: this.stateMachineArn,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.stateMachineOutputs;\n  }\n\n  /**\n   * The principal this state machine is running as\n   */\n  public abstract readonly grantPrincipal: iam.IPrincipal;\n\n  /**\n   * Grant the given identity permissions to start an execution of this state\n   * machine.\n   */\n  public grantStartExecution(identity: iam.IGrantable): iam.Grant {\n    return iam.Grant.addToPrincipal({\n      grantee: identity,\n      actions: [\"states:StartExecution\"],\n      resourceArns: [this.stateMachineArn],\n    });\n  }\n\n  /**\n   * Grant the given identity permissions to start a synchronous execution of\n   * this state machine.\n   */\n  public grantStartSyncExecution(identity: iam.IGrantable): iam.Grant {\n    return iam.Grant.addToPrincipal({\n      grantee: identity,\n      actions: [\"states:StartSyncExecution\"],\n      resourceArns: [this.stateMachineArn],\n    });\n  }\n\n  /**\n   * Grant the given identity permissions to read results from state\n   * machine.\n   */\n  public grantRead(identity: iam.IGrantable): iam.Grant {\n    iam.Grant.addToPrincipal({\n      grantee: identity,\n      actions: [\"states:ListExecutions\", \"states:ListStateMachines\"],\n      resourceArns: [this.stateMachineArn],\n    });\n    iam.Grant.addToPrincipal({\n      grantee: identity,\n      actions: [\n        \"states:DescribeExecution\",\n        \"states:DescribeStateMachineForExecution\",\n        \"states:GetExecutionHistory\",\n      ],\n      resourceArns: [`${this.executionArn()}:*`],\n    });\n    return iam.Grant.addToPrincipal({\n      grantee: identity,\n      actions: [\n        \"states:ListActivities\",\n        \"states:DescribeStateMachine\",\n        \"states:DescribeActivity\",\n      ],\n      resourceArns: [\"*\"],\n    });\n  }\n\n  /**\n   * Grant the given identity task response permissions on a state machine\n   */\n  public grantTaskResponse(identity: iam.IGrantable): iam.Grant {\n    return iam.Grant.addToPrincipal({\n      grantee: identity,\n      actions: [\n        \"states:SendTaskSuccess\",\n        \"states:SendTaskFailure\",\n        \"states:SendTaskHeartbeat\",\n      ],\n      resourceArns: [this.stateMachineArn],\n    });\n  }\n\n  /**\n   * Grant the given identity permissions on all executions of the state machine\n   */\n  public grantExecution(identity: iam.IGrantable, ...actions: string[]) {\n    return iam.Grant.addToPrincipal({\n      grantee: identity,\n      actions,\n      resourceArns: [`${this.executionArn()}:*`],\n    });\n  }\n\n  /**\n   * Grant the given identity custom permissions\n   */\n  public grant(identity: iam.IGrantable, ...actions: string[]): iam.Grant {\n    return iam.Grant.addToPrincipal({\n      grantee: identity,\n      actions,\n      resourceArns: [this.stateMachineArn],\n    });\n  }\n\n  /**\n   * Returns the pattern for the execution ARN's of the state machine\n   */\n  private executionArn(): string {\n    return this.stack.formatArn({\n      resource: \"execution\",\n      service: \"states\",\n      resourceName: Arn.split(\n        this.stateMachineArn,\n        ArnFormat.COLON_RESOURCE_NAME,\n      ).resourceName,\n      arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n    });\n  }\n}\n\n/**\n * Define a StepFunctions State Machine\n */\nexport class StateMachine extends StateMachineBase {\n  /**\n   * Execution role of this state machine\n   */\n  public readonly role: iam.IRole;\n  public readonly resource: sfnStateMachine.SfnStateMachine;\n  /**\n   * The name of the state machine\n   * @attribute\n   */\n  public get stateMachineName(): string {\n    return this.resource.name;\n  }\n\n  /**\n   * The ARN of the state machine\n   */\n  public get stateMachineArn(): string {\n    return this.resource.arn;\n  }\n\n  /**\n   * Type of the state machine\n   * @attribute\n   */\n  public readonly stateMachineType: StateMachineType;\n\n  /**\n   * Identifier for the state machine revision, which is an immutable, read-only snapshot of a state machine’s definition and configuration.\n   * @attribute\n   */\n  public readonly stateMachineRevisionId: string;\n\n  constructor(scope: Construct, id: string, props: StateMachineProps) {\n    super(scope, id, props);\n\n    const { stateMachineName, namePrefix } = this.validateStateMachineName(\n      props.stateMachineName,\n      props.namePrefix,\n    );\n\n    this.role =\n      props.role ||\n      new iam.Role(this, \"Role\", {\n        assumedBy: new iam.ServicePrincipal(\"states.amazonaws.com\"),\n      });\n\n    const definitionBody = props.definitionBody;\n\n    this.stateMachineType = props.stateMachineType ?? StateMachineType.STANDARD;\n\n    let graph: StateGraph | undefined = undefined;\n    if (definitionBody instanceof ChainDefinitionBody) {\n      graph = new StateGraph(\n        definitionBody.chainable.startState,\n        \"State Machine definition\",\n      );\n      graph.timeout = props.timeout;\n      for (const statement of graph.policyStatements) {\n        this.addToRolePolicy(statement);\n      }\n    }\n\n    this.resource = new sfnStateMachine.SfnStateMachine(this, \"Resource\", {\n      name: stateMachineName,\n      namePrefix,\n      type: props.stateMachineType ?? undefined,\n      roleArn: this.role.roleArn,\n      loggingConfiguration: props.logs\n        ? this.buildLoggingConfiguration(props.logs)\n        : undefined,\n      tracingConfiguration: this.buildTracingConfiguration(\n        props.tracingEnabled,\n      ),\n      ...definitionBody.bind(this, this.role, props, graph),\n      publish: props.publish,\n      tags: props.tags,\n      // encryptionConfiguration: buildEncryptionConfiguration(props.encryptionConfiguration),\n    });\n\n    if (definitionBody instanceof ChainDefinitionBody) {\n      graph!.bind(this);\n    }\n\n    this.resource.node.addDependency(this.role);\n    this.stateMachineRevisionId = this.resource.stateMachineVersionArn;\n  }\n\n  /**\n   * The principal this state machine is running as\n   */\n  public get grantPrincipal() {\n    return this.role.grantPrincipal;\n  }\n\n  /**\n   * Add the given statement to the role's policy\n   */\n  public addToRolePolicy(statement: iam.PolicyStatement) {\n    this.role.addToPrincipalPolicy(statement);\n  }\n\n  private validateStateMachineName(\n    stateMachineName?: string,\n    prefix?: string,\n  ): { stateMachineName?: string; namePrefix?: string } {\n    if (stateMachineName && prefix) {\n      throw new Error(\n        \"Cannot specify both 'stateMachineName' and 'namePrefix'. Use only one.\",\n      );\n    } else {\n    }\n\n    if (!stateMachineName) {\n      return {\n        namePrefix: this.stack.uniqueResourceNamePrefix(this, {\n          prefix: (prefix ?? this.gridUUID) + \"-\",\n          allowedSpecialCharacters: \"-_\",\n          maxLength: 80,\n        }),\n      };\n    } else {\n      if (Token.isUnresolved(stateMachineName)) {\n        // can't really validate...\n        return {\n          stateMachineName,\n        };\n      }\n\n      if (stateMachineName.length < 1 || stateMachineName.length > 80) {\n        throw new Error(\n          `State Machine name must be between 1 and 80 characters. Received: ${stateMachineName}`,\n        );\n      }\n\n      if (!stateMachineName.match(/^[a-z0-9\\+\\!\\@\\.\\(\\)\\-\\=\\_\\']+$/i)) {\n        throw new Error(\n          `State Machine name must match \"^[a-z0-9+!@.()-=_']+$/i\". Received: ${stateMachineName}`,\n        );\n      }\n    }\n    return {\n      stateMachineName,\n    };\n  }\n\n  private buildLoggingConfiguration(\n    logOptions: LogOptions,\n  ): sfnStateMachine.SfnStateMachineLoggingConfiguration {\n    // https://docs.aws.amazon.com/step-functions/latest/dg/cw-logs.html#cloudwatch-iam-policy\n    this.addToRolePolicy(\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: [\n          \"logs:CreateLogDelivery\",\n          \"logs:GetLogDelivery\",\n          \"logs:UpdateLogDelivery\",\n          \"logs:DeleteLogDelivery\",\n          \"logs:ListLogDeliveries\",\n          \"logs:PutResourcePolicy\",\n          \"logs:DescribeResourcePolicies\",\n          \"logs:DescribeLogGroups\",\n        ],\n        resources: [\"*\"],\n      }),\n    );\n\n    return {\n      // TODO: Implement ILogGroup\n      logDestination: logOptions.logDestination,\n      includeExecutionData: logOptions.includeExecutionData,\n      level: logOptions.level || \"ERROR\",\n    };\n  }\n\n  private buildTracingConfiguration(\n    isTracing?: boolean,\n  ): sfnStateMachine.SfnStateMachineTracingConfiguration | undefined {\n    if (isTracing === undefined) {\n      return undefined;\n    }\n\n    if (isTracing) {\n      this.addToRolePolicy(\n        new iam.PolicyStatement({\n          // https://docs.aws.amazon.com/xray/latest/devguide/security_iam_id-based-policy-examples.html#xray-permissions-resources\n          // https://docs.aws.amazon.com/step-functions/latest/dg/xray-iam.html\n          actions: [\n            \"xray:PutTraceSegments\",\n            \"xray:PutTelemetryRecords\",\n            \"xray:GetSamplingRules\",\n            \"xray:GetSamplingTargets\",\n          ],\n          resources: [\"*\"],\n        }),\n      );\n    }\n\n    return {\n      enabled: isTracing,\n    };\n  }\n}\n\n/**\n * Partial object from the StateMachine L1 construct properties containing definition information\n */\nexport interface DefinitionConfig {\n  readonly definition: string;\n}\n\nexport abstract class DefinitionBody {\n  public static fromString(definition: string): DefinitionBody {\n    return new StringDefinitionBody(definition);\n  }\n\n  public static fromChainable(chainable: IChainable): DefinitionBody {\n    return new ChainDefinitionBody(chainable);\n  }\n\n  public abstract bind(\n    scope: Construct,\n    sfnPrincipal: iam.IPrincipal,\n    sfnProps: StateMachineProps,\n    graph?: StateGraph,\n  ): DefinitionConfig;\n}\n\nexport class StringDefinitionBody extends DefinitionBody {\n  constructor(public readonly body: string) {\n    super();\n  }\n\n  public bind(\n    _scope: Construct,\n    _sfnPrincipal: iam.IPrincipal,\n    _sfnProps: StateMachineProps,\n    _graph?: StateGraph,\n  ): DefinitionConfig {\n    return {\n      definition: this.body,\n    };\n  }\n}\n\nexport class ChainDefinitionBody extends DefinitionBody {\n  constructor(public readonly chainable: IChainable) {\n    super();\n  }\n\n  public bind(\n    scope: Construct,\n    _sfnPrincipal: iam.IPrincipal,\n    sfnProps: StateMachineProps,\n    graph?: StateGraph,\n  ): DefinitionConfig {\n    const graphJson = graph!.toGraphJson();\n    return {\n      definition: AwsStack.ofAwsConstruct(scope).toJsonString({\n        ...graphJson,\n        Comment: sfnProps.comment,\n      }),\n    };\n  }\n}\n\n/**\n * Two types of state machines are available in AWS Step Functions: EXPRESS AND STANDARD.\n *\n * @see https://docs.aws.amazon.com/step-functions/latest/dg/concepts-standard-vs-express.html\n *\n * @default STANDARD\n */\nexport enum StateMachineType {\n  /**\n   * Express Workflows are ideal for high-volume, event processing workloads.\n   */\n  EXPRESS = \"EXPRESS\",\n\n  /**\n   * Standard Workflows are ideal for long-running, durable, and auditable workflows.\n   */\n  STANDARD = \"STANDARD\",\n}\n\n/**\n * Defines which category of execution history events are logged.\n *\n * @see https://docs.aws.amazon.com/step-functions/latest/dg/cloudwatch-log-level.html\n *\n * @default ERROR\n */\nexport enum LogLevel {\n  /**\n   * No Logging\n   */\n  OFF = \"OFF\",\n  /**\n   * Log everything\n   */\n  ALL = \"ALL\",\n  /**\n   * Log all errors\n   */\n  ERROR = \"ERROR\",\n  /**\n   * Log fatal errors\n   */\n  FATAL = \"FATAL\",\n}\n\nexport interface LogOptions {\n  // TODO: why not just use StructBuilder for SfnStateMachineLoggingConfiguration?\n\n  /**\n   * Determines whether execution data is included in your log.\n   *\n   * When set to false, data is excluded.\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/sfn_state_machine#include_execution_data SfnStateMachine#include_execution_data}\n   * @default false\n   */\n  readonly includeExecutionData?: boolean | IResolvable;\n  /**\n   * Defines which category of execution history events are logged.\n   *\n   * @default ERROR\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/sfn_state_machine#level SfnStateMachine#level}\n   */\n  readonly level?: LogLevel;\n  /**\n   * The log group where the execution history events will be logged.\n   *\n   * Amazon Resource Name (ARN) of a CloudWatch log group.\n   * Make sure the State Machine has the correct IAM policies for logging.\n   * The ARN must end with `:*`\n   *\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/sfn_state_machine#log_destination SfnStateMachine#log_destination}\n   */\n  readonly logDestination?: string; //TODO Implement ILogGroup\n}\n"]}

package/lib/aws/compute/states/choice.d.ts

@@ -0,0 +1,94 @@
+import { Construct } from "constructs";
+import { ChoiceTransitionOptions, State } from "./state";
+import { Chain } from "../chain";
+import { Condition } from "../condition";
+import { IChainable, INextable } from "../types";
+/**
+ * Properties for defining a Choice state
+ */
+export interface ChoiceProps {
+    /**
+     * Optional name for this state
+     *
+     * @default - The construct ID will be used as state name
+     */
+    readonly stateName?: string;
+    /**
+     * An optional description for this state
+     *
+     * @default No comment
+     */
+    readonly comment?: string;
+    /**
+     * JSONPath expression to select part of the state to be the input to this state.
+     *
+     * May also be the special value JsonPath.DISCARD, which will cause the effective
+     * input to be the empty object {}.
+     *
+     * @default $
+     */
+    readonly inputPath?: string;
+    /**
+     * JSONPath expression to select part of the state to be the output to this state.
+     *
+     * May also be the special value JsonPath.DISCARD, which will cause the effective
+     * output to be the empty object {}.
+     *
+     * @default $
+     */
+    readonly outputPath?: string;
+}
+/**
+ * Define a Choice in the state machine
+ *
+ * A choice state can be used to make decisions based on the execution
+ * state.
+ */
+export declare class Choice extends State {
+    readonly endStates: INextable[];
+    constructor(scope: Construct, id: string, props?: ChoiceProps);
+    /**
+     * If the given condition matches, continue execution with the given state
+     */
+    when(condition: Condition, next: IChainable, options?: ChoiceTransitionOptions): Choice;
+    /**
+     * If none of the given conditions match, continue execution with the given state
+     *
+     * If no conditions match and no otherwise() has been given, an execution
+     * error will be raised.
+     */
+    otherwise(def: IChainable): Choice;
+    /**
+     * Return a Chain that contains all reachable end states from this Choice
+     *
+     * Use this to combine all possible choice paths back.
+     */
+    afterwards(options?: AfterwardsOptions): Chain;
+    /**
+     * Return the Amazon States Language object for this state
+     */
+    toStateJson(): object;
+}
+/**
+ * Options for selecting the choice paths
+ */
+export interface AfterwardsOptions {
+    /**
+     * Whether to include error handling states
+     *
+     * If this is true, all states which are error handlers (added through 'onError')
+     * and states reachable via error handlers will be included as well.
+     *
+     * @default false
+     */
+    readonly includeErrorHandlers?: boolean;
+    /**
+     * Whether to include the default/otherwise transition for the current Choice state
+     *
+     * If this is true and the current Choice does not have a default outgoing
+     * transition, one will be added included when .next() is called on the chain.
+     *
+     * @default false
+     */
+    readonly includeOtherwise?: boolean;
+}

package/lib/aws/compute/states/choice.js

@@ -0,0 +1,81 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Choice = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const state_type_1 = require("./private/state-type");
+const state_1 = require("./state");
+const chain_1 = require("../chain");
+/**
+ * Define a Choice in the state machine
+ *
+ * A choice state can be used to make decisions based on the execution
+ * state.
+ */
+class Choice extends state_1.State {
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        this.endStates = [];
+    }
+    /**
+     * If the given condition matches, continue execution with the given state
+     */
+    when(condition, next, options) {
+        super.addChoice(condition, next.startState, options);
+        return this;
+    }
+    /**
+     * If none of the given conditions match, continue execution with the given state
+     *
+     * If no conditions match and no otherwise() has been given, an execution
+     * error will be raised.
+     */
+    otherwise(def) {
+        super.makeDefault(def.startState);
+        return this;
+    }
+    /**
+     * Return a Chain that contains all reachable end states from this Choice
+     *
+     * Use this to combine all possible choice paths back.
+     */
+    afterwards(options = {}) {
+        const endStates = state_1.State.filterNextables(state_1.State.findReachableEndStates(this, {
+            includeErrorHandlers: options.includeErrorHandlers,
+        }));
+        if (options.includeOtherwise && this.defaultChoice) {
+            throw new Error(`'includeOtherwise' set but Choice state ${this.stateId} already has an 'otherwise' transition`);
+        }
+        if (options.includeOtherwise) {
+            endStates.push(new DefaultAsNext(this));
+        }
+        return chain_1.Chain.custom(this, endStates, this);
+    }
+    /**
+     * Return the Amazon States Language object for this state
+     */
+    toStateJson() {
+        return {
+            Type: state_type_1.StateType.CHOICE,
+            Comment: this.comment,
+            ...this.renderInputOutput(),
+            ...this.renderChoices(),
+        };
+    }
+}
+exports.Choice = Choice;
+_a = JSII_RTTI_SYMBOL_1;
+Choice[_a] = { fqn: "terraconstructs.aws.compute.Choice", version: "0.0.8" };
+/**
+ * Adapter to make the .otherwise() transition settable through .next()
+ */
+class DefaultAsNext {
+    constructor(choice) {
+        this.choice = choice;
+    }
+    next(state) {
+        this.choice.otherwise(state);
+        return chain_1.Chain.sequence(this.choice, state);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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