terraconstructs 0.0.17 → 0.0.18

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

@@ -0,0 +1,219 @@
+import { Construct } from "constructs";
+import { DeliveryPolicy } from "./delivery-policy";
+import { SubscriptionFilter } from "./subscription-filter";
+import { ITopic } from "./topic-base";
+import { AwsConstructBase, AwsConstructProps } from "../aws-construct";
+import * as notify from "../notify";
+/**
+ * Outputs for the Subscription construct.
+ */
+export interface SubscriptionOutputs {
+    /**
+     * The ARN of the subscription.
+     */
+    readonly subscriptionArn: string;
+}
+/**
+ * Options for creating a new subscription
+ */
+export interface SubscriptionOptions extends AwsConstructProps {
+    /**
+     * What type of subscription to add.
+     */
+    readonly protocol: SubscriptionProtocol;
+    /**
+     * The subscription endpoint.
+     *
+     * The meaning of this value depends on the value for 'protocol'.
+     */
+    readonly endpoint: string;
+    /**
+     * true if raw message delivery is enabled for the subscription. Raw messages are free of JSON formatting and can be
+     * sent to HTTP/S and Amazon SQS endpoints. For more information, see GetSubscriptionAttributes in the Amazon Simple
+     * Notification Service API Reference.
+     *
+     * @default false
+     */
+    readonly rawMessageDelivery?: boolean;
+    /**
+     * The filter policy.
+     *
+     * @default - all messages are delivered
+     */
+    readonly filterPolicy?: {
+        [attribute: string]: SubscriptionFilter;
+    };
+    /**
+     * The filter policy that is applied on the message body.
+     * To apply a filter policy to the message attributes, use `filterPolicy`. A maximum of one of `filterPolicyWithMessageBody` and `filterPolicy` may be used.
+     *
+     * @default - all messages are delivered
+     */
+    readonly filterPolicyWithMessageBody?: {
+        [attribute: string]: FilterOrPolicy;
+    };
+    /**
+     * Queue to be used as dead letter queue.
+     * If not passed no dead letter queue is enabled.
+     *
+     * @default - No dead letter queue enabled.
+     */
+    readonly deadLetterQueue?: notify.IQueue;
+    /**
+     * Arn of role allowing access to firehose delivery stream.
+     * Required for a firehose subscription protocol.
+     * @default - No subscription role is provided
+     */
+    readonly subscriptionRoleArn?: string;
+    /**
+     * The delivery policy.
+     *
+     * @default - if the initial delivery of the message fails, three retries with a delay between failed attempts set at 20 seconds
+     */
+    readonly deliveryPolicy?: DeliveryPolicy;
+}
+/**
+ * Properties for creating a new subscription
+ */
+export interface SubscriptionProps extends SubscriptionOptions {
+    /**
+     * The topic to subscribe to.
+     */
+    readonly topic: ITopic;
+}
+/**
+ * A new subscription.
+ *
+ * Prefer to use the `ITopic.addSubscription()` methods to create instances of
+ * this class.
+ *
+ * @resource aws_sns_topic_subscription
+ */
+export declare class Subscription extends AwsConstructBase {
+    /**
+     * The DLQ associated with this subscription if present.
+     */
+    readonly deadLetterQueue?: notify.IQueue;
+    private readonly resource;
+    readonly subscriptionOutputs: SubscriptionOutputs;
+    get outputs(): Record<string, any>;
+    constructor(scope: Construct, id: string, props: SubscriptionProps);
+    private renderDeliveryPolicy;
+    private buildDeadLetterQueue;
+    private buildDeadLetterConfig;
+}
+/**
+ * The type of subscription, controlling the type of the endpoint parameter.
+ */
+export declare enum SubscriptionProtocol {
+    /**
+     * JSON-encoded message is POSTED to an HTTP url.
+     */
+    HTTP = "http",
+    /**
+     * JSON-encoded message is POSTed to an HTTPS url.
+     */
+    HTTPS = "https",
+    /**
+     * Notifications are sent via email.
+     */
+    EMAIL = "email",
+    /**
+     * Notifications are JSON-encoded and sent via mail.
+     */
+    EMAIL_JSON = "email-json",
+    /**
+     * Notification is delivered by SMS
+     */
+    SMS = "sms",
+    /**
+     * Notifications are enqueued into an SQS queue.
+     */
+    SQS = "sqs",
+    /**
+     * JSON-encoded notifications are sent to a mobile app endpoint.
+     */
+    APPLICATION = "application",
+    /**
+     * Notifications trigger a Lambda function.
+     */
+    LAMBDA = "lambda",
+    /**
+     * Notifications put records into a firehose delivery stream.
+     */
+    FIREHOSE = "firehose"
+}
+/**
+ * The type of the MessageBody at a given key value pair
+ */
+export declare enum FilterOrPolicyType {
+    /**
+     * The filter of the MessageBody
+     */
+    FILTER = 0,
+    /**
+     * A nested key of the MessageBody
+     */
+    POLICY = 1
+}
+/**
+ * Class for building the FilterPolicy by avoiding union types
+ */
+export declare abstract class FilterOrPolicy {
+    /**
+     * Filter of MessageBody
+     */
+    static filter(filter: SubscriptionFilter): notify.Filter;
+    /**
+     * Policy of MessageBody
+     */
+    static policy(policy: {
+        [attribute: string]: FilterOrPolicy;
+    }): notify.Policy;
+    /**
+     * Type switch for disambiguating between subclasses
+     */
+    abstract readonly type: FilterOrPolicyType;
+    /**
+     * Check if instance is `Policy` type
+     */
+    isPolicy(): this is Policy;
+    /**
+     * Check if instance is `Filter` type
+     */
+    isFilter(): this is Filter;
+}
+/**
+ * Filter implementation of FilterOrPolicy
+ */
+export declare class Filter extends FilterOrPolicy {
+    readonly filterDoc: SubscriptionFilter;
+    /**
+     * Type used in DFS buildFilterPolicyWithMessageBody to determine json value type
+     */
+    readonly type = notify.FilterOrPolicyType.FILTER;
+    /**
+     * Policy constructor
+     * @param filterDoc filter argument to construct
+     */
+    constructor(filterDoc: SubscriptionFilter);
+}
+/**
+ * Policy Implementation of FilterOrPolicy
+ */
+export declare class Policy extends FilterOrPolicy {
+    readonly policyDoc: {
+        [attribute: string]: FilterOrPolicy;
+    };
+    /**
+     * Type used in DFS buildFilterPolicyWithMessageBody to determine json value type
+     */
+    readonly type = notify.FilterOrPolicyType.POLICY;
+    /**
+     * Policy constructor
+     * @param policyDoc policy argument to construct
+     */
+    constructor(policyDoc: {
+        [attribute: string]: FilterOrPolicy;
+    });
+}

