terraconstructs 0.0.8

package/lib/aws/compute/tasks/lambda/invoke.d.ts

@@ -0,0 +1,106 @@
+import { Construct } from "constructs";
+import * as compute from "../../";
+import * as iam from "../../../iam";
+/**
+ * Properties for invoking a Lambda function with LambdaInvoke
+ */
+export interface LambdaInvokeProps extends compute.TaskStateBaseProps {
+    /**
+     * Lambda function to invoke
+     */
+    readonly lambdaFunction: compute.IFunction;
+    /**
+     * The JSON that will be supplied as input to the Lambda function
+     *
+     * @default - The state input (JSON path '$')
+     */
+    readonly payload?: compute.TaskInput;
+    /**
+     * Invocation type of the Lambda function
+     *
+     * @default InvocationType.REQUEST_RESPONSE
+     */
+    readonly invocationType?: LambdaInvocationType;
+    /**
+     * Up to 3583 bytes of base64-encoded data about the invoking client
+     * to pass to the function.
+     *
+     * @default - No context
+     */
+    readonly clientContext?: string;
+    /**
+     * Version or alias to invoke a published version of the function
+     *
+     * You only need to supply this if you want the version of the Lambda Function to depend
+     * on data in the state machine state. If not, you can pass the appropriate Alias or Version object
+     * directly as the `lambdaFunction` argument.
+     *
+     * @default - Version or alias inherent to the `lambdaFunction` object.
+     */
+    readonly qualifier?: string;
+    /**
+     * Invoke the Lambda in a way that only returns the payload response without additional metadata.
+     *
+     * The `payloadResponseOnly` property cannot be used if `integrationPattern`, `invocationType`,
+     * `clientContext`, or `qualifier` are specified.
+     * It always uses the REQUEST_RESPONSE behavior.
+     *
+     * @default false
+     */
+    readonly payloadResponseOnly?: boolean;
+    /**
+     * Whether to retry on Lambda service exceptions.
+     *
+     * This handles `Lambda.ServiceException`, `Lambda.AWSLambdaException`,
+     * `Lambda.SdkClientException`, and `Lambda.ClientExecutionTimeoutException`
+     * with an interval of 2 seconds, a back-off rate
+     * of 2 and 6 maximum attempts.
+     *
+     * @see https://docs.aws.amazon.com/step-functions/latest/dg/bp-lambda-serviceexception.html
+     *
+     * @default true
+     */
+    readonly retryOnServiceExceptions?: boolean;
+}
+/**
+ * Invoke a Lambda function as a Task
+ *
+ * @see https://docs.aws.amazon.com/step-functions/latest/dg/connect-lambda.html
+ */
+export declare class LambdaInvoke extends compute.TaskStateBase {
+    private readonly props;
+    private static readonly SUPPORTED_INTEGRATION_PATTERNS;
+    protected readonly taskPolicies?: iam.PolicyStatement[];
+    private readonly integrationPattern;
+    constructor(scope: Construct, id: string, props: LambdaInvokeProps);
+    /**
+     * Provides the Lambda Invoke service integration task configuration
+     */
+    /**
+     * @internal
+     */
+    protected _renderTask(): any;
+}
+/**
+ * Invocation type of a Lambda
+ */
+export declare enum LambdaInvocationType {
+    /**
+     * Invoke the function synchronously.
+     *
+     * Keep the connection open until the function returns a response or times out.
+     * The API response includes the function response and additional data.
+     */
+    REQUEST_RESPONSE = "RequestResponse",
+    /**
+     * Invoke the function asynchronously.
+     *
+     * Send events that fail multiple times to the function's dead-letter queue (if it's configured).
+     * The API response only includes a status code.
+     */
+    EVENT = "Event",
+    /**
+     * Validate parameter values and verify that the user or role has permission to invoke the function.
+     */
+    DRY_RUN = "DryRun"
+}

package/lib/aws/compute/tasks/lambda/invoke.js

