terraconstructs 0.0.25 → 0.1.1

package/lib/aws/compute/method.js

@@ -0,0 +1,396 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthorizationType = exports.Method = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/aws-apigateway/lib/method.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const apigateway_canned_metrics_generated_1 = require("./apigateway-canned-metrics.generated");
+const apigateway_util_1 = require("./apigateway-util");
+const authorizer_1 = require("./authorizer");
+const mock_1 = require("./integrations/mock");
+const restapi_1 = require("./restapi");
+// import { Fn } from "../../terra-func";
+const arn_1 = require("../arn");
+const aws_construct_1 = require("../aws-construct");
+const aws_stack_1 = require("../aws-stack");
+const cloudwatch = require("../cloudwatch");
+const iam = require("../iam");
+class Method extends aws_construct_1.AwsConstructBase {
+    get outputs() {
+        return {
+            methodId: this.methodId,
+            httpMethod: this.httpMethod,
+            methodArn: this.methodArn,
+        };
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this._methodResponses = [];
+        this.resource = props.resource;
+        this.api = props.resource.api;
+        this.httpMethod = props.httpMethod.toUpperCase();
+        (0, apigateway_util_1.validateHttpMethod)(this.httpMethod);
+        const options = props.options || {};
+        const defaultMethodOptions = props.resource.defaultMethodOptions || {};
+        const authorizer = options.authorizationType === AuthorizationType.NONE &&
+            options.authorizer == undefined
+            ? undefined
+            : options.authorizer || defaultMethodOptions.authorizer;
+        const authorizerId = authorizer?.authorizerId
+            ? authorizer.authorizerId
+            : undefined;
+        /**
+         * Get and validate authorization type from the values set by API resource and method.
+         *
+         * REST API Resource
+         * └── defaultMethodOptions: Method options to use as a default for all methods created within this API unless custom options are specified.
+         *    ├── authorizationType: Specifies the default authorization type unless custom options are specified, recommended to not be specified.
+         *    └── authorizer: Specifies the default authorizer for all methods created within this API unless custom options are specified.
+         *        └── authorizerType: The default authorization type of this authorizer.
+         *
+         * REST API Method
+         * └── options: Method options.
+         *    ├── authorizationType: Specifies the authorization type, recommended to not be specified.
+         *    └── authorizer: Specifies an authorizer to use for this method.
+         *        └── authorizerType: The authorization type of this authorizer.
+         *
+         * Authorization type is first set to "authorizer.authorizerType", falling back to method's "authorizationType",
+         * falling back to API resource's default "authorizationType", and lastly "Authorizer.NONE".
+         *
+         * Note that "authorizer.authorizerType" should match method or resource's "authorizationType" if exists.
+         */
+        const authorizationType = this.getMethodAuthorizationType(options, defaultMethodOptions, authorizer);
+        // AuthorizationScope should only be applied to COGNITO_USER_POOLS AuthorizationType.
+        const defaultScopes = options.authorizationScopes ?? defaultMethodOptions.authorizationScopes;
+        const authorizationScopes = authorizationType === AuthorizationType.COGNITO
+            ? defaultScopes
+            : undefined;
+        if (authorizationType !== AuthorizationType.COGNITO && defaultScopes) {
+            // '@aws-cdk/aws-apigateway:invalidAuthScope'
+            cdktf_1.Annotations.of(this).addWarning("'AuthorizationScopes' can only be set when 'AuthorizationType' sets 'COGNITO_USER_POOLS'. Default to ignore the values set in 'AuthorizationScopes'.");
+        }
+        if (authorizer_1.Authorizer.isAuthorizer(authorizer)) {
+            authorizer._attachToApi(this.api);
+        }
+        for (const mr of options.methodResponses ??
+            defaultMethodOptions.methodResponses ??
+            []) {
+            this.addMethodResponse(mr);
+        }
+        const requestValidatorIdValue = this.resolveRequestValidatorId(options);
+        const integration = props.integration ??
+            this.resource.defaultIntegration ??
+            new mock_1.MockIntegration();
+        this.bindResult = integration.bind(this);
+        const methodProps = {
+            restApiId: this.api.restApiId,
+            resourceId: props.resource.resourceId,
+            httpMethod: this.httpMethod,
+            authorization: authorizationType,
+            authorizerId,
+            apiKeyRequired: options.apiKeyRequired ?? defaultMethodOptions.apiKeyRequired,
+            operationName: options.operationName || defaultMethodOptions.operationName,
+            requestParameters: options.requestParameters || defaultMethodOptions.requestParameters,
+            requestModels: this.renderRequestModels(options.requestModels || defaultMethodOptions.requestModels),
+            requestValidatorId: requestValidatorIdValue,
+            authorizationScopes: authorizationScopes,
+        };
+        this.methodResource = new provider_aws_1.apiGatewayMethod.ApiGatewayMethod(this, "Resource", methodProps);
+        this.methodId = this.methodResource.id;
+        if (restapi_1.RestApiBase._isRestApiBase(this.api)) {
+            this.api._attachMethod(this);
+        }
+        const deployment = props.resource.api.latestDeployment;
+        if (deployment) {
+            deployment.node.addDependency(this.methodResource);
+            // Fn.sha1(Fn.jsonencode()) causes nested Tokens and Resolver errors?
+            deployment.addToTriggers({
+                method: {
+                    ...methodProps,
+                    integrationToken: this.bindResult?.deploymentToken,
+                },
+            });
+            // addToLogicalId is CDK specific removalPolicy.RETAIN functionality
+            // deployment.addToLogicalId({
+            //   method: {
+            //     ...methodProps,
+            //     integrationToken: bindResult?.deploymentToken,
+            //   },
+            // });
+        }
+    }
+    /**
+     * The RestApi associated with this Method
+     * @deprecated - Throws an error if this Resource is not associated with an instance of `RestApi`. Use `api` instead.
+     */
+    get restApi() {
+        if (!(this.api instanceof restapi_1.RestApi)) {
+            throw new Error("not available on Resource not connected to an instance of RestApi");
+        }
+        return this.api;
+    }
+    /**
+     * Returns an execute-api ARN for this method:
+     *
+     *   arn:aws:execute-api:{region}:{account}:{restApiId}/{stage}/{method}/{path}
+     *
+     * NOTE: {stage} will refer to the `restApi.deploymentStage`, which will
+     * automatically set if auto-deploy is enabled, or can be explicitly assigned.
+     * When not configured, {stage} will be set to '*', as a shorthand for 'all stages'.
+     *
+     * @attribute
+     */
+    get methodArn() {
+        const stage = this.api.deploymentStage?.stageName;
+        return this.api.arnForExecuteApi(this.httpMethod, pathForArn(this.resource.path), stage);
+    }
+    /**
+     * Returns an execute-api ARN for this method's "test-invoke-stage" stage.
+     * This stage is used by the AWS Console UI when testing the method.
+     */
+    get testMethodArn() {
+        return this.api.arnForExecuteApi(this.httpMethod, pathForArn(this.resource.path), "test-invoke-stage");
+    }
+    /**
+     * Add a method response to this method
+     *
+     * If a method response for the same status code already exists, the `responseModels`
+     * and `responseParameters` maps will be merged.
+     */
+    addMethodResponse(methodResponse) {
+        // https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/aws-apigateway/lib/method.ts#L316
+        // + fix from https://github.com/aws/aws-cdk/pull/26718/files
+        const i = this._methodResponses.findIndex((mr) => mr.statusCode === methodResponse.statusCode);
+        if (i >= 0) {
+            // Need to do a splice because MethodResponses are immutable
+            const existing = this._methodResponses[i];
+            this._methodResponses.splice(i, 1, {
+                statusCode: methodResponse.statusCode,
+                responseModels: mergeDicts(existing.responseModels, methodResponse.responseModels),
+                responseParameters: mergeDicts(existing.responseParameters, methodResponse.responseParameters),
+            });
+        }
+        else {
+            this._methodResponses.push(methodResponse);
+        }
+    }
+    getMethodAuthorizationType(options, defaultMethodOptions, authorizer) {
+        const authorizerAuthType = authorizer?.authorizationType;
+        const optionsAuthType = options.authorizationType || defaultMethodOptions.authorizationType;
+        const finalAuthType = authorizerAuthType || optionsAuthType || AuthorizationType.NONE;
+        if (authorizerAuthType &&
+            optionsAuthType &&
+            authorizerAuthType !== optionsAuthType) {
+            throw new Error(`${this.resource}/${this.httpMethod} - Authorization type is set to ${optionsAuthType} ` +
+                `which is different from what is required by the authorizer [${authorizerAuthType}]`);
+        }
+        return finalAuthType;
+    }
+    renderRequestModels(requestModels) {
+        if (!requestModels) {
+            return undefined;
+        }
+        const models = {};
+        for (const contentType in requestModels) {
+            if (requestModels.hasOwnProperty(contentType)) {
+                models[contentType] = requestModels[contentType].modelId;
+            }
+        }
+        return models;
+    }
+    resolveRequestValidatorId(options) {
+        if (options.requestValidator && options.requestValidatorOptions) {
+            throw new Error("Only one of 'requestValidator' or 'requestValidatorOptions' must be specified.");
+        }
+        if (options.requestValidatorOptions) {
+            // Assuming APIGATEWAY_REQUEST_VALIDATOR_UNIQUE_ID is effectively true for TerraConstructs
+            const id = aws_stack_1.AwsStack.ofAwsConstruct(this).uniqueResourceName(new cdktf_1.TerraformElement(this, "Validator"), {
+                maxLength: 64,
+                allowedSpecialCharacters: "-_",
+            });
+            const validator = this.api.addRequestValidator(id, options.requestValidatorOptions);
+            return validator.requestValidatorId;
+        }
+        return options.requestValidator?.requestValidatorId;
+    }
+    metric(metricName, stage, props) {
+        return new cloudwatch.Metric({
+            namespace: "AWS/ApiGateway",
+            metricName,
+            dimensionsMap: {
+                ApiName: this.api.restApiName,
+                Method: this.httpMethod,
+                Resource: this.resource.path,
+                Stage: stage.stageName,
+            },
+            ...props,
+        }).attachTo(this);
+    }
+    metricClientError(stage, props) {
+        return this.cannedMetric(apigateway_canned_metrics_generated_1.ApiGatewayMetrics._4XxErrorSum, stage, props);
+    }
+    metricServerError(stage, props) {
+        return this.cannedMetric(apigateway_canned_metrics_generated_1.ApiGatewayMetrics._5XxErrorSum, stage, props);
+    }
+    metricCacheHitCount(stage, props) {
+        return this.cannedMetric(apigateway_canned_metrics_generated_1.ApiGatewayMetrics.cacheHitCountSum, stage, props);
+    }
+    metricCacheMissCount(stage, props) {
+        return this.cannedMetric(apigateway_canned_metrics_generated_1.ApiGatewayMetrics.cacheMissCountSum, stage, props);
+    }
+    metricCount(stage, props) {
+        return this.cannedMetric(apigateway_canned_metrics_generated_1.ApiGatewayMetrics.countSum, stage, {
+            statistic: "SampleCount",
+            ...props,
+        });
+    }
+    metricIntegrationLatency(stage, props) {
+        return this.cannedMetric(apigateway_canned_metrics_generated_1.ApiGatewayMetrics.integrationLatencyAverage, stage, props);
+    }
+    metricLatency(stage, props) {
+        return this.cannedMetric(apigateway_canned_metrics_generated_1.ApiGatewayMetrics.latencyAverage, stage, props);
+    }
+    grantExecute(grantee) {
+        return iam.Grant.addToPrincipal({
+            grantee,
+            actions: ["execute-api:Invoke"],
+            resourceArns: [this.methodArn],
+        });
+    }
+    cannedMetric(fn, stage, props) {
+        return new cloudwatch.Metric({
+            ...fn({
+                ApiName: this.api.restApiName,
+                Method: this.httpMethod,
+                Resource: this.resource.path,
+                Stage: stage.stageName,
+            }),
+            ...props,
+        }).attachTo(this);
+    }
+    /**
+     * Adds resource to the terraform JSON output.
+     *
+     * called by TerraformStack.prepareStack()
+     */
+    toTerraform() {
+        if (this._methodResponses.length === 0 && !this.bindResult) {
+            return {};
+        }
+        // NOTE: The TerraformDependendableAspect will propgate construct tree dependencies
+        const methodResponses = {};
+        for (let i = 0; i < this._methodResponses.length; i++) {
+            const mrProps = this._methodResponses[i];
+            // unique id by status code
+            const id = `MethodResponse${mrProps.statusCode}`;
+            // no re-create if already generated
+            const methodResponse = this.node.tryFindChild(id);
+            if (methodResponse) {
+                methodResponses[mrProps.statusCode] =
+                    methodResponse;
+                continue;
+            }
+            // generate new ApiGatewayMethodResponse
+            methodResponses[mrProps.statusCode] =
+                new provider_aws_1.apiGatewayMethodResponse.ApiGatewayMethodResponse(this, id, {
+                    restApiId: this.api.restApiId,
+                    resourceId: this.resource.resourceId,
+                    httpMethod: this.methodResource.httpMethod,
+                    statusCode: mrProps.statusCode,
+                    responseParameters: mrProps.responseParameters,
+                    responseModels: this.renderResponseModels(mrProps.responseModels),
+                });
+        }
+        // add integration resources
+        const integrationId = "Integration";
+        if (this.bindResult && !this.node.tryFindChild(integrationId)) {
+            const integrationResource = new provider_aws_1.apiGatewayIntegration.ApiGatewayIntegration(this, integrationId, this.renderIntegration(this.bindResult));
+            // add integration responses (with dependencies on integration)
+            this.bindResult.options?.integrationResponses?.forEach((ir) => {
+                const irId = `IntegrationResponse${ir.statusCode}`;
+                if (this.node.tryFindChild(irId))
+                    return;
+                new provider_aws_1.apiGatewayIntegrationResponse.ApiGatewayIntegrationResponse(this, irId, this.renderIntegrationResponse(integrationResource, ir, methodResponses));
+            });
+        }
+        return {};
+    }
+    renderResponseModels(responseModels) {
+        if (!responseModels) {
+            return undefined;
+        }
+        return Object.fromEntries(Object.entries(responseModels).map(([contentType, rm]) => [
+            contentType,
+            rm.modelId,
+        ]));
+    }
+    renderIntegration(bindResult) {
+        const options = bindResult.options ?? {};
+        let credentials;
+        if (options.credentialsRole) {
+            credentials = options.credentialsRole.roleArn;
+        }
+        else if (options.credentialsPassthrough) {
+            credentials = aws_stack_1.AwsStack.ofAwsConstruct(this).formatArn({
+                service: "iam",
+                region: "",
+                account: "*",
+                resource: "user",
+                arnFormat: arn_1.ArnFormat.SLASH_RESOURCE_NAME,
+                resourceName: "*",
+            });
+        }
+        return {
+            restApiId: this.api.restApiId,
+            resourceId: this.resource.resourceId,
+            httpMethod: this.methodResource.httpMethod, // Frontend method's HTTP verb
+            type: bindResult.type,
+            uri: bindResult.uri,
+            integrationHttpMethod: bindResult.integrationHttpMethod, // Backend method's HTTP verb
+            cacheKeyParameters: options.cacheKeyParameters,
+            cacheNamespace: options.cacheNamespace,
+            contentHandling: options.contentHandling,
+            requestParameters: options.requestParameters,
+            requestTemplates: options.requestTemplates,
+            passthroughBehavior: options.passthroughBehavior,
+            connectionType: options.connectionType,
+            connectionId: options.vpcLink ? options.vpcLink.vpcLinkId : undefined,
+            credentials,
+            timeoutMilliseconds: options.timeout?.toMilliseconds(),
+        };
+    }
+    renderIntegrationResponse(integration, ir, mr) {
+        const methodResponse = mr[ir.statusCode];
+        return {
+            restApiId: this.api.restApiId,
+            resourceId: this.resource.resourceId,
+            httpMethod: this.methodResource.httpMethod,
+            // TODO: Is this correct to not create a methodResponse?
+            statusCode: methodResponse ? methodResponse.statusCode : ir.statusCode,
+            contentHandling: ir.contentHandling,
+            responseParameters: ir.responseParameters,
+            responseTemplates: ir.responseTemplates,
+            selectionPattern: ir.selectionPattern,
+            dependsOn: [integration],
+        };
+    }
+}
+exports.Method = Method;
+_a = JSII_RTTI_SYMBOL_1;
+Method[_a] = { fqn: "terraconstructs.aws.compute.Method", version: "0.1.1" };
+var AuthorizationType;
+(function (AuthorizationType) {
+    AuthorizationType["NONE"] = "NONE";
+    AuthorizationType["IAM"] = "AWS_IAM";
+    AuthorizationType["CUSTOM"] = "CUSTOM";
+    AuthorizationType["COGNITO"] = "COGNITO_USER_POOLS";
+})(AuthorizationType || (exports.AuthorizationType = AuthorizationType = {}));
+function pathForArn(path) {
+    return path.replace(/\{[^\}]*\}/g, "*");
+}
+function mergeDicts(xs, ys) {
+    return xs || ys ? Object.assign(xs ?? {}, ys) : undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"method.js","sourceRoot":"","sources":["../../../src/aws/compute/method.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/aws-apigateway/lib/method.ts\n\nimport {\n  apiGatewayMethod,\n  apiGatewayIntegration,\n  apiGatewayMethodResponse,\n  apiGatewayIntegrationResponse,\n} from \"@cdktf/provider-aws\";\nimport { Annotations, TerraformElement } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { ApiGatewayMetrics } from \"./apigateway-canned-metrics.generated\";\nimport { validateHttpMethod } from \"./apigateway-util\";\nimport { Authorizer, IAuthorizer } from \"./authorizer\";\nimport {\n  Integration,\n  IntegrationConfig,\n  IntegrationResponse,\n} from \"./integration\";\nimport { MockIntegration } from \"./integrations/mock\";\nimport { MethodResponse } from \"./methodresponse\";\nimport { IModel } from \"./model\";\nimport { IRequestValidator, RequestValidatorOptions } from \"./requestvalidator\";\nimport { IResource } from \"./resource\";\nimport { IRestApi, RestApi, RestApiBase } from \"./restapi\";\nimport { IStage } from \"./stage\";\n// import { Fn } from \"../../terra-func\";\nimport { ArnFormat } from \"../arn\";\nimport { AwsConstructBase, AwsConstructProps } from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\nimport * as cloudwatch from \"../cloudwatch\";\nimport * as iam from \"../iam\";\n\nexport interface MethodOptions {\n  /**\n   * A friendly operation name for the method. For example, you can assign the\n   * OperationName of ListPets for the GET /pets method.\n   */\n  readonly operationName?: string;\n\n  /**\n   * Method authorization.\n   * If the value is set of `Custom`, an `authorizer` must also be specified.\n   *\n   * If you're using one of the authorizers that are available via the `Authorizer` class, such as `Authorizer#token()`,\n   * it is recommended that this option not be specified. The authorizer will take care of setting the correct authorization type.\n   * However, specifying an authorization type using this property that conflicts with what is expected by the `Authorizer`\n   * will result in an error.\n   *\n   * @default - open access unless `authorizer` is specified\n   */\n  readonly authorizationType?: AuthorizationType;\n\n  /**\n   * If `authorizationType` is `Custom`, this specifies the ID of the method\n   * authorizer resource.\n   * If specified, the value of `authorizationType` must be set to `Custom`\n   */\n  readonly authorizer?: IAuthorizer;\n\n  /**\n   * Indicates whether the method requires clients to submit a valid API key.\n   * @default false\n   */\n  readonly apiKeyRequired?: boolean;\n\n  /**\n   * The responses that can be sent to the client who calls the method.\n   * @default None\n   *\n   * This property is not required, but if these are not supplied for a Lambda\n   * proxy integration, the Lambda function must return a value of the correct format,\n   * for the integration response to be correctly mapped to a response to the client.\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-method-settings-method-response.html\n   */\n  readonly methodResponses?: MethodResponse[];\n\n  /**\n   * The request parameters that API Gateway accepts. Specify request parameters\n   * as key-value pairs (string-to-Boolean mapping), with a source as the key and\n   * a Boolean as the value. The Boolean specifies whether a parameter is required.\n   * A source must match the format method.request.location.name, where the location\n   * is querystring, path, or header, and name is a valid, unique parameter name.\n   * @default None\n   */\n  readonly requestParameters?: { [param: string]: boolean };\n\n  /**\n   * The models which describe data structure of request payload. When\n   * combined with `requestValidator` or `requestValidatorOptions`, the service\n   * will validate the API request payload before it reaches the API's Integration (including proxies).\n   * Specify `requestModels` as key-value pairs, with a content type\n   * (e.g. `'application/json'`) as the key and an API Gateway Model as the value.\n   *\n   * @example\n   *\n   *     declare const api: apigateway.RestApi;\n   *     declare const userLambda: lambda.Function;\n   *\n   *     const userModel: apigateway.Model = api.addModel('UserModel', {\n   *         schema: {\n   *             type: apigateway.JsonSchemaType.OBJECT,\n   *             properties: {\n   *                 userId: {\n   *                     type: apigateway.JsonSchemaType.STRING\n   *                 },\n   *                 name: {\n   *                     type: apigateway.JsonSchemaType.STRING\n   *                 }\n   *             },\n   *             required: ['userId']\n   *         }\n   *     });\n   *     api.root.addResource('user').addMethod('POST',\n   *         new apigateway.LambdaIntegration(userLambda), {\n   *             requestModels: {\n   *                 'application/json': userModel\n   *             }\n   *         }\n   *     );\n   *\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-method-settings-method-request.html#setup-method-request-model\n   */\n  readonly requestModels?: { [param: string]: IModel };\n\n  /**\n   * The ID of the associated request validator.\n   * Only one of `requestValidator` or `requestValidatorOptions` must be specified.\n   * Works together with `requestModels` or `requestParameters` to validate\n   * the request before it reaches integration like Lambda Proxy Integration.\n   * @default - No default validator\n   */\n  readonly requestValidator?: IRequestValidator;\n\n  /**\n   * A list of authorization scopes configured on the method. The scopes are used with\n   * a COGNITO_USER_POOLS authorizer to authorize the method invocation.\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-method.html#cfn-apigateway-method-authorizationscopes\n   * @default - no authorization scopes\n   */\n  readonly authorizationScopes?: string[];\n\n  /**\n   * Request validator options to create new validator\n   * Only one of `requestValidator` or `requestValidatorOptions` must be specified.\n   * Works together with `requestModels` or `requestParameters` to validate\n   * the request before it reaches integration like Lambda Proxy Integration.\n   * @default - No default validator\n   */\n  readonly requestValidatorOptions?: RequestValidatorOptions;\n}\n\nexport interface MethodProps extends AwsConstructProps {\n  /**\n   * The resource this method is associated with. For root resource methods,\n   * specify the `RestApi` object.\n   */\n  readonly resource: IResource;\n\n  /**\n   * The HTTP method (\"GET\", \"POST\", \"PUT\", ...) that clients use to call this method.\n   */\n  readonly httpMethod: string;\n\n  /**\n   * The backend system that the method calls when it receives a request.\n   *\n   * @default - a new `MockIntegration`.\n   */\n  readonly integration?: Integration;\n\n  /**\n   * Method options.\n   *\n   * @default - No options.\n   */\n  readonly options?: MethodOptions;\n}\n\nexport class Method extends AwsConstructBase {\n  public readonly methodId: string;\n  public readonly httpMethod: string;\n  public readonly resource: IResource;\n  /**\n   * The API Gateway RestApi associated with this method.\n   */\n  public readonly api: IRestApi;\n\n  private readonly _methodResponses: MethodResponse[] = [];\n  private readonly methodResource: apiGatewayMethod.ApiGatewayMethod;\n  private readonly bindResult?: IntegrationConfig;\n\n  public get outputs(): Record<string, any> {\n    return {\n      methodId: this.methodId,\n      httpMethod: this.httpMethod,\n      methodArn: this.methodArn,\n    };\n  }\n\n  constructor(scope: Construct, id: string, props: MethodProps) {\n    super(scope, id, props);\n\n    this.resource = props.resource;\n    this.api = props.resource.api;\n    this.httpMethod = props.httpMethod.toUpperCase();\n\n    validateHttpMethod(this.httpMethod);\n\n    const options = props.options || {};\n    const defaultMethodOptions = props.resource.defaultMethodOptions || {};\n\n    const authorizer =\n      options.authorizationType === AuthorizationType.NONE &&\n      options.authorizer == undefined\n        ? undefined\n        : options.authorizer || defaultMethodOptions.authorizer;\n    const authorizerId = authorizer?.authorizerId\n      ? authorizer.authorizerId\n      : undefined;\n\n    /**\n     * Get and validate authorization type from the values set by API resource and method.\n     *\n     * REST API Resource\n     * └── defaultMethodOptions: Method options to use as a default for all methods created within this API unless custom options are specified.\n     *    ├── authorizationType: Specifies the default authorization type unless custom options are specified, recommended to not be specified.\n     *    └── authorizer: Specifies the default authorizer for all methods created within this API unless custom options are specified.\n     *        └── authorizerType: The default authorization type of this authorizer.\n     *\n     * REST API Method\n     * └── options: Method options.\n     *    ├── authorizationType: Specifies the authorization type, recommended to not be specified.\n     *    └── authorizer: Specifies an authorizer to use for this method.\n     *        └── authorizerType: The authorization type of this authorizer.\n     *\n     * Authorization type is first set to \"authorizer.authorizerType\", falling back to method's \"authorizationType\",\n     * falling back to API resource's default \"authorizationType\", and lastly \"Authorizer.NONE\".\n     *\n     * Note that \"authorizer.authorizerType\" should match method or resource's \"authorizationType\" if exists.\n     */\n    const authorizationType = this.getMethodAuthorizationType(\n      options,\n      defaultMethodOptions,\n      authorizer,\n    );\n\n    // AuthorizationScope should only be applied to COGNITO_USER_POOLS AuthorizationType.\n    const defaultScopes =\n      options.authorizationScopes ?? defaultMethodOptions.authorizationScopes;\n    const authorizationScopes =\n      authorizationType === AuthorizationType.COGNITO\n        ? defaultScopes\n        : undefined;\n    if (authorizationType !== AuthorizationType.COGNITO && defaultScopes) {\n      // '@aws-cdk/aws-apigateway:invalidAuthScope'\n      Annotations.of(this).addWarning(\n        \"'AuthorizationScopes' can only be set when 'AuthorizationType' sets 'COGNITO_USER_POOLS'. Default to ignore the values set in 'AuthorizationScopes'.\",\n      );\n    }\n\n    if (Authorizer.isAuthorizer(authorizer)) {\n      authorizer._attachToApi(this.api);\n    }\n\n    for (const mr of options.methodResponses ??\n      defaultMethodOptions.methodResponses ??\n      []) {\n      this.addMethodResponse(mr);\n    }\n\n    const requestValidatorIdValue = this.resolveRequestValidatorId(options);\n\n    const integration =\n      props.integration ??\n      this.resource.defaultIntegration ??\n      new MockIntegration();\n    this.bindResult = integration.bind(this);\n\n    const methodProps: apiGatewayMethod.ApiGatewayMethodConfig = {\n      restApiId: this.api.restApiId,\n      resourceId: props.resource.resourceId,\n      httpMethod: this.httpMethod,\n      authorization: authorizationType,\n      authorizerId,\n      apiKeyRequired:\n        options.apiKeyRequired ?? defaultMethodOptions.apiKeyRequired,\n      operationName:\n        options.operationName || defaultMethodOptions.operationName,\n      requestParameters:\n        options.requestParameters || defaultMethodOptions.requestParameters,\n      requestModels: this.renderRequestModels(\n        options.requestModels || defaultMethodOptions.requestModels,\n      ),\n      requestValidatorId: requestValidatorIdValue,\n      authorizationScopes: authorizationScopes,\n    };\n\n    this.methodResource = new apiGatewayMethod.ApiGatewayMethod(\n      this,\n      \"Resource\",\n      methodProps,\n    );\n\n    this.methodId = this.methodResource.id;\n    if (RestApiBase._isRestApiBase(this.api)) {\n      this.api._attachMethod(this);\n    }\n\n    const deployment = props.resource.api.latestDeployment;\n    if (deployment) {\n      deployment.node.addDependency(this.methodResource);\n      // Fn.sha1(Fn.jsonencode()) causes nested Tokens and Resolver errors?\n      deployment.addToTriggers({\n        method: {\n          ...methodProps,\n          integrationToken: this.bindResult?.deploymentToken,\n        },\n      });\n      // addToLogicalId is CDK specific removalPolicy.RETAIN functionality\n      // deployment.addToLogicalId({\n      //   method: {\n      //     ...methodProps,\n      //     integrationToken: bindResult?.deploymentToken,\n      //   },\n      // });\n    }\n  }\n\n  /**\n   * The RestApi associated with this Method\n   * @deprecated - Throws an error if this Resource is not associated with an instance of `RestApi`. Use `api` instead.\n   */\n  public get restApi(): RestApi {\n    if (!(this.api instanceof RestApi)) {\n      throw new Error(\n        \"not available on Resource not connected to an instance of RestApi\",\n      );\n    }\n    return this.api;\n  }\n\n  /**\n   * Returns an execute-api ARN for this method:\n   *\n   *   arn:aws:execute-api:{region}:{account}:{restApiId}/{stage}/{method}/{path}\n   *\n   * NOTE: {stage} will refer to the `restApi.deploymentStage`, which will\n   * automatically set if auto-deploy is enabled, or can be explicitly assigned.\n   * When not configured, {stage} will be set to '*', as a shorthand for 'all stages'.\n   *\n   * @attribute\n   */\n  public get methodArn(): string {\n    const stage = this.api.deploymentStage?.stageName;\n    return this.api.arnForExecuteApi(\n      this.httpMethod,\n      pathForArn(this.resource.path),\n      stage,\n    );\n  }\n\n  /**\n   * Returns an execute-api ARN for this method's \"test-invoke-stage\" stage.\n   * This stage is used by the AWS Console UI when testing the method.\n   */\n  public get testMethodArn(): string {\n    return this.api.arnForExecuteApi(\n      this.httpMethod,\n      pathForArn(this.resource.path),\n      \"test-invoke-stage\",\n    );\n  }\n\n  /**\n   * Add a method response to this method\n   *\n   * If a method response for the same status code already exists, the `responseModels`\n   * and `responseParameters` maps will be merged.\n   */\n  public addMethodResponse(methodResponse: MethodResponse): void {\n    // https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/aws-apigateway/lib/method.ts#L316\n    // + fix from https://github.com/aws/aws-cdk/pull/26718/files\n    const i = this._methodResponses.findIndex(\n      (mr) => mr.statusCode === methodResponse.statusCode,\n    );\n    if (i >= 0) {\n      // Need to do a splice because MethodResponses are immutable\n      const existing = this._methodResponses[i];\n      this._methodResponses.splice(i, 1, {\n        statusCode: methodResponse.statusCode,\n        responseModels: mergeDicts(\n          existing.responseModels,\n          methodResponse.responseModels,\n        ),\n        responseParameters: mergeDicts(\n          existing.responseParameters,\n          methodResponse.responseParameters,\n        ),\n      });\n    } else {\n      this._methodResponses.push(methodResponse);\n    }\n  }\n\n  private getMethodAuthorizationType(\n    options: MethodOptions,\n    defaultMethodOptions: MethodOptions,\n    authorizer?: IAuthorizer,\n  ): string {\n    const authorizerAuthType = authorizer?.authorizationType;\n    const optionsAuthType =\n      options.authorizationType || defaultMethodOptions.authorizationType;\n    const finalAuthType =\n      authorizerAuthType || optionsAuthType || AuthorizationType.NONE;\n\n    if (\n      authorizerAuthType &&\n      optionsAuthType &&\n      authorizerAuthType !== optionsAuthType\n    ) {\n      throw new Error(\n        `${this.resource}/${this.httpMethod} - Authorization type is set to ${optionsAuthType} ` +\n          `which is different from what is required by the authorizer [${authorizerAuthType}]`,\n      );\n    }\n\n    return finalAuthType;\n  }\n\n  private renderRequestModels(\n    requestModels: { [param: string]: IModel } | undefined,\n  ): { [param: string]: string } | undefined {\n    if (!requestModels) {\n      return undefined;\n    }\n\n    const models: { [param: string]: string } = {};\n    for (const contentType in requestModels) {\n      if (requestModels.hasOwnProperty(contentType)) {\n        models[contentType] = requestModels[contentType].modelId;\n      }\n    }\n    return models;\n  }\n\n  private resolveRequestValidatorId(\n    options: MethodOptions,\n  ): string | undefined {\n    if (options.requestValidator && options.requestValidatorOptions) {\n      throw new Error(\n        \"Only one of 'requestValidator' or 'requestValidatorOptions' must be specified.\",\n      );\n    }\n\n    if (options.requestValidatorOptions) {\n      // Assuming APIGATEWAY_REQUEST_VALIDATOR_UNIQUE_ID is effectively true for TerraConstructs\n      const id = AwsStack.ofAwsConstruct(this).uniqueResourceName(\n        new TerraformElement(this, \"Validator\"),\n        {\n          maxLength: 64,\n          allowedSpecialCharacters: \"-_\",\n        },\n      );\n      const validator = (this.api as RestApi).addRequestValidator(\n        id,\n        options.requestValidatorOptions,\n      );\n      return validator.requestValidatorId;\n    }\n\n    return options.requestValidator?.requestValidatorId;\n  }\n\n  public metric(\n    metricName: string,\n    stage: IStage,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return new cloudwatch.Metric({\n      namespace: \"AWS/ApiGateway\",\n      metricName,\n      dimensionsMap: {\n        ApiName: this.api.restApiName,\n        Method: this.httpMethod,\n        Resource: this.resource.path,\n        Stage: stage.stageName,\n      },\n      ...props,\n    }).attachTo(this);\n  }\n\n  public metricClientError(\n    stage: IStage,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return this.cannedMetric(ApiGatewayMetrics._4XxErrorSum, stage, props);\n  }\n\n  public metricServerError(\n    stage: IStage,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return this.cannedMetric(ApiGatewayMetrics._5XxErrorSum, stage, props);\n  }\n\n  public metricCacheHitCount(\n    stage: IStage,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return this.cannedMetric(ApiGatewayMetrics.cacheHitCountSum, stage, props);\n  }\n\n  public metricCacheMissCount(\n    stage: IStage,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return this.cannedMetric(ApiGatewayMetrics.cacheMissCountSum, stage, props);\n  }\n\n  public metricCount(\n    stage: IStage,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return this.cannedMetric(ApiGatewayMetrics.countSum, stage, {\n      statistic: \"SampleCount\",\n      ...props,\n    });\n  }\n\n  public metricIntegrationLatency(\n    stage: IStage,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return this.cannedMetric(\n      ApiGatewayMetrics.integrationLatencyAverage,\n      stage,\n      props,\n    );\n  }\n\n  public metricLatency(\n    stage: IStage,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return this.cannedMetric(ApiGatewayMetrics.latencyAverage, stage, props);\n  }\n\n  public grantExecute(grantee: iam.IGrantable): iam.Grant {\n    return iam.Grant.addToPrincipal({\n      grantee,\n      actions: [\"execute-api:Invoke\"],\n      resourceArns: [this.methodArn],\n    });\n  }\n\n  private cannedMetric(\n    fn: (dims: {\n      ApiName: string;\n      Method: string;\n      Resource: string;\n      Stage: string;\n    }) => cloudwatch.MetricProps,\n    stage: IStage,\n    props?: cloudwatch.MetricOptions,\n  ) {\n    return new cloudwatch.Metric({\n      ...fn({\n        ApiName: this.api.restApiName,\n        Method: this.httpMethod,\n        Resource: this.resource.path,\n        Stage: stage.stageName,\n      }),\n      ...props,\n    }).attachTo(this);\n  }\n\n  /**\n   * Adds resource to the terraform JSON output.\n   *\n   * called by TerraformStack.prepareStack()\n   */\n  public toTerraform(): any {\n    if (this._methodResponses.length === 0 && !this.bindResult) {\n      return {};\n    }\n\n    // NOTE: The TerraformDependendableAspect will propgate construct tree dependencies\n    const methodResponses: Record<\n      string,\n      apiGatewayMethodResponse.ApiGatewayMethodResponse\n    > = {};\n    for (let i = 0; i < this._methodResponses.length; i++) {\n      const mrProps = this._methodResponses[i];\n      // unique id by status code\n      const id = `MethodResponse${mrProps.statusCode}`;\n      // no re-create if already generated\n      const methodResponse = this.node.tryFindChild(id);\n      if (methodResponse) {\n        methodResponses[mrProps.statusCode] =\n          methodResponse as apiGatewayMethodResponse.ApiGatewayMethodResponse;\n        continue;\n      }\n\n      // generate new ApiGatewayMethodResponse\n      methodResponses[mrProps.statusCode] =\n        new apiGatewayMethodResponse.ApiGatewayMethodResponse(this, id, {\n          restApiId: this.api.restApiId,\n          resourceId: this.resource.resourceId,\n          httpMethod: this.methodResource.httpMethod,\n          statusCode: mrProps.statusCode,\n          responseParameters: mrProps.responseParameters,\n          responseModels: this.renderResponseModels(mrProps.responseModels),\n        });\n    }\n\n    // add integration resources\n    const integrationId = \"Integration\";\n    if (this.bindResult && !this.node.tryFindChild(integrationId)) {\n      const integrationResource =\n        new apiGatewayIntegration.ApiGatewayIntegration(\n          this,\n          integrationId,\n          this.renderIntegration(this.bindResult),\n        );\n      // add integration responses (with dependencies on integration)\n      this.bindResult.options?.integrationResponses?.forEach((ir) => {\n        const irId = `IntegrationResponse${ir.statusCode}`;\n        if (this.node.tryFindChild(irId)) return;\n        new apiGatewayIntegrationResponse.ApiGatewayIntegrationResponse(\n          this,\n          irId,\n          this.renderIntegrationResponse(\n            integrationResource,\n            ir,\n            methodResponses,\n          ),\n        );\n      });\n    }\n\n    return {};\n  }\n\n  private renderResponseModels(\n    responseModels: { [contentType: string]: IModel } | undefined,\n  ): { [contentType: string]: string } | undefined {\n    if (!responseModels) {\n      return undefined;\n    }\n    return Object.fromEntries(\n      Object.entries(responseModels).map(([contentType, rm]) => [\n        contentType,\n        rm.modelId,\n      ]),\n    );\n  }\n\n  private renderIntegration(\n    bindResult: IntegrationConfig,\n  ): apiGatewayIntegration.ApiGatewayIntegrationConfig {\n    const options = bindResult.options ?? {};\n    let credentials: string | undefined;\n    if (options.credentialsRole) {\n      credentials = options.credentialsRole.roleArn;\n    } else if (options.credentialsPassthrough) {\n      credentials = AwsStack.ofAwsConstruct(this).formatArn({\n        service: \"iam\",\n        region: \"\",\n        account: \"*\",\n        resource: \"user\",\n        arnFormat: ArnFormat.SLASH_RESOURCE_NAME,\n        resourceName: \"*\",\n      });\n    }\n\n    return {\n      restApiId: this.api.restApiId,\n      resourceId: this.resource.resourceId,\n      httpMethod: this.methodResource.httpMethod, // Frontend method's HTTP verb\n      type: bindResult.type,\n      uri: bindResult.uri,\n      integrationHttpMethod: bindResult.integrationHttpMethod, // Backend method's HTTP verb\n      cacheKeyParameters: options.cacheKeyParameters,\n      cacheNamespace: options.cacheNamespace,\n      contentHandling: options.contentHandling,\n      requestParameters: options.requestParameters,\n      requestTemplates: options.requestTemplates,\n      passthroughBehavior: options.passthroughBehavior,\n      connectionType: options.connectionType,\n      connectionId: options.vpcLink ? options.vpcLink.vpcLinkId : undefined,\n      credentials,\n      timeoutMilliseconds: options.timeout?.toMilliseconds(),\n    };\n  }\n\n  private renderIntegrationResponse(\n    integration: apiGatewayIntegration.ApiGatewayIntegration,\n    ir: IntegrationResponse,\n    mr: Record<string, apiGatewayMethodResponse.ApiGatewayMethodResponse>,\n  ): apiGatewayIntegrationResponse.ApiGatewayIntegrationResponseConfig {\n    const methodResponse = mr[ir.statusCode];\n    return {\n      restApiId: this.api.restApiId,\n      resourceId: this.resource.resourceId,\n      httpMethod: this.methodResource.httpMethod,\n      // TODO: Is this correct to not create a methodResponse?\n      statusCode: methodResponse ? methodResponse.statusCode : ir.statusCode,\n      contentHandling: ir.contentHandling,\n      responseParameters: ir.responseParameters,\n      responseTemplates: ir.responseTemplates,\n      selectionPattern: ir.selectionPattern,\n      dependsOn: [integration],\n    };\n  }\n}\n\nexport enum AuthorizationType {\n  NONE = \"NONE\",\n  IAM = \"AWS_IAM\",\n  CUSTOM = \"CUSTOM\",\n  COGNITO = \"COGNITO_USER_POOLS\",\n}\n\nfunction pathForArn(path: string): string {\n  return path.replace(/\\{[^\\}]*\\}/g, \"*\");\n}\n\nfunction mergeDicts<T>(\n  xs?: Record<string, T>,\n  ys?: Record<string, T>,\n): Record<string, T> | undefined {\n  return xs || ys ? Object.assign(xs ?? {}, ys) : undefined;\n}\n"]}

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

