terraconstructs 0.0.8

package/lib/aws/compute/states/task-base.d.ts

@@ -0,0 +1,225 @@
+import { Construct } from "constructs";
+import { State } from "./state";
+import { Duration } from "../../..";
+import * as iam from "../../iam";
+import { Chain } from "../chain";
+import { StateGraph } from "../state-graph";
+import { Credentials } from "../task-credentials";
+import { CatchProps, IChainable, INextable, RetryProps } from "../types";
+/**
+ * Props that are common to all tasks
+ */
+export interface TaskStateBaseProps {
+    /**
+     * 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 - The entire task input (JSON path '$')
+     */
+    readonly inputPath?: string;
+    /**
+     * JSONPath expression to select select a portion of the state output to pass
+     * to the next state.
+     *
+     * May also be the special value JsonPath.DISCARD, which will cause the effective
+     * output to be the empty object {}.
+     *
+     * @default - The entire JSON node determined by the state input, the task result,
+     *   and resultPath is passed to the next state (JSON path '$')
+     */
+    readonly outputPath?: string;
+    /**
+     * JSONPath expression to indicate where to inject the state's output
+     *
+     * May also be the special value JsonPath.DISCARD, which will cause the state's
+     * input to become its output.
+     *
+     * @default - Replaces the entire input with the result (JSON path '$')
+     */
+    readonly resultPath?: string;
+    /**
+     * The JSON that will replace the state's raw result and become the effective
+     * result before ResultPath is applied.
+     *
+     * You can use ResultSelector to create a payload with values that are static
+     * or selected from the state's raw result.
+     *
+     * @see
+     * https://docs.aws.amazon.com/step-functions/latest/dg/input-output-inputpath-params.html#input-output-resultselector
+     *
+     * @default - None
+     */
+    readonly resultSelector?: {
+        [key: string]: any;
+    };
+    /**
+     * Timeout for the task
+     *
+     * @default - None
+     * @deprecated use `taskTimeout`
+     */
+    readonly timeout?: Duration;
+    /**
+     * Timeout for the task
+     *
+     * [disable-awslint:duration-prop-type] is needed because all props interface in
+     * aws-stepfunctions-tasks extend this interface
+     *
+     * @default - None
+     */
+    readonly taskTimeout?: Timeout;
+    /**
+     * Timeout for the heartbeat
+     *
+     * @default - None
+     * @deprecated use `heartbeatTimeout`
+     */
+    readonly heartbeat?: Duration;
+    /**
+     * Timeout for the heartbeat
+     *
+     * [disable-awslint:duration-prop-type] is needed because all props interface in
+     * aws-stepfunctions-tasks extend this interface
+     *
+     * @default - None
+     */
+    readonly heartbeatTimeout?: Timeout;
+    /**
+     * AWS Step Functions integrates with services directly in the Amazon States Language.
+     * You can control these AWS services using service integration patterns.
+     *
+     * Depending on the AWS Service, the Service Integration Pattern availability will vary.
+     *
+     * @see https://docs.aws.amazon.com/step-functions/latest/dg/connect-supported-services.html
+     *
+     * @default - `IntegrationPattern.REQUEST_RESPONSE` for most tasks.
+     * `IntegrationPattern.RUN_JOB` for the following exceptions:
+     *  `BatchSubmitJob`, `EmrAddStep`, `EmrCreateCluster`, `EmrTerminationCluster`, and `EmrContainersStartJobRun`.
+     *
+     */
+    readonly integrationPattern?: IntegrationPattern;
+    /**
+     * Credentials for an IAM Role that the State Machine assumes for executing the task.
+     * This enables cross-account resource invocations.
+     *
+     * @see https://docs.aws.amazon.com/step-functions/latest/dg/concepts-access-cross-acct-resources.html
+     *
+     * @default - None (Task is executed using the State Machine's execution role)
+     */
+    readonly credentials?: Credentials;
+}
+/**
+ * Define a Task state in the state machine
+ *
+ * Reaching a Task state causes some work to be executed, represented by the
+ * Task's resource property. Task constructs represent a generic Amazon
+ * States Language Task.
+ *
+ * For some resource types, more specific subclasses of Task may be available
+ * which are more convenient to use.
+ */
+export declare abstract class TaskStateBase extends State implements INextable {
+    readonly endStates: INextable[];
+    protected abstract readonly taskPolicies?: iam.PolicyStatement[];
+    private readonly timeout?;
+    private readonly taskTimeout?;
+    private readonly heartbeat?;
+    private readonly heartbeatTimeout?;
+    private readonly credentials?;
+    constructor(scope: Construct, id: string, props: TaskStateBaseProps);
+    /**
+     * Add retry configuration for this state
+     *
+     * This controls if and how the execution will be retried if a particular
+     * error occurs.
+     */
+    addRetry(props?: RetryProps): TaskStateBase;
+    /**
+     * Add a recovery handler for this state
+     *
+     * When a particular error occurs, execution will continue at the error
+     * handler instead of failing the state machine execution.
+     */
+    addCatch(handler: IChainable, props?: CatchProps): TaskStateBase;
+    /**
+     * Continue normal execution with the given state
+     */
+    next(next: IChainable): Chain;
+    /**
+     * Return the Amazon States Language object for this state
+     */
+    toStateJson(): object;
+    protected whenBoundToGraph(graph: StateGraph): void;
+    /**
+     * @internal
+     */
+    protected abstract _renderTask(): any;
+    private renderCredentials;
+    private renderTaskBase;
+}
+/**
+ *
+ * AWS Step Functions integrates with services directly in the Amazon States Language.
+ * You can control these AWS services using service integration patterns:
+ *
+ * @see https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html
+ *
+ */
+export declare enum IntegrationPattern {
+    /**
+     * Step Functions will wait for an HTTP response and then progress to the next state.
+     *
+     * @see https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-default
+     */
+    REQUEST_RESPONSE = "REQUEST_RESPONSE",
+    /**
+     * Step Functions can wait for a request to complete before progressing to the next state.
+     *
+     * @see https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-sync
+     */
+    RUN_JOB = "RUN_JOB",
+    /**
+     * Callback tasks provide a way to pause a workflow until a task token is returned.
+     * You must set a task token when using the callback pattern
+     *
+     * @see https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-wait-token
+     */
+    WAIT_FOR_TASK_TOKEN = "WAIT_FOR_TASK_TOKEN"
+}
+/**
+ * Timeout for a task or heartbeat
+ */
+export declare abstract class Timeout {
+    /**
+     * Use a duration as timeout
+     */
+    static duration(duration: Duration): Timeout;
+    /**
+     * Use a dynamic timeout specified by a path in the state input.
+     *
+     * The path must select a field whose value is a positive integer.
+     */
+    static at(path: string): Timeout;
+    /**
+     * Seconds for this timeout
+     */
+    abstract readonly seconds?: number;
+    /**
+     * Path for this timeout
+     */
+    abstract readonly path?: string;
+}

