terraconstructs 0.0.8

package/lib/aws/compute/tasks/aws-sdk/call-aws-service.js

@@ -0,0 +1,69 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallAwsService = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdktf_1 = require("cdktf");
+const compute = require("../../");
+const iam = require("../../../iam");
+const task_utils_1 = require("../private/task-utils");
+/**
+ * A StepFunctions task to call an AWS service API
+ */
+class CallAwsService extends compute.TaskStateBase {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.props = props;
+        if (this.props.integrationPattern === compute.IntegrationPattern.RUN_JOB) {
+            throw new Error("The RUN_JOB integration pattern is not supported for CallAwsService");
+        }
+        if (!cdktf_1.Token.isUnresolved(this.props.action) &&
+            !this.props.action.startsWith(this.props.action[0]?.toLowerCase())) {
+            throw new Error(`action must be camelCase, got: ${this.props.action}`);
+        }
+        if (this.props.parameters) {
+            const invalidKeys = Object.keys(this.props.parameters).filter((key) => !key.startsWith(key[0]?.toUpperCase()));
+            if (invalidKeys.length) {
+                throw new Error(`parameter names must be PascalCase, got: ${invalidKeys.join(", ")}`);
+            }
+        }
+        // https://github.com/aws/aws-cdk/pull/27623
+        const iamServiceMap = {
+            sfn: "states",
+            cloudwatchlogs: "logs",
+            mediapackagevod: "mediapackage-vod",
+            mwaa: "airflow",
+            efs: "elasticfilesystem",
+        };
+        const iamService = iamServiceMap[props.service] ?? props.service;
+        this.taskPolicies = [
+            new iam.PolicyStatement({
+                resources: props.iamResources,
+                // The prefix and the action name are case insensitive
+                // https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_action.html
+                actions: [props.iamAction ?? `${iamService}:${props.action}`],
+            }),
+            ...(props.additionalIamStatements ?? []),
+        ];
+    }
+    /**
+     * @internal
+     */
+    _renderTask() {
+        let service = this.props.service;
+        if (!cdktf_1.Token.isUnresolved(service)) {
+            service = service.toLowerCase();
+        }
+        // The pattern here is: "arn:aws:states:::aws-sdk:serviceName:apiAction.[serviceIntegrationPattern]"
+        // See here: https://docs.aws.amazon.com/step-functions/latest/dg/supported-services-awssdk.html
+        // This does not change with sdk upgrades, TT:P125388388
+        return {
+            Resource: (0, task_utils_1.integrationResourceArn)(this, "aws-sdk", `${service}:${this.props.action}`, this.props.integrationPattern),
+            Parameters: compute.FieldUtils.renderObject(this.props.parameters) ?? {}, // Parameters is required for aws-sdk
+        };
+    }
+}
+exports.CallAwsService = CallAwsService;
+_a = JSII_RTTI_SYMBOL_1;
+CallAwsService[_a] = { fqn: "terraconstructs.aws.compute.tasks.CallAwsService", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"call-aws-service.js","sourceRoot":"","sources":["../../../../../src/aws/compute/tasks/aws-sdk/call-aws-service.ts"],"names":[],"mappings":";;;;;AAAA,iCAA8B;AAE9B,kCAAkC;AAClC,oCAAoC;AACpC,sDAA+D;AAgE/D;;GAEG;AACH,MAAa,cAAe,SAAQ,OAAO,CAAC,aAAa;IAIvD,YACE,KAAgB,EAChB,EAAU,EACO,KAA0B;QAE3C,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;QAFP,UAAK,GAAL,KAAK,CAAqB;QAI3C,IAAI,IAAI,CAAC,KAAK,CAAC,kBAAkB,KAAK,OAAO,CAAC,kBAAkB,CAAC,OAAO,EAAE,CAAC;YACzE,MAAM,IAAI,KAAK,CACb,qEAAqE,CACtE,CAAC;QACJ,CAAC;QACD,IACE,CAAC,aAAK,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;YACtC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAClE,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,kCAAkC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;QACzE,CAAC;QACD,IAAI,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC;YAC1B,MAAM,WAAW,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,MAAM,CAC3D,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,CAChD,CAAC;YACF,IAAI,WAAW,CAAC,MAAM,EAAE,CAAC;gBACvB,MAAM,IAAI,KAAK,CACb,4CAA4C,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CACrE,CAAC;YACJ,CAAC;QACH,CAAC;QAED,4CAA4C;QAC5C,MAAM,aAAa,GAA2B;YAC5C,GAAG,EAAE,QAAQ;YACb,cAAc,EAAE,MAAM;YACtB,eAAe,EAAE,kBAAkB;YACnC,IAAI,EAAE,SAAS;YACf,GAAG,EAAE,mBAAmB;SACzB,CAAC;QACF,MAAM,UAAU,GAAG,aAAa,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC;QAEjE,IAAI,CAAC,YAAY,GAAG;YAClB,IAAI,GAAG,CAAC,eAAe,CAAC;gBACtB,SAAS,EAAE,KAAK,CAAC,YAAY;gBAC7B,sDAAsD;gBACtD,2FAA2F;gBAC3F,OAAO,EAAE,CAAC,KAAK,CAAC,SAAS,IAAI,GAAG,UAAU,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;aAC9D,CAAC;YACF,GAAG,CAAC,KAAK,CAAC,uBAAuB,IAAI,EAAE,CAAC;SACzC,CAAC;IACJ,CAAC;IAED;;OAEG;IACO,WAAW;QACnB,IAAI,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC;QAEjC,IAAI,CAAC,aAAK,CAAC,YAAY,CAAC,OAAO,CAAC,EAAE,CAAC;YACjC,OAAO,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;QAClC,CAAC;QAED,oGAAoG;QACpG,gGAAgG;QAChG,wDAAwD;QACxD,OAAO;YACL,QAAQ,EAAE,IAAA,mCAAsB,EAC9B,IAAI,EACJ,SAAS,EACT,GAAG,OAAO,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,EACjC,IAAI,CAAC,KAAK,CAAC,kBAAkB,CAC9B;YACD,UAAU,EAAE,OAAO,CAAC,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,EAAE,EAAE,qCAAqC;SAChH,CAAC;IACJ,CAAC;;AA5EH,wCA6EC","sourcesContent":["import { Token } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport * as compute from \"../../\";\nimport * as iam from \"../../../iam\";\nimport { integrationResourceArn } from \"../private/task-utils\";\n\n/**\n * Properties for calling an AWS service's API action from your\n * state machine.\n *\n * @see https://docs.aws.amazon.com/step-functions/latest/dg/supported-services-awssdk.html\n */\nexport interface CallAwsServiceProps extends compute.TaskStateBaseProps {\n  /**\n   * The AWS service to call.\n   *\n   * @see https://docs.aws.amazon.com/step-functions/latest/dg/supported-services-awssdk.html\n   */\n  readonly service: string;\n\n  /**\n   * The API action to call.\n   *\n   * Use camelCase.\n   */\n  readonly action: string;\n\n  /**\n   * Parameters for the API action call.\n   *\n   * Use PascalCase for the parameter names.\n   *\n   * @default - no parameters\n   */\n  readonly parameters?: { [key: string]: any };\n\n  /**\n   * The resources for the IAM statement that will be added to the state\n   * machine role's policy to allow the state machine to make the API call.\n   *\n   * By default the action for this IAM statement will be `service:action`.\n   */\n  readonly iamResources: string[];\n\n  /**\n   * The action for the IAM statement that will be added to the state\n   * machine role's policy to allow the state machine to make the API call.\n   *\n   * Use in the case where the IAM action name does not match with the\n   * API service/action name, e.g. `s3:ListBuckets` requires `s3:ListAllMyBuckets`.\n   *\n   * @default - service:action\n   */\n  readonly iamAction?: string;\n\n  /**\n   * Additional IAM statements that will be added to the state machine\n   * role's policy.\n   *\n   * Use in the case where the call requires more than a single statement to\n   * be executed, e.g. `rekognition:detectLabels` requires also S3 permissions\n   * to read the object on which it must act.\n   *\n   * @default - no additional statements are added\n   */\n  readonly additionalIamStatements?: iam.PolicyStatement[];\n}\n\n/**\n * A StepFunctions task to call an AWS service API\n */\nexport class CallAwsService extends compute.TaskStateBase {\n  // protected readonly taskMetrics?: sfn.TaskMetricsConfig;\n  protected readonly taskPolicies?: iam.PolicyStatement[];\n\n  constructor(\n    scope: Construct,\n    id: string,\n    private readonly props: CallAwsServiceProps,\n  ) {\n    super(scope, id, props);\n\n    if (this.props.integrationPattern === compute.IntegrationPattern.RUN_JOB) {\n      throw new Error(\n        \"The RUN_JOB integration pattern is not supported for CallAwsService\",\n      );\n    }\n    if (\n      !Token.isUnresolved(this.props.action) &&\n      !this.props.action.startsWith(this.props.action[0]?.toLowerCase())\n    ) {\n      throw new Error(`action must be camelCase, got: ${this.props.action}`);\n    }\n    if (this.props.parameters) {\n      const invalidKeys = Object.keys(this.props.parameters).filter(\n        (key) => !key.startsWith(key[0]?.toUpperCase()),\n      );\n      if (invalidKeys.length) {\n        throw new Error(\n          `parameter names must be PascalCase, got: ${invalidKeys.join(\", \")}`,\n        );\n      }\n    }\n\n    // https://github.com/aws/aws-cdk/pull/27623\n    const iamServiceMap: Record<string, string> = {\n      sfn: \"states\",\n      cloudwatchlogs: \"logs\",\n      mediapackagevod: \"mediapackage-vod\",\n      mwaa: \"airflow\",\n      efs: \"elasticfilesystem\",\n    };\n    const iamService = iamServiceMap[props.service] ?? props.service;\n\n    this.taskPolicies = [\n      new iam.PolicyStatement({\n        resources: props.iamResources,\n        // The prefix and the action name are case insensitive\n        // https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_action.html\n        actions: [props.iamAction ?? `${iamService}:${props.action}`],\n      }),\n      ...(props.additionalIamStatements ?? []),\n    ];\n  }\n\n  /**\n   * @internal\n   */\n  protected _renderTask(): any {\n    let service = this.props.service;\n\n    if (!Token.isUnresolved(service)) {\n      service = service.toLowerCase();\n    }\n\n    // The pattern here is: \"arn:aws:states:::aws-sdk:serviceName:apiAction.[serviceIntegrationPattern]\"\n    // See here: https://docs.aws.amazon.com/step-functions/latest/dg/supported-services-awssdk.html\n    // This does not change with sdk upgrades, TT:P125388388\n    return {\n      Resource: integrationResourceArn(\n        this,\n        \"aws-sdk\",\n        `${service}:${this.props.action}`,\n        this.props.integrationPattern,\n      ),\n      Parameters: compute.FieldUtils.renderObject(this.props.parameters) ?? {}, // Parameters is required for aws-sdk\n    };\n  }\n}\n"]}