@@ -0,0 +1,28 @@
+import { IModel } from "./model";
+export interface MethodResponse {
+    /**
+     * The method response's status code, which you map to an IntegrationResponse.
+     * Required.
+     */
+    readonly statusCode: string;
+    /**
+     * Response parameters that API Gateway sends to the client that called a method.
+     * Specify response parameters as key-value pairs (string-to-Boolean maps), with
+     * a destination as the key and a Boolean as the value. Specify the destination
+     * using the following pattern: method.response.header.name, where the name is a
+     * valid, unique header name. The Boolean specifies whether a parameter is required.
+     * @default None
+     */
+    readonly responseParameters?: {
+        [destination: string]: boolean;
+    };
+    /**
+     * The resources used for the response's content type. Specify response models as
+     * key-value pairs (string-to-string maps), with a content type as the key and a Model
+     * resource name as the value.
+     * @default None
+     */
+    readonly responseModels?: {
+        [contentType: string]: IModel;
+    };
+}

package/lib/aws/compute/methodresponse.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWV0aG9kcmVzcG9uc2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXdzL2NvbXB1dGUvbWV0aG9kcmVzcG9uc2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IElNb2RlbCB9IGZyb20gXCIuL21vZGVsXCI7XG5cbmV4cG9ydCBpbnRlcmZhY2UgTWV0aG9kUmVzcG9uc2Uge1xuICAvKipcbiAgICogVGhlIG1ldGhvZCByZXNwb25zZSdzIHN0YXR1cyBjb2RlLCB3aGljaCB5b3UgbWFwIHRvIGFuIEludGVncmF0aW9uUmVzcG9uc2UuXG4gICAqIFJlcXVpcmVkLlxuICAgKi9cbiAgcmVhZG9ubHkgc3RhdHVzQ29kZTogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBSZXNwb25zZSBwYXJhbWV0ZXJzIHRoYXQgQVBJIEdhdGV3YXkgc2VuZHMgdG8gdGhlIGNsaWVudCB0aGF0IGNhbGxlZCBhIG1ldGhvZC5cbiAgICogU3BlY2lmeSByZXNwb25zZSBwYXJhbWV0ZXJzIGFzIGtleS12YWx1ZSBwYWlycyAoc3RyaW5nLXRvLUJvb2xlYW4gbWFwcyksIHdpdGhcbiAgICogYSBkZXN0aW5hdGlvbiBhcyB0aGUga2V5IGFuZCBhIEJvb2xlYW4gYXMgdGhlIHZhbHVlLiBTcGVjaWZ5IHRoZSBkZXN0aW5hdGlvblxuICAgKiB1c2luZyB0aGUgZm9sbG93aW5nIHBhdHRlcm46IG1ldGhvZC5yZXNwb25zZS5oZWFkZXIubmFtZSwgd2hlcmUgdGhlIG5hbWUgaXMgYVxuICAgKiB2YWxpZCwgdW5pcXVlIGhlYWRlciBuYW1lLiBUaGUgQm9vbGVhbiBzcGVjaWZpZXMgd2hldGhlciBhIHBhcmFtZXRlciBpcyByZXF1aXJlZC5cbiAgICogQGRlZmF1bHQgTm9uZVxuICAgKi9cbiAgcmVhZG9ubHkgcmVzcG9uc2VQYXJhbWV0ZXJzPzogeyBbZGVzdGluYXRpb246IHN0cmluZ106IGJvb2xlYW4gfTtcblxuICAvKipcbiAgICogVGhlIHJlc291cmNlcyB1c2VkIGZvciB0aGUgcmVzcG9uc2UncyBjb250ZW50IHR5cGUuIFNwZWNpZnkgcmVzcG9uc2UgbW9kZWxzIGFzXG4gICAqIGtleS12YWx1ZSBwYWlycyAoc3RyaW5nLXRvLXN0cmluZyBtYXBzKSwgd2l0aCBhIGNvbnRlbnQgdHlwZSBhcyB0aGUga2V5IGFuZCBhIE1vZGVsXG4gICAqIHJlc291cmNlIG5hbWUgYXMgdGhlIHZhbHVlLlxuICAgKiBAZGVmYXVsdCBOb25lXG4gICAqL1xuICByZWFkb25seSByZXNwb25zZU1vZGVscz86IHsgW2NvbnRlbnRUeXBlOiBzdHJpbmddOiBJTW9kZWwgfTtcbn1cbiJdfQ==