terraconstructs 0.0.8

package/lib/aws/compute/function-base.js

@@ -0,0 +1,421 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QualifiedFunctionBase = exports.LambdaFunctionBase = 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 with https://github.com/aws/aws-cdk/blob/v2.156.0/packages/aws-cdk-lib/aws-lambda/lib/function-base.ts
+const crypto = require("crypto");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const arn_1 = require("../arn");
+const aws_construct_1 = require("../aws-construct");
+const aws_stack_1 = require("../aws-stack");
+const event_invoke_config_1 = require("./event-invoke-config");
+const event_source_mapping_1 = require("./event-source-mapping");
+const function_url_1 = require("./function-url");
+const iam = require("../iam");
+class LambdaFunctionBase extends aws_construct_1.AwsConstructBase {
+    constructor() {
+        super(...arguments);
+        /**
+         * 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 = {};
+    }
+    /**
+     * Adds a permission to the Lambda resource policy.
+     * @param id The id for the permission construct
+     * @param permission The permission to grant to this Lambda function. @see Permission for details.
+     */
+    addPermission(id, permission) {
+        if (!this.canCreatePermissions) {
+            if (!this._skipPermissions) {
+                // TODO: revise this annotation
+                // Unclear Lambda Environment
+                cdktf_1.Annotations.of(this).addWarning([
+                    `addPermission() has no effect on a Lambda Function with region=${this.env.region}, account=${this.env.account},`,
+                    `in a Stack with region=${aws_stack_1.AwsStack.ofAwsConstruct(this).region}, account=${aws_stack_1.AwsStack.ofAwsConstruct(this).account}.`,
+                    `Suppress this warning if this is is intentional, or pass sameEnvironment=true to fromFunctionAttributes()`,
+                    `if you would like to add the permissions.`,
+                ].join(" "));
+            }
+            return;
+        }
+        let principal = this.parsePermissionPrincipal(permission.principal);
+        let { sourceArn, sourceAccount, principalOrgID } = this.validateConditionCombinations(permission.principal) ?? {};
+        const action = permission.action ?? "lambda:InvokeFunction";
+        const scope = permission.scope ?? this;
+        /**
+         * Do invokeFunction lambdas with unqualified function references apply to TF?
+         * A warning should be added to functions under the following conditions:
+         * - permissions that include `lambda:InvokeFunction` are added to the unqualified function.
+         * - function.currentVersion is invoked before or after the permission is created.
+         *
+         * This applies only to permissions on Lambda functions, not versions or aliases.
+         * This function is overridden as a noOp for QualifiedFunctionBase.
+         * https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/aws-lambda/lib/function-base.ts#L332
+         */
+        // [
+        //   "AWS Lambda has changed their authorization strategy, which may cause client invocations using the 'Qualifier' parameter of the lambda function to fail with Access Denied errors.",
+        //   "If you are using a lambda Version or Alias, make sure to call 'grantInvoke' or 'addPermission' on the Version or Alias, not the underlying Function",
+        //   'See: https://github.com/aws/aws-cdk/issues/19273',
+        // ].join('\n'));
+        new provider_aws_1.lambdaPermission.LambdaPermission(scope, id, {
+            action,
+            principal,
+            // qualifier: permission.qualifier,
+            functionName: this.functionArn,
+            eventSourceToken: permission.eventSourceToken,
+            sourceAccount: permission.sourceAccount ?? sourceAccount,
+            sourceArn: permission.sourceArn ?? sourceArn,
+            principalOrgId: permission.organizationId ?? principalOrgID,
+            functionUrlAuthType: permission.functionUrlAuthType,
+        });
+    }
+    /**
+     * Adds a statement to the IAM role assumed by the instance.
+     */
+    addToRolePolicy(statement) {
+        if (!this.role) {
+            return;
+        }
+        this.role.addToPrincipalPolicy(statement);
+    }
+    addEventSourceMapping(id, options) {
+        return new event_source_mapping_1.EventSourceMapping(this, id, {
+            target: this,
+            ...options,
+        });
+    }
+    /**
+     * Grant the given identity permissions to invoke this Lambda
+     */
+    grantInvoke(grantee) {
+        const hash = crypto
+            .createHash("sha256")
+            .update(JSON.stringify({
+            principal: grantee.grantPrincipal.toString(),
+            conditions: grantee.grantPrincipal.policyFragment.conditions,
+        }), "utf8")
+            .digest("base64");
+        const identifier = `Invoke${hash}`;
+        // Memoize the result so subsequent grantInvoke() calls are idempotent
+        let grant = this._invocationGrants[identifier];
+        if (!grant) {
+            grant = this.grant(grantee, identifier, "lambda:InvokeFunction", this.resourceArnsForGrantInvoke);
+            this._invocationGrants[identifier] = grant;
+        }
+        return grant;
+    }
+    /**
+     * Grant the given identity permissions to invoke the $LATEST version or
+     * unqualified version of this Lambda
+     */
+    grantInvokeLatestVersion(grantee) {
+        return this.grantInvokeVersion(grantee, this.version);
+    }
+    /**
+     * Grant the given identity permissions to invoke the given version of this Lambda
+     */
+    grantInvokeVersion(grantee, version) {
+        let grant;
+        if (cdktf_1.Token.isUnresolved(version)) {
+            // Identifier is set to "InvokeLatest"??
+            return this.grantInvoke(grantee);
+        }
+        // else, use version string in hash?
+        const hash = crypto
+            .createHash("sha256")
+            .update(JSON.stringify({
+            principal: grantee.grantPrincipal.toString(),
+            conditions: grantee.grantPrincipal.policyFragment.conditions,
+            version: version,
+        }), "utf8")
+            .digest("base64");
+        const identifier = `Invoke${hash}`;
+        // Memoize the result so subsequent grantInvoke() calls are idempotent
+        grant = this._invocationGrants[identifier];
+        if (!grant) {
+            let resouceArns = [`${this.functionArn}:${version}`];
+            if (version == this.version) {
+                resouceArns.push(this.functionArn);
+            }
+            grant = this.grant(grantee, identifier, "lambda:InvokeFunction", resouceArns);
+            this._invocationGrants[identifier] = grant;
+        }
+        return grant;
+    }
+    /**
+     * Grant the given identity permissions to invoke this Lambda Function URL
+     */
+    grantInvokeUrl(grantee) {
+        const identifier = `InvokeFunctionUrl${grantee.grantPrincipal}`; // calls the .toString() of the principal
+        // Memoize the result so subsequent grantInvoke() calls are idempotent
+        let grant = this._functionUrlInvocationGrants[identifier];
+        if (!grant) {
+            grant = this.grant(grantee, identifier, "lambda:InvokeFunctionUrl", [this.functionArn], {
+                functionUrlAuthType: function_url_1.FunctionUrlAuthType.AWS_IAM,
+            });
+            this._functionUrlInvocationGrants[identifier] = grant;
+        }
+        return grant;
+    }
+    /**
+     * Grant multiple principals the ability to invoke this Lambda via CompositePrincipal
+     */
+    grantInvokeCompositePrincipal(compositePrincipal) {
+        return compositePrincipal.principals.map((principal) => this.grantInvoke(principal));
+    }
+    addEventSource(source) {
+        source.bind(this);
+    }
+    configureAsyncInvoke(options) {
+        if (this.node.tryFindChild("EventInvokeConfig") !== undefined) {
+            throw new Error(`An EventInvokeConfig has already been configured for the function at ${this.node.path}`);
+        }
+        new event_invoke_config_1.EventInvokeConfig(this, "EventInvokeConfig", {
+            function: this,
+            ...options,
+        });
+    }
+    /**
+     * A function URL is a dedicated HTTP(S) endpoint for a Lambda function.
+     */
+    addFunctionUrl(options) {
+        if (this.node.tryFindChild("FunctionUrl") !== undefined) {
+            throw new Error(`A FunctionUrl has already been configured for the function at ${this.node.path}`);
+        }
+        return new function_url_1.FunctionUrl(this, "FunctionUrl", {
+            function: this,
+            ...options,
+        });
+    }
+    /**
+     * Returns the construct tree node that corresponds to the lambda function.
+     * For use internally for constructs, when the tree is set up in non-standard ways. Ex: SingletonFunction.
+     * @internal
+     */
+    _functionNode() {
+        return this.node;
+    }
+    /**
+     * Given the function arn, check if the account id matches this account
+     *
+     * Function ARNs look like this:
+     *
+     *   arn:aws:lambda:region:account-id:function:function-name
+     *
+     * ..which means that in order to extract the `account-id` component from the ARN, we can
+     * split the ARN using ":" and select the component in index 4.
+     *
+     * @returns true if account id of function matches the account specified on the stack, false otherwise.
+     *
+     * @internal
+     */
+    _isStackAccount() {
+        if (cdktf_1.Token.isUnresolved(this.stack.account) ||
+            cdktf_1.Token.isUnresolved(this.functionArn)) {
+            return false;
+        }
+        return (this.stack.splitArn(this.functionArn, arn_1.ArnFormat.SLASH_RESOURCE_NAME)
+            .account === this.stack.account);
+    }
+    grant(grantee, identifier, action, resourceArns, permissionOverrides) {
+        const grant = iam.Grant.addToPrincipalOrResource({
+            grantee,
+            actions: [action],
+            resourceArns,
+            // Fake resource-like object on which to call addToResourcePolicy(), which actually
+            // calls addPermission()
+            resource: {
+                addToResourcePolicy: (_statement) => {
+                    // Couldn't add permissions to the principal, so add them locally.
+                    this.addPermission(identifier, {
+                        principal: grantee.grantPrincipal,
+                        action: action,
+                        ...permissionOverrides,
+                    });
+                    const permissionNode = this._functionNode().tryFindChild(identifier);
+                    if (!permissionNode && !this._skipPermissions) {
+                        throw new Error("Cannot modify permission to lambda function. Function is either imported or $LATEST version.\n" +
+                            "If the function is imported from the same account use `fromFunctionAttributes()` API with the `sameEnvironment` flag.\n" +
+                            "If the function is imported from a different account and already has the correct permissions use `fromFunctionAttributes()` API with the `skipPermissions` flag.");
+                    }
+                    return { statementAdded: true, policyDependable: permissionNode };
+                },
+                node: this.node,
+                stack: this.stack,
+                env: this.env,
+                environmentName: this.environmentName,
+                gridUUID: this.gridUUID,
+                outputs: {},
+            },
+        });
+        return grant;
+    }
+    /**
+     * Translate IPrincipal to something we can pass to aws_lambda_permission
+     * https://docs.aws.amazon.com/lambda/latest/api/API_AddPermission.html#lambda-AddPermission-request-Principal
+     * https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/lambda_permission#principal
+     *
+     * Do some nasty things because `Permission` supports a subset of what the
+     * full IAM principal language supports, and we may not be able to parse strings
+     * outright because they may be tokens.
+     *
+     * Try to recognize some specific Principal classes first, then try a generic
+     * fallback.
+     */
+    parsePermissionPrincipal(principal) {
+        // Try some specific common classes first.
+        // use duck-typing, not instance of
+        if ("wrapped" in principal) {
+            // eslint-disable-next-line dot-notation
+            principal = principal["wrapped"];
+        }
+        if ("accountId" in principal) {
+            return principal.accountId;
+        }
+        if ("service" in principal) {
+            return principal.service;
+        }
+        if ("arn" in principal) {
+            return principal.arn;
+        }
+        const stringEquals = matchSingleCondition("StringEquals", principal.policyFragment.conditions);
+        if (stringEquals &&
+            stringEquals.length === 1 &&
+            stringEquals[0].variable === "aws:PrincipalOrgID") {
+            // we will move the organization id to the `principalOrgId` property of `Permissions`.
+            return "*";
+        }
+        // Try a best-effort approach to support simple principals that are not any of the predefined
+        // classes, but are simple enough that they will fit into the Lambda Permission model.
+        // Main target here: imported Roles, Users, Groups.
+        //
+        // The principal cannot have conditions and must have a single { AWS: [arn] } entry.
+        const principals = principal.policyFragment.principals.filter((p) => p.type === "AWS");
+        if (principal.policyFragment.conditions.length === 0 &&
+            principals.length === 1) {
+            if (principals[0].identifiers.length === 1) {
+                return principals[0].identifiers[0];
+            }
+        }
+        throw new Error(`Invalid principal type for Lambda permission statement: ${principal.constructor.name}. ` +
+            "Supported: AccountPrincipal, ArnPrincipal, ServicePrincipal, OrganizationPrincipal");
+        /**
+         * Returns the conditions for a certain test if it exists and if there are no other conditions. Otherwise,
+         * returns undefined.
+         */
+        function matchSingleCondition(test, obj) {
+            if (obj.length !== 1) {
+                return undefined;
+            }
+            return obj.filter((c) => c.test === test);
+        }
+    }
+    validateConditionCombinations(principal) {
+        const conditions = this.validateConditions(principal);
+        if (!conditions) {
+            return undefined;
+        }
+        // TODO: what if more than 1 identifier? Should any of these throw?
+        const sourcArnConditions = conditions.filter((c) => c.test === "ArnLike" && c.variable === "aws:SourceArn");
+        const sourceArn = sourcArnConditions.length > 0
+            ? sourcArnConditions[0].values[0]
+            : undefined;
+        // requireString(
+        //   requireObject(conditions.ArnLike)?.["aws:SourceArn"],
+        // );
+        const sourceAccountConditions = conditions.filter((c) => c.test === "StringEquals" && c.variable === "aws:SourceAccount");
+        const sourceAccount = sourceAccountConditions.length > 0
+            ? sourceAccountConditions[0].values[0]
+            : undefined;
+        // requireString(
+        //   requireObject(conditions.StringEquals)?.["aws:SourceAccount"],
+        // );
+        const principalOrgIDConditions = conditions.filter((c) => c.test === "StringEquals" && c.variable === "aws:PrincipalOrgID");
+        const principalOrgID = principalOrgIDConditions.length > 0
+            ? principalOrgIDConditions[0].values[0]
+            : undefined;
+        // requireString(
+        //   requireObject(conditions.StringEquals)?.["aws:PrincipalOrgID"],
+        // );
+        // PrincipalOrgID cannot be combined with any other conditions
+        if (principalOrgID && (sourceArn || sourceAccount)) {
+            throw new Error("PrincipalWithConditions had unsupported condition combinations for Lambda permission statement: principalOrgID cannot be set with other conditions.");
+        }
+        return {
+            sourceArn,
+            sourceAccount,
+            principalOrgID,
+        };
+    }
+    validateConditions(principal) {
+        if (this.isPrincipalWithConditions(principal)) {
+            const conditions = principal.policyFragment.conditions;
+            // These are all the supported conditions. Some combinations are not supported,
+            // like only 'aws:SourceArn' or 'aws:PrincipalOrgID' and 'aws:SourceAccount'.
+            // These will be validated through `this.validateConditionCombinations`.
+            const supportedPrincipalConditions = [
+                {
+                    test: "ArnLike",
+                    variable: "aws:SourceArn",
+                },
+                {
+                    test: "StringEquals",
+                    variable: "aws:SourceAccount",
+                },
+                {
+                    test: "StringEquals",
+                    variable: "aws:PrincipalOrgID",
+                },
+            ];
+            const unsupportedConditions = conditions.filter((condition) => !supportedPrincipalConditions.some((supportedCondition) => supportedCondition.test === condition.test &&
+                supportedCondition.variable === condition.variable));
+            if (unsupportedConditions.length == 0) {
+                return conditions;
+            }
+            else {
+                throw new Error(`PrincipalWithConditions had unsupported conditions for Lambda permission statement: ${JSON.stringify(unsupportedConditions)}. ` +
+                    `Supported operator/condition pairs: ${JSON.stringify(supportedPrincipalConditions)}`);
+            }
+        }
+        return undefined;
+    }
+    isPrincipalWithConditions(principal) {
+        return principal.policyFragment.conditions.length > 0;
+    }
+}
+exports.LambdaFunctionBase = LambdaFunctionBase;
+_a = JSII_RTTI_SYMBOL_1;
+LambdaFunctionBase[_a] = { fqn: "terraconstructs.aws.compute.LambdaFunctionBase", version: "0.0.8" };
+class QualifiedFunctionBase extends LambdaFunctionBase {
+    constructor() {
+        super(...arguments);
+        this.permissionsNode = this.node;
+    }
+    get resourceArnsForGrantInvoke() {
+        return [this.functionArn];
+    }
+    configureAsyncInvoke(options) {
+        if (this.node.tryFindChild("EventInvokeConfig") !== undefined) {
+            throw new Error(`An EventInvokeConfig has already been configured for the qualified function at ${this.node.path}`);
+        }
+        new event_invoke_config_1.EventInvokeConfig(this, "EventInvokeConfig", {
+            function: this.lambda,
+            qualifier: this.version,
+            ...options,
+        });
+    }
+}
+exports.QualifiedFunctionBase = QualifiedFunctionBase;
+_b = JSII_RTTI_SYMBOL_1;
+QualifiedFunctionBase[_b] = { fqn: "terraconstructs.aws.compute.QualifiedFunctionBase", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"function-base.js","sourceRoot":"","sources":["../../../src/aws/compute/function-base.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 with https://github.com/aws/aws-cdk/blob/v2.156.0/packages/aws-cdk-lib/aws-lambda/lib/function-base.ts\nimport * as crypto from \"crypto\";\nimport { lambdaPermission } from \"@cdktf/provider-aws\";\nimport { IResolvable, Annotations, Token } from \"cdktf\";\nimport { Node } from \"constructs\";\nimport { ArnFormat } from \"../arn\";\nimport { AwsConstructBase, IAwsConstruct } from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\nimport { Architecture } from \"./architecture\";\nimport {\n  EventInvokeConfig,\n  EventInvokeConfigOptions,\n} from \"./event-invoke-config\";\nimport {\n  EventSourceMapping,\n  EventSourceMappingOptions,\n} from \"./event-source-mapping\";\nimport { Permission } from \"./function-permission\";\nimport {\n  FunctionUrlOptions,\n  FunctionUrl,\n  FunctionUrlAuthType,\n} from \"./function-url\";\nimport * as iam from \"../iam\";\n\n// TODO: re-add ec2.IConnectable?\n\n/**\n * Represents a Lambda function defined outside of this stack.\n */\nexport interface FunctionAttributes {\n  /**\n   * The ARN of the Lambda function.\n   *\n   * Format: arn:<partition>:lambda:<region>:<account-id>:function:<function-name>\n   */\n  readonly functionArn: string;\n\n  /**\n   * The IAM execution role associated with this function.\n   *\n   * If the role is not specified, any role-related operations will no-op.\n   */\n  readonly role?: iam.IRole;\n\n  /**\n   * The security group of this Lambda, if in a VPC.\n   *\n   * This needs to be given in order to support allowing connections\n   * to this Lambda.\n   */\n  readonly securityGroup?: string | IResolvable; // TODO: Re-add support for EC2 security groups\n\n  /**\n   * Setting this property informs the CDK that the imported function is in the same environment as the stack.\n   * This affects certain behaviours such as, whether this function's permission can be modified.\n   * When not configured, the CDK attempts to auto-determine this. For environment agnostic stacks, i.e., stacks\n   * where the account is not specified with the `env` property, this is determined to be false.\n   *\n   * Set this to property *ONLY IF* the imported function is in the same account as the stack\n   * it's imported in.\n   * @default - depends: true, if the Stack is configured with an explicit `env` (account and region) and the account is the same as this function.\n   * For environment-agnostic stacks this will default to `false`.\n   */\n  readonly sameEnvironment?: boolean;\n\n  /**\n   * Setting this property informs the TerraConstruct that the imported function ALREADY HAS the necessary permissions\n   * for what you are trying to do. When not configured, E.T, attempts to auto-determine whether or not\n   * additional permissions are necessary on the function when grant APIs are used. If TerraConstruct 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   * this TerraConstruct stack. You are acknowledging that your TerraConstruct code alone will have insufficient permissions to access the\n   * imported function.\n   *\n   * @default false\n   */\n  readonly skipPermissions?: boolean;\n\n  /**\n   * The architecture of this Lambda Function (this is an optional attribute and defaults to X86_64).\n   * @default - Architecture.X86_64\n   */\n  readonly architecture?: Architecture;\n}\n\n/**\n * A Lambda function.\n */\nexport interface IFunction extends IAwsConstruct, iam.IGrantable {\n  /**\n   * The name of the function.\n   *\n   * @attribute\n   */\n  readonly functionName: string;\n\n  /**\n   * The ARN of the function.\n   *\n   * @attribute\n   */\n  readonly functionArn: string;\n\n  /**\n   * The IAM role associated with this function.\n   */\n  readonly role?: iam.IRole;\n\n  /**\n   * The construct node where permissions are attached.\n   */\n  readonly permissionsNode: Node;\n\n  /**\n   * The system architectures compatible with this lambda function.\n   */\n  readonly architecture: Architecture;\n\n  /**\n   * Adds an event source that maps to this AWS Lambda function.\n   * @param id construct ID\n   * @param options mapping options\n   */\n  addEventSourceMapping(\n    id: string,\n    options: EventSourceMappingOptions,\n  ): EventSourceMapping;\n\n  /**\n   * Adds an event source to this function.\n   *\n   * The following example adds an SQS Queue as an event source:\n   * ```\n   * import { compute } from 'terraconstructs';\n   * myFunction.addEventSource(new compute.SqsEventSource(myQueue));\n   * ```\n   */\n  addEventSource(source: IEventSource): void;\n\n  /**\n   * Adds a permission to the Lambda resource policy.\n   * @param id The id for the permission construct\n   * @param permission The permission to grant to this Lambda function. @see Permission for details.\n   */\n  addPermission(id: string, permission: Permission): void;\n\n  /**\n   * Adds a statement to the IAM role assumed by the instance.\n   */\n  addToRolePolicy(statement: iam.PolicyStatement): void;\n\n  /**\n   * Grant the given identity permissions to invoke this Lambda\n   */\n  grantInvoke(identity: iam.IGrantable): iam.Grant;\n\n  /**\n   * Grant the given identity permissions to invoke the $LATEST version or\n   * unqualified version of this Lambda\n   */\n  grantInvokeLatestVersion(identity: iam.IGrantable): iam.Grant;\n\n  /**\n   * Grant the given identity permissions to invoke the given (or latest) version of this Lambda\n   */\n  grantInvokeVersion(identity: iam.IGrantable, version: string): iam.Grant;\n\n  /**\n   * Grant the given identity permissions to invoke this Lambda Function URL\n   */\n  grantInvokeUrl(identity: iam.IGrantable): iam.Grant;\n\n  /**\n   * Grant multiple principals the ability to invoke this Lambda via CompositePrincipal\n   */\n  grantInvokeCompositePrincipal(\n    compositePrincipal: iam.CompositePrincipal,\n  ): iam.Grant[];\n\n  /**\n   * Configures options for asynchronous invocation.\n   */\n  configureAsyncInvoke(options: EventInvokeConfigOptions): void;\n\n  /**\n   * Adds a url to this lambda function.\n   */\n  addFunctionUrl(options?: FunctionUrlOptions): FunctionUrl;\n}\n\nexport abstract class LambdaFunctionBase\n  extends AwsConstructBase\n  implements IFunction\n{\n  /**\n   * The name of the function.\n   */\n  public abstract readonly functionName: string;\n\n  /**\n   * The principal this Lambda Function is running as\n   */\n  public abstract readonly grantPrincipal: iam.IPrincipal;\n\n  /**\n   * The ARN fo the function.\n   *\n   * Should include version (if versioning is enabled via publish = true)\n   */\n  public abstract readonly functionArn: string;\n\n  /**\n   * Latest published version of your Lambda Function.\n   *\n   * Used as qualifier of the version or alias of this function.\n   * A qualifier is the identifier that's appended to a version or alias ARN.\n   * @see https://docs.aws.amazon.com/lambda/latest/dg/API_GetFunctionConfiguration.html#API_GetFunctionConfiguration_RequestParameters\n   */\n  public abstract readonly version: string;\n\n  /**\n   * The qualifier of the version or alias of this function.\n   * A qualifier is the identifier that's appended to a version or alias ARN.\n   * @see https://docs.aws.amazon.com/lambda/latest/dg/API_GetFunctionConfiguration.html#API_GetFunctionConfiguration_RequestParameters\n   */\n\n  /**\n   * The IAM role associated with this function.\n   *\n   * Undefined if the function was imported without a role.\n   */\n  public abstract readonly role?: iam.IRole;\n\n  /**\n   * The construct node where permissions are attached.\n   */\n  public abstract readonly permissionsNode: Node;\n\n  /**\n   * The architecture of this Lambda Function.\n   */\n  public abstract readonly architecture: Architecture;\n\n  /**\n   * Whether the addPermission() call adds any permissions\n   *\n   * True for new Lambdas, false for version $LATEST and imported Lambdas\n   * from different accounts.\n   */\n  protected abstract readonly canCreatePermissions: boolean;\n\n  /**\n   * The ARN(s) to put into the resource field of the generated IAM policy for grantInvoke()\n   */\n  public abstract readonly resourceArnsForGrantInvoke: string[];\n\n  /**\n   * Whether the user decides to skip adding permissions.\n   * The only use case is for cross-account, imported lambdas\n   * where the user commits to modifying the permisssions\n   * on the imported lambda outside this TerraConstruct Spec.\n   * @internal\n   */\n  protected readonly _skipPermissions?: boolean;\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  /**\n   * Adds a permission to the Lambda resource policy.\n   * @param id The id for the permission construct\n   * @param permission The permission to grant to this Lambda function. @see Permission for details.\n   */\n  public addPermission(id: string, permission: Permission) {\n    if (!this.canCreatePermissions) {\n      if (!this._skipPermissions) {\n        // TODO: revise this annotation\n        // Unclear Lambda Environment\n        Annotations.of(this).addWarning(\n          [\n            `addPermission() has no effect on a Lambda Function with region=${this.env.region}, account=${this.env.account},`,\n            `in a Stack with region=${AwsStack.ofAwsConstruct(this).region}, account=${AwsStack.ofAwsConstruct(this).account}.`,\n            `Suppress this warning if this is is intentional, or pass sameEnvironment=true to fromFunctionAttributes()`,\n            `if you would like to add the permissions.`,\n          ].join(\" \"),\n        );\n      }\n      return;\n    }\n\n    let principal = this.parsePermissionPrincipal(permission.principal);\n\n    let { sourceArn, sourceAccount, principalOrgID } =\n      this.validateConditionCombinations(permission.principal) ?? {};\n\n    const action = permission.action ?? \"lambda:InvokeFunction\";\n    const scope = permission.scope ?? this;\n\n    /**\n     * Do invokeFunction lambdas with unqualified function references apply to TF?\n     * A warning should be added to functions under the following conditions:\n     * - permissions that include `lambda:InvokeFunction` are added to the unqualified function.\n     * - function.currentVersion is invoked before or after the permission is created.\n     *\n     * This applies only to permissions on Lambda functions, not versions or aliases.\n     * This function is overridden as a noOp for QualifiedFunctionBase.\n     * https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/aws-lambda/lib/function-base.ts#L332\n     */\n    // [\n    //   \"AWS Lambda has changed their authorization strategy, which may cause client invocations using the 'Qualifier' parameter of the lambda function to fail with Access Denied errors.\",\n    //   \"If you are using a lambda Version or Alias, make sure to call 'grantInvoke' or 'addPermission' on the Version or Alias, not the underlying Function\",\n    //   'See: https://github.com/aws/aws-cdk/issues/19273',\n    // ].join('\\n'));\n\n    new lambdaPermission.LambdaPermission(scope, id, {\n      action,\n      principal,\n      // qualifier: permission.qualifier,\n      functionName: this.functionArn,\n      eventSourceToken: permission.eventSourceToken,\n      sourceAccount: permission.sourceAccount ?? sourceAccount,\n      sourceArn: permission.sourceArn ?? sourceArn,\n      principalOrgId: permission.organizationId ?? principalOrgID,\n      functionUrlAuthType: permission.functionUrlAuthType,\n    });\n  }\n\n  /**\n   * Adds a statement to the IAM role assumed by the instance.\n   */\n  public addToRolePolicy(statement: iam.PolicyStatement) {\n    if (!this.role) {\n      return;\n    }\n\n    this.role.addToPrincipalPolicy(statement);\n  }\n\n  public addEventSourceMapping(\n    id: string,\n    options: EventSourceMappingOptions,\n  ): EventSourceMapping {\n    return new EventSourceMapping(this, id, {\n      target: this,\n      ...options,\n    });\n  }\n\n  /**\n   * Grant the given identity permissions to invoke this Lambda\n   */\n  public grantInvoke(grantee: iam.IGrantable): iam.Grant {\n    const hash = crypto\n      .createHash(\"sha256\")\n      .update(\n        JSON.stringify({\n          principal: grantee.grantPrincipal.toString(),\n          conditions: grantee.grantPrincipal.policyFragment.conditions,\n        }),\n        \"utf8\",\n      )\n      .digest(\"base64\");\n    const identifier = `Invoke${hash}`;\n\n    // Memoize the result so subsequent grantInvoke() calls are idempotent\n    let grant = this._invocationGrants[identifier];\n    if (!grant) {\n      grant = this.grant(\n        grantee,\n        identifier,\n        \"lambda:InvokeFunction\",\n        this.resourceArnsForGrantInvoke,\n      );\n      this._invocationGrants[identifier] = grant;\n    }\n    return grant;\n  }\n\n  /**\n   * Grant the given identity permissions to invoke the $LATEST version or\n   * unqualified version of this Lambda\n   */\n  public grantInvokeLatestVersion(grantee: iam.IGrantable): iam.Grant {\n    return this.grantInvokeVersion(grantee, this.version);\n  }\n\n  /**\n   * Grant the given identity permissions to invoke the given version of this Lambda\n   */\n  public grantInvokeVersion(\n    grantee: iam.IGrantable,\n    version: string,\n  ): iam.Grant {\n    let grant: iam.Grant;\n    if (Token.isUnresolved(version)) {\n      // Identifier is set to \"InvokeLatest\"??\n      return this.grantInvoke(grantee);\n    }\n    // else, use version string in hash?\n    const hash = crypto\n      .createHash(\"sha256\")\n      .update(\n        JSON.stringify({\n          principal: grantee.grantPrincipal.toString(),\n          conditions: grantee.grantPrincipal.policyFragment.conditions,\n          version: version,\n        }),\n        \"utf8\",\n      )\n      .digest(\"base64\");\n    const identifier = `Invoke${hash}`;\n\n    // Memoize the result so subsequent grantInvoke() calls are idempotent\n    grant = this._invocationGrants[identifier];\n    if (!grant) {\n      let resouceArns = [`${this.functionArn}:${version}`];\n      if (version == this.version) {\n        resouceArns.push(this.functionArn);\n      }\n      grant = this.grant(\n        grantee,\n        identifier,\n        \"lambda:InvokeFunction\",\n        resouceArns,\n      );\n      this._invocationGrants[identifier] = grant;\n    }\n    return grant;\n  }\n\n  /**\n   * Grant the given identity permissions to invoke this Lambda Function URL\n   */\n  public grantInvokeUrl(grantee: iam.IGrantable): iam.Grant {\n    const identifier = `InvokeFunctionUrl${grantee.grantPrincipal}`; // calls the .toString() of the principal\n\n    // Memoize the result so subsequent grantInvoke() calls are idempotent\n    let grant = this._functionUrlInvocationGrants[identifier];\n    if (!grant) {\n      grant = this.grant(\n        grantee,\n        identifier,\n        \"lambda:InvokeFunctionUrl\",\n        [this.functionArn],\n        {\n          functionUrlAuthType: FunctionUrlAuthType.AWS_IAM,\n        },\n      );\n      this._functionUrlInvocationGrants[identifier] = grant;\n    }\n    return grant;\n  }\n\n  /**\n   * Grant multiple principals the ability to invoke this Lambda via CompositePrincipal\n   */\n  public grantInvokeCompositePrincipal(\n    compositePrincipal: iam.CompositePrincipal,\n  ): iam.Grant[] {\n    return compositePrincipal.principals.map((principal) =>\n      this.grantInvoke(principal),\n    );\n  }\n\n  public addEventSource(source: IEventSource) {\n    source.bind(this);\n  }\n\n  public configureAsyncInvoke(options: EventInvokeConfigOptions): void {\n    if (this.node.tryFindChild(\"EventInvokeConfig\") !== undefined) {\n      throw new Error(\n        `An EventInvokeConfig has already been configured for the function at ${this.node.path}`,\n      );\n    }\n\n    new EventInvokeConfig(this, \"EventInvokeConfig\", {\n      function: this,\n      ...options,\n    });\n  }\n\n  /**\n   * A function URL is a dedicated HTTP(S) endpoint for a Lambda function.\n   */\n  public addFunctionUrl(options?: FunctionUrlOptions): FunctionUrl {\n    if (this.node.tryFindChild(\"FunctionUrl\") !== undefined) {\n      throw new Error(\n        `A FunctionUrl has already been configured for the function at ${this.node.path}`,\n      );\n    }\n    return new FunctionUrl(this, \"FunctionUrl\", {\n      function: this,\n      ...options,\n    });\n  }\n\n  /**\n   * Returns the construct tree node that corresponds to the lambda function.\n   * For use internally for constructs, when the tree is set up in non-standard ways. Ex: SingletonFunction.\n   * @internal\n   */\n  protected _functionNode(): Node {\n    return this.node;\n  }\n\n  /**\n   * Given the function arn, check if the account id matches this account\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 `account-id` component from the ARN, we can\n   * split the ARN using \":\" and select the component in index 4.\n   *\n   * @returns true if account id of function matches the account specified on the stack, false otherwise.\n   *\n   * @internal\n   */\n  protected _isStackAccount(): boolean {\n    if (\n      Token.isUnresolved(this.stack.account) ||\n      Token.isUnresolved(this.functionArn)\n    ) {\n      return false;\n    }\n    return (\n      this.stack.splitArn(this.functionArn, ArnFormat.SLASH_RESOURCE_NAME)\n        .account === this.stack.account\n    );\n  }\n\n  private grant(\n    grantee: iam.IGrantable,\n    identifier: string,\n    action: string,\n    resourceArns: string[],\n    permissionOverrides?: Partial<Permission>,\n  ): iam.Grant {\n    const grant = iam.Grant.addToPrincipalOrResource({\n      grantee,\n      actions: [action],\n      resourceArns,\n\n      // Fake resource-like object on which to call addToResourcePolicy(), which actually\n      // calls addPermission()\n      resource: {\n        addToResourcePolicy: (_statement) => {\n          // Couldn't add permissions to the principal, so add them locally.\n          this.addPermission(identifier, {\n            principal: grantee.grantPrincipal!,\n            action: action,\n            ...permissionOverrides,\n          });\n\n          const permissionNode = this._functionNode().tryFindChild(identifier);\n          if (!permissionNode && !this._skipPermissions) {\n            throw new Error(\n              \"Cannot modify permission to lambda function. Function is either imported or $LATEST version.\\n\" +\n                \"If the function is imported from the same account use `fromFunctionAttributes()` API with the `sameEnvironment` flag.\\n\" +\n                \"If the function is imported from a different account and already has the correct permissions use `fromFunctionAttributes()` API with the `skipPermissions` flag.\",\n            );\n          }\n          return { statementAdded: true, policyDependable: permissionNode };\n        },\n        node: this.node,\n        stack: this.stack,\n        env: this.env,\n        environmentName: this.environmentName,\n        gridUUID: this.gridUUID,\n        outputs: {},\n      },\n    });\n\n    return grant;\n  }\n\n  /**\n   * Translate IPrincipal to something we can pass to aws_lambda_permission\n   * https://docs.aws.amazon.com/lambda/latest/api/API_AddPermission.html#lambda-AddPermission-request-Principal\n   * https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/lambda_permission#principal\n   *\n   * Do some nasty things because `Permission` supports a subset of what the\n   * full IAM principal language supports, and we may not be able to parse strings\n   * outright because they may be tokens.\n   *\n   * Try to recognize some specific Principal classes first, then try a generic\n   * fallback.\n   */\n  private parsePermissionPrincipal(\n    principal: iam.IPrincipal | { readonly wrapped: iam.IPrincipal },\n  ) {\n    // Try some specific common classes first.\n    // use duck-typing, not instance of\n    if (\"wrapped\" in principal) {\n      // eslint-disable-next-line dot-notation\n      principal = principal[\"wrapped\"];\n    }\n\n    if (\"accountId\" in principal) {\n      return (principal as iam.AccountPrincipal).accountId;\n    }\n\n    if (\"service\" in principal) {\n      return (principal as iam.ServicePrincipal).service;\n    }\n\n    if (\"arn\" in principal) {\n      return (principal as iam.ArnPrincipal).arn;\n    }\n\n    const stringEquals = matchSingleCondition(\n      \"StringEquals\",\n      principal.policyFragment.conditions,\n    );\n    if (\n      stringEquals &&\n      stringEquals.length === 1 &&\n      stringEquals[0].variable === \"aws:PrincipalOrgID\"\n    ) {\n      // we will move the organization id to the `principalOrgId` property of `Permissions`.\n      return \"*\";\n    }\n\n    // Try a best-effort approach to support simple principals that are not any of the predefined\n    // classes, but are simple enough that they will fit into the Lambda Permission model.\n    // Main target here: imported Roles, Users, Groups.\n    //\n    // The principal cannot have conditions and must have a single { AWS: [arn] } entry.\n    const principals = principal.policyFragment.principals.filter(\n      (p) => p.type === \"AWS\",\n    );\n    if (\n      principal.policyFragment.conditions.length === 0 &&\n      principals.length === 1\n    ) {\n      if (principals[0].identifiers.length === 1) {\n        return principals[0].identifiers[0];\n      }\n    }\n\n    throw new Error(\n      `Invalid principal type for Lambda permission statement: ${principal.constructor.name}. ` +\n        \"Supported: AccountPrincipal, ArnPrincipal, ServicePrincipal, OrganizationPrincipal\",\n    );\n\n    /**\n     * Returns the conditions for a certain test if it exists and if there are no other conditions. Otherwise,\n     * returns undefined.\n     */\n    function matchSingleCondition(\n      test: string,\n      obj: iam.Conditions,\n    ): iam.Conditions | undefined {\n      if (obj.length !== 1) {\n        return undefined;\n      }\n\n      return obj.filter((c) => c.test === test);\n    }\n  }\n\n  private validateConditionCombinations(principal: iam.IPrincipal):\n    | {\n        sourceArn: string | undefined;\n        sourceAccount: string | undefined;\n        principalOrgID: string | undefined;\n      }\n    | undefined {\n    const conditions = this.validateConditions(principal);\n\n    if (!conditions) {\n      return undefined;\n    }\n\n    // TODO: what if more than 1 identifier? Should any of these throw?\n    const sourcArnConditions = conditions.filter(\n      (c) => c.test === \"ArnLike\" && c.variable === \"aws:SourceArn\",\n    );\n    const sourceArn =\n      sourcArnConditions.length > 0\n        ? sourcArnConditions[0].values[0]\n        : undefined;\n    // requireString(\n    //   requireObject(conditions.ArnLike)?.[\"aws:SourceArn\"],\n    // );\n    const sourceAccountConditions = conditions.filter(\n      (c) => c.test === \"StringEquals\" && c.variable === \"aws:SourceAccount\",\n    );\n    const sourceAccount =\n      sourceAccountConditions.length > 0\n        ? sourceAccountConditions[0].values[0]\n        : undefined;\n    // requireString(\n    //   requireObject(conditions.StringEquals)?.[\"aws:SourceAccount\"],\n    // );\n    const principalOrgIDConditions = conditions.filter(\n      (c) => c.test === \"StringEquals\" && c.variable === \"aws:PrincipalOrgID\",\n    );\n    const principalOrgID =\n      principalOrgIDConditions.length > 0\n        ? principalOrgIDConditions[0].values[0]\n        : undefined;\n    // requireString(\n    //   requireObject(conditions.StringEquals)?.[\"aws:PrincipalOrgID\"],\n    // );\n\n    // PrincipalOrgID cannot be combined with any other conditions\n    if (principalOrgID && (sourceArn || sourceAccount)) {\n      throw new Error(\n        \"PrincipalWithConditions had unsupported condition combinations for Lambda permission statement: principalOrgID cannot be set with other conditions.\",\n      );\n    }\n\n    return {\n      sourceArn,\n      sourceAccount,\n      principalOrgID,\n    };\n  }\n\n  private validateConditions(\n    principal: iam.IPrincipal,\n  ): iam.Conditions | undefined {\n    if (this.isPrincipalWithConditions(principal)) {\n      const conditions = principal.policyFragment.conditions;\n      // These are all the supported conditions. Some combinations are not supported,\n      // like only 'aws:SourceArn' or 'aws:PrincipalOrgID' and 'aws:SourceAccount'.\n      // These will be validated through `this.validateConditionCombinations`.\n      const supportedPrincipalConditions = [\n        {\n          test: \"ArnLike\",\n          variable: \"aws:SourceArn\",\n        },\n        {\n          test: \"StringEquals\",\n          variable: \"aws:SourceAccount\",\n        },\n        {\n          test: \"StringEquals\",\n          variable: \"aws:PrincipalOrgID\",\n        },\n      ];\n\n      const unsupportedConditions = conditions.filter(\n        (condition) =>\n          !supportedPrincipalConditions.some(\n            (supportedCondition) =>\n              supportedCondition.test === condition.test &&\n              supportedCondition.variable === condition.variable,\n          ),\n      );\n\n      if (unsupportedConditions.length == 0) {\n        return conditions;\n      } else {\n        throw new Error(\n          `PrincipalWithConditions had unsupported conditions for Lambda permission statement: ${JSON.stringify(unsupportedConditions)}. ` +\n            `Supported operator/condition pairs: ${JSON.stringify(supportedPrincipalConditions)}`,\n        );\n      }\n    }\n\n    return undefined;\n  }\n\n  private isPrincipalWithConditions(principal: iam.IPrincipal): boolean {\n    return principal.policyFragment.conditions.length > 0;\n  }\n}\n\nexport abstract class QualifiedFunctionBase extends LambdaFunctionBase {\n  /** The underlying `IFunction` */\n  public abstract readonly lambda: IFunction; // TODO: Verify publish is set to true?\n\n  public readonly permissionsNode = this.node;\n\n  public get resourceArnsForGrantInvoke() {\n    return [this.functionArn];\n  }\n\n  public configureAsyncInvoke(options: EventInvokeConfigOptions): void {\n    if (this.node.tryFindChild(\"EventInvokeConfig\") !== undefined) {\n      throw new Error(\n        `An EventInvokeConfig has already been configured for the qualified function at ${this.node.path}`,\n      );\n    }\n\n    new EventInvokeConfig(this, \"EventInvokeConfig\", {\n      function: this.lambda,\n      qualifier: this.version,\n      ...options,\n    });\n  }\n}\n\n/**\n * An abstract class which represents an AWS Lambda event source.\n */\nexport interface IEventSource {\n  /**\n   * Called by `lambda.addEventSource` to allow the event source to bind to this\n   * function.\n   *\n   * @param target That lambda function to bind to.\n   */\n  bind(target: IFunction): void;\n}\n"]}

package/lib/aws/compute/function-destination.d.ts

@@ -0,0 +1,42 @@
+import { Construct } from "constructs";
+import { IFunction } from "./function-base";
+/**
+ * A destination configuration
+ */
+export interface DestinationConfig {
+    /**
+     * The Amazon Resource Name (ARN) of the destination resource
+     */
+    readonly destination: string;
+}
+/**
+ * The type of destination
+ */
+export declare enum DestinationType {
+    /**
+     * Failure
+     */
+    FAILURE = "Failure",
+    /**
+     * Success
+     */
+    SUCCESS = "Success"
+}
+/**
+ * Options when binding a destination to a function
+ */
+export interface DestinationOptions {
+    /**
+     * The destination type
+     */
+    readonly type: DestinationType;
+}
+/**
+ * A Lambda destination
+ */
+export interface IDestination {
+    /**
+     * Binds this destination to the Lambda function
+     */
+    bind(scope: Construct, fn: IFunction, options?: DestinationOptions): DestinationConfig;
+}

package/lib/aws/compute/function-destination.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DestinationType = void 0;
+/**
+ * The type of destination
+ */
+var DestinationType;
+(function (DestinationType) {
+    /**
+     * Failure
+     */
+    DestinationType["FAILURE"] = "Failure";
+    /**
+     * Success
+     */
+    DestinationType["SUCCESS"] = "Success";
+})(DestinationType || (exports.DestinationType = DestinationType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnVuY3Rpb24tZGVzdGluYXRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXdzL2NvbXB1dGUvZnVuY3Rpb24tZGVzdGluYXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBYUE7O0dBRUc7QUFDSCxJQUFZLGVBVVg7QUFWRCxXQUFZLGVBQWU7SUFDekI7O09BRUc7SUFDSCxzQ0FBbUIsQ0FBQTtJQUVuQjs7T0FFRztJQUNILHNDQUFtQixDQUFBO0FBQ3JCLENBQUMsRUFWVyxlQUFlLCtCQUFmLGVBQWUsUUFVMUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb25zdHJ1Y3QgfSBmcm9tIFwiY29uc3RydWN0c1wiO1xuaW1wb3J0IHsgSUZ1bmN0aW9uIH0gZnJvbSBcIi4vZnVuY3Rpb24tYmFzZVwiO1xuXG4vKipcbiAqIEEgZGVzdGluYXRpb24gY29uZmlndXJhdGlvblxuICovXG5leHBvcnQgaW50ZXJmYWNlIERlc3RpbmF0aW9uQ29uZmlnIHtcbiAgLyoqXG4gICAqIFRoZSBBbWF6b24gUmVzb3VyY2UgTmFtZSAoQVJOKSBvZiB0aGUgZGVzdGluYXRpb24gcmVzb3VyY2VcbiAgICovXG4gIHJlYWRvbmx5IGRlc3RpbmF0aW9uOiBzdHJpbmc7XG59XG5cbi8qKlxuICogVGhlIHR5cGUgb2YgZGVzdGluYXRpb25cbiAqL1xuZXhwb3J0IGVudW0gRGVzdGluYXRpb25UeXBlIHtcbiAgLyoqXG4gICAqIEZhaWx1cmVcbiAgICovXG4gIEZBSUxVUkUgPSBcIkZhaWx1cmVcIixcblxuICAvKipcbiAgICogU3VjY2Vzc1xuICAgKi9cbiAgU1VDQ0VTUyA9IFwiU3VjY2Vzc1wiLFxufVxuXG4vKipcbiAqIE9wdGlvbnMgd2hlbiBiaW5kaW5nIGEgZGVzdGluYXRpb24gdG8gYSBmdW5jdGlvblxuICovXG5leHBvcnQgaW50ZXJmYWNlIERlc3RpbmF0aW9uT3B0aW9ucyB7XG4gIC8qKlxuICAgKiBUaGUgZGVzdGluYXRpb24gdHlwZVxuICAgKi9cbiAgcmVhZG9ubHkgdHlwZTogRGVzdGluYXRpb25UeXBlO1xufVxuXG4vKipcbiAqIEEgTGFtYmRhIGRlc3RpbmF0aW9uXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgSURlc3RpbmF0aW9uIHtcbiAgLyoqXG4gICAqIEJpbmRzIHRoaXMgZGVzdGluYXRpb24gdG8gdGhlIExhbWJkYSBmdW5jdGlvblxuICAgKi9cbiAgYmluZChcbiAgICBzY29wZTogQ29uc3RydWN0LFxuICAgIGZuOiBJRnVuY3Rpb24sXG4gICAgb3B0aW9ucz86IERlc3RpbmF0aW9uT3B0aW9ucyxcbiAgKTogRGVzdGluYXRpb25Db25maWc7XG59XG4iXX0=

package/lib/aws/compute/function-destinations/event-bridge.d.ts

@@ -0,0 +1,19 @@
+import { Construct } from "constructs";
+import * as compute from "../";
+import * as notify from "../../notify";
+/**
+ * Use an Event Bridge event bus as a Lambda destination.
+ *
+ * If no event bus is specified, the default event bus is used.
+ */
+export declare class EventBridgeDestination implements compute.IDestination {
+    private readonly eventBus?;
+    /**
+     * @default - use the default event bus
+     */
+    constructor(eventBus?: notify.IEventBus | undefined);
+    /**
+     * Returns a destination configuration
+     */
+    bind(_scope: Construct, fn: compute.IFunction, _options?: compute.DestinationOptions): compute.DestinationConfig;
+}