terraconstructs 0.0.25 → 0.1.0

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

@@ -0,0 +1,268 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StepFunctionsIntegration = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const fs = require("fs");
+const path = require("path");
+const cdktf_1 = require("cdktf");
+const sfn = require("..");
+const aws_1 = require("./aws");
+const iam = require("../../iam");
+// import { ValidationError } from "../../../core/lib/errors";
+const integration_1 = require("../integration");
+const model_1 = require("../model");
+/**
+ * Options to integrate with various StepFunction API
+ */
+class StepFunctionsIntegration {
+    /**
+     * Integrates a Synchronous Express State Machine from AWS Step Functions to an API Gateway method.
+     *
+     * @example
+     *
+     *    const stateMachine = new stepfunctions.StateMachine(this, 'MyStateMachine', {
+     *       stateMachineType: stepfunctions.StateMachineType.EXPRESS,
+     *       definition: stepfunctions.Chain.start(new stepfunctions.Pass(this, 'Pass')),
+     *    });
+     *
+     *    const api = new apigateway.RestApi(this, 'Api', {
+     *       restApiName: 'MyApi',
+     *    });
+     *    api.root.addMethod('GET', apigateway.StepFunctionsIntegration.startExecution(stateMachine));
+     */
+    static startExecution(stateMachine, options) {
+        return new StepFunctionsExecutionIntegration(stateMachine, options);
+    }
+}
+exports.StepFunctionsIntegration = StepFunctionsIntegration;
+_a = JSII_RTTI_SYMBOL_1;
+StepFunctionsIntegration[_a] = { fqn: "terraconstructs.aws.compute.StepFunctionsIntegration", version: "0.1.0" };
+class StepFunctionsExecutionIntegration extends aws_1.AwsIntegration {
+    constructor(stateMachine, options = {}) {
+        super({
+            service: "states",
+            action: "StartSyncExecution",
+            options: {
+                credentialsRole: options.credentialsRole,
+                integrationResponses: options.integrationResponses ?? integrationResponse(),
+                passthroughBehavior: integration_1.PassthroughBehavior.NEVER,
+                requestTemplates: requestTemplates(stateMachine, options),
+                ...options,
+            },
+        });
+        this.stateMachine = stateMachine;
+        this.useDefaultMethodResponses = options.useDefaultMethodResponses ?? true;
+    }
+    bind(method) {
+        const bindResult = super.bind(method);
+        const credentialsRole = bindResult.options?.credentialsRole ??
+            new iam.Role(method, "StartSyncExecutionRole", {
+                assumedBy: new iam.ServicePrincipal("apigateway.amazonaws.com"),
+            });
+        this.stateMachine.grantStartSyncExecution(credentialsRole);
+        let stateMachineName;
+        if (this.stateMachine instanceof sfn.StateMachine) {
+            const stateMachineType = this.stateMachine
+                .stateMachineType;
+            if (stateMachineType !== sfn.StateMachineType.EXPRESS) {
+                // throw new ValidationError(
+                throw new Error('State Machine must be of type "EXPRESS". Please use StateMachineType.EXPRESS as the stateMachineType');
+            }
+            // if not imported, extract the name from the CFN layer to reach the
+            // literal value if it is given (rather than a token)
+            stateMachineName = this.stateMachine.node.defaultChild.nameInput;
+        }
+        else {
+            // imported state machine
+            stateMachineName = `StateMachine-${this.stateMachine.stack.node.addr}`;
+        }
+        let deploymentToken;
+        if (stateMachineName !== undefined &&
+            !cdktf_1.Token.isUnresolved(stateMachineName)) {
+            deploymentToken = JSON.stringify({ stateMachineName });
+        }
+        if (this.useDefaultMethodResponses) {
+            for (const methodResponse of METHOD_RESPONSES) {
+                method.addMethodResponse(methodResponse);
+            }
+        }
+        return {
+            ...bindResult,
+            options: {
+                ...bindResult.options,
+                credentialsRole,
+            },
+            deploymentToken,
+        };
+    }
+}
+/**
+ * Defines the integration response that passes the result on success,
+ * or the error on failure, from the synchronous execution to the caller.
+ *
+ * @returns integrationResponse mapping
+ */
+function integrationResponse() {
+    const errorResponse = [
+        {
+            /**
+             * Specifies the regular expression (regex) pattern used to choose
+             * an integration response based on the response from the back end.
+             * In this case it will match all '4XX' HTTP Errors
+             */
+            selectionPattern: "4\\d{2}",
+            statusCode: "400",
+            responseTemplates: {
+                "application/json": `{
+            "error": "Bad request!"
+          }`,
+            },
+        },
+        {
+            /**
+             * Match all '5XX' HTTP Errors
+             */
+            selectionPattern: "5\\d{2}",
+            statusCode: "500",
+            responseTemplates: {
+                "application/json": "\"error\": $input.path('$.error')",
+            },
+        },
+    ];
+    const integResponse = [
+        {
+            statusCode: "200",
+            responseTemplates: {
+                /* eslint-disable */
+                "application/json": [
+                    "#set($inputRoot = $input.path('$'))",
+                    "#if($input.path('$.status').toString().equals(\"FAILED\"))",
+                    "#set($context.responseOverride.status = 500)",
+                    "{",
+                    '"error": "$input.path(\'$.error\')",',
+                    '"cause": "$input.path(\'$.cause\')"',
+                    "}",
+                    "#else",
+                    "$input.path('$.output')",
+                    "#end",
+                    /* eslint-enable */
+                ].join("\n"),
+            },
+        },
+        ...errorResponse,
+    ];
+    return integResponse;
+}
+/**
+ * Defines the request template that will be used for the integration
+ */
+function requestTemplates(stateMachine, options) {
+    const templateStr = templateString(stateMachine, options);
+    const requestTemplate = {
+        "application/json": templateStr,
+    };
+    return requestTemplate;
+}
+/**
+ * Reads the VTL template and returns the template string to be used
+ * for the request template.
+ */
+function templateString(stateMachine, options) {
+    let templateStr;
+    let requestContextStr = "";
+    const includeHeader = options.headers ?? false;
+    const includeQueryString = options.querystring ?? true;
+    const includePath = options.path ?? true;
+    const includeAuthorizer = options.authorizer ?? false;
+    if (options.requestContext &&
+        Object.keys(options.requestContext).length > 0) {
+        requestContextStr = requestContext(options.requestContext);
+    }
+    templateStr = fs.readFileSync(path.join(__dirname, "stepfunctions.vtl"), {
+        encoding: "utf-8",
+    });
+    templateStr = templateStr.replace("%STATEMACHINE%", stateMachine.stateMachineArn);
+    templateStr = templateStr.replace("%INCLUDE_HEADERS%", String(includeHeader));
+    templateStr = templateStr.replace("%INCLUDE_QUERYSTRING%", String(includeQueryString));
+    templateStr = templateStr.replace("%INCLUDE_PATH%", String(includePath));
+    templateStr = templateStr.replace("%INCLUDE_AUTHORIZER%", String(includeAuthorizer));
+    templateStr = templateStr.replace("%REQUESTCONTEXT%", requestContextStr);
+    return templateStr;
+}
+function requestContext(requestContextObj) {
+    const context = {
+        accountId: requestContextObj?.accountId
+            ? "$context.identity.accountId"
+            : undefined,
+        apiId: requestContextObj?.apiId ? "$context.apiId" : undefined,
+        apiKey: requestContextObj?.apiKey ? "$context.identity.apiKey" : undefined,
+        authorizerPrincipalId: requestContextObj?.authorizerPrincipalId
+            ? "$context.authorizer.principalId"
+            : undefined,
+        caller: requestContextObj?.caller ? "$context.identity.caller" : undefined,
+        cognitoAuthenticationProvider: requestContextObj?.cognitoAuthenticationProvider
+            ? "$context.identity.cognitoAuthenticationProvider"
+            : undefined,
+        cognitoAuthenticationType: requestContextObj?.cognitoAuthenticationType
+            ? "$context.identity.cognitoAuthenticationType"
+            : undefined,
+        cognitoIdentityId: requestContextObj?.cognitoIdentityId
+            ? "$context.identity.cognitoIdentityId"
+            : undefined,
+        cognitoIdentityPoolId: requestContextObj?.cognitoIdentityPoolId
+            ? "$context.identity.cognitoIdentityPoolId"
+            : undefined,
+        httpMethod: requestContextObj?.httpMethod
+            ? "$context.httpMethod"
+            : undefined,
+        stage: requestContextObj?.stage ? "$context.stage" : undefined,
+        sourceIp: requestContextObj?.sourceIp
+            ? "$context.identity.sourceIp"
+            : undefined,
+        user: requestContextObj?.user ? "$context.identity.user" : undefined,
+        userAgent: requestContextObj?.userAgent
+            ? "$context.identity.userAgent"
+            : undefined,
+        userArn: requestContextObj?.userArn
+            ? "$context.identity.userArn"
+            : undefined,
+        requestId: requestContextObj?.requestId ? "$context.requestId" : undefined,
+        resourceId: requestContextObj?.resourceId
+            ? "$context.resourceId"
+            : undefined,
+        resourcePath: requestContextObj?.resourcePath
+            ? "$context.resourcePath"
+            : undefined,
+    };
+    const contextAsString = JSON.stringify(context);
+    // The VTL Template conflicts with double-quotes (") for strings.
+    // Before sending to the template, we replace double-quotes (") with @@ and replace it back inside the .vtl file
+    const doublequotes = '"';
+    const replaceWith = "@@";
+    return contextAsString.split(doublequotes).join(replaceWith);
+}
+/**
+ * Method response model for each HTTP code response
+ */
+const METHOD_RESPONSES = [
+    {
+        statusCode: "200",
+        responseModels: {
+            "application/json": model_1.Model.EMPTY_MODEL,
+        },
+    },
+    {
+        statusCode: "400",
+        responseModels: {
+            "application/json": model_1.Model.ERROR_MODEL,
+        },
+    },
+    {
+        statusCode: "500",
+        responseModels: {
+            "application/json": model_1.Model.ERROR_MODEL,
+        },
+    },
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stepfunctions.js","sourceRoot":"","sources":["../../../../src/aws/compute/integrations/stepfunctions.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from \"fs\";\nimport * as path from \"path\";\nimport { sfnStateMachine } from \"@cdktf/provider-aws\";\nimport { Token } from \"cdktf\";\nimport { RequestContext } from \".\";\nimport * as sfn from \"..\";\nimport { AwsIntegration } from \"./aws\";\nimport * as iam from \"../../iam\";\n// import { ValidationError } from \"../../../core/lib/errors\";\nimport {\n  IntegrationConfig,\n  IntegrationOptions,\n  PassthroughBehavior,\n} from \"../integration\";\nimport { Method } from \"../method\";\nimport { Model } from \"../model\";\n\n/**\n * Options when configuring Step Functions synchronous integration with Rest API\n */\nexport interface StepFunctionsExecutionIntegrationOptions\n  extends IntegrationOptions {\n  /**\n   * Which details of the incoming request must be passed onto the underlying state machine,\n   * such as, account id, user identity, request id, etc. The execution input will include a new key `requestContext`:\n   *\n   * {\n   *   \"body\": {},\n   *   \"requestContext\": {\n   *       \"key\": \"value\"\n   *   }\n   * }\n   *\n   * @default - all parameters within request context will be set as false\n   */\n  readonly requestContext?: RequestContext;\n\n  /**\n   * Check if querystring is to be included inside the execution input. The execution input will include a new key `queryString`:\n   *\n   * {\n   *   \"body\": {},\n   *   \"querystring\": {\n   *     \"key\": \"value\"\n   *   }\n   * }\n   *\n   * @default true\n   */\n  readonly querystring?: boolean;\n\n  /**\n   * Check if path is to be included inside the execution input. The execution input will include a new key `path`:\n   *\n   * {\n   *   \"body\": {},\n   *   \"path\": {\n   *     \"resourceName\": \"resourceValue\"\n   *   }\n   * }\n   *\n   * @default true\n   */\n  readonly path?: boolean;\n\n  /**\n   * Check if header is to be included inside the execution input. The execution input will include a new key `headers`:\n   *\n   * {\n   *   \"body\": {},\n   *   \"headers\": {\n   *      \"header1\": \"value\",\n   *      \"header2\": \"value\"\n   *   }\n   * }\n   * @default false\n   */\n  readonly headers?: boolean;\n\n  /**\n   * If the whole authorizer object, including custom context values should be in the execution input. The execution input will include a new key `authorizer`:\n   *\n   * {\n   *   \"body\": {},\n   *   \"authorizer\": {\n   *     \"key\": \"value\"\n   *   }\n   * }\n   *\n   * @default false\n   */\n  readonly authorizer?: boolean;\n\n  /**\n   * Whether to add default response models with 200, 400, and 500 status codes to the method.\n   *\n   * @default true\n   */\n  readonly useDefaultMethodResponses?: boolean;\n}\n\n/**\n * Options to integrate with various StepFunction API\n */\nexport class StepFunctionsIntegration {\n  /**\n   * Integrates a Synchronous Express State Machine from AWS Step Functions to an API Gateway method.\n   *\n   * @example\n   *\n   *    const stateMachine = new stepfunctions.StateMachine(this, 'MyStateMachine', {\n   *       stateMachineType: stepfunctions.StateMachineType.EXPRESS,\n   *       definition: stepfunctions.Chain.start(new stepfunctions.Pass(this, 'Pass')),\n   *    });\n   *\n   *    const api = new apigateway.RestApi(this, 'Api', {\n   *       restApiName: 'MyApi',\n   *    });\n   *    api.root.addMethod('GET', apigateway.StepFunctionsIntegration.startExecution(stateMachine));\n   */\n  public static startExecution(\n    stateMachine: sfn.IStateMachine,\n    options?: StepFunctionsExecutionIntegrationOptions,\n  ): AwsIntegration {\n    return new StepFunctionsExecutionIntegration(stateMachine, options);\n  }\n}\n\nclass StepFunctionsExecutionIntegration extends AwsIntegration {\n  private readonly stateMachine: sfn.IStateMachine;\n  private readonly useDefaultMethodResponses: boolean;\n\n  constructor(\n    stateMachine: sfn.IStateMachine,\n    options: StepFunctionsExecutionIntegrationOptions = {},\n  ) {\n    super({\n      service: \"states\",\n      action: \"StartSyncExecution\",\n      options: {\n        credentialsRole: options.credentialsRole,\n        integrationResponses:\n          options.integrationResponses ?? integrationResponse(),\n        passthroughBehavior: PassthroughBehavior.NEVER,\n        requestTemplates: requestTemplates(stateMachine, options),\n        ...options,\n      },\n    });\n\n    this.stateMachine = stateMachine;\n    this.useDefaultMethodResponses = options.useDefaultMethodResponses ?? true;\n  }\n\n  public bind(method: Method): IntegrationConfig {\n    const bindResult = super.bind(method);\n\n    const credentialsRole =\n      bindResult.options?.credentialsRole ??\n      new iam.Role(method, \"StartSyncExecutionRole\", {\n        assumedBy: new iam.ServicePrincipal(\"apigateway.amazonaws.com\"),\n      });\n    this.stateMachine.grantStartSyncExecution(credentialsRole);\n\n    let stateMachineName;\n\n    if (this.stateMachine instanceof sfn.StateMachine) {\n      const stateMachineType = (this.stateMachine as sfn.StateMachine)\n        .stateMachineType;\n      if (stateMachineType !== sfn.StateMachineType.EXPRESS) {\n        // throw new ValidationError(\n        throw new Error(\n          'State Machine must be of type \"EXPRESS\". Please use StateMachineType.EXPRESS as the stateMachineType',\n          // method,\n        );\n      }\n\n      // if not imported, extract the name from the CFN layer to reach the\n      // literal value if it is given (rather than a token)\n      stateMachineName = (\n        this.stateMachine.node.defaultChild as sfnStateMachine.SfnStateMachine\n      ).nameInput;\n    } else {\n      // imported state machine\n      stateMachineName = `StateMachine-${this.stateMachine.stack.node.addr}`;\n    }\n\n    let deploymentToken;\n\n    if (\n      stateMachineName !== undefined &&\n      !Token.isUnresolved(stateMachineName)\n    ) {\n      deploymentToken = JSON.stringify({ stateMachineName });\n    }\n\n    if (this.useDefaultMethodResponses) {\n      for (const methodResponse of METHOD_RESPONSES) {\n        method.addMethodResponse(methodResponse);\n      }\n    }\n\n    return {\n      ...bindResult,\n      options: {\n        ...bindResult.options,\n        credentialsRole,\n      },\n      deploymentToken,\n    };\n  }\n}\n\n/**\n * Defines the integration response that passes the result on success,\n * or the error on failure, from the synchronous execution to the caller.\n *\n * @returns integrationResponse mapping\n */\nfunction integrationResponse() {\n  const errorResponse = [\n    {\n      /**\n       * Specifies the regular expression (regex) pattern used to choose\n       * an integration response based on the response from the back end.\n       * In this case it will match all '4XX' HTTP Errors\n       */\n      selectionPattern: \"4\\\\d{2}\",\n      statusCode: \"400\",\n      responseTemplates: {\n        \"application/json\": `{\n            \"error\": \"Bad request!\"\n          }`,\n      },\n    },\n    {\n      /**\n       * Match all '5XX' HTTP Errors\n       */\n      selectionPattern: \"5\\\\d{2}\",\n      statusCode: \"500\",\n      responseTemplates: {\n        \"application/json\": \"\\\"error\\\": $input.path('$.error')\",\n      },\n    },\n  ];\n\n  const integResponse = [\n    {\n      statusCode: \"200\",\n      responseTemplates: {\n        /* eslint-disable */\n        \"application/json\": [\n          \"#set($inputRoot = $input.path('$'))\",\n          \"#if($input.path('$.status').toString().equals(\\\"FAILED\\\"))\",\n          \"#set($context.responseOverride.status = 500)\",\n          \"{\",\n          '\"error\": \"$input.path(\\'$.error\\')\",',\n          '\"cause\": \"$input.path(\\'$.cause\\')\"',\n          \"}\",\n          \"#else\",\n          \"$input.path('$.output')\",\n          \"#end\",\n          /* eslint-enable */\n        ].join(\"\\n\"),\n      },\n    },\n    ...errorResponse,\n  ];\n\n  return integResponse;\n}\n\n/**\n * Defines the request template that will be used for the integration\n */\nfunction requestTemplates(\n  stateMachine: sfn.IStateMachine,\n  options: StepFunctionsExecutionIntegrationOptions,\n) {\n  const templateStr = templateString(stateMachine, options);\n\n  const requestTemplate: { [contentType: string]: string } = {\n    \"application/json\": templateStr,\n  };\n\n  return requestTemplate;\n}\n\n/**\n * Reads the VTL template and returns the template string to be used\n * for the request template.\n */\nfunction templateString(\n  stateMachine: sfn.IStateMachine,\n  options: StepFunctionsExecutionIntegrationOptions,\n): string {\n  let templateStr: string;\n\n  let requestContextStr = \"\";\n\n  const includeHeader = options.headers ?? false;\n  const includeQueryString = options.querystring ?? true;\n  const includePath = options.path ?? true;\n  const includeAuthorizer = options.authorizer ?? false;\n\n  if (\n    options.requestContext &&\n    Object.keys(options.requestContext).length > 0\n  ) {\n    requestContextStr = requestContext(options.requestContext);\n  }\n\n  templateStr = fs.readFileSync(path.join(__dirname, \"stepfunctions.vtl\"), {\n    encoding: \"utf-8\",\n  });\n  templateStr = templateStr.replace(\n    \"%STATEMACHINE%\",\n    stateMachine.stateMachineArn,\n  );\n  templateStr = templateStr.replace(\"%INCLUDE_HEADERS%\", String(includeHeader));\n  templateStr = templateStr.replace(\n    \"%INCLUDE_QUERYSTRING%\",\n    String(includeQueryString),\n  );\n  templateStr = templateStr.replace(\"%INCLUDE_PATH%\", String(includePath));\n  templateStr = templateStr.replace(\n    \"%INCLUDE_AUTHORIZER%\",\n    String(includeAuthorizer),\n  );\n  templateStr = templateStr.replace(\"%REQUESTCONTEXT%\", requestContextStr);\n\n  return templateStr;\n}\n\nfunction requestContext(requestContextObj: RequestContext | undefined): string {\n  const context = {\n    accountId: requestContextObj?.accountId\n      ? \"$context.identity.accountId\"\n      : undefined,\n    apiId: requestContextObj?.apiId ? \"$context.apiId\" : undefined,\n    apiKey: requestContextObj?.apiKey ? \"$context.identity.apiKey\" : undefined,\n    authorizerPrincipalId: requestContextObj?.authorizerPrincipalId\n      ? \"$context.authorizer.principalId\"\n      : undefined,\n    caller: requestContextObj?.caller ? \"$context.identity.caller\" : undefined,\n    cognitoAuthenticationProvider:\n      requestContextObj?.cognitoAuthenticationProvider\n        ? \"$context.identity.cognitoAuthenticationProvider\"\n        : undefined,\n    cognitoAuthenticationType: requestContextObj?.cognitoAuthenticationType\n      ? \"$context.identity.cognitoAuthenticationType\"\n      : undefined,\n    cognitoIdentityId: requestContextObj?.cognitoIdentityId\n      ? \"$context.identity.cognitoIdentityId\"\n      : undefined,\n    cognitoIdentityPoolId: requestContextObj?.cognitoIdentityPoolId\n      ? \"$context.identity.cognitoIdentityPoolId\"\n      : undefined,\n    httpMethod: requestContextObj?.httpMethod\n      ? \"$context.httpMethod\"\n      : undefined,\n    stage: requestContextObj?.stage ? \"$context.stage\" : undefined,\n    sourceIp: requestContextObj?.sourceIp\n      ? \"$context.identity.sourceIp\"\n      : undefined,\n    user: requestContextObj?.user ? \"$context.identity.user\" : undefined,\n    userAgent: requestContextObj?.userAgent\n      ? \"$context.identity.userAgent\"\n      : undefined,\n    userArn: requestContextObj?.userArn\n      ? \"$context.identity.userArn\"\n      : undefined,\n    requestId: requestContextObj?.requestId ? \"$context.requestId\" : undefined,\n    resourceId: requestContextObj?.resourceId\n      ? \"$context.resourceId\"\n      : undefined,\n    resourcePath: requestContextObj?.resourcePath\n      ? \"$context.resourcePath\"\n      : undefined,\n  };\n\n  const contextAsString = JSON.stringify(context);\n\n  // The VTL Template conflicts with double-quotes (\") for strings.\n  // Before sending to the template, we replace double-quotes (\") with @@ and replace it back inside the .vtl file\n  const doublequotes = '\"';\n  const replaceWith = \"@@\";\n  return contextAsString.split(doublequotes).join(replaceWith);\n}\n\n/**\n * Method response model for each HTTP code response\n */\nconst METHOD_RESPONSES = [\n  {\n    statusCode: \"200\",\n    responseModels: {\n      \"application/json\": Model.EMPTY_MODEL,\n    },\n  },\n  {\n    statusCode: \"400\",\n    responseModels: {\n      \"application/json\": Model.ERROR_MODEL,\n    },\n  },\n  {\n    statusCode: \"500\",\n    responseModels: {\n      \"application/json\": Model.ERROR_MODEL,\n    },\n  },\n];\n"]}