package/lib/aws/compute/tasks/eventbridge/put-events.d.ts

@@ -0,0 +1,74 @@
+import { Construct } from "constructs";
+import * as compute from "../../";
+import * as iam from "../../../iam";
+import * as notify from "../../../notify";
+/**
+ * An entry to be sent to EventBridge
+ *
+ * @see https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEventsRequestEntry.html
+ */
+export interface EventBridgePutEventsEntry {
+    /**
+     * The event body
+     *
+     * Can either be provided as an object or as a JSON-serialized string
+     * @example
+     *
+     * compute.TaskInput.fromText('{"instance-id": "i-1234567890abcdef0", "state": "terminated"}');
+     * compute.TaskInput.fromObject({ Message: 'Hello from Step Functions' });
+     * compute.TaskInput.fromJsonPathAt('$.EventDetail');
+     */
+    readonly detail: compute.TaskInput;
+    /**
+     * Used along with the source field to help identify the fields and values expected in the detail field
+     *
+     * For example, events by CloudTrail have detail type "AWS API Call via CloudTrail"
+     * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-events.html
+     */
+    readonly detailType: string;
+    /**
+     * The event bus the entry will be sent to.
+     *
+     * @default - event is sent to account's default event bus
+     */
+    readonly eventBus?: notify.IEventBus;
+    /**
+     * The service or application that caused this event to be generated
+     *
+     * Example value: `com.example.service`
+     *
+     * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-events.html
+     */
+    readonly source: string;
+}
+/**
+ * Properties for sending events with PutEvents
+ */
+export interface EventBridgePutEventsProps extends compute.TaskStateBaseProps {
+    /**
+     * The entries that will be sent. Minimum number of entries is 1 and maximum is 10,
+     * unless [PutEvents API limit](https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEvents.html#API_PutEvents_RequestSyntax) has changed.
+     */
+    readonly entries: EventBridgePutEventsEntry[];
+}
+/**
+ * A StepFunctions Task to send events to an EventBridge event bus
+ */
+export declare class EventBridgePutEvents 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: EventBridgePutEventsProps);
+    /**
+     * Returns an array of EventBusArn strings based on this.props.entries
+     */
+    private get eventBusArns();
+    /**
+     * Provides the EventBridge put events service integration task configuration
+     * @internal
+     */
+    protected _renderTask(): any;
+    private renderEntries;
+    private validateEntries;
+}