package/lib/aws/compute/states/task-base.js

@@ -0,0 +1,160 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Timeout = exports.IntegrationPattern = exports.TaskStateBase = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const state_1 = require("./state");
+const iam = require("../../iam");
+const chain_1 = require("../chain");
+const fields_1 = require("../fields");
+/**
+ * Define a Task state in the state machine
+ *
+ * Reaching a Task state causes some work to be executed, represented by the
+ * Task's resource property. Task constructs represent a generic Amazon
+ * States Language Task.
+ *
+ * For some resource types, more specific subclasses of Task may be available
+ * which are more convenient to use.
+ */
+class TaskStateBase extends state_1.State {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.endStates = [this];
+        this.timeout = props.timeout;
+        this.taskTimeout = props.taskTimeout;
+        this.heartbeat = props.heartbeat;
+        this.heartbeatTimeout = props.heartbeatTimeout;
+        this.credentials = props.credentials;
+    }
+    /**
+     * Add retry configuration for this state
+     *
+     * This controls if and how the execution will be retried if a particular
+     * error occurs.
+     */
+    addRetry(props = {}) {
+        super._addRetry(props);
+        return this;
+    }
+    /**
+     * Add a recovery handler for this state
+     *
+     * When a particular error occurs, execution will continue at the error
+     * handler instead of failing the state machine execution.
+     */
+    addCatch(handler, props = {}) {
+        super._addCatch(handler.startState, props);
+        return this;
+    }
+    /**
+     * Continue normal execution with the given state
+     */
+    next(next) {
+        super.makeNext(next.startState);
+        return chain_1.Chain.sequence(this, next);
+    }
+    /**
+     * Return the Amazon States Language object for this state
+     */
+    toStateJson() {
+        return {
+            ...this.renderNextEnd(),
+            ...this.renderRetryCatch(),
+            ...this.renderTaskBase(),
+            ...this._renderTask(),
+        };
+    }
+    // TODO: Re-add CloudWatch metrics
+    whenBoundToGraph(graph) {
+        super.whenBoundToGraph(graph);
+        for (const policyStatement of this.taskPolicies || []) {
+            graph.registerPolicyStatement(policyStatement);
+        }
+        if (this.credentials) {
+            graph.registerPolicyStatement(new iam.PolicyStatement({
+                effect: iam.Effect.ALLOW,
+                actions: ["sts:AssumeRole"],
+                resources: [this.credentials.role.resource],
+            }));
+        }
+    }
+    renderCredentials() {
+        return this.credentials
+            ? fields_1.FieldUtils.renderObject({
+                Credentials: { RoleArn: this.credentials.role.roleArn },
+            })
+            : undefined;
+    }
+    renderTaskBase() {
+        return {
+            Type: "Task",
+            Comment: this.comment,
+            TimeoutSeconds: this.timeout?.toSeconds() ?? this.taskTimeout?.seconds,
+            TimeoutSecondsPath: this.taskTimeout?.path,
+            HeartbeatSeconds: this.heartbeat?.toSeconds() ?? this.heartbeatTimeout?.seconds,
+            HeartbeatSecondsPath: this.heartbeatTimeout?.path,
+            InputPath: (0, state_1.renderJsonPath)(this.inputPath),
+            OutputPath: (0, state_1.renderJsonPath)(this.outputPath),
+            ResultPath: (0, state_1.renderJsonPath)(this.resultPath),
+            ...this.renderResultSelector(),
+            ...this.renderCredentials(),
+        };
+    }
+}
+exports.TaskStateBase = TaskStateBase;
+_a = JSII_RTTI_SYMBOL_1;
+TaskStateBase[_a] = { fqn: "terraconstructs.aws.compute.TaskStateBase", version: "0.0.8" };
+/**
+ *
+ * AWS Step Functions integrates with services directly in the Amazon States Language.
+ * You can control these AWS services using service integration patterns:
+ *
+ * @see https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html
+ *
+ */
+var IntegrationPattern;
+(function (IntegrationPattern) {
+    /**
+     * Step Functions will wait for an HTTP response and then progress to the next state.
+     *
+     * @see https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-default
+     */
+    IntegrationPattern["REQUEST_RESPONSE"] = "REQUEST_RESPONSE";
+    /**
+     * Step Functions can wait for a request to complete before progressing to the next state.
+     *
+     * @see https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-sync
+     */
+    IntegrationPattern["RUN_JOB"] = "RUN_JOB";
+    /**
+     * Callback tasks provide a way to pause a workflow until a task token is returned.
+     * You must set a task token when using the callback pattern
+     *
+     * @see https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-wait-token
+     */
+    IntegrationPattern["WAIT_FOR_TASK_TOKEN"] = "WAIT_FOR_TASK_TOKEN";
+})(IntegrationPattern || (exports.IntegrationPattern = IntegrationPattern = {}));
+/**
+ * Timeout for a task or heartbeat
+ */
+class Timeout {
+    /**
+     * Use a duration as timeout
+     */
+    static duration(duration) {
+        return { seconds: duration.toSeconds() };
+    }
+    /**
+     * Use a dynamic timeout specified by a path in the state input.
+     *
+     * The path must select a field whose value is a positive integer.
+     */
+    static at(path) {
+        return { path };
+    }
+}
+exports.Timeout = Timeout;
+_b = JSII_RTTI_SYMBOL_1;
+Timeout[_b] = { fqn: "terraconstructs.aws.compute.Timeout", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task-base.js","sourceRoot":"","sources":["../../../../src/aws/compute/states/task-base.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from \"constructs\";\nimport { renderJsonPath, State } from \"./state\";\nimport { Duration } from \"../../..\";\nimport * as iam from \"../../iam\";\nimport { Chain } from \"../chain\";\nimport { FieldUtils } from \"../fields\";\nimport { StateGraph } from \"../state-graph\";\nimport { Credentials } from \"../task-credentials\";\nimport { CatchProps, IChainable, INextable, RetryProps } from \"../types\";\n\n/**\n * Props that are common to all tasks\n */\nexport interface TaskStateBaseProps {\n  /**\n   * Optional name for this state\n   *\n   * @default - The construct ID will be used as state name\n   */\n  readonly stateName?: string;\n\n  /**\n   * An optional description for this state\n   *\n   * @default - No comment\n   */\n  readonly comment?: string;\n\n  /**\n   * JSONPath expression to select part of the state to be the input to this state.\n   *\n   * May also be the special value JsonPath.DISCARD, which will cause the effective\n   * input to be the empty object {}.\n   *\n   * @default - The entire task input (JSON path '$')\n   */\n  readonly inputPath?: string;\n\n  /**\n   * JSONPath expression to select select a portion of the state output to pass\n   * to the next state.\n   *\n   * May also be the special value JsonPath.DISCARD, which will cause the effective\n   * output to be the empty object {}.\n   *\n   * @default - The entire JSON node determined by the state input, the task result,\n   *   and resultPath is passed to the next state (JSON path '$')\n   */\n  readonly outputPath?: string;\n\n  /**\n   * JSONPath expression to indicate where to inject the state's output\n   *\n   * May also be the special value JsonPath.DISCARD, which will cause the state's\n   * input to become its output.\n   *\n   * @default - Replaces the entire input with the result (JSON path '$')\n   */\n  readonly resultPath?: string;\n\n  /**\n   * The JSON that will replace the state's raw result and become the effective\n   * result before ResultPath is applied.\n   *\n   * You can use ResultSelector to create a payload with values that are static\n   * or selected from the state's raw result.\n   *\n   * @see\n   * https://docs.aws.amazon.com/step-functions/latest/dg/input-output-inputpath-params.html#input-output-resultselector\n   *\n   * @default - None\n   */\n  readonly resultSelector?: { [key: string]: any };\n\n  /**\n   * Timeout for the task\n   *\n   * @default - None\n   * @deprecated use `taskTimeout`\n   */\n  readonly timeout?: Duration;\n\n  /**\n   * Timeout for the task\n   *\n   * [disable-awslint:duration-prop-type] is needed because all props interface in\n   * aws-stepfunctions-tasks extend this interface\n   *\n   * @default - None\n   */\n  readonly taskTimeout?: Timeout;\n\n  /**\n   * Timeout for the heartbeat\n   *\n   * @default - None\n   * @deprecated use `heartbeatTimeout`\n   */\n  readonly heartbeat?: Duration;\n\n  /**\n   * Timeout for the heartbeat\n   *\n   * [disable-awslint:duration-prop-type] is needed because all props interface in\n   * aws-stepfunctions-tasks extend this interface\n   *\n   * @default - None\n   */\n  readonly heartbeatTimeout?: Timeout;\n\n  /**\n   * AWS Step Functions integrates with services directly in the Amazon States Language.\n   * You can control these AWS services using service integration patterns.\n   *\n   * Depending on the AWS Service, the Service Integration Pattern availability will vary.\n   *\n   * @see https://docs.aws.amazon.com/step-functions/latest/dg/connect-supported-services.html\n   *\n   * @default - `IntegrationPattern.REQUEST_RESPONSE` for most tasks.\n   * `IntegrationPattern.RUN_JOB` for the following exceptions:\n   *  `BatchSubmitJob`, `EmrAddStep`, `EmrCreateCluster`, `EmrTerminationCluster`, and `EmrContainersStartJobRun`.\n   *\n   */\n  readonly integrationPattern?: IntegrationPattern;\n\n  /**\n   * Credentials for an IAM Role that the State Machine assumes for executing the task.\n   * This enables cross-account resource invocations.\n   *\n   * @see https://docs.aws.amazon.com/step-functions/latest/dg/concepts-access-cross-acct-resources.html\n   *\n   * @default - None (Task is executed using the State Machine's execution role)\n   */\n  readonly credentials?: Credentials;\n}\n\n/**\n * Define a Task state in the state machine\n *\n * Reaching a Task state causes some work to be executed, represented by the\n * Task's resource property. Task constructs represent a generic Amazon\n * States Language Task.\n *\n * For some resource types, more specific subclasses of Task may be available\n * which are more convenient to use.\n */\nexport abstract class TaskStateBase extends State implements INextable {\n  public readonly endStates: INextable[];\n\n  // protected abstract readonly taskMetrics?: TaskMetricsConfig;\n  protected abstract readonly taskPolicies?: iam.PolicyStatement[];\n\n  private readonly timeout?: Duration;\n  private readonly taskTimeout?: Timeout;\n  private readonly heartbeat?: Duration;\n  private readonly heartbeatTimeout?: Timeout;\n  private readonly credentials?: Credentials;\n\n  constructor(scope: Construct, id: string, props: TaskStateBaseProps) {\n    super(scope, id, props);\n\n    this.endStates = [this];\n    this.timeout = props.timeout;\n    this.taskTimeout = props.taskTimeout;\n    this.heartbeat = props.heartbeat;\n    this.heartbeatTimeout = props.heartbeatTimeout;\n    this.credentials = props.credentials;\n  }\n\n  /**\n   * Add retry configuration for this state\n   *\n   * This controls if and how the execution will be retried if a particular\n   * error occurs.\n   */\n  public addRetry(props: RetryProps = {}): TaskStateBase {\n    super._addRetry(props);\n    return this;\n  }\n\n  /**\n   * Add a recovery handler for this state\n   *\n   * When a particular error occurs, execution will continue at the error\n   * handler instead of failing the state machine execution.\n   */\n  public addCatch(handler: IChainable, props: CatchProps = {}): TaskStateBase {\n    super._addCatch(handler.startState, props);\n    return this;\n  }\n\n  /**\n   * Continue normal execution with the given state\n   */\n  public next(next: IChainable): Chain {\n    super.makeNext(next.startState);\n    return Chain.sequence(this, next);\n  }\n\n  /**\n   * Return the Amazon States Language object for this state\n   */\n  public toStateJson(): object {\n    return {\n      ...this.renderNextEnd(),\n      ...this.renderRetryCatch(),\n      ...this.renderTaskBase(),\n      ...this._renderTask(),\n    };\n  }\n\n  // TODO: Re-add CloudWatch metrics\n\n  protected whenBoundToGraph(graph: StateGraph) {\n    super.whenBoundToGraph(graph);\n    for (const policyStatement of this.taskPolicies || []) {\n      graph.registerPolicyStatement(policyStatement);\n    }\n    if (this.credentials) {\n      graph.registerPolicyStatement(\n        new iam.PolicyStatement({\n          effect: iam.Effect.ALLOW,\n          actions: [\"sts:AssumeRole\"],\n          resources: [this.credentials.role.resource],\n        }),\n      );\n    }\n  }\n\n  /**\n   * @internal\n   */\n  protected abstract _renderTask(): any;\n\n  private renderCredentials() {\n    return this.credentials\n      ? FieldUtils.renderObject({\n          Credentials: { RoleArn: this.credentials.role.roleArn },\n        })\n      : undefined;\n  }\n\n  private renderTaskBase() {\n    return {\n      Type: \"Task\",\n      Comment: this.comment,\n      TimeoutSeconds: this.timeout?.toSeconds() ?? this.taskTimeout?.seconds,\n      TimeoutSecondsPath: this.taskTimeout?.path,\n      HeartbeatSeconds:\n        this.heartbeat?.toSeconds() ?? this.heartbeatTimeout?.seconds,\n      HeartbeatSecondsPath: this.heartbeatTimeout?.path,\n      InputPath: renderJsonPath(this.inputPath),\n      OutputPath: renderJsonPath(this.outputPath),\n      ResultPath: renderJsonPath(this.resultPath),\n      ...this.renderResultSelector(),\n      ...this.renderCredentials(),\n    };\n  }\n}\n\n/**\n *\n * AWS Step Functions integrates with services directly in the Amazon States Language.\n * You can control these AWS services using service integration patterns:\n *\n * @see https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html\n *\n */\nexport enum IntegrationPattern {\n  /**\n   * Step Functions will wait for an HTTP response and then progress to the next state.\n   *\n   * @see https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-default\n   */\n  REQUEST_RESPONSE = \"REQUEST_RESPONSE\",\n\n  /**\n   * Step Functions can wait for a request to complete before progressing to the next state.\n   *\n   * @see https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-sync\n   */\n  RUN_JOB = \"RUN_JOB\",\n\n  /**\n   * Callback tasks provide a way to pause a workflow until a task token is returned.\n   * You must set a task token when using the callback pattern\n   *\n   * @see https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-wait-token\n   */\n  WAIT_FOR_TASK_TOKEN = \"WAIT_FOR_TASK_TOKEN\",\n}\n\n/**\n * Timeout for a task or heartbeat\n */\nexport abstract class Timeout {\n  /**\n   * Use a duration as timeout\n   */\n  public static duration(duration: Duration): Timeout {\n    return { seconds: duration.toSeconds() };\n  }\n\n  /**\n   * Use a dynamic timeout specified by a path in the state input.\n   *\n   * The path must select a field whose value is a positive integer.\n   */\n  public static at(path: string): Timeout {\n    return { path };\n  }\n\n  /**\n   * Seconds for this timeout\n   */\n  public abstract readonly seconds?: number;\n\n  /**\n   * Path for this timeout\n   */\n  public abstract readonly path?: string;\n}\n"]}

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