package/lib/aws/compute/ip-addresses.js

@@ -41,7 +41,7 @@ class IpAddresses {
 }
 exports.IpAddresses = IpAddresses;
 _a = JSII_RTTI_SYMBOL_1;
-IpAddresses[_a] = { fqn: "terraconstructs.aws.compute.IpAddresses", version: "0.0.25" };
+IpAddresses[_a] = { fqn: "terraconstructs.aws.compute.IpAddresses", version: "0.1.0" };
 /**
  * Implements integration with Amazon VPC IP Address Manager (IPAM).
  *
@@ -180,7 +180,7 @@ class Ipv6Addresses {
 }
 exports.Ipv6Addresses = Ipv6Addresses;
 _b = JSII_RTTI_SYMBOL_1;
-Ipv6Addresses[_b] = { fqn: "terraconstructs.aws.compute.Ipv6Addresses", version: "0.0.25" };
+Ipv6Addresses[_b] = { fqn: "terraconstructs.aws.compute.Ipv6Addresses", version: "0.1.0" };
 /**
  * Implements integration with Amazon provided IPv6 CIDRs.
  *

package/lib/aws/compute/ipam.js

@@ -279,7 +279,7 @@ class Ipam extends aws_construct_1.AwsConstructBase {
 }
 exports.Ipam = Ipam;
 _a = JSII_RTTI_SYMBOL_1;
-Ipam[_a] = { fqn: "terraconstructs.aws.compute.alpha.Ipam", version: "0.0.25" };
+Ipam[_a] = { fqn: "terraconstructs.aws.compute.alpha.Ipam", version: "0.1.0" };
 /**
  * Function to create IpamPool under scope
  * @internal

package/lib/aws/compute/json-schema.d.ts

@@ -0,0 +1,75 @@
+export declare enum JsonSchemaVersion {
+    /**
+     * In API Gateway models are defined using the JSON schema draft 4.
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-04
+     */
+    DRAFT4 = "http://json-schema.org/draft-04/schema#",
+    DRAFT7 = "http://json-schema.org/draft-07/schema#"
+}
+export declare enum JsonSchemaType {
+    NULL = "null",
+    BOOLEAN = "boolean",
+    OBJECT = "object",
+    ARRAY = "array",
+    NUMBER = "number",
+    INTEGER = "integer",
+    STRING = "string"
+}
+/**
+ * Represents a JSON schema definition of the structure of a
+ * REST API model. Copied from npm module jsonschema.
+ *
+ * @see http://json-schema.org/
+ * @see https://github.com/tdegrunt/jsonschema
+ */
+export interface JsonSchema {
+    readonly schema?: JsonSchemaVersion;
+    readonly id?: string;
+    readonly ref?: string;
+    readonly type?: JsonSchemaType | JsonSchemaType[];
+    readonly title?: string;
+    readonly description?: string;
+    readonly enum?: any[];
+    /**
+     * The default value if you use an enum.
+     *
+     * @default - not set
+     */
+    readonly default?: any;
+    readonly format?: string;
+    readonly definitions?: {
+        [name: string]: JsonSchema;
+    };
+    readonly multipleOf?: number;
+    readonly maximum?: number;
+    readonly exclusiveMaximum?: boolean;
+    readonly minimum?: number;
+    readonly exclusiveMinimum?: boolean;
+    readonly maxLength?: number;
+    readonly minLength?: number;
+    readonly pattern?: string;
+    readonly items?: JsonSchema | JsonSchema[];
+    readonly additionalItems?: JsonSchema[];
+    readonly maxItems?: number;
+    readonly minItems?: number;
+    readonly uniqueItems?: boolean;
+    readonly contains?: JsonSchema | JsonSchema[];
+    readonly maxProperties?: number;
+    readonly minProperties?: number;
+    readonly required?: string[];
+    readonly properties?: {
+        [name: string]: JsonSchema;
+    };
+    readonly additionalProperties?: JsonSchema | boolean;
+    readonly patternProperties?: {
+        [name: string]: JsonSchema;
+    };
+    readonly dependencies?: {
+        [name: string]: JsonSchema | string[];
+    };
+    readonly propertyNames?: JsonSchema;
+    readonly allOf?: JsonSchema[];
+    readonly anyOf?: JsonSchema[];
+    readonly oneOf?: JsonSchema[];
+    readonly not?: JsonSchema;
+}

