terraconstructs 0.0.25 → 0.1.1

package/lib/aws/compute/integration.d.ts

@@ -0,0 +1,311 @@
+import { Method } from "./method";
+import { IVpcLink } from "./vpc-link";
+import { Duration } from "../../duration";
+import * as iam from "../iam";
+export interface IntegrationOptions {
+    /**
+     * A list of request parameters whose values are to be cached. It determines
+     * request parameters that will make it into the cache key.
+     */
+    readonly cacheKeyParameters?: string[];
+    /**
+     * An API-specific tag group of related cached parameters.
+     */
+    readonly cacheNamespace?: string;
+    /**
+     * Specifies how to handle request payload content type conversions.
+     *
+     * @default none if this property isn't defined, the request payload is passed
+     * through from the method request to the integration request without
+     * modification, provided that the `passthroughBehaviors` property is
+     * configured to support payload pass-through.
+     */
+    readonly contentHandling?: ContentHandling;
+    /**
+     * An IAM role that API Gateway assumes.
+     *
+     * Mutually exclusive with `credentialsPassThrough`.
+     *
+     * @default A role is not assumed
+     */
+    readonly credentialsRole?: iam.IRole;
+    /**
+     * Requires that the caller's identity be passed through from the request.
+     *
+     * @default Caller identity is not passed through
+     */
+    readonly credentialsPassthrough?: boolean;
+    /**
+     * Specifies the pass-through behavior for incoming requests based on the
+     * Content-Type header in the request, and the available mapping templates
+     * specified as the requestTemplates property on the Integration resource.
+     * There are three valid values: WHEN_NO_MATCH, WHEN_NO_TEMPLATES, and
+     * NEVER.
+     */
+    readonly passthroughBehavior?: PassthroughBehavior;
+    /**
+     * The request parameters that API Gateway sends with the backend request.
+     * Specify request parameters as key-value pairs (string-to-string
+     * mappings), with a destination as the key and a source as the value.
+     *
+     * Specify the destination by using the following pattern
+     * integration.request.location.name, where location is querystring, path,
+     * or header, and name is a valid, unique parameter name.
+     *
+     * The source must be an existing method request parameter or a static
+     * value. You must enclose static values in single quotation marks and
+     * pre-encode these values based on their destination in the request.
+     */
+    readonly requestParameters?: {
+        [dest: string]: string;
+    };
+    /**
+     * A map of Apache Velocity templates that are applied on the request
+     * payload. The template that API Gateway uses is based on the value of the
+     * Content-Type header that's sent by the client. The content type value is
+     * the key, and the template is the value (specified as a string), such as
+     * the following snippet:
+     *
+     * ```
+     *   { "application/json": "{ \"statusCode\": 200 }" }
+     * ```
+     *
+     * @see http://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-mapping-template-reference.html
+     */
+    readonly requestTemplates?: {
+        [contentType: string]: string;
+    };
+    /**
+     * The maximum amount of time an integration will run before it returns without a response.
+     *
+     * By default, the value must be between 50 milliseconds and 29 seconds.
+     * The upper bound can be increased for regional and private Rest APIs only,
+     * via a quota increase request for your acccount.
+     * This increase might require a reduction in your account-level throttle quota limit.
+     *
+     * See {@link https://docs.aws.amazon.com/apigateway/latest/developerguide/limits.html Amazon API Gateway quotas} for more details.
+     *
+     * @default Duration.seconds(29)
+     */
+    readonly timeout?: Duration;
+    /**
+     * The response that API Gateway provides after a method's backend completes
+     * processing a request. API Gateway intercepts the response from the
+     * backend so that you can control how API Gateway surfaces backend
+     * responses. For example, you can map the backend status codes to codes
+     * that you define.
+     */
+    readonly integrationResponses?: IntegrationResponse[];
+    /**
+     * The type of network connection to the integration endpoint.
+     * @default - ConnectionType.VPC_LINK if `vpcLink` property is configured; ConnectionType.Internet otherwise.
+     */
+    readonly connectionType?: ConnectionType;
+    /**
+     * The VpcLink used for the integration.
+     * Required if connectionType is VPC_LINK
+     */
+    readonly vpcLink?: IVpcLink;
+}
+export interface IntegrationProps {
+    /**
+     * Specifies an API method integration type.
+     */
+    readonly type: IntegrationType;
+    /**
+     * The Uniform Resource Identifier (URI) for the integration.
+     *
+     * - If you specify HTTP for the `type` property, specify the API endpoint URL.
+     * - If you specify MOCK for the `type` property, don't specify this property.
+     * - If you specify AWS for the `type` property, specify an AWS service that
+     *   follows this form: `arn:partition:apigateway:region:subdomain.service|service:path|action/service_api.`
+     *   For example, a Lambda function URI follows this form:
+     *   arn:partition:apigateway:region:lambda:path/path. The path is usually in the
+     *   form /2015-03-31/functions/LambdaFunctionARN/invocations.
+     *
+     * @see https://docs.aws.amazon.com/apigateway/api-reference/resource/integration/#uri
+     */
+    readonly uri?: any;
+    /**
+     * The integration's HTTP method type.
+     * Required unless you use a MOCK integration.
+     */
+    readonly integrationHttpMethod?: string;
+    /**
+     * Integration options.
+     */
+    readonly options?: IntegrationOptions;
+}
+/**
+ * Result of binding an Integration to a Method.
+ */
+export interface IntegrationConfig {
+    /**
+     * Integration options.
+     * @default - no integration options
+     */
+    readonly options?: IntegrationOptions;
+    /**
+     * Specifies an API method integration type.
+     */
+    readonly type: IntegrationType;
+    /**
+     * The Uniform Resource Identifier (URI) for the integration.
+     * @see https://docs.aws.amazon.com/apigateway/api-reference/resource/integration/#uri
+     * @default - no URI. Usually applies to MOCK integration
+     */
+    readonly uri?: string;
+    /**
+     * The integration's HTTP method type.
+     * Required unless you use a MOCK integration.
+     *
+     * @default - no integration method specified.
+     */
+    readonly integrationHttpMethod?: string;
+    /**
+     * This value is included in computing the Deployment's fingerprint. When the fingerprint
+     * changes, a new deployment is triggered.
+     * This property should contain values associated with the Integration that upon changing
+     * should trigger a fresh the Deployment needs to be refreshed.
+     * @default undefined deployments are not triggered for any change to this integration.
+     */
+    readonly deploymentToken?: string;
+}
+/**
+ * Base class for backend integrations for an API Gateway method.
+ *
+ * Use one of the concrete classes such as `MockIntegration`, `AwsIntegration`, `LambdaIntegration`
+ * or implement on your own by specifying the set of props.
+ */
+export declare class Integration {
+    private readonly props;
+    constructor(props: IntegrationProps);
+    /**
+     * Can be overridden by subclasses to allow the integration to interact with the method
+     * being integrated, access the REST API object, method ARNs, etc.
+     */
+    bind(method: Method): IntegrationConfig;
+}
+export declare enum ContentHandling {
+    /**
+     * Converts a request payload from a base64-encoded string to a binary blob.
+     */
+    CONVERT_TO_BINARY = "CONVERT_TO_BINARY",
+    /**
+     * Converts a request payload from a binary blob to a base64-encoded string.
+     */
+    CONVERT_TO_TEXT = "CONVERT_TO_TEXT"
+}
+export declare enum IntegrationType {
+    /**
+     * For integrating the API method request with an AWS service action,
+     * including the Lambda function-invoking action. With the Lambda
+     * function-invoking action, this is referred to as the Lambda custom
+     * integration. With any other AWS service action, this is known as AWS
+     * integration.
+     */
+    AWS = "AWS",
+    /**
+     * For integrating the API method request with the Lambda function-invoking
+     * action with the client request passed through as-is. This integration is
+     * also referred to as the Lambda proxy integration
+     */
+    AWS_PROXY = "AWS_PROXY",
+    /**
+     * For integrating the API method request with an HTTP endpoint, including a
+     * private HTTP endpoint within a VPC. This integration is also referred to
+     * as the HTTP custom integration.
+     */
+    HTTP = "HTTP",
+    /**
+     * For integrating the API method request with an HTTP endpoint, including a
+     * private HTTP endpoint within a VPC, with the client request passed
+     * through as-is. This is also referred to as the HTTP proxy integration
+     */
+    HTTP_PROXY = "HTTP_PROXY",
+    /**
+     * For integrating the API method request with API Gateway as a "loop-back"
+     * endpoint without invoking any backend.
+     */
+    MOCK = "MOCK"
+}
+export declare enum PassthroughBehavior {
+    /**
+     * Passes the request body for unmapped content types through to the
+     * integration back end without transformation.
+     */
+    WHEN_NO_MATCH = "WHEN_NO_MATCH",
+    /**
+     * Rejects unmapped content types with an HTTP 415 'Unsupported Media Type'
+     * response
+     */
+    NEVER = "NEVER",
+    /**
+     * Allows pass-through when the integration has NO content types mapped to
+     * templates. However if there is at least one content type defined,
+     * unmapped content types will be rejected with the same 415 response.
+     */
+    WHEN_NO_TEMPLATES = "WHEN_NO_TEMPLATES"
+}
+export declare enum ConnectionType {
+    /**
+     * For connections through the public routable internet
+     */
+    INTERNET = "INTERNET",
+    /**
+     * For private connections between API Gateway and a network load balancer in a VPC
+     */
+    VPC_LINK = "VPC_LINK"
+}
+export interface IntegrationResponse {
+    /**
+     * Specifies the regular expression (regex) pattern used to choose an integration response based on the response from
+     * the back end. For example, if the success response returns nothing and the error response returns some string, you
+     * could use the ``.+`` regex to match error response. However, make sure that the error response does not contain any
+     * newline (``\n``) character in such cases. If the back end is an AWS Lambda function, the AWS Lambda function error
+     * header is matched. For all other HTTP and AWS back ends, the HTTP status code is matched.
+     *
+     * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-integration-settings-integration-response.html
+     */
+    readonly selectionPattern?: string;
+    /**
+     * The status code that API Gateway uses to map the integration response to
+     * a MethodResponse status code.
+     */
+    readonly statusCode: string;
+    /**
+     * Specifies how to handle request payload content type conversions.
+     *
+     * @default none the request payload is passed through from the method
+     * request to the integration request without modification.
+     */
+    readonly contentHandling?: ContentHandling;
+    /**
+     * The response parameters from the backend response that API Gateway sends
+     * to the method response.
+     *
+     * Use the destination as the key and the source as the value:
+     *
+     * - The destination must be an existing response parameter in the
+     *   MethodResponse property.
+     * - The source must be an existing method request parameter or a static
+     *   value. You must enclose static values in single quotation marks and
+     *   pre-encode these values based on the destination specified in the
+     *   request.
+     *
+     * @see http://docs.aws.amazon.com/apigateway/latest/developerguide/request-response-data-mappings.html
+     */
+    readonly responseParameters?: {
+        [destination: string]: string;
+    };
+    /**
+     * The templates that are used to transform the integration response body.
+     * Specify templates as key-value pairs, with a content type as the key and
+     * a template as the value.
+     *
+     * @see http://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-mapping-template-reference.html
+     */
+    readonly responseTemplates?: {
+        [contentType: string]: string;
+    };
+}

