terraconstructs 0.0.17 → 0.0.19

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

@@ -0,0 +1,129 @@
+/**
+ * Conditions that can be applied to string attributes.
+ */
+export interface StringConditions {
+    /**
+     * Match one or more values.
+     *
+     * @deprecated use `allowlist`
+     * @default - None
+     */
+    readonly whitelist?: string[];
+    /**
+     * Match any value that doesn't include any of the specified values.
+     * @deprecated use `denylist`
+     * @default - None
+     */
+    readonly blacklist?: string[];
+    /**
+     * Match one or more values.
+     * @default - None
+     */
+    readonly allowlist?: string[];
+    /**
+     * Match any value that doesn't include any of the specified values.
+     * @default - None
+     */
+    readonly denylist?: string[];
+    /**
+     * Matches values that begins with the specified prefixes.
+     *
+     * @default - None
+     */
+    readonly matchPrefixes?: string[];
+    /**
+     * Matches values that end with the specified suffixes.
+     *
+     * @default - None
+     */
+    readonly matchSuffixes?: string[];
+}
+/**
+ * Between condition for a numeric attribute.
+ */
+export interface BetweenCondition {
+    /**
+     * The start value.
+     */
+    readonly start: number;
+    /**
+     * The stop value.
+     */
+    readonly stop: number;
+}
+/**
+ * Conditions that can be applied to numeric attributes.
+ */
+export interface NumericConditions {
+    /**
+     * Match one or more values.
+     * @deprecated use `allowlist`
+     * @default - None
+     */
+    readonly whitelist?: number[];
+    /**
+     * Match one or more values.
+     *
+     * @default - None
+     */
+    readonly allowlist?: number[];
+    /**
+     * Match values that are greater than the specified value.
+     *
+     * @default - None
+     */
+    readonly greaterThan?: number;
+    /**
+     * Match values that are greater than or equal to the specified value.
+     *
+     * @default - None
+     */
+    readonly greaterThanOrEqualTo?: number;
+    /**
+     * Match values that are less than the specified value.
+     *
+     * @default - None
+     */
+    readonly lessThan?: number;
+    /**
+     * Match values that are less than or equal to the specified value.
+     *
+     * @default - None
+     */
+    readonly lessThanOrEqualTo?: number;
+    /**
+     * Match values that are between the specified values.
+     *
+     * @default - None
+     */
+    readonly between?: BetweenCondition;
+    /**
+     * Match values that are strictly between the specified values.
+     *
+     * @default - None
+     */
+    readonly betweenStrict?: BetweenCondition;
+}
+/**
+ * A subscription filter for an attribute.
+ */
+export declare class SubscriptionFilter {
+    readonly conditions: any[];
+    /**
+     * Returns a subscription filter for a string attribute.
+     */
+    static stringFilter(stringConditions: StringConditions): SubscriptionFilter;
+    /**
+     * Returns a subscription filter for a numeric attribute.
+     */
+    static numericFilter(numericConditions: NumericConditions): SubscriptionFilter;
+    /**
+     * Returns a subscription filter for attribute key matching.
+     */
+    static existsFilter(): SubscriptionFilter;
+    /**
+     *
+     * @param conditions conditions that specify the message attributes that should be included, excluded, matched, etc.
+     */
+    constructor(conditions?: any[]);
+}

package/lib/aws/notify/subscription-filter.js