@@ -0,0 +1,127 @@
+import { Construct } from "constructs";
+import { State } from "./state";
+import { Duration } from "../../..";
+import { Chain } from "../chain";
+import { StateGraph } from "../state-graph";
+import { IStepFunctionsTask } from "../step-functions-task";
+import { CatchProps, IChainable, INextable, RetryProps } from "../types";
+/**
+ * Props that are common to all tasks
+ */
+export interface TaskProps {
+    /**
+     * Actual task to be invoked in this workflow
+     */
+    readonly task: IStepFunctionsTask;
+    /**
+     * 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;
+    /**
+     * JSONPath expression to indicate where to inject the state's output
+     *
+     * May also be the special value JsonPath.DISCARD, which will cause the state's
+     * input to become its output.
+     *
+     * @default $
+     */
+    readonly resultPath?: string;
+    /**
+     * Parameters to invoke the task with
+     *
+     * It is not recommended to use this field. The object that is passed in
+     * the `task` property will take care of returning the right values for the
+     * `Parameters` field in the Step Functions definition.
+     *
+     * The various classes that implement `IStepFunctionsTask` will take a
+     * properties which make sense for the task type. For example, for
+     * `InvokeFunction` the field that populates the `parameters` field will be
+     * called `payload`, and for the `PublishToTopic` the `parameters` field
+     * will be populated via a combination of the referenced topic, subject and
+     * message.
+     *
+     * If passed anyway, the keys in this map will override the parameters
+     * returned by the task object.
+     *
+     * @see
+     * https://docs.aws.amazon.com/step-functions/latest/dg/input-output-inputpath-params.html#input-output-parameters
+     *
+     * @default - Use the parameters implied by the `task` property
+     */
+    readonly parameters?: {
+        [name: string]: any;
+    };
+    /**
+     * Maximum run time of this state
+     *
+     * If the state takes longer than this amount of time to complete, a 'Timeout' error is raised.
+     *
+     * @default 60
+     */
+    readonly timeout?: Duration;
+}
+/**
+ * Define a Task state in the state machine
+ *
+ * Reaching a Task state causes some work to be executed, represented by the
+ * Task's resource property. Task constructs represent a generic Amazon
+ * States Language Task.
+ *
+ * For some resource types, more specific subclasses of Task may be available
+ * which are more convenient to use.
+ */
+export declare class Task extends State implements INextable {
+    readonly endStates: INextable[];
+    private readonly timeout?;
+    private readonly taskProps;
+    constructor(scope: Construct, id: string, props: TaskProps);
+    /**
+     * Add retry configuration for this state
+     *
+     * This controls if and how the execution will be retried if a particular
+     * error occurs.
+     */
+    addRetry(props?: RetryProps): Task;
+    /**
+     * Add a recovery handler for this state
+     *
+     * When a particular error occurs, execution will continue at the error
+     * handler instead of failing the state machine execution.
+     */
+    addCatch(handler: IChainable, props?: CatchProps): Task;
+    /**
+     * Continue normal execution with the given state
+     */
+    next(next: IChainable): Chain;
+    /**
+     * Return the Amazon States Language object for this state
+     */
+    toStateJson(): object;
+    protected whenBoundToGraph(graph: StateGraph): void;
+}

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