@@ -0,0 +1,125 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LambdaInvocationType = exports.LambdaInvoke = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const compute = require("../../");
+const duration_1 = require("../../../../duration");
+const iam = require("../../../iam");
+const task_utils_1 = require("../private/task-utils");
+/**
+ * Invoke a Lambda function as a Task
+ *
+ * @see https://docs.aws.amazon.com/step-functions/latest/dg/connect-lambda.html
+ */
+class LambdaInvoke extends compute.TaskStateBase {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.props = props;
+        this.integrationPattern =
+            props.integrationPattern ?? compute.IntegrationPattern.REQUEST_RESPONSE;
+        (0, task_utils_1.validatePatternSupported)(this.integrationPattern, LambdaInvoke.SUPPORTED_INTEGRATION_PATTERNS);
+        if (this.integrationPattern ===
+            compute.IntegrationPattern.WAIT_FOR_TASK_TOKEN &&
+            !compute.FieldUtils.containsTaskToken(props.payload)) {
+            throw new Error("Task Token is required in `payload` for callback. Use JsonPath.taskToken to set the token.");
+        }
+        if (props.payloadResponseOnly &&
+            (props.integrationPattern ||
+                props.invocationType ||
+                props.clientContext ||
+                props.qualifier)) {
+            throw new Error("The 'payloadResponseOnly' property cannot be used if 'integrationPattern', 'invocationType', 'clientContext', or 'qualifier' are specified.");
+        }
+        // this.taskMetrics = {
+        //   metricPrefixSingular: "LambdaFunction",
+        //   metricPrefixPlural: "LambdaFunctions",
+        //   metricDimensions: {
+        //     LambdaFunctionArn: this.props.lambdaFunction.functionArn,
+        //     ...(this.props.qualifier && { Qualifier: this.props.qualifier }),
+        //   },
+        // };
+        this.taskPolicies = [
+            new iam.PolicyStatement({
+                resources: [this.props.lambdaFunction.functionArn], // .resourceArnsForGrantInvoke,
+                actions: ["lambda:InvokeFunction"],
+            }),
+        ];
+        if (props.retryOnServiceExceptions ?? true) {
+            // Best practice from https://docs.aws.amazon.com/step-functions/latest/dg/bp-lambda-serviceexception.html
+            this.addRetry({
+                errors: [
+                    "Lambda.ClientExecutionTimeoutException",
+                    "Lambda.ServiceException",
+                    "Lambda.AWSLambdaException",
+                    "Lambda.SdkClientException",
+                ],
+                interval: duration_1.Duration.seconds(2),
+                maxAttempts: 6,
+                backoffRate: 2,
+            });
+        }
+    }
+    /**
+     * Provides the Lambda Invoke service integration task configuration
+     */
+    /**
+     * @internal
+     */
+    _renderTask() {
+        if (this.props.payloadResponseOnly) {
+            return {
+                Resource: this.props.lambdaFunction.functionArn,
+                ...(this.props.payload && {
+                    Parameters: compute.FieldUtils.renderObject(this.props.payload.value),
+                }),
+            };
+        }
+        else {
+            return {
+                Resource: (0, task_utils_1.integrationResourceArn)(this, "lambda", "invoke", this.integrationPattern),
+                Parameters: compute.FieldUtils.renderObject({
+                    FunctionName: this.props.lambdaFunction.functionArn,
+                    Payload: this.props.payload
+                        ? this.props.payload.value
+                        : compute.TaskInput.fromJsonPathAt("$").value,
+                    InvocationType: this.props.invocationType,
+                    ClientContext: this.props.clientContext,
+                    Qualifier: this.props.qualifier,
+                }),
+            };
+        }
+    }
+}
+exports.LambdaInvoke = LambdaInvoke;
+_a = JSII_RTTI_SYMBOL_1;
+LambdaInvoke[_a] = { fqn: "terraconstructs.aws.compute.tasks.LambdaInvoke", version: "0.0.8" };
+LambdaInvoke.SUPPORTED_INTEGRATION_PATTERNS = [
+    compute.IntegrationPattern.REQUEST_RESPONSE,
+    compute.IntegrationPattern.WAIT_FOR_TASK_TOKEN,
+];
+/**
+ * Invocation type of a Lambda
+ */
+var LambdaInvocationType;
+(function (LambdaInvocationType) {
+    /**
+     * Invoke the function synchronously.
+     *
+     * Keep the connection open until the function returns a response or times out.
+     * The API response includes the function response and additional data.
+     */
+    LambdaInvocationType["REQUEST_RESPONSE"] = "RequestResponse";
+    /**
+     * Invoke the function asynchronously.
+     *
+     * Send events that fail multiple times to the function's dead-letter queue (if it's configured).
+     * The API response only includes a status code.
+     */
+    LambdaInvocationType["EVENT"] = "Event";
+    /**
+     * Validate parameter values and verify that the user or role has permission to invoke the function.
+     */
+    LambdaInvocationType["DRY_RUN"] = "DryRun";
+})(LambdaInvocationType || (exports.LambdaInvocationType = LambdaInvocationType = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"invoke.js","sourceRoot":"","sources":["../../../../../src/aws/compute/tasks/lambda/invoke.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from \"constructs\";\nimport * as compute from \"../../\";\nimport { Duration } from \"../../../../duration\";\nimport * as iam from \"../../../iam\";\nimport {\n  integrationResourceArn,\n  validatePatternSupported,\n} from \"../private/task-utils\";\n\n/**\n * Properties for invoking a Lambda function with LambdaInvoke\n */\nexport interface LambdaInvokeProps extends compute.TaskStateBaseProps {\n  /**\n   * Lambda function to invoke\n   */\n  readonly lambdaFunction: compute.IFunction;\n\n  /**\n   * The JSON that will be supplied as input to the Lambda function\n   *\n   * @default - The state input (JSON path '$')\n   */\n  readonly payload?: compute.TaskInput;\n\n  /**\n   * Invocation type of the Lambda function\n   *\n   * @default InvocationType.REQUEST_RESPONSE\n   */\n  readonly invocationType?: LambdaInvocationType;\n\n  /**\n   * Up to 3583 bytes of base64-encoded data about the invoking client\n   * to pass to the function.\n   *\n   * @default - No context\n   */\n  readonly clientContext?: string;\n\n  /**\n   * Version or alias to invoke a published version of the function\n   *\n   * You only need to supply this if you want the version of the Lambda Function to depend\n   * on data in the state machine state. If not, you can pass the appropriate Alias or Version object\n   * directly as the `lambdaFunction` argument.\n   *\n   * @default - Version or alias inherent to the `lambdaFunction` object.\n   */\n  readonly qualifier?: string;\n  // deprecate this? pass a Version or Alias object as lambdaFunction instead\n\n  /**\n   * Invoke the Lambda in a way that only returns the payload response without additional metadata.\n   *\n   * The `payloadResponseOnly` property cannot be used if `integrationPattern`, `invocationType`,\n   * `clientContext`, or `qualifier` are specified.\n   * It always uses the REQUEST_RESPONSE behavior.\n   *\n   * @default false\n   */\n  readonly payloadResponseOnly?: boolean;\n\n  /**\n   * Whether to retry on Lambda service exceptions.\n   *\n   * This handles `Lambda.ServiceException`, `Lambda.AWSLambdaException`,\n   * `Lambda.SdkClientException`, and `Lambda.ClientExecutionTimeoutException`\n   * with an interval of 2 seconds, a back-off rate\n   * of 2 and 6 maximum attempts.\n   *\n   * @see https://docs.aws.amazon.com/step-functions/latest/dg/bp-lambda-serviceexception.html\n   *\n   * @default true\n   */\n  readonly retryOnServiceExceptions?: boolean;\n}\n\n/**\n * Invoke a Lambda function as a Task\n *\n * @see https://docs.aws.amazon.com/step-functions/latest/dg/connect-lambda.html\n */\nexport class LambdaInvoke extends compute.TaskStateBase {\n  private static readonly SUPPORTED_INTEGRATION_PATTERNS: compute.IntegrationPattern[] =\n    [\n      compute.IntegrationPattern.REQUEST_RESPONSE,\n      compute.IntegrationPattern.WAIT_FOR_TASK_TOKEN,\n    ];\n\n  // protected readonly taskMetrics?: compute.TaskMetricsConfig;\n  protected readonly taskPolicies?: iam.PolicyStatement[];\n\n  private readonly integrationPattern: compute.IntegrationPattern;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    private readonly props: LambdaInvokeProps,\n  ) {\n    super(scope, id, props);\n    this.integrationPattern =\n      props.integrationPattern ?? compute.IntegrationPattern.REQUEST_RESPONSE;\n\n    validatePatternSupported(\n      this.integrationPattern,\n      LambdaInvoke.SUPPORTED_INTEGRATION_PATTERNS,\n    );\n\n    if (\n      this.integrationPattern ===\n        compute.IntegrationPattern.WAIT_FOR_TASK_TOKEN &&\n      !compute.FieldUtils.containsTaskToken(props.payload)\n    ) {\n      throw new Error(\n        \"Task Token is required in `payload` for callback. Use JsonPath.taskToken to set the token.\",\n      );\n    }\n\n    if (\n      props.payloadResponseOnly &&\n      (props.integrationPattern ||\n        props.invocationType ||\n        props.clientContext ||\n        props.qualifier)\n    ) {\n      throw new Error(\n        \"The 'payloadResponseOnly' property cannot be used if 'integrationPattern', 'invocationType', 'clientContext', or 'qualifier' are specified.\",\n      );\n    }\n\n    // this.taskMetrics = {\n    //   metricPrefixSingular: \"LambdaFunction\",\n    //   metricPrefixPlural: \"LambdaFunctions\",\n    //   metricDimensions: {\n    //     LambdaFunctionArn: this.props.lambdaFunction.functionArn,\n    //     ...(this.props.qualifier && { Qualifier: this.props.qualifier }),\n    //   },\n    // };\n\n    this.taskPolicies = [\n      new iam.PolicyStatement({\n        resources: [this.props.lambdaFunction.functionArn], // .resourceArnsForGrantInvoke,\n        actions: [\"lambda:InvokeFunction\"],\n      }),\n    ];\n\n    if (props.retryOnServiceExceptions ?? true) {\n      // Best practice from https://docs.aws.amazon.com/step-functions/latest/dg/bp-lambda-serviceexception.html\n      this.addRetry({\n        errors: [\n          \"Lambda.ClientExecutionTimeoutException\",\n          \"Lambda.ServiceException\",\n          \"Lambda.AWSLambdaException\",\n          \"Lambda.SdkClientException\",\n        ],\n        interval: Duration.seconds(2),\n        maxAttempts: 6,\n        backoffRate: 2,\n      });\n    }\n  }\n\n  /**\n   * Provides the Lambda Invoke service integration task configuration\n   */\n  /**\n   * @internal\n   */\n  protected _renderTask(): any {\n    if (this.props.payloadResponseOnly) {\n      return {\n        Resource: this.props.lambdaFunction.functionArn,\n        ...(this.props.payload && {\n          Parameters: compute.FieldUtils.renderObject(this.props.payload.value),\n        }),\n      };\n    } else {\n      return {\n        Resource: integrationResourceArn(\n          this,\n          \"lambda\",\n          \"invoke\",\n          this.integrationPattern,\n        ),\n        Parameters: compute.FieldUtils.renderObject({\n          FunctionName: this.props.lambdaFunction.functionArn,\n          Payload: this.props.payload\n            ? this.props.payload.value\n            : compute.TaskInput.fromJsonPathAt(\"$\").value,\n          InvocationType: this.props.invocationType,\n          ClientContext: this.props.clientContext,\n          Qualifier: this.props.qualifier,\n        }),\n      };\n    }\n  }\n}\n\n/**\n * Invocation type of a Lambda\n */\nexport enum LambdaInvocationType {\n  /**\n   * Invoke the function synchronously.\n   *\n   * Keep the connection open until the function returns a response or times out.\n   * The API response includes the function response and additional data.\n   */\n  REQUEST_RESPONSE = \"RequestResponse\",\n\n  /**\n   * Invoke the function asynchronously.\n   *\n   * Send events that fail multiple times to the function's dead-letter queue (if it's configured).\n   * The API response only includes a status code.\n   */\n  EVENT = \"Event\",\n\n  /**\n   * Validate parameter values and verify that the user or role has permission to invoke the function.\n   */\n  DRY_RUN = \"DryRun\",\n}\n"]}

package/lib/aws/compute/tasks/private/task-utils.d.ts

@@ -0,0 +1,8 @@
+import { Construct } from "constructs";
+import { IntegrationPattern } from "../../";
+/**
+ * Verifies that a validation pattern is supported for a service integration
+ *
+ */
+export declare function validatePatternSupported(integrationPattern: IntegrationPattern, supportedPatterns: IntegrationPattern[]): void;
+export declare function integrationResourceArn(scope: Construct, service: string, api: string, integrationPattern?: IntegrationPattern): string;

package/lib/aws/compute/tasks/private/task-utils.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.integrationResourceArn = exports.validatePatternSupported = void 0;
+const __1 = require("../../");
+const aws_stack_1 = require("../../../aws-stack");
+/**
+ * Verifies that a validation pattern is supported for a service integration
+ *
+ */
+function validatePatternSupported(integrationPattern, supportedPatterns) {
+    if (!supportedPatterns.includes(integrationPattern)) {
+        throw new Error(`Unsupported service integration pattern. Supported Patterns: ${supportedPatterns}. Received: ${integrationPattern}`);
+    }
+}
+exports.validatePatternSupported = validatePatternSupported;
+/**
+ * Suffixes corresponding to different service integration patterns
+ *
+ * Key is the service integration pattern, value is the resource ARN suffix.
+ *
+ * @see https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html
+ */
+const resourceArnSuffix = {
+    [__1.IntegrationPattern.REQUEST_RESPONSE]: "",
+    [__1.IntegrationPattern.RUN_JOB]: ".sync",
+    [__1.IntegrationPattern.WAIT_FOR_TASK_TOKEN]: ".waitForTaskToken",
+};
+function integrationResourceArn(scope, service, api, integrationPattern) {
+    if (!service || !api) {
+        throw new Error("Both 'service' and 'api' must be provided to build the resource ARN.");
+    }
+    return (`arn:${aws_stack_1.AwsStack.ofAwsConstruct(scope).partition}:states:::${service}:${api}` +
+        (integrationPattern ? resourceArnSuffix[integrationPattern] : ""));
+}
+exports.integrationResourceArn = integrationResourceArn;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/compute/tasks/resource-arn-suffix.d.ts

@@ -0,0 +1,3 @@
+import { Construct } from "constructs";
+import * as sfn from "../";
+export declare function getResourceArn(scope: Construct, service: string, api: string, integrationPattern: sfn.ServiceIntegrationPattern): string;

package/lib/aws/compute/tasks/resource-arn-suffix.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getResourceArn = void 0;
+const sfn = require("../");
+const __1 = require("../../");
+/**
+ * Suffixes corresponding to different service integration patterns
+ *
+ * Key is the service integration pattern, value is the resource ARN suffix.
+ *
+ * @see https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html
+ */
+const resourceArnSuffix = new Map();
+resourceArnSuffix.set(sfn.ServiceIntegrationPattern.FIRE_AND_FORGET, "");
+resourceArnSuffix.set(sfn.ServiceIntegrationPattern.SYNC, ".sync");
+resourceArnSuffix.set(sfn.ServiceIntegrationPattern.WAIT_FOR_TASK_TOKEN, ".waitForTaskToken");
+function getResourceArn(scope, service, api, integrationPattern) {
+    if (!service || !api) {
+        throw new Error("Both 'service' and 'api' must be provided to build the resource ARN.");
+    }
+    return (`arn:${__1.AwsStack.ofAwsConstruct(scope).partition}:states:::${service}:${api}` +
+        (integrationPattern ? resourceArnSuffix.get(integrationPattern) : ""));
+}
+exports.getResourceArn = getResourceArn;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/compute/tasks/sqs/send-message.d.ts

@@ -0,0 +1,62 @@
+import { Construct } from "constructs";
+import * as compute from "../../";
+import { Duration } from "../../../../duration";
+import * as iam from "../../../iam";
+import * as notify from "../../../notify";
+/**
+ * Properties for sending a message to an SQS queue
+ */
+export interface SqsSendMessageProps extends compute.TaskStateBaseProps {
+    /**
+     * The SQS queue that messages will be sent to
+     */
+    readonly queue: notify.IQueue;
+    /**
+     * The text message to send to the queue.
+     */
+    readonly messageBody: compute.TaskInput;
+    /**
+     * The length of time, for which to delay a message.
+     * Messages that you send to the queue remain invisible to consumers for the duration
+     * of the delay period. The maximum allowed delay is 15 minutes.
+     *
+     * @default - delay set on the queue. If a delay is not set on the queue,
+     *   messages are sent immediately (0 seconds).
+     */
+    readonly delay?: Duration;
+    /**
+     * The token used for deduplication of sent messages.
+     * Any messages sent with the same deduplication ID are accepted successfully,
+     * but aren't delivered during the 5-minute deduplication interval.
+     *
+     * @default - None
+     */
+    readonly messageDeduplicationId?: string;
+    /**
+     * The tag that specifies that a message belongs to a specific message group.
+     *
+     * Messages that belong to the same message group are processed in a FIFO manner.
+     * Messages in different message groups might be processed out of order.
+     *
+     * @default - None
+     */
+    readonly messageGroupId?: string;
+}
+/**
+ * A StepFunctions Task to send messages to SQS queue.
+ *
+ */
+export declare class SqsSendMessage extends compute.TaskStateBase {
+    private readonly props;
+    private static readonly SUPPORTED_INTEGRATION_PATTERNS;
+    protected readonly taskPolicies?: iam.PolicyStatement[];
+    private readonly integrationPattern;
+    constructor(scope: Construct, id: string, props: SqsSendMessageProps);
+    /**
+     * Provides the SQS SendMessage service integration task configuration
+     */
+    /**
+     * @internal
+     */
+    protected _renderTask(): any;
+}

package/lib/aws/compute/tasks/sqs/send-message.js

@@ -0,0 +1,70 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqsSendMessage = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const compute = require("../../");
+const iam = require("../../../iam");
+const task_utils_1 = require("../private/task-utils");
+/**
+ * A StepFunctions Task to send messages to SQS queue.
+ *
+ */
+class SqsSendMessage extends compute.TaskStateBase {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.props = props;
+        this.integrationPattern =
+            props.integrationPattern ?? compute.IntegrationPattern.REQUEST_RESPONSE;
+        (0, task_utils_1.validatePatternSupported)(this.integrationPattern, SqsSendMessage.SUPPORTED_INTEGRATION_PATTERNS);
+        if (props.integrationPattern ===
+            compute.IntegrationPattern.WAIT_FOR_TASK_TOKEN) {
+            if (!compute.FieldUtils.containsTaskToken(props.messageBody)) {
+                throw new Error("Task Token is required in `messageBody` Use JsonPath.taskToken to set the token.");
+            }
+        }
+        this.taskPolicies = [
+            new iam.PolicyStatement({
+                actions: ["sqs:SendMessage"],
+                resources: [this.props.queue.queueArn],
+            }),
+        ];
+        // // TODO: Re-Add encryption support
+        // // sending to an encrypted queue requires
+        // // permissions on the associated kms key
+        // if (this.props.queue.encryptionMasterKey) {
+        //   this.taskPolicies.push(
+        //     new iam.PolicyStatement({
+        //       actions: ["kms:Decrypt", "kms:GenerateDataKey*"],
+        //       resources: [this.props.queue.encryptionMasterKey.keyArn],
+        //     }),
+        //   );
+        // }
+    }
+    /**
+     * Provides the SQS SendMessage service integration task configuration
+     */
+    /**
+     * @internal
+     */
+    _renderTask() {
+        return {
+            Resource: (0, task_utils_1.integrationResourceArn)(this, "sqs", "sendMessage", this.integrationPattern),
+            Parameters: compute.FieldUtils.renderObject({
+                QueueUrl: this.props.queue.queueUrl,
+                MessageBody: this.props.messageBody.value,
+                DelaySeconds: this.props.delay?.toSeconds(),
+                MessageDeduplicationId: this.props.messageDeduplicationId,
+                MessageGroupId: this.props.messageGroupId,
+            }),
+        };
+    }
+}
+exports.SqsSendMessage = SqsSendMessage;
+_a = JSII_RTTI_SYMBOL_1;
+SqsSendMessage[_a] = { fqn: "terraconstructs.aws.compute.tasks.SqsSendMessage", version: "0.0.8" };
+SqsSendMessage.SUPPORTED_INTEGRATION_PATTERNS = [
+    compute.IntegrationPattern.REQUEST_RESPONSE,
+    compute.IntegrationPattern.WAIT_FOR_TASK_TOKEN,
+];
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/compute/tasks/stepfunctions/invoke-activity.d.ts

