terraconstructs 0.0.8

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

@@ -0,0 +1,40 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventBus = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const util_1 = require("./util");
+const iam = require("../../iam");
+/**
+ * Notify an existing Event Bus of an event
+ */
+class EventBus {
+    constructor(eventBus, props = {}) {
+        this.eventBus = eventBus;
+        this.props = props;
+    }
+    bind(rule, _id) {
+        const role = this.props.role ?? (0, util_1.singletonEventRole)(rule);
+        role.addToPrincipalPolicy(this.putEventStatement());
+        if (this.props.deadLetterQueue) {
+            (0, util_1.addToDeadLetterQueueResourcePolicy)(rule, this.props.deadLetterQueue);
+        }
+        return {
+            arn: this.eventBus.eventBusArn,
+            deadLetterConfig: this.props.deadLetterQueue
+                ? { arn: this.props.deadLetterQueue?.queueArn }
+                : undefined,
+            role,
+        };
+    }
+    putEventStatement() {
+        return new iam.PolicyStatement({
+            actions: ["events:PutEvents"],
+            resources: [this.eventBus.eventBusArn],
+        });
+    }
+}
+exports.EventBus = EventBus;
+_a = JSII_RTTI_SYMBOL_1;
+EventBus[_a] = { fqn: "terraconstructs.aws.notify.targets.EventBus", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/notify/targets/function.d.ts

@@ -0,0 +1,31 @@
+import { RuleTargetInput } from "../input";
+import { IRule } from "../rule";
+import { IRuleTarget, RuleTargetConfig } from "../target";
+import { TargetBaseProps } from "./util";
+import * as compute from "../../compute";
+/**
+ * Customize the Lambda Event Target
+ */
+export interface LambdaFunctionProps extends TargetBaseProps {
+    /**
+     * The event to send to the Lambda
+     *
+     * This will be the payload sent to the Lambda Function.
+     *
+     * @default the entire EventBridge event
+     */
+    readonly event?: RuleTargetInput;
+}
+/**
+ * Use an AWS Lambda function as an event rule target.
+ */
+export declare class LambdaFunction implements IRuleTarget {
+    private readonly handler;
+    private readonly props;
+    constructor(handler: compute.IFunction, props?: LambdaFunctionProps);
+    /**
+     * Returns a RuleTarget that can be used to trigger this Lambda as a
+     * result from an EventBridge event.
+     */
+    bind(rule: IRule, _id?: string): RuleTargetConfig;
+}

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

@@ -0,0 +1,36 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LambdaFunction = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const util_1 = require("./util");
+/**
+ * Use an AWS Lambda function as an event rule target.
+ */
+class LambdaFunction {
+    constructor(handler, props = {}) {
+        this.handler = handler;
+        this.props = props;
+    }
+    /**
+     * Returns a RuleTarget that can be used to trigger this Lambda as a
+     * result from an EventBridge event.
+     */
+    bind(rule, _id) {
+        // Allow handler to be called from rule
+        (0, util_1.addLambdaPermission)(rule, this.handler);
+        if (this.props.deadLetterQueue) {
+            (0, util_1.addToDeadLetterQueueResourcePolicy)(rule, this.props.deadLetterQueue);
+        }
+        return {
+            ...(0, util_1.bindBaseTargetConfig)(this.props),
+            arn: this.handler.functionArn,
+            input: this.props.event,
+            targetResource: this.handler,
+        };
+    }
+}
+exports.LambdaFunction = LambdaFunction;
+_a = JSII_RTTI_SYMBOL_1;
+LambdaFunction[_a] = { fqn: "terraconstructs.aws.notify.targets.LambdaFunction", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnVuY3Rpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYXdzL25vdGlmeS90YXJnZXRzL2Z1bmN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBR0EsaUNBS2dCO0FBaUJoQjs7R0FFRztBQUNILE1BQWEsY0FBYztJQUN6QixZQUNtQixPQUEwQixFQUMxQixRQUE2QixFQUFFO1FBRC9CLFlBQU8sR0FBUCxPQUFPLENBQW1CO1FBQzFCLFVBQUssR0FBTCxLQUFLLENBQTBCO0lBQy9DLENBQUM7SUFFSjs7O09BR0c7SUFDSSxJQUFJLENBQUMsSUFBVyxFQUFFLEdBQVk7UUFDbkMsdUNBQXVDO1FBQ3ZDLElBQUEsMEJBQW1CLEVBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUV4QyxJQUFJLElBQUksQ0FBQyxLQUFLLENBQUMsZUFBZSxFQUFFLENBQUM7WUFDL0IsSUFBQSx5Q0FBa0MsRUFBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLEtBQUssQ0FBQyxlQUFlLENBQUMsQ0FBQztRQUN2RSxDQUFDO1FBRUQsT0FBTztZQUNMLEdBQUcsSUFBQSwyQkFBb0IsRUFBQyxJQUFJLENBQUMsS0FBSyxDQUFDO1lBQ25DLEdBQUcsRUFBRSxJQUFJLENBQUMsT0FBTyxDQUFDLFdBQVc7WUFDN0IsS0FBSyxFQUFFLElBQUksQ0FBQyxLQUFLLENBQUMsS0FBSztZQUN2QixjQUFjLEVBQUUsSUFBSSxDQUFDLE9BQU87U0FDN0IsQ0FBQztJQUNKLENBQUM7O0FBeEJILHdDQXlCQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFJ1bGVUYXJnZXRJbnB1dCB9IGZyb20gXCIuLi9pbnB1dFwiO1xuaW1wb3J0IHsgSVJ1bGUgfSBmcm9tIFwiLi4vcnVsZVwiO1xuaW1wb3J0IHsgSVJ1bGVUYXJnZXQsIFJ1bGVUYXJnZXRDb25maWcgfSBmcm9tIFwiLi4vdGFyZ2V0XCI7XG5pbXBvcnQge1xuICBhZGRMYW1iZGFQZXJtaXNzaW9uLFxuICBhZGRUb0RlYWRMZXR0ZXJRdWV1ZVJlc291cmNlUG9saWN5LFxuICBUYXJnZXRCYXNlUHJvcHMsXG4gIGJpbmRCYXNlVGFyZ2V0Q29uZmlnLFxufSBmcm9tIFwiLi91dGlsXCI7XG5pbXBvcnQgKiBhcyBjb21wdXRlIGZyb20gXCIuLi8uLi9jb21wdXRlXCI7XG5cbi8qKlxuICogQ3VzdG9taXplIHRoZSBMYW1iZGEgRXZlbnQgVGFyZ2V0XG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgTGFtYmRhRnVuY3Rpb25Qcm9wcyBleHRlbmRzIFRhcmdldEJhc2VQcm9wcyB7XG4gIC8qKlxuICAgKiBUaGUgZXZlbnQgdG8gc2VuZCB0byB0aGUgTGFtYmRhXG4gICAqXG4gICAqIFRoaXMgd2lsbCBiZSB0aGUgcGF5bG9hZCBzZW50IHRvIHRoZSBMYW1iZGEgRnVuY3Rpb24uXG4gICAqXG4gICAqIEBkZWZhdWx0IHRoZSBlbnRpcmUgRXZlbnRCcmlkZ2UgZXZlbnRcbiAgICovXG4gIHJlYWRvbmx5IGV2ZW50PzogUnVsZVRhcmdldElucHV0O1xufVxuXG4vKipcbiAqIFVzZSBhbiBBV1MgTGFtYmRhIGZ1bmN0aW9uIGFzIGFuIGV2ZW50IHJ1bGUgdGFyZ2V0LlxuICovXG5leHBvcnQgY2xhc3MgTGFtYmRhRnVuY3Rpb24gaW1wbGVtZW50cyBJUnVsZVRhcmdldCB7XG4gIGNvbnN0cnVjdG9yKFxuICAgIHByaXZhdGUgcmVhZG9ubHkgaGFuZGxlcjogY29tcHV0ZS5JRnVuY3Rpb24sXG4gICAgcHJpdmF0ZSByZWFkb25seSBwcm9wczogTGFtYmRhRnVuY3Rpb25Qcm9wcyA9IHt9LFxuICApIHt9XG5cbiAgLyoqXG4gICAqIFJldHVybnMgYSBSdWxlVGFyZ2V0IHRoYXQgY2FuIGJlIHVzZWQgdG8gdHJpZ2dlciB0aGlzIExhbWJkYSBhcyBhXG4gICAqIHJlc3VsdCBmcm9tIGFuIEV2ZW50QnJpZGdlIGV2ZW50LlxuICAgKi9cbiAgcHVibGljIGJpbmQocnVsZTogSVJ1bGUsIF9pZD86IHN0cmluZyk6IFJ1bGVUYXJnZXRDb25maWcge1xuICAgIC8vIEFsbG93IGhhbmRsZXIgdG8gYmUgY2FsbGVkIGZyb20gcnVsZVxuICAgIGFkZExhbWJkYVBlcm1pc3Npb24ocnVsZSwgdGhpcy5oYW5kbGVyKTtcblxuICAgIGlmICh0aGlzLnByb3BzLmRlYWRMZXR0ZXJRdWV1ZSkge1xuICAgICAgYWRkVG9EZWFkTGV0dGVyUXVldWVSZXNvdXJjZVBvbGljeShydWxlLCB0aGlzLnByb3BzLmRlYWRMZXR0ZXJRdWV1ZSk7XG4gICAgfVxuXG4gICAgcmV0dXJuIHtcbiAgICAgIC4uLmJpbmRCYXNlVGFyZ2V0Q29uZmlnKHRoaXMucHJvcHMpLFxuICAgICAgYXJuOiB0aGlzLmhhbmRsZXIuZnVuY3Rpb25Bcm4sXG4gICAgICBpbnB1dDogdGhpcy5wcm9wcy5ldmVudCxcbiAgICAgIHRhcmdldFJlc291cmNlOiB0aGlzLmhhbmRsZXIsXG4gICAgfTtcbiAgfVxufVxuIl19

package/lib/aws/notify/targets/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./function";
+export * from "./sqs";
+export * from "./util";
+export * from "./event-bus";
+export * from "./state-machine";
+export * from "./log-group";

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

@@ -0,0 +1,37 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-events-targets/lib/index.ts
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./function"), exports);
+__exportStar(require("./sqs"), exports);
+__exportStar(require("./util"), exports);
+__exportStar(require("./event-bus"), exports);
+__exportStar(require("./state-machine"), exports);
+// export * from "./batch";
+// export * from "./codepipeline";
+// export * from "./sns";
+// export * from "./codebuild";
+// export * from "./aws-api";
+// export * from "./ecs-task-properties";
+// export * from "./ecs-task";
+// export * from "./kinesis-stream";
+__exportStar(require("./log-group"), exports);
+// export * from "./kinesis-firehose-stream";
+// export * from "./api-gateway";
+// export * from "./api-destination";
+// export * from "./appsync";
+// export * from "./redshift-query";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYXdzL25vdGlmeS90YXJnZXRzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxvR0FBb0c7Ozs7Ozs7Ozs7Ozs7Ozs7QUFFcEcsNkNBQTJCO0FBQzNCLHdDQUFzQjtBQUN0Qix5Q0FBdUI7QUFDdkIsOENBQTRCO0FBQzVCLGtEQUFnQztBQUNoQywyQkFBMkI7QUFDM0Isa0NBQWtDO0FBQ2xDLHlCQUF5QjtBQUN6QiwrQkFBK0I7QUFDL0IsNkJBQTZCO0FBQzdCLHlDQUF5QztBQUN6Qyw4QkFBOEI7QUFDOUIsb0NBQW9DO0FBQ3BDLDhDQUE0QjtBQUM1Qiw2Q0FBNkM7QUFDN0MsaUNBQWlDO0FBQ2pDLHFDQUFxQztBQUNyQyw2QkFBNkI7QUFDN0Isb0NBQW9DIiwic291cmNlc0NvbnRlbnQiOlsiLy8gaHR0cHM6Ly9naXRodWIuY29tL2F3cy9hd3MtY2RrL2Jsb2IvdjIuMTcwLjAvcGFja2FnZXMvYXdzLWNkay1saWIvYXdzLWV2ZW50cy10YXJnZXRzL2xpYi9pbmRleC50c1xuXG5leHBvcnQgKiBmcm9tIFwiLi9mdW5jdGlvblwiO1xuZXhwb3J0ICogZnJvbSBcIi4vc3FzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi91dGlsXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9ldmVudC1idXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3N0YXRlLW1hY2hpbmVcIjtcbi8vIGV4cG9ydCAqIGZyb20gXCIuL2JhdGNoXCI7XG4vLyBleHBvcnQgKiBmcm9tIFwiLi9jb2RlcGlwZWxpbmVcIjtcbi8vIGV4cG9ydCAqIGZyb20gXCIuL3Nuc1wiO1xuLy8gZXhwb3J0ICogZnJvbSBcIi4vY29kZWJ1aWxkXCI7XG4vLyBleHBvcnQgKiBmcm9tIFwiLi9hd3MtYXBpXCI7XG4vLyBleHBvcnQgKiBmcm9tIFwiLi9lY3MtdGFzay1wcm9wZXJ0aWVzXCI7XG4vLyBleHBvcnQgKiBmcm9tIFwiLi9lY3MtdGFza1wiO1xuLy8gZXhwb3J0ICogZnJvbSBcIi4va2luZXNpcy1zdHJlYW1cIjtcbmV4cG9ydCAqIGZyb20gXCIuL2xvZy1ncm91cFwiO1xuLy8gZXhwb3J0ICogZnJvbSBcIi4va2luZXNpcy1maXJlaG9zZS1zdHJlYW1cIjtcbi8vIGV4cG9ydCAqIGZyb20gXCIuL2FwaS1nYXRld2F5XCI7XG4vLyBleHBvcnQgKiBmcm9tIFwiLi9hcGktZGVzdGluYXRpb25cIjtcbi8vIGV4cG9ydCAqIGZyb20gXCIuL2FwcHN5bmNcIjtcbi8vIGV4cG9ydCAqIGZyb20gXCIuL3JlZHNoaWZ0LXF1ZXJ5XCI7XG4iXX0=

package/lib/aws/notify/targets/log-group.d.ts

@@ -0,0 +1,89 @@
+import { RuleTargetInputProperties, RuleTargetInput } from "../input";
+import { IRule } from "../rule";
+import { IRuleTarget, RuleTargetConfig } from "../target";
+import { TargetBaseProps } from "./util";
+import * as logs from "../../cloudwatch";
+/**
+ * Options used when creating a target input template
+ */
+export interface LogGroupTargetInputOptions {
+    /**
+     * The timestamp that will appear in the CloudWatch Logs record
+     *
+     * @default EventField.time
+     */
+    readonly timestamp?: any;
+    /**
+     * The value provided here will be used in the Log "message" field.
+     *
+     * This field must be a string. If an object is passed (e.g. JSON data)
+     * it will not throw an error, but the message that makes it to
+     * CloudWatch logs will be incorrect. This is a likely scenario if
+     * doing something like: EventField.fromPath('$.detail') since in most cases
+     * the `detail` field contains JSON data.
+     *
+     * @default EventField.detailType
+     */
+    readonly message?: any;
+}
+/**
+ * The input to send to the CloudWatch LogGroup target
+ */
+export declare abstract class LogGroupTargetInput {
+    /**
+     * Pass a JSON object to the the log group event target
+     *
+     * May contain strings returned by `EventField.from()` to substitute in parts of the
+     * matched event.
+     */
+    static fromObject(options?: LogGroupTargetInputOptions): RuleTargetInput;
+    /**
+     * Return the input properties for this input object
+     */
+    abstract bind(rule: IRule): RuleTargetInputProperties;
+}
+/**
+ * Customize the CloudWatch LogGroup Event Target
+ */
+export interface LogGroupProps extends TargetBaseProps {
+    /**
+     * The event to send to the CloudWatch LogGroup
+     *
+     * This will be the event logged into the CloudWatch LogGroup
+     *
+     * @default - the entire EventBridge event
+     * @deprecated use logEvent instead
+     */
+    readonly event?: RuleTargetInput;
+    /**
+     * The event to send to the CloudWatch LogGroup
+     *
+     * This will be the event logged into the CloudWatch LogGroup
+     *
+     * @default - the entire EventBridge event
+     */
+    readonly logEvent?: LogGroupTargetInput;
+}
+/**
+ * Use an AWS CloudWatch LogGroup as an event rule target.
+ */
+export declare class CloudWatchLogGroup implements IRuleTarget {
+    private readonly logGroup;
+    private readonly props;
+    private target?;
+    constructor(logGroup: logs.ILogGroup, props?: LogGroupProps);
+    /**
+     * Returns a RuleTarget that can be used to log an event into a CloudWatch LogGroup
+     */
+    bind(_rule: IRule, _id?: string): RuleTargetConfig;
+    /**
+     * Validate that the target event input template has the correct format.
+     * The CloudWatchLogs target only supports a template with the format of:
+     *   {"timestamp": <time>, "message": <message>}
+     *
+     * This is only needed if the deprecated `event` property is used.
+     *
+     * @see https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutTargets.html
+     */
+    private validateInputTemplate;
+}

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

@@ -0,0 +1,110 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudWatchLogGroup = exports.LogGroupTargetInput = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const input_1 = require("../input");
+// Custom Resource no longer needed
+// logGroup ResourcePolicy was added to CFN - https://github.com/aws/aws-cdk/pull/17015/files
+// import { LogGroupResourcePolicy } from "./log-group-resource-policy";
+const util_1 = require("./util");
+const arn_1 = require("../../arn");
+const aws_stack_1 = require("../../aws-stack");
+const iam = require("../../iam");
+/**
+ * The input to send to the CloudWatch LogGroup target
+ */
+class LogGroupTargetInput {
+    /**
+     * Pass a JSON object to the the log group event target
+     *
+     * May contain strings returned by `EventField.from()` to substitute in parts of the
+     * matched event.
+     */
+    static fromObject(options) {
+        return input_1.RuleTargetInput.fromObject({
+            timestamp: options?.timestamp ?? input_1.EventField.time,
+            message: options?.message ?? input_1.EventField.detailType,
+        });
+    }
+}
+exports.LogGroupTargetInput = LogGroupTargetInput;
+_a = JSII_RTTI_SYMBOL_1;
+LogGroupTargetInput[_a] = { fqn: "terraconstructs.aws.notify.targets.LogGroupTargetInput", version: "0.0.8" };
+/**
+ * Use an AWS CloudWatch LogGroup as an event rule target.
+ */
+class CloudWatchLogGroup {
+    constructor(logGroup, props = {}) {
+        this.logGroup = logGroup;
+        this.props = props;
+    }
+    /**
+     * Returns a RuleTarget that can be used to log an event into a CloudWatch LogGroup
+     */
+    bind(_rule, _id) {
+        const logGroupStack = aws_stack_1.AwsStack.ofAwsConstruct(this.logGroup);
+        if (this.props.event && this.props.logEvent) {
+            throw new Error('Only one of "event" or "logEvent" can be specified');
+        }
+        this.target = this.props.event?.bind(_rule);
+        if (this.target?.inputPath || this.target?.input) {
+            throw new Error("CloudWatchLogGroup targets does not support input or inputPath");
+        }
+        this.logGroup.grantWrite(new iam.ServicePrincipal("events.amazonaws.com"));
+        _rule.node.addValidation({ validate: () => this.validateInputTemplate() });
+        return {
+            ...(0, util_1.bindBaseTargetConfig)(this.props),
+            arn: logGroupStack.formatArn({
+                service: "logs",
+                resource: "log-group",
+                arnFormat: arn_1.ArnFormat.COLON_RESOURCE_NAME,
+                resourceName: this.logGroup.logGroupName,
+            }),
+            input: this.props.event ?? this.props.logEvent,
+            targetResource: this.logGroup,
+        };
+    }
+    /**
+     * Validate that the target event input template has the correct format.
+     * The CloudWatchLogs target only supports a template with the format of:
+     *   {"timestamp": <time>, "message": <message>}
+     *
+     * This is only needed if the deprecated `event` property is used.
+     *
+     * @see https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutTargets.html
+     */
+    validateInputTemplate() {
+        if (this.target?.inputTemplate) {
+            const resolvedTemplate = aws_stack_1.AwsStack.ofAwsConstruct(this.logGroup).resolve(this.target.inputTemplate);
+            if (typeof resolvedTemplate === "string") {
+                // need to add the quotes back to the string so that we can parse the json
+                // '{"timestamp": <time>}' -> '{"timestamp": "<time>"}'
+                const quotedTemplate = resolvedTemplate.replace(new RegExp("(<[^<>]*?>)", "g"), '"$1"');
+                try {
+                    const inputTemplate = JSON.parse(quotedTemplate);
+                    const inputTemplateKeys = Object.keys(inputTemplate);
+                    if (inputTemplateKeys.length !== 2 ||
+                        !inputTemplateKeys.includes("timestamp") ||
+                        !inputTemplateKeys.includes("message")) {
+                        return [
+                            "CloudWatchLogGroup targets only support input templates in the format {timestamp: <timestamp>, message: <message>}",
+                        ];
+                    }
+                }
+                catch (e) {
+                    return [
+                        "Could not parse input template as JSON.\n" +
+                            "CloudWatchLogGroup targets only support input templates in the format {timestamp: <timestamp>, message: <message>}",
+                        e,
+                    ];
+                }
+            }
+        }
+        return [];
+    }
+}
+exports.CloudWatchLogGroup = CloudWatchLogGroup;
+_b = JSII_RTTI_SYMBOL_1;
+CloudWatchLogGroup[_b] = { fqn: "terraconstructs.aws.notify.targets.CloudWatchLogGroup", version: "0.0.8" };
+//# 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.d.ts

@@ -0,0 +1,45 @@
+import * as notify from "..";
+import { TargetBaseProps } from "./util";
+/**
+ * Customize the SQS Queue Event Target
+ */
+export interface SqsQueueProps extends TargetBaseProps {
+    /**
+     * Message Group ID for messages sent to this queue
+     *
+     * Required for FIFO queues, leave empty for regular queues.
+     *
+     * @default - no message group ID (regular queue)
+     */
+    readonly messageGroupId?: string;
+    /**
+     * The message to send to the queue.
+     *
+     * Must be a valid JSON text passed to the target queue.
+     *
+     * @default the entire EventBridge event
+     */
+    readonly message?: notify.RuleTargetInput;
+}
+/**
+ * Use an SQS Queue as a target for Amazon EventBridge rules.
+ *
+ * @example
+ *   /// fixture=withRepoAndSqsQueue
+ *   // publish to an SQS queue every time code is committed
+ *   // to a CodeCommit repository
+ *   repository.onCommit('onCommit', { target: new targets.SqsQueue(queue) });
+ *
+ */
+export declare class SqsQueue implements notify.IRuleTarget {
+    readonly queue: notify.IQueue;
+    private readonly props;
+    constructor(queue: notify.IQueue, props?: SqsQueueProps);
+    /**
+     * Returns a RuleTarget that can be used to trigger this SQS queue as a
+     * result from an EventBridge event.
+     *
+     * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/resource-based-policies-eventbridge.html#sqs-permissions
+     */
+    bind(rule: notify.IRule, _id?: string): notify.RuleTargetConfig;
+}

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

@@ -0,0 +1,73 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqsQueue = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const util_1 = require("./util");
+const iam = require("../../iam");
+/**
+ * Use an SQS Queue as a target for Amazon EventBridge rules.
+ *
+ * @example
+ *   /// fixture=withRepoAndSqsQueue
+ *   // publish to an SQS queue every time code is committed
+ *   // to a CodeCommit repository
+ *   repository.onCommit('onCommit', { target: new targets.SqsQueue(queue) });
+ *
+ */
+class SqsQueue {
+    constructor(queue, props = {}) {
+        this.queue = queue;
+        this.props = props;
+        if (props.messageGroupId !== undefined && !queue.fifo) {
+            throw new Error("messageGroupId cannot be specified for non-FIFO queues");
+        }
+    }
+    /**
+     * Returns a RuleTarget that can be used to trigger this SQS queue as a
+     * result from an EventBridge event.
+     *
+     * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/resource-based-policies-eventbridge.html#sqs-permissions
+     */
+    bind(rule, _id) {
+        // restrict to same account
+        let conditions = [
+            // Add only the account id as a condition, to avoid circular dependency.
+            // https://github.com/aws/aws-cdk/issues/11158
+            {
+                test: "StringEquals",
+                variable: "aws:SourceAccount",
+                values: [rule.env.account],
+            },
+        ];
+        // //TODO: Re-add KMS support
+        // //TODO: Update Tests as well
+        // if (!this.queue.encryptionMasterKey) {
+        // conditions = [
+        //   {
+        //     test: "ArnEquals",
+        //     variable: "aws:SourceArn",
+        //     values: [rule.ruleArn],
+        //   },
+        // ];
+        // }
+        // deduplicated automatically (by PolicyDocument PostProcessor)
+        this.queue.grantSendMessages(new iam.ServicePrincipal("events.amazonaws.com", { conditions }));
+        if (this.props.deadLetterQueue) {
+            (0, util_1.addToDeadLetterQueueResourcePolicy)(rule, this.props.deadLetterQueue);
+        }
+        return {
+            ...(0, util_1.bindBaseTargetConfig)(this.props),
+            arn: this.queue.queueArn,
+            input: this.props.message,
+            targetResource: this.queue,
+            sqsParameters: this.props.messageGroupId
+                ? { messageGroupId: this.props.messageGroupId }
+                : undefined,
+        };
+    }
+}
+exports.SqsQueue = SqsQueue;
+_a = JSII_RTTI_SYMBOL_1;
+SqsQueue[_a] = { fqn: "terraconstructs.aws.notify.targets.SqsQueue", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/notify/targets/state-machine.d.ts

@@ -0,0 +1,36 @@
+import * as notify from "..";
+import { TargetBaseProps } from "./util";
+import * as compute from "../../compute";
+import * as iam from "../../iam";
+/**
+ * Customize the Step Functions State Machine target
+ */
+export interface SfnStateMachineProps extends TargetBaseProps {
+    /**
+     * The input to the state machine execution
+     *
+     * @default the entire EventBridge event
+     */
+    readonly input?: notify.RuleTargetInput;
+    /**
+     * The IAM role to be assumed to execute the State Machine
+     *
+     * @default - a new role will be created
+     */
+    readonly role?: iam.IRole;
+}
+/**
+ * Use a StepFunctions state machine as a target for Amazon EventBridge rules.
+ */
+export declare class SfnStateMachine implements notify.IRuleTarget {
+    readonly machine: compute.IStateMachine;
+    private readonly props;
+    private readonly role;
+    constructor(machine: compute.IStateMachine, props?: SfnStateMachineProps);
+    /**
+     * Returns a properties that are used in an Rule to trigger this State Machine
+     *
+     * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/resource-based-policies-eventbridge.html#sns-permissions
+     */
+    bind(_rule: notify.IRule, _id?: string): notify.RuleTargetConfig;
+}

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

@@ -0,0 +1,39 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SfnStateMachine = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const util_1 = require("./util");
+/**
+ * Use a StepFunctions state machine as a target for Amazon EventBridge rules.
+ */
+class SfnStateMachine {
+    constructor(machine, props = {}) {
+        this.machine = machine;
+        this.props = props;
+        // no statements are passed because we are configuring permissions by using grant* helper below
+        this.role = props.role ?? (0, util_1.singletonEventRole)(machine);
+        machine.grantStartExecution(this.role);
+    }
+    /**
+     * Returns a properties that are used in an Rule to trigger this State Machine
+     *
+     * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/resource-based-policies-eventbridge.html#sns-permissions
+     */
+    bind(_rule, _id) {
+        if (this.props.deadLetterQueue) {
+            (0, util_1.addToDeadLetterQueueResourcePolicy)(_rule, this.props.deadLetterQueue);
+        }
+        return {
+            ...(0, util_1.bindBaseTargetConfig)(this.props),
+            arn: this.machine.stateMachineArn,
+            role: this.role,
+            input: this.props.input,
+            targetResource: this.machine,
+        };
+    }
+}
+exports.SfnStateMachine = SfnStateMachine;
+_a = JSII_RTTI_SYMBOL_1;
+SfnStateMachine[_a] = { fqn: "terraconstructs.aws.notify.targets.SfnStateMachine", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,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