terraconstructs 0.0.8

package/lib/aws/notify/queue.js

@@ -0,0 +1,305 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FifoThroughputLimit = exports.DeduplicationScope = exports.RedrivePermission = exports.Queue = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const _1 = require(".");
+const aws_construct_1 = require("../aws-construct");
+const iam = require("../iam");
+/**
+ * The `Queue` beacon provides an [AWS SQS Queue](https://aws.amazon.com/sqs/).
+ *
+ * ```ts
+ * new notify.Queue(stack, "Queue", {
+ *   namePrefix: "queue.fifo",
+ *   messageRetentionSeconds: Duration.days(14).toSeconds(),
+ *   visibilityTimeoutSeconds: Duration.minutes(15).toSeconds(),
+ * });
+ * ```
+ *
+ * @resource aws_sqs_queue
+ * @beacon-class notify.IQueue
+ */
+class Queue extends aws_construct_1.AwsConstructBase {
+    get queueOutputs() {
+        return this._outputs;
+    }
+    get outputs() {
+        return this.queueOutputs;
+    }
+    get queueArn() {
+        return this.resource.arn;
+    }
+    get queueUrl() {
+        return this.resource.url;
+    }
+    get queueName() {
+        return this.resource.name;
+    }
+    constructor(scope, name, props = {}) {
+        super(scope, name, props);
+        // TODO: support ability to specify redriveAllowPolicy separately
+        // ref: https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/sqs_queue_redrive_allow_policy
+        if (props.redriveAllowPolicy) {
+            const { redrivePermission, sourceQueues } = props.redriveAllowPolicy;
+            if (redrivePermission === RedrivePermission.BY_QUEUE) {
+                if (!sourceQueues || sourceQueues.length === 0) {
+                    throw new Error("At least one source queue must be specified when RedrivePermission is set to 'byQueue'");
+                }
+                if (sourceQueues && sourceQueues.length > 10) {
+                    throw new Error("Up to 10 sourceQueues can be specified. Set RedrivePermission to 'allowAll' to specify more");
+                }
+            }
+            else if (redrivePermission && sourceQueues) {
+                throw new Error("sourceQueues cannot be configured when RedrivePermission is set to 'allowAll' or 'denyAll'");
+            }
+        }
+        const fifoProps = this.determineFifoProps(props);
+        this.fifo = fifoProps.fifoQueue || false;
+        let namePrefix = props.namePrefix;
+        if (namePrefix && !cdktf_1.Token.isUnresolved(namePrefix)) {
+            if (namePrefix.endsWith(".fifo")) {
+                namePrefix = namePrefix.slice(0, -5);
+            }
+        }
+        // TODO: Should we always have the gridUUID as the prefix?
+        namePrefix = this.stack.uniqueResourceNamePrefix(this, {
+            prefix: namePrefix ?? this.gridUUID + "-",
+            allowedSpecialCharacters: "_-",
+            maxLength: 80,
+        });
+        const redrivePolicy = props.deadLetterQueue
+            ? {
+                deadLetterTargetArn: props.deadLetterQueue.queue.queueOutputs.arn,
+                maxReceiveCount: props.deadLetterQueue.maxReceiveCount,
+            }
+            : undefined;
+        // When `redriveAllowPolicy` is provided, `redrivePermission` defaults to allow all queues (`ALLOW_ALL`);
+        const redriveAllowPolicy = props.redriveAllowPolicy
+            ? {
+                redrivePermission: props.redriveAllowPolicy.redrivePermission ??
+                    // When `sourceQueues` is provided in `redriveAllowPolicy`, `redrivePermission` defaults to
+                    // allow specified queues (`BY_QUEUE`); otherwise, it defaults to allow all queues (`ALLOW_ALL`).
+                    (props.redriveAllowPolicy.sourceQueues
+                        ? RedrivePermission.BY_QUEUE
+                        : RedrivePermission.ALLOW_ALL),
+                sourceQueueArns: props.redriveAllowPolicy.sourceQueues?.map((q) => q.queueOutputs.arn),
+            }
+            : undefined;
+        this.resource = new provider_aws_1.sqsQueue.SqsQueue(this, "Resource", {
+            ...props,
+            ...fifoProps,
+            redrivePolicy: redrivePolicy ? JSON.stringify(redrivePolicy) : undefined,
+            redriveAllowPolicy: redriveAllowPolicy
+                ? JSON.stringify(redriveAllowPolicy)
+                : undefined,
+            namePrefix,
+        });
+        this.deadLetterQueue = props.deadLetterQueue;
+        this._outputs = {
+            name: this.resource.name,
+            arn: this.resource.arn,
+            url: this.resource.url,
+        };
+    }
+    /**
+     * Adds a statement to the IAM resource policy associated with this queue.
+     *
+     * If this queue was created in this stack (`new Queue`), a queue policy
+     * will be automatically created upon the first call to `addToPolicy`.
+     */
+    addToResourcePolicy(statement) {
+        if (!this.policy) {
+            this.policy = new _1.QueuePolicy(this, "Policy", { queue: this });
+        }
+        if (this.policy) {
+            this.policy.document.addStatements(statement);
+            return { statementAdded: true, policyDependable: this.policy };
+        }
+        return { statementAdded: false };
+    }
+    /**
+     * Grant permissions to consume messages from a queue
+     *
+     * This will grant the following permissions:
+     *
+     *   - sqs:ChangeMessageVisibility
+     *   - sqs:DeleteMessage
+     *   - sqs:ReceiveMessage
+     *   - sqs:GetQueueAttributes
+     *   - sqs:GetQueueUrl
+     *
+     * If encryption is used, permission to use the key to decrypt the contents of the queue will also be granted to the same principal.
+     *
+     * This will grant the following KMS permissions:
+     *
+     *   - kms:Decrypt
+     *
+     * @param grantee Principal to grant consume rights to
+     */
+    grantConsumeMessages(grantee) {
+        const ret = this.grant(grantee, "sqs:ReceiveMessage", "sqs:ChangeMessageVisibility", "sqs:GetQueueUrl", "sqs:DeleteMessage", "sqs:GetQueueAttributes");
+        // // TODO: Re-Add KMS support
+        // if (this.encryptionMasterKey) {
+        //   this.encryptionMasterKey.grantDecrypt(grantee);
+        // }
+        return ret;
+    }
+    /**
+     * Grant access to send messages to a queue to the given identity.
+     *
+     * This will grant the following permissions:
+     *
+     *  - sqs:SendMessage
+     *  - sqs:GetQueueAttributes
+     *  - sqs:GetQueueUrl
+     *
+     * If encryption is used, permission to use the key to encrypt/decrypt the contents of the queue will also be granted to the same principal.
+     *
+     * This will grant the following KMS permissions:
+     *
+     *  - kms:Decrypt
+     *  - kms:Encrypt
+     *  - kms:ReEncrypt*
+     *  - kms:GenerateDataKey*
+     *
+     * @param grantee Principal to grant send rights to
+     */
+    grantSendMessages(grantee) {
+        const ret = this.grant(grantee, "sqs:SendMessage", "sqs:GetQueueAttributes", "sqs:GetQueueUrl");
+        // // TODO: Re-Add KMS support
+        // if (this.encryptionMasterKey) {
+        //   // kms:Decrypt necessary to execute grantsendMessages to an SSE enabled SQS queue
+        //   this.encryptionMasterKey.grantEncryptDecrypt(grantee);
+        // }
+        return ret;
+    }
+    /**
+     * Grant an IAM principal permissions to purge all messages from the queue.
+     *
+     * This will grant the following permissions:
+     *
+     *  - sqs:PurgeQueue
+     *  - sqs:GetQueueAttributes
+     *  - sqs:GetQueueUrl
+     *
+     * @param grantee Principal to grant send rights to
+     */
+    grantPurge(grantee) {
+        return this.grant(grantee, "sqs:PurgeQueue", "sqs:GetQueueAttributes", "sqs:GetQueueUrl");
+    }
+    /**
+     * Grant the actions defined in queueActions to the identity Principal given
+     * on this SQS queue resource.
+     *
+     * @param grantee Principal to grant right to
+     * @param actions The actions to grant
+     */
+    grant(grantee, ...actions) {
+        return iam.Grant.addToPrincipalOrResource({
+            grantee,
+            actions,
+            resourceArns: [this.queueArn],
+            resource: this,
+        });
+    }
+    /**
+     * Look at the props, see if the FIFO props agree, and return the correct subset of props
+     */
+    determineFifoProps(props) {
+        // Check if any of the signals that we have say that this is a FIFO queue.
+        let fifoQueue = props.fifo;
+        const prefix = props.namePrefix;
+        if (typeof fifoQueue === "undefined" &&
+            prefix &&
+            !cdktf_1.Token.isUnresolved(prefix) &&
+            prefix.endsWith(".fifo")) {
+            fifoQueue = true;
+        }
+        if (typeof fifoQueue === "undefined" && props.contentBasedDeduplication) {
+            fifoQueue = true;
+        }
+        if (typeof fifoQueue === "undefined" && props.deduplicationScope) {
+            fifoQueue = true;
+        }
+        if (typeof fifoQueue === "undefined" && props.fifoThroughputLimit) {
+            fifoQueue = true;
+        }
+        // If we have a name, see that it agrees with the FIFO setting
+        if (typeof prefix === "string") {
+            if (fifoQueue && !prefix.endsWith(".fifo")) {
+                throw new Error("FIFO queue names must end in '.fifo'");
+            }
+            if (!fifoQueue && prefix.endsWith(".fifo")) {
+                throw new Error("Non-FIFO queue name may not end in '.fifo'");
+            }
+        }
+        if (props.contentBasedDeduplication && !fifoQueue) {
+            throw new Error("Content-based deduplication can only be defined for FIFO queues");
+        }
+        if (props.deduplicationScope && !fifoQueue) {
+            throw new Error("Deduplication scope can only be defined for FIFO queues");
+        }
+        if (props.fifoThroughputLimit && !fifoQueue) {
+            throw new Error("FIFO throughput limit can only be defined for FIFO queues");
+        }
+        return {
+            contentBasedDeduplication: props.contentBasedDeduplication,
+            deduplicationScope: props.deduplicationScope,
+            fifoThroughputLimit: props.fifoThroughputLimit,
+            fifoQueue,
+        };
+    }
+}
+exports.Queue = Queue;
+_a = JSII_RTTI_SYMBOL_1;
+Queue[_a] = { fqn: "terraconstructs.aws.notify.Queue", version: "0.0.8" };
+/**
+ * The permission type that defines which source queues can specify the current queue as the dead-letter queue
+ */
+var RedrivePermission;
+(function (RedrivePermission) {
+    /**
+     * Any source queues in this AWS account in the same Region can specify this queue as the dead-letter queue
+     */
+    RedrivePermission["ALLOW_ALL"] = "allowAll";
+    /**
+     * No source queues can specify this queue as the dead-letter queue
+     */
+    RedrivePermission["DENY_ALL"] = "denyAll";
+    /**
+     * Only queues specified by the `sourceQueueArns` parameter can specify this queue as the dead-letter queue
+     */
+    RedrivePermission["BY_QUEUE"] = "byQueue";
+})(RedrivePermission || (exports.RedrivePermission = RedrivePermission = {}));
+/**
+ * What kind of deduplication scope to apply
+ */
+var DeduplicationScope;
+(function (DeduplicationScope) {
+    /**
+     * Deduplication occurs at the message group level
+     */
+    DeduplicationScope["MESSAGE_GROUP"] = "messageGroup";
+    /**
+     * Deduplication occurs at the message queue level
+     */
+    DeduplicationScope["QUEUE"] = "queue";
+})(DeduplicationScope || (exports.DeduplicationScope = DeduplicationScope = {}));
+/**
+ * Whether the FIFO queue throughput quota applies to the entire queue or per message group
+ */
+var FifoThroughputLimit;
+(function (FifoThroughputLimit) {
+    /**
+     * Throughput quota applies per queue
+     */
+    FifoThroughputLimit["PER_QUEUE"] = "perQueue";
+    /**
+     * Throughput quota applies per message group id
+     */
+    FifoThroughputLimit["PER_MESSAGE_GROUP_ID"] = "perMessageGroupId";
+})(FifoThroughputLimit || (exports.FifoThroughputLimit = FifoThroughputLimit = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"queue.js","sourceRoot":"","sources":["../../../src/aws/notify/queue.ts"],"names":[],"mappings":"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","sourcesContent":["import { sqsQueue } from \"@cdktf/provider-aws\";\nimport { Token } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { SqsQueueConfig, QueuePolicy } from \".\";\nimport { AwsConstructBase, AwsConstructProps } from \"../aws-construct\";\nimport * as iam from \"../iam\";\n\nexport interface QueueProps extends AwsConstructProps, SqsQueueConfig {\n  /**\n   * Queue Name prefix\n   *\n   * Queue names must be made up of only uppercase and lowercase ASCII letters,\n   * numbers, underscores, and hyphens, and must be between 1 and 80 characters\n   * long.\n   *\n   * Terraform Prefixes must reserve 26 characters for the terraform generated suffix.\n   *\n   * For a FIFO (first-in-first-out) queue, the name must end with the .fifo\n   * @default - GridUUID + Stack Unique Name\n   */\n  readonly namePrefix?: string;\n\n  /**\n   * Send messages to this queue if they were unsuccessfully dequeued a number of times.\n   *\n   * See [AWS Docs](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html)\n   *\n   * @default no dead-letter queue\n   *\n   * {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/sqs_queue#redrive_policy SqsQueue#redrive_policy}\n   */\n  readonly deadLetterQueue?: DeadLetterQueue;\n  /**\n   * The string that includes the parameters for the permissions for the dead-letter queue\n   * redrive permission and which source queues can specify dead-letter queues.\n   *\n   * @default - All source queues can designate this queue as their dead-letter queue.\n   *\n   * {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/sqs_queue#redrive_allow_policy SqsQueue#redrive_allow_policy}\n   */\n  readonly redriveAllowPolicy?: RedriveAllowPolicy;\n  /**\n   * Whether this a first-in-first-out (FIFO) queue.\n   *\n   * @default false, unless nameSuffix ends in '.fifo' or 'contentBasedDeduplication' is true.\n   */\n  readonly fifo?: boolean;\n  /**\n   * Specifies whether to enable content-based deduplication.\n   *\n   * During the deduplication interval (5 minutes), Amazon SQS treats\n   * messages that are sent with identical content (excluding attributes) as\n   * duplicates and delivers only one copy of the message.\n   *\n   * If you don't enable content-based deduplication and you want to deduplicate\n   * messages, provide an explicit deduplication ID in your SendMessage() call.\n   *\n   * (Only applies to FIFO queues.)\n   *\n   * @default false\n   */\n  readonly contentBasedDeduplication?: boolean;\n  /**\n   * For high throughput for FIFO queues, specifies whether message deduplication\n   * occurs at the message group or queue level.\n   *\n   * (Only applies to FIFO queues.)\n   *\n   * @default DeduplicationScope.QUEUE\n   */\n  readonly deduplicationScope?: DeduplicationScope;\n  /**\n   * For high throughput for FIFO queues, specifies whether the FIFO queue\n   * throughput quota applies to the entire queue or per message group.\n   *\n   * (Only applies to FIFO queues.)\n   *\n   * @default FifoThroughputLimit.PER_QUEUE\n   */\n  readonly fifoThroughputLimit?: FifoThroughputLimit;\n}\n\n/**\n * Outputs which may be registered for output via the Grid.\n */\nexport interface QueueOutputs {\n  /**\n   * Queue name\n   */\n  readonly name: string;\n\n  /**\n   * Queue arn\n   */\n  readonly arn: string;\n\n  /**\n   * Queue url\n   */\n  readonly url: string;\n}\n\n/**\n * Imported or created Queue attributes\n */\nexport interface IQueue extends iam.IAwsConstructWithPolicy {\n  /** Strongly typed outputs */\n  readonly queueOutputs: QueueOutputs;\n  /**\n   * The ARN of this queue\n   * @attribute\n   */\n  readonly queueArn: string;\n  /**\n   * The URL of this queue\n   * @attribute\n   */\n  readonly queueUrl: string;\n  /**\n   * The name of this queue\n   * @attribute\n   */\n  readonly queueName: string;\n  /**\n   * If this queue is configured with a dead-letter queue, this is the dead-letter queue settings.\n   */\n  readonly deadLetterQueue?: DeadLetterQueue;\n\n  // // TODO: Re-Add KMS support\n  // /**\n  //  * Whether the contents of the queue are encrypted, and by what type of key.\n  //  */\n  // readonly encryptionType?: QueueEncryption;\n\n  /**\n   * Whether this queue is an Amazon SQS FIFO queue. If false, this is a standard queue.\n   */\n  readonly fifo: boolean;\n\n  /**\n   * Grant permissions to consume messages from a queue\n   *\n   * This will grant the following permissions:\n   *\n   *   - sqs:ChangeMessageVisibility\n   *   - sqs:DeleteMessage\n   *   - sqs:ReceiveMessage\n   *   - sqs:GetQueueAttributes\n   *   - sqs:GetQueueUrl\n   *\n   * @param grantee Principal to grant consume rights to\n   */\n  grantConsumeMessages(grantee: iam.IGrantable): iam.Grant;\n\n  /**\n   * Grant access to send messages to a queue to the given identity.\n   *\n   * This will grant the following permissions:\n   *\n   *  - sqs:SendMessage\n   *  - sqs:GetQueueAttributes\n   *  - sqs:GetQueueUrl\n   *\n   * @param grantee Principal to grant send rights to\n   */\n  grantSendMessages(grantee: iam.IGrantable): iam.Grant;\n\n  /**\n   * Grant an IAM principal permissions to purge all messages from the queue.\n   *\n   * This will grant the following permissions:\n   *\n   *  - sqs:PurgeQueue\n   *  - sqs:GetQueueAttributes\n   *  - sqs:GetQueueUrl\n   *\n   * @param grantee Principal to grant send rights to\n   */\n  grantPurge(grantee: iam.IGrantable): iam.Grant;\n\n  /**\n   * Grant the actions defined in queueActions to the identity Principal given\n   * on this SQS queue resource.\n   *\n   * @param grantee Principal to grant right to\n   * @param queueActions The actions to grant\n   */\n  grant(grantee: iam.IGrantable, ...queueActions: string[]): iam.Grant;\n}\n\n/**\n * The `Queue` beacon provides an [AWS SQS Queue](https://aws.amazon.com/sqs/).\n *\n * ```ts\n * new notify.Queue(stack, \"Queue\", {\n *   namePrefix: \"queue.fifo\",\n *   messageRetentionSeconds: Duration.days(14).toSeconds(),\n *   visibilityTimeoutSeconds: Duration.minutes(15).toSeconds(),\n * });\n * ```\n *\n * @resource aws_sqs_queue\n * @beacon-class notify.IQueue\n */\nexport class Queue extends AwsConstructBase implements IQueue {\n  // TODO: Add static fromLookup?\n  public readonly resource: sqsQueue.SqsQueue;\n\n  private readonly _outputs: QueueOutputs;\n  public get queueOutputs(): QueueOutputs {\n    return this._outputs;\n  }\n  public get outputs(): Record<string, any> {\n    return this.queueOutputs;\n  }\n  private policy?: QueuePolicy;\n\n  public get queueArn(): string {\n    return this.resource.arn;\n  }\n  public get queueUrl(): string {\n    return this.resource.url;\n  }\n  public get queueName(): string {\n    return this.resource.name;\n  }\n  public readonly deadLetterQueue?: DeadLetterQueue;\n\n  /**\n   * Whether this queue is an Amazon SQS FIFO queue. If false, this is a standard queue.\n   */\n  public readonly fifo: boolean;\n\n  constructor(scope: Construct, name: string, props: QueueProps = {}) {\n    super(scope, name, props);\n\n    // TODO: support ability to specify redriveAllowPolicy separately\n    // ref: https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/sqs_queue_redrive_allow_policy\n    if (props.redriveAllowPolicy) {\n      const { redrivePermission, sourceQueues } = props.redriveAllowPolicy;\n      if (redrivePermission === RedrivePermission.BY_QUEUE) {\n        if (!sourceQueues || sourceQueues.length === 0) {\n          throw new Error(\n            \"At least one source queue must be specified when RedrivePermission is set to 'byQueue'\",\n          );\n        }\n        if (sourceQueues && sourceQueues.length > 10) {\n          throw new Error(\n            \"Up to 10 sourceQueues can be specified. Set RedrivePermission to 'allowAll' to specify more\",\n          );\n        }\n      } else if (redrivePermission && sourceQueues) {\n        throw new Error(\n          \"sourceQueues cannot be configured when RedrivePermission is set to 'allowAll' or 'denyAll'\",\n        );\n      }\n    }\n\n    const fifoProps = this.determineFifoProps(props);\n    this.fifo = fifoProps.fifoQueue || false;\n\n    let namePrefix = props.namePrefix;\n    if (namePrefix && !Token.isUnresolved(namePrefix)) {\n      if (namePrefix.endsWith(\".fifo\")) {\n        namePrefix = namePrefix.slice(0, -5);\n      }\n    }\n    // TODO: Should we always have the gridUUID as the prefix?\n    namePrefix = this.stack.uniqueResourceNamePrefix(this, {\n      prefix: namePrefix ?? this.gridUUID + \"-\",\n      allowedSpecialCharacters: \"_-\",\n      maxLength: 80,\n    });\n\n    const redrivePolicy = props.deadLetterQueue\n      ? {\n          deadLetterTargetArn: props.deadLetterQueue.queue.queueOutputs.arn,\n          maxReceiveCount: props.deadLetterQueue.maxReceiveCount,\n        }\n      : undefined;\n\n    // When `redriveAllowPolicy` is provided, `redrivePermission` defaults to allow all queues (`ALLOW_ALL`);\n    const redriveAllowPolicy = props.redriveAllowPolicy\n      ? {\n          redrivePermission:\n            props.redriveAllowPolicy.redrivePermission ??\n            // When `sourceQueues` is provided in `redriveAllowPolicy`, `redrivePermission` defaults to\n            // allow specified queues (`BY_QUEUE`); otherwise, it defaults to allow all queues (`ALLOW_ALL`).\n            (props.redriveAllowPolicy.sourceQueues\n              ? RedrivePermission.BY_QUEUE\n              : RedrivePermission.ALLOW_ALL),\n          sourceQueueArns: props.redriveAllowPolicy.sourceQueues?.map(\n            (q) => q.queueOutputs.arn,\n          ),\n        }\n      : undefined;\n\n    this.resource = new sqsQueue.SqsQueue(this, \"Resource\", {\n      ...props,\n      ...fifoProps,\n      redrivePolicy: redrivePolicy ? JSON.stringify(redrivePolicy) : undefined,\n      redriveAllowPolicy: redriveAllowPolicy\n        ? JSON.stringify(redriveAllowPolicy)\n        : undefined,\n      namePrefix,\n    });\n    this.deadLetterQueue = props.deadLetterQueue;\n    this._outputs = {\n      name: this.resource.name,\n      arn: this.resource.arn,\n      url: this.resource.url,\n    };\n  }\n\n  /**\n   * Adds a statement to the IAM resource policy associated with this queue.\n   *\n   * If this queue was created in this stack (`new Queue`), a queue policy\n   * will be automatically created upon the first call to `addToPolicy`.\n   */\n  public addToResourcePolicy(\n    statement: iam.PolicyStatement,\n  ): iam.AddToResourcePolicyResult {\n    if (!this.policy) {\n      this.policy = new QueuePolicy(this, \"Policy\", { queue: this });\n    }\n\n    if (this.policy) {\n      this.policy.document.addStatements(statement);\n      return { statementAdded: true, policyDependable: this.policy };\n    }\n\n    return { statementAdded: false };\n  }\n\n  /**\n   * Grant permissions to consume messages from a queue\n   *\n   * This will grant the following permissions:\n   *\n   *   - sqs:ChangeMessageVisibility\n   *   - sqs:DeleteMessage\n   *   - sqs:ReceiveMessage\n   *   - sqs:GetQueueAttributes\n   *   - sqs:GetQueueUrl\n   *\n   * If encryption is used, permission to use the key to decrypt the contents of the queue will also be granted to the same principal.\n   *\n   * This will grant the following KMS permissions:\n   *\n   *   - kms:Decrypt\n   *\n   * @param grantee Principal to grant consume rights to\n   */\n  public grantConsumeMessages(grantee: iam.IGrantable) {\n    const ret = this.grant(\n      grantee,\n      \"sqs:ReceiveMessage\",\n      \"sqs:ChangeMessageVisibility\",\n      \"sqs:GetQueueUrl\",\n      \"sqs:DeleteMessage\",\n      \"sqs:GetQueueAttributes\",\n    );\n\n    // // TODO: Re-Add KMS support\n    // if (this.encryptionMasterKey) {\n    //   this.encryptionMasterKey.grantDecrypt(grantee);\n    // }\n\n    return ret;\n  }\n\n  /**\n   * Grant access to send messages to a queue to the given identity.\n   *\n   * This will grant the following permissions:\n   *\n   *  - sqs:SendMessage\n   *  - sqs:GetQueueAttributes\n   *  - sqs:GetQueueUrl\n   *\n   * If encryption is used, permission to use the key to encrypt/decrypt the contents of the queue will also be granted to the same principal.\n   *\n   * This will grant the following KMS permissions:\n   *\n   *  - kms:Decrypt\n   *  - kms:Encrypt\n   *  - kms:ReEncrypt*\n   *  - kms:GenerateDataKey*\n   *\n   * @param grantee Principal to grant send rights to\n   */\n  public grantSendMessages(grantee: iam.IGrantable) {\n    const ret = this.grant(\n      grantee,\n      \"sqs:SendMessage\",\n      \"sqs:GetQueueAttributes\",\n      \"sqs:GetQueueUrl\",\n    );\n\n    // // TODO: Re-Add KMS support\n    // if (this.encryptionMasterKey) {\n    //   // kms:Decrypt necessary to execute grantsendMessages to an SSE enabled SQS queue\n    //   this.encryptionMasterKey.grantEncryptDecrypt(grantee);\n    // }\n    return ret;\n  }\n\n  /**\n   * Grant an IAM principal permissions to purge all messages from the queue.\n   *\n   * This will grant the following permissions:\n   *\n   *  - sqs:PurgeQueue\n   *  - sqs:GetQueueAttributes\n   *  - sqs:GetQueueUrl\n   *\n   * @param grantee Principal to grant send rights to\n   */\n  public grantPurge(grantee: iam.IGrantable) {\n    return this.grant(\n      grantee,\n      \"sqs:PurgeQueue\",\n      \"sqs:GetQueueAttributes\",\n      \"sqs:GetQueueUrl\",\n    );\n  }\n\n  /**\n   * Grant the actions defined in queueActions to the identity Principal given\n   * on this SQS queue resource.\n   *\n   * @param grantee Principal to grant right to\n   * @param actions The actions to grant\n   */\n  public grant(grantee: iam.IGrantable, ...actions: string[]) {\n    return iam.Grant.addToPrincipalOrResource({\n      grantee,\n      actions,\n      resourceArns: [this.queueArn],\n      resource: this,\n    });\n  }\n\n  /**\n   * Look at the props, see if the FIFO props agree, and return the correct subset of props\n   */\n  private determineFifoProps(props: QueueProps): FifoProps {\n    // Check if any of the signals that we have say that this is a FIFO queue.\n    let fifoQueue = props.fifo;\n    const prefix = props.namePrefix;\n    if (\n      typeof fifoQueue === \"undefined\" &&\n      prefix &&\n      !Token.isUnresolved(prefix) &&\n      prefix.endsWith(\".fifo\")\n    ) {\n      fifoQueue = true;\n    }\n    if (typeof fifoQueue === \"undefined\" && props.contentBasedDeduplication) {\n      fifoQueue = true;\n    }\n    if (typeof fifoQueue === \"undefined\" && props.deduplicationScope) {\n      fifoQueue = true;\n    }\n    if (typeof fifoQueue === \"undefined\" && props.fifoThroughputLimit) {\n      fifoQueue = true;\n    }\n\n    // If we have a name, see that it agrees with the FIFO setting\n    if (typeof prefix === \"string\") {\n      if (fifoQueue && !prefix.endsWith(\".fifo\")) {\n        throw new Error(\"FIFO queue names must end in '.fifo'\");\n      }\n      if (!fifoQueue && prefix.endsWith(\".fifo\")) {\n        throw new Error(\"Non-FIFO queue name may not end in '.fifo'\");\n      }\n    }\n\n    if (props.contentBasedDeduplication && !fifoQueue) {\n      throw new Error(\n        \"Content-based deduplication can only be defined for FIFO queues\",\n      );\n    }\n\n    if (props.deduplicationScope && !fifoQueue) {\n      throw new Error(\n        \"Deduplication scope can only be defined for FIFO queues\",\n      );\n    }\n\n    if (props.fifoThroughputLimit && !fifoQueue) {\n      throw new Error(\n        \"FIFO throughput limit can only be defined for FIFO queues\",\n      );\n    }\n\n    return {\n      contentBasedDeduplication: props.contentBasedDeduplication,\n      deduplicationScope: props.deduplicationScope,\n      fifoThroughputLimit: props.fifoThroughputLimit,\n      fifoQueue,\n    };\n  }\n}\n\ninterface FifoProps {\n  readonly fifoQueue?: boolean;\n  readonly contentBasedDeduplication?: boolean;\n  readonly deduplicationScope?: DeduplicationScope;\n  readonly fifoThroughputLimit?: FifoThroughputLimit;\n}\n\n/**\n * Dead letter queue settings\n */\nexport interface DeadLetterQueue {\n  /**\n   * The dead-letter queue to which Amazon SQS moves messages after the value of maxReceiveCount is exceeded.\n   */\n  readonly queue: IQueue;\n\n  /**\n   * The number of times a message can be unsuccessfully dequeued before being moved to the dead-letter queue.\n   */\n  readonly maxReceiveCount: number;\n}\n\n/**\n * Permission settings for the dead letter source queue\n */\nexport interface RedriveAllowPolicy {\n  /**\n   * Permission settings for source queues that can designate this queue as their dead-letter queue.\n   *\n   * @default - `RedrivePermission.BY_QUEUE` if `sourceQueues` is specified,`RedrivePermission.ALLOW_ALL` otherwise.\n   */\n  readonly redrivePermission?: RedrivePermission;\n\n  /**\n   * Source queues that can designate this queue as their dead-letter queue.\n   *\n   * When `redrivePermission` is set to `RedrivePermission.BY_QUEUE`, this parameter is required.\n   *\n   * You can specify up to 10 source queues.\n   * To allow more than 10 source queues to specify dead-letter queues, set the `redrivePermission` to\n   * `RedrivePermission.ALLOW_ALL`.\n   *\n   * When `redrivePermission` is either `RedrivePermission.ALLOW_ALL` or `RedrivePermission.DENY_ALL`,\n   * this parameter cannot be set.\n   *\n   * @default - Required when `redrivePermission` is `RedrivePermission.BY_QUEUE`, cannot be defined otherwise.\n   */\n  readonly sourceQueues?: IQueue[];\n}\n\n/**\n * The permission type that defines which source queues can specify the current queue as the dead-letter queue\n */\nexport enum RedrivePermission {\n  /**\n   * Any source queues in this AWS account in the same Region can specify this queue as the dead-letter queue\n   */\n  ALLOW_ALL = \"allowAll\",\n  /**\n   * No source queues can specify this queue as the dead-letter queue\n   */\n  DENY_ALL = \"denyAll\",\n  /**\n   * Only queues specified by the `sourceQueueArns` parameter can specify this queue as the dead-letter queue\n   */\n  BY_QUEUE = \"byQueue\",\n}\n\n/**\n * What kind of deduplication scope to apply\n */\nexport enum DeduplicationScope {\n  /**\n   * Deduplication occurs at the message group level\n   */\n  MESSAGE_GROUP = \"messageGroup\",\n  /**\n   * Deduplication occurs at the message queue level\n   */\n  QUEUE = \"queue\",\n}\n\n/**\n * Whether the FIFO queue throughput quota applies to the entire queue or per message group\n */\nexport enum FifoThroughputLimit {\n  /**\n   * Throughput quota applies per queue\n   */\n  PER_QUEUE = \"perQueue\",\n  /**\n   * Throughput quota applies per message group id\n   */\n  PER_MESSAGE_GROUP_ID = \"perMessageGroupId\",\n}\n"]}

package/lib/aws/notify/resource-policy.d.ts

@@ -0,0 +1,41 @@
+import { Construct } from "constructs";
+import { AwsConstructBase, AwsConstructProps } from "../aws-construct";
+import { IStream } from "./kinesis-stream";
+import { PolicyDocument } from "../iam";
+/**
+ * Properties to associate a data stream with a policy
+ */
+export interface ResourcePolicyProps extends AwsConstructProps {
+    /**
+     * The stream this policy applies to.
+     */
+    readonly stream: IStream;
+    /**
+     * IAM policy document to apply to a data stream.
+     *
+     * @default - empty policy document
+     */
+    readonly policyDocument?: PolicyDocument;
+}
+/**
+ * The policy for a data stream or registered consumer.
+ *
+ * Policies define the operations that are allowed on this resource.
+ *
+ * You almost never need to define this construct directly.
+ *
+ * All AWS resources that support resource policies have a method called
+ * `addToResourcePolicy()`, which will automatically create a new resource
+ * policy if one doesn't exist yet, otherwise it will add to the existing
+ * policy.
+ *
+ * Prefer to use `addToResourcePolicy()` instead.
+ */
+export declare class ResourcePolicy extends AwsConstructBase {
+    /**
+     * The IAM policy document for this policy.
+     */
+    readonly document: PolicyDocument;
+    get outputs(): Record<string, any>;
+    constructor(scope: Construct, id: string, props: ResourcePolicyProps);
+}

package/lib/aws/notify/resource-policy.js

@@ -0,0 +1,43 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourcePolicy = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-kinesis/lib/resource-policy.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const aws_construct_1 = require("../aws-construct");
+const iam_1 = require("../iam");
+/**
+ * The policy for a data stream or registered consumer.
+ *
+ * Policies define the operations that are allowed on this resource.
+ *
+ * You almost never need to define this construct directly.
+ *
+ * All AWS resources that support resource policies have a method called
+ * `addToResourcePolicy()`, which will automatically create a new resource
+ * policy if one doesn't exist yet, otherwise it will add to the existing
+ * policy.
+ *
+ * Prefer to use `addToResourcePolicy()` instead.
+ */
+class ResourcePolicy extends aws_construct_1.AwsConstructBase {
+    get outputs() {
+        /**
+         * This resource exports no additional attributes.
+         */
+        return {};
+    }
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.document = props.policyDocument ?? new iam_1.PolicyDocument(this, "Policy");
+        new provider_aws_1.kinesisResourcePolicy.KinesisResourcePolicy(this, "Resource", {
+            policy: this.document.json,
+            resourceArn: props.stream.streamArn,
+        });
+    }
+}
+exports.ResourcePolicy = ResourcePolicy;
+_a = JSII_RTTI_SYMBOL_1;
+ResourcePolicy[_a] = { fqn: "terraconstructs.aws.notify.ResourcePolicy", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/notify/rule.d.ts

@@ -0,0 +1,153 @@
+import { cloudwatchEventRule } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { AwsConstructBase, IAwsConstruct, AwsConstructProps } from "../aws-construct";
+import { Schedule, EventPattern, IRuleTarget, IEventBus, EventCommonOptions } from "./";
+export interface RuleProps extends AwsConstructProps, EventCommonOptions {
+    /**
+     * Indicates whether the rule is enabled.
+     *
+     * @default true
+     */
+    readonly enabled?: boolean;
+    /**
+     * Rule Name prefix to append to Grid UUID
+     *
+     * Rule names must be made up of only uppercase and lowercase ASCII letters,
+     * numbers, underscores, and hyphens, and Due to the length of the tf generated
+     * suffix, must be 64 characters or less long.
+     *
+     *
+     * @default - GridUUID + Stack Unique Name
+     */
+    readonly namePrefix?: string;
+    /**
+     * The schedule or rate (frequency) that determines when EventBridge
+     * runs the rule.
+     *
+     * You must specify this property, the `eventPattern` property, or both.
+     *
+     * For more information, see Schedule Expression Syntax for
+     * Rules in the Amazon EventBridge User Guide.
+     *
+     * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/scheduled-events.html
+     *
+     * @default - None.
+     */
+    readonly schedule?: Schedule;
+    /**
+     * Targets to invoke when this rule matches an event.
+     *
+     * Input will be the full matched event. If you wish to specify custom
+     * target input, use `addTarget(target[, inputOptions])`.
+     *
+     * @default - No targets.
+     */
+    readonly targets?: IRuleTarget[];
+    /**
+     * The event bus to associate with this rule.
+     *
+     * @default - The default event bus.
+     */
+    readonly eventBus?: IEventBus;
+}
+export interface RuleOutputs {
+    /**
+     * Rule name
+     */
+    readonly name: string;
+    /**
+     * Rule arn
+     */
+    readonly arn: string;
+}
+export interface IRule extends IAwsConstruct {
+    /** Strongly typed outputs */
+    readonly ruleOutputs: RuleOutputs;
+    /**
+     * The value of the event rule Amazon Resource Name (ARN), such as
+     * arn:aws:events:us-east-2:123456789012:rule/example.
+     *
+     * @attribute
+     */
+    readonly ruleArn: string;
+    /**
+     * The name event rule
+     *
+     * @attribute
+     */
+    readonly ruleName: string;
+}
+export declare class Rule extends AwsConstructBase implements IRule {
+    /**
+     * Import an existing EventBridge Rule provided an ARN
+     *
+     * @param scope The parent creating construct (usually `this`).
+     * @param id The construct's name.
+     * @param eventRuleArn Event Rule ARN (i.e. arn:aws:events:<region>:<account-id>:rule/MyScheduledRule).
+     */
+    static fromEventRuleArn(scope: Construct, id: string, eventRuleArn: string): IRule;
+    readonly resource: cloudwatchEventRule.CloudwatchEventRule;
+    get ruleArn(): string;
+    get ruleName(): string;
+    get ruleOutputs(): RuleOutputs;
+    get outputs(): Record<string, any>;
+    private readonly targets;
+    private readonly eventPattern;
+    private readonly scheduleExpression?;
+    private readonly description?;
+    constructor(scope: Construct, name: string, props?: RuleProps);
+    /**
+     * Adds an event pattern filter to this rule. If a pattern was already specified,
+     * these values are merged into the existing pattern.
+     *
+     * For example, if the rule already contains the pattern:
+     *
+     *    {
+     *      "resources": [ "r1" ],
+     *      "detail": {
+     *        "hello": [ 1 ]
+     *      }
+     *    }
+     *
+     * And `addEventPattern` is called with the pattern:
+     *
+     *    {
+     *      "resources": [ "r2" ],
+     *      "detail": {
+     *        "foo": [ "bar" ]
+     *      }
+     *    }
+     *
+     * The resulting event pattern will be:
+     *
+     *    {
+     *      "resources": [ "r1", "r2" ],
+     *      "detail": {
+     *        "hello": [ 1 ],
+     *        "foo": [ "bar" ]
+     *      }
+     *    }
+     *
+     */
+    addEventPattern(eventPattern?: EventPattern): void;
+    /**
+     * Not private only to be overrideen in CopyRule.
+     *
+     * @internal
+     */
+    _renderEventPattern(): any;
+    protected validateRule(ruleName?: string): string[];
+    /**
+     * Adds a target to the rule. The abstract class RuleTarget can be extended to define new
+     * targets.
+     *
+     * No-op if target is undefined.
+     */
+    addTarget(target?: IRuleTarget): void;
+    /**
+     * Adds resource to the Terraform JSON output at Synth time.
+     *
+     * called by TerraformStack.prepareStack()
+     */
+    toTerraform(): any;
+}