terraconstructs 0.0.24 → 0.1.0

package/lib/aws/compute/code.js

@@ -0,0 +1,424 @@
+"use strict";
+var _a, _b, _c, _d, _e, _f, _g, _h;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetImageCode = exports.EcrImageCode = exports.TerraformVariablesCode = exports.AssetCode = exports.InlineCode = exports.S3CodeV2 = exports.S3Code = exports.Code = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const child_process_1 = require("child_process");
+const cdktf = require("cdktf");
+const bundling_1 = require("../../bundling");
+const aws_stack_1 = require("../aws-stack");
+const iam = require("../iam");
+// import { IAwsConstruct } from "../aws-construct";
+const ecr_assets = require("../storage/assets/image-asset");
+const s3_assets = require("../storage/assets/s3");
+// TODO: Adopt UnscopedValidationError
+// - https://github.com/aws/aws-cdk/pull/33382/
+// - https://github.com/aws/aws-cdk/pull/33045
+// import {
+//   UnscopedValidationError,
+//   ValidationError,
+// } from "../../core/lib/errors";
+/**
+ * Represents the Lambda Handler Code.
+ */
+class Code {
+    /**
+     * Lambda handler code as an S3 object.
+     * @param bucket The S3 bucket
+     * @param key The object key
+     * @param objectVersion Optional S3 object version
+     */
+    static fromBucket(bucket, key, objectVersion) {
+        return new S3Code(bucket, key, objectVersion);
+    }
+    /**
+     * Lambda handler code as an S3 object.
+     * @param bucket The S3 bucket
+     * @param key The object key
+     * @param options Optional parameters for setting the code, current optional parameters to set here are
+     * 1. `objectVersion` to set S3 object version
+     * 2. `sourceKMSKey` to set KMS Key for encryption of code
+     */
+    static fromBucketV2(bucket, key, options) {
+        return new S3CodeV2(bucket, key, options);
+    }
+    /**
+     * DEPRECATED
+     * @deprecated use `fromBucket`
+     */
+    static bucket(bucket, key, objectVersion) {
+        return this.fromBucket(bucket, key, objectVersion);
+    }
+    /**
+     * Inline code for Lambda handler
+     * @returns `LambdaInlineCode` with inline code.
+     * @param code The actual handler code (the resulting zip file cannot exceed 4MB)
+     */
+    static fromInline(code) {
+        return new InlineCode(code);
+    }
+    /**
+     * DEPRECATED
+     * @deprecated use `fromInline`
+     */
+    static inline(code) {
+        return this.fromInline(code);
+    }
+    /**
+     * Loads the function code from a local disk path.
+     *
+     * @param path Either a directory with the Lambda code bundle or a .zip file
+     */
+    static fromAsset(path, options) {
+        return new AssetCode(path, options);
+    }
+    /**
+     * Runs a command to build the code asset that will be used.
+     *
+     * @param output Where the output of the command will be directed, either a directory or a .zip file with the output Lambda code bundle
+     * * For example, if you use the command to run a build script (e.g., [ 'node', 'bundle_code.js' ]), and the build script generates a directory `/my/lambda/code`
+     * containing code that should be ran in a Lambda function, then output should be set to `/my/lambda/code`
+     * @param command The command which will be executed to generate the output, for example, [ 'node', 'bundle_code.js' ]
+     * @param options options for the custom command, and other asset options -- but bundling options are not allowed.
+     */
+    static fromCustomCommand(output, command, options) {
+        if (command.length === 0) {
+            // throw new UnscopedValidationError(
+            throw new Error('command must contain at least one argument. For example, ["node", "buildFile.js"].');
+        }
+        const cmd = command[0];
+        const commandArguments = command.splice(1);
+        const proc = options?.commandOptions === undefined
+            ? (0, child_process_1.spawnSync)(cmd, commandArguments) // use the default spawnSyncOptions
+            : (0, child_process_1.spawnSync)(cmd, commandArguments, options.commandOptions);
+        if (proc.error) {
+            // throw new UnscopedValidationError(
+            throw new Error(`Failed to execute custom command: ${proc.error}`);
+        }
+        if (proc.status !== 0) {
+            // throw new UnscopedValidationError(
+            throw new Error(`${command.join(" ")} exited with status: ${proc.status}\n\nstdout: ${proc.stdout?.toString().trim()}\n\nstderr: ${proc.stderr?.toString().trim()}`);
+        }
+        return new AssetCode(output, options);
+    }
+    /**
+     * Loads the function code from an asset created by a Docker build.
+     *
+     * By default, the asset is expected to be located at `/asset` in the
+     * image.
+     *
+     * @param path The path to the directory containing the Docker file
+     * @param options Docker build options
+     */
+    static fromDockerBuild(path, options = {}) {
+        let imagePath = options.imagePath ?? "/asset/.";
+        // ensure imagePath ends with /. to copy the **content** at this path
+        if (imagePath.endsWith("/")) {
+            imagePath = `${imagePath}.`;
+        }
+        else if (!imagePath.endsWith("/.")) {
+            imagePath = `${imagePath}/.`;
+        }
+        const assetPath = bundling_1.DockerImage.fromBuild(path, options).cp(imagePath, options.outputPath);
+        return new AssetCode(assetPath);
+    }
+    /**
+     * DEPRECATED
+     * @deprecated use `fromAsset`
+     */
+    static asset(path) {
+        return this.fromAsset(path);
+    }
+    /**
+     * Creates a new Lambda source defined using Terraform variables.
+     *
+     * @returns a new instance of `TerraformVariablesCode`
+     * @param props optional construction properties of `TerraformVariablesCode`
+     */
+    static fromTerraformVariables(props) {
+        return new TerraformVariablesCode(props);
+    }
+    /**
+     * DEPRECATED
+     * @deprecated use `fromCfnParameters`
+     */
+    static terraformVariables(props) {
+        return this.fromTerraformVariables(props);
+    }
+    /**
+     * Use an existing ECR image as the Lambda code.
+     * @param repository the ECR repository that the image is in
+     * @param props properties to further configure the selected image
+     */
+    static fromEcrImage(repository, props) {
+        return new EcrImageCode(repository, props);
+    }
+    /**
+     * Create an ECR image from the specified asset and bind it as the Lambda code.
+     * @param directory the directory from which the asset must be created
+     * @param props properties to further configure the selected image
+     */
+    static fromAssetImage(directory, props = {}) {
+        return new AssetImageCode(directory, props);
+    }
+}
+exports.Code = Code;
+_a = JSII_RTTI_SYMBOL_1;
+Code[_a] = { fqn: "terraconstructs.aws.compute.Code", version: "0.1.0" };
+/**
+ * Lambda code from an S3 archive.
+ */
+class S3Code extends Code {
+    constructor(bucket, key, objectVersion) {
+        super();
+        this.key = key;
+        this.objectVersion = objectVersion;
+        this.isInline = false;
+        if (!bucket.bucketName) {
+            // throw new ValidationError(
+            throw new Error("bucketName is undefined for the provided bucket");
+        }
+        this.bucketName = bucket.bucketName;
+    }
+    bind(_scope) {
+        return {
+            s3Location: {
+                bucketName: this.bucketName,
+                objectKey: this.key,
+                objectVersion: this.objectVersion,
+            },
+        };
+    }
+}
+exports.S3Code = S3Code;
+_b = JSII_RTTI_SYMBOL_1;
+S3Code[_b] = { fqn: "terraconstructs.aws.compute.S3Code", version: "0.1.0" };
+/**
+ * Lambda code from an S3 archive. With option to set KMSKey for encryption.
+ */
+class S3CodeV2 extends Code {
+    constructor(bucket, key, options) {
+        super();
+        this.key = key;
+        this.options = options;
+        this.isInline = false;
+        if (!bucket.bucketName) {
+            // throw new ValidationError(
+            throw new Error("bucketName is undefined for the provided bucket");
+        }
+        this.bucketName = bucket.bucketName;
+    }
+    bind(_scope) {
+        return {
+            s3Location: {
+                bucketName: this.bucketName,
+                objectKey: this.key,
+                objectVersion: this.options?.objectVersion,
+            },
+            sourceKMSKeyArn: this.options?.sourceKMSKey?.keyArn,
+        };
+    }
+}
+exports.S3CodeV2 = S3CodeV2;
+_c = JSII_RTTI_SYMBOL_1;
+S3CodeV2[_c] = { fqn: "terraconstructs.aws.compute.S3CodeV2", version: "0.1.0" };
+/**
+ * Lambda code from an inline string.
+ */
+class InlineCode extends Code {
+    constructor(code) {
+        super();
+        this.code = code;
+        this.isInline = true;
+        if (code.length === 0) {
+            // throw new UnscopedValidationError(
+            throw new Error("Lambda inline code cannot be empty");
+        }
+    }
+    bind(_scope) {
+        return {
+            inlineCode: this.code,
+        };
+    }
+}
+exports.InlineCode = InlineCode;
+_d = JSII_RTTI_SYMBOL_1;
+InlineCode[_d] = { fqn: "terraconstructs.aws.compute.InlineCode", version: "0.1.0" };
+/**
+ * Lambda code from a local directory.
+ */
+class AssetCode extends Code {
+    /**
+     * @param path The path to the asset file or directory.
+     */
+    constructor(path, options = {}) {
+        super();
+        this.path = path;
+        this.options = options;
+        this.isInline = false;
+    }
+    bind(scope) {
+        // If the same AssetCode is used multiple times, retain only the first instantiation.
+        if (!this.asset) {
+            this.asset = new s3_assets.Asset(scope, "Code", {
+                path: this.path,
+                deployTime: true,
+                ...this.options,
+            });
+        }
+        else if (aws_stack_1.AwsStack.ofAwsConstruct(this.asset) !== aws_stack_1.AwsStack.ofAwsConstruct(scope)) {
+            // throw new ValidationError(
+            throw new Error(`Asset is already associated with another stack '${aws_stack_1.AwsStack.ofAwsConstruct(this.asset).gridUUID}'. ` +
+                "Create a new Code instance for every stack.");
+        }
+        if (!this.asset.isZipArchive) {
+            // throw new ValidationError(
+            throw new Error(`Asset must be a .zip file or a directory (${this.path})`);
+        }
+        return {
+            s3Location: {
+                bucketName: this.asset.s3BucketName,
+                objectKey: this.asset.s3ObjectKey,
+            },
+            sourceKMSKeyArn: this.options.sourceKMSKey?.keyArn,
+        };
+    }
+}
+exports.AssetCode = AssetCode;
+_e = JSII_RTTI_SYMBOL_1;
+AssetCode[_e] = { fqn: "terraconstructs.aws.compute.AssetCode", version: "0.1.0" };
+/**
+ * Lambda code defined using 2 Terraform variables.
+ * Useful when you don't have access to the code of your Lambda from your CDK code, so you can't use Assets,
+ * and you want to deploy the Lambda in a pipeline, during Terraform execution.
+ */
+class TerraformVariablesCode extends Code {
+    constructor(props = {}) {
+        super();
+        this.isInline = false;
+        this._bucketNameVar = props.bucketNameVar;
+        this._objectKeyVar = props.objectKeyVar;
+        this._sourceKMSKey = props.sourceKMSKey;
+    }
+    bind(scope) {
+        if (!this._bucketNameVar) {
+            this._bucketNameVar = new cdktf.TerraformVariable(scope, "LambdaSourceBucketNameParameter", {
+                type: "String",
+            });
+        }
+        if (!this._objectKeyVar) {
+            this._objectKeyVar = new cdktf.TerraformVariable(scope, "LambdaSourceObjectKeyParameter", {
+                type: "String",
+            });
+        }
+        return {
+            s3Location: {
+                bucketName: this._bucketNameVar.stringValue,
+                objectKey: this._objectKeyVar.stringValue,
+            },
+            sourceKMSKeyArn: this._sourceKMSKey?.keyArn,
+        };
+    }
+    /**
+     * Create a parameters map from this instance's Terraform variables.
+     *
+     * It returns a map with 2 keys that correspond to the names of the parameters defined in this Lambda code,
+     * and as values it contains the appropriate expressions pointing at the provided S3 location
+     * (most likely, obtained from a CodePipeline Artifact by calling the `artifact.s3Location` method).
+     * The result should be provided to the CloudFormation Action
+     * that is deploying the Stack that the Lambda with this code is part of,
+     * in the `parameterOverrides` property.
+     *
+     * @param location the location of the object in S3 that represents the Lambda code
+     */
+    assign(location) {
+        const ret = {};
+        ret[this.bucketNameVar] = location.bucketName;
+        ret[this.objectKeyVar] = location.objectKey;
+        return ret;
+    }
+    get bucketNameVar() {
+        if (this._bucketNameVar) {
+            return this._bucketNameVar.fqn;
+        }
+        else {
+            // throw new UnscopedValidationError(
+            throw new Error("Pass TerraformVariablesCode to a Lambda Function before accessing the bucketNameVar property");
+        }
+    }
+    get objectKeyVar() {
+        if (this._objectKeyVar) {
+            return this._objectKeyVar.fqn;
+        }
+        else {
+            // throw new UnscopedValidationError(
+            throw new Error("Pass TerraformVariablesCode to a Lambda Function before accessing the objectKeyVar property");
+        }
+    }
+}
+exports.TerraformVariablesCode = TerraformVariablesCode;
+_f = JSII_RTTI_SYMBOL_1;
+TerraformVariablesCode[_f] = { fqn: "terraconstructs.aws.compute.TerraformVariablesCode", version: "0.1.0" };
+/**
+ * Represents a Docker image in ECR that can be bound as Lambda Code.
+ */
+class EcrImageCode extends Code {
+    constructor(repository, props = {}) {
+        super();
+        this.repository = repository;
+        this.props = props;
+        this.isInline = false;
+    }
+    bind(_scope) {
+        this.repository.grantPull(new iam.ServicePrincipal("lambda.amazonaws.com"));
+        return {
+            image: {
+                imageUri: this.repository.repositoryUriForTagOrDigest(this.props?.tagOrDigest ?? this.props?.tag ?? "latest"),
+                cmd: this.props.cmd,
+                entrypoint: this.props.entrypoint,
+                workingDirectory: this.props.workingDirectory,
+            },
+        };
+    }
+}
+exports.EcrImageCode = EcrImageCode;
+_g = JSII_RTTI_SYMBOL_1;
+EcrImageCode[_g] = { fqn: "terraconstructs.aws.compute.EcrImageCode", version: "0.1.0" };
+/**
+ * Represents an ECR image that will be constructed from the specified asset and can be bound as Lambda code.
+ */
+class AssetImageCode extends Code {
+    constructor(directory, props) {
+        super();
+        this.directory = directory;
+        this.props = props;
+        this.isInline = false;
+    }
+    bind(scope) {
+        // If the same AssetImageCode is used multiple times, retain only the first instantiation.
+        if (!this.asset) {
+            this.asset = new ecr_assets.DockerImageAsset(scope, "AssetImage", {
+                directory: this.directory,
+                ...this.props,
+            });
+            this.asset.repository.grantPull(new iam.ServicePrincipal("lambda.amazonaws.com"));
+        }
+        else if (aws_stack_1.AwsStack.ofAwsConstruct(this.asset) !== aws_stack_1.AwsStack.ofAwsConstruct(scope)) {
+            // throw new ValidationError(
+            throw new Error(`Asset is already associated with another stack '${aws_stack_1.AwsStack.ofAwsConstruct(this.asset).gridUUID}'. ` +
+                "Create a new Code instance for every stack.");
+        }
+        return {
+            image: {
+                imageUri: this.asset.imageUri,
+                entrypoint: this.props.entrypoint,
+                cmd: this.props.cmd,
+                workingDirectory: this.props.workingDirectory,
+            },
+        };
+    }
+}
+exports.AssetImageCode = AssetImageCode;
+_h = JSII_RTTI_SYMBOL_1;
+AssetImageCode[_h] = { fqn: "terraconstructs.aws.compute.AssetImageCode", version: "0.1.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"code.js","sourceRoot":"","sources":["../../../src/aws/compute/code.ts"],"names":[],"mappings":"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","sourcesContent":["import { spawnSync } from \"child_process\";\nimport * as cdktf from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { DockerImage, DockerBuildOptions } from \"../../bundling\";\nimport { AwsStack } from \"../aws-stack\";\nimport { IKey } from \"../encryption\";\nimport * as iam from \"../iam\";\nimport * as storage from \"../storage\";\n// import { IAwsConstruct } from \"../aws-construct\";\nimport * as ecr_assets from \"../storage/assets/image-asset\";\nimport * as s3_assets from \"../storage/assets/s3\";\n// TODO: Adopt UnscopedValidationError\n// - https://github.com/aws/aws-cdk/pull/33382/\n// - https://github.com/aws/aws-cdk/pull/33045\n// import {\n//   UnscopedValidationError,\n//   ValidationError,\n// } from \"../../core/lib/errors\";\n\n/**\n * Represents the Lambda Handler Code.\n */\nexport abstract class Code {\n  /**\n   * Lambda handler code as an S3 object.\n   * @param bucket The S3 bucket\n   * @param key The object key\n   * @param objectVersion Optional S3 object version\n   */\n  public static fromBucket(\n    bucket: storage.IBucket,\n    key: string,\n    objectVersion?: string,\n  ): S3Code {\n    return new S3Code(bucket, key, objectVersion);\n  }\n\n  /**\n   * Lambda handler code as an S3 object.\n   * @param bucket The S3 bucket\n   * @param key The object key\n   * @param options Optional parameters for setting the code, current optional parameters to set here are\n   * 1. `objectVersion` to set S3 object version\n   * 2. `sourceKMSKey` to set KMS Key for encryption of code\n   */\n  public static fromBucketV2(\n    bucket: storage.IBucket,\n    key: string,\n    options?: BucketOptions,\n  ): S3CodeV2 {\n    return new S3CodeV2(bucket, key, options);\n  }\n\n  /**\n   * DEPRECATED\n   * @deprecated use `fromBucket`\n   */\n  public static bucket(\n    bucket: storage.IBucket,\n    key: string,\n    objectVersion?: string,\n  ): S3Code {\n    return this.fromBucket(bucket, key, objectVersion);\n  }\n\n  /**\n   * Inline code for Lambda handler\n   * @returns `LambdaInlineCode` with inline code.\n   * @param code The actual handler code (the resulting zip file cannot exceed 4MB)\n   */\n  public static fromInline(code: string): InlineCode {\n    return new InlineCode(code);\n  }\n\n  /**\n   * DEPRECATED\n   * @deprecated use `fromInline`\n   */\n  public static inline(code: string): InlineCode {\n    return this.fromInline(code);\n  }\n\n  /**\n   * Loads the function code from a local disk path.\n   *\n   * @param path Either a directory with the Lambda code bundle or a .zip file\n   */\n  public static fromAsset(\n    path: string,\n    options?: s3_assets.AssetOptions,\n  ): AssetCode {\n    return new AssetCode(path, options);\n  }\n\n  /**\n   * Runs a command to build the code asset that will be used.\n   *\n   * @param output Where the output of the command will be directed, either a directory or a .zip file with the output Lambda code bundle\n   * * For example, if you use the command to run a build script (e.g., [ 'node', 'bundle_code.js' ]), and the build script generates a directory `/my/lambda/code`\n   * containing code that should be ran in a Lambda function, then output should be set to `/my/lambda/code`\n   * @param command The command which will be executed to generate the output, for example, [ 'node', 'bundle_code.js' ]\n   * @param options options for the custom command, and other asset options -- but bundling options are not allowed.\n   */\n  public static fromCustomCommand(\n    output: string,\n    command: string[],\n    options?: CustomCommandOptions,\n  ): AssetCode {\n    if (command.length === 0) {\n      // throw new UnscopedValidationError(\n      throw new Error(\n        'command must contain at least one argument. For example, [\"node\", \"buildFile.js\"].',\n      );\n    }\n\n    const cmd = command[0];\n    const commandArguments = command.splice(1);\n\n    const proc =\n      options?.commandOptions === undefined\n        ? spawnSync(cmd, commandArguments) // use the default spawnSyncOptions\n        : spawnSync(cmd, commandArguments, options.commandOptions);\n\n    if (proc.error) {\n      // throw new UnscopedValidationError(\n      throw new Error(`Failed to execute custom command: ${proc.error}`);\n    }\n    if (proc.status !== 0) {\n      // throw new UnscopedValidationError(\n      throw new Error(\n        `${command.join(\" \")} exited with status: ${proc.status}\\n\\nstdout: ${proc.stdout?.toString().trim()}\\n\\nstderr: ${proc.stderr?.toString().trim()}`,\n      );\n    }\n\n    return new AssetCode(output, options);\n  }\n\n  /**\n   * Loads the function code from an asset created by a Docker build.\n   *\n   * By default, the asset is expected to be located at `/asset` in the\n   * image.\n   *\n   * @param path The path to the directory containing the Docker file\n   * @param options Docker build options\n   */\n  public static fromDockerBuild(\n    path: string,\n    options: DockerBuildAssetOptions = {},\n  ): AssetCode {\n    let imagePath = options.imagePath ?? \"/asset/.\";\n\n    // ensure imagePath ends with /. to copy the **content** at this path\n    if (imagePath.endsWith(\"/\")) {\n      imagePath = `${imagePath}.`;\n    } else if (!imagePath.endsWith(\"/.\")) {\n      imagePath = `${imagePath}/.`;\n    }\n\n    const assetPath = DockerImage.fromBuild(path, options).cp(\n      imagePath,\n      options.outputPath,\n    );\n\n    return new AssetCode(assetPath);\n  }\n\n  /**\n   * DEPRECATED\n   * @deprecated use `fromAsset`\n   */\n  public static asset(path: string): AssetCode {\n    return this.fromAsset(path);\n  }\n\n  /**\n   * Creates a new Lambda source defined using Terraform variables.\n   *\n   * @returns a new instance of `TerraformVariablesCode`\n   * @param props optional construction properties of `TerraformVariablesCode`\n   */\n  public static fromTerraformVariables(\n    props?: TerraformVariablesCodeProps,\n  ): TerraformVariablesCode {\n    return new TerraformVariablesCode(props);\n  }\n\n  /**\n   * DEPRECATED\n   * @deprecated use `fromCfnParameters`\n   */\n  public static terraformVariables(\n    props?: TerraformVariablesCodeProps,\n  ): TerraformVariablesCode {\n    return this.fromTerraformVariables(props);\n  }\n\n  /**\n   * Use an existing ECR image as the Lambda code.\n   * @param repository the ECR repository that the image is in\n   * @param props properties to further configure the selected image\n   */\n  public static fromEcrImage(\n    repository: storage.IRepository,\n    props?: EcrImageCodeProps,\n  ) {\n    return new EcrImageCode(repository, props);\n  }\n\n  /**\n   * Create an ECR image from the specified asset and bind it as the Lambda code.\n   * @param directory the directory from which the asset must be created\n   * @param props properties to further configure the selected image\n   */\n  public static fromAssetImage(\n    directory: string,\n    props: AssetImageCodeProps = {},\n  ) {\n    return new AssetImageCode(directory, props);\n  }\n\n  /**\n   * Determines whether this Code is inline code or not.\n   *\n   * @deprecated this value is ignored since inline is now determined based on the\n   * the `inlineCode` field of `CodeConfig` returned from `bind()`.\n   */\n  public abstract readonly isInline: boolean;\n\n  /**\n   * Called when the lambda or layer is initialized to allow this object to bind\n   * to the stack, add resources and have fun.\n   *\n   * @param scope The binding scope. Don't be smart about trying to down-cast or\n   * assume it's initialized. You may just use it as a construct scope.\n   */\n  public abstract bind(scope: Construct): CodeConfig;\n\n  // TODO: pending custom CLI to mock Lambda function invocations locally\n  // /**\n  //  * Called after the terraform provider function resource has been created to allow the code\n  //  * class to bind to it. Specifically it's required to allow assets to add\n  //  * metadata for tooling like SAM CLI to be able to find their origins.\n  //  */\n  // public bindToResource(\n  //   _resource: IAwsConstruct,\n  //   _options?: ResourceBindOptions,\n  // ) {\n  //   return;\n  // }\n}\n\n/**\n * Result of binding `Code` into a `Function`.\n */\nexport interface CodeConfig {\n  /**\n   * The location of the code in S3 (mutually exclusive with `inlineCode` and `image`).\n   * @default - code is not an s3 location\n   */\n  readonly s3Location?: storage.S3Location;\n\n  /**\n   * Inline code (mutually exclusive with `s3Location` and `image`).\n   * @default - code is not inline code\n   */\n  readonly inlineCode?: string;\n\n  /**\n   * Docker image configuration (mutually exclusive with `s3Location` and `inlineCode`).\n   * @default - code is not an ECR container image\n   */\n  readonly image?: CodeImageConfig;\n\n  /**\n   * The ARN of the KMS key used to encrypt the handler code.\n   * @default - the default server-side encryption with Amazon S3 managed keys(SSE-S3) key will be used.\n   */\n  readonly sourceKMSKeyArn?: string;\n\n  /**\n   * A hash of the source code, used to determine if the code has changed.\n   */\n  readonly sourceCodeHash?: string;\n}\n\n/**\n * Result of the bind when an ECR image is used.\n */\nexport interface CodeImageConfig {\n  /**\n   * URI to the Docker image.\n   */\n  readonly imageUri: string;\n\n  /**\n   * Specify or override the CMD on the specified Docker image or Dockerfile.\n   * This needs to be in the 'exec form', viz., `[ 'executable', 'param1', 'param2' ]`.\n   * @see https://docs.docker.com/engine/reference/builder/#cmd\n   * @default - use the CMD specified in the docker image or Dockerfile.\n   */\n  readonly cmd?: string[];\n\n  /**\n   * Specify or override the ENTRYPOINT on the specified Docker image or Dockerfile.\n   * An ENTRYPOINT allows you to configure a container that will run as an executable.\n   * This needs to be in the 'exec form', viz., `[ 'executable', 'param1', 'param2' ]`.\n   * @see https://docs.docker.com/engine/reference/builder/#entrypoint\n   * @default - use the ENTRYPOINT in the docker image or Dockerfile.\n   */\n  readonly entrypoint?: string[];\n\n  /**\n   * Specify or override the WORKDIR on the specified Docker image or Dockerfile.\n   * A WORKDIR allows you to configure the working directory the container will use.\n   * @see https://docs.docker.com/engine/reference/builder/#workdir\n   * @default - use the WORKDIR in the docker image or Dockerfile.\n   */\n  readonly workingDirectory?: string;\n}\n\n/**\n * Lambda code from an S3 archive.\n */\nexport class S3Code extends Code {\n  public readonly isInline = false;\n  private bucketName: string;\n\n  constructor(\n    bucket: storage.IBucket,\n    private key: string,\n    private objectVersion?: string,\n  ) {\n    super();\n\n    if (!bucket.bucketName) {\n      // throw new ValidationError(\n      throw new Error(\n        \"bucketName is undefined for the provided bucket\",\n        // bucket,\n      );\n    }\n\n    this.bucketName = bucket.bucketName;\n  }\n\n  public bind(_scope: Construct): CodeConfig {\n    return {\n      s3Location: {\n        bucketName: this.bucketName,\n        objectKey: this.key,\n        objectVersion: this.objectVersion,\n      },\n    };\n  }\n}\n\n/**\n * Lambda code from an S3 archive. With option to set KMSKey for encryption.\n */\nexport class S3CodeV2 extends Code {\n  public readonly isInline = false;\n  private bucketName: string;\n\n  constructor(\n    bucket: storage.IBucket,\n    private key: string,\n    private options?: BucketOptions,\n  ) {\n    super();\n    if (!bucket.bucketName) {\n      // throw new ValidationError(\n      throw new Error(\n        \"bucketName is undefined for the provided bucket\",\n        // bucket,\n      );\n    }\n\n    this.bucketName = bucket.bucketName;\n  }\n\n  public bind(_scope: Construct): CodeConfig {\n    return {\n      s3Location: {\n        bucketName: this.bucketName,\n        objectKey: this.key,\n        objectVersion: this.options?.objectVersion,\n      },\n      sourceKMSKeyArn: this.options?.sourceKMSKey?.keyArn,\n    };\n  }\n}\n\n/**\n * Lambda code from an inline string.\n */\nexport class InlineCode extends Code {\n  public readonly isInline = true;\n\n  constructor(private code: string) {\n    super();\n\n    if (code.length === 0) {\n      // throw new UnscopedValidationError(\n      throw new Error(\"Lambda inline code cannot be empty\");\n    }\n  }\n\n  public bind(_scope: Construct): CodeConfig {\n    return {\n      inlineCode: this.code,\n    };\n  }\n}\n\n/**\n * Lambda code from a local directory.\n */\nexport class AssetCode extends Code {\n  public readonly isInline = false;\n  private asset?: s3_assets.Asset;\n\n  /**\n   * @param path The path to the asset file or directory.\n   */\n  constructor(\n    public readonly path: string,\n    private readonly options: s3_assets.AssetOptions = {},\n  ) {\n    super();\n  }\n\n  public bind(scope: Construct): CodeConfig {\n    // If the same AssetCode is used multiple times, retain only the first instantiation.\n    if (!this.asset) {\n      this.asset = new s3_assets.Asset(scope, \"Code\", {\n        path: this.path,\n        deployTime: true,\n        ...this.options,\n      });\n    } else if (\n      AwsStack.ofAwsConstruct(this.asset) !== AwsStack.ofAwsConstruct(scope)\n    ) {\n      // throw new ValidationError(\n      throw new Error(\n        `Asset is already associated with another stack '${AwsStack.ofAwsConstruct(this.asset).gridUUID}'. ` +\n          \"Create a new Code instance for every stack.\",\n        // scope,\n      );\n    }\n\n    if (!this.asset.isZipArchive) {\n      // throw new ValidationError(\n      throw new Error(\n        `Asset must be a .zip file or a directory (${this.path})`,\n        // scope,\n      );\n    }\n\n    return {\n      s3Location: {\n        bucketName: this.asset.s3BucketName,\n        objectKey: this.asset.s3ObjectKey,\n      },\n      sourceKMSKeyArn: this.options.sourceKMSKey?.keyArn,\n    };\n  }\n\n  // public bindToResource(\n  //   resource: IAwsConstruct,\n  //   options: ResourceBindOptions = {},\n  // ) {\n  //   if (!this.asset) {\n  //     // throw new ValidationError(\n  //     throw new Error(\n  //       \"bindToResource() must be called after bind()\",\n  //       // resource,\n  //     );\n  //   }\n\n  //   const resourceProperty = options.resourceProperty || \"Code\";\n  //   // https://github.com/aws/aws-cdk/issues/1432\n  //   this.asset.addResourceMetadata(resource, resourceProperty);\n  // }\n}\n\nexport interface ResourceBindOptions {\n  /**\n   * The name of the property to annotate with asset metadata.\n   * @see https://github.com/aws/aws-cdk/issues/1432\n   * @default Code\n   */\n  readonly resourceProperty?: string;\n}\n\n/**\n * Construction properties for `TerraformVariablesCode`.\n */\nexport interface TerraformVariablesCodeProps {\n  /**\n   * The Terraform variable that represents the name of the S3 Bucket\n   * where the Lambda code will be located in.\n   * Must be of type 'String'.\n   *\n   * @default a new variable will be created\n   */\n  readonly bucketNameVar?: cdktf.TerraformVariable;\n\n  /**\n   * The Terraform variable that represents the path inside the S3 Bucket\n   * where the Lambda code will be located at.\n   * Must be of type 'String'.\n   *\n   * @default a new variable will be created\n   */\n  readonly objectKeyVar?: cdktf.TerraformVariable;\n  /**\n   * The ARN of the KMS key used to encrypt the handler code.\n   * @default - the default server-side encryption with Amazon S3 managed keys(SSE-S3) key will be used.\n   */\n  readonly sourceKMSKey?: IKey;\n}\n\n/**\n * Lambda code defined using 2 Terraform variables.\n * Useful when you don't have access to the code of your Lambda from your CDK code, so you can't use Assets,\n * and you want to deploy the Lambda in a pipeline, during Terraform execution.\n */\nexport class TerraformVariablesCode extends Code {\n  public readonly isInline = false;\n  private _bucketNameVar?: cdktf.TerraformVariable;\n  private _objectKeyVar?: cdktf.TerraformVariable;\n  private _sourceKMSKey?: IKey;\n\n  constructor(props: TerraformVariablesCodeProps = {}) {\n    super();\n\n    this._bucketNameVar = props.bucketNameVar;\n    this._objectKeyVar = props.objectKeyVar;\n    this._sourceKMSKey = props.sourceKMSKey;\n  }\n\n  public bind(scope: Construct): CodeConfig {\n    if (!this._bucketNameVar) {\n      this._bucketNameVar = new cdktf.TerraformVariable(\n        scope,\n        \"LambdaSourceBucketNameParameter\",\n        {\n          type: \"String\",\n        },\n      );\n    }\n\n    if (!this._objectKeyVar) {\n      this._objectKeyVar = new cdktf.TerraformVariable(\n        scope,\n        \"LambdaSourceObjectKeyParameter\",\n        {\n          type: \"String\",\n        },\n      );\n    }\n\n    return {\n      s3Location: {\n        bucketName: this._bucketNameVar.stringValue,\n        objectKey: this._objectKeyVar.stringValue,\n      },\n      sourceKMSKeyArn: this._sourceKMSKey?.keyArn,\n    };\n  }\n\n  /**\n   * Create a parameters map from this instance's Terraform variables.\n   *\n   * It returns a map with 2 keys that correspond to the names of the parameters defined in this Lambda code,\n   * and as values it contains the appropriate expressions pointing at the provided S3 location\n   * (most likely, obtained from a CodePipeline Artifact by calling the `artifact.s3Location` method).\n   * The result should be provided to the CloudFormation Action\n   * that is deploying the Stack that the Lambda with this code is part of,\n   * in the `parameterOverrides` property.\n   *\n   * @param location the location of the object in S3 that represents the Lambda code\n   */\n  public assign(location: storage.S3Location): { [name: string]: any } {\n    const ret: { [name: string]: any } = {};\n    ret[this.bucketNameVar] = location.bucketName;\n    ret[this.objectKeyVar] = location.objectKey;\n    return ret;\n  }\n\n  public get bucketNameVar(): string {\n    if (this._bucketNameVar) {\n      return this._bucketNameVar.fqn;\n    } else {\n      // throw new UnscopedValidationError(\n      throw new Error(\n        \"Pass TerraformVariablesCode to a Lambda Function before accessing the bucketNameVar property\",\n      );\n    }\n  }\n\n  public get objectKeyVar(): string {\n    if (this._objectKeyVar) {\n      return this._objectKeyVar.fqn;\n    } else {\n      // throw new UnscopedValidationError(\n      throw new Error(\n        \"Pass TerraformVariablesCode to a Lambda Function before accessing the objectKeyVar property\",\n      );\n    }\n  }\n}\n\n/**\n * Properties to initialize a new EcrImageCode\n */\nexport interface EcrImageCodeProps {\n  /**\n   * Specify or override the CMD on the specified Docker image or Dockerfile.\n   * This needs to be in the 'exec form', viz., `[ 'executable', 'param1', 'param2' ]`.\n   * @see https://docs.docker.com/engine/reference/builder/#cmd\n   * @default - use the CMD specified in the docker image or Dockerfile.\n   */\n  readonly cmd?: string[];\n\n  /**\n   * Specify or override the ENTRYPOINT on the specified Docker image or Dockerfile.\n   * An ENTRYPOINT allows you to configure a container that will run as an executable.\n   * This needs to be in the 'exec form', viz., `[ 'executable', 'param1', 'param2' ]`.\n   * @see https://docs.docker.com/engine/reference/builder/#entrypoint\n   * @default - use the ENTRYPOINT in the docker image or Dockerfile.\n   */\n  readonly entrypoint?: string[];\n\n  /**\n   * Specify or override the WORKDIR on the specified Docker image or Dockerfile.\n   * A WORKDIR allows you to configure the working directory the container will use.\n   * @see https://docs.docker.com/engine/reference/builder/#workdir\n   * @default - use the WORKDIR in the docker image or Dockerfile.\n   */\n  readonly workingDirectory?: string;\n\n  /**\n   * The image tag to use when pulling the image from ECR.\n   * @default 'latest'\n   * @deprecated use `tagOrDigest`\n   */\n  readonly tag?: string;\n\n  /**\n   * The image tag or digest to use when pulling the image from ECR (digests must start with `sha256:`).\n   * @default 'latest'\n   */\n  readonly tagOrDigest?: string;\n}\n\n/**\n * Represents a Docker image in ECR that can be bound as Lambda Code.\n */\nexport class EcrImageCode extends Code {\n  public readonly isInline: boolean = false;\n\n  constructor(\n    private readonly repository: storage.IRepository,\n    private readonly props: EcrImageCodeProps = {},\n  ) {\n    super();\n  }\n\n  public bind(_scope: Construct): CodeConfig {\n    this.repository.grantPull(new iam.ServicePrincipal(\"lambda.amazonaws.com\"));\n\n    return {\n      image: {\n        imageUri: this.repository.repositoryUriForTagOrDigest(\n          this.props?.tagOrDigest ?? this.props?.tag ?? \"latest\",\n        ),\n        cmd: this.props.cmd,\n        entrypoint: this.props.entrypoint,\n        workingDirectory: this.props.workingDirectory,\n      },\n    };\n  }\n}\n\n/**\n * Properties to initialize a new AssetImage\n */\nexport interface AssetImageCodeProps\n  extends ecr_assets.DockerImageAssetOptions {\n  /**\n   * Specify or override the CMD on the specified Docker image or Dockerfile.\n   * This needs to be in the 'exec form', viz., `[ 'executable', 'param1', 'param2' ]`.\n   * @see https://docs.docker.com/engine/reference/builder/#cmd\n   * @default - use the CMD specified in the docker image or Dockerfile.\n   */\n  readonly cmd?: string[];\n\n  /**\n   * Specify or override the ENTRYPOINT on the specified Docker image or Dockerfile.\n   * An ENTRYPOINT allows you to configure a container that will run as an executable.\n   * This needs to be in the 'exec form', viz., `[ 'executable', 'param1', 'param2' ]`.\n   * @see https://docs.docker.com/engine/reference/builder/#entrypoint\n   * @default - use the ENTRYPOINT in the docker image or Dockerfile.\n   */\n  readonly entrypoint?: string[];\n\n  /**\n   * Specify or override the WORKDIR on the specified Docker image or Dockerfile.\n   * A WORKDIR allows you to configure the working directory the container will use.\n   * @see https://docs.docker.com/engine/reference/builder/#workdir\n   * @default - use the WORKDIR in the docker image or Dockerfile.\n   */\n  readonly workingDirectory?: string;\n}\n\n/**\n * Represents an ECR image that will be constructed from the specified asset and can be bound as Lambda code.\n */\nexport class AssetImageCode extends Code {\n  public readonly isInline: boolean = false;\n  private asset?: ecr_assets.DockerImageAsset;\n\n  constructor(\n    private readonly directory: string,\n    private readonly props: AssetImageCodeProps,\n  ) {\n    super();\n  }\n\n  public bind(scope: Construct): CodeConfig {\n    // If the same AssetImageCode is used multiple times, retain only the first instantiation.\n    if (!this.asset) {\n      this.asset = new ecr_assets.DockerImageAsset(scope, \"AssetImage\", {\n        directory: this.directory,\n        ...this.props,\n      });\n      this.asset.repository.grantPull(\n        new iam.ServicePrincipal(\"lambda.amazonaws.com\"),\n      );\n    } else if (\n      AwsStack.ofAwsConstruct(this.asset) !== AwsStack.ofAwsConstruct(scope)\n    ) {\n      // throw new ValidationError(\n      throw new Error(\n        `Asset is already associated with another stack '${AwsStack.ofAwsConstruct(this.asset).gridUUID}'. ` +\n          \"Create a new Code instance for every stack.\",\n        // scope,\n      );\n    }\n\n    return {\n      image: {\n        imageUri: this.asset.imageUri,\n        entrypoint: this.props.entrypoint,\n        cmd: this.props.cmd,\n        workingDirectory: this.props.workingDirectory,\n      },\n    };\n  }\n\n  // // TODO: pending custom CLI to mock Lambda function invocations locally\n  // public bindToResource(\n  //   resource: IAwsConstruct,\n  //   options: ResourceBindOptions = {},\n  // ) {\n  //   if (!this.asset) {\n  //     // throw new ValidationError(\n  //     throw new Error(\"bindToResource() must be called after bind()\"); //, resource);\n  //   }\n\n  //   // const resourceProperty = _options.resourceProperty || \"Code.ImageUri\";\n\n  //   // // https://github.com/aws/aws-cdk/issues/14593\n  //   // this.asset.addResourceMetadata(_resource, resourceProperty);\n  // }\n}\n\n/**\n * Options when creating an asset from a Docker build.\n */\nexport interface DockerBuildAssetOptions extends DockerBuildOptions {\n  /**\n   * The path in the Docker image where the asset is located after the build\n   * operation.\n   *\n   * @default /asset\n   */\n  readonly imagePath?: string;\n\n  /**\n   * The path on the local filesystem where the asset will be copied\n   * using `docker cp`.\n   *\n   * @default - a unique temporary directory in the system temp directory\n   */\n  readonly outputPath?: string;\n}\n\n/**\n * Options for creating `AssetCode` with a custom command, such as running a buildfile.\n */\nexport interface CustomCommandOptions extends s3_assets.AssetOptions {\n  /**\n   * options that are passed to the spawned process, which determine the characteristics of the spawned process.\n   *\n   * @default: see `child_process.SpawnSyncOptions` (https://nodejs.org/api/child_process.html#child_processspawnsynccommand-args-options).\n   */\n  readonly commandOptions?: { [options: string]: any };\n}\n\n/**\n * Optional parameters for creating code using bucket\n */\nexport interface BucketOptions {\n  /**\n   * Optional S3 object version\n   */\n  readonly objectVersion?: string;\n  /**\n   * The ARN of the KMS key used to encrypt the handler code.\n   * @default - the default server-side encryption with Amazon S3 managed keys(SSE-S3) key will be used.\n   */\n  readonly sourceKMSKey?: IKey;\n}\n"]}