package/lib/aws/compute/tasks/eventbridge/put-events.js

@@ -0,0 +1,94 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventBridgePutEvents = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const compute = require("../../");
+const arn_1 = require("../../../arn");
+const aws_stack_1 = require("../../../aws-stack");
+const iam = require("../../../iam");
+const task_utils_1 = require("../private/task-utils");
+/**
+ * A StepFunctions Task to send events to an EventBridge event bus
+ */
+class EventBridgePutEvents 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, EventBridgePutEvents.SUPPORTED_INTEGRATION_PATTERNS);
+        if (this.integrationPattern === compute.IntegrationPattern.WAIT_FOR_TASK_TOKEN) {
+            if (!compute.FieldUtils.containsTaskToken(props.entries.map((entry) => entry.detail))) {
+                throw new Error("Task Token is required in `entries`. Use JsonPath.taskToken to set the token.");
+            }
+        }
+        this.validateEntries();
+        this.taskPolicies = [
+            new iam.PolicyStatement({
+                actions: ["events:PutEvents"],
+                resources: this.eventBusArns,
+            }),
+        ];
+    }
+    /**
+     * Returns an array of EventBusArn strings based on this.props.entries
+     */
+    get eventBusArns() {
+        return this.props.entries.map((entry) => {
+            if (entry.eventBus) {
+                // If an eventBus is provided, use the corresponding ARN
+                return entry.eventBus.eventBusArn;
+            }
+            else {
+                // If neither an eventBus nor eventBusName is provided,
+                // format the ARN for the default event bus in the account.
+                return aws_stack_1.AwsStack.ofAwsConstruct(this).formatArn({
+                    resource: "event-bus",
+                    resourceName: "default",
+                    arnFormat: arn_1.ArnFormat.SLASH_RESOURCE_NAME,
+                    service: "events",
+                });
+            }
+        });
+    }
+    /**
+     * Provides the EventBridge put events service integration task configuration
+     * @internal
+     */
+    _renderTask() {
+        return {
+            Resource: (0, task_utils_1.integrationResourceArn)(this, "events", "putEvents", this.integrationPattern),
+            Parameters: compute.FieldUtils.renderObject({
+                Entries: this.renderEntries(),
+            }),
+        };
+    }
+    renderEntries() {
+        // we should have validated all entries in validateEntries()
+        return this.props.entries.map((entry) => {
+            return {
+                Detail: entry.detail?.value,
+                DetailType: entry.detailType,
+                EventBusName: entry.eventBus?.eventBusArn,
+                Source: entry.source,
+            };
+        });
+    }
+    validateEntries() {
+        if (this.props.entries.length <= 0) {
+            throw new Error("Value for property `entries` must be a non-empty array.");
+        }
+        if (this.props.entries.some((e) => e.source.startsWith("aws."))) {
+            throw new Error('Event source cannot start with "aws."');
+        }
+    }
+}
+exports.EventBridgePutEvents = EventBridgePutEvents;
+_a = JSII_RTTI_SYMBOL_1;
+EventBridgePutEvents[_a] = { fqn: "terraconstructs.aws.compute.tasks.EventBridgePutEvents", version: "0.0.8" };
+EventBridgePutEvents.SUPPORTED_INTEGRATION_PATTERNS = [
+    compute.IntegrationPattern.REQUEST_RESPONSE,
+    compute.IntegrationPattern.WAIT_FOR_TASK_TOKEN,
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"put-events.js","sourceRoot":"","sources":["../../../../../src/aws/compute/tasks/eventbridge/put-events.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from \"constructs\";\nimport * as compute from \"../../\";\nimport { ArnFormat } from \"../../../arn\";\nimport { AwsStack } from \"../../../aws-stack\";\nimport * as iam from \"../../../iam\";\nimport * as notify from \"../../../notify\";\nimport {\n  integrationResourceArn,\n  validatePatternSupported,\n} from \"../private/task-utils\";\n\n/**\n * An entry to be sent to EventBridge\n *\n * @see https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEventsRequestEntry.html\n */\nexport interface EventBridgePutEventsEntry {\n  /**\n   * The event body\n   *\n   * Can either be provided as an object or as a JSON-serialized string\n   * @example\n   *\n   * compute.TaskInput.fromText('{\"instance-id\": \"i-1234567890abcdef0\", \"state\": \"terminated\"}');\n   * compute.TaskInput.fromObject({ Message: 'Hello from Step Functions' });\n   * compute.TaskInput.fromJsonPathAt('$.EventDetail');\n   */\n  readonly detail: compute.TaskInput;\n\n  /**\n   * Used along with the source field to help identify the fields and values expected in the detail field\n   *\n   * For example, events by CloudTrail have detail type \"AWS API Call via CloudTrail\"\n   * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-events.html\n   */\n  readonly detailType: string;\n\n  /**\n   * The event bus the entry will be sent to.\n   *\n   * @default - event is sent to account's default event bus\n   */\n  readonly eventBus?: notify.IEventBus;\n\n  /**\n   * The service or application that caused this event to be generated\n   *\n   * Example value: `com.example.service`\n   *\n   * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-events.html\n   */\n  readonly source: string;\n}\n\n/**\n * Properties for sending events with PutEvents\n */\nexport interface EventBridgePutEventsProps extends compute.TaskStateBaseProps {\n  /**\n   * The entries that will be sent. Minimum number of entries is 1 and maximum is 10,\n   * unless [PutEvents API limit](https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEvents.html#API_PutEvents_RequestSyntax) has changed.\n   */\n  readonly entries: EventBridgePutEventsEntry[];\n}\n\n/**\n * A StepFunctions Task to send events to an EventBridge event bus\n */\nexport class EventBridgePutEvents 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?: sfn.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: EventBridgePutEventsProps,\n  ) {\n    super(scope, id, props);\n\n    this.integrationPattern =\n      props.integrationPattern ?? compute.IntegrationPattern.REQUEST_RESPONSE;\n\n    validatePatternSupported(\n      this.integrationPattern,\n      EventBridgePutEvents.SUPPORTED_INTEGRATION_PATTERNS,\n    );\n\n    if (\n      this.integrationPattern === compute.IntegrationPattern.WAIT_FOR_TASK_TOKEN\n    ) {\n      if (\n        !compute.FieldUtils.containsTaskToken(\n          props.entries.map((entry) => entry.detail),\n        )\n      ) {\n        throw new Error(\n          \"Task Token is required in `entries`. Use JsonPath.taskToken to set the token.\",\n        );\n      }\n    }\n\n    this.validateEntries();\n\n    this.taskPolicies = [\n      new iam.PolicyStatement({\n        actions: [\"events:PutEvents\"],\n        resources: this.eventBusArns,\n      }),\n    ];\n  }\n\n  /**\n   * Returns an array of EventBusArn strings based on this.props.entries\n   */\n  private get eventBusArns(): string[] {\n    return this.props.entries.map((entry) => {\n      if (entry.eventBus) {\n        // If an eventBus is provided, use the corresponding ARN\n        return entry.eventBus.eventBusArn;\n      } else {\n        // If neither an eventBus nor eventBusName is provided,\n        // format the ARN for the default event bus in the account.\n        return AwsStack.ofAwsConstruct(this).formatArn({\n          resource: \"event-bus\",\n          resourceName: \"default\",\n          arnFormat: ArnFormat.SLASH_RESOURCE_NAME,\n          service: \"events\",\n        });\n      }\n    });\n  }\n\n  /**\n   * Provides the EventBridge put events service integration task configuration\n   * @internal\n   */\n  protected _renderTask(): any {\n    return {\n      Resource: integrationResourceArn(\n        this,\n        \"events\",\n        \"putEvents\",\n        this.integrationPattern,\n      ),\n      Parameters: compute.FieldUtils.renderObject({\n        Entries: this.renderEntries(),\n      }),\n    };\n  }\n\n  private renderEntries(): Object[] {\n    // we should have validated all entries in validateEntries()\n    return this.props.entries.map((entry) => {\n      return {\n        Detail: entry.detail?.value,\n        DetailType: entry.detailType,\n        EventBusName: entry.eventBus?.eventBusArn,\n        Source: entry.source,\n      };\n    });\n  }\n\n  private validateEntries(): void {\n    if (this.props.entries.length <= 0) {\n      throw new Error(\n        \"Value for property `entries` must be a non-empty array.\",\n      );\n    }\n    if (this.props.entries.some((e) => e.source.startsWith(\"aws.\"))) {\n      throw new Error('Event source cannot start with \"aws.\"');\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,104 @@
+import { Construct } from "constructs";
+import * as compute from "../../";
+import * as iam from "../../../iam";
+import * as notify from "../../../notify";
+/**
+ * The style used when applying URL encoding to array values.
+ */
+export declare enum URLEncodingFormat {
+    /**
+     * Encode arrays using brackets. For example, {'array': ['a','b','c']} encodes to 'array[]=a&array[]=b&array[]=c'
+     */
+    BRACKETS = "BRACKETS",
+    /**
+     * Encode arrays using commas. For example, {'array': ['a','b','c']} encodes to 'array=a,b,c,d'
+     */
+    COMMAS = "COMMAS",
+    /**
+     * Apply the default URL encoding style (INDICES).
+     */
+    DEFAULT = "DEFAULT",
+    /**
+     * Encode arrays using the index value. For example, {'array': ['a','b','c']} encodes to 'array[0]=a&array[1]=b&array[2]=c'
+     */
+    INDICES = "INDICES",
+    /**
+     * Do not apply URL encoding.
+     */
+    NONE = "NONE",
+    /**
+     * Repeat key for each item in the array. For example, {'array': ['a','b','c']} encodes to 'array[]=a&array[]=b&array[]=c'
+     */
+    REPEAT = "REPEAT"
+}
+/**
+ * Properties for calling an external HTTP endpoint with HttpInvoke.
+ */
+export interface HttpInvokeProps extends compute.TaskStateBaseProps {
+    /**
+     * Permissions are granted to call all resources under this path.
+     *
+     * @example 'https://api.example.com'
+     */
+    readonly apiRoot: string;
+    /**
+     * The API endpoint to call, relative to `apiRoot`.
+     * @example compute.TaskInput.fromText('path/to/resource')
+     */
+    readonly apiEndpoint: compute.TaskInput;
+    /**
+     * The HTTP method to use.
+     *
+     * @example compute.TaskInput.fromText('GET')
+     */
+    readonly method: compute.TaskInput;
+    /**
+     * The EventBridge Connection to use for authentication.
+     */
+    readonly connection: notify.IConnection;
+    /**
+     * The body to send to the HTTP endpoint.
+     *
+     * @default - No body is sent with the request.
+     */
+    readonly body?: compute.TaskInput;
+    /**
+     * The headers to send to the HTTP endpoint.
+     *
+     * @example compute.TaskInput.fromObject({ 'Content-Type': 'application/json' })
+     *
+     * @default - No additional headers are added to the request.
+     */
+    readonly headers?: compute.TaskInput;
+    /**
+     * The query string parameters to send to the HTTP endpoint.
+     * @default - No query string parameters are sent in the request.
+     */
+    readonly queryStringParameters?: compute.TaskInput;
+    /**
+     * Determines whether to apply URL encoding to the request body, and which array encoding format to use.
+     *
+     * `URLEncodingFormat.NONE` passes the JSON-serialized `RequestBody` field as the HTTP request body.
+     * Otherwise, the HTTP request body is the URL-encoded form data of the `RequestBody` field using the
+     * specified array encoding format, and the `Content-Type` header is set to `application/x-www-form-urlencoded`.
+     *
+     * @default - URLEncodingFormat.NONE
+     */
+    readonly urlEncodingFormat?: URLEncodingFormat;
+}
+/**
+ * A Step Functions Task to call a public third-party API.
+ */
+export declare class HttpInvoke extends compute.TaskStateBase {
+    private readonly props;
+    protected readonly taskPolicies?: iam.PolicyStatement[];
+    constructor(scope: Construct, id: string, props: HttpInvokeProps);
+    /**
+     * Provides the HTTP Invoke service integration task configuration.
+     *
+     * @internal
+     */
+    protected _renderTask(): any;
+    protected buildTaskPolicyStatements(): iam.PolicyStatement[];
+    private buildTaskParameters;
+}

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

@@ -0,0 +1,117 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpInvoke = exports.URLEncodingFormat = 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");
+/**
+ * The style used when applying URL encoding to array values.
+ */
+var URLEncodingFormat;
+(function (URLEncodingFormat) {
+    /**
+     * Encode arrays using brackets. For example, {'array': ['a','b','c']} encodes to 'array[]=a&array[]=b&array[]=c'
+     */
+    URLEncodingFormat["BRACKETS"] = "BRACKETS";
+    /**
+     * Encode arrays using commas. For example, {'array': ['a','b','c']} encodes to 'array=a,b,c,d'
+     */
+    URLEncodingFormat["COMMAS"] = "COMMAS";
+    /**
+     * Apply the default URL encoding style (INDICES).
+     */
+    URLEncodingFormat["DEFAULT"] = "DEFAULT";
+    /**
+     * Encode arrays using the index value. For example, {'array': ['a','b','c']} encodes to 'array[0]=a&array[1]=b&array[2]=c'
+     */
+    URLEncodingFormat["INDICES"] = "INDICES";
+    /**
+     * Do not apply URL encoding.
+     */
+    URLEncodingFormat["NONE"] = "NONE";
+    /**
+     * Repeat key for each item in the array. For example, {'array': ['a','b','c']} encodes to 'array[]=a&array[]=b&array[]=c'
+     */
+    URLEncodingFormat["REPEAT"] = "REPEAT";
+})(URLEncodingFormat || (exports.URLEncodingFormat = URLEncodingFormat = {}));
+/**
+ * A Step Functions Task to call a public third-party API.
+ */
+class HttpInvoke extends compute.TaskStateBase {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.props = props;
+        this.taskPolicies = this.buildTaskPolicyStatements();
+    }
+    /**
+     * Provides the HTTP Invoke service integration task configuration.
+     *
+     * @internal
+     */
+    _renderTask() {
+        return {
+            Resource: (0, task_utils_1.integrationResourceArn)(this, "http", "invoke"),
+            Parameters: compute.FieldUtils.renderObject(this.buildTaskParameters()),
+        };
+    }
+    buildTaskPolicyStatements() {
+        return [
+            new iam.PolicyStatement({
+                actions: ["events:RetrieveConnectionCredentials"],
+                resources: [this.props.connection.connectionArn],
+            }),
+            new iam.PolicyStatement({
+                actions: [
+                    "secretsmanager:GetSecretValue",
+                    "secretsmanager:DescribeSecret",
+                ],
+                resources: [this.props.connection.connectionSecretArn],
+            }),
+            new iam.PolicyStatement({
+                actions: ["states:InvokeHTTPEndpoint"],
+                resources: ["*"],
+                condition: [
+                    {
+                        test: "StringLike",
+                        variable: "states:HTTPEndpoint",
+                        values: [`${this.props.apiRoot}*`],
+                    },
+                ],
+            }),
+        ];
+    }
+    buildTaskParameters() {
+        const parameters = {
+            ApiEndpoint: `${this.props.apiRoot}/${this.props.apiEndpoint.value}`,
+            Authentication: {
+                ConnectionArn: this.props.connection.connectionArn,
+            },
+            Method: this.props.method.value,
+            Headers: this.props.headers?.value,
+            RequestBody: this.props.body?.value,
+            QueryParameters: this.props.queryStringParameters?.value,
+        };
+        if (this.props.urlEncodingFormat != null &&
+            this.props.urlEncodingFormat !== URLEncodingFormat.NONE) {
+            parameters.Headers = {
+                ...parameters.Headers,
+                "Content-Type": "application/x-www-form-urlencoded",
+            };
+            parameters.Transform = {
+                RequestBodyEncoding: "URL_ENCODED",
+            };
+            if (this.props.urlEncodingFormat !== URLEncodingFormat.DEFAULT) {
+                parameters.Transform.RequestEncodingOptions = {
+                    ArrayFormat: this.props.urlEncodingFormat,
+                };
+            }
+        }
+        return parameters;
+    }
+}
+exports.HttpInvoke = HttpInvoke;
+_a = JSII_RTTI_SYMBOL_1;
+HttpInvoke[_a] = { fqn: "terraconstructs.aws.compute.tasks.HttpInvoke", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"invoke.js","sourceRoot":"","sources":["../../../../../src/aws/compute/tasks/http/invoke.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from \"constructs\";\nimport * as compute from \"../../\";\nimport * as iam from \"../../../iam\";\nimport * as notify from \"../../../notify\";\nimport { integrationResourceArn } from \"../private/task-utils\";\n\n/**\n * The style used when applying URL encoding to array values.\n */\nexport enum URLEncodingFormat {\n  /**\n   * Encode arrays using brackets. For example, {'array': ['a','b','c']} encodes to 'array[]=a&array[]=b&array[]=c'\n   */\n  BRACKETS = \"BRACKETS\",\n  /**\n   * Encode arrays using commas. For example, {'array': ['a','b','c']} encodes to 'array=a,b,c,d'\n   */\n  COMMAS = \"COMMAS\",\n  /**\n   * Apply the default URL encoding style (INDICES).\n   */\n  DEFAULT = \"DEFAULT\",\n  /**\n   * Encode arrays using the index value. For example, {'array': ['a','b','c']} encodes to 'array[0]=a&array[1]=b&array[2]=c'\n   */\n  INDICES = \"INDICES\",\n  /**\n   * Do not apply URL encoding.\n   */\n  NONE = \"NONE\",\n  /**\n   * Repeat key for each item in the array. For example, {'array': ['a','b','c']} encodes to 'array[]=a&array[]=b&array[]=c'\n   */\n  REPEAT = \"REPEAT\",\n}\n\n/**\n * The StepFunctions parameters for the http:invoke task.\n */\ninterface TaskParameters {\n  ApiEndpoint: string;\n  Authentication: {\n    ConnectionArn: string;\n  };\n  Method: string;\n  Headers?: { [key: string]: string };\n  RequestBody?: string;\n  QueryParameters?: { [key: string]: string };\n  Transform?: {\n    RequestBodyEncoding: string;\n    RequestEncodingOptions?: {\n      ArrayFormat: string;\n    };\n  };\n}\n\n/**\n * Properties for calling an external HTTP endpoint with HttpInvoke.\n */\nexport interface HttpInvokeProps extends compute.TaskStateBaseProps {\n  /**\n   * Permissions are granted to call all resources under this path.\n   *\n   * @example 'https://api.example.com'\n   */\n  readonly apiRoot: string;\n\n  /**\n   * The API endpoint to call, relative to `apiRoot`.\n   * @example compute.TaskInput.fromText('path/to/resource')\n   */\n  readonly apiEndpoint: compute.TaskInput;\n\n  /**\n   * The HTTP method to use.\n   *\n   * @example compute.TaskInput.fromText('GET')\n   */\n  readonly method: compute.TaskInput;\n\n  /**\n   * The EventBridge Connection to use for authentication.\n   */\n  readonly connection: notify.IConnection;\n\n  /**\n   * The body to send to the HTTP endpoint.\n   *\n   * @default - No body is sent with the request.\n   */\n  readonly body?: compute.TaskInput;\n\n  /**\n   * The headers to send to the HTTP endpoint.\n   *\n   * @example compute.TaskInput.fromObject({ 'Content-Type': 'application/json' })\n   *\n   * @default - No additional headers are added to the request.\n   */\n  readonly headers?: compute.TaskInput;\n\n  /**\n   * The query string parameters to send to the HTTP endpoint.\n   * @default - No query string parameters are sent in the request.\n   */\n  readonly queryStringParameters?: compute.TaskInput;\n\n  /**\n   * Determines whether to apply URL encoding to the request body, and which array encoding format to use.\n   *\n   * `URLEncodingFormat.NONE` passes the JSON-serialized `RequestBody` field as the HTTP request body.\n   * Otherwise, the HTTP request body is the URL-encoded form data of the `RequestBody` field using the\n   * specified array encoding format, and the `Content-Type` header is set to `application/x-www-form-urlencoded`.\n   *\n   * @default - URLEncodingFormat.NONE\n   */\n  readonly urlEncodingFormat?: URLEncodingFormat;\n}\n\n/**\n * A Step Functions Task to call a public third-party API.\n */\nexport class HttpInvoke extends compute.TaskStateBase {\n  // protected readonly taskMetrics?: compute.TaskMetricsConfig;\n  protected readonly taskPolicies?: iam.PolicyStatement[];\n\n  constructor(\n    scope: Construct,\n    id: string,\n    private readonly props: HttpInvokeProps,\n  ) {\n    super(scope, id, props);\n\n    this.taskPolicies = this.buildTaskPolicyStatements();\n  }\n\n  /**\n   * Provides the HTTP Invoke service integration task configuration.\n   *\n   * @internal\n   */\n  protected _renderTask(): any {\n    return {\n      Resource: integrationResourceArn(this, \"http\", \"invoke\"),\n      Parameters: compute.FieldUtils.renderObject(this.buildTaskParameters()),\n    };\n  }\n\n  protected buildTaskPolicyStatements(): iam.PolicyStatement[] {\n    return [\n      new iam.PolicyStatement({\n        actions: [\"events:RetrieveConnectionCredentials\"],\n        resources: [this.props.connection.connectionArn],\n      }),\n      new iam.PolicyStatement({\n        actions: [\n          \"secretsmanager:GetSecretValue\",\n          \"secretsmanager:DescribeSecret\",\n        ],\n        resources: [this.props.connection.connectionSecretArn],\n      }),\n      new iam.PolicyStatement({\n        actions: [\"states:InvokeHTTPEndpoint\"],\n        resources: [\"*\"],\n        condition: [\n          {\n            test: \"StringLike\",\n            variable: \"states:HTTPEndpoint\",\n            values: [`${this.props.apiRoot}*`],\n          },\n        ],\n      }),\n    ];\n  }\n\n  private buildTaskParameters() {\n    const parameters: TaskParameters = {\n      ApiEndpoint: `${this.props.apiRoot}/${this.props.apiEndpoint.value}`,\n      Authentication: {\n        ConnectionArn: this.props.connection.connectionArn,\n      },\n      Method: this.props.method.value,\n      Headers: this.props.headers?.value,\n      RequestBody: this.props.body?.value,\n      QueryParameters: this.props.queryStringParameters?.value,\n    };\n\n    if (\n      this.props.urlEncodingFormat != null &&\n      this.props.urlEncodingFormat !== URLEncodingFormat.NONE\n    ) {\n      parameters.Headers = {\n        ...parameters.Headers,\n        \"Content-Type\": \"application/x-www-form-urlencoded\",\n      };\n      parameters.Transform = {\n        RequestBodyEncoding: \"URL_ENCODED\",\n      };\n\n      if (this.props.urlEncodingFormat !== URLEncodingFormat.DEFAULT) {\n        parameters.Transform.RequestEncodingOptions = {\n          ArrayFormat: this.props.urlEncodingFormat,\n        };\n      }\n    }\n\n    return parameters;\n  }\n}\n"]}

package/lib/aws/compute/tasks/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./lambda/invoke";
+export * from "./sqs/send-message";
+export * from "./stepfunctions/start-execution";
+export * from "./stepfunctions/invoke-activity";
+export * from "./eventbridge/put-events";
+export * from "./aws-sdk/call-aws-service";
+export * from "./http/invoke";

package/lib/aws/compute/tasks/index.js

@@ -0,0 +1,42 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lambda/invoke"), exports);
+// export * from "./lambda/call-aws-service-cross-region"; // TODO: Re-add after custom resource support
+__exportStar(require("./sqs/send-message"), exports);
+__exportStar(require("./stepfunctions/start-execution"), exports);
+__exportStar(require("./stepfunctions/invoke-activity"), exports);
+__exportStar(require("./eventbridge/put-events"), exports);
+__exportStar(require("./aws-sdk/call-aws-service"), exports);
+__exportStar(require("./http/invoke"), exports);
+// export * from "./ecs/run-ecs-task-base"; // Remove this once we can
+// export * from "./ecs/run-ecs-task-base-types";
+// export * from "./sns/publish-to-topic";
+// export * from "./sns/publish";
+// export * from "./ecs/run-ecs-ec2-task";
+// export * from "./ecs/run-ecs-fargate-task";
+// export * from "./ecs/run-task";
+// export * from "./batch/run-batch-job";
+// export * from "./batch/submit-job";
+// export * from "./dynamodb/get-item";
+// export * from "./dynamodb/put-item";
+// export * from "./dynamodb/update-item";
+// export * from "./dynamodb/delete-item";
+// export * from "./dynamodb/shared-types";
+// export * from "./eks/call";
+// export * from "./apigateway";
+// export * from "./evaluate-expression"; // missing SingletonLambda for this...
+//# sourceMappingURL=data:application/json;base64,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