package/lib/aws/compute/json-schema.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonSchemaType = exports.JsonSchemaVersion = void 0;
+var JsonSchemaVersion;
+(function (JsonSchemaVersion) {
+    /**
+     * In API Gateway models are defined using the JSON schema draft 4.
+     * @see https://tools.ietf.org/html/draft-zyp-json-schema-04
+     */
+    JsonSchemaVersion["DRAFT4"] = "http://json-schema.org/draft-04/schema#";
+    JsonSchemaVersion["DRAFT7"] = "http://json-schema.org/draft-07/schema#";
+})(JsonSchemaVersion || (exports.JsonSchemaVersion = JsonSchemaVersion = {}));
+var JsonSchemaType;
+(function (JsonSchemaType) {
+    JsonSchemaType["NULL"] = "null";
+    JsonSchemaType["BOOLEAN"] = "boolean";
+    JsonSchemaType["OBJECT"] = "object";
+    JsonSchemaType["ARRAY"] = "array";
+    JsonSchemaType["NUMBER"] = "number";
+    JsonSchemaType["INTEGER"] = "integer";
+    JsonSchemaType["STRING"] = "string";
+})(JsonSchemaType || (exports.JsonSchemaType = JsonSchemaType = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/compute/key-pair.js

@@ -190,5 +190,5 @@ class KeyPair extends aws_construct_1.AwsConstructBase {
 }
 exports.KeyPair = KeyPair;
 _a = JSII_RTTI_SYMBOL_1;
-KeyPair[_a] = { fqn: "terraconstructs.aws.compute.KeyPair", version: "0.0.25" };
+KeyPair[_a] = { fqn: "terraconstructs.aws.compute.KeyPair", version: "0.1.0" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"key-pair.js","sourceRoot":"","sources":["../../../src/aws/compute/key-pair.ts"],"names":[],"mappings":";;;;;AAAA,4FAA4F;AAE5F,sDAA2D;AAC3D,sDAAiD;AACjD,iCAA2B;AAE3B,mDAAsD;AACtD,oDAI0B;AAC1B,oDAI8B;AAE9B,MAAM;AACN,gCAAgC;AAChC,MAAM;AACN,8BAA8B;AAC9B,QAAQ;AACR,8CAA8C;AAC9C,QAAQ;AACR,iBAAiB;AAEjB,QAAQ;AACR,mBAAmB;AACnB,QAAQ;AACR,iBAAiB;AACjB,IAAI;AAEJ;;GAEG;AACH,IAAY,WAYX;AAZD,WAAY,WAAW;IACrB;;OAEG;IACH,0BAAW,CAAA;IAEX;;;;OAIG;IACH,kCAAmB,CAAA;AACrB,CAAC,EAZW,WAAW,2BAAX,WAAW,QAYtB;AAsHD;;;;GAIG;AACH,MAAa,OAAQ,SAAQ,gCAAgB;IAC3C;;OAEG;IACI,MAAM,CAAC,eAAe,CAC3B,KAAgB,EAChB,EAAU,EACV,WAAmB;QAEnB,OAAO,OAAO,CAAC,qBAAqB,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC,CAAC;IACnE,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,qBAAqB,CACjC,KAAgB,EAChB,EAAU,EACV,KAAwB;QAExB,MAAM,MAAO,SAAQ,gCAAgB;YAGnC,IAAW,cAAc;gBACvB,OAAO;oBACL,WAAW,EAAE,IAAI,CAAC,WAAW;oBAC7B,IAAI,EAAE,IAAI,CAAC,IAAI;iBAChB,CAAC;YACJ,CAAC;YACD,IAAW,OAAO;gBAChB,OAAO,IAAI,CAAC,cAAc,CAAC;YAC7B,CAAC;YAED;gBACE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;gBACjB,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC,WAAW,CAAC;gBACrC,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;YACzB,CAAC;YAED;;;;eAIG;YACI,eAAe,CAAC,MAA2B;gBAChD,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;oBAClB,KAAK,WAAW,CAAC,OAAO;wBACtB,OAAO,MAAM,KAAK,mCAAmB,CAAC,OAAO,CAAC;oBAChD,KAAK,WAAW,CAAC,GAAG;wBAClB,OAAO,IAAI,CAAC;oBACd;wBACE,OAAO,IAAI,CAAC;gBAChB,CAAC;YACH,CAAC;SACF;QACD,OAAO,IAAI,MAAM,EAAE,CAAC;IACtB,CAAC;IAED,IAAW,cAAc;QACvB,OAAO;YACL,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,IAAI,EAAE,IAAI,CAAC,IAAI;SAChB,CAAC;IACJ,CAAC;IACD,IAAW,OAAO;QAChB,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IAwCD,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAoB;QAC5D,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;QAExB,IAAI,KAAK,EAAE,WAAW,IAAI,KAAK,EAAE,iBAAiB,EAAE,CAAC;YACnD,MAAM,IAAI,KAAK,CACb,2DAA2D,CAC5D,CAAC;QACJ,CAAC;QAED,MAAM,iBAAiB,GACrB,KAAK,EAAE,iBAAiB;YACxB,IAAI,CAAC,KAAK,CAAC,kBAAkB,CAAC,IAAI,EAAE;gBAClC,MAAM,EAAE,IAAI,CAAC,QAAQ;gBACrB,SAAS,EAAE,GAAG;aACf,CAAC,CAAC;QAEL,qBAAqB;QACrB,0EAA0E;QAC1E,MAAM;QAEN,IAAI,KAAK,EAAE,iBAAiB,IAAI,KAAK,EAAE,IAAI,EAAE,CAAC;YAC5C,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;QAC3E,CAAC;QAED,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC,KAAK,EAAE,iBAAiB,CAAC;QAE5C,MAAM,OAAO,GAAG,KAAK,EAAE,IAAI,IAAI,WAAW,CAAC,GAAG,CAAC;QAC/C,IAAI,SAAS,GAAG,KAAK,EAAE,iBAAiB,CAAC;QACzC,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,IAAI,SAAsC,CAAC;YAC3C,QAAQ,OAAO,EAAE,CAAC;gBAChB,KAAK,WAAW,CAAC,OAAO;oBACtB,SAAS,GAAG,SAAS,CAAC;oBACtB,MAAM;gBACR,KAAK,WAAW,CAAC,GAAG,CAAC;gBACrB;oBACE,SAAS,GAAG,KAAK,CAAC;YACtB,CAAC;YACD,IAAI,CAAC,WAAW,GAAG,IAAI,yBAAU,CAAC,UAAU,CAAC,IAAI,EAAE,YAAY,EAAE;gBAC/D,SAAS;aACV,CAAC,CAAC;YACH,SAAS,GAAG,UAAE,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,CAAC;QAC9D,CAAC;QAED,IAAI,CAAC,QAAQ,GAAG,IAAI,sBAAS,CAAC,OAAO,CAAC,IAAI,EAAE,UAAU,EAAE;YACtD,OAAO,EAAE,KAAK,EAAE,WAAW;YAC3B,aAAa,EAAE,iBAAiB;YAChC,iDAAiD;YACjD,SAAS;SACV,CAAC,CAAC;QAEH,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YACrB,2DAA2D;YAC3D,IAAI,CAAC,cAAc,GAAG,IAAI,2BAAe,CAAC,IAAI,EAAE,qBAAqB,EAAE;gBACrE,aAAa,EAAE,gBAAgB,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE;gBACjD,WAAW,EAAE,mBAAmB,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE;gBACvD,IAAI,EAAE,yBAAa,CAAC,aAAa;gBACjC,oBAAoB,EAAE,IAAI,CAAC,WAAW,CAAC,aAAa;gBACpD,UAAU,EAAE,KAAK;aAClB,CAAC,CAAC;QACL,CAAC;QAED,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC;QACzC,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC;QACpD,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;QAClC,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC;QACpB,2BAA2B;IAC7B,CAAC;IAED;;;;;OAKG;IACH,IAAW,mBAAmB;QAC5B,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED;;OAEG;IACH,IAAW,UAAU;QACnB,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACnB,MAAM,IAAI,KAAK,CACb,6EAA6E,CAC9E,CAAC;QACJ,CAAC;QACD,qCAAqC;QACrC,OAAO,IAAI,CAAC,cAAe,CAAC;IAC9B,CAAC;IAED;;;;OAIG;IACI,eAAe,CAAC,MAA2B;QAChD,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;YAClB,KAAK,WAAW,CAAC,OAAO;gBACtB,OAAO,MAAM,KAAK,mCAAmB,CAAC,OAAO,CAAC;YAChD,KAAK,WAAW,CAAC,GAAG;gBAClB,OAAO,IAAI,CAAC;YACd;gBACE,OAAO,IAAI,CAAC;QAChB,CAAC;IACH,CAAC;;AApNH,0BAqNC","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ec2/lib/key-pair.ts\n\nimport { keyPair as tfKeyPair } from \"@cdktf/provider-aws\";\nimport { privateKey } from \"@cdktf/provider-tls\";\nimport { Fn } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { OperatingSystemType } from \"./machine-image\";\nimport {\n  AwsConstructBase,\n  AwsConstructProps,\n  IAwsConstruct,\n} from \"../aws-construct\";\nimport {\n  StringParameter,\n  IStringParameter,\n  ParameterType,\n} from \"../storage/parameter\";\n\n// /**\n//  * The format of the Key Pair\n//  */\n// export enum KeyPairFormat {\n//   /**\n//    * A PPK file, typically used with PuTTY.\n//    */\n//   PPK = \"ppk\",\n\n//   /**\n//    * A PEM file.\n//    */\n//   PEM = \"pem\",\n// }\n\n/**\n * The type of the key pair.\n */\nexport enum KeyPairType {\n  /**\n   * An RSA key.\n   */\n  RSA = \"rsa\",\n\n  /**\n   * An ED25519 key.\n   *\n   * Note that ED25519 keys are not supported for Windows instances.\n   */\n  ED25519 = \"ed25519\",\n}\n\n/**\n * The properties of a Key Pair\n */\nexport interface KeyPairProps extends AwsConstructProps {\n  /**\n   * A unique name for the key pair.\n   *\n   * @default A generated name\n   */\n  readonly keyPairName?: string;\n\n  /**\n   * Creates a unique name beginning with the specified prefix.\n   *\n   * Conflicts with `keyPairName`. If neither `keyPairName` nor `keyPairNamePrefix` is provided,\n   * TerraConstructs will create a unique key name using the `gridUUID` as prefix.\n   *\n   * @default A generated name\n   */\n  readonly keyPairNamePrefix?: string;\n\n  // /**\n  //  * The format of the key pair.\n  //  *\n  //  * @default PEM\n  //  */\n  // readonly format?: KeyPairFormat;\n\n  /**\n   * The type of key pair.\n   *\n   * @default RSA (ignored if keyMaterial is provided)\n   */\n  readonly type?: KeyPairType;\n\n  /**\n   * The public key material.\n   *\n   * If this is provided the key is considered \"imported\". For imported\n   * keys, it is assumed that you already have the private key material\n   * so the private key material will not be returned or stored in\n   * AWS Systems Manager Parameter Store.\n   *\n   * The private key generated by this resource will be stored unencrypted\n   * in your Terraform state file.\n   *\n   * Omitting the publicKeyMaterial for production deployments is not recommended.\n   * Instead, generate a private key file outside of Terraform and distribute it\n   * securely to the system where Terraform will be run.\n   *\n   * @default a public and private key will be generated\n   */\n  readonly publicKeyMaterial?: string;\n}\n\n/**\n * Outputs which may be registered for output via the Grid.\n */\nexport interface KeyPairOutputs {\n  /**\n   * The unique name of the key pair.\n   */\n  readonly keyPairName: string;\n\n  /**\n   * The type of the key pair.\n   *\n   * @default no type specified\n   */\n  readonly type?: KeyPairType;\n}\n\n/**\n * Attributes of a Key Pair.\n */\nexport interface KeyPairAttributes {\n  /**\n   * The unique name of the key pair.\n   */\n  readonly keyPairName: string;\n\n  /**\n   * The type of the key pair.\n   *\n   * @default no type specified\n   */\n  readonly type?: KeyPairType;\n}\n\n/**\n * An EC2 Key Pair.\n */\nexport interface IKeyPair extends IAwsConstruct {\n  /** Strongly typed outputs */\n  readonly keyPairOutputs: KeyPairOutputs;\n\n  /**\n   * The name of the key pair.\n   *\n   * @attribute\n   */\n  readonly keyPairName: string;\n\n  /**\n   * The type of the key pair.\n   */\n  readonly type?: KeyPairType;\n\n  /**\n   * Used internally to determine whether the key pair is compatible with an OS type.\n   *\n   * @internal\n   */\n  _isOsCompatible(osType: OperatingSystemType): boolean;\n}\n\n/**\n * An EC2 Key Pair.\n *\n * @resource AWS::EC2::KeyPair\n */\nexport class KeyPair extends AwsConstructBase implements IKeyPair {\n  /**\n   * Imports a key pair based on the name.\n   */\n  public static fromKeyPairName(\n    scope: Construct,\n    id: string,\n    keyPairName: string,\n  ): IKeyPair {\n    return KeyPair.fromKeyPairAttributes(scope, id, { keyPairName });\n  }\n\n  /**\n   * Imports a key pair with a name and optional type.\n   */\n  public static fromKeyPairAttributes(\n    scope: Construct,\n    id: string,\n    attrs: KeyPairAttributes,\n  ): IKeyPair {\n    class Import extends AwsConstructBase implements IKeyPair {\n      public readonly keyPairName: string;\n      public readonly type?: KeyPairType;\n      public get keyPairOutputs(): KeyPairOutputs {\n        return {\n          keyPairName: this.keyPairName,\n          type: this.type,\n        };\n      }\n      public get outputs(): Record<string, any> {\n        return this.keyPairOutputs;\n      }\n\n      constructor() {\n        super(scope, id);\n        this.keyPairName = attrs.keyPairName;\n        this.type = attrs.type;\n      }\n\n      /**\n       * Used internally to determine whether the key pair is compatible with an OS type.\n       *\n       * @internal\n       */\n      public _isOsCompatible(osType: OperatingSystemType): boolean {\n        switch (this.type) {\n          case KeyPairType.ED25519:\n            return osType !== OperatingSystemType.WINDOWS;\n          case KeyPairType.RSA:\n            return true;\n          default:\n            return true;\n        }\n      }\n    }\n    return new Import();\n  }\n\n  public get keyPairOutputs(): KeyPairOutputs {\n    return {\n      keyPairName: this.keyPairName,\n      type: this.type,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.keyPairOutputs;\n  }\n\n  /**\n   * The unique name of the key pair.\n   *\n   * @attribute\n   */\n  public readonly keyPairName: string;\n\n  /**\n   * The fingerprint of the key pair.\n   *\n   * @attribute\n   */\n  public readonly keyPairFingerprint: string;\n\n  /**\n   * The unique ID of the key pair.\n   *\n   * @attribute\n   */\n  public readonly keyPairId: string;\n\n  /**\n   * The type of the key pair.\n   */\n  public readonly type?: KeyPairType;\n\n  // not supported in Terraform\n  // /**\n  //  * The format of the key pair.\n  //  */\n  // public readonly format: KeyPairFormat;\n\n  private _privateKey?: privateKey.PrivateKey;\n  private _privateKeySsm?: IStringParameter;\n  private readonly _isImport: boolean;\n\n  public readonly resource: tfKeyPair.KeyPair;\n\n  constructor(scope: Construct, id: string, props?: KeyPairProps) {\n    super(scope, id, props);\n\n    if (props?.keyPairName && props?.keyPairNamePrefix) {\n      throw new Error(\n        \"Cannot specify both 'keyPairName' and 'keyPairNamePrefix'\",\n      );\n    }\n\n    const keyPairNamePrefix =\n      props?.keyPairNamePrefix ||\n      this.stack.uniqueResourceName(this, {\n        prefix: this.gridUUID,\n        maxLength: 255,\n      });\n\n    // Lazy.stringValue({\n    //   produce: () => AwsStack.uniqueResourceName(this, { maxLength: 255 }),\n    // });\n\n    if (props?.publicKeyMaterial && props?.type) {\n      throw new Error(\"Cannot specify 'type' for keys with imported material\");\n    }\n\n    this._isImport = !!props?.publicKeyMaterial;\n\n    const keyType = props?.type ?? KeyPairType.RSA;\n    let publicKey = props?.publicKeyMaterial;\n    if (!publicKey) {\n      let algorithm: \"RSA\" | \"ECDSA\" | \"ED25519\";\n      switch (keyType) {\n        case KeyPairType.ED25519:\n          algorithm = \"ED25519\";\n          break;\n        case KeyPairType.RSA:\n        default:\n          algorithm = \"RSA\";\n      }\n      this._privateKey = new privateKey.PrivateKey(this, \"PrivateKey\", {\n        algorithm,\n      });\n      publicKey = Fn.trimspace(this._privateKey.publicKeyOpenssh);\n    }\n\n    this.resource = new tfKeyPair.KeyPair(this, \"Resource\", {\n      keyName: props?.keyPairName,\n      keyNamePrefix: keyPairNamePrefix,\n      // keyFormat: props?.format ?? KeyPairFormat.PEM,\n      publicKey,\n    });\n\n    if (this._privateKey) {\n      // if privateKey was generated, mimic CFN behavior with SSM\n      this._privateKeySsm = new StringParameter(this, \"PrivateKeyParameter\", {\n        parameterName: `/ec2/keypair/${this.resource.id}`,\n        description: `Private key for ${this.resource.keyName}`,\n        type: ParameterType.SECURE_STRING,\n        sensitiveStringValue: this._privateKey.privateKeyPem,\n        simpleName: false,\n      });\n    }\n\n    this.keyPairName = this.resource.keyName;\n    this.keyPairFingerprint = this.resource.fingerprint;\n    this.keyPairId = this.resource.id;\n    this.type = keyType;\n    // this.format = keyFormat;\n  }\n\n  /**\n   * Whether the key material was imported.\n   *\n   * Keys with imported material do not have their private key material stored\n   * or returned automatically.\n   */\n  public get hasImportedMaterial(): boolean {\n    return this._isImport;\n  }\n\n  /**\n   * The Systems Manager Parameter Store parameter with the pair's private key material.\n   */\n  public get privateKey(): IStringParameter {\n    if (this._isImport) {\n      throw new Error(\n        \"An SSM parameter with private key material is not created for imported keys\",\n      );\n    }\n    // else, this is guaranteed to be set\n    return this._privateKeySsm!;\n  }\n\n  /**\n   * Used internally to determine whether the key pair is compatible with an OS type.\n   *\n   * @internal\n   */\n  public _isOsCompatible(osType: OperatingSystemType): boolean {\n    switch (this.type) {\n      case KeyPairType.ED25519:\n        return osType !== OperatingSystemType.WINDOWS;\n      case KeyPairType.RSA:\n        return true;\n      default:\n        return true;\n    }\n  }\n}\n"]}

package/lib/aws/compute/lambda-api.d.ts

@@ -0,0 +1,46 @@
+import { Construct } from "constructs";
+import * as lambda from ".";
+import { LambdaIntegrationOptions } from "./integrations";
+import { RestApi, RestApiProps } from "./restapi";
+export interface LambdaRestApiProps extends RestApiProps {
+    /**
+     * The default Lambda function that handles all requests from this API.
+     *
+     * This handler will be used as a the default integration for all methods in
+     * this API, unless specified otherwise in `addMethod`.
+     */
+    readonly handler: lambda.IFunction;
+    /**
+     * Specific Lambda integration options.
+     *
+     * @default see defaults defined in `LambdaIntegrationOptions`.
+     */
+    readonly integrationOptions?: LambdaIntegrationOptions;
+    /**
+     * If true, route all requests to the Lambda Function
+     *
+     * If set to false, you will need to explicitly define the API model using
+     * `addResource` and `addMethod` (or `addProxy`).
+     *
+     * @default true
+     */
+    readonly proxy?: boolean;
+    /**
+     * @deprecated the `LambdaRestApiProps` now extends `RestApiProps`, so all
+     * options are just available here. Note that the options specified in
+     * `options` will be overridden by any props specified at the root level.
+     *
+     * @default - no options.
+     */
+    readonly options?: RestApiProps;
+}
+/**
+ * Defines an API Gateway REST API with AWS Lambda proxy integration.
+ *
+ * Use the `proxy` property to define a greedy proxy ("{proxy+}") and "ANY"
+ * method from the specified path. If not defined, you will need to explicity
+ * add resources and methods to the API.
+ */
+export declare class LambdaRestApi extends RestApi {
+    constructor(scope: Construct, id: string, props: LambdaRestApiProps);
+}

package/lib/aws/compute/lambda-api.js

@@ -0,0 +1,64 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LambdaRestApi = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const integrations_1 = require("./integrations");
+const restapi_1 = require("./restapi");
+/**
+ * Defines an API Gateway REST API with AWS Lambda proxy integration.
+ *
+ * Use the `proxy` property to define a greedy proxy ("{proxy+}") and "ANY"
+ * method from the specified path. If not defined, you will need to explicity
+ * add resources and methods to the API.
+ */
+class LambdaRestApi extends restapi_1.RestApi {
+    constructor(scope, id, props) {
+        if (props.options?.defaultIntegration || props.defaultIntegration) {
+            // throw new ValidationError(
+            throw new Error('Cannot specify "defaultIntegration" since Lambda integration is automatically defined');
+        }
+        super(scope, id, {
+            defaultIntegration: new integrations_1.LambdaIntegration(props.handler, props.integrationOptions),
+            ...props.options, // deprecated, but we still support
+            ...props,
+        });
+        if (props.proxy !== false) {
+            this.root.addProxy();
+            // Make sure users cannot call any other resource adding function
+            this.root.addResource = addResourceThrows;
+            this.root.addMethod = addMethodThrows;
+            this.root.addProxy = addProxyThrows;
+        }
+        this.node.addValidation({
+            validate() {
+                for (const value of Object.values(props.deployOptions?.variables ?? {})) {
+                    // Checks that variable Stage values match regex
+                    const regexp = /[A-Za-z0-9-._~:/?#&=,]+/;
+                    if (value.match(regexp) === null) {
+                        return [
+                            "Stage variable value " + value + " does not match the regex.",
+                        ];
+                    }
+                }
+                return [];
+            },
+        });
+    }
+}
+exports.LambdaRestApi = LambdaRestApi;
+_a = JSII_RTTI_SYMBOL_1;
+LambdaRestApi[_a] = { fqn: "terraconstructs.aws.compute.LambdaRestApi", version: "0.1.0" };
+function addResourceThrows() {
+    // throw new UnscopedValidationError(
+    throw new Error("Cannot call 'addResource' on a proxying LambdaRestApi; set 'proxy' to false");
+}
+function addMethodThrows() {
+    // throw new UnscopedValidationError(
+    throw new Error("Cannot call 'addMethod' on a proxying LambdaRestApi; set 'proxy' to false");
+}
+function addProxyThrows() {
+    // throw new UnscopedValidationError(
+    throw new Error("Cannot call 'addProxy' on a proxying LambdaRestApi; set 'proxy' to false");
+}
+//# sourceMappingURL=data:application/json;base64,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