@@ -0,0 +1,92 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Task = 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");
+// import { TaskStateBase, TaskStateBaseProps } from "./task-base";
+const fields_1 = require("../fields");
+const util_1 = require("../private/util");
+/**
+ * Define a Task state in the state machine
+ *
+ * Reaching a Task state causes some work to be executed, represented by the
+ * Task's resource property. Task constructs represent a generic Amazon
+ * States Language Task.
+ *
+ * For some resource types, more specific subclasses of Task may be available
+ * which are more convenient to use.
+ */
+class Task extends state_1.State {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.timeout = props.timeout;
+        const taskProps = props.task.bind(this);
+        this.taskProps = {
+            ...taskProps,
+            parameters: (0, util_1.noEmptyObject)({
+                ...(taskProps.parameters || {}),
+                ...(props.parameters || {}),
+            }),
+        };
+        this.endStates = [this];
+    }
+    /**
+     * Add retry configuration for this state
+     *
+     * This controls if and how the execution will be retried if a particular
+     * error occurs.
+     */
+    addRetry(props = {}) {
+        super._addRetry(props);
+        return this;
+    }
+    /**
+     * Add a recovery handler for this state
+     *
+     * When a particular error occurs, execution will continue at the error
+     * handler instead of failing the state machine execution.
+     */
+    addCatch(handler, props = {}) {
+        super._addCatch(handler.startState, props);
+        return this;
+    }
+    /**
+     * Continue normal execution with the given state
+     */
+    next(next) {
+        super.makeNext(next.startState);
+        return chain_1.Chain.sequence(this, next);
+    }
+    /**
+     * Return the Amazon States Language object for this state
+     */
+    toStateJson() {
+        return {
+            ...this.renderNextEnd(),
+            ...this.renderRetryCatch(),
+            ...this.renderInputOutput(),
+            Type: state_type_1.StateType.TASK,
+            Comment: this.comment,
+            Resource: this.taskProps.resourceArn,
+            Parameters: this.taskProps.parameters &&
+                fields_1.FieldUtils.renderObject(this.taskProps.parameters),
+            ResultPath: (0, state_1.renderJsonPath)(this.resultPath),
+            TimeoutSeconds: this.timeout && this.timeout.toSeconds(),
+            HeartbeatSeconds: this.taskProps.heartbeat && this.taskProps.heartbeat.toSeconds(),
+        };
+    }
+    // TODO: Re-add CloudWatch metrics
+    whenBoundToGraph(graph) {
+        super.whenBoundToGraph(graph);
+        for (const policyStatement of this.taskProps.policyStatements || []) {
+            graph.registerPolicyStatement(policyStatement);
+        }
+    }
+}
+exports.Task = Task;
+_a = JSII_RTTI_SYMBOL_1;
+Task[_a] = { fqn: "terraconstructs.aws.compute.Task", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task.js","sourceRoot":"","sources":["../../../../src/aws/compute/states/task.ts"],"names":[],"mappings":";;;;;AACA,qDAAiD;AACjD,mCAAgD;AAEhD,oCAAiC;AACjC,mEAAmE;AACnE,sCAAuC;AACvC,0CAAgD;AAkGhD;;;;;;;;;GASG;AACH,MAAa,IAAK,SAAQ,aAAK;IAO7B,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAgB;QACxD,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;QAExB,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;QAC7B,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAExC,IAAI,CAAC,SAAS,GAAG;YACf,GAAG,SAAS;YACZ,UAAU,EAAE,IAAA,oBAAa,EAAC;gBACxB,GAAG,CAAC,SAAS,CAAC,UAAU,IAAI,EAAE,CAAC;gBAC/B,GAAG,CAAC,KAAK,CAAC,UAAU,IAAI,EAAE,CAAC;aAC5B,CAAC;SACH,CAAC;QACF,IAAI,CAAC,SAAS,GAAG,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;IAED;;;;;OAKG;IACI,QAAQ,CAAC,QAAoB,EAAE;QACpC,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACvB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACI,QAAQ,CAAC,OAAmB,EAAE,QAAoB,EAAE;QACzD,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;QAC3C,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACI,IAAI,CAAC,IAAgB;QAC1B,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAChC,OAAO,aAAK,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACpC,CAAC;IAED;;OAEG;IACI,WAAW;QAChB,OAAO;YACL,GAAG,IAAI,CAAC,aAAa,EAAE;YACvB,GAAG,IAAI,CAAC,gBAAgB,EAAE;YAC1B,GAAG,IAAI,CAAC,iBAAiB,EAAE;YAC3B,IAAI,EAAE,sBAAS,CAAC,IAAI;YACpB,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,QAAQ,EAAE,IAAI,CAAC,SAAS,CAAC,WAAW;YACpC,UAAU,EACR,IAAI,CAAC,SAAS,CAAC,UAAU;gBACzB,mBAAU,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC;YACpD,UAAU,EAAE,IAAA,sBAAc,EAAC,IAAI,CAAC,UAAU,CAAC;YAC3C,cAAc,EAAE,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE;YACxD,gBAAgB,EACd,IAAI,CAAC,SAAS,CAAC,SAAS,IAAI,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,SAAS,EAAE;SACnE,CAAC;IACJ,CAAC;IAED,kCAAkC;IAExB,gBAAgB,CAAC,KAAiB;QAC1C,KAAK,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;QAC9B,KAAK,MAAM,eAAe,IAAI,IAAI,CAAC,SAAS,CAAC,gBAAgB,IAAI,EAAE,EAAE,CAAC;YACpE,KAAK,CAAC,uBAAuB,CAAC,eAAe,CAAC,CAAC;QACjD,CAAC;IACH,CAAC;;AAjFH,oBAkFC","sourcesContent":["import { Construct } from \"constructs\";\nimport { StateType } from \"./private/state-type\";\nimport { renderJsonPath, State } from \"./state\";\nimport { Duration } from \"../../..\";\nimport { Chain } from \"../chain\";\n// import { TaskStateBase, TaskStateBaseProps } from \"./task-base\";\nimport { FieldUtils } from \"../fields\";\nimport { noEmptyObject } from \"../private/util\";\nimport { StateGraph } from \"../state-graph\";\nimport {\n  IStepFunctionsTask,\n  StepFunctionsTaskConfig,\n} from \"../step-functions-task\";\nimport { CatchProps, IChainable, INextable, RetryProps } from \"../types\";\n\n// TODO: replace by service integration specific classes (i.e. LambdaInvoke, SnsPublish)\n// https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/aws-stepfunctions-tasks/README.md\n\n/**\n * Props that are common to all tasks\n */\nexport interface TaskProps {\n  /**\n   * Actual task to be invoked in this workflow\n   */\n  readonly task: IStepFunctionsTask;\n\n  /**\n   * Optional name for this state\n   *\n   * @default - The construct ID will be used as state name\n   */\n  readonly stateName?: string;\n\n  /**\n   * An optional description for this state\n   *\n   * @default No comment\n   */\n  readonly comment?: string;\n\n  /**\n   * JSONPath expression to select part of the state to be the input to this state.\n   *\n   * May also be the special value JsonPath.DISCARD, which will cause the effective\n   * input to be the empty object {}.\n   *\n   * @default $\n   */\n  readonly inputPath?: string;\n\n  /**\n   * JSONPath expression to select part of the state to be the output to this state.\n   *\n   * May also be the special value JsonPath.DISCARD, which will cause the effective\n   * output to be the empty object {}.\n   *\n   * @default $\n   */\n  readonly outputPath?: string;\n\n  /**\n   * JSONPath expression to indicate where to inject the state's output\n   *\n   * May also be the special value JsonPath.DISCARD, which will cause the state's\n   * input to become its output.\n   *\n   * @default $\n   */\n  readonly resultPath?: string;\n\n  /**\n   * Parameters to invoke the task with\n   *\n   * It is not recommended to use this field. The object that is passed in\n   * the `task` property will take care of returning the right values for the\n   * `Parameters` field in the Step Functions definition.\n   *\n   * The various classes that implement `IStepFunctionsTask` will take a\n   * properties which make sense for the task type. For example, for\n   * `InvokeFunction` the field that populates the `parameters` field will be\n   * called `payload`, and for the `PublishToTopic` the `parameters` field\n   * will be populated via a combination of the referenced topic, subject and\n   * message.\n   *\n   * If passed anyway, the keys in this map will override the parameters\n   * returned by the task object.\n   *\n   * @see\n   * https://docs.aws.amazon.com/step-functions/latest/dg/input-output-inputpath-params.html#input-output-parameters\n   *\n   * @default - Use the parameters implied by the `task` property\n   */\n  readonly parameters?: { [name: string]: any };\n\n  /**\n   * Maximum run time of this state\n   *\n   * If the state takes longer than this amount of time to complete, a 'Timeout' error is raised.\n   *\n   * @default 60\n   */\n  readonly timeout?: Duration;\n}\n\n/**\n * Define a Task state in the state machine\n *\n * Reaching a Task state causes some work to be executed, represented by the\n * Task's resource property. Task constructs represent a generic Amazon\n * States Language Task.\n *\n * For some resource types, more specific subclasses of Task may be available\n * which are more convenient to use.\n */\nexport class Task extends State implements INextable {\n  // TODO: replace by service integration specific classes (i.e. LambdaInvoke, SnsPublish)\n  // ref: aws-stepfunctions-tasks/README.md\n  public readonly endStates: INextable[];\n  private readonly timeout?: Duration;\n  private readonly taskProps: StepFunctionsTaskConfig;\n\n  constructor(scope: Construct, id: string, props: TaskProps) {\n    super(scope, id, props);\n\n    this.timeout = props.timeout;\n    const taskProps = props.task.bind(this);\n\n    this.taskProps = {\n      ...taskProps,\n      parameters: noEmptyObject({\n        ...(taskProps.parameters || {}),\n        ...(props.parameters || {}),\n      }),\n    };\n    this.endStates = [this];\n  }\n\n  /**\n   * Add retry configuration for this state\n   *\n   * This controls if and how the execution will be retried if a particular\n   * error occurs.\n   */\n  public addRetry(props: RetryProps = {}): Task {\n    super._addRetry(props);\n    return this;\n  }\n\n  /**\n   * Add a recovery handler for this state\n   *\n   * When a particular error occurs, execution will continue at the error\n   * handler instead of failing the state machine execution.\n   */\n  public addCatch(handler: IChainable, props: CatchProps = {}): Task {\n    super._addCatch(handler.startState, props);\n    return this;\n  }\n\n  /**\n   * Continue normal execution with the given state\n   */\n  public next(next: IChainable): Chain {\n    super.makeNext(next.startState);\n    return Chain.sequence(this, next);\n  }\n\n  /**\n   * Return the Amazon States Language object for this state\n   */\n  public toStateJson(): object {\n    return {\n      ...this.renderNextEnd(),\n      ...this.renderRetryCatch(),\n      ...this.renderInputOutput(),\n      Type: StateType.TASK,\n      Comment: this.comment,\n      Resource: this.taskProps.resourceArn,\n      Parameters:\n        this.taskProps.parameters &&\n        FieldUtils.renderObject(this.taskProps.parameters),\n      ResultPath: renderJsonPath(this.resultPath),\n      TimeoutSeconds: this.timeout && this.timeout.toSeconds(),\n      HeartbeatSeconds:\n        this.taskProps.heartbeat && this.taskProps.heartbeat.toSeconds(),\n    };\n  }\n\n  // TODO: Re-add CloudWatch metrics\n\n  protected whenBoundToGraph(graph: StateGraph) {\n    super.whenBoundToGraph(graph);\n    for (const policyStatement of this.taskProps.policyStatements || []) {\n      graph.registerPolicyStatement(policyStatement);\n    }\n  }\n}\n"]}