terraconstructs 0.0.17 → 0.0.18

package/lib/aws/notify/targets/function.js

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

package/lib/aws/notify/targets/log-group.js

@@ -30,7 +30,7 @@ class LogGroupTargetInput {
 }
 exports.LogGroupTargetInput = LogGroupTargetInput;
 _a = JSII_RTTI_SYMBOL_1;
-LogGroupTargetInput[_a] = { fqn: "terraconstructs.aws.notify.targets.LogGroupTargetInput", version: "0.0.17" };
+LogGroupTargetInput[_a] = { fqn: "terraconstructs.aws.notify.targets.LogGroupTargetInput", version: "0.0.18" };
 /**
  * Use an AWS CloudWatch LogGroup as an event rule target.
  */
@@ -106,5 +106,5 @@ class CloudWatchLogGroup {
 }
 exports.CloudWatchLogGroup = CloudWatchLogGroup;
 _b = JSII_RTTI_SYMBOL_1;
-CloudWatchLogGroup[_b] = { fqn: "terraconstructs.aws.notify.targets.CloudWatchLogGroup", version: "0.0.17" };
+CloudWatchLogGroup[_b] = { fqn: "terraconstructs.aws.notify.targets.CloudWatchLogGroup", version: "0.0.18" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"log-group.js","sourceRoot":"","sources":["../../../../src/aws/notify/targets/log-group.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  RuleTargetInputProperties,\n  RuleTargetInput,\n  EventField,\n} from \"../input\";\nimport { IRule } from \"../rule\";\nimport { IRuleTarget, RuleTargetConfig } from \"../target\";\n// Custom Resource no longer needed\n// logGroup ResourcePolicy was added to CFN - https://github.com/aws/aws-cdk/pull/17015/files\n// import { LogGroupResourcePolicy } from \"./log-group-resource-policy\";\nimport { TargetBaseProps, bindBaseTargetConfig } from \"./util\";\nimport { ArnFormat } from \"../../arn\";\nimport { AwsStack } from \"../../aws-stack\";\nimport * as logs from \"../../cloudwatch\";\nimport * as iam from \"../../iam\";\n\n/**\n * Options used when creating a target input template\n */\nexport interface LogGroupTargetInputOptions {\n  /**\n   * The timestamp that will appear in the CloudWatch Logs record\n   *\n   * @default EventField.time\n   */\n  readonly timestamp?: any;\n\n  /**\n   * The value provided here will be used in the Log \"message\" field.\n   *\n   * This field must be a string. If an object is passed (e.g. JSON data)\n   * it will not throw an error, but the message that makes it to\n   * CloudWatch logs will be incorrect. This is a likely scenario if\n   * doing something like: EventField.fromPath('$.detail') since in most cases\n   * the `detail` field contains JSON data.\n   *\n   * @default EventField.detailType\n   */\n  readonly message?: any;\n}\n\n/**\n * The input to send to the CloudWatch LogGroup target\n */\nexport abstract class LogGroupTargetInput {\n  /**\n   * Pass a JSON object to the the log group event target\n   *\n   * May contain strings returned by `EventField.from()` to substitute in parts of the\n   * matched event.\n   */\n  public static fromObject(\n    options?: LogGroupTargetInputOptions,\n  ): RuleTargetInput {\n    return RuleTargetInput.fromObject({\n      timestamp: options?.timestamp ?? EventField.time,\n      message: options?.message ?? EventField.detailType,\n    });\n  }\n\n  /**\n   * Return the input properties for this input object\n   */\n  public abstract bind(rule: IRule): RuleTargetInputProperties;\n}\n\n/**\n * Customize the CloudWatch LogGroup Event Target\n */\nexport interface LogGroupProps extends TargetBaseProps {\n  /**\n   * The event to send to the CloudWatch LogGroup\n   *\n   * This will be the event logged into the CloudWatch LogGroup\n   *\n   * @default - the entire EventBridge event\n   * @deprecated use logEvent instead\n   */\n  readonly event?: RuleTargetInput;\n\n  /**\n   * The event to send to the CloudWatch LogGroup\n   *\n   * This will be the event logged into the CloudWatch LogGroup\n   *\n   * @default - the entire EventBridge event\n   */\n  readonly logEvent?: LogGroupTargetInput;\n}\n\n/**\n * Use an AWS CloudWatch LogGroup as an event rule target.\n */\nexport class CloudWatchLogGroup implements IRuleTarget {\n  private target?: RuleTargetInputProperties;\n  constructor(\n    private readonly logGroup: logs.ILogGroup,\n    private readonly props: LogGroupProps = {},\n  ) {}\n\n  /**\n   * Returns a RuleTarget that can be used to log an event into a CloudWatch LogGroup\n   */\n  public bind(_rule: IRule, _id?: string): RuleTargetConfig {\n    const logGroupStack = AwsStack.ofAwsConstruct(this.logGroup);\n    if (this.props.event && this.props.logEvent) {\n      throw new Error('Only one of \"event\" or \"logEvent\" can be specified');\n    }\n\n    this.target = this.props.event?.bind(_rule);\n    if (this.target?.inputPath || this.target?.input) {\n      throw new Error(\n        \"CloudWatchLogGroup targets does not support input or inputPath\",\n      );\n    }\n\n    this.logGroup.grantWrite(new iam.ServicePrincipal(\"events.amazonaws.com\"));\n    _rule.node.addValidation({ validate: () => this.validateInputTemplate() });\n\n    return {\n      ...bindBaseTargetConfig(this.props),\n      arn: logGroupStack.formatArn({\n        service: \"logs\",\n        resource: \"log-group\",\n        arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n        resourceName: this.logGroup.logGroupName,\n      }),\n      input: this.props.event ?? this.props.logEvent,\n      targetResource: this.logGroup,\n    };\n  }\n\n  /**\n   * Validate that the target event input template has the correct format.\n   * The CloudWatchLogs target only supports a template with the format of:\n   *   {\"timestamp\": <time>, \"message\": <message>}\n   *\n   * This is only needed if the deprecated `event` property is used.\n   *\n   * @see https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutTargets.html\n   */\n  private validateInputTemplate(): string[] {\n    if (this.target?.inputTemplate) {\n      const resolvedTemplate = AwsStack.ofAwsConstruct(this.logGroup).resolve(\n        this.target.inputTemplate,\n      );\n      if (typeof resolvedTemplate === \"string\") {\n        // need to add the quotes back to the string so that we can parse the json\n        // '{\"timestamp\": <time>}' -> '{\"timestamp\": \"<time>\"}'\n        const quotedTemplate = resolvedTemplate.replace(\n          new RegExp(\"(<[^<>]*?>)\", \"g\"),\n          '\"$1\"',\n        );\n        try {\n          const inputTemplate = JSON.parse(quotedTemplate);\n          const inputTemplateKeys = Object.keys(inputTemplate);\n          if (\n            inputTemplateKeys.length !== 2 ||\n            !inputTemplateKeys.includes(\"timestamp\") ||\n            !inputTemplateKeys.includes(\"message\")\n          ) {\n            return [\n              \"CloudWatchLogGroup targets only support input templates in the format {timestamp: <timestamp>, message: <message>}\",\n            ];\n          }\n        } catch (e: any) {\n          return [\n            \"Could not parse input template as JSON.\\n\" +\n              \"CloudWatchLogGroup targets only support input templates in the format {timestamp: <timestamp>, message: <message>}\",\n            e,\n          ];\n        }\n      }\n    }\n    return [];\n  }\n}\n"]}

