terraconstructs 0.0.8

package/lib/aws/compute/function.js

@@ -0,0 +1,692 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggingFormat = exports.ApplicationLogLevel = exports.SystemLogLevel = exports.Tracing = exports.LambdaFunction = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// source: https://github.com/cdktf-plus/cdktf-plus/blob/586aabad3ab2fb2a2e93e05ed33f94474ebe9397/packages/%40cdktf-plus/aws/lib/aws-lambda-function/index.ts
+// update to align closer with https://github.com/aws/aws-cdk/blob/v2.156.0/packages/aws-cdk-lib/aws-lambda/lib/function.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const __1 = require("..");
+const architecture_1 = require("./architecture");
+const function_base_1 = require("./function-base");
+const util_1 = require("./util");
+const __2 = require("../../");
+const iam = require("../iam");
+const notify_1 = require("../notify");
+// re-add ec2.IConnectable?
+// /**
+//  * A Lambda function.
+//  */
+// export interface IFunction extends IAwsConstruct, iam.IGrantable {
+//   /**
+//    * Add an environment variable to this function.
+//    */
+//   addEnvironment(key: string, value: string): IFunction;
+// }
+/**
+ * Provides a Lambda Function resource. Lambda allows you to trigger execution
+ * of code in response to events in AWS, enabling serverless backend solutions.
+ *
+ * The Lambda Function itself includes source code and runtime configuration.
+ *
+ * This Construct manages permissions as part of the function Principal iam policy.
+ * This works for same account resources, but for cross-account resources,
+ * you may need to manage access as part of the Resource iam policy.
+ *
+ * @resource aws_lambda_function
+ * @beacon-class compute.IFunction
+ */
+class LambdaFunction extends function_base_1.LambdaFunctionBase {
+    // TODO: Terraform aws_lambda_function == CDK FunctionVersion
+    /**
+     * Latest published version of your Lambda Function.
+     */
+    get version() {
+        // TODO: What is this if publish is false??
+        return this.resource.version;
+    }
+    /**
+     * Import a lambda function into the TerraConstruct spec using its name
+     */
+    static fromFunctionName(scope, id, functionName) {
+        return LambdaFunction.fromFunctionAttributes(scope, id, {
+            functionArn: __1.AwsStack.ofAwsConstruct(scope).formatArn({
+                service: "lambda",
+                resource: "function",
+                resourceName: functionName,
+                arnFormat: __1.ArnFormat.COLON_RESOURCE_NAME,
+            }),
+            sameEnvironment: true,
+        });
+    }
+    /**
+     * Import a lambda function into the TerraConstruct spec using its ARN.
+     *
+     * For `Function.addPermissions()` to work on this imported lambda, make sure that is
+     * in the same account and region as the stack you are importing it into.
+     */
+    static fromFunctionArn(scope, id, functionArn) {
+        return LambdaFunction.fromFunctionAttributes(scope, id, { functionArn });
+    }
+    /**
+     * Creates a Lambda function object which represents a function not defined
+     * within this stack.
+     *
+     * For `Function.addPermissions()` to work on this imported lambda, set the sameEnvironment property to true
+     * if this imported lambda is in the same account and region as the stack you are importing it into.
+     *
+     * @param scope The parent construct
+     * @param id The name of the lambda construct
+     * @param attrs the attributes of the function to import
+     */
+    static fromFunctionAttributes(scope, id, attrs) {
+        const functionArn = attrs.functionArn;
+        const functionName = extractNameFromArn(attrs.functionArn);
+        const role = attrs.role;
+        class Import extends function_base_1.LambdaFunctionBase {
+            /**
+             * The version of the Lambda function returned.
+             *
+             * If qualifier is not set, this will resolve to the most recent published version.
+             * If no published version of the function exists, version will resolve to `$LATEST`.
+             */
+            get version() {
+                return this.resource.version;
+            }
+            get functionOutputs() {
+                return {
+                    name: this.functionName,
+                    arn: this.functionArn,
+                    roleArn: this.role?.roleArn ?? "",
+                };
+            }
+            get outputs() {
+                return this.functionOutputs;
+            }
+            constructor(s, i) {
+                super(s, i, {
+                    environmentFromArn: functionArn,
+                });
+                this.functionName = functionName;
+                this.functionArn = functionArn;
+                this.role = role;
+                this.permissionsNode = this.node;
+                // Force user to provide arch or assume X86_64
+                this.architecture = attrs.architecture ?? architecture_1.Architecture.X86_64;
+                // public get architecture(): string {
+                //   return Fn.element(this.resource.architectures, 0) as string;
+                // }
+                this.resourceArnsForGrantInvoke = [
+                    this.functionArn,
+                    `${this.functionArn}:*`,
+                ];
+                this.canCreatePermissions = attrs.sameEnvironment ?? this._isStackAccount();
+                this._skipPermissions = attrs.skipPermissions ?? false;
+                this.grantPrincipal =
+                    role || new iam.UnknownPrincipal({ resource: this });
+                this.resource = new provider_aws_1.dataAwsLambdaFunction.DataAwsLambdaFunction(this, "Resource", {
+                    functionName: this.functionName,
+                });
+                // // TODO: re-add support for EC2 connections
+                // if (attrs.securityGroup) {
+                //   this._connections = new ec2.Connections({
+                //     securityGroups: [attrs.securityGroup],
+                //   });
+                // }
+            }
+        }
+        return new Import(scope, id);
+    }
+    /** Strongly Typed Function Outputs */
+    get functionOutputs() {
+        return this._outputs;
+    }
+    get outputs() {
+        return this.functionOutputs;
+    }
+    /**
+     * The ARN fo the function.
+     */
+    get functionArn() {
+        return this.resource.arn;
+    }
+    /**
+     * The ARN fo the function.
+     * (if versioning is enabled via publish = true)
+     */
+    get functionQualifiedArn() {
+        return this.resource.qualifiedArn;
+    }
+    /**
+     * The ARN fo the function.
+     */
+    get functionQualifiedInvokeArn() {
+        return this.resource.qualifiedInvokeArn;
+    }
+    // // Teraform provider for AWS Automatically manages Function Versioning through code hash..
+    // // need to drop most of this version logic..
+    // private readonly currentVersionOptions?: VersionOptions;
+    // private _currentVersion?: Version;
+    // /**
+    //  * Returns a `lambda.Version` which represents the current version of this
+    //  * Lambda function. A new version will be created every time the function's
+    //  * configuration changes.
+    //  *
+    //  * You can specify options for this version using the `currentVersionOptions`
+    //  * prop when initializing the `lambda.Function`.
+    //  */
+    // public get currentVersion(): Version {
+    //   if (this._currentVersion) {
+    //     return this._currentVersion;
+    //   }
+    //   // if (this._warnIfCurrentVersionCalled) {
+    //   //   this.warnInvokeFunctionPermissions(this);
+    //   // }
+    //   this._currentVersion = new Version(this, "CurrentVersion", {
+    //     lambda: this,
+    //     ...this.currentVersionOptions,
+    //   });
+    //   // override the version's logical ID with a lazy string which includes the
+    //   // hash of the function itself, so a new version resource is created when
+    //   // the function configuration changes.
+    //   const cfn = this._currentVersion.node.defaultChild as TerraformResource;
+    //   const originalLogicalId = this.stack.resolve(cfn.logicalId) as string;
+    //   cfn.overrideLogicalId(
+    //     Lazy.stringValue({
+    //       produce: () => {
+    //         const hash = calculateFunctionHash(this, this.hashMixins.join(""));
+    //         const logicalId = trimFromStart(originalLogicalId, 255 - 32);
+    //         return `${logicalId}${hash}`;
+    //       },
+    //     }),
+    //   );
+    //   return this._currentVersion;
+    // }
+    /**
+     * The ARN(s) to put into the resource field of the generated IAM policy for grantInvoke()
+     */
+    get resourceArnsForGrantInvoke() {
+        // TODO: should this be qualifiedArn or qualifiedInvokeArn?
+        // https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/lambda_function#qualified_arn
+        return [this.functionArn, this.functionQualifiedInvokeArn];
+    }
+    /**
+     * HTTP Endpoint for this function if defined.
+     *
+     * use `addFunctionUrl` to enable Endpoint.
+     */
+    get url() {
+        return this._url;
+    }
+    get eventSources() {
+        return Object.values(this._eventSources);
+    }
+    get securityGroup() {
+        return this._securityGroup;
+    }
+    constructor(scope, name, props) {
+        super(scope, name, props);
+        /**
+         * The construct node where permissions are attached.
+         */
+        this.permissionsNode = this.node;
+        this.canCreatePermissions = true;
+        /**
+         * Mapping of invocation principals to grants. Used to de-dupe `grantInvoke()` calls.
+         * @internal
+         */
+        this._invocationGrants = {};
+        /**
+         * Mapping of fucntion URL invocation principals to grants. Used to de-dupe `grantInvokeUrl()` calls.
+         * @internal
+         */
+        this._functionUrlInvocationGrants = {};
+        /**
+         * Environment variables for this function
+         */
+        this.environment = {};
+        this._eventSources = {};
+        const { description, environment: variables, logRetentionInDays = __1.RetentionDays.ONE_WEEK, memorySize = 128, timeout = __2.Duration.seconds(3), layers, reservedConcurrentExecutions, } = props;
+        /**
+         * The name or ARN of the Lambda function.
+         * is limited to 64 characters in length.
+         *
+         * ARN Pattern: ([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
+         */
+        const functionName = props.functionName ??
+            this.stack.uniqueResourceNamePrefix(this, {
+                prefix: props.functionNamePrefix ?? this.gridUUID + "-",
+                allowedSpecialCharacters: "+",
+                maxLength: 64,
+            });
+        if (functionName && !cdktf_1.Token.isUnresolved(functionName)) {
+            if (functionName.length > 64) {
+                throw new Error(`Function name can not be longer than 64 characters but has ${functionName.length} characters.`);
+            }
+            if (!/^[a-zA-Z0-9-_]+$/.test(functionName)) {
+                throw new Error(`Function name ${functionName} can contain only letters, numbers, hyphens, or underscores with no spaces.`);
+            }
+        }
+        if (description && !cdktf_1.Token.isUnresolved(description)) {
+            if (description.length > 256) {
+                throw new Error(`Function description can not be longer than 256 characters but has ${description.length} characters.`);
+            }
+        }
+        const managedPolicies = new Array();
+        // the arn is in the form of - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
+        managedPolicies.push(iam.ManagedPolicy.fromAwsManagedPolicyName(this, "AWSLambdaBasicExecutionRole", "service-role/AWSLambdaBasicExecutionRole"));
+        if (props.networkConfig) {
+            // Policy that will have ENI creation permissions
+            // not sure if time.sleep is necessary?
+            // ref:
+            //  - https://github.com/pulumi/pulumi-aws/issues/2260#issuecomment-1977606509
+            //  - https://github.com/hashicorp/terraform-provider-aws/issues/29828#issuecomment-1693307500
+            managedPolicies.push(iam.ManagedPolicy.fromAwsManagedPolicyName(this, "AWSLambdaVPCAccessExecutionRole", "service-role/AWSLambdaVPCAccessExecutionRole"));
+        }
+        // TODO: Any concern not scoping the logGroup IAM Permissions?
+        // .allow()
+        // .toCreateLogStream()
+        // .toPutLogEvents()
+        // .on(logGroup.arn, `${logGroup.arn}:log-stream:*`),
+        this.role =
+            props.role ||
+                new iam.Role(this, "ServiceRole", {
+                    assumedBy: new iam.ServicePrincipal("lambda.amazonaws.com"),
+                    managedPolicies,
+                });
+        this.grantPrincipal = this.role;
+        // TODO: Re-add filesystem / localMountPath support
+        // ref: filesystem.config.policies to be added to principal
+        // https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/aws-lambda/lib/function.ts#L949-L965
+        for (const statement of props.initialPolicy || []) {
+            this.role.addToPrincipalPolicy(statement);
+        }
+        // add support for AWS_CODEGURU Profile env variables...
+        const env = variables || {};
+        for (const [key, value] of Object.entries(env)) {
+            this.addEnvironment(key, value);
+        }
+        // DLQ can be either sns.ITopic or sqs.IQueue
+        const dlqTopicOrQueue = this.buildDeadLetterQueue(props);
+        if (dlqTopicOrQueue !== undefined) {
+            if (this.isQueue(dlqTopicOrQueue)) {
+                this.deadLetterQueue = dlqTopicOrQueue;
+            }
+            else {
+                throw new Error("DeadLetterTopic is not supported yet");
+                // this.deadLetterTopic = dlqTopicOrQueue;
+            }
+        }
+        const logGroup = new provider_aws_1.cloudwatchLogGroup.CloudwatchLogGroup(this, "LogGroup", {
+            name: `/aws/lambda/${functionName}`,
+            retentionInDays: logRetentionInDays,
+        });
+        this._logGroup = logGroup;
+        this.resource = new provider_aws_1.lambdaFunction.LambdaFunction(this, "Resource", {
+            functionName,
+            description,
+            role: this.role.roleArn,
+            architectures: [
+                // This is an array, but maximum length is 1!
+                // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html#cfn-lambda-function-architectures
+                props.architecture?.toString() ?? architecture_1.Architecture.X86_64.toString(),
+            ],
+            memorySize,
+            timeout: timeout.toSeconds(),
+            layers, // TODO: Support ILayer with Lazy list of arns
+            reservedConcurrentExecutions,
+            // TODO: CDK Sorts environment to match Lambda Hash behaviour
+            // ref: https://github.com/aws/aws-cdk/blob/v2.156.0/packages/aws-cdk-lib/aws-lambda/lib/function.ts#L1467
+            environment: {
+                variables: cdktf_1.Lazy.anyValue({
+                    produce: (_context) => {
+                        return this.environment;
+                    },
+                }),
+            },
+            vpcConfig: this.parseVpcConfig(props.networkConfig),
+            loggingConfig: this.getLoggingConfig(this._logGroup.name, props),
+            tracingConfig: this.parseTracingConfig(props.tracing ?? Tracing.ACTIVE),
+            deadLetterConfig: this.parseDeadLetterConfig(dlqTopicOrQueue),
+            publish: props.publish,
+            // TODO: use logGroup.node.addDependency when logGroup is implemented
+            dependsOn: [logGroup],
+        });
+        this.functionName = this.resource.functionName;
+        // make sure any role attachments are added as dependencies for this lambda
+        // this achieved by the CDKTF Aspect on the parent StackBase
+        this.resource.node.addDependency(this.role);
+        this.timeout = props.timeout;
+        this.architecture = props.architecture ?? architecture_1.Architecture.X86_64;
+        // TODO: Add aws_lambda_provisioned_concurrency_config
+        for (const event of props.events || []) {
+            this.addEventSource(event);
+        }
+        // Event Invoke Config
+        if (props.onFailure ||
+            props.onSuccess ||
+            props.maxEventAge ||
+            props.retryAttempts !== undefined) {
+            this.configureAsyncInvoke({
+                onFailure: props.onFailure,
+                onSuccess: props.onSuccess,
+                maxEventAge: props.maxEventAge,
+                retryAttempts: props.retryAttempts,
+            });
+        }
+        this._outputs = {
+            name: this.functionName,
+            arn: this.resource.arn,
+            roleArn: this.role.roleArn,
+            // only known at synth time
+            // explicit `null` required to avoid syntax errors when using stringValue && "undefined"
+            url: cdktf_1.Lazy.anyValue({
+                produce: () => this._url ?? null,
+            }),
+            defaultSecurityGroup: cdktf_1.Lazy.anyValue({
+                produce: () => this._securityGroup?.id ?? null,
+            }),
+        };
+    }
+    /**
+     * Adds an environment variable to this Lambda function.
+     * If this is a ref to a Lambda function, this operation results in a no-op.
+     * @param key The environment variable key.
+     * @param value The environment variable's value.
+     */
+    addEnvironment(key, value) {
+        // Reserved environment variables will fail during cloudformation deploy if they're set.
+        // This check is just to allow CDK to fail faster when these are specified.
+        const reservedEnvironmentVariables = [
+            "_HANDLER",
+            "_X_AMZN_TRACE_ID",
+            "AWS_DEFAULT_REGION",
+            "AWS_REGION",
+            "AWS_EXECUTION_ENV",
+            "AWS_LAMBDA_FUNCTION_NAME",
+            "AWS_LAMBDA_FUNCTION_MEMORY_SIZE",
+            "AWS_LAMBDA_FUNCTION_VERSION",
+            "AWS_LAMBDA_INITIALIZATION_TYPE",
+            "AWS_LAMBDA_LOG_GROUP_NAME",
+            "AWS_LAMBDA_LOG_STREAM_NAME",
+            "AWS_ACCESS_KEY",
+            "AWS_ACCESS_KEY_ID",
+            "AWS_SECRET_ACCESS_KEY",
+            "AWS_SESSION_TOKEN",
+            "AWS_LAMBDA_RUNTIME_API",
+            "LAMBDA_TASK_ROOT",
+            "LAMBDA_RUNTIME_DIR",
+        ];
+        if (reservedEnvironmentVariables.includes(key)) {
+            throw new Error(`${key} environment variable is reserved by the lambda runtime and can not be set manually. See https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html`);
+        }
+        this.environment[key] = value;
+        return this;
+    }
+    addFunctionUrl(options) {
+        const endpoint = super.addFunctionUrl(options);
+        this._url = endpoint.url;
+        return endpoint;
+    }
+    /**
+     * Get Logging Config propety for the function.
+     * This method returns the function LoggingConfig Property if the property is set on the
+     * function and undefined if not.
+     */
+    getLoggingConfig(logGroupName, props) {
+        if (props.applicationLogLevel || props.systemLogLevel) {
+            if (props.loggingFormat !== LoggingFormat.JSON) {
+                throw new Error(`To use ApplicationLogLevel and/or SystemLogLevel you must set LoggingFormat to '${LoggingFormat.JSON}', got '${props.loggingFormat}'.`);
+            }
+        }
+        let loggingConfig;
+        if (props.loggingFormat) {
+            loggingConfig = {
+                logFormat: props.loggingFormat,
+                systemLogLevel: props.systemLogLevel,
+                applicationLogLevel: props.applicationLogLevel,
+                logGroup: logGroupName,
+            };
+            return loggingConfig;
+        }
+        return undefined;
+    }
+    /**
+     * Defines an alias for this function.
+     *
+     * The alias will automatically be updated to point to the latest version of
+     * the function as it is being updated during a deployment.
+     *
+     * ```ts
+     * declare const fn: compute.LambdaFunction;
+     *
+     * fn.addAlias('Live');
+     *
+     * // Is equivalent to
+     *
+     * new compute.Alias(this, 'AliasLive', {
+     *   aliasName: 'Live',
+     *   version: fn.version,
+     * });
+     * ```
+     *
+     * @param aliasName The name of the alias
+     * @param options Alias options
+     */
+    addAlias(aliasName, options) {
+        return (0, util_1.addAlias)(this, this, this.version, aliasName, options);
+    }
+    /**
+     * Optionally create LambdaFunctionVpcConfig
+     */
+    parseVpcConfig(config) {
+        if (!config) {
+            return undefined;
+        }
+        let securityGroupIds = config.securityGroupIds;
+        if (!securityGroupIds) {
+            this._securityGroup = new provider_aws_1.securityGroup.SecurityGroup(this, "SecurityGroup", {
+                name: this.functionName,
+                description: this.functionName,
+                vpcId: config.vpcId,
+                egress: config.egress ?? [
+                    {
+                        fromPort: 0,
+                        toPort: 0,
+                        protocol: "-1",
+                        cidrBlocks: ["0.0.0.0/0"],
+                        ipv6CidrBlocks: ["::/0"],
+                    },
+                ],
+            });
+            securityGroupIds = [this._securityGroup.id];
+        }
+        return {
+            subnetIds: config.subnetIds,
+            ipv6AllowedForDualStack: config.ipv6AllowedForDualStack,
+            securityGroupIds,
+        };
+    }
+    isQueue(deadLetterQueue) {
+        return deadLetterQueue.queueArn !== undefined;
+    }
+    buildDeadLetterQueue(props) {
+        // | sns.ITopic
+        if (!props.deadLetterQueue &&
+            !props.deadLetterQueueEnabled
+        // && !props.deadLetterTopic
+        ) {
+            return undefined;
+        }
+        if (props.deadLetterQueue && props.deadLetterQueueEnabled === false) {
+            throw Error("deadLetterQueue defined but deadLetterQueueEnabled explicitly set to false");
+        }
+        // if (
+        //   props.deadLetterTopic &&
+        //   (props.deadLetterQueue || props.deadLetterQueueEnabled !== undefined)
+        // ) {
+        //   throw new Error(
+        //     "deadLetterQueue and deadLetterTopic cannot be specified together at the same time",
+        //   );
+        // }
+        let deadLetterQueue; // | ITopic;
+        // if (props.deadLetterTopic) {
+        //   deadLetterQueue = props.deadLetterTopic;
+        //   this.addToRolePolicy(
+        //     new iam.PolicyStatement({
+        //       actions: ["sns:Publish"],
+        //       resources: [deadLetterQueue.topicArn],
+        //     }),
+        //   );
+        // } else {
+        deadLetterQueue =
+            props.deadLetterQueue ||
+                new notify_1.Queue(this, "DeadLetterQueue", {
+                    messageRetentionSeconds: __2.Duration.days(14).toSeconds(),
+                });
+        this.addToRolePolicy(new iam.PolicyStatement({
+            actions: ["sqs:SendMessage"],
+            resources: [deadLetterQueue.queueArn],
+        }));
+        // }
+        return deadLetterQueue;
+    }
+    // TODO: Support sns.ITopic + sns:Publish topicArn
+    /**
+     * Optionally create LambdaFunctionDeadLetterConfig
+     */
+    parseDeadLetterConfig(deadLetterQueue) {
+        if (deadLetterQueue) {
+            // this.isQueue(deadLetterQueue) ? deadLetterQueue.queueArn : ...
+            return {
+                targetArn: deadLetterQueue.queueArn,
+            };
+        }
+        else {
+            return undefined;
+        }
+    }
+    parseTracingConfig(tracing) {
+        if (tracing === undefined || tracing === Tracing.DISABLED) {
+            return undefined;
+        }
+        this.addToRolePolicy(new iam.PolicyStatement({
+            actions: ["xray:PutTraceSegments", "xray:PutTelemetryRecords"],
+            resources: ["*"],
+        }));
+        return {
+            mode: tracing,
+        };
+    }
+}
+exports.LambdaFunction = LambdaFunction;
+_a = JSII_RTTI_SYMBOL_1;
+LambdaFunction[_a] = { fqn: "terraconstructs.aws.compute.LambdaFunction", version: "0.0.8" };
+/**
+ * Given an opaque (token) ARN, returns a TF expression that extracts the function
+ * name from the ARN.
+ *
+ * Function ARNs look like this:
+ *
+ *   arn:aws:lambda:region:account-id:function:function-name
+ *
+ * ..which means that in order to extract the `function-name` component from the ARN, we can
+ * split the ARN using ":" and select the component in index 6.
+ *
+ * @returns `element(split(':', arn), 6)`
+ */
+function extractNameFromArn(arn) {
+    return cdktf_1.Fn.element(cdktf_1.Fn.split(":", arn), 6);
+}
+/**
+ * X-Ray Tracing Modes (https://docs.aws.amazon.com/lambda/latest/dg/API_TracingConfig.html)
+ */
+var Tracing;
+(function (Tracing) {
+    /**
+     * Lambda will respect any tracing header it receives from an upstream service.
+     * If no tracing header is received, Lambda will sample the request based on a fixed rate. Please see the [Using AWS Lambda with AWS X-Ray](https://docs.aws.amazon.com/lambda/latest/dg/services-xray.html) documentation for details on this sampling behavior.
+     */
+    Tracing["ACTIVE"] = "Active";
+    /**
+     * Lambda will only trace the request from an upstream service
+     * if it contains a tracing header with "sampled=1"
+     */
+    Tracing["PASS_THROUGH"] = "PassThrough";
+    /**
+     * Lambda will not trace any request.
+     */
+    Tracing["DISABLED"] = "Disabled";
+})(Tracing || (exports.Tracing = Tracing = {}));
+/**
+ * Lambda service will automatically captures system logs about function invocation
+ * generated by the Lambda service (known as system logs) and sends these logs to a
+ * default CloudWatch log group named after the Lambda function.
+ */
+var SystemLogLevel;
+(function (SystemLogLevel) {
+    /**
+     * Lambda will capture only logs at info level.
+     */
+    SystemLogLevel["INFO"] = "INFO";
+    /**
+     * Lambda will capture only logs at debug level.
+     */
+    SystemLogLevel["DEBUG"] = "DEBUG";
+    /**
+     * Lambda will capture only logs at warn level.
+     */
+    SystemLogLevel["WARN"] = "WARN";
+})(SystemLogLevel || (exports.SystemLogLevel = SystemLogLevel = {}));
+/**
+ * Lambda service automatically captures logs generated by the function code
+ * (known as application logs) and sends these logs to a default CloudWatch
+ * log group named after the Lambda function.
+ */
+var ApplicationLogLevel;
+(function (ApplicationLogLevel) {
+    /**
+     * Lambda will capture only logs at info level.
+     */
+    ApplicationLogLevel["INFO"] = "INFO";
+    /**
+     * Lambda will capture only logs at debug level.
+     */
+    ApplicationLogLevel["DEBUG"] = "DEBUG";
+    /**
+     * Lambda will capture only logs at warn level.
+     */
+    ApplicationLogLevel["WARN"] = "WARN";
+    /**
+     * Lambda will capture only logs at trace level.
+     */
+    ApplicationLogLevel["TRACE"] = "TRACE";
+    /**
+     * Lambda will capture only logs at error level.
+     */
+    ApplicationLogLevel["ERROR"] = "ERROR";
+    /**
+     * Lambda will capture only logs at fatal level.
+     */
+    ApplicationLogLevel["FATAL"] = "FATAL";
+})(ApplicationLogLevel || (exports.ApplicationLogLevel = ApplicationLogLevel = {}));
+/**
+ * This field takes in 2 values either Text or JSON. By setting this value to Text,
+ * will result in the current structure of logs format, whereas, by setting this value to JSON,
+ * Lambda will print the logs as Structured JSON Logs, with the corresponding timestamp and log level
+ * of each event. Selecting ‘JSON’ format will only allow customer’s to have different log level
+ * Application log level and the System log level.
+ */
+var LoggingFormat;
+(function (LoggingFormat) {
+    /**
+     * Lambda Logs text format.
+     */
+    LoggingFormat["TEXT"] = "Text";
+    /**
+     * Lambda structured logging in Json format.
+     */
+    LoggingFormat["JSON"] = "JSON";
+})(LoggingFormat || (exports.LoggingFormat = LoggingFormat = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"function.js","sourceRoot":"","sources":["../../../src/aws/compute/function.ts"],"names":[],"mappings":"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","sourcesContent":["// source: https://github.com/cdktf-plus/cdktf-plus/blob/586aabad3ab2fb2a2e93e05ed33f94474ebe9397/packages/%40cdktf-plus/aws/lib/aws-lambda-function/index.ts\n// update to align closer with https://github.com/aws/aws-cdk/blob/v2.156.0/packages/aws-cdk-lib/aws-lambda/lib/function.ts\nimport {\n  lambdaFunction,\n  cloudwatchLogGroup,\n  securityGroup,\n  lambdaEventSourceMapping,\n  dataAwsLambdaFunction,\n} from \"@cdktf/provider-aws\";\nimport { IResolveContext, Lazy, IResolvable, Token, Fn } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { RetentionDays, AwsStack, ArnFormat } from \"..\";\nimport { Architecture } from \"./architecture\";\nimport { EventInvokeConfigOptions } from \"./event-invoke-config\";\nimport { IEventSourceMapping } from \"./event-source-mapping\";\nimport { AliasOptions, Alias } from \"./function-alias\";\nimport {\n  LambdaFunctionBase,\n  IFunction,\n  FunctionAttributes,\n  IEventSource,\n} from \"./function-base\";\nimport { FunctionUrl, FunctionUrlOptions } from \"./function-url\";\nimport { VpcConfig } from \"./function-vpc-config.generated\";\nimport { addAlias } from \"./util\";\nimport { Duration } from \"../../\";\nimport * as iam from \"../iam\";\nimport { IQueue, Queue } from \"../notify\";\n\nexport interface FunctionOutputs {\n  /**\n   * AWS Lambda function name\n   */\n  readonly name: string;\n\n  /**\n   * AWS Lambda arn of the function\n   */\n  readonly arn: string;\n\n  /**\n   * The IAM Role associated with the Lambda function\n   */\n  readonly roleArn: string;\n\n  /**\n   * Function URL if enabled\n   */\n  readonly url?: string | IResolvable;\n\n  /**\n   * Security group of the function if created\n   */\n  readonly defaultSecurityGroup?: string | IResolvable;\n}\n\nexport interface FunctionProps extends EventInvokeConfigOptions {\n  /**\n   * Force function name (for adoption of existing resources).\n   *\n   * Prefer to use functionNamePrefix.\n   *\n   * Use [Terraform Resource Meta Arguments](https://developer.hashicorp.com/terraform/language/resources/syntax#meta-arguments)\n   * to control lifecycle when replacing the function.\n   *\n   * @default - If omitted, Refer to `functionNamePrefix`.\n   */\n  readonly functionName?: string;\n\n  /**\n   * A name prefix for the function.\n   *\n   * @default - Grid generates a unique physical ID and uses that\n   * ID for the function's name.\n   */\n  readonly functionNamePrefix?: string;\n\n  /**\n   * The environment variables to be passed to the Lambda function.\n   *\n   * Key-value pairs that Lambda caches and makes available for your Lambda\n   * functions. Use environment variables to apply configuration changes, such\n   * as test and production environment configurations, without changing your\n   * Lambda function source code.\n   */\n  readonly environment?: { [key: string]: string };\n\n  /**\n   * Description of what your Lambda Function does.\n   */\n  readonly description?: string;\n\n  /**\n   * The system architectures compatible with this lambda function.\n   * @default Architecture.X86_64\n   */\n  readonly architecture?: Architecture;\n\n  /**\n   * The tracing mode for the Lambda function.\n   *\n   * The Lambda function iam role will receive permission to\n   * write to AWS X-Ray.\n   *\n   * @default Tracing.ACTIVE\n   */\n  readonly tracing?: Tracing;\n\n  /**\n   * The log retention period in days. Defaults to 7.\n   */\n  readonly logRetentionInDays?: RetentionDays;\n\n  /**\n   * The memory limit in MB.\n   *\n   * @default 128.\n   */\n  readonly memorySize?: number;\n\n  /**\n   * The function execution time (in seconds) after which Lambda terminates\n   * the function. Because the execution time affects cost, set this value\n   * based on the function's expected execution time.\n   *\n   * @default Duration.seconds(3)\n   */\n  readonly timeout?: Duration;\n\n  /**\n   * Layers for the Lambda.\n   */\n  readonly layers?: string[];\n\n  /**\n   * Initial policy statements to add to the created Lambda Role.\n   *\n   * You can call `addToRolePolicy` to the created lambda to add statements post creation.\n   *\n   * @default - No policy statements are added to the created Lambda role.\n   */\n  readonly initialPolicy?: iam.PolicyStatement[];\n\n  /**\n   * Lambda execution role.\n   *\n   * This is the role that will be assumed by the function upon execution.\n   * It controls the permissions that the function will have. The Role must\n   * be assumable by the 'lambda.amazonaws.com' service principal.\n   *\n   * The default Role automatically has permissions granted for Lambda execution. If you\n   * provide a Role, you must add the relevant AWS managed policies yourself.\n   *\n   * The relevant managed policies are \"service-role/AWSLambdaBasicExecutionRole\" and\n   * \"service-role/AWSLambdaVPCAccessExecutionRole\".\n   *\n   * @default - A unique role will be generated for this lambda function.\n   * Both supplied and generated roles can always be changed by calling `addToRolePolicy`.\n   */\n  readonly role?: iam.IRole;\n\n  /**\n   * Config for network connectivity to AWS resources in a VPC, specify a list\n   * of subnet, and optionally security groups, in the VPC.\n   *\n   * The Lambda function iam role will receive permission to\n   * manage ENIs within the provided network.\n   *\n   * When you connect a function to a VPC, it can only access resources and the internet through that VPC.\n   *\n   * See [VPC Settings](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc.html).\n   */\n  readonly networkConfig?: VpcConfig;\n\n  /**\n   * The SQS DLQ.\n   *\n   * The Lambda function iam role will receive permission to\n   * send messages on this queue.\n   *\n   * @default - no deadletter queue\n   */\n  readonly deadLetterQueue?: IQueue;\n\n  /**\n   * Enabled DLQ. If `deadLetterQueue` is undefined,\n   * an SQS queue with default options will be defined for your Function.\n   *\n   * @default - false unless `deadLetterQueue` is set, which implies DLQ is enabled.\n   */\n  readonly deadLetterQueueEnabled?: boolean;\n\n  // TODO: re-add SNS deadLetterTopic\n\n  /**\n   * Event sources for this function.\n   *\n   * You can also add event sources using `addEventSource`.\n   *\n   * @default - No event sources.\n   */\n  readonly events?: IEventSource[];\n\n  /**\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.60.0/docs/resources/lambda_function#reserved_concurrent_executions LambdaFunction#reserved_concurrent_executions}\n   */\n  readonly reservedConcurrentExecutions?: number;\n\n  /**\n   * Tags to apply to the Lambda function.\n   */\n  readonly tags?: { [key: string]: string };\n\n  /**\n   * Setting this property informs the CDK that the imported function ALREADY HAS the necessary permissions\n   * for what you are trying to do. When not configured, the CDK attempts to auto-determine whether or not\n   * additional permissions are necessary on the function when grant APIs are used. If the CDK tried to add\n   * permissions on an imported lambda, it will fail.\n   *\n   * Set this property *ONLY IF* you are committing to manage the imported function's permissions outside of\n   * CDK. You are acknowledging that your CDK code alone will have insufficient permissions to access the\n   * imported function.\n   *\n   * @default false\n   */\n  readonly skipPermissions?: boolean;\n\n  /**\n   * Sets the loggingFormat for the function.\n   * @default LoggingFormat.TEXT\n   */\n  readonly loggingFormat?: LoggingFormat;\n\n  /**\n   * Sets the application log level for the function.\n   * @default ApplicationLogLevel.INFO\n   */\n  readonly applicationLogLevel?: ApplicationLogLevel;\n\n  /**\n   * Sets the system log level for the function.\n   * @default SystemLogLevel.INFO\n   */\n  readonly systemLogLevel?: SystemLogLevel;\n  /**\n   * Whether to publish creation/change as new Lambda Function Version.\n   *\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/lambda_function#publish LambdaFunction#publish}\n   * @default false\n   */\n  readonly publish?: boolean | IResolvable;\n\n  // // This will be defined by extending classes\n  // // ref: https://aws.github.io/jsii/user-guides/lib-author/typescript-restrictions/#covariant-overrides-parameter-list-changes\n  // // implement Runtime as a class?\n  // // https://github.com/aws/aws-cdk/blob/v2.156.0/packages/aws-cdk-lib/aws-lambda/lib/runtime.ts\n  // /**\n  //  * Identifier of the function's runtime.\n  //  *\n  //  * Docs:\n  //  * - at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/lambda_function#runtime LambdaFunction#runtime}\n  //  * - AWS Lambda CreatFunction docs: {@link https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-Runtime CreateFunction#rntime}\n  //  */\n  // readonly runtime?: string;\n}\n\n// re-add ec2.IConnectable?\n\n// /**\n//  * A Lambda function.\n//  */\n// export interface IFunction extends IAwsConstruct, iam.IGrantable {\n\n//   /**\n//    * Add an environment variable to this function.\n//    */\n//   addEnvironment(key: string, value: string): IFunction;\n// }\n\n/**\n * Provides a Lambda Function resource. Lambda allows you to trigger execution\n * of code in response to events in AWS, enabling serverless backend solutions.\n *\n * The Lambda Function itself includes source code and runtime configuration.\n *\n * This Construct manages permissions as part of the function Principal iam policy.\n * This works for same account resources, but for cross-account resources,\n * you may need to manage access as part of the Resource iam policy.\n *\n * @resource aws_lambda_function\n * @beacon-class compute.IFunction\n */\nexport class LambdaFunction extends LambdaFunctionBase implements IFunction {\n  // TODO: Terraform aws_lambda_function == CDK FunctionVersion\n\n  /**\n   * Latest published version of your Lambda Function.\n   */\n  public get version(): string {\n    // TODO: What is this if publish is false??\n    return this.resource.version;\n  }\n\n  /**\n   * Import a lambda function into the TerraConstruct spec using its name\n   */\n  public static fromFunctionName(\n    scope: Construct,\n    id: string,\n    functionName: string,\n  ): IFunction {\n    return LambdaFunction.fromFunctionAttributes(scope, id, {\n      functionArn: AwsStack.ofAwsConstruct(scope).formatArn({\n        service: \"lambda\",\n        resource: \"function\",\n        resourceName: functionName,\n        arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n      }),\n      sameEnvironment: true,\n    });\n  }\n\n  /**\n   * Import a lambda function into the TerraConstruct spec using its ARN.\n   *\n   * For `Function.addPermissions()` to work on this imported lambda, make sure that is\n   * in the same account and region as the stack you are importing it into.\n   */\n  public static fromFunctionArn(\n    scope: Construct,\n    id: string,\n    functionArn: string,\n  ): IFunction {\n    return LambdaFunction.fromFunctionAttributes(scope, id, { functionArn });\n  }\n\n  /**\n   * Creates a Lambda function object which represents a function not defined\n   * within this stack.\n   *\n   * For `Function.addPermissions()` to work on this imported lambda, set the sameEnvironment property to true\n   * if this imported lambda is in the same account and region as the stack you are importing it into.\n   *\n   * @param scope The parent construct\n   * @param id The name of the lambda construct\n   * @param attrs the attributes of the function to import\n   */\n  public static fromFunctionAttributes(\n    scope: Construct,\n    id: string,\n    attrs: FunctionAttributes,\n  ): IFunction {\n    const functionArn = attrs.functionArn;\n    const functionName = extractNameFromArn(attrs.functionArn);\n    const role = attrs.role;\n\n    class Import extends LambdaFunctionBase {\n      public readonly resource: dataAwsLambdaFunction.DataAwsLambdaFunction;\n      public readonly functionName = functionName;\n      public readonly functionArn = functionArn;\n      // TODO: Resolve role and principal resolve from TF data source?\n      public readonly grantPrincipal: iam.IPrincipal;\n      public readonly role = role;\n      public readonly permissionsNode = this.node;\n      /**\n       * The version of the Lambda function returned.\n       *\n       * If qualifier is not set, this will resolve to the most recent published version.\n       * If no published version of the function exists, version will resolve to `$LATEST`.\n       */\n      public get version(): string {\n        return this.resource.version;\n      }\n      // Force user to provide arch or assume X86_64\n      public readonly architecture = attrs.architecture ?? Architecture.X86_64;\n      // public get architecture(): string {\n      //   return Fn.element(this.resource.architectures, 0) as string;\n      // }\n      public readonly resourceArnsForGrantInvoke = [\n        this.functionArn,\n        `${this.functionArn}:*`,\n      ];\n      public get functionOutputs(): FunctionOutputs {\n        return {\n          name: this.functionName,\n          arn: this.functionArn,\n          roleArn: this.role?.roleArn ?? \"\",\n        };\n      }\n      public get outputs() {\n        return this.functionOutputs;\n      }\n      protected readonly canCreatePermissions =\n        attrs.sameEnvironment ?? this._isStackAccount();\n      protected readonly _skipPermissions = attrs.skipPermissions ?? false;\n\n      constructor(s: Construct, i: string) {\n        super(s, i, {\n          environmentFromArn: functionArn,\n        });\n\n        this.grantPrincipal =\n          role || new iam.UnknownPrincipal({ resource: this });\n        this.resource = new dataAwsLambdaFunction.DataAwsLambdaFunction(\n          this,\n          \"Resource\",\n          {\n            functionName: this.functionName,\n          },\n        );\n\n        // // TODO: re-add support for EC2 connections\n        // if (attrs.securityGroup) {\n        //   this._connections = new ec2.Connections({\n        //     securityGroups: [attrs.securityGroup],\n        //   });\n        // }\n      }\n    }\n\n    return new Import(scope, id);\n  }\n\n  protected readonly resource: lambdaFunction.LambdaFunction;\n\n  private readonly _outputs: FunctionOutputs;\n\n  /** Strongly Typed Function Outputs */\n  public get functionOutputs(): FunctionOutputs {\n    return this._outputs;\n  }\n  public get outputs(): Record<string, any> {\n    return this.functionOutputs;\n  }\n\n  /**\n   * The name of the function.\n   *\n   * (not a TOKEN)\n   */\n  public readonly functionName: string;\n\n  /**\n   * The ARN fo the function.\n   */\n  public get functionArn(): string {\n    return this.resource.arn;\n  }\n\n  /**\n   * The ARN fo the function.\n   * (if versioning is enabled via publish = true)\n   */\n  public get functionQualifiedArn(): string {\n    return this.resource.qualifiedArn;\n  }\n\n  /**\n   * The ARN fo the function.\n   */\n  public get functionQualifiedInvokeArn(): string {\n    return this.resource.qualifiedInvokeArn;\n  }\n\n  /**\n   * The architecture of this Lambda Function.\n   */\n  public readonly architecture: Architecture;\n\n  /**\n   * The principal this Lambda Function is running as\n   */\n  public readonly grantPrincipal: iam.IPrincipal;\n\n  /**\n   * The IAM role associated with this function.\n   *\n   * Undefined if the function was imported without a role.\n   */\n  public readonly role?: iam.IRole;\n\n  /**\n   * The DLQ (as queue) associated with this Lambda Function (this is an optional attribute).\n   */\n  public readonly deadLetterQueue?: IQueue;\n\n  /**\n   * The timeout configured for this lambda.\n   */\n  public readonly timeout?: Duration;\n\n  /**\n   * The construct node where permissions are attached.\n   */\n  public readonly permissionsNode = this.node;\n\n  protected readonly canCreatePermissions = true;\n\n  /**\n   * Mapping of invocation principals to grants. Used to de-dupe `grantInvoke()` calls.\n   * @internal\n   */\n  protected _invocationGrants: Record<string, iam.Grant> = {};\n\n  /**\n   * Mapping of fucntion URL invocation principals to grants. Used to de-dupe `grantInvokeUrl()` calls.\n   * @internal\n   */\n  protected _functionUrlInvocationGrants: Record<string, iam.Grant> = {};\n\n  // // Teraform provider for AWS Automatically manages Function Versioning through code hash..\n  // // need to drop most of this version logic..\n\n  // private readonly currentVersionOptions?: VersionOptions;\n  // private _currentVersion?: Version;\n  // /**\n  //  * Returns a `lambda.Version` which represents the current version of this\n  //  * Lambda function. A new version will be created every time the function's\n  //  * configuration changes.\n  //  *\n  //  * You can specify options for this version using the `currentVersionOptions`\n  //  * prop when initializing the `lambda.Function`.\n  //  */\n  // public get currentVersion(): Version {\n  //   if (this._currentVersion) {\n  //     return this._currentVersion;\n  //   }\n\n  //   // if (this._warnIfCurrentVersionCalled) {\n  //   //   this.warnInvokeFunctionPermissions(this);\n  //   // }\n\n  //   this._currentVersion = new Version(this, \"CurrentVersion\", {\n  //     lambda: this,\n  //     ...this.currentVersionOptions,\n  //   });\n\n  //   // override the version's logical ID with a lazy string which includes the\n  //   // hash of the function itself, so a new version resource is created when\n  //   // the function configuration changes.\n  //   const cfn = this._currentVersion.node.defaultChild as TerraformResource;\n  //   const originalLogicalId = this.stack.resolve(cfn.logicalId) as string;\n\n  //   cfn.overrideLogicalId(\n  //     Lazy.stringValue({\n  //       produce: () => {\n  //         const hash = calculateFunctionHash(this, this.hashMixins.join(\"\"));\n  //         const logicalId = trimFromStart(originalLogicalId, 255 - 32);\n  //         return `${logicalId}${hash}`;\n  //       },\n  //     }),\n  //   );\n\n  //   return this._currentVersion;\n  // }\n\n  /**\n   * The ARN(s) to put into the resource field of the generated IAM policy for grantInvoke()\n   */\n  public get resourceArnsForGrantInvoke() {\n    // TODO: should this be qualifiedArn or qualifiedInvokeArn?\n    // https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/lambda_function#qualified_arn\n    return [this.functionArn, this.functionQualifiedInvokeArn];\n  }\n\n  /** @internal */\n  public readonly _logGroup: cloudwatchLogGroup.CloudwatchLogGroup;\n\n  /**\n   * Environment variables for this function\n   */\n  public readonly environment: { [key: string]: string } = {};\n\n  private _url?: string;\n  /**\n   * HTTP Endpoint for this function if defined.\n   *\n   * use `addFunctionUrl` to enable Endpoint.\n   */\n  public get url(): string | undefined {\n    return this._url;\n  }\n\n  private _eventSources: {\n    [id: string]: lambdaEventSourceMapping.LambdaEventSourceMapping;\n  } = {};\n  public get eventSources(): lambdaEventSourceMapping.LambdaEventSourceMapping[] {\n    return Object.values(this._eventSources);\n  }\n\n  private _securityGroup?: securityGroup.SecurityGroup;\n  public get securityGroup(): securityGroup.SecurityGroup | undefined {\n    return this._securityGroup;\n  }\n\n  constructor(scope: Construct, name: string, props: FunctionProps) {\n    super(scope, name, props);\n\n    const {\n      description,\n      environment: variables,\n      logRetentionInDays = RetentionDays.ONE_WEEK,\n      memorySize = 128,\n      timeout = Duration.seconds(3),\n      layers,\n      reservedConcurrentExecutions,\n    } = props;\n\n    /**\n     * The name or ARN of the Lambda function.\n     * is limited to 64 characters in length.\n     *\n     * ARN Pattern: ([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?\n     */\n    const functionName =\n      props.functionName ??\n      this.stack.uniqueResourceNamePrefix(this, {\n        prefix: props.functionNamePrefix ?? this.gridUUID + \"-\",\n        allowedSpecialCharacters: \"+\",\n        maxLength: 64,\n      });\n\n    if (functionName && !Token.isUnresolved(functionName)) {\n      if (functionName.length > 64) {\n        throw new Error(\n          `Function name can not be longer than 64 characters but has ${functionName.length} characters.`,\n        );\n      }\n      if (!/^[a-zA-Z0-9-_]+$/.test(functionName)) {\n        throw new Error(\n          `Function name ${functionName} can contain only letters, numbers, hyphens, or underscores with no spaces.`,\n        );\n      }\n    }\n\n    if (description && !Token.isUnresolved(description)) {\n      if (description.length > 256) {\n        throw new Error(\n          `Function description can not be longer than 256 characters but has ${description.length} characters.`,\n        );\n      }\n    }\n\n    const managedPolicies = new Array<iam.IManagedPolicy>();\n    // the arn is in the form of - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole\n    managedPolicies.push(\n      iam.ManagedPolicy.fromAwsManagedPolicyName(\n        this,\n        \"AWSLambdaBasicExecutionRole\",\n        \"service-role/AWSLambdaBasicExecutionRole\",\n      ),\n    );\n    if (props.networkConfig) {\n      // Policy that will have ENI creation permissions\n      // not sure if time.sleep is necessary?\n      // ref:\n      //  - https://github.com/pulumi/pulumi-aws/issues/2260#issuecomment-1977606509\n      //  - https://github.com/hashicorp/terraform-provider-aws/issues/29828#issuecomment-1693307500\n      managedPolicies.push(\n        iam.ManagedPolicy.fromAwsManagedPolicyName(\n          this,\n          \"AWSLambdaVPCAccessExecutionRole\",\n          \"service-role/AWSLambdaVPCAccessExecutionRole\",\n        ),\n      );\n    }\n\n    // TODO: Any concern not scoping the logGroup IAM Permissions?\n    // .allow()\n    // .toCreateLogStream()\n    // .toPutLogEvents()\n    // .on(logGroup.arn, `${logGroup.arn}:log-stream:*`),\n\n    this.role =\n      props.role ||\n      new iam.Role(this, \"ServiceRole\", {\n        assumedBy: new iam.ServicePrincipal(\"lambda.amazonaws.com\"),\n        managedPolicies,\n      });\n    this.grantPrincipal = this.role;\n    // TODO: Re-add filesystem / localMountPath support\n    // ref: filesystem.config.policies to be added to principal\n    // https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/aws-lambda/lib/function.ts#L949-L965\n\n    for (const statement of props.initialPolicy || []) {\n      this.role.addToPrincipalPolicy(statement);\n    }\n\n    // add support for AWS_CODEGURU Profile env variables...\n    const env = variables || {};\n    for (const [key, value] of Object.entries(env)) {\n      this.addEnvironment(key, value);\n    }\n\n    // DLQ can be either sns.ITopic or sqs.IQueue\n    const dlqTopicOrQueue = this.buildDeadLetterQueue(props);\n    if (dlqTopicOrQueue !== undefined) {\n      if (this.isQueue(dlqTopicOrQueue)) {\n        this.deadLetterQueue = dlqTopicOrQueue;\n      } else {\n        throw new Error(\"DeadLetterTopic is not supported yet\");\n        // this.deadLetterTopic = dlqTopicOrQueue;\n      }\n    }\n\n    const logGroup = new cloudwatchLogGroup.CloudwatchLogGroup(\n      this,\n      \"LogGroup\",\n      {\n        name: `/aws/lambda/${functionName}`,\n        retentionInDays: logRetentionInDays,\n      },\n    );\n    this._logGroup = logGroup;\n\n    this.resource = new lambdaFunction.LambdaFunction(this, \"Resource\", {\n      functionName,\n      description,\n      role: this.role.roleArn,\n      architectures: [\n        // This is an array, but maximum length is 1!\n        // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html#cfn-lambda-function-architectures\n        props.architecture?.toString() ?? Architecture.X86_64.toString(),\n      ],\n      memorySize,\n      timeout: timeout.toSeconds(),\n      layers, // TODO: Support ILayer with Lazy list of arns\n      reservedConcurrentExecutions,\n      // TODO: CDK Sorts environment to match Lambda Hash behaviour\n      // ref: https://github.com/aws/aws-cdk/blob/v2.156.0/packages/aws-cdk-lib/aws-lambda/lib/function.ts#L1467\n      environment: {\n        variables: Lazy.anyValue({\n          produce: (_context: IResolveContext) => {\n            return this.environment;\n          },\n        }) as any,\n      },\n      vpcConfig: this.parseVpcConfig(props.networkConfig),\n      loggingConfig: this.getLoggingConfig(this._logGroup.name, props),\n      tracingConfig: this.parseTracingConfig(props.tracing ?? Tracing.ACTIVE),\n      deadLetterConfig: this.parseDeadLetterConfig(dlqTopicOrQueue),\n      publish: props.publish,\n      // TODO: use logGroup.node.addDependency when logGroup is implemented\n      dependsOn: [logGroup],\n    });\n    this.functionName = this.resource.functionName;\n\n    // make sure any role attachments are added as dependencies for this lambda\n    // this achieved by the CDKTF Aspect on the parent StackBase\n    this.resource.node.addDependency(this.role);\n\n    this.timeout = props.timeout;\n    this.architecture = props.architecture ?? Architecture.X86_64;\n\n    // TODO: Add aws_lambda_provisioned_concurrency_config\n\n    for (const event of props.events || []) {\n      this.addEventSource(event);\n    }\n\n    // Event Invoke Config\n    if (\n      props.onFailure ||\n      props.onSuccess ||\n      props.maxEventAge ||\n      props.retryAttempts !== undefined\n    ) {\n      this.configureAsyncInvoke({\n        onFailure: props.onFailure,\n        onSuccess: props.onSuccess,\n        maxEventAge: props.maxEventAge,\n        retryAttempts: props.retryAttempts,\n      });\n    }\n\n    this._outputs = {\n      name: this.functionName,\n      arn: this.resource.arn,\n      roleArn: this.role.roleArn,\n      // only known at synth time\n      // explicit `null` required to avoid syntax errors when using stringValue && \"undefined\"\n      url: Lazy.anyValue({\n        produce: () => this._url ?? null,\n      }),\n      defaultSecurityGroup: Lazy.anyValue({\n        produce: () => this._securityGroup?.id ?? null,\n      }),\n    };\n  }\n\n  /**\n   * Adds an environment variable to this Lambda function.\n   * If this is a ref to a Lambda function, this operation results in a no-op.\n   * @param key The environment variable key.\n   * @param value The environment variable's value.\n   */\n  public addEnvironment(key: string, value: string): IFunction {\n    // Reserved environment variables will fail during cloudformation deploy if they're set.\n    // This check is just to allow CDK to fail faster when these are specified.\n    const reservedEnvironmentVariables = [\n      \"_HANDLER\",\n      \"_X_AMZN_TRACE_ID\",\n      \"AWS_DEFAULT_REGION\",\n      \"AWS_REGION\",\n      \"AWS_EXECUTION_ENV\",\n      \"AWS_LAMBDA_FUNCTION_NAME\",\n      \"AWS_LAMBDA_FUNCTION_MEMORY_SIZE\",\n      \"AWS_LAMBDA_FUNCTION_VERSION\",\n      \"AWS_LAMBDA_INITIALIZATION_TYPE\",\n      \"AWS_LAMBDA_LOG_GROUP_NAME\",\n      \"AWS_LAMBDA_LOG_STREAM_NAME\",\n      \"AWS_ACCESS_KEY\",\n      \"AWS_ACCESS_KEY_ID\",\n      \"AWS_SECRET_ACCESS_KEY\",\n      \"AWS_SESSION_TOKEN\",\n      \"AWS_LAMBDA_RUNTIME_API\",\n      \"LAMBDA_TASK_ROOT\",\n      \"LAMBDA_RUNTIME_DIR\",\n    ];\n    if (reservedEnvironmentVariables.includes(key)) {\n      throw new Error(\n        `${key} environment variable is reserved by the lambda runtime and can not be set manually. See https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html`,\n      );\n    }\n    this.environment[key] = value;\n    return this;\n  }\n\n  public addFunctionUrl(options?: FunctionUrlOptions): FunctionUrl {\n    const endpoint = super.addFunctionUrl(options);\n    this._url = endpoint.url;\n    return endpoint;\n  }\n\n  /**\n   * Get Logging Config propety for the function.\n   * This method returns the function LoggingConfig Property if the property is set on the\n   * function and undefined if not.\n   */\n  private getLoggingConfig(\n    logGroupName: string,\n    props: FunctionProps,\n  ): lambdaFunction.LambdaFunctionLoggingConfig | undefined {\n    if (props.applicationLogLevel || props.systemLogLevel) {\n      if (props.loggingFormat !== LoggingFormat.JSON) {\n        throw new Error(\n          `To use ApplicationLogLevel and/or SystemLogLevel you must set LoggingFormat to '${LoggingFormat.JSON}', got '${props.loggingFormat}'.`,\n        );\n      }\n    }\n\n    let loggingConfig: lambdaFunction.LambdaFunctionLoggingConfig;\n    if (props.loggingFormat) {\n      loggingConfig = {\n        logFormat: props.loggingFormat,\n        systemLogLevel: props.systemLogLevel,\n        applicationLogLevel: props.applicationLogLevel,\n        logGroup: logGroupName,\n      };\n      return loggingConfig;\n    }\n    return undefined;\n  }\n\n  /**\n   * Defines an alias for this function.\n   *\n   * The alias will automatically be updated to point to the latest version of\n   * the function as it is being updated during a deployment.\n   *\n   * ```ts\n   * declare const fn: compute.LambdaFunction;\n   *\n   * fn.addAlias('Live');\n   *\n   * // Is equivalent to\n   *\n   * new compute.Alias(this, 'AliasLive', {\n   *   aliasName: 'Live',\n   *   version: fn.version,\n   * });\n   * ```\n   *\n   * @param aliasName The name of the alias\n   * @param options Alias options\n   */\n  public addAlias(aliasName: string, options?: AliasOptions): Alias {\n    return addAlias(this, this, this.version, aliasName, options);\n  }\n\n  /**\n   * Optionally create LambdaFunctionVpcConfig\n   */\n  private parseVpcConfig(\n    config?: VpcConfig,\n  ): lambdaFunction.LambdaFunctionVpcConfig | undefined {\n    if (!config) {\n      return undefined;\n    }\n    let securityGroupIds = config.securityGroupIds;\n    if (!securityGroupIds) {\n      this._securityGroup = new securityGroup.SecurityGroup(\n        this,\n        \"SecurityGroup\",\n        {\n          name: this.functionName,\n          description: this.functionName,\n          vpcId: config.vpcId,\n\n          egress: config.egress ?? [\n            {\n              fromPort: 0,\n              toPort: 0,\n              protocol: \"-1\",\n              cidrBlocks: [\"0.0.0.0/0\"],\n              ipv6CidrBlocks: [\"::/0\"],\n            },\n          ],\n        },\n      );\n      securityGroupIds = [this._securityGroup.id];\n    }\n    return {\n      subnetIds: config.subnetIds,\n      ipv6AllowedForDualStack: config.ipv6AllowedForDualStack,\n      securityGroupIds,\n    };\n  }\n\n  private isQueue(deadLetterQueue: IQueue): deadLetterQueue is IQueue {\n    return (<IQueue>deadLetterQueue).queueArn !== undefined;\n  }\n\n  private buildDeadLetterQueue(props: FunctionProps): IQueue | undefined {\n    // | sns.ITopic\n    if (\n      !props.deadLetterQueue &&\n      !props.deadLetterQueueEnabled\n      // && !props.deadLetterTopic\n    ) {\n      return undefined;\n    }\n    if (props.deadLetterQueue && props.deadLetterQueueEnabled === false) {\n      throw Error(\n        \"deadLetterQueue defined but deadLetterQueueEnabled explicitly set to false\",\n      );\n    }\n    // if (\n    //   props.deadLetterTopic &&\n    //   (props.deadLetterQueue || props.deadLetterQueueEnabled !== undefined)\n    // ) {\n    //   throw new Error(\n    //     \"deadLetterQueue and deadLetterTopic cannot be specified together at the same time\",\n    //   );\n    // }\n\n    let deadLetterQueue: IQueue; // | ITopic;\n    // if (props.deadLetterTopic) {\n    //   deadLetterQueue = props.deadLetterTopic;\n    //   this.addToRolePolicy(\n    //     new iam.PolicyStatement({\n    //       actions: [\"sns:Publish\"],\n    //       resources: [deadLetterQueue.topicArn],\n    //     }),\n    //   );\n    // } else {\n    deadLetterQueue =\n      props.deadLetterQueue ||\n      new Queue(this, \"DeadLetterQueue\", {\n        messageRetentionSeconds: Duration.days(14).toSeconds(),\n      });\n    this.addToRolePolicy(\n      new iam.PolicyStatement({\n        actions: [\"sqs:SendMessage\"],\n        resources: [deadLetterQueue.queueArn],\n      }),\n    );\n    // }\n\n    return deadLetterQueue;\n  }\n\n  // TODO: Support sns.ITopic + sns:Publish topicArn\n  /**\n   * Optionally create LambdaFunctionDeadLetterConfig\n   */\n  private parseDeadLetterConfig(\n    deadLetterQueue?: IQueue, // | sns.ITopic\n  ): lambdaFunction.LambdaFunctionDeadLetterConfig | undefined {\n    if (deadLetterQueue) {\n      // this.isQueue(deadLetterQueue) ? deadLetterQueue.queueArn : ...\n      return {\n        targetArn: deadLetterQueue.queueArn,\n      };\n    } else {\n      return undefined;\n    }\n  }\n\n  private parseTracingConfig(\n    tracing: Tracing,\n  ): lambdaFunction.LambdaFunctionTracingConfig | undefined {\n    if (tracing === undefined || tracing === Tracing.DISABLED) {\n      return undefined;\n    }\n\n    this.addToRolePolicy(\n      new iam.PolicyStatement({\n        actions: [\"xray:PutTraceSegments\", \"xray:PutTelemetryRecords\"],\n        resources: [\"*\"],\n      }),\n    );\n\n    return {\n      mode: tracing,\n    };\n  }\n}\n\n/**\n * Given an opaque (token) ARN, returns a TF expression that extracts the function\n * name from the ARN.\n *\n * Function ARNs look like this:\n *\n *   arn:aws:lambda:region:account-id:function:function-name\n *\n * ..which means that in order to extract the `function-name` component from the ARN, we can\n * split the ARN using \":\" and select the component in index 6.\n *\n * @returns `element(split(':', arn), 6)`\n */\nfunction extractNameFromArn(arn: string) {\n  return Fn.element(Fn.split(\":\", arn), 6);\n}\n\n/**\n * X-Ray Tracing Modes (https://docs.aws.amazon.com/lambda/latest/dg/API_TracingConfig.html)\n */\nexport enum Tracing {\n  /**\n   * Lambda will respect any tracing header it receives from an upstream service.\n   * If no tracing header is received, Lambda will sample the request based on a fixed rate. Please see the [Using AWS Lambda with AWS X-Ray](https://docs.aws.amazon.com/lambda/latest/dg/services-xray.html) documentation for details on this sampling behavior.\n   */\n  ACTIVE = \"Active\",\n  /**\n   * Lambda will only trace the request from an upstream service\n   * if it contains a tracing header with \"sampled=1\"\n   */\n  PASS_THROUGH = \"PassThrough\",\n  /**\n   * Lambda will not trace any request.\n   */\n  DISABLED = \"Disabled\",\n}\n\n/**\n * Lambda service will automatically captures system logs about function invocation\n * generated by the Lambda service (known as system logs) and sends these logs to a\n * default CloudWatch log group named after the Lambda function.\n */\nexport enum SystemLogLevel {\n  /**\n   * Lambda will capture only logs at info level.\n   */\n  INFO = \"INFO\",\n  /**\n   * Lambda will capture only logs at debug level.\n   */\n  DEBUG = \"DEBUG\",\n  /**\n   * Lambda will capture only logs at warn level.\n   */\n  WARN = \"WARN\",\n}\n\n/**\n * Lambda service automatically captures logs generated by the function code\n * (known as application logs) and sends these logs to a default CloudWatch\n * log group named after the Lambda function.\n */\nexport enum ApplicationLogLevel {\n  /**\n   * Lambda will capture only logs at info level.\n   */\n  INFO = \"INFO\",\n  /**\n   * Lambda will capture only logs at debug level.\n   */\n  DEBUG = \"DEBUG\",\n  /**\n   * Lambda will capture only logs at warn level.\n   */\n  WARN = \"WARN\",\n  /**\n   * Lambda will capture only logs at trace level.\n   */\n  TRACE = \"TRACE\",\n  /**\n   * Lambda will capture only logs at error level.\n   */\n  ERROR = \"ERROR\",\n  /**\n   * Lambda will capture only logs at fatal level.\n   */\n  FATAL = \"FATAL\",\n}\n\n/**\n * This field takes in 2 values either Text or JSON. By setting this value to Text,\n * will result in the current structure of logs format, whereas, by setting this value to JSON,\n * Lambda will print the logs as Structured JSON Logs, with the corresponding timestamp and log level\n * of each event. Selecting ‘JSON’ format will only allow customer’s to have different log level\n * Application log level and the System log level.\n */\nexport enum LoggingFormat {\n  /**\n   * Lambda Logs text format.\n   */\n  TEXT = \"Text\",\n  /**\n   * Lambda structured logging in Json format.\n   */\n  JSON = \"JSON\",\n}\n\n/**\n * A destination configuration\n */\nexport interface DlqDestinationConfig {\n  /**\n   * The Amazon Resource Name (ARN) of the destination resource\n   */\n  readonly destination: string;\n}\n\n/**\n * A DLQ for an event source\n */\nexport interface IEventSourceDlq {\n  /**\n   * Returns the DLQ destination config of the DLQ\n   */\n  bind(\n    target: IEventSourceMapping,\n    targetHandler: IFunction,\n  ): DlqDestinationConfig;\n}\n"]}