@@ -0,0 +1,36 @@
+import { Construct } from "constructs";
+import * as compute from "../../";
+import * as iam from "../../../iam";
+/**
+ * Properties for invoking an Activity worker
+ */
+export interface StepFunctionsInvokeActivityProps extends compute.TaskStateBaseProps {
+    /**
+     * Step Functions Activity to invoke
+     */
+    readonly activity: compute.IActivity;
+    /**
+     * Parameters pass a collection of key-value pairs, either static values or JSONPath expressions that select from the input.
+     *
+     * @see https://docs.aws.amazon.com/step-functions/latest/dg/input-output-inputpath-params.html#input-output-parameters
+     *
+     * @default No parameters
+     */
+    readonly parameters?: {
+        [name: string]: any;
+    };
+}
+/**
+ * A Step Functions Task to invoke an Activity worker.
+ *
+ * An Activity can be used directly as a Resource.
+ */
+export declare class StepFunctionsInvokeActivity extends compute.TaskStateBase {
+    private readonly props;
+    protected readonly taskPolicies?: iam.PolicyStatement[];
+    constructor(scope: Construct, id: string, props: StepFunctionsInvokeActivityProps);
+    /**
+     * @internal
+     */
+    protected _renderTask(): any;
+}

package/lib/aws/compute/tasks/stepfunctions/invoke-activity.js

