terraconstructs 0.0.8

package/lib/aws/compute/event-source-mapping.js

@@ -0,0 +1,267 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StartingPosition = exports.SourceAccessConfigurationType = exports.EventSourceMapping = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf = require("cdktf");
+const __1 = require("..");
+const token_1 = require("../../token");
+/**
+ * Defines a Lambda EventSourceMapping resource.
+ *
+ * Usually, you won't need to define the mapping yourself. This will usually be done by
+ * event sources. For example, to add an SQS event source to a function:
+ *
+ * ```ts
+ * import { notify, compute } from 'terraconstructs';
+ *
+ * declare const handler: compute.Function;
+ * declare const queue: notify.Queue;
+ *
+ * handler.addEventSource(new compute.eventsources.SqsEventSource(queue));
+ * ```
+ *
+ * The `SqsEventSource` class will automatically create the mapping, and will also
+ * modify the Lambda's execution role so it can consume messages from the queue.
+ */
+class EventSourceMapping extends __1.AwsConstructBase {
+    /**
+     * Import an event source into this stack from its event source id.
+     */
+    static fromEventSourceMappingId(scope, id, eventSourceMappingId) {
+        const eventSourceMappingArn = EventSourceMapping.formatArn(scope, eventSourceMappingId);
+        class Import extends __1.AwsConstructBase {
+            constructor() {
+                super(...arguments);
+                this.eventSourceMappingId = eventSourceMappingId;
+                this.eventSourceMappingArn = eventSourceMappingArn;
+                this.eventSourceMappingOutputs = {
+                    uuid: eventSourceMappingId,
+                };
+            }
+            get outputs() {
+                return this.eventSourceMappingOutputs;
+            }
+        }
+        return new Import(scope, id);
+    }
+    static formatArn(scope, eventSourceMappingId) {
+        return __1.AwsStack.ofAwsConstruct(scope).formatArn({
+            service: "lambda",
+            resource: "event-source-mapping",
+            resourceName: eventSourceMappingId,
+            arnFormat: __1.ArnFormat.COLON_RESOURCE_NAME,
+        });
+    }
+    get outputs() {
+        return this.eventSourceMappingOutputs;
+    }
+    constructor(scope, id, props) {
+        super(scope, id);
+        if (props.eventSourceArn == undefined &&
+            props.kafkaBootstrapServers == undefined) {
+            throw new Error("Either eventSourceArn or kafkaBootstrapServers must be set");
+        }
+        if (props.eventSourceArn !== undefined &&
+            props.kafkaBootstrapServers !== undefined) {
+            throw new Error("eventSourceArn and kafkaBootstrapServers are mutually exclusive");
+        }
+        if (props.kafkaBootstrapServers &&
+            props.kafkaBootstrapServers?.length < 1) {
+            throw new Error("kafkaBootStrapServers must not be empty if set");
+        }
+        if (props.maxBatchingWindow && props.maxBatchingWindow.toSeconds() > 300) {
+            throw new Error(`maxBatchingWindow cannot be over 300 seconds, got ${props.maxBatchingWindow.toSeconds()}`);
+        }
+        if (props.maxConcurrency &&
+            !cdktf.Token.isUnresolved(props.maxConcurrency) &&
+            (props.maxConcurrency < 2 || props.maxConcurrency > 1000)) {
+            throw new Error("maxConcurrency must be between 2 and 1000 concurrent instances");
+        }
+        if (props.maxRecordAge &&
+            (props.maxRecordAge.toSeconds() < 60 ||
+                props.maxRecordAge.toDays({ integral: false }) > 7)) {
+            throw new Error("maxRecordAge must be between 60 seconds and 7 days inclusive");
+        }
+        props.retryAttempts !== undefined &&
+            (0, token_1.withResolved)(props.retryAttempts, (attempts) => {
+                if (attempts < 0 || attempts > 10000) {
+                    throw new Error(`retryAttempts must be between 0 and 10000 inclusive, got ${attempts}`);
+                }
+            });
+        props.parallelizationFactor !== undefined &&
+            (0, token_1.withResolved)(props.parallelizationFactor, (factor) => {
+                if (factor < 1 || factor > 10) {
+                    throw new Error(`parallelizationFactor must be between 1 and 10 inclusive, got ${factor}`);
+                }
+            });
+        if (props.tumblingWindow &&
+            !cdktf.Token.isUnresolved(props.tumblingWindow) &&
+            props.tumblingWindow.toSeconds() > 900) {
+            throw new Error(`tumblingWindow cannot be over 900 seconds, got ${props.tumblingWindow.toSeconds()}`);
+        }
+        if (props.startingPosition === StartingPosition.AT_TIMESTAMP &&
+            !props.startingPositionTimestamp) {
+            throw new Error("startingPositionTimestamp must be provided when startingPosition is AT_TIMESTAMP");
+        }
+        if (props.startingPosition !== StartingPosition.AT_TIMESTAMP &&
+            props.startingPositionTimestamp) {
+            throw new Error("startingPositionTimestamp can only be used when startingPosition is AT_TIMESTAMP");
+        }
+        if (props.kafkaConsumerGroupId) {
+            this.validateKafkaConsumerGroupIdOrThrow(props.kafkaConsumerGroupId);
+        }
+        // TODO: re-add KMS support
+        // if (props.filterEncryption !== undefined && props.filters == undefined) {
+        //   throw new Error(
+        //     "filter criteria must be provided to enable setting filter criteria encryption",
+        //   );
+        // }
+        //
+        // /**
+        //  * Grants the Lambda function permission to decrypt data using the specified KMS key.
+        //  * This step is necessary for setting up encrypted filter criteria.
+        //  *
+        //  * If the KMS key was created within this CloudFormation stack (via `new Key`), a Key policy
+        //  * will be attached to the key to allow the Lambda function to access it. However, if the
+        //  * Key is imported from an existing ARN (`Key.fromKeyArn`), no action will be taken.
+        //  */
+        // if (props.filterEncryption !== undefined) {
+        //   const lambdaPrincipal = new iam.ServicePrincipal("lambda.amazonaws.com");
+        //   props.filterEncryption.grantDecrypt(lambdaPrincipal);
+        // }
+        let destinationConfig;
+        if (props.onFailure) {
+            destinationConfig = {
+                onFailure: props.onFailure.bind(this, props.target),
+            };
+        }
+        let selfManagedEventSource;
+        if (props.kafkaBootstrapServers) {
+            selfManagedEventSource = {
+                endpoints: {
+                    KAFKA_BOOTSTRAP_SERVERS: props.kafkaBootstrapServers.join(","),
+                },
+            };
+        }
+        let consumerGroupConfig = props.kafkaConsumerGroupId
+            ? { consumerGroupId: props.kafkaConsumerGroupId }
+            : undefined;
+        const resource = new provider_aws_1.lambdaEventSourceMapping.LambdaEventSourceMapping(this, "Resource", {
+            batchSize: props.batchSize,
+            bisectBatchOnFunctionError: props.bisectBatchOnError,
+            destinationConfig,
+            enabled: props.enabled,
+            eventSourceArn: props.eventSourceArn,
+            functionName: props.target.functionName,
+            startingPosition: props.startingPosition,
+            startingPositionTimestamp: props.startingPositionTimestamp
+                ? new Date(props.startingPositionTimestamp * 1000).toISOString()
+                : undefined,
+            functionResponseTypes: props.reportBatchItemFailures
+                ? ["ReportBatchItemFailures"]
+                : undefined,
+            maximumBatchingWindowInSeconds: props.maxBatchingWindow?.toSeconds(),
+            maximumRecordAgeInSeconds: props.maxRecordAge?.toSeconds(),
+            maximumRetryAttempts: props.retryAttempts,
+            parallelizationFactor: props.parallelizationFactor,
+            topics: props.kafkaTopic !== undefined ? [props.kafkaTopic] : undefined,
+            tumblingWindowInSeconds: props.tumblingWindow?.toSeconds(),
+            scalingConfig: props.maxConcurrency
+                ? { maximumConcurrency: props.maxConcurrency }
+                : undefined,
+            sourceAccessConfiguration: props.sourceAccessConfigurations,
+            selfManagedEventSource,
+            filterCriteria: props.filters ? { filter: props.filters } : undefined,
+            // kmsKeyArn: props.filterEncryption?.keyArn, // TODO: re-add KMS support
+            selfManagedKafkaEventSourceConfig: props.kafkaBootstrapServers
+                ? consumerGroupConfig
+                : undefined,
+            amazonManagedKafkaEventSourceConfig: props.eventSourceArn
+                ? consumerGroupConfig
+                : undefined,
+        });
+        this.eventSourceMappingId = resource.uuid;
+        this.eventSourceMappingArn = EventSourceMapping.formatArn(this, this.eventSourceMappingId);
+        this.eventSourceMappingOutputs = {
+            uuid: this.eventSourceMappingId,
+        };
+    }
+    validateKafkaConsumerGroupIdOrThrow(kafkaConsumerGroupId) {
+        if (cdktf.Token.isUnresolved(kafkaConsumerGroupId)) {
+            return;
+        }
+        if (kafkaConsumerGroupId.length > 200 || kafkaConsumerGroupId.length < 1) {
+            throw new Error("kafkaConsumerGroupId must be a valid string between 1 and 200 characters");
+        }
+        const regex = new RegExp(/[a-zA-Z0-9-\/*:_+=.@-]*/);
+        const patternMatch = regex.exec(kafkaConsumerGroupId);
+        if (patternMatch === null || patternMatch[0] !== kafkaConsumerGroupId) {
+            throw new Error('kafkaConsumerGroupId contains invalid characters. Allowed values are "[a-zA-Z0-9-/*:_+=.@-]"');
+        }
+    }
+}
+exports.EventSourceMapping = EventSourceMapping;
+_a = JSII_RTTI_SYMBOL_1;
+EventSourceMapping[_a] = { fqn: "terraconstructs.aws.compute.EventSourceMapping", version: "0.0.8" };
+/**
+ * The type of authentication protocol or the VPC components for your event source's SourceAccessConfiguration
+ * @see https://docs.aws.amazon.com/lambda/latest/dg/API_SourceAccessConfiguration.html#SSS-Type-SourceAccessConfiguration-Type
+ */
+var SourceAccessConfigurationType;
+(function (SourceAccessConfigurationType) {
+    /**
+     * (MQ) The Secrets Manager secret that stores your broker credentials.
+     */
+    SourceAccessConfigurationType["BASIC_AUTH"] = "BASIC_AUTH";
+    /**
+     * The subnets associated with your VPC. Lambda connects to these subnets to fetch data from your Self-Managed Apache Kafka cluster.
+     */
+    SourceAccessConfigurationType["VPC_SUBNET"] = "VPC_SUBNET";
+    /**
+     * The VPC security group used to manage access to your Self-Managed Apache Kafka brokers.
+     */
+    SourceAccessConfigurationType["VPC_SECURITY_GROUP"] = "VPC_SECURITY_GROUP";
+    /**
+     * The Secrets Manager ARN of your secret key used for SASL SCRAM-256 authentication of your Self-Managed Apache Kafka brokers.
+     */
+    SourceAccessConfigurationType["SASL_SCRAM_256_AUTH"] = "SASL_SCRAM_256_AUTH";
+    /**
+     * The Secrets Manager ARN of your secret key used for SASL SCRAM-512 authentication of your Self-Managed Apache Kafka brokers.
+     */
+    SourceAccessConfigurationType["SASL_SCRAM_512_AUTH"] = "SASL_SCRAM_512_AUTH";
+    /**
+     * The Secrets Manager ARN of your secret key containing the certificate chain (X.509 PEM), private key (PKCS#8 PEM),
+     * and private key password (optional) used for mutual TLS authentication of your MSK/Apache Kafka brokers.
+     */
+    SourceAccessConfigurationType["CLIENT_CERTIFICATE_TLS_AUTH"] = "CLIENT_CERTIFICATE_TLS_AUTH";
+    /**
+     * The Secrets Manager ARN of your secret key containing the root CA certificate (X.509 PEM) used for TLS encryption of your Apache Kafka brokers.
+     */
+    SourceAccessConfigurationType["SERVER_ROOT_CA_CERTIFICATE"] = "SERVER_ROOT_CA_CERTIFICATE";
+})(SourceAccessConfigurationType || (exports.SourceAccessConfigurationType = SourceAccessConfigurationType = {}));
+/**
+ * The position in the DynamoDB, Kinesis or MSK stream where AWS Lambda should start
+ * reading.
+ */
+var StartingPosition;
+(function (StartingPosition) {
+    /**
+     * Start reading at the last untrimmed record in the shard in the system,
+     * which is the oldest data record in the shard.
+     */
+    StartingPosition["TRIM_HORIZON"] = "TRIM_HORIZON";
+    /**
+     * Start reading just after the most recent record in the shard, so that you
+     * always read the most recent data in the shard
+     */
+    StartingPosition["LATEST"] = "LATEST";
+    /**
+     * Start reading from a position defined by a time stamp.
+     * Only supported for Amazon Kinesis streams, otherwise an error will occur.
+     * If supplied, `startingPositionTimestamp` must also be set.
+     */
+    StartingPosition["AT_TIMESTAMP"] = "AT_TIMESTAMP";
+})(StartingPosition || (exports.StartingPosition = StartingPosition = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event-source-mapping.js","sourceRoot":"","sources":["../../../src/aws/compute/event-source-mapping.ts"],"names":[],"mappings":"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","sourcesContent":["import { lambdaEventSourceMapping } from \"@cdktf/provider-aws\";\nimport * as cdktf from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport {\n  AwsStack,\n  IAwsConstruct,\n  AwsConstructBase,\n  AwsConstructProps,\n  ArnFormat,\n} from \"..\";\nimport { IEventSourceDlq } from \"./function\";\nimport { IFunction } from \"./function-base\";\nimport { Duration } from \"../..\";\nimport { withResolved } from \"../../token\";\n// TODO: re-add support for KMS\n// import * as iam from \"../iam\"; // required to grant KMS permissions\n// import { IKey } from \"../encryption\";\n\nexport interface EventSourceMappingOptions extends AwsConstructProps {\n  /**\n   * The Amazon Resource Name (ARN) of the event source. Any record added to\n   * this stream can invoke the Lambda function.\n   *\n   * @default - not set if using a self managed Kafka cluster, throws an error otherwise\n   */\n  readonly eventSourceArn?: string;\n\n  /**\n   * The largest number of records that AWS Lambda will retrieve from your event\n   * source at the time of invoking your function. Your function receives an\n   * event with all the retrieved records.\n   *\n   * Valid Range: Minimum value of 1. Maximum value of 10000.\n   *\n   * @default - Amazon Kinesis, Amazon DynamoDB, and Amazon MSK is 100 records.\n   * The default for Amazon SQS is 10 messages. For standard SQS queues, the maximum is 10,000. For FIFO SQS queues, the maximum is 10.\n   */\n  readonly batchSize?: number;\n\n  /**\n   * If the function returns an error, split the batch in two and retry.\n   *\n   * @default false\n   */\n  readonly bisectBatchOnError?: boolean;\n\n  /**\n   * An Amazon SQS queue or Amazon SNS topic destination for discarded records.\n   *\n   * @default discarded records are ignored\n   */\n  readonly onFailure?: IEventSourceDlq;\n\n  /**\n   * Set to false to disable the event source upon creation.\n   *\n   * @default true\n   */\n  readonly enabled?: boolean;\n\n  /**\n   * The position in the DynamoDB, Kinesis or MSK stream where AWS Lambda should\n   * start reading.\n   *\n   * @see https://docs.aws.amazon.com/kinesis/latest/APIReference/API_GetShardIterator.html#Kinesis-GetShardIterator-request-ShardIteratorType\n   *\n   * @default - no starting position\n   */\n  readonly startingPosition?: StartingPosition;\n\n  /**\n   * The time from which to start reading, in Unix time seconds.\n   *\n   * @default - no timestamp\n   */\n  readonly startingPositionTimestamp?: number;\n\n  /**\n   * Allow functions to return partially successful responses for a batch of records.\n   *\n   * @see https://docs.aws.amazon.com/lambda/latest/dg/with-ddb.html#services-ddb-batchfailurereporting\n   *\n   * @default false\n   */\n  readonly reportBatchItemFailures?: boolean;\n\n  /**\n   * The maximum amount of time to gather records before invoking the function.\n   * Maximum of Duration.minutes(5)\n   *\n   * @default Duration.seconds(0)\n   */\n  readonly maxBatchingWindow?: Duration;\n\n  /**\n   * The maximum concurrency setting limits the number of concurrent instances of the function that an Amazon SQS event source can invoke.\n   *\n   * @see https://docs.aws.amazon.com/lambda/latest/dg/with-sqs.html#events-sqs-max-concurrency\n   *\n   * Valid Range: Minimum value of 2. Maximum value of 1000.\n   *\n   * @default - No specific limit.\n   */\n  readonly maxConcurrency?: number;\n\n  /**\n   * The maximum age of a record that Lambda sends to a function for processing.\n   * Valid Range:\n   * * Minimum value of 60 seconds\n   * * Maximum value of 7 days\n   *\n   * @default - infinite or until the record expires.\n   */\n  readonly maxRecordAge?: Duration;\n\n  /**\n   * The maximum number of times to retry when the function returns an error.\n   * Set to `undefined` if you want lambda to keep retrying infinitely or until\n   * the record expires.\n   *\n   * Valid Range:\n   * * Minimum value of 0\n   * * Maximum value of 10000\n   *\n   * @default - infinite or until the record expires.\n   */\n  readonly retryAttempts?: number;\n\n  /**\n   * The number of batches to process from each shard concurrently.\n   * Valid Range:\n   * * Minimum value of 1\n   * * Maximum value of 10\n   *\n   * @default 1\n   */\n  readonly parallelizationFactor?: number;\n\n  /**\n   * The name of the Kafka topic.\n   *\n   * @default - no topic\n   */\n  readonly kafkaTopic?: string;\n\n  /**\n   * The size of the tumbling windows to group records sent to DynamoDB or Kinesis\n   *\n   * @see https://docs.aws.amazon.com/lambda/latest/dg/with-ddb.html#services-ddb-windows\n   *\n   * Valid Range: 0 - 15 minutes\n   *\n   * @default - None\n   */\n  readonly tumblingWindow?: Duration;\n\n  /**\n   * A list of host and port pairs that are the addresses of the Kafka brokers in a self managed \"bootstrap\" Kafka cluster\n   * that a Kafka client connects to initially to bootstrap itself.\n   * They are in the format `abc.example.com:9096`.\n   *\n   * @default - none\n   */\n  readonly kafkaBootstrapServers?: string[];\n\n  /**\n   * The identifier for the Kafka consumer group to join. The consumer group ID must be unique among all your Kafka event sources. After creating a Kafka event source mapping with the consumer group ID specified, you cannot update this value. The value must have a lenght between 1 and 200 and full the pattern '[a-zA-Z0-9-\\/*:_+=.@-]*'. For more information, see [Customizable consumer group ID](https://docs.aws.amazon.com/lambda/latest/dg/with-msk.html#services-msk-consumer-group-id).\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lambda-eventsourcemapping-amazonmanagedkafkaeventsourceconfig.html\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lambda-eventsourcemapping-selfmanagedkafkaeventsourceconfig.html\n   *\n   * @default - none\n   */\n  readonly kafkaConsumerGroupId?: string;\n\n  /**\n   * Specific settings like the authentication protocol or the VPC components to secure access to your event source.\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lambda-eventsourcemapping-sourceaccessconfiguration.html\n   *\n   * @default - none\n   */\n  readonly sourceAccessConfigurations?: SourceAccessConfiguration[];\n\n  /**\n   * Add filter criteria to Event Source.\n   *\n   * A set of up to 5 filter. If an event satisfies at least one, Lambda sends the event to the function or adds it to the next batch.\n   * @see https://docs.aws.amazon.com/lambda/latest/dg/invocation-eventfiltering.html\n   *\n   * @default - none\n   */\n  readonly filters?: Array<{ [key: string]: any }>;\n\n  // TODO: re-add KMS support\n  // /**\n  //  * Add Customer managed KMS key to encrypt Filter Criteria.\n  //  * @see https://docs.aws.amazon.com/lambda/latest/dg/invocation-eventfiltering.html\n  //  * By default, Lambda will encrypt Filter Criteria using AWS managed keys\n  //  * @see https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-managed-cmk\n  //  *\n  //  * @default - none\n  //  */\n  // readonly filterEncryption?: IKey;\n\n  /**\n   * Check if support S3 onfailure destination(ODF). Currently only MSK and self managed kafka event support S3 ODF\n   *\n   * @default false\n   */\n  readonly supportS3OnFailureDestination?: boolean;\n}\n\n/**\n * Properties for declaring a new event source mapping.\n */\nexport interface EventSourceMappingProps extends EventSourceMappingOptions {\n  /**\n   * The target AWS Lambda function.\n   */\n  readonly target: IFunction;\n}\n\n/**\n * Outputs to expose via the grid.\n */\nexport interface EventSourceMappingOutputs {\n  /**\n   * The identifier for the EventSourceMapping.\n   */\n  readonly uuid: string;\n}\n\n/**\n * Represents an event source mapping for a lambda function.\n * @see https://docs.aws.amazon.com/lambda/latest/dg/invocation-eventsourcemapping.html\n */\nexport interface IEventSourceMapping extends IAwsConstruct {\n  /**\n   * strongly typed outputs\n   */\n  readonly eventSourceMappingOutputs: EventSourceMappingOutputs;\n\n  /**\n   * The identifier for this EventSourceMapping\n   * @attribute\n   */\n  readonly eventSourceMappingId: string;\n\n  /**\n   * The ARN of the event source mapping (i.e. arn:aws:lambda:region:account-id:event-source-mapping/event-source-mapping-id)\n   */\n  readonly eventSourceMappingArn: string;\n}\n\n/**\n * Defines a Lambda EventSourceMapping resource.\n *\n * Usually, you won't need to define the mapping yourself. This will usually be done by\n * event sources. For example, to add an SQS event source to a function:\n *\n * ```ts\n * import { notify, compute } from 'terraconstructs';\n *\n * declare const handler: compute.Function;\n * declare const queue: notify.Queue;\n *\n * handler.addEventSource(new compute.eventsources.SqsEventSource(queue));\n * ```\n *\n * The `SqsEventSource` class will automatically create the mapping, and will also\n * modify the Lambda's execution role so it can consume messages from the queue.\n */\nexport class EventSourceMapping\n  extends AwsConstructBase\n  implements IEventSourceMapping\n{\n  /**\n   * Import an event source into this stack from its event source id.\n   */\n  public static fromEventSourceMappingId(\n    scope: Construct,\n    id: string,\n    eventSourceMappingId: string,\n  ): IEventSourceMapping {\n    const eventSourceMappingArn = EventSourceMapping.formatArn(\n      scope,\n      eventSourceMappingId,\n    );\n\n    class Import extends AwsConstructBase implements IEventSourceMapping {\n      public readonly eventSourceMappingId = eventSourceMappingId;\n      public readonly eventSourceMappingArn = eventSourceMappingArn;\n      public readonly eventSourceMappingOutputs = {\n        uuid: eventSourceMappingId,\n      };\n      public get outputs() {\n        return this.eventSourceMappingOutputs;\n      }\n    }\n    return new Import(scope, id);\n  }\n\n  private static formatArn(\n    scope: Construct,\n    eventSourceMappingId: string,\n  ): string {\n    return AwsStack.ofAwsConstruct(scope).formatArn({\n      service: \"lambda\",\n      resource: \"event-source-mapping\",\n      resourceName: eventSourceMappingId,\n      arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n    });\n  }\n\n  public readonly eventSourceMappingId: string;\n  public readonly eventSourceMappingArn: string;\n  public readonly eventSourceMappingOutputs: EventSourceMappingOutputs;\n  public get outputs(): Record<string, any> {\n    return this.eventSourceMappingOutputs;\n  }\n\n  constructor(scope: Construct, id: string, props: EventSourceMappingProps) {\n    super(scope, id);\n\n    if (\n      props.eventSourceArn == undefined &&\n      props.kafkaBootstrapServers == undefined\n    ) {\n      throw new Error(\n        \"Either eventSourceArn or kafkaBootstrapServers must be set\",\n      );\n    }\n\n    if (\n      props.eventSourceArn !== undefined &&\n      props.kafkaBootstrapServers !== undefined\n    ) {\n      throw new Error(\n        \"eventSourceArn and kafkaBootstrapServers are mutually exclusive\",\n      );\n    }\n\n    if (\n      props.kafkaBootstrapServers &&\n      props.kafkaBootstrapServers?.length < 1\n    ) {\n      throw new Error(\"kafkaBootStrapServers must not be empty if set\");\n    }\n\n    if (props.maxBatchingWindow && props.maxBatchingWindow.toSeconds() > 300) {\n      throw new Error(\n        `maxBatchingWindow cannot be over 300 seconds, got ${props.maxBatchingWindow.toSeconds()}`,\n      );\n    }\n\n    if (\n      props.maxConcurrency &&\n      !cdktf.Token.isUnresolved(props.maxConcurrency) &&\n      (props.maxConcurrency < 2 || props.maxConcurrency > 1000)\n    ) {\n      throw new Error(\n        \"maxConcurrency must be between 2 and 1000 concurrent instances\",\n      );\n    }\n\n    if (\n      props.maxRecordAge &&\n      (props.maxRecordAge.toSeconds() < 60 ||\n        props.maxRecordAge.toDays({ integral: false }) > 7)\n    ) {\n      throw new Error(\n        \"maxRecordAge must be between 60 seconds and 7 days inclusive\",\n      );\n    }\n\n    props.retryAttempts !== undefined &&\n      withResolved(props.retryAttempts, (attempts) => {\n        if (attempts < 0 || attempts > 10000) {\n          throw new Error(\n            `retryAttempts must be between 0 and 10000 inclusive, got ${attempts}`,\n          );\n        }\n      });\n\n    props.parallelizationFactor !== undefined &&\n      withResolved(props.parallelizationFactor, (factor) => {\n        if (factor < 1 || factor > 10) {\n          throw new Error(\n            `parallelizationFactor must be between 1 and 10 inclusive, got ${factor}`,\n          );\n        }\n      });\n\n    if (\n      props.tumblingWindow &&\n      !cdktf.Token.isUnresolved(props.tumblingWindow) &&\n      props.tumblingWindow.toSeconds() > 900\n    ) {\n      throw new Error(\n        `tumblingWindow cannot be over 900 seconds, got ${props.tumblingWindow.toSeconds()}`,\n      );\n    }\n\n    if (\n      props.startingPosition === StartingPosition.AT_TIMESTAMP &&\n      !props.startingPositionTimestamp\n    ) {\n      throw new Error(\n        \"startingPositionTimestamp must be provided when startingPosition is AT_TIMESTAMP\",\n      );\n    }\n\n    if (\n      props.startingPosition !== StartingPosition.AT_TIMESTAMP &&\n      props.startingPositionTimestamp\n    ) {\n      throw new Error(\n        \"startingPositionTimestamp can only be used when startingPosition is AT_TIMESTAMP\",\n      );\n    }\n\n    if (props.kafkaConsumerGroupId) {\n      this.validateKafkaConsumerGroupIdOrThrow(props.kafkaConsumerGroupId);\n    }\n\n    // TODO: re-add KMS support\n    // if (props.filterEncryption !== undefined && props.filters == undefined) {\n    //   throw new Error(\n    //     \"filter criteria must be provided to enable setting filter criteria encryption\",\n    //   );\n    // }\n    //\n    // /**\n    //  * Grants the Lambda function permission to decrypt data using the specified KMS key.\n    //  * This step is necessary for setting up encrypted filter criteria.\n    //  *\n    //  * If the KMS key was created within this CloudFormation stack (via `new Key`), a Key policy\n    //  * will be attached to the key to allow the Lambda function to access it. However, if the\n    //  * Key is imported from an existing ARN (`Key.fromKeyArn`), no action will be taken.\n    //  */\n    // if (props.filterEncryption !== undefined) {\n    //   const lambdaPrincipal = new iam.ServicePrincipal(\"lambda.amazonaws.com\");\n    //   props.filterEncryption.grantDecrypt(lambdaPrincipal);\n    // }\n\n    let destinationConfig: any;\n\n    if (props.onFailure) {\n      destinationConfig = {\n        onFailure: props.onFailure.bind(this, props.target),\n      };\n    }\n\n    let selfManagedEventSource:\n      | lambdaEventSourceMapping.LambdaEventSourceMappingSelfManagedEventSource\n      | undefined;\n    if (props.kafkaBootstrapServers) {\n      selfManagedEventSource = {\n        endpoints: {\n          KAFKA_BOOTSTRAP_SERVERS: props.kafkaBootstrapServers.join(\",\"),\n        },\n      };\n    }\n\n    let consumerGroupConfig = props.kafkaConsumerGroupId\n      ? { consumerGroupId: props.kafkaConsumerGroupId }\n      : undefined;\n\n    const resource = new lambdaEventSourceMapping.LambdaEventSourceMapping(\n      this,\n      \"Resource\",\n      {\n        batchSize: props.batchSize,\n        bisectBatchOnFunctionError: props.bisectBatchOnError,\n        destinationConfig,\n        enabled: props.enabled,\n        eventSourceArn: props.eventSourceArn,\n        functionName: props.target.functionName,\n        startingPosition: props.startingPosition,\n        startingPositionTimestamp: props.startingPositionTimestamp\n          ? new Date(props.startingPositionTimestamp * 1000).toISOString()\n          : undefined,\n        functionResponseTypes: props.reportBatchItemFailures\n          ? [\"ReportBatchItemFailures\"]\n          : undefined,\n        maximumBatchingWindowInSeconds: props.maxBatchingWindow?.toSeconds(),\n        maximumRecordAgeInSeconds: props.maxRecordAge?.toSeconds(),\n        maximumRetryAttempts: props.retryAttempts,\n        parallelizationFactor: props.parallelizationFactor,\n        topics: props.kafkaTopic !== undefined ? [props.kafkaTopic] : undefined,\n        tumblingWindowInSeconds: props.tumblingWindow?.toSeconds(),\n        scalingConfig: props.maxConcurrency\n          ? { maximumConcurrency: props.maxConcurrency }\n          : undefined,\n        sourceAccessConfiguration: props.sourceAccessConfigurations,\n        selfManagedEventSource,\n        filterCriteria: props.filters ? { filter: props.filters } : undefined,\n        // kmsKeyArn: props.filterEncryption?.keyArn, // TODO: re-add KMS support\n        selfManagedKafkaEventSourceConfig: props.kafkaBootstrapServers\n          ? consumerGroupConfig\n          : undefined,\n        amazonManagedKafkaEventSourceConfig: props.eventSourceArn\n          ? consumerGroupConfig\n          : undefined,\n      },\n    );\n    this.eventSourceMappingId = resource.uuid;\n    this.eventSourceMappingArn = EventSourceMapping.formatArn(\n      this,\n      this.eventSourceMappingId,\n    );\n\n    this.eventSourceMappingOutputs = {\n      uuid: this.eventSourceMappingId,\n    };\n  }\n\n  private validateKafkaConsumerGroupIdOrThrow(kafkaConsumerGroupId: string) {\n    if (cdktf.Token.isUnresolved(kafkaConsumerGroupId)) {\n      return;\n    }\n\n    if (kafkaConsumerGroupId.length > 200 || kafkaConsumerGroupId.length < 1) {\n      throw new Error(\n        \"kafkaConsumerGroupId must be a valid string between 1 and 200 characters\",\n      );\n    }\n\n    const regex = new RegExp(/[a-zA-Z0-9-\\/*:_+=.@-]*/);\n    const patternMatch = regex.exec(kafkaConsumerGroupId);\n    if (patternMatch === null || patternMatch[0] !== kafkaConsumerGroupId) {\n      throw new Error(\n        'kafkaConsumerGroupId contains invalid characters. Allowed values are \"[a-zA-Z0-9-/*:_+=.@-]\"',\n      );\n    }\n  }\n}\n\n/**\n * The type of authentication protocol or the VPC components for your event source's SourceAccessConfiguration\n * @see https://docs.aws.amazon.com/lambda/latest/dg/API_SourceAccessConfiguration.html#SSS-Type-SourceAccessConfiguration-Type\n */\nexport enum SourceAccessConfigurationType {\n  /**\n   * (MQ) The Secrets Manager secret that stores your broker credentials.\n   */\n  BASIC_AUTH = \"BASIC_AUTH\",\n\n  /**\n   * The subnets associated with your VPC. Lambda connects to these subnets to fetch data from your Self-Managed Apache Kafka cluster.\n   */\n  VPC_SUBNET = \"VPC_SUBNET\",\n\n  /**\n   * The VPC security group used to manage access to your Self-Managed Apache Kafka brokers.\n   */\n  VPC_SECURITY_GROUP = \"VPC_SECURITY_GROUP\",\n\n  /**\n   * The Secrets Manager ARN of your secret key used for SASL SCRAM-256 authentication of your Self-Managed Apache Kafka brokers.\n   */\n  SASL_SCRAM_256_AUTH = \"SASL_SCRAM_256_AUTH\",\n\n  /**\n   * The Secrets Manager ARN of your secret key used for SASL SCRAM-512 authentication of your Self-Managed Apache Kafka brokers.\n   */\n  SASL_SCRAM_512_AUTH = \"SASL_SCRAM_512_AUTH\",\n\n  /**\n   * The Secrets Manager ARN of your secret key containing the certificate chain (X.509 PEM), private key (PKCS#8 PEM),\n   * and private key password (optional) used for mutual TLS authentication of your MSK/Apache Kafka brokers.\n   */\n  CLIENT_CERTIFICATE_TLS_AUTH = \"CLIENT_CERTIFICATE_TLS_AUTH\",\n\n  /**\n   * The Secrets Manager ARN of your secret key containing the root CA certificate (X.509 PEM) used for TLS encryption of your Apache Kafka brokers.\n   */\n  SERVER_ROOT_CA_CERTIFICATE = \"SERVER_ROOT_CA_CERTIFICATE\",\n}\n\n/**\n * Specific settings like the authentication protocol or the VPC components to secure access to your event source.\n */\nexport interface SourceAccessConfiguration {\n  /**\n   * The type of authentication protocol or the VPC components for your event source. For example: \"SASL_SCRAM_512_AUTH\".\n   */\n  readonly type: SourceAccessConfigurationType;\n  /**\n   * The value for your chosen configuration in type.\n   * For example: \"URI\": \"arn:aws:secretsmanager:us-east-1:01234567890:secret:MyBrokerSecretName\".\n   * The exact string depends on the type.\n   * @see SourceAccessConfigurationType\n   */\n  readonly uri: string;\n}\n/**\n * The position in the DynamoDB, Kinesis or MSK stream where AWS Lambda should start\n * reading.\n */\nexport enum StartingPosition {\n  /**\n   * Start reading at the last untrimmed record in the shard in the system,\n   * which is the oldest data record in the shard.\n   */\n  TRIM_HORIZON = \"TRIM_HORIZON\",\n\n  /**\n   * Start reading just after the most recent record in the shard, so that you\n   * always read the most recent data in the shard\n   */\n  LATEST = \"LATEST\",\n\n  /**\n   * Start reading from a position defined by a time stamp.\n   * Only supported for Amazon Kinesis streams, otherwise an error will occur.\n   * If supplied, `startingPositionTimestamp` must also be set.\n   */\n  AT_TIMESTAMP = \"AT_TIMESTAMP\",\n}\n"]}

package/lib/aws/compute/event-sources/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./s3";
+export * from "./sqs";
+export * from "./sqs-dlq";
+export * from "./s3-onfailure-destination";

package/lib/aws/compute/event-sources/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// export * from './api';
+// export * from './dynamodb';
+// export * from './kafka';
+// export * from './kinesis';
+__exportStar(require("./s3"), exports);
+// export * from './sns';
+// export * from './sns-dlq';
+// export * from './stream';
+__exportStar(require("./sqs"), exports);
+__exportStar(require("./sqs-dlq"), exports);
+__exportStar(require("./s3-onfailure-destination"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYXdzL2NvbXB1dGUvZXZlbnQtc291cmNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEseUJBQXlCO0FBQ3pCLDhCQUE4QjtBQUM5QiwyQkFBMkI7QUFDM0IsNkJBQTZCO0FBQzdCLHVDQUFxQjtBQUNyQix5QkFBeUI7QUFDekIsNkJBQTZCO0FBQzdCLDRCQUE0QjtBQUM1Qix3Q0FBc0I7QUFDdEIsNENBQTBCO0FBQzFCLDZEQUEyQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIGV4cG9ydCAqIGZyb20gJy4vYXBpJztcbi8vIGV4cG9ydCAqIGZyb20gJy4vZHluYW1vZGInO1xuLy8gZXhwb3J0ICogZnJvbSAnLi9rYWZrYSc7XG4vLyBleHBvcnQgKiBmcm9tICcuL2tpbmVzaXMnO1xuZXhwb3J0ICogZnJvbSBcIi4vczNcIjtcbi8vIGV4cG9ydCAqIGZyb20gJy4vc25zJztcbi8vIGV4cG9ydCAqIGZyb20gJy4vc25zLWRscSc7XG4vLyBleHBvcnQgKiBmcm9tICcuL3N0cmVhbSc7XG5leHBvcnQgKiBmcm9tIFwiLi9zcXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3Nxcy1kbHFcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3MzLW9uZmFpbHVyZS1kZXN0aW5hdGlvblwiO1xuIl19

package/lib/aws/compute/event-sources/s3-onfailure-destination.d.ts

@@ -0,0 +1,13 @@
+import { DlqDestinationConfig, IEventSourceDlq, IEventSourceMapping, IFunction } from "../";
+import * as storage from "../../storage";
+/**
+ * An S3 dead letter bucket destination configuration for a Lambda event source
+ */
+export declare class S3OnFailureDestination implements IEventSourceDlq {
+    private readonly bucket;
+    constructor(bucket: storage.IBucket);
+    /**
+     * Returns a destination configuration for the DLQ
+     */
+    bind(_target: IEventSourceMapping, targetHandler: IFunction): DlqDestinationConfig;
+}

package/lib/aws/compute/event-sources/s3-onfailure-destination.js

@@ -0,0 +1,26 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3OnFailureDestination = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * An S3 dead letter bucket destination configuration for a Lambda event source
+ */
+class S3OnFailureDestination {
+    constructor(bucket) {
+        this.bucket = bucket;
+    }
+    /**
+     * Returns a destination configuration for the DLQ
+     */
+    bind(_target, targetHandler) {
+        this.bucket.grantReadWrite(targetHandler);
+        return {
+            destination: this.bucket.bucketArn,
+        };
+    }
+}
+exports.S3OnFailureDestination = S3OnFailureDestination;
+_a = JSII_RTTI_SYMBOL_1;
+S3OnFailureDestination[_a] = { fqn: "terraconstructs.aws.compute.sources.S3OnFailureDestination", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiczMtb25mYWlsdXJlLWRlc3RpbmF0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2F3cy9jb21wdXRlL2V2ZW50LXNvdXJjZXMvczMtb25mYWlsdXJlLWRlc3RpbmF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBUUE7O0dBRUc7QUFDSCxNQUFhLHNCQUFzQjtJQUNqQyxZQUE2QixNQUF1QjtRQUF2QixXQUFNLEdBQU4sTUFBTSxDQUFpQjtJQUFHLENBQUM7SUFFeEQ7O09BRUc7SUFDSSxJQUFJLENBQ1QsT0FBNEIsRUFDNUIsYUFBd0I7UUFFeEIsSUFBSSxDQUFDLE1BQU0sQ0FBQyxjQUFjLENBQUMsYUFBYSxDQUFDLENBQUM7UUFFMUMsT0FBTztZQUNMLFdBQVcsRUFBRSxJQUFJLENBQUMsTUFBTSxDQUFDLFNBQVM7U0FDbkMsQ0FBQztJQUNKLENBQUM7O0FBZkgsd0RBZ0JDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgRGxxRGVzdGluYXRpb25Db25maWcsXG4gIElFdmVudFNvdXJjZURscSxcbiAgSUV2ZW50U291cmNlTWFwcGluZyxcbiAgSUZ1bmN0aW9uLFxufSBmcm9tIFwiLi4vXCI7XG5pbXBvcnQgKiBhcyBzdG9yYWdlIGZyb20gXCIuLi8uLi9zdG9yYWdlXCI7XG5cbi8qKlxuICogQW4gUzMgZGVhZCBsZXR0ZXIgYnVja2V0IGRlc3RpbmF0aW9uIGNvbmZpZ3VyYXRpb24gZm9yIGEgTGFtYmRhIGV2ZW50IHNvdXJjZVxuICovXG5leHBvcnQgY2xhc3MgUzNPbkZhaWx1cmVEZXN0aW5hdGlvbiBpbXBsZW1lbnRzIElFdmVudFNvdXJjZURscSB7XG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgcmVhZG9ubHkgYnVja2V0OiBzdG9yYWdlLklCdWNrZXQpIHt9XG5cbiAgLyoqXG4gICAqIFJldHVybnMgYSBkZXN0aW5hdGlvbiBjb25maWd1cmF0aW9uIGZvciB0aGUgRExRXG4gICAqL1xuICBwdWJsaWMgYmluZChcbiAgICBfdGFyZ2V0OiBJRXZlbnRTb3VyY2VNYXBwaW5nLFxuICAgIHRhcmdldEhhbmRsZXI6IElGdW5jdGlvbixcbiAgKTogRGxxRGVzdGluYXRpb25Db25maWcge1xuICAgIHRoaXMuYnVja2V0LmdyYW50UmVhZFdyaXRlKHRhcmdldEhhbmRsZXIpO1xuXG4gICAgcmV0dXJuIHtcbiAgICAgIGRlc3RpbmF0aW9uOiB0aGlzLmJ1Y2tldC5idWNrZXRBcm4sXG4gICAgfTtcbiAgfVxufVxuIl19

package/lib/aws/compute/event-sources/s3.d.ts

@@ -0,0 +1,24 @@
+import * as compute from "..";
+import * as storage from "../../storage";
+export interface S3EventSourceProps {
+    /**
+     * The s3 event types that will trigger the notification.
+     */
+    readonly events: storage.EventType[];
+    /**
+     * S3 object key filter rules to determine which objects trigger this event.
+     * Each filter must include a `prefix` and/or `suffix` that will be matched
+     * against the s3 object key. Refer to the S3 Developer Guide for details
+     * about allowed filter rules.
+     */
+    readonly filters?: storage.NotificationKeyFilter[];
+}
+/**
+ * Use S3 bucket notifications as an event source for AWS Lambda.
+ */
+export declare class S3EventSource implements compute.IEventSource {
+    private readonly bucket;
+    private readonly props;
+    constructor(bucket: storage.IBucket, props: S3EventSourceProps);
+    bind(target: compute.IFunction): void;
+}

package/lib/aws/compute/event-sources/s3.js

@@ -0,0 +1,25 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3EventSource = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const notifs = require("../../storage/notification-targets");
+/**
+ * Use S3 bucket notifications as an event source for AWS Lambda.
+ */
+class S3EventSource {
+    constructor(bucket, props) {
+        this.bucket = bucket;
+        this.props = props;
+    }
+    bind(target) {
+        const filters = this.props.filters || [];
+        for (const event of this.props.events) {
+            this.bucket.addEventNotification(event, new notifs.FunctionDestination(target), ...filters);
+        }
+    }
+}
+exports.S3EventSource = S3EventSource;
+_a = JSII_RTTI_SYMBOL_1;
+S3EventSource[_a] = { fqn: "terraconstructs.aws.compute.sources.S3EventSource", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/compute/event-sources/sqs-dlq.d.ts

@@ -0,0 +1,13 @@
+import { DlqDestinationConfig, IEventSourceDlq, IEventSourceMapping, IFunction } from "../";
+import * as notify from "../../notify";
+/**
+ * An SQS dead letter queue destination configuration for a Lambda event source
+ */
+export declare class SqsDlq implements IEventSourceDlq {
+    private readonly queue;
+    constructor(queue: notify.IQueue);
+    /**
+     * Returns a destination configuration for the DLQ
+     */
+    bind(_target: IEventSourceMapping, targetHandler: IFunction): DlqDestinationConfig;
+}

package/lib/aws/compute/event-sources/sqs-dlq.js

@@ -0,0 +1,26 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqsDlq = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * An SQS dead letter queue destination configuration for a Lambda event source
+ */
+class SqsDlq {
+    constructor(queue) {
+        this.queue = queue;
+    }
+    /**
+     * Returns a destination configuration for the DLQ
+     */
+    bind(_target, targetHandler) {
+        this.queue.grantSendMessages(targetHandler);
+        return {
+            destination: this.queue.queueArn,
+        };
+    }
+}
+exports.SqsDlq = SqsDlq;
+_a = JSII_RTTI_SYMBOL_1;
+SqsDlq[_a] = { fqn: "terraconstructs.aws.compute.sources.SqsDlq", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3FzLWRscS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9hd3MvY29tcHV0ZS9ldmVudC1zb3VyY2VzL3Nxcy1kbHEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFRQTs7R0FFRztBQUNILE1BQWEsTUFBTTtJQUNqQixZQUE2QixLQUFvQjtRQUFwQixVQUFLLEdBQUwsS0FBSyxDQUFlO0lBQUcsQ0FBQztJQUVyRDs7T0FFRztJQUNJLElBQUksQ0FDVCxPQUE0QixFQUM1QixhQUF3QjtRQUV4QixJQUFJLENBQUMsS0FBSyxDQUFDLGlCQUFpQixDQUFDLGFBQWEsQ0FBQyxDQUFDO1FBRTVDLE9BQU87WUFDTCxXQUFXLEVBQUUsSUFBSSxDQUFDLEtBQUssQ0FBQyxRQUFRO1NBQ2pDLENBQUM7SUFDSixDQUFDOztBQWZILHdCQWdCQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gIERscURlc3RpbmF0aW9uQ29uZmlnLFxuICBJRXZlbnRTb3VyY2VEbHEsXG4gIElFdmVudFNvdXJjZU1hcHBpbmcsXG4gIElGdW5jdGlvbixcbn0gZnJvbSBcIi4uL1wiO1xuaW1wb3J0ICogYXMgbm90aWZ5IGZyb20gXCIuLi8uLi9ub3RpZnlcIjtcblxuLyoqXG4gKiBBbiBTUVMgZGVhZCBsZXR0ZXIgcXVldWUgZGVzdGluYXRpb24gY29uZmlndXJhdGlvbiBmb3IgYSBMYW1iZGEgZXZlbnQgc291cmNlXG4gKi9cbmV4cG9ydCBjbGFzcyBTcXNEbHEgaW1wbGVtZW50cyBJRXZlbnRTb3VyY2VEbHEge1xuICBjb25zdHJ1Y3Rvcihwcml2YXRlIHJlYWRvbmx5IHF1ZXVlOiBub3RpZnkuSVF1ZXVlKSB7fVxuXG4gIC8qKlxuICAgKiBSZXR1cm5zIGEgZGVzdGluYXRpb24gY29uZmlndXJhdGlvbiBmb3IgdGhlIERMUVxuICAgKi9cbiAgcHVibGljIGJpbmQoXG4gICAgX3RhcmdldDogSUV2ZW50U291cmNlTWFwcGluZyxcbiAgICB0YXJnZXRIYW5kbGVyOiBJRnVuY3Rpb24sXG4gICk6IERscURlc3RpbmF0aW9uQ29uZmlnIHtcbiAgICB0aGlzLnF1ZXVlLmdyYW50U2VuZE1lc3NhZ2VzKHRhcmdldEhhbmRsZXIpO1xuXG4gICAgcmV0dXJuIHtcbiAgICAgIGRlc3RpbmF0aW9uOiB0aGlzLnF1ZXVlLnF1ZXVlQXJuLFxuICAgIH07XG4gIH1cbn1cbiJdfQ==

package/lib/aws/compute/event-sources/sqs.d.ts

@@ -0,0 +1,75 @@
+import * as compute from "..";
+import { Duration } from "../../..";
+import * as notify from "../../notify";
+export interface SqsEventSourceProps {
+    /**
+     * The largest number of records that AWS Lambda will retrieve from your event
+     * source at the time of invoking your function. Your function receives an
+     * event with all the retrieved records.
+     *
+     * Valid Range: Minimum value of 1. Maximum value of 10.
+     * If `maxBatchingWindow` is configured, this value can go up to 10,000.
+     *
+     * @default 10
+     */
+    readonly batchSize?: number;
+    /**
+     * The maximum amount of time to gather records before invoking the function.
+     *
+     * Valid Range: Minimum value of 0 minutes. Maximum value of 5 minutes.
+     *
+     * @default - no batching window. The lambda function will be invoked immediately with the records that are available.
+     */
+    readonly maxBatchingWindow?: Duration;
+    /**
+     * Allow functions to return partially successful responses for a batch of records.
+     *
+     * @see https://docs.aws.amazon.com/lambda/latest/dg/with-sqs.html#services-sqs-batchfailurereporting
+     *
+     * @default false
+     */
+    readonly reportBatchItemFailures?: boolean;
+    /**
+     * If the SQS event source mapping should be enabled.
+     *
+     * @default true
+     */
+    readonly enabled?: boolean;
+    /**
+     * Add filter criteria option
+     *
+     * @default - None
+     */
+    readonly filters?: Array<{
+        [key: string]: any;
+    }>;
+    /**
+     * The maximum concurrency setting limits the number of concurrent instances of the function that an Amazon SQS event source can invoke.
+     *
+     * @see https://docs.aws.amazon.com/lambda/latest/dg/with-sqs.html#events-sqs-max-concurrency
+     *
+     * Valid Range: Minimum value of 2. Maximum value of 1000.
+     *
+     * @default - No specific limit.
+     */
+    readonly maxConcurrency?: number;
+}
+/**
+ * Use an Amazon SQS queue as an event source for AWS Lambda.
+ */
+export declare class SqsEventSource implements compute.IEventSource {
+    readonly queue: notify.IQueue;
+    private readonly props;
+    private _eventSourceMappingId?;
+    private _eventSourceMappingArn?;
+    constructor(queue: notify.IQueue, props?: SqsEventSourceProps);
+    bind(target: compute.IFunction): void;
+    /**
+     * The identifier for this EventSourceMapping
+     */
+    get eventSourceMappingId(): string;
+    /**
+     * The ARN for this EventSourceMapping
+     */
+    get eventSourceMappingArn(): string;
+}