package/lib/aws/compute/condition.js

@@ -300,7 +300,7 @@ class Condition {
 }
 exports.Condition = Condition;
 _a = JSII_RTTI_SYMBOL_1;
-Condition[_a] = { fqn: "terraconstructs.aws.compute.Condition", version: "0.0.24" };
+Condition[_a] = { fqn: "terraconstructs.aws.compute.Condition", version: "0.1.0" };
 /**
  * Comparison Operator types
  */

package/lib/aws/compute/connections.js

@@ -178,7 +178,7 @@ class Connections {
 }
 exports.Connections = Connections;
 _a = JSII_RTTI_SYMBOL_1;
-Connections[_a] = { fqn: "terraconstructs.aws.compute.Connections", version: "0.0.24" };
+Connections[_a] = { fqn: "terraconstructs.aws.compute.Connections", version: "0.1.0" };
 class ReactiveList {
     constructor() {
         this.elements = new Array();

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

@@ -0,0 +1,102 @@
+import { Duration } from "../../duration";
+export interface CorsOptions {
+    /**
+     * Specifies the response status code returned from the OPTIONS method.
+     *
+     * @default 204
+     */
+    readonly statusCode?: number;
+    /**
+     * Specifies the list of origins that are allowed to make requests to this
+     * resource. If you wish to allow all origins, specify `Cors.ALL_ORIGINS` or
+     * `[ * ]`.
+     *
+     * Responses will include the `Access-Control-Allow-Origin` response header.
+     * If specific origins are specified (not `Cors.ALL_ORIGINS`), the `Vary: Origin`
+     * response header will also be included.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin
+     */
+    readonly allowOrigins: string[];
+    /**
+     * The Access-Control-Allow-Headers response header is used in response to a
+     * preflight request which includes the Access-Control-Request-Headers to
+     * indicate which HTTP headers can be used during the actual request.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers
+     * @default Cors.DEFAULT_HEADERS
+     */
+    readonly allowHeaders?: string[];
+    /**
+     * The Access-Control-Allow-Methods response header specifies the method or
+     * methods allowed when accessing the resource in response to a preflight request.
+     *
+     * If `ANY` is specified, it will be expanded to `Cors.ALL_METHODS`.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Methods
+     * @default Cors.ALL_METHODS
+     */
+    readonly allowMethods?: string[];
+    /**
+     * The Access-Control-Allow-Credentials response header tells browsers whether
+     * to expose the response to frontend JavaScript code when the request's
+     * credentials mode (Request.credentials) is "include".
+     *
+     * When a request's credentials mode (Request.credentials) is "include",
+     * browsers will only expose the response to frontend JavaScript code if the
+     * Access-Control-Allow-Credentials value is true.
+     *
+     * Credentials are cookies, authorization headers or TLS client certificates.
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Credentials
+     * @default false
+     */
+    readonly allowCredentials?: boolean;
+    /**
+     * The Access-Control-Max-Age response header indicates how long the results of
+     * a preflight request (that is the information contained in the
+     * Access-Control-Allow-Methods and Access-Control-Allow-Headers headers)
+     * can be cached.
+     *
+     * To disable caching altogether use `disableCache: true`.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Max-Age
+     * @default - browser-specific (see reference)
+     */
+    readonly maxAge?: Duration;
+    /**
+     * Sets Access-Control-Max-Age to -1, which means that caching is disabled.
+     * This option cannot be used with `maxAge`.
+     *
+     * @default - cache is enabled
+     */
+    readonly disableCache?: boolean;
+    /**
+     * The Access-Control-Expose-Headers response header indicates which headers
+     * can be exposed as part of the response by listing their names.
+     *
+     * If you want clients to be able to access other headers, you have to list
+     * them using the Access-Control-Expose-Headers header.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Expose-Headers
+     *
+     * @default - only the 6 CORS-safelisted response headers are exposed:
+     * Cache-Control, Content-Language, Content-Type, Expires, Last-Modified,
+     * Pragma
+     */
+    readonly exposeHeaders?: string[];
+}
+export declare class Cors {
+    /**
+     * All HTTP methods.
+     */
+    static readonly ALL_METHODS: string[];
+    /**
+     * All origins.
+     */
+    static readonly ALL_ORIGINS: string[];
+    /**
+     * The set of default headers allowed for CORS and useful for API Gateway.
+     */
+    static readonly DEFAULT_HEADERS: string[];
+    private constructor();
+}