@@ -0,0 +1,45 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StepFunctionsInvokeActivity = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const compute = require("../../");
+/**
+ * A Step Functions Task to invoke an Activity worker.
+ *
+ * An Activity can be used directly as a Resource.
+ */
+class StepFunctionsInvokeActivity extends compute.TaskStateBase {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.props = props;
+        // if (
+        //   this.props.activity.encryptionConfiguration instanceof
+        //   CustomerManagedEncryptionConfiguration
+        // ) {
+        //   this.taskPolicies = this.createPolicyStatements(
+        //     this.props.activity.encryptionConfiguration.kmsKey,
+        //   );
+        // }
+        // this.taskMetrics = {
+        //   metricDimensions: { ActivityArn: this.props.activity.activityArn },
+        //   metricPrefixSingular: "Activity",
+        //   metricPrefixPlural: "Activities",
+        // };
+    }
+    /**
+     * @internal
+     */
+    _renderTask() {
+        return {
+            Resource: this.props.activity.activityArn,
+            Parameters: this.props.parameters
+                ? compute.FieldUtils.renderObject(this.props.parameters)
+                : undefined,
+        };
+    }
+}
+exports.StepFunctionsInvokeActivity = StepFunctionsInvokeActivity;
+_a = JSII_RTTI_SYMBOL_1;
+StepFunctionsInvokeActivity[_a] = { fqn: "terraconstructs.aws.compute.tasks.StepFunctionsInvokeActivity", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/compute/tasks/stepfunctions/start-execution.d.ts

@@ -0,0 +1,63 @@
+import { Construct } from "constructs";
+import * as compute from "../../";
+import * as iam from "../../../iam";
+/**
+ * Properties for StartExecution
+ */
+export interface StepFunctionsStartExecutionProps extends compute.TaskStateBaseProps {
+    /**
+     * The Step Functions state machine to start the execution on.
+     */
+    readonly stateMachine: compute.IStateMachine;
+    /**
+     * The JSON input for the execution, same as that of StartExecution.
+     *
+     * @see https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html
+     *
+     * @default - The state input (JSON path '$')
+     */
+    readonly input?: compute.TaskInput;
+    /**
+     * The name of the execution, same as that of StartExecution.
+     *
+     * @see https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html
+     *
+     * @default - None
+     */
+    readonly name?: string;
+    /**
+     * Pass the execution ID from the context object to the execution input.
+     * This allows the Step Functions UI to link child executions from parent executions, making it easier to trace execution flow across state machines.
+     *
+     * If you set this property to `true`, the `input` property must be an object (provided by `sfn.TaskInput.fromObject`) or omitted entirely.
+     *
+     * @see https://docs.aws.amazon.com/step-functions/latest/dg/concepts-nested-workflows.html#nested-execution-startid
+     *
+     * @default - false
+     */
+    readonly associateWithParent?: boolean;
+}
+/**
+ * A Step Functions Task to call StartExecution on another state machine.
+ *
+ * It supports three service integration patterns: REQUEST_RESPONSE, RUN_JOB, and WAIT_FOR_TASK_TOKEN.
+ */
+export declare class StepFunctionsStartExecution extends compute.TaskStateBase {
+    private readonly props;
+    private static readonly SUPPORTED_INTEGRATION_PATTERNS;
+    protected readonly taskPolicies?: iam.PolicyStatement[];
+    private readonly integrationPattern;
+    constructor(scope: Construct, id: string, props: StepFunctionsStartExecutionProps);
+    /**
+     * @internal
+     */
+    protected _renderTask(): any;
+    /**
+     * As StateMachineArn is extracted automatically from the state machine object included in the constructor,
+     *
+     * the scoped access policy should be generated accordingly.
+     *
+     * This means the action of StartExecution should be restricted on the given state machine, instead of being granted to all the resources (*).
+     */
+    private createScopedAccessPolicy;
+}