@@ -0,0 +1,105 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptionFilter = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * A subscription filter for an attribute.
+ */
+class SubscriptionFilter {
+    /**
+     * Returns a subscription filter for a string attribute.
+     */
+    static stringFilter(stringConditions) {
+        const conditions = new Array();
+        if (stringConditions.whitelist && stringConditions.allowlist) {
+            // TODO: Adopt UnscopedValidationError
+            throw new Error("`whitelist` is deprecated; please use `allowlist` instead");
+        }
+        if (stringConditions.blacklist && stringConditions.denylist) {
+            // TODO: Adopt UnscopedValidationError
+            throw new Error("`blacklist` is deprecated; please use `denylist` instead");
+        }
+        const allowlist = stringConditions.allowlist ?? stringConditions.whitelist;
+        const denylist = stringConditions.denylist ?? stringConditions.blacklist;
+        if (allowlist) {
+            conditions.push(...allowlist);
+        }
+        if (denylist) {
+            conditions.push({ "anything-but": denylist });
+        }
+        if (stringConditions.matchPrefixes) {
+            conditions.push(...stringConditions.matchPrefixes.map((p) => ({ prefix: p })));
+        }
+        if (stringConditions.matchSuffixes) {
+            conditions.push(...stringConditions.matchSuffixes.map((s) => ({ suffix: s })));
+        }
+        return new SubscriptionFilter(conditions);
+    }
+    /**
+     * Returns a subscription filter for a numeric attribute.
+     */
+    static numericFilter(numericConditions) {
+        const conditions = new Array();
+        if (numericConditions.whitelist && numericConditions.allowlist) {
+            // TODO: Adopt UnscopedValidationError
+            throw new Error("`whitelist` is deprecated; please use `allowlist` instead");
+        }
+        const allowlist = numericConditions.allowlist ?? numericConditions.whitelist;
+        if (allowlist) {
+            conditions.push(...allowlist.map((v) => ({ numeric: ["=", v] })));
+        }
+        if (numericConditions.greaterThan !== undefined) {
+            conditions.push({ numeric: [">", numericConditions.greaterThan] });
+        }
+        if (numericConditions.greaterThanOrEqualTo !== undefined) {
+            conditions.push({
+                numeric: [">=", numericConditions.greaterThanOrEqualTo],
+            });
+        }
+        if (numericConditions.lessThan !== undefined) {
+            conditions.push({ numeric: ["<", numericConditions.lessThan] });
+        }
+        if (numericConditions.lessThanOrEqualTo !== undefined) {
+            conditions.push({ numeric: ["<=", numericConditions.lessThanOrEqualTo] });
+        }
+        if (numericConditions.between) {
+            conditions.push({
+                numeric: [
+                    ">=",
+                    numericConditions.between.start,
+                    "<=",
+                    numericConditions.between.stop,
+                ],
+            });
+        }
+        if (numericConditions.betweenStrict) {
+            conditions.push({
+                numeric: [
+                    ">",
+                    numericConditions.betweenStrict.start,
+                    "<",
+                    numericConditions.betweenStrict.stop,
+                ],
+            });
+        }
+        return new SubscriptionFilter(conditions);
+    }
+    /**
+     * Returns a subscription filter for attribute key matching.
+     */
+    static existsFilter() {
+        return new SubscriptionFilter([{ exists: true }]);
+    }
+    /**
+     *
+     * @param conditions conditions that specify the message attributes that should be included, excluded, matched, etc.
+     */
+    constructor(conditions = []) {
+        this.conditions = conditions;
+    }
+}
+exports.SubscriptionFilter = SubscriptionFilter;
+_a = JSII_RTTI_SYMBOL_1;
+SubscriptionFilter[_a] = { fqn: "terraconstructs.aws.notify.SubscriptionFilter", version: "0.0.19" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"subscription-filter.js","sourceRoot":"","sources":["../../../src/aws/notify/subscription-filter.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/7452462550a100f5bd2dcab6f495c9f68bf0db4a/packages/aws-cdk-lib/aws-sns/lib/subscription-filter.ts\n\n// TODO: Adopt UnscopedValidationError\n// - https://github.com/aws/aws-cdk/pull/33382/\n// - https://github.com/aws/aws-cdk/pull/33045\n// import { UnscopedValidationError } from \"../../core/lib/errors\";\n\n/**\n * Conditions that can be applied to string attributes.\n */\nexport interface StringConditions {\n  /**\n   * Match one or more values.\n   *\n   * @deprecated use `allowlist`\n   * @default - None\n   */\n  readonly whitelist?: string[];\n\n  /**\n   * Match any value that doesn't include any of the specified values.\n   * @deprecated use `denylist`\n   * @default - None\n   */\n  readonly blacklist?: string[];\n\n  /**\n   * Match one or more values.\n   * @default - None\n   */\n  readonly allowlist?: string[];\n\n  /**\n   * Match any value that doesn't include any of the specified values.\n   * @default - None\n   */\n  readonly denylist?: string[];\n\n  /**\n   * Matches values that begins with the specified prefixes.\n   *\n   * @default - None\n   */\n  readonly matchPrefixes?: string[];\n\n  /**\n   * Matches values that end with the specified suffixes.\n   *\n   * @default - None\n   */\n  readonly matchSuffixes?: string[];\n}\n\n/**\n * Between condition for a numeric attribute.\n */\nexport interface BetweenCondition {\n  /**\n   * The start value.\n   */\n  readonly start: number;\n\n  /**\n   * The stop value.\n   */\n  readonly stop: number;\n}\n\n/**\n * Conditions that can be applied to numeric attributes.\n */\nexport interface NumericConditions {\n  /**\n   * Match one or more values.\n   * @deprecated use `allowlist`\n   * @default - None\n   */\n  readonly whitelist?: number[];\n\n  /**\n   * Match one or more values.\n   *\n   * @default - None\n   */\n  readonly allowlist?: number[];\n\n  /**\n   * Match values that are greater than the specified value.\n   *\n   * @default - None\n   */\n  readonly greaterThan?: number;\n\n  /**\n   * Match values that are greater than or equal to the specified value.\n   *\n   * @default - None\n   */\n  readonly greaterThanOrEqualTo?: number;\n\n  /**\n   * Match values that are less than the specified value.\n   *\n   * @default - None\n   */\n  readonly lessThan?: number;\n\n  /**\n   * Match values that are less than or equal to the specified value.\n   *\n   * @default - None\n   */\n  readonly lessThanOrEqualTo?: number;\n\n  /**\n   * Match values that are between the specified values.\n   *\n   * @default - None\n   */\n  readonly between?: BetweenCondition;\n\n  /**\n   * Match values that are strictly between the specified values.\n   *\n   * @default - None\n   */\n  readonly betweenStrict?: BetweenCondition;\n}\n\n/**\n * A subscription filter for an attribute.\n */\nexport class SubscriptionFilter {\n  /**\n   * Returns a subscription filter for a string attribute.\n   */\n  public static stringFilter(stringConditions: StringConditions) {\n    const conditions = new Array<any>();\n\n    if (stringConditions.whitelist && stringConditions.allowlist) {\n      // TODO: Adopt UnscopedValidationError\n      throw new Error(\n        \"`whitelist` is deprecated; please use `allowlist` instead\",\n      );\n    }\n    if (stringConditions.blacklist && stringConditions.denylist) {\n      // TODO: Adopt UnscopedValidationError\n      throw new Error(\n        \"`blacklist` is deprecated; please use `denylist` instead\",\n      );\n    }\n    const allowlist = stringConditions.allowlist ?? stringConditions.whitelist;\n    const denylist = stringConditions.denylist ?? stringConditions.blacklist;\n\n    if (allowlist) {\n      conditions.push(...allowlist);\n    }\n\n    if (denylist) {\n      conditions.push({ \"anything-but\": denylist });\n    }\n\n    if (stringConditions.matchPrefixes) {\n      conditions.push(\n        ...stringConditions.matchPrefixes.map((p) => ({ prefix: p })),\n      );\n    }\n\n    if (stringConditions.matchSuffixes) {\n      conditions.push(\n        ...stringConditions.matchSuffixes.map((s) => ({ suffix: s })),\n      );\n    }\n\n    return new SubscriptionFilter(conditions);\n  }\n\n  /**\n   * Returns a subscription filter for a numeric attribute.\n   */\n  public static numericFilter(numericConditions: NumericConditions) {\n    const conditions = new Array<any>();\n\n    if (numericConditions.whitelist && numericConditions.allowlist) {\n      // TODO: Adopt UnscopedValidationError\n      throw new Error(\n        \"`whitelist` is deprecated; please use `allowlist` instead\",\n      );\n    }\n    const allowlist =\n      numericConditions.allowlist ?? numericConditions.whitelist;\n\n    if (allowlist) {\n      conditions.push(...allowlist.map((v) => ({ numeric: [\"=\", v] })));\n    }\n\n    if (numericConditions.greaterThan !== undefined) {\n      conditions.push({ numeric: [\">\", numericConditions.greaterThan] });\n    }\n\n    if (numericConditions.greaterThanOrEqualTo !== undefined) {\n      conditions.push({\n        numeric: [\">=\", numericConditions.greaterThanOrEqualTo],\n      });\n    }\n\n    if (numericConditions.lessThan !== undefined) {\n      conditions.push({ numeric: [\"<\", numericConditions.lessThan] });\n    }\n\n    if (numericConditions.lessThanOrEqualTo !== undefined) {\n      conditions.push({ numeric: [\"<=\", numericConditions.lessThanOrEqualTo] });\n    }\n\n    if (numericConditions.between) {\n      conditions.push({\n        numeric: [\n          \">=\",\n          numericConditions.between.start,\n          \"<=\",\n          numericConditions.between.stop,\n        ],\n      });\n    }\n\n    if (numericConditions.betweenStrict) {\n      conditions.push({\n        numeric: [\n          \">\",\n          numericConditions.betweenStrict.start,\n          \"<\",\n          numericConditions.betweenStrict.stop,\n        ],\n      });\n    }\n\n    return new SubscriptionFilter(conditions);\n  }\n\n  /**\n   * Returns a subscription filter for attribute key matching.\n   */\n  public static existsFilter() {\n    return new SubscriptionFilter([{ exists: true }]);\n  }\n\n  /**\n   *\n   * @param conditions conditions that specify the message attributes that should be included, excluded, matched, etc.\n   */\n  constructor(public readonly conditions: any[] = []) {}\n}\n"]}

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;
+    });
+}