package/lib/aws/notify/subscription.js

@@ -0,0 +1,357 @@
+"use strict";
+var _a, _b, _c, _d;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Policy = exports.Filter = exports.FilterOrPolicy = exports.FilterOrPolicyType = exports.SubscriptionProtocol = exports.Subscription = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/6b9e47a1529319561bc1040739fe02bac15895bf/packages/aws-cdk-lib/aws-sns/lib/subscription.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const aws_construct_1 = require("../aws-construct");
+const iam = require("../iam");
+/**
+ * A new subscription.
+ *
+ * Prefer to use the `ITopic.addSubscription()` methods to create instances of
+ * this class.
+ *
+ * @resource aws_sns_topic_subscription
+ */
+class Subscription extends aws_construct_1.AwsConstructBase {
+    get outputs() {
+        return this.subscriptionOutputs;
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        if (props.rawMessageDelivery &&
+            [
+                SubscriptionProtocol.HTTP,
+                SubscriptionProtocol.HTTPS,
+                SubscriptionProtocol.SQS,
+                SubscriptionProtocol.FIREHOSE,
+            ].indexOf(props.protocol) < 0) {
+            // TODO: re-add ValidationError
+            throw new Error("Raw message delivery can only be enabled for HTTP, HTTPS, SQS, and Firehose subscriptions.");
+        }
+        let filterPolicyJson;
+        /** Whether the filter_policy applies to MessageAttributes (default) or MessageBody */
+        let filterPolicyScope;
+        if (props.filterPolicy && props.filterPolicyWithMessageBody) {
+            throw new Error("A maximum of one of `filterPolicyWithMessageBody` and `filterPolicy` may be used.");
+        }
+        if (props.filterPolicy) {
+            if (Object.keys(props.filterPolicy).length > 5) {
+                throw new Error("A filter policy can have a maximum of 5 attribute names.");
+            }
+            const filterPolicyConditions = Object.entries(props.filterPolicy).reduce((acc, [k, v]) => ({ ...acc, [k]: v.conditions }), {});
+            let total = 1;
+            Object.values(filterPolicyConditions).forEach((filter) => {
+                total *= filter.length;
+            });
+            if (total > 150) {
+                // TODO: re-add ValidationError
+                throw new Error(`The total combination of values (${total}) must not exceed 150.`);
+            }
+            filterPolicyJson = JSON.stringify(filterPolicyConditions);
+            filterPolicyScope = "MessageAttributes"; // Default scope
+        }
+        else if (props.filterPolicyWithMessageBody) {
+            if (Object.keys(props.filterPolicyWithMessageBody).length > 5) {
+                throw new Error("A filter policy can have a maximum of 5 attribute names.");
+            }
+            const builtPolicy = buildFilterPolicyWithMessageBody(this, props.filterPolicyWithMessageBody);
+            filterPolicyJson = JSON.stringify(builtPolicy);
+            filterPolicyScope = "MessageBody";
+        }
+        if (props.protocol === SubscriptionProtocol.FIREHOSE &&
+            !props.subscriptionRoleArn) {
+            throw new Error("Subscription role arn is required field for subscriptions with a firehose protocol.");
+        }
+        this.deadLetterQueue = this.buildDeadLetterQueue(props);
+        const redrivePolicyJson = this.buildDeadLetterConfig(this.deadLetterQueue);
+        const deliveryPolicyJson = props.deliveryPolicy
+            ? this.renderDeliveryPolicy(props.deliveryPolicy, props.protocol)
+            : undefined;
+        this.resource = new provider_aws_1.snsTopicSubscription.SnsTopicSubscription(this, "Resource", {
+            endpoint: props.endpoint,
+            protocol: props.protocol,
+            topicArn: props.topic.topicArn,
+            rawMessageDelivery: props.rawMessageDelivery,
+            filterPolicy: filterPolicyJson,
+            filterPolicyScope: filterPolicyScope,
+            redrivePolicy: redrivePolicyJson,
+            subscriptionRoleArn: props.subscriptionRoleArn,
+            deliveryPolicy: deliveryPolicyJson,
+            // confirmationTimeoutInMinutes: // Not directly available in CDK props
+            // endpointAutoConfirms: // Not directly available in CDK props
+            // replayPolicy: // Not directly available in CDK props (missing in AWS CDK)
+        });
+        this.subscriptionOutputs = {
+            subscriptionArn: this.resource.arn,
+        };
+    }
+    renderDeliveryPolicy(deliveryPolicy, protocol) {
+        // TODO: re-add ValidationError(s)
+        if (![SubscriptionProtocol.HTTP, SubscriptionProtocol.HTTPS].includes(protocol)) {
+            throw new Error(`Delivery policy is only supported for HTTP and HTTPS subscriptions, got: ${protocol}`);
+        }
+        const { healthyRetryPolicy, throttlePolicy, requestPolicy } = deliveryPolicy;
+        const renderedPolicy = {};
+        if (healthyRetryPolicy) {
+            const delayTargetLimitSecs = 3600;
+            const minDelayTarget = healthyRetryPolicy.minDelayTarget;
+            const maxDelayTarget = healthyRetryPolicy.maxDelayTarget;
+            if (minDelayTarget !== undefined) {
+                if (minDelayTarget.toMilliseconds() % 1000 !== 0) {
+                    throw new Error(`minDelayTarget must be a whole number of seconds, got: ${minDelayTarget}`);
+                }
+                const minDelayTargetSecs = minDelayTarget.toSeconds();
+                if (minDelayTargetSecs < 1 ||
+                    minDelayTargetSecs > delayTargetLimitSecs) {
+                    throw new Error(`minDelayTarget must be between 1 and ${delayTargetLimitSecs} seconds inclusive, got: ${minDelayTargetSecs}s`);
+                }
+            }
+            if (maxDelayTarget !== undefined) {
+                if (maxDelayTarget.toMilliseconds() % 1000 !== 0) {
+                    throw new Error(`maxDelayTarget must be a whole number of seconds, got: ${maxDelayTarget}`);
+                }
+                const maxDelayTargetSecs = maxDelayTarget.toSeconds();
+                if (maxDelayTargetSecs < 1 ||
+                    maxDelayTargetSecs > delayTargetLimitSecs) {
+                    throw new Error(`maxDelayTarget must be between 1 and ${delayTargetLimitSecs} seconds inclusive, got: ${maxDelayTargetSecs}s`);
+                }
+                if (minDelayTarget !== undefined &&
+                    minDelayTarget.toSeconds() > maxDelayTargetSecs) {
+                    throw new Error("minDelayTarget must not exceed maxDelayTarget");
+                }
+            }
+            const numRetriesLimit = 100;
+            if (healthyRetryPolicy.numRetries &&
+                (healthyRetryPolicy.numRetries < 0 ||
+                    healthyRetryPolicy.numRetries > numRetriesLimit)) {
+                throw new Error(`numRetries must be between 0 and ${numRetriesLimit} inclusive, got: ${healthyRetryPolicy.numRetries}`);
+            }
+            const { numNoDelayRetries, numMinDelayRetries, numMaxDelayRetries } = healthyRetryPolicy;
+            if (numNoDelayRetries &&
+                (numNoDelayRetries < 0 || !Number.isInteger(numNoDelayRetries))) {
+                throw new Error(`numNoDelayRetries must be an integer zero or greater, got: ${numNoDelayRetries}`);
+            }
+            if (numMinDelayRetries &&
+                (numMinDelayRetries < 0 || !Number.isInteger(numMinDelayRetries))) {
+                throw new Error(`numMinDelayRetries must be an integer zero or greater, got: ${numMinDelayRetries}`);
+            }
+            if (numMaxDelayRetries &&
+                (numMaxDelayRetries < 0 || !Number.isInteger(numMaxDelayRetries))) {
+                throw new Error(`numMaxDelayRetries must be an integer zero or greater, got: ${numMaxDelayRetries}`);
+            }
+            renderedPolicy.healthyRetryPolicy = {
+                minDelayTarget: healthyRetryPolicy.minDelayTarget === undefined
+                    ? 20
+                    : healthyRetryPolicy.minDelayTarget.toSeconds(),
+                maxDelayTarget: healthyRetryPolicy.maxDelayTarget === undefined
+                    ? 20
+                    : healthyRetryPolicy.maxDelayTarget.toSeconds(),
+                numRetries: healthyRetryPolicy.numRetries === undefined
+                    ? 3
+                    : healthyRetryPolicy.numRetries,
+                numNoDelayRetries: healthyRetryPolicy.numNoDelayRetries,
+                numMinDelayRetries: healthyRetryPolicy.numMinDelayRetries,
+                numMaxDelayRetries: healthyRetryPolicy.numMaxDelayRetries,
+                backoffFunction: healthyRetryPolicy.backoffFunction,
+            };
+        }
+        if (throttlePolicy) {
+            const maxReceivesPerSecond = throttlePolicy.maxReceivesPerSecond;
+            if (maxReceivesPerSecond !== undefined &&
+                (maxReceivesPerSecond < 1 || !Number.isInteger(maxReceivesPerSecond))) {
+                throw new Error(`maxReceivesPerSecond must be an integer greater than zero, got: ${maxReceivesPerSecond}`);
+            }
+            renderedPolicy.throttlePolicy = {
+                maxReceivesPerSecond: throttlePolicy.maxReceivesPerSecond,
+            };
+        }
+        if (requestPolicy) {
+            renderedPolicy.requestPolicy = {
+                headerContentType: requestPolicy.headerContentType,
+            };
+        }
+        return JSON.stringify(renderedPolicy);
+    }
+    buildDeadLetterQueue(props) {
+        if (!props.deadLetterQueue) {
+            return undefined;
+        }
+        const deadLetterQueue = props.deadLetterQueue;
+        deadLetterQueue.addToResourcePolicy(new iam.PolicyStatement({
+            resources: [deadLetterQueue.queueArn],
+            actions: ["sqs:SendMessage"],
+            principals: [new iam.ServicePrincipal("sns.amazonaws.com")],
+            condition: [
+                {
+                    test: "ArnEquals",
+                    variable: "aws:SourceArn",
+                    values: [props.topic.topicArn],
+                },
+            ],
+        }));
+        return deadLetterQueue;
+    }
+    buildDeadLetterConfig(deadLetterQueue) {
+        if (deadLetterQueue) {
+            return JSON.stringify({
+                deadLetterTargetArn: deadLetterQueue.queueArn,
+            });
+        }
+        else {
+            return undefined;
+        }
+    }
+}
+exports.Subscription = Subscription;
+_a = JSII_RTTI_SYMBOL_1;
+Subscription[_a] = { fqn: "terraconstructs.aws.notify.Subscription", version: "0.0.18" };
+/**
+ * The type of subscription, controlling the type of the endpoint parameter.
+ */
+var SubscriptionProtocol;
+(function (SubscriptionProtocol) {
+    /**
+     * JSON-encoded message is POSTED to an HTTP url.
+     */
+    SubscriptionProtocol["HTTP"] = "http";
+    /**
+     * JSON-encoded message is POSTed to an HTTPS url.
+     */
+    SubscriptionProtocol["HTTPS"] = "https";
+    /**
+     * Notifications are sent via email.
+     */
+    SubscriptionProtocol["EMAIL"] = "email";
+    /**
+     * Notifications are JSON-encoded and sent via mail.
+     */
+    SubscriptionProtocol["EMAIL_JSON"] = "email-json";
+    /**
+     * Notification is delivered by SMS
+     */
+    SubscriptionProtocol["SMS"] = "sms";
+    /**
+     * Notifications are enqueued into an SQS queue.
+     */
+    SubscriptionProtocol["SQS"] = "sqs";
+    /**
+     * JSON-encoded notifications are sent to a mobile app endpoint.
+     */
+    SubscriptionProtocol["APPLICATION"] = "application";
+    /**
+     * Notifications trigger a Lambda function.
+     */
+    SubscriptionProtocol["LAMBDA"] = "lambda";
+    /**
+     * Notifications put records into a firehose delivery stream.
+     */
+    SubscriptionProtocol["FIREHOSE"] = "firehose";
+})(SubscriptionProtocol || (exports.SubscriptionProtocol = SubscriptionProtocol = {}));
+function buildFilterPolicyWithMessageBody(scope, inputObject, depth = 1, totalCombinationValues = [1]) {
+    const result = {};
+    for (const [key, filterOrPolicy] of Object.entries(inputObject)) {
+        if (filterOrPolicy.isPolicy()) {
+            result[key] = buildFilterPolicyWithMessageBody(scope, filterOrPolicy.policyDoc, depth + 1, totalCombinationValues);
+        }
+        else if (filterOrPolicy.isFilter()) {
+            const filter = filterOrPolicy.filterDoc.conditions;
+            result[key] = filter;
+            totalCombinationValues[0] *= filter.length * depth;
+        }
+    }
+    // https://docs.aws.amazon.com/sns/latest/dg/subscription-filter-policy-constraints.html
+    if (totalCombinationValues[0] > 150) {
+        throw new Error(`The total combination of values (${totalCombinationValues}) must not exceed 150.`);
+    }
+    return result;
+}
+/**
+ * The type of the MessageBody at a given key value pair
+ */
+var FilterOrPolicyType;
+(function (FilterOrPolicyType) {
+    /**
+     * The filter of the MessageBody
+     */
+    FilterOrPolicyType[FilterOrPolicyType["FILTER"] = 0] = "FILTER";
+    /**
+     * A nested key of the MessageBody
+     */
+    FilterOrPolicyType[FilterOrPolicyType["POLICY"] = 1] = "POLICY";
+})(FilterOrPolicyType || (exports.FilterOrPolicyType = FilterOrPolicyType = {}));
+/**
+ * Class for building the FilterPolicy by avoiding union types
+ */
+class FilterOrPolicy {
+    /**
+     * Filter of MessageBody
+     */
+    static filter(filter) {
+        return new Filter(filter);
+    }
+    /**
+     * Policy of MessageBody
+     */
+    static policy(policy) {
+        return new Policy(policy);
+    }
+    /**
+     * Check if instance is `Policy` type
+     */
+    isPolicy() {
+        return this.type === FilterOrPolicyType.POLICY;
+    }
+    /**
+     * Check if instance is `Filter` type
+     */
+    isFilter() {
+        return this.type === FilterOrPolicyType.FILTER;
+    }
+}
+exports.FilterOrPolicy = FilterOrPolicy;
+_b = JSII_RTTI_SYMBOL_1;
+FilterOrPolicy[_b] = { fqn: "terraconstructs.aws.notify.FilterOrPolicy", version: "0.0.18" };
+/**
+ * Filter implementation of FilterOrPolicy
+ */
+class Filter extends FilterOrPolicy {
+    /**
+     * Policy constructor
+     * @param filterDoc filter argument to construct
+     */
+    constructor(filterDoc) {
+        super();
+        this.filterDoc = filterDoc;
+        /**
+         * Type used in DFS buildFilterPolicyWithMessageBody to determine json value type
+         */
+        this.type = FilterOrPolicyType.FILTER;
+    }
+}
+exports.Filter = Filter;
+_c = JSII_RTTI_SYMBOL_1;
+Filter[_c] = { fqn: "terraconstructs.aws.notify.Filter", version: "0.0.18" };
+/**
+ * Policy Implementation of FilterOrPolicy
+ */
+class Policy extends FilterOrPolicy {
+    /**
+     * Policy constructor
+     * @param policyDoc policy argument to construct
+     */
+    constructor(policyDoc) {
+        super();
+        this.policyDoc = policyDoc;
+        /**
+         * Type used in DFS buildFilterPolicyWithMessageBody to determine json value type
+         */
+        this.type = FilterOrPolicyType.POLICY;
+    }
+}
+exports.Policy = Policy;
+_d = JSII_RTTI_SYMBOL_1;
+Policy[_d] = { fqn: "terraconstructs.aws.notify.Policy", version: "0.0.18" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"subscription.js","sourceRoot":"","sources":["../../../src/aws/notify/subscription.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/6b9e47a1529319561bc1040739fe02bac15895bf/packages/aws-cdk-lib/aws-sns/lib/subscription.ts\n\nimport { snsTopicSubscription } from \"@cdktf/provider-aws\";\nimport { Construct } from \"constructs\";\nimport { DeliveryPolicy } from \"./delivery-policy\";\nimport { SubscriptionFilter } from \"./subscription-filter\";\nimport { ITopic } from \"./topic-base\";\nimport { AwsConstructBase, AwsConstructProps } from \"../aws-construct\";\nimport * as iam from \"../iam\";\nimport * as notify from \"../notify\";\n\n/**\n * Outputs for the Subscription construct.\n */\nexport interface SubscriptionOutputs {\n  /**\n   * The ARN of the subscription.\n   */\n  readonly subscriptionArn: string;\n}\n\n/**\n * Options for creating a new subscription\n */\nexport interface SubscriptionOptions extends AwsConstructProps {\n  /**\n   * What type of subscription to add.\n   */\n  readonly protocol: SubscriptionProtocol;\n\n  /**\n   * The subscription endpoint.\n   *\n   * The meaning of this value depends on the value for 'protocol'.\n   */\n  readonly endpoint: string;\n\n  /**\n   * true if raw message delivery is enabled for the subscription. Raw messages are free of JSON formatting and can be\n   * sent to HTTP/S and Amazon SQS endpoints. For more information, see GetSubscriptionAttributes in the Amazon Simple\n   * Notification Service API Reference.\n   *\n   * @default false\n   */\n  readonly rawMessageDelivery?: boolean;\n\n  /**\n   * The filter policy.\n   *\n   * @default - all messages are delivered\n   */\n  readonly filterPolicy?: { [attribute: string]: SubscriptionFilter };\n\n  /**\n   * The filter policy that is applied on the message body.\n   * To apply a filter policy to the message attributes, use `filterPolicy`. A maximum of one of `filterPolicyWithMessageBody` and `filterPolicy` may be used.\n   *\n   * @default - all messages are delivered\n   */\n  readonly filterPolicyWithMessageBody?: {\n    [attribute: string]: FilterOrPolicy;\n  };\n\n  // TODO: Cross-region subscriptions might require provider aliases in CDKTF.\n  // The sns_topic_subscription resource itself doesn't have a region parameter.\n  // /**\n  //  * The region where the topic resides, in the case of cross-region subscriptions\n  //  * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-sns-subscription.html#cfn-sns-subscription-region\n  //  * @default - the region where the stack is being deployed.\n  //  */\n  // readonly region?: string;\n\n  /**\n   * Queue to be used as dead letter queue.\n   * If not passed no dead letter queue is enabled.\n   *\n   * @default - No dead letter queue enabled.\n   */\n  readonly deadLetterQueue?: notify.IQueue;\n\n  /**\n   * Arn of role allowing access to firehose delivery stream.\n   * Required for a firehose subscription protocol.\n   * @default - No subscription role is provided\n   */\n  readonly subscriptionRoleArn?: string;\n\n  /**\n   * The delivery policy.\n   *\n   * @default - if the initial delivery of the message fails, three retries with a delay between failed attempts set at 20 seconds\n   */\n  readonly deliveryPolicy?: DeliveryPolicy;\n}\n/**\n * Properties for creating a new subscription\n */\nexport interface SubscriptionProps extends SubscriptionOptions {\n  /**\n   * The topic to subscribe to.\n   */\n  readonly topic: ITopic;\n}\n\n/**\n * A new subscription.\n *\n * Prefer to use the `ITopic.addSubscription()` methods to create instances of\n * this class.\n *\n * @resource aws_sns_topic_subscription\n */\nexport class Subscription extends AwsConstructBase {\n  /**\n   * The DLQ associated with this subscription if present.\n   */\n  public readonly deadLetterQueue?: notify.IQueue;\n\n  private readonly resource: snsTopicSubscription.SnsTopicSubscription;\n\n  public readonly subscriptionOutputs: SubscriptionOutputs;\n  public get outputs(): Record<string, any> {\n    return this.subscriptionOutputs;\n  }\n\n  constructor(scope: Construct, id: string, props: SubscriptionProps) {\n    super(scope, id, props);\n\n    if (\n      props.rawMessageDelivery &&\n      [\n        SubscriptionProtocol.HTTP,\n        SubscriptionProtocol.HTTPS,\n        SubscriptionProtocol.SQS,\n        SubscriptionProtocol.FIREHOSE,\n      ].indexOf(props.protocol) < 0\n    ) {\n      // TODO: re-add ValidationError\n      throw new Error(\n        \"Raw message delivery can only be enabled for HTTP, HTTPS, SQS, and Firehose subscriptions.\",\n      );\n    }\n\n    let filterPolicyJson: string | undefined;\n    /** Whether the filter_policy applies to MessageAttributes (default) or MessageBody */\n    let filterPolicyScope: \"MessageAttributes\" | \"MessageBody\" | undefined;\n\n    if (props.filterPolicy && props.filterPolicyWithMessageBody) {\n      throw new Error(\n        \"A maximum of one of `filterPolicyWithMessageBody` and `filterPolicy` may be used.\",\n      );\n    }\n\n    if (props.filterPolicy) {\n      if (Object.keys(props.filterPolicy).length > 5) {\n        throw new Error(\n          \"A filter policy can have a maximum of 5 attribute names.\",\n        );\n      }\n\n      const filterPolicyConditions = Object.entries(props.filterPolicy).reduce(\n        (acc, [k, v]) => ({ ...acc, [k]: v.conditions }),\n        {},\n      );\n\n      let total = 1;\n      Object.values(filterPolicyConditions).forEach((filter: any) => {\n        total *= filter.length;\n      });\n      if (total > 150) {\n        // TODO: re-add ValidationError\n        throw new Error(\n          `The total combination of values (${total}) must not exceed 150.`,\n        );\n      }\n      filterPolicyJson = JSON.stringify(filterPolicyConditions);\n      filterPolicyScope = \"MessageAttributes\"; // Default scope\n    } else if (props.filterPolicyWithMessageBody) {\n      if (Object.keys(props.filterPolicyWithMessageBody).length > 5) {\n        throw new Error(\n          \"A filter policy can have a maximum of 5 attribute names.\",\n        );\n      }\n      const builtPolicy = buildFilterPolicyWithMessageBody(\n        this,\n        props.filterPolicyWithMessageBody,\n      );\n      filterPolicyJson = JSON.stringify(builtPolicy);\n      filterPolicyScope = \"MessageBody\";\n    }\n\n    if (\n      props.protocol === SubscriptionProtocol.FIREHOSE &&\n      !props.subscriptionRoleArn\n    ) {\n      throw new Error(\n        \"Subscription role arn is required field for subscriptions with a firehose protocol.\",\n      );\n    }\n\n    this.deadLetterQueue = this.buildDeadLetterQueue(props);\n    const redrivePolicyJson = this.buildDeadLetterConfig(this.deadLetterQueue);\n    const deliveryPolicyJson = props.deliveryPolicy\n      ? this.renderDeliveryPolicy(props.deliveryPolicy, props.protocol)\n      : undefined;\n\n    this.resource = new snsTopicSubscription.SnsTopicSubscription(\n      this,\n      \"Resource\",\n      {\n        endpoint: props.endpoint,\n        protocol: props.protocol,\n        topicArn: props.topic.topicArn,\n        rawMessageDelivery: props.rawMessageDelivery,\n        filterPolicy: filterPolicyJson,\n        filterPolicyScope: filterPolicyScope,\n        redrivePolicy: redrivePolicyJson,\n        subscriptionRoleArn: props.subscriptionRoleArn,\n        deliveryPolicy: deliveryPolicyJson,\n        // confirmationTimeoutInMinutes: // Not directly available in CDK props\n        // endpointAutoConfirms: // Not directly available in CDK props\n        // replayPolicy: // Not directly available in CDK props (missing in AWS CDK)\n      },\n    );\n\n    this.subscriptionOutputs = {\n      subscriptionArn: this.resource.arn,\n    };\n  }\n\n  private renderDeliveryPolicy(\n    deliveryPolicy: DeliveryPolicy,\n    protocol: SubscriptionProtocol,\n  ): string {\n    // TODO: re-add ValidationError(s)\n    if (\n      ![SubscriptionProtocol.HTTP, SubscriptionProtocol.HTTPS].includes(\n        protocol,\n      )\n    ) {\n      throw new Error(\n        `Delivery policy is only supported for HTTP and HTTPS subscriptions, got: ${protocol}`,\n      );\n    }\n    const { healthyRetryPolicy, throttlePolicy, requestPolicy } =\n      deliveryPolicy;\n    const renderedPolicy: any = {};\n\n    if (healthyRetryPolicy) {\n      const delayTargetLimitSecs = 3600;\n      const minDelayTarget = healthyRetryPolicy.minDelayTarget;\n      const maxDelayTarget = healthyRetryPolicy.maxDelayTarget;\n      if (minDelayTarget !== undefined) {\n        if (minDelayTarget.toMilliseconds() % 1000 !== 0) {\n          throw new Error(\n            `minDelayTarget must be a whole number of seconds, got: ${minDelayTarget}`,\n          );\n        }\n        const minDelayTargetSecs = minDelayTarget.toSeconds();\n        if (\n          minDelayTargetSecs < 1 ||\n          minDelayTargetSecs > delayTargetLimitSecs\n        ) {\n          throw new Error(\n            `minDelayTarget must be between 1 and ${delayTargetLimitSecs} seconds inclusive, got: ${minDelayTargetSecs}s`,\n          );\n        }\n      }\n      if (maxDelayTarget !== undefined) {\n        if (maxDelayTarget.toMilliseconds() % 1000 !== 0) {\n          throw new Error(\n            `maxDelayTarget must be a whole number of seconds, got: ${maxDelayTarget}`,\n          );\n        }\n        const maxDelayTargetSecs = maxDelayTarget.toSeconds();\n        if (\n          maxDelayTargetSecs < 1 ||\n          maxDelayTargetSecs > delayTargetLimitSecs\n        ) {\n          throw new Error(\n            `maxDelayTarget must be between 1 and ${delayTargetLimitSecs} seconds inclusive, got: ${maxDelayTargetSecs}s`,\n          );\n        }\n        if (\n          minDelayTarget !== undefined &&\n          minDelayTarget.toSeconds() > maxDelayTargetSecs\n        ) {\n          throw new Error(\"minDelayTarget must not exceed maxDelayTarget\");\n        }\n      }\n\n      const numRetriesLimit = 100;\n      if (\n        healthyRetryPolicy.numRetries &&\n        (healthyRetryPolicy.numRetries < 0 ||\n          healthyRetryPolicy.numRetries > numRetriesLimit)\n      ) {\n        throw new Error(\n          `numRetries must be between 0 and ${numRetriesLimit} inclusive, got: ${healthyRetryPolicy.numRetries}`,\n        );\n      }\n      const { numNoDelayRetries, numMinDelayRetries, numMaxDelayRetries } =\n        healthyRetryPolicy;\n      if (\n        numNoDelayRetries &&\n        (numNoDelayRetries < 0 || !Number.isInteger(numNoDelayRetries))\n      ) {\n        throw new Error(\n          `numNoDelayRetries must be an integer zero or greater, got: ${numNoDelayRetries}`,\n        );\n      }\n      if (\n        numMinDelayRetries &&\n        (numMinDelayRetries < 0 || !Number.isInteger(numMinDelayRetries))\n      ) {\n        throw new Error(\n          `numMinDelayRetries must be an integer zero or greater, got: ${numMinDelayRetries}`,\n        );\n      }\n      if (\n        numMaxDelayRetries &&\n        (numMaxDelayRetries < 0 || !Number.isInteger(numMaxDelayRetries))\n      ) {\n        throw new Error(\n          `numMaxDelayRetries must be an integer zero or greater, got: ${numMaxDelayRetries}`,\n        );\n      }\n\n      renderedPolicy.healthyRetryPolicy = {\n        minDelayTarget:\n          healthyRetryPolicy.minDelayTarget === undefined\n            ? 20\n            : healthyRetryPolicy.minDelayTarget.toSeconds(),\n        maxDelayTarget:\n          healthyRetryPolicy.maxDelayTarget === undefined\n            ? 20\n            : healthyRetryPolicy.maxDelayTarget.toSeconds(),\n        numRetries:\n          healthyRetryPolicy.numRetries === undefined\n            ? 3\n            : healthyRetryPolicy.numRetries,\n        numNoDelayRetries: healthyRetryPolicy.numNoDelayRetries,\n        numMinDelayRetries: healthyRetryPolicy.numMinDelayRetries,\n        numMaxDelayRetries: healthyRetryPolicy.numMaxDelayRetries,\n        backoffFunction: healthyRetryPolicy.backoffFunction,\n      };\n    }\n\n    if (throttlePolicy) {\n      const maxReceivesPerSecond = throttlePolicy.maxReceivesPerSecond;\n      if (\n        maxReceivesPerSecond !== undefined &&\n        (maxReceivesPerSecond < 1 || !Number.isInteger(maxReceivesPerSecond))\n      ) {\n        throw new Error(\n          `maxReceivesPerSecond must be an integer greater than zero, got: ${maxReceivesPerSecond}`,\n        );\n      }\n      renderedPolicy.throttlePolicy = {\n        maxReceivesPerSecond: throttlePolicy.maxReceivesPerSecond,\n      };\n    }\n\n    if (requestPolicy) {\n      renderedPolicy.requestPolicy = {\n        headerContentType: requestPolicy.headerContentType,\n      };\n    }\n\n    return JSON.stringify(renderedPolicy);\n  }\n\n  private buildDeadLetterQueue(\n    props: SubscriptionProps,\n  ): notify.IQueue | undefined {\n    if (!props.deadLetterQueue) {\n      return undefined;\n    }\n\n    const deadLetterQueue = props.deadLetterQueue;\n\n    deadLetterQueue.addToResourcePolicy(\n      new iam.PolicyStatement({\n        resources: [deadLetterQueue.queueArn],\n        actions: [\"sqs:SendMessage\"],\n        principals: [new iam.ServicePrincipal(\"sns.amazonaws.com\")],\n        condition: [\n          {\n            test: \"ArnEquals\",\n            variable: \"aws:SourceArn\",\n            values: [props.topic.topicArn],\n          },\n        ],\n      }),\n    );\n\n    return deadLetterQueue;\n  }\n\n  private buildDeadLetterConfig(\n    deadLetterQueue?: notify.IQueue,\n  ): string | undefined {\n    if (deadLetterQueue) {\n      return JSON.stringify({\n        deadLetterTargetArn: deadLetterQueue.queueArn,\n      });\n    } else {\n      return undefined;\n    }\n  }\n}\n\n/**\n * The type of subscription, controlling the type of the endpoint parameter.\n */\nexport enum SubscriptionProtocol {\n  /**\n   * JSON-encoded message is POSTED to an HTTP url.\n   */\n  HTTP = \"http\",\n\n  /**\n   * JSON-encoded message is POSTed to an HTTPS url.\n   */\n  HTTPS = \"https\",\n\n  /**\n   * Notifications are sent via email.\n   */\n  EMAIL = \"email\",\n\n  /**\n   * Notifications are JSON-encoded and sent via mail.\n   */\n  EMAIL_JSON = \"email-json\",\n\n  /**\n   * Notification is delivered by SMS\n   */\n  SMS = \"sms\",\n\n  /**\n   * Notifications are enqueued into an SQS queue.\n   */\n  SQS = \"sqs\",\n\n  /**\n   * JSON-encoded notifications are sent to a mobile app endpoint.\n   */\n  APPLICATION = \"application\",\n\n  /**\n   * Notifications trigger a Lambda function.\n   */\n  LAMBDA = \"lambda\",\n\n  /**\n   * Notifications put records into a firehose delivery stream.\n   */\n  FIREHOSE = \"firehose\",\n}\n\nfunction buildFilterPolicyWithMessageBody(\n  scope: Construct,\n  inputObject: { [key: string]: FilterOrPolicy },\n  depth = 1,\n  totalCombinationValues = [1],\n): { [key: string]: any } {\n  const result: { [key: string]: any } = {};\n\n  for (const [key, filterOrPolicy] of Object.entries(inputObject)) {\n    if (filterOrPolicy.isPolicy()) {\n      result[key] = buildFilterPolicyWithMessageBody(\n        scope,\n        filterOrPolicy.policyDoc,\n        depth + 1,\n        totalCombinationValues,\n      );\n    } else if (filterOrPolicy.isFilter()) {\n      const filter = filterOrPolicy.filterDoc.conditions;\n      result[key] = filter;\n      totalCombinationValues[0] *= filter.length * depth;\n    }\n  }\n\n  // https://docs.aws.amazon.com/sns/latest/dg/subscription-filter-policy-constraints.html\n  if (totalCombinationValues[0] > 150) {\n    throw new Error(\n      `The total combination of values (${totalCombinationValues}) must not exceed 150.`,\n    );\n  }\n\n  return result;\n}\n\n/**\n * The type of the MessageBody at a given key value pair\n */\nexport enum FilterOrPolicyType {\n  /**\n   * The filter of the MessageBody\n   */\n  FILTER,\n  /**\n   * A nested key of the MessageBody\n   */\n  POLICY,\n}\n\n/**\n * Class for building the FilterPolicy by avoiding union types\n */\nexport abstract class FilterOrPolicy {\n  /**\n   * Filter of MessageBody\n   */\n  public static filter(filter: SubscriptionFilter) {\n    return new Filter(filter);\n  }\n\n  /**\n   * Policy of MessageBody\n   */\n  public static policy(policy: { [attribute: string]: FilterOrPolicy }) {\n    return new Policy(policy);\n  }\n\n  /**\n   * Type switch for disambiguating between subclasses\n   */\n  abstract readonly type: FilterOrPolicyType;\n\n  /**\n   * Check if instance is `Policy` type\n   */\n  public isPolicy(): this is Policy {\n    return this.type === FilterOrPolicyType.POLICY;\n  }\n\n  /**\n   * Check if instance is `Filter` type\n   */\n  public isFilter(): this is Filter {\n    return this.type === FilterOrPolicyType.FILTER;\n  }\n}\n\n/**\n * Filter implementation of FilterOrPolicy\n */\nexport class Filter extends FilterOrPolicy {\n  /**\n   * Type used in DFS buildFilterPolicyWithMessageBody to determine json value type\n   */\n  public readonly type = FilterOrPolicyType.FILTER;\n  /**\n   * Policy constructor\n   * @param filterDoc filter argument to construct\n   */\n  public constructor(public readonly filterDoc: SubscriptionFilter) {\n    super();\n  }\n}\n\n/**\n * Policy Implementation of FilterOrPolicy\n */\nexport class Policy extends FilterOrPolicy {\n  /**\n   * Type used in DFS buildFilterPolicyWithMessageBody to determine json value type\n   */\n  public readonly type = FilterOrPolicyType.POLICY;\n  /**\n   * Policy constructor\n   * @param policyDoc policy argument to construct\n   */\n  public constructor(\n    public readonly policyDoc: { [attribute: string]: FilterOrPolicy },\n  ) {\n    super();\n  }\n}\n"]}

package/lib/aws/notify/targets/event-bus.js

@@ -36,5 +36,5 @@ class EventBus {
 }
 exports.EventBus = EventBus;
 _a = JSII_RTTI_SYMBOL_1;
-EventBus[_a] = { fqn: "terraconstructs.aws.notify.targets.EventBus", version: "0.0.17" };
+EventBus[_a] = { fqn: "terraconstructs.aws.notify.targets.EventBus", version: "0.0.18" };
 //# sourceMappingURL=data:application/json;base64,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