package/lib/aws/notify/targets/sqs.js

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

package/lib/aws/notify/targets/state-machine.js

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

package/lib/aws/notify/topic-base.d.ts

@@ -0,0 +1,155 @@
+import * as constructs from "constructs";
+import { Construct } from "constructs";
+import { INotificationRuleTarget, NotificationRuleTargetConfig } from "./notification-rule-target";
+import { ITopicSubscription } from "./subscriber";
+import { Subscription } from "./subscription";
+import { IAwsConstruct, AwsConstructBase, AwsConstructProps } from "../aws-construct";
+import { IKey } from "../encryption";
+import * as iam from "../iam";
+/**
+ * Outputs for the Subscription construct.
+ */
+export interface TopicOutputs {
+    /**
+     * The ARN of the topic
+     *
+     * @attribute
+     */
+    readonly topicArn: string;
+    /**
+     * The name of the topic
+     *
+     * @attribute
+     */
+    readonly topicName: string;
+}
+/**
+ * Represents an SNS topic
+ */
+export interface ITopic extends IAwsConstruct, INotificationRuleTarget {
+    /**
+     * strongly typed outputs for the topic
+     */
+    readonly topicOutputs: TopicOutputs;
+    /**
+     * The ARN of the topic
+     *
+     * @attribute
+     */
+    readonly topicArn: string;
+    /**
+     * The name of the topic
+     *
+     * @attribute
+     */
+    readonly topicName: string;
+    /**
+     * A KMS Key, either managed by this CDK app, or imported.
+     *
+     * This property applies only to server-side encryption.
+     *
+     * @see https://docs.aws.amazon.com/sns/latest/dg/sns-server-side-encryption.html
+     *
+     * @default None
+     */
+    readonly masterKey?: IKey;
+    /**
+     * Enables content-based deduplication for FIFO topics.
+     *
+     * @attribute
+     */
+    readonly contentBasedDeduplication: boolean;
+    /**
+     * Whether this topic is an Amazon SNS FIFO queue. If false, this is a standard topic.
+     *
+     * @attribute
+     */
+    readonly fifo: boolean;
+    /**
+     * Subscribe some endpoint to this topic
+     */
+    addSubscription(subscription: ITopicSubscription): Subscription;
+    /**
+     * Adds a statement to the IAM resource policy associated with this topic.
+     *
+     * If this topic was created in this stack (`new Topic`), a topic policy
+     * will be automatically created upon the first call to `addToResourcePolicy`. If
+     * the topic is imported (`Topic.import`), then this is a no-op.
+     */
+    addToResourcePolicy(statement: iam.PolicyStatement): iam.AddToResourcePolicyResult;
+    /**
+     * Grant topic publishing permissions to the given identity
+     */
+    grantPublish(identity: iam.IGrantable): iam.Grant;
+    /**
+     * Grant topic subscribing permissions to the given identity
+     */
+    grantSubscribe(identity: iam.IGrantable): iam.Grant;
+}
+/**
+ * Either a new or imported Topic
+ */
+export declare abstract class TopicBase extends AwsConstructBase implements ITopic {
+    get topicOutputs(): TopicOutputs;
+    get outputs(): Record<string, any>;
+    abstract readonly topicArn: string;
+    abstract readonly topicName: string;
+    abstract readonly masterKey?: IKey;
+    abstract readonly fifo: boolean;
+    abstract readonly contentBasedDeduplication: boolean;
+    /**
+     * Controls automatic creation of policy objects.
+     *
+     * Set by subclasses.
+     */
+    protected abstract readonly autoCreatePolicy: boolean;
+    /**
+     * Adds a statement to enforce encryption of data in transit when publishing to the topic.
+     */
+    protected enforceSSL?: boolean;
+    private policy?;
+    constructor(scope: Construct, id: string, props?: AwsConstructProps);
+    /**
+     * Subscribe some endpoint to this topic
+     */
+    addSubscription(topicSubscription: ITopicSubscription): Subscription;
+    /**
+     * Adds a statement to the IAM resource policy associated with this topic.
+     *
+     * If this topic was created in this stack (`new Topic`), a topic policy
+     * will be automatically created upon the first call to `addToResourcePolicy`.
+     * However, if `enforceSSL` is set to `true`, the policy has already been created
+     * before the first call to this method.
+     *
+     * If the topic is imported (`Topic.import`), then this is a no-op.
+     */
+    addToResourcePolicy(statement: iam.PolicyStatement): iam.AddToResourcePolicyResult;
+    /**
+     * Adds a SSL policy to the topic resource policy.
+     */
+    protected addSSLPolicy(): void;
+    /**
+     * Creates a topic policy for this topic.
+     */
+    protected createTopicPolicy(): void;
+    /**
+     * Adds a statement to enforce encryption of data in transit when publishing to the topic.
+     *
+     * For more information, see https://docs.aws.amazon.com/sns/latest/dg/sns-security-best-practices.html#enforce-encryption-data-in-transit.
+     */
+    protected createSSLPolicyDocument(): iam.PolicyStatement;
+    /**
+     * Grant topic publishing permissions to the given identity
+     */
+    grantPublish(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * Grant topic subscribing permissions to the given identity
+     */
+    grantSubscribe(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * Represents a notification target
+     * That allows SNS topic to associate with this rule target.
+     */
+    bindAsNotificationRuleTarget(_scope: constructs.Construct): NotificationRuleTargetConfig;
+    private nextTokenId;
+}

package/lib/aws/notify/topic-base.js

@@ -0,0 +1,175 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopicBase = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/f1c092634a391b0b7aed0f75626dd6d0ffd56564/packages/aws-cdk-lib/aws-sns/lib/topic-base.ts
+const cdktf_1 = require("cdktf");
+const policy_1 = require("./policy");
+const subscription_1 = require("./subscription");
+const aws_construct_1 = require("../aws-construct");
+const iam = require("../iam");
+/**
+ * Either a new or imported Topic
+ */
+class TopicBase extends aws_construct_1.AwsConstructBase {
+    get topicOutputs() {
+        return {
+            topicArn: this.topicArn,
+            topicName: this.topicName,
+        };
+    }
+    get outputs() {
+        return this.topicOutputs;
+    }
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        this.node.addValidation({
+            validate: () => this.policy?.document.validateForResourcePolicy() ?? [],
+        });
+    }
+    /**
+     * Subscribe some endpoint to this topic
+     */
+    addSubscription(topicSubscription) {
+        const subscriptionConfig = topicSubscription.bind(this);
+        const scope = subscriptionConfig.subscriberScope || this;
+        let id = subscriptionConfig.subscriberId;
+        if (cdktf_1.Token.isUnresolved(subscriptionConfig.subscriberId)) {
+            id = this.nextTokenId(scope);
+        }
+        // We use the subscriber's id as the construct id. There's no meaning
+        // to subscribing the same subscriber twice on the same topic.
+        if (scope.node.tryFindChild(id)) {
+            // TODO: Adopt ValidationError
+            throw new Error(`A subscription with id "${id}" already exists under the scope ${scope.node.path}`);
+        }
+        const subscription = new subscription_1.Subscription(scope, id, {
+            topic: this,
+            ...subscriptionConfig,
+        });
+        // Add dependency for the subscription, for example for SQS subscription
+        // the queue policy has to deploy before the subscription is created
+        if (subscriptionConfig.subscriptionDependency) {
+            subscription.node.addDependency(subscriptionConfig.subscriptionDependency);
+        }
+        return subscription;
+    }
+    /**
+     * Adds a statement to the IAM resource policy associated with this topic.
+     *
+     * If this topic was created in this stack (`new Topic`), a topic policy
+     * will be automatically created upon the first call to `addToResourcePolicy`.
+     * However, if `enforceSSL` is set to `true`, the policy has already been created
+     * before the first call to this method.
+     *
+     * If the topic is imported (`Topic.import`), then this is a no-op.
+     */
+    addToResourcePolicy(statement) {
+        this.createTopicPolicy();
+        if (this.policy) {
+            this.policy.document.addStatements(statement);
+            return { statementAdded: true, policyDependable: this.policy };
+        }
+        return { statementAdded: false };
+    }
+    /**
+     * Adds a SSL policy to the topic resource policy.
+     */
+    addSSLPolicy() {
+        this.createTopicPolicy();
+        if (this.policy) {
+            this.policy.document.addStatements(this.createSSLPolicyDocument());
+        }
+    }
+    /**
+     * Creates a topic policy for this topic.
+     */
+    createTopicPolicy() {
+        if (!this.policy && this.autoCreatePolicy) {
+            this.policy = new policy_1.TopicPolicy(this, "Policy", { topics: [this] });
+        }
+    }
+    /**
+     * Adds a statement to enforce encryption of data in transit when publishing to the topic.
+     *
+     * For more information, see https://docs.aws.amazon.com/sns/latest/dg/sns-security-best-practices.html#enforce-encryption-data-in-transit.
+     */
+    createSSLPolicyDocument() {
+        return new iam.PolicyStatement({
+            sid: "AllowPublishThroughSSLOnly",
+            actions: ["sns:Publish"],
+            effect: iam.Effect.DENY,
+            resources: [this.topicArn],
+            condition: [
+                {
+                    test: "Bool",
+                    values: ["false"],
+                    variable: "aws:SecureTransport",
+                },
+            ],
+            principals: [new iam.StarPrincipal()],
+        });
+    }
+    /**
+     * Grant topic publishing permissions to the given identity
+     */
+    grantPublish(grantee) {
+        const ret = iam.Grant.addToPrincipalOrResource({
+            grantee,
+            actions: ["sns:Publish"],
+            resourceArns: [this.topicArn],
+            resource: this,
+        });
+        if (this.masterKey) {
+            this.masterKey.grant(grantee, "kms:Decrypt", "kms:GenerateDataKey*");
+        }
+        return ret;
+    }
+    /**
+     * Grant topic subscribing permissions to the given identity
+     */
+    grantSubscribe(grantee) {
+        return iam.Grant.addToPrincipalOrResource({
+            grantee,
+            actions: ["sns:Subscribe"],
+            resourceArns: [this.topicArn],
+            resource: this,
+        });
+    }
+    /**
+     * Represents a notification target
+     * That allows SNS topic to associate with this rule target.
+     */
+    bindAsNotificationRuleTarget(_scope) {
+        // SNS topic need to grant codestar-notifications service to publish
+        // @see https://docs.aws.amazon.com/dtconsole/latest/userguide/set-up-sns.html
+        this.grantPublish(new iam.ServicePrincipal("codestar-notifications.amazonaws.com"));
+        return {
+            targetType: "SNS",
+            targetAddress: this.topicArn,
+        };
+    }
+    nextTokenId(scope) {
+        let nextSuffix = 1;
+        const re = /TokenSubscription:([\d]*)/gm;
+        // Search through the construct and all of its children
+        // for previous subscriptions that match our regex pattern
+        for (const source of scope.node.findAll()) {
+            const m = re.exec(source.node.id); // Use regex to find a match
+            if (m !== null) {
+                // if we found a match
+                const matchSuffix = parseInt(m[1], 10); // get the suffix for that match (as integer)
+                if (matchSuffix >= nextSuffix) {
+                    // check if the match suffix is larger or equal to currently proposed suffix
+                    nextSuffix = matchSuffix + 1; // increment the suffix
+                }
+            }
+        }
+        return `TokenSubscription:${nextSuffix}`;
+    }
+}
+exports.TopicBase = TopicBase;
+_a = JSII_RTTI_SYMBOL_1;
+TopicBase[_a] = { fqn: "terraconstructs.aws.notify.TopicBase", version: "0.0.18" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"topic-base.js","sourceRoot":"","sources":["../../../src/aws/notify/topic-base.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/f1c092634a391b0b7aed0f75626dd6d0ffd56564/packages/aws-cdk-lib/aws-sns/lib/topic-base.ts\n\nimport { Token } from \"cdktf\";\nimport * as constructs from \"constructs\";\nimport { Construct } from \"constructs\";\nimport {\n  INotificationRuleTarget,\n  NotificationRuleTargetConfig,\n} from \"./notification-rule-target\";\nimport { TopicPolicy } from \"./policy\";\nimport { ITopicSubscription } from \"./subscriber\";\nimport { Subscription } from \"./subscription\";\nimport {\n  IAwsConstruct,\n  AwsConstructBase,\n  AwsConstructProps,\n} from \"../aws-construct\";\nimport { IKey } from \"../encryption\";\nimport * as iam from \"../iam\";\n// TODO: Adopt ValidationError\n// - https://github.com/aws/aws-cdk/pull/33382/\n// - https://github.com/aws/aws-cdk/pull/33045\n// import { ValidationError } from \"../../core/lib/errors\";\n\n/**\n * Outputs for the Subscription construct.\n */\nexport interface TopicOutputs {\n  /**\n   * The ARN of the topic\n   *\n   * @attribute\n   */\n  readonly topicArn: string;\n\n  /**\n   * The name of the topic\n   *\n   * @attribute\n   */\n  readonly topicName: string;\n}\n\n/**\n * Represents an SNS topic\n */\nexport interface ITopic extends IAwsConstruct, INotificationRuleTarget {\n  /**\n   * strongly typed outputs for the topic\n   */\n  readonly topicOutputs: TopicOutputs;\n  /**\n   * The ARN of the topic\n   *\n   * @attribute\n   */\n  readonly topicArn: string;\n\n  /**\n   * The name of the topic\n   *\n   * @attribute\n   */\n  readonly topicName: string;\n\n  /**\n   * A KMS Key, either managed by this CDK app, or imported.\n   *\n   * This property applies only to server-side encryption.\n   *\n   * @see https://docs.aws.amazon.com/sns/latest/dg/sns-server-side-encryption.html\n   *\n   * @default None\n   */\n  readonly masterKey?: IKey;\n\n  /**\n   * Enables content-based deduplication for FIFO topics.\n   *\n   * @attribute\n   */\n  readonly contentBasedDeduplication: boolean;\n\n  /**\n   * Whether this topic is an Amazon SNS FIFO queue. If false, this is a standard topic.\n   *\n   * @attribute\n   */\n  readonly fifo: boolean;\n\n  /**\n   * Subscribe some endpoint to this topic\n   */\n  addSubscription(subscription: ITopicSubscription): Subscription;\n\n  /**\n   * Adds a statement to the IAM resource policy associated with this topic.\n   *\n   * If this topic was created in this stack (`new Topic`), a topic policy\n   * will be automatically created upon the first call to `addToResourcePolicy`. If\n   * the topic is imported (`Topic.import`), then this is a no-op.\n   */\n  addToResourcePolicy(\n    statement: iam.PolicyStatement,\n  ): iam.AddToResourcePolicyResult;\n\n  /**\n   * Grant topic publishing permissions to the given identity\n   */\n  grantPublish(identity: iam.IGrantable): iam.Grant;\n\n  /**\n   * Grant topic subscribing permissions to the given identity\n   */\n  grantSubscribe(identity: iam.IGrantable): iam.Grant;\n}\n\n/**\n * Either a new or imported Topic\n */\nexport abstract class TopicBase extends AwsConstructBase implements ITopic {\n  public get topicOutputs(): TopicOutputs {\n    return {\n      topicArn: this.topicArn,\n      topicName: this.topicName,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.topicOutputs;\n  }\n  public abstract readonly topicArn: string;\n\n  public abstract readonly topicName: string;\n\n  public abstract readonly masterKey?: IKey;\n\n  public abstract readonly fifo: boolean;\n\n  public abstract readonly contentBasedDeduplication: boolean;\n\n  /**\n   * Controls automatic creation of policy objects.\n   *\n   * Set by subclasses.\n   */\n  protected abstract readonly autoCreatePolicy: boolean;\n\n  /**\n   * Adds a statement to enforce encryption of data in transit when publishing to the topic.\n   */\n  protected enforceSSL?: boolean;\n\n  private policy?: TopicPolicy;\n\n  constructor(scope: Construct, id: string, props: AwsConstructProps = {}) {\n    super(scope, id, props);\n\n    this.node.addValidation({\n      validate: () => this.policy?.document.validateForResourcePolicy() ?? [],\n    });\n  }\n\n  /**\n   * Subscribe some endpoint to this topic\n   */\n  public addSubscription(topicSubscription: ITopicSubscription): Subscription {\n    const subscriptionConfig = topicSubscription.bind(this);\n\n    const scope = subscriptionConfig.subscriberScope || this;\n    let id = subscriptionConfig.subscriberId;\n    if (Token.isUnresolved(subscriptionConfig.subscriberId)) {\n      id = this.nextTokenId(scope);\n    }\n\n    // We use the subscriber's id as the construct id. There's no meaning\n    // to subscribing the same subscriber twice on the same topic.\n    if (scope.node.tryFindChild(id)) {\n      // TODO: Adopt ValidationError\n      throw new Error(\n        `A subscription with id \"${id}\" already exists under the scope ${scope.node.path}`,\n      );\n    }\n\n    const subscription = new Subscription(scope, id, {\n      topic: this,\n      ...subscriptionConfig,\n    });\n\n    // Add dependency for the subscription, for example for SQS subscription\n    // the queue policy has to deploy before the subscription is created\n    if (subscriptionConfig.subscriptionDependency) {\n      subscription.node.addDependency(\n        subscriptionConfig.subscriptionDependency,\n      );\n    }\n\n    return subscription;\n  }\n\n  /**\n   * Adds a statement to the IAM resource policy associated with this topic.\n   *\n   * If this topic was created in this stack (`new Topic`), a topic policy\n   * will be automatically created upon the first call to `addToResourcePolicy`.\n   * However, if `enforceSSL` is set to `true`, the policy has already been created\n   * before the first call to this method.\n   *\n   * If the topic is imported (`Topic.import`), then this is a no-op.\n   */\n  public addToResourcePolicy(\n    statement: iam.PolicyStatement,\n  ): iam.AddToResourcePolicyResult {\n    this.createTopicPolicy();\n\n    if (this.policy) {\n      this.policy.document.addStatements(statement);\n      return { statementAdded: true, policyDependable: this.policy };\n    }\n    return { statementAdded: false };\n  }\n\n  /**\n   * Adds a SSL policy to the topic resource policy.\n   */\n  protected addSSLPolicy(): void {\n    this.createTopicPolicy();\n\n    if (this.policy) {\n      this.policy.document.addStatements(this.createSSLPolicyDocument());\n    }\n  }\n\n  /**\n   * Creates a topic policy for this topic.\n   */\n  protected createTopicPolicy(): void {\n    if (!this.policy && this.autoCreatePolicy) {\n      this.policy = new TopicPolicy(this, \"Policy\", { topics: [this] });\n    }\n  }\n\n  /**\n   * Adds a statement to enforce encryption of data in transit when publishing to the topic.\n   *\n   * For more information, see https://docs.aws.amazon.com/sns/latest/dg/sns-security-best-practices.html#enforce-encryption-data-in-transit.\n   */\n  protected createSSLPolicyDocument(): iam.PolicyStatement {\n    return new iam.PolicyStatement({\n      sid: \"AllowPublishThroughSSLOnly\",\n      actions: [\"sns:Publish\"],\n      effect: iam.Effect.DENY,\n      resources: [this.topicArn],\n      condition: [\n        {\n          test: \"Bool\",\n          values: [\"false\"],\n          variable: \"aws:SecureTransport\",\n        },\n      ],\n      principals: [new iam.StarPrincipal()],\n    });\n  }\n\n  /**\n   * Grant topic publishing permissions to the given identity\n   */\n  public grantPublish(grantee: iam.IGrantable) {\n    const ret = iam.Grant.addToPrincipalOrResource({\n      grantee,\n      actions: [\"sns:Publish\"],\n      resourceArns: [this.topicArn],\n      resource: this,\n    });\n    if (this.masterKey) {\n      this.masterKey.grant(grantee, \"kms:Decrypt\", \"kms:GenerateDataKey*\");\n    }\n    return ret;\n  }\n\n  /**\n   * Grant topic subscribing permissions to the given identity\n   */\n  public grantSubscribe(grantee: iam.IGrantable) {\n    return iam.Grant.addToPrincipalOrResource({\n      grantee,\n      actions: [\"sns:Subscribe\"],\n      resourceArns: [this.topicArn],\n      resource: this,\n    });\n  }\n\n  /**\n   * Represents a notification target\n   * That allows SNS topic to associate with this rule target.\n   */\n  public bindAsNotificationRuleTarget(\n    _scope: constructs.Construct,\n  ): NotificationRuleTargetConfig {\n    // SNS topic need to grant codestar-notifications service to publish\n    // @see https://docs.aws.amazon.com/dtconsole/latest/userguide/set-up-sns.html\n    this.grantPublish(\n      new iam.ServicePrincipal(\"codestar-notifications.amazonaws.com\"),\n    );\n    return {\n      targetType: \"SNS\",\n      targetAddress: this.topicArn,\n    };\n  }\n\n  private nextTokenId(scope: Construct) {\n    let nextSuffix = 1;\n    const re = /TokenSubscription:([\\d]*)/gm;\n    // Search through the construct and all of its children\n    // for previous subscriptions that match our regex pattern\n    for (const source of scope.node.findAll()) {\n      const m = re.exec(source.node.id); // Use regex to find a match\n      if (m !== null) {\n        // if we found a match\n        const matchSuffix = parseInt(m[1], 10); // get the suffix for that match (as integer)\n        if (matchSuffix >= nextSuffix) {\n          // check if the match suffix is larger or equal to currently proposed suffix\n          nextSuffix = matchSuffix + 1; // increment the suffix\n        }\n      }\n    }\n    return `TokenSubscription:${nextSuffix}`;\n  }\n}\n"]}