package/lib/aws/compute/integration.js

@@ -0,0 +1,165 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionType = exports.PassthroughBehavior = exports.IntegrationType = exports.ContentHandling = exports.Integration = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdktf_1 = require("cdktf");
+const vpc_link_1 = require("./vpc-link");
+/**
+ * Base class for backend integrations for an API Gateway method.
+ *
+ * Use one of the concrete classes such as `MockIntegration`, `AwsIntegration`, `LambdaIntegration`
+ * or implement on your own by specifying the set of props.
+ */
+class Integration {
+    constructor(props) {
+        this.props = props;
+        const options = this.props.options || {};
+        if (options.credentialsPassthrough !== undefined &&
+            options.credentialsRole !== undefined) {
+            // throw new UnscopedValidationError(
+            throw new Error("'credentialsPassthrough' and 'credentialsRole' are mutually exclusive");
+        }
+        if (options.connectionType === ConnectionType.VPC_LINK &&
+            options.vpcLink === undefined) {
+            // throw new UnscopedValidationError(
+            throw new Error("'connectionType' of VPC_LINK requires 'vpcLink' prop to be set");
+        }
+        if (options.connectionType === ConnectionType.INTERNET &&
+            options.vpcLink !== undefined) {
+            // throw new UnscopedValidationError(
+            throw new Error("cannot set 'vpcLink' where 'connectionType' is INTERNET");
+        }
+        if (options.timeout &&
+            !options.timeout.isUnresolved() &&
+            options.timeout.toMilliseconds() < 50) {
+            // throw new UnscopedValidationError(
+            throw new Error("Integration timeout must be greater than 50 milliseconds.");
+        }
+        if (props.type !== IntegrationType.MOCK && !props.integrationHttpMethod) {
+            // throw new UnscopedValidationError(
+            throw new Error("integrationHttpMethod is required for non-mock integration types.");
+        }
+    }
+    /**
+     * Can be overridden by subclasses to allow the integration to interact with the method
+     * being integrated, access the REST API object, method ARNs, etc.
+     */
+    bind(method) {
+        let uri = this.props.uri;
+        const options = this.props.options;
+        if (options?.connectionType === ConnectionType.VPC_LINK &&
+            uri === undefined) {
+            uri = cdktf_1.Lazy.stringValue({
+                // needs to be a lazy since the targets can be added to the VpcLink construct after initialization.
+                produce: () => {
+                    const vpcLink = options.vpcLink;
+                    if (vpcLink instanceof vpc_link_1.VpcLink) {
+                        const targets = vpcLink._targetDnsNames;
+                        if (targets.length > 1) {
+                            // throw new ValidationError(
+                            throw new Error(`'uri' is required when there are more than one NLBs in the VPC Link (${method.node.path})`);
+                        }
+                        else {
+                            return `http://${targets[0]}`;
+                        }
+                    }
+                    else {
+                        // throw new ValidationError(
+                        throw new Error(`'uri' is required when the 'connectionType' is VPC_LINK (${method.node.path})`);
+                    }
+                },
+            });
+        }
+        return {
+            options: {
+                ...options,
+                connectionType: options?.vpcLink
+                    ? ConnectionType.VPC_LINK
+                    : options?.connectionType,
+            },
+            type: this.props.type,
+            uri,
+            integrationHttpMethod: this.props.integrationHttpMethod,
+        };
+    }
+}
+exports.Integration = Integration;
+_a = JSII_RTTI_SYMBOL_1;
+Integration[_a] = { fqn: "terraconstructs.aws.compute.Integration", version: "0.1.1" };
+var ContentHandling;
+(function (ContentHandling) {
+    /**
+     * Converts a request payload from a base64-encoded string to a binary blob.
+     */
+    ContentHandling["CONVERT_TO_BINARY"] = "CONVERT_TO_BINARY";
+    /**
+     * Converts a request payload from a binary blob to a base64-encoded string.
+     */
+    ContentHandling["CONVERT_TO_TEXT"] = "CONVERT_TO_TEXT";
+})(ContentHandling || (exports.ContentHandling = ContentHandling = {}));
+var IntegrationType;
+(function (IntegrationType) {
+    /**
+     * For integrating the API method request with an AWS service action,
+     * including the Lambda function-invoking action. With the Lambda
+     * function-invoking action, this is referred to as the Lambda custom
+     * integration. With any other AWS service action, this is known as AWS
+     * integration.
+     */
+    IntegrationType["AWS"] = "AWS";
+    /**
+     * For integrating the API method request with the Lambda function-invoking
+     * action with the client request passed through as-is. This integration is
+     * also referred to as the Lambda proxy integration
+     */
+    IntegrationType["AWS_PROXY"] = "AWS_PROXY";
+    /**
+     * For integrating the API method request with an HTTP endpoint, including a
+     * private HTTP endpoint within a VPC. This integration is also referred to
+     * as the HTTP custom integration.
+     */
+    IntegrationType["HTTP"] = "HTTP";
+    /**
+     * For integrating the API method request with an HTTP endpoint, including a
+     * private HTTP endpoint within a VPC, with the client request passed
+     * through as-is. This is also referred to as the HTTP proxy integration
+     */
+    IntegrationType["HTTP_PROXY"] = "HTTP_PROXY";
+    /**
+     * For integrating the API method request with API Gateway as a "loop-back"
+     * endpoint without invoking any backend.
+     */
+    IntegrationType["MOCK"] = "MOCK";
+})(IntegrationType || (exports.IntegrationType = IntegrationType = {}));
+var PassthroughBehavior;
+(function (PassthroughBehavior) {
+    /**
+     * Passes the request body for unmapped content types through to the
+     * integration back end without transformation.
+     */
+    PassthroughBehavior["WHEN_NO_MATCH"] = "WHEN_NO_MATCH";
+    /**
+     * Rejects unmapped content types with an HTTP 415 'Unsupported Media Type'
+     * response
+     */
+    PassthroughBehavior["NEVER"] = "NEVER";
+    /**
+     * Allows pass-through when the integration has NO content types mapped to
+     * templates. However if there is at least one content type defined,
+     * unmapped content types will be rejected with the same 415 response.
+     */
+    PassthroughBehavior["WHEN_NO_TEMPLATES"] = "WHEN_NO_TEMPLATES";
+})(PassthroughBehavior || (exports.PassthroughBehavior = PassthroughBehavior = {}));
+var ConnectionType;
+(function (ConnectionType) {
+    /**
+     * For connections through the public routable internet
+     */
+    ConnectionType["INTERNET"] = "INTERNET";
+    /**
+     * For private connections between API Gateway and a network load balancer in a VPC
+     */
+    ConnectionType["VPC_LINK"] = "VPC_LINK";
+})(ConnectionType || (exports.ConnectionType = ConnectionType = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"integration.js","sourceRoot":"","sources":["../../../src/aws/compute/integration.ts"],"names":[],"mappings":"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","sourcesContent":["import { Lazy } from \"cdktf\";\nimport { Method } from \"./method\";\nimport { IVpcLink, VpcLink } from \"./vpc-link\";\nimport { Duration } from \"../../duration\";\nimport * as iam from \"../iam\";\n// TODO: Adopt UnscopedValidationError\n// - https://github.com/aws/aws-cdk/pull/33382/\n// - https://github.com/aws/aws-cdk/pull/33045\n// import {\n//   UnscopedValidationError,\n//   ValidationError,\n// } from \"../../core/lib/errors\";\n\nexport interface IntegrationOptions {\n  /**\n   * A list of request parameters whose values are to be cached. It determines\n   * request parameters that will make it into the cache key.\n   */\n  readonly cacheKeyParameters?: string[];\n\n  /**\n   * An API-specific tag group of related cached parameters.\n   */\n  readonly cacheNamespace?: string;\n\n  /**\n   * Specifies how to handle request payload content type conversions.\n   *\n   * @default none if this property isn't defined, the request payload is passed\n   * through from the method request to the integration request without\n   * modification, provided that the `passthroughBehaviors` property is\n   * configured to support payload pass-through.\n   */\n  readonly contentHandling?: ContentHandling;\n\n  /**\n   * An IAM role that API Gateway assumes.\n   *\n   * Mutually exclusive with `credentialsPassThrough`.\n   *\n   * @default A role is not assumed\n   */\n  readonly credentialsRole?: iam.IRole;\n\n  /**\n   * Requires that the caller's identity be passed through from the request.\n   *\n   * @default Caller identity is not passed through\n   */\n  readonly credentialsPassthrough?: boolean;\n\n  /**\n   * Specifies the pass-through behavior for incoming requests based on the\n   * Content-Type header in the request, and the available mapping templates\n   * specified as the requestTemplates property on the Integration resource.\n   * There are three valid values: WHEN_NO_MATCH, WHEN_NO_TEMPLATES, and\n   * NEVER.\n   */\n  readonly passthroughBehavior?: PassthroughBehavior;\n\n  /**\n   * The request parameters that API Gateway sends with the backend request.\n   * Specify request parameters as key-value pairs (string-to-string\n   * mappings), with a destination as the key and a source as the value.\n   *\n   * Specify the destination by using the following pattern\n   * integration.request.location.name, where location is querystring, path,\n   * or header, and name is a valid, unique parameter name.\n   *\n   * The source must be an existing method request parameter or a static\n   * value. You must enclose static values in single quotation marks and\n   * pre-encode these values based on their destination in the request.\n   */\n  readonly requestParameters?: { [dest: string]: string };\n\n  /**\n   * A map of Apache Velocity templates that are applied on the request\n   * payload. The template that API Gateway uses is based on the value of the\n   * Content-Type header that's sent by the client. The content type value is\n   * the key, and the template is the value (specified as a string), such as\n   * the following snippet:\n   *\n   * ```\n   *   { \"application/json\": \"{ \\\"statusCode\\\": 200 }\" }\n   * ```\n   *\n   * @see http://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-mapping-template-reference.html\n   */\n  readonly requestTemplates?: { [contentType: string]: string };\n\n  /**\n   * The maximum amount of time an integration will run before it returns without a response.\n   *\n   * By default, the value must be between 50 milliseconds and 29 seconds.\n   * The upper bound can be increased for regional and private Rest APIs only,\n   * via a quota increase request for your acccount.\n   * This increase might require a reduction in your account-level throttle quota limit.\n   *\n   * See {@link https://docs.aws.amazon.com/apigateway/latest/developerguide/limits.html Amazon API Gateway quotas} for more details.\n   *\n   * @default Duration.seconds(29)\n   */\n  readonly timeout?: Duration;\n\n  /**\n   * The response that API Gateway provides after a method's backend completes\n   * processing a request. API Gateway intercepts the response from the\n   * backend so that you can control how API Gateway surfaces backend\n   * responses. For example, you can map the backend status codes to codes\n   * that you define.\n   */\n  readonly integrationResponses?: IntegrationResponse[];\n\n  /**\n   * The type of network connection to the integration endpoint.\n   * @default - ConnectionType.VPC_LINK if `vpcLink` property is configured; ConnectionType.Internet otherwise.\n   */\n  readonly connectionType?: ConnectionType;\n\n  /**\n   * The VpcLink used for the integration.\n   * Required if connectionType is VPC_LINK\n   */\n  readonly vpcLink?: IVpcLink;\n}\n\nexport interface IntegrationProps {\n  /**\n   * Specifies an API method integration type.\n   */\n  readonly type: IntegrationType;\n\n  /**\n   * The Uniform Resource Identifier (URI) for the integration.\n   *\n   * - If you specify HTTP for the `type` property, specify the API endpoint URL.\n   * - If you specify MOCK for the `type` property, don't specify this property.\n   * - If you specify AWS for the `type` property, specify an AWS service that\n   *   follows this form: `arn:partition:apigateway:region:subdomain.service|service:path|action/service_api.`\n   *   For example, a Lambda function URI follows this form:\n   *   arn:partition:apigateway:region:lambda:path/path. The path is usually in the\n   *   form /2015-03-31/functions/LambdaFunctionARN/invocations.\n   *\n   * @see https://docs.aws.amazon.com/apigateway/api-reference/resource/integration/#uri\n   */\n  readonly uri?: any;\n\n  /**\n   * The integration's HTTP method type.\n   * Required unless you use a MOCK integration.\n   */\n  readonly integrationHttpMethod?: string;\n\n  /**\n   * Integration options.\n   */\n  readonly options?: IntegrationOptions;\n}\n\n/**\n * Result of binding an Integration to a Method.\n */\nexport interface IntegrationConfig {\n  /**\n   * Integration options.\n   * @default - no integration options\n   */\n  readonly options?: IntegrationOptions;\n\n  /**\n   * Specifies an API method integration type.\n   */\n  readonly type: IntegrationType;\n\n  /**\n   * The Uniform Resource Identifier (URI) for the integration.\n   * @see https://docs.aws.amazon.com/apigateway/api-reference/resource/integration/#uri\n   * @default - no URI. Usually applies to MOCK integration\n   */\n  readonly uri?: string;\n\n  /**\n   * The integration's HTTP method type.\n   * Required unless you use a MOCK integration.\n   *\n   * @default - no integration method specified.\n   */\n  readonly integrationHttpMethod?: string;\n\n  /**\n   * This value is included in computing the Deployment's fingerprint. When the fingerprint\n   * changes, a new deployment is triggered.\n   * This property should contain values associated with the Integration that upon changing\n   * should trigger a fresh the Deployment needs to be refreshed.\n   * @default undefined deployments are not triggered for any change to this integration.\n   */\n  readonly deploymentToken?: string;\n}\n\n/**\n * Base class for backend integrations for an API Gateway method.\n *\n * Use one of the concrete classes such as `MockIntegration`, `AwsIntegration`, `LambdaIntegration`\n * or implement on your own by specifying the set of props.\n */\nexport class Integration {\n  constructor(private readonly props: IntegrationProps) {\n    const options = this.props.options || {};\n    if (\n      options.credentialsPassthrough !== undefined &&\n      options.credentialsRole !== undefined\n    ) {\n      // throw new UnscopedValidationError(\n      throw new Error(\n        \"'credentialsPassthrough' and 'credentialsRole' are mutually exclusive\",\n      );\n    }\n\n    if (\n      options.connectionType === ConnectionType.VPC_LINK &&\n      options.vpcLink === undefined\n    ) {\n      // throw new UnscopedValidationError(\n      throw new Error(\n        \"'connectionType' of VPC_LINK requires 'vpcLink' prop to be set\",\n      );\n    }\n\n    if (\n      options.connectionType === ConnectionType.INTERNET &&\n      options.vpcLink !== undefined\n    ) {\n      // throw new UnscopedValidationError(\n      throw new Error(\n        \"cannot set 'vpcLink' where 'connectionType' is INTERNET\",\n      );\n    }\n\n    if (\n      options.timeout &&\n      !options.timeout.isUnresolved() &&\n      options.timeout.toMilliseconds() < 50\n    ) {\n      // throw new UnscopedValidationError(\n      throw new Error(\n        \"Integration timeout must be greater than 50 milliseconds.\",\n      );\n    }\n\n    if (props.type !== IntegrationType.MOCK && !props.integrationHttpMethod) {\n      // throw new UnscopedValidationError(\n      throw new Error(\n        \"integrationHttpMethod is required for non-mock integration types.\",\n      );\n    }\n  }\n\n  /**\n   * Can be overridden by subclasses to allow the integration to interact with the method\n   * being integrated, access the REST API object, method ARNs, etc.\n   */\n  public bind(method: Method): IntegrationConfig {\n    let uri = this.props.uri;\n    const options = this.props.options;\n\n    if (\n      options?.connectionType === ConnectionType.VPC_LINK &&\n      uri === undefined\n    ) {\n      uri = Lazy.stringValue({\n        // needs to be a lazy since the targets can be added to the VpcLink construct after initialization.\n        produce: () => {\n          const vpcLink = options.vpcLink;\n          if (vpcLink instanceof VpcLink) {\n            const targets = vpcLink._targetDnsNames;\n            if (targets.length > 1) {\n              // throw new ValidationError(\n              throw new Error(\n                `'uri' is required when there are more than one NLBs in the VPC Link (${method.node.path})`,\n                // method,\n              );\n            } else {\n              return `http://${targets[0]}`;\n            }\n          } else {\n            // throw new ValidationError(\n            throw new Error(\n              `'uri' is required when the 'connectionType' is VPC_LINK (${method.node.path})`,\n              // method,\n            );\n          }\n        },\n      });\n    }\n    return {\n      options: {\n        ...options,\n        connectionType: options?.vpcLink\n          ? ConnectionType.VPC_LINK\n          : options?.connectionType,\n      },\n      type: this.props.type,\n      uri,\n      integrationHttpMethod: this.props.integrationHttpMethod,\n    };\n  }\n}\n\nexport enum ContentHandling {\n  /**\n   * Converts a request payload from a base64-encoded string to a binary blob.\n   */\n  CONVERT_TO_BINARY = \"CONVERT_TO_BINARY\",\n\n  /**\n   * Converts a request payload from a binary blob to a base64-encoded string.\n   */\n  CONVERT_TO_TEXT = \"CONVERT_TO_TEXT\",\n}\n\nexport enum IntegrationType {\n  /**\n   * For integrating the API method request with an AWS service action,\n   * including the Lambda function-invoking action. With the Lambda\n   * function-invoking action, this is referred to as the Lambda custom\n   * integration. With any other AWS service action, this is known as AWS\n   * integration.\n   */\n  AWS = \"AWS\",\n\n  /**\n   * For integrating the API method request with the Lambda function-invoking\n   * action with the client request passed through as-is. This integration is\n   * also referred to as the Lambda proxy integration\n   */\n  AWS_PROXY = \"AWS_PROXY\",\n\n  /**\n   * For integrating the API method request with an HTTP endpoint, including a\n   * private HTTP endpoint within a VPC. This integration is also referred to\n   * as the HTTP custom integration.\n   */\n  HTTP = \"HTTP\",\n\n  /**\n   * For integrating the API method request with an HTTP endpoint, including a\n   * private HTTP endpoint within a VPC, with the client request passed\n   * through as-is. This is also referred to as the HTTP proxy integration\n   */\n  HTTP_PROXY = \"HTTP_PROXY\",\n\n  /**\n   * For integrating the API method request with API Gateway as a \"loop-back\"\n   * endpoint without invoking any backend.\n   */\n  MOCK = \"MOCK\",\n}\n\nexport enum PassthroughBehavior {\n  /**\n   * Passes the request body for unmapped content types through to the\n   * integration back end without transformation.\n   */\n  WHEN_NO_MATCH = \"WHEN_NO_MATCH\",\n\n  /**\n   * Rejects unmapped content types with an HTTP 415 'Unsupported Media Type'\n   * response\n   */\n  NEVER = \"NEVER\",\n\n  /**\n   * Allows pass-through when the integration has NO content types mapped to\n   * templates. However if there is at least one content type defined,\n   * unmapped content types will be rejected with the same 415 response.\n   */\n  WHEN_NO_TEMPLATES = \"WHEN_NO_TEMPLATES\",\n}\n\nexport enum ConnectionType {\n  /**\n   * For connections through the public routable internet\n   */\n  INTERNET = \"INTERNET\",\n\n  /**\n   * For private connections between API Gateway and a network load balancer in a VPC\n   */\n  VPC_LINK = \"VPC_LINK\",\n}\n\nexport interface IntegrationResponse {\n  /**\n   * Specifies the regular expression (regex) pattern used to choose an integration response based on the response from\n   * the back end. For example, if the success response returns nothing and the error response returns some string, you\n   * could use the ``.+`` regex to match error response. However, make sure that the error response does not contain any\n   * newline (``\\n``) character in such cases. If the back end is an AWS Lambda function, the AWS Lambda function error\n   * header is matched. For all other HTTP and AWS back ends, the HTTP status code is matched.\n   *\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-integration-settings-integration-response.html\n   */\n  readonly selectionPattern?: string;\n\n  /**\n   * The status code that API Gateway uses to map the integration response to\n   * a MethodResponse status code.\n   */\n  readonly statusCode: string;\n\n  /**\n   * Specifies how to handle request payload content type conversions.\n   *\n   * @default none the request payload is passed through from the method\n   * request to the integration request without modification.\n   */\n  readonly contentHandling?: ContentHandling;\n\n  /**\n   * The response parameters from the backend response that API Gateway sends\n   * to the method response.\n   *\n   * Use the destination as the key and the source as the value:\n   *\n   * - The destination must be an existing response parameter in the\n   *   MethodResponse property.\n   * - The source must be an existing method request parameter or a static\n   *   value. You must enclose static values in single quotation marks and\n   *   pre-encode these values based on the destination specified in the\n   *   request.\n   *\n   * @see http://docs.aws.amazon.com/apigateway/latest/developerguide/request-response-data-mappings.html\n   */\n  readonly responseParameters?: { [destination: string]: string };\n\n  /**\n   * The templates that are used to transform the integration response body.\n   * Specify templates as key-value pairs, with a content type as the key and\n   * a template as the value.\n   *\n   * @see http://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-mapping-template-reference.html\n   */\n  readonly responseTemplates?: { [contentType: string]: string };\n}\n"]}

package/lib/aws/compute/integrations/aws.d.ts

@@ -0,0 +1,72 @@
+import { Integration, IntegrationConfig, IntegrationOptions } from "../integration";
+import { Method } from "../method";
+export interface AwsIntegrationProps {
+    /**
+     * Use AWS_PROXY integration.
+     *
+     * @default false
+     */
+    readonly proxy?: boolean;
+    /**
+     * The name of the integrated AWS service (e.g. `s3`)
+     */
+    readonly service: string;
+    /**
+     * A designated subdomain supported by certain AWS service for fast
+     * host-name lookup.
+     */
+    readonly subdomain?: string;
+    /**
+     * The path to use for path-base APIs.
+     *
+     * For example, for S3 GET, you can set path to `bucket/key`.
+     * For lambda, you can set path to `2015-03-31/functions/${function-arn}/invocations`
+     *
+     * Mutually exclusive with the `action` options.
+     */
+    readonly path?: string;
+    /**
+     * The AWS action to perform in the integration.
+     *
+     * Use `actionParams` to specify key-value params for the action.
+     *
+     * Mutually exclusive with `path`.
+     */
+    readonly action?: string;
+    /**
+     * Parameters for the action.
+     *
+     * `action` must be set, and `path` must be undefined.
+     * The action params will be URL encoded.
+     */
+    readonly actionParameters?: {
+        [key: string]: string;
+    };
+    /**
+     * The integration's HTTP method type.
+     *
+     * @default POST
+     */
+    readonly integrationHttpMethod?: string;
+    /**
+     * Integration options, such as content handling, request/response mapping, etc.
+     */
+    readonly options?: IntegrationOptions;
+    /**
+     * The region of the integrated AWS service.
+     *
+     * @default - same region as the stack
+     */
+    readonly region?: string;
+}
+/**
+ * This type of integration lets an API expose AWS service actions. It is
+ * intended for calling all AWS service actions, but is not recommended for
+ * calling a Lambda function, because the Lambda custom integration is a legacy
+ * technology.
+ */
+export declare class AwsIntegration extends Integration {
+    private scope?;
+    constructor(props: AwsIntegrationProps);
+    bind(method: Method): IntegrationConfig;
+}

package/lib/aws/compute/integrations/aws.js

@@ -0,0 +1,55 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AwsIntegration = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdk = require("cdktf");
+const arn_1 = require("../../arn");
+const aws_stack_1 = require("../../aws-stack");
+const apigateway_util_1 = require("../apigateway-util");
+const integration_1 = require("../integration");
+/**
+ * This type of integration lets an API expose AWS service actions. It is
+ * intended for calling all AWS service actions, but is not recommended for
+ * calling a Lambda function, because the Lambda custom integration is a legacy
+ * technology.
+ */
+class AwsIntegration extends integration_1.Integration {
+    constructor(props) {
+        const backend = props.subdomain
+            ? `${props.subdomain}.${props.service}`
+            : props.service;
+        const type = props.proxy ? integration_1.IntegrationType.AWS_PROXY : integration_1.IntegrationType.AWS;
+        const { apiType, apiValue } = (0, apigateway_util_1.parseAwsApiCall)(props.path, props.action, props.actionParameters);
+        super({
+            type,
+            integrationHttpMethod: props.integrationHttpMethod || "POST",
+            uri: cdk.Lazy.stringValue({
+                produce: () => {
+                    if (!this.scope) {
+                        // throw new UnscopedValidationError(
+                        throw new Error("AwsIntegration must be used in API");
+                    }
+                    return aws_stack_1.AwsStack.ofAwsConstruct(this.scope).formatArn({
+                        service: "apigateway",
+                        account: backend,
+                        resource: apiType,
+                        arnFormat: arn_1.ArnFormat.SLASH_RESOURCE_NAME,
+                        resourceName: apiValue,
+                        region: props.region,
+                    });
+                },
+            }),
+            options: props.options,
+        });
+    }
+    bind(method) {
+        const bindResult = super.bind(method);
+        this.scope = method;
+        return bindResult;
+    }
+}
+exports.AwsIntegration = AwsIntegration;
+_a = JSII_RTTI_SYMBOL_1;
+AwsIntegration[_a] = { fqn: "terraconstructs.aws.compute.AwsIntegration", version: "0.1.1" };
+//# sourceMappingURL=data:application/json;base64,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