terraconstructs 0.0.8

package/lib/aws/notify/rule.js

@@ -0,0 +1,227 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rule = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const arn_1 = require("../arn");
+const aws_construct_1 = require("../aws-construct");
+const aws_stack_1 = require("../aws-stack");
+const util_1 = require("./util");
+class Rule extends aws_construct_1.AwsConstructBase {
+    /**
+     * Import an existing EventBridge Rule provided an ARN
+     *
+     * @param scope The parent creating construct (usually `this`).
+     * @param id The construct's name.
+     * @param eventRuleArn Event Rule ARN (i.e. arn:aws:events:<region>:<account-id>:rule/MyScheduledRule).
+     */
+    static fromEventRuleArn(scope, id, eventRuleArn) {
+        const parts = aws_stack_1.AwsStack.ofAwsConstruct(scope).splitArn(eventRuleArn, arn_1.ArnFormat.SLASH_RESOURCE_NAME);
+        class Import extends aws_construct_1.AwsConstructBase {
+            constructor() {
+                super(...arguments);
+                this.ruleArn = eventRuleArn;
+                this.ruleName = parts.resourceName || "";
+                this.ruleOutputs = {
+                    name: this.ruleName,
+                    arn: this.ruleArn,
+                };
+                this.outputs = this.ruleOutputs;
+            }
+        }
+        return new Import(scope, id, {
+            environmentFromArn: eventRuleArn,
+        });
+    }
+    get ruleArn() {
+        return this.resource.arn;
+    }
+    get ruleName() {
+        return this.resource.name;
+    }
+    get ruleOutputs() {
+        return {
+            name: this.ruleName,
+            arn: this.ruleArn,
+        };
+    }
+    get outputs() {
+        return this.ruleOutputs;
+    }
+    constructor(scope, name, props = {}) {
+        super(scope, name, props);
+        this.targets = new Array();
+        this.eventPattern = {};
+        if (props.eventBus && props.schedule) {
+            throw new Error("Cannot associate rule with 'eventBus' when using 'schedule'");
+        }
+        let namePrefix;
+        if (!props.ruleName) {
+            namePrefix = this.stack.uniqueResourceNamePrefix(this, {
+                prefix: props.namePrefix ?? this.gridUUID + "-",
+                allowedSpecialCharacters: ".-_",
+                maxLength: 64,
+            });
+        }
+        this.description = props.description;
+        this.scheduleExpression = props.schedule?.expressionString;
+        // add a warning on synth when minute is not defined in a cron schedule
+        props.schedule?._bind(this);
+        this.resource = new provider_aws_1.cloudwatchEventRule.CloudwatchEventRule(this, "Resource", {
+            name: props.ruleName,
+            namePrefix,
+            description: this.description,
+            state: props.enabled == null
+                ? "ENABLED"
+                : props.enabled
+                    ? "ENABLED"
+                    : "DISABLED", //TODO: support ENABLED_WITH_ALL_CLOUDTRAIL_MANAGEMENT_EVENTS?
+            scheduleExpression: this.scheduleExpression,
+            eventPattern: cdktf_1.Lazy.stringValue({
+                produce: () => this.stack.toJsonString(this._renderEventPattern()),
+            }),
+            // terraform-provider-aws separates targets to different resources.
+            // targets: Lazy.anyValue({ produce: () => this.renderTargets() }),
+            eventBusName: props.eventBus?.eventBusName,
+            dependsOn: props.dependsOn,
+        });
+        this.addEventPattern(props.eventPattern);
+        for (const target of props.targets || []) {
+            this.addTarget(target);
+        }
+        this.node.addValidation({
+            validate: () => this.validateRule(props.ruleName),
+        });
+    }
+    /**
+     * Adds an event pattern filter to this rule. If a pattern was already specified,
+     * these values are merged into the existing pattern.
+     *
+     * For example, if the rule already contains the pattern:
+     *
+     *    {
+     *      "resources": [ "r1" ],
+     *      "detail": {
+     *        "hello": [ 1 ]
+     *      }
+     *    }
+     *
+     * And `addEventPattern` is called with the pattern:
+     *
+     *    {
+     *      "resources": [ "r2" ],
+     *      "detail": {
+     *        "foo": [ "bar" ]
+     *      }
+     *    }
+     *
+     * The resulting event pattern will be:
+     *
+     *    {
+     *      "resources": [ "r1", "r2" ],
+     *      "detail": {
+     *        "hello": [ 1 ],
+     *        "foo": [ "bar" ]
+     *      }
+     *    }
+     *
+     */
+    addEventPattern(eventPattern) {
+        if (!eventPattern) {
+            return;
+        }
+        (0, util_1.mergeEventPattern)(this.eventPattern, eventPattern);
+    }
+    /**
+     * Not private only to be overrideen in CopyRule.
+     *
+     * @internal
+     */
+    _renderEventPattern() {
+        return (0, util_1.renderEventPattern)(this.eventPattern);
+    }
+    validateRule(ruleName) {
+        if (ruleName !== undefined && !cdktf_1.Token.isUnresolved(ruleName)) {
+            if (ruleName.length < 1 || ruleName.length > 64) {
+                throw new Error(`Event rule name must be between 1 and 64 characters. Received: ${ruleName}`);
+            }
+            if (!/^[\.\-_A-Za-z0-9]+$/.test(ruleName)) {
+                throw new Error(`Event rule name ${ruleName} can contain only letters, numbers, periods, hyphens, or underscores with no spaces.`);
+            }
+        }
+        const errors = [];
+        if (Object.keys(this.eventPattern).length === 0 &&
+            !this.scheduleExpression) {
+            errors.push("Either 'eventPattern' or 'schedule' must be defined");
+        }
+        if (this.targets.length > 5) {
+            errors.push("Event rule cannot have more than 5 targets.");
+        }
+        return errors;
+    }
+    /**
+     * Adds a target to the rule. The abstract class RuleTarget can be extended to define new
+     * targets.
+     *
+     * No-op if target is undefined.
+     */
+    addTarget(target) {
+        if (!target) {
+            return;
+        }
+        // Simply increment id for each `addTarget` call. This is guaranteed to be unique.
+        const targetId = `Target${this.targets.length}`;
+        const targetProps = target.bind(this, targetId);
+        const inputProps = targetProps.input && targetProps.input.bind(this);
+        this.targets.push({
+            targetId,
+            roleArn: targetProps.role?.roleArn,
+            rule: this.resource.name,
+            arn: targetProps.arn,
+            ecsTarget: targetProps.ecsParameters,
+            httpTarget: targetProps.httpParameters,
+            kinesisTarget: targetProps.kinesisParameters,
+            runCommandTargets: targetProps.runCommandParameters,
+            batchTarget: targetProps.batchParameters,
+            deadLetterConfig: targetProps.deadLetterConfig,
+            retryPolicy: targetProps.retryPolicy,
+            sqsTarget: targetProps.sqsParameters,
+            redshiftTarget: targetProps.redshiftDataParameters,
+            // TODO: not available in terraform-provider-aws
+            // appSyncParameters: targetProps.appSyncParameters,
+            input: inputProps && inputProps.input,
+            inputPath: inputProps && inputProps.inputPath,
+            inputTransformer: inputProps?.inputTemplate !== undefined
+                ? {
+                    inputTemplate: inputProps.inputTemplate,
+                    inputPaths: inputProps.inputPathsMap,
+                }
+                : undefined,
+        });
+    }
+    /**
+     * Adds resource to the Terraform JSON output at Synth time.
+     *
+     * called by TerraformStack.prepareStack()
+     */
+    toTerraform() {
+        /**
+         * A preparing resolve might add new resources to the stack
+         */
+        for (const target of this.targets) {
+            // note: targetId is calculated in addTarget()
+            // TODO: Ideally we should have used IResolvable.resolve and use the IResolveContext.preparing flag
+            // ref: https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-iam/lib/policy-document.ts#L48
+            if (this.node.tryFindChild(target.targetId))
+                continue; // ignore if already generated
+            new provider_aws_1.cloudwatchEventTarget.CloudwatchEventTarget(this, target.targetId, target);
+        }
+        return {};
+    }
+}
+exports.Rule = Rule;
+_a = JSII_RTTI_SYMBOL_1;
+Rule[_a] = { fqn: "terraconstructs.aws.notify.Rule", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../src/aws/notify/rule.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  cloudwatchEventRule,\n  cloudwatchEventTarget,\n  //schedulerScheduleGroup //TODO: support scheduler groups?\n} from \"@cdktf/provider-aws\";\nimport { Lazy, Token } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { ArnFormat } from \"../arn\";\nimport {\n  AwsConstructBase,\n  IAwsConstruct,\n  AwsConstructProps,\n} from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\nimport {\n  Schedule,\n  EventPattern,\n  IRuleTarget,\n  IEventBus,\n  EventCommonOptions,\n} from \"./\";\nimport { mergeEventPattern, renderEventPattern } from \"./util\";\n\nexport interface RuleProps extends AwsConstructProps, EventCommonOptions {\n  /**\n   * Indicates whether the rule is enabled.\n   *\n   * @default true\n   */\n  readonly enabled?: boolean;\n\n  /**\n   * Rule Name prefix to append to Grid UUID\n   *\n   * Rule names must be made up of only uppercase and lowercase ASCII letters,\n   * numbers, underscores, and hyphens, and Due to the length of the tf generated\n   * suffix, must be 64 characters or less long.\n   *\n   *\n   * @default - GridUUID + Stack Unique Name\n   */\n  readonly namePrefix?: string;\n\n  /**\n   * The schedule or rate (frequency) that determines when EventBridge\n   * runs the rule.\n   *\n   * You must specify this property, the `eventPattern` property, or both.\n   *\n   * For more information, see Schedule Expression Syntax for\n   * Rules in the Amazon EventBridge User Guide.\n   *\n   * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/scheduled-events.html\n   *\n   * @default - None.\n   */\n  readonly schedule?: Schedule;\n\n  /**\n   * Targets to invoke when this rule matches an event.\n   *\n   * Input will be the full matched event. If you wish to specify custom\n   * target input, use `addTarget(target[, inputOptions])`.\n   *\n   * @default - No targets.\n   */\n  readonly targets?: IRuleTarget[];\n\n  /**\n   * The event bus to associate with this rule.\n   *\n   * @default - The default event bus.\n   */\n  readonly eventBus?: IEventBus;\n\n  // /**\n  //  * Additional restrictions for the event to route to the specified target\n  //  *\n  //  * The method that generates the rule probably imposes some type of event\n  //  * filtering. The filtering implied by what you pass here is added\n  //  * on top of that filtering.\n  //  *\n  //  * @default - No additional filtering based on an event pattern.\n  //  *\n  //  * @see\n  //  * https://docs.aws.amazon.com/eventbridge/latest/userguide/eventbridge-and-event-patterns.html\n  //  */\n  // readonly eventPattern?: EventPattern;\n}\n\nexport interface RuleOutputs {\n  /**\n   * Rule name\n   */\n  readonly name: string;\n\n  /**\n   * Rule arn\n   */\n  readonly arn: string;\n}\n\nexport interface IRule extends IAwsConstruct {\n  /** Strongly typed outputs */\n  readonly ruleOutputs: RuleOutputs;\n  /**\n   * The value of the event rule Amazon Resource Name (ARN), such as\n   * arn:aws:events:us-east-2:123456789012:rule/example.\n   *\n   * @attribute\n   */\n  readonly ruleArn: string;\n\n  /**\n   * The name event rule\n   *\n   * @attribute\n   */\n  readonly ruleName: string;\n}\n\nexport class Rule extends AwsConstructBase implements IRule {\n  /**\n   * Import an existing EventBridge Rule provided an ARN\n   *\n   * @param scope The parent creating construct (usually `this`).\n   * @param id The construct's name.\n   * @param eventRuleArn Event Rule ARN (i.e. arn:aws:events:<region>:<account-id>:rule/MyScheduledRule).\n   */\n  public static fromEventRuleArn(\n    scope: Construct,\n    id: string,\n    eventRuleArn: string,\n  ): IRule {\n    const parts = AwsStack.ofAwsConstruct(scope).splitArn(\n      eventRuleArn,\n      ArnFormat.SLASH_RESOURCE_NAME,\n    );\n\n    class Import extends AwsConstructBase implements IRule {\n      public ruleArn = eventRuleArn;\n      public ruleName = parts.resourceName || \"\";\n      public ruleOutputs = {\n        name: this.ruleName,\n        arn: this.ruleArn,\n      };\n      public outputs = this.ruleOutputs;\n    }\n    return new Import(scope, id, {\n      environmentFromArn: eventRuleArn,\n    });\n  }\n\n  public readonly resource: cloudwatchEventRule.CloudwatchEventRule;\n  public get ruleArn() {\n    return this.resource.arn;\n  }\n  public get ruleName() {\n    return this.resource.name;\n  }\n  public get ruleOutputs(): RuleOutputs {\n    return {\n      name: this.ruleName,\n      arn: this.ruleArn,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.ruleOutputs;\n  }\n\n  private readonly targets =\n    new Array<cloudwatchEventTarget.CloudwatchEventTargetConfig>();\n  private readonly eventPattern: EventPattern = {};\n\n  private readonly scheduleExpression?: string;\n  private readonly description?: string;\n  constructor(scope: Construct, name: string, props: RuleProps = {}) {\n    super(scope, name, props);\n\n    if (props.eventBus && props.schedule) {\n      throw new Error(\n        \"Cannot associate rule with 'eventBus' when using 'schedule'\",\n      );\n    }\n\n    let namePrefix: string | undefined;\n    if (!props.ruleName) {\n      namePrefix = this.stack.uniqueResourceNamePrefix(this, {\n        prefix: props.namePrefix ?? this.gridUUID + \"-\",\n        allowedSpecialCharacters: \".-_\",\n        maxLength: 64,\n      });\n    }\n    this.description = props.description;\n    this.scheduleExpression = props.schedule?.expressionString;\n\n    // add a warning on synth when minute is not defined in a cron schedule\n    props.schedule?._bind(this);\n\n    this.resource = new cloudwatchEventRule.CloudwatchEventRule(\n      this,\n      \"Resource\",\n      {\n        name: props.ruleName,\n        namePrefix,\n        description: this.description,\n        state:\n          props.enabled == null\n            ? \"ENABLED\"\n            : props.enabled\n              ? \"ENABLED\"\n              : \"DISABLED\", //TODO: support ENABLED_WITH_ALL_CLOUDTRAIL_MANAGEMENT_EVENTS?\n        scheduleExpression: this.scheduleExpression,\n        eventPattern: Lazy.stringValue({\n          produce: () => this.stack.toJsonString(this._renderEventPattern()),\n        }),\n        // terraform-provider-aws separates targets to different resources.\n        // targets: Lazy.anyValue({ produce: () => this.renderTargets() }),\n        eventBusName: props.eventBus?.eventBusName,\n        dependsOn: props.dependsOn,\n      },\n    );\n\n    this.addEventPattern(props.eventPattern);\n\n    for (const target of props.targets || []) {\n      this.addTarget(target);\n    }\n\n    this.node.addValidation({\n      validate: () => this.validateRule(props.ruleName),\n    });\n  }\n\n  /**\n   * Adds an event pattern filter to this rule. If a pattern was already specified,\n   * these values are merged into the existing pattern.\n   *\n   * For example, if the rule already contains the pattern:\n   *\n   *    {\n   *      \"resources\": [ \"r1\" ],\n   *      \"detail\": {\n   *        \"hello\": [ 1 ]\n   *      }\n   *    }\n   *\n   * And `addEventPattern` is called with the pattern:\n   *\n   *    {\n   *      \"resources\": [ \"r2\" ],\n   *      \"detail\": {\n   *        \"foo\": [ \"bar\" ]\n   *      }\n   *    }\n   *\n   * The resulting event pattern will be:\n   *\n   *    {\n   *      \"resources\": [ \"r1\", \"r2\" ],\n   *      \"detail\": {\n   *        \"hello\": [ 1 ],\n   *        \"foo\": [ \"bar\" ]\n   *      }\n   *    }\n   *\n   */\n  public addEventPattern(eventPattern?: EventPattern) {\n    if (!eventPattern) {\n      return;\n    }\n    mergeEventPattern(this.eventPattern, eventPattern);\n  }\n\n  /**\n   * Not private only to be overrideen in CopyRule.\n   *\n   * @internal\n   */\n  public _renderEventPattern(): any {\n    return renderEventPattern(this.eventPattern);\n  }\n\n  protected validateRule(ruleName?: string) {\n    if (ruleName !== undefined && !Token.isUnresolved(ruleName)) {\n      if (ruleName.length < 1 || ruleName.length > 64) {\n        throw new Error(\n          `Event rule name must be between 1 and 64 characters. Received: ${ruleName}`,\n        );\n      }\n      if (!/^[\\.\\-_A-Za-z0-9]+$/.test(ruleName)) {\n        throw new Error(\n          `Event rule name ${ruleName} can contain only letters, numbers, periods, hyphens, or underscores with no spaces.`,\n        );\n      }\n    }\n\n    const errors: string[] = [];\n    if (\n      Object.keys(this.eventPattern).length === 0 &&\n      !this.scheduleExpression\n    ) {\n      errors.push(\"Either 'eventPattern' or 'schedule' must be defined\");\n    }\n\n    if (this.targets.length > 5) {\n      errors.push(\"Event rule cannot have more than 5 targets.\");\n    }\n\n    return errors;\n  }\n\n  /**\n   * Adds a target to the rule. The abstract class RuleTarget can be extended to define new\n   * targets.\n   *\n   * No-op if target is undefined.\n   */\n  public addTarget(target?: IRuleTarget): void {\n    if (!target) {\n      return;\n    }\n    // Simply increment id for each `addTarget` call. This is guaranteed to be unique.\n    const targetId = `Target${this.targets.length}`;\n    const targetProps = target.bind(this, targetId);\n    const inputProps = targetProps.input && targetProps.input.bind(this);\n    this.targets.push({\n      targetId,\n      roleArn: targetProps.role?.roleArn,\n      rule: this.resource.name,\n      arn: targetProps.arn,\n      ecsTarget: targetProps.ecsParameters,\n      httpTarget: targetProps.httpParameters,\n      kinesisTarget: targetProps.kinesisParameters,\n      runCommandTargets: targetProps.runCommandParameters,\n      batchTarget: targetProps.batchParameters,\n      deadLetterConfig: targetProps.deadLetterConfig,\n      retryPolicy: targetProps.retryPolicy,\n      sqsTarget: targetProps.sqsParameters,\n      redshiftTarget: targetProps.redshiftDataParameters,\n      // TODO: not available in terraform-provider-aws\n      // appSyncParameters: targetProps.appSyncParameters,\n      input: inputProps && inputProps.input,\n      inputPath: inputProps && inputProps.inputPath,\n      inputTransformer:\n        inputProps?.inputTemplate !== undefined\n          ? {\n              inputTemplate: inputProps.inputTemplate,\n              inputPaths: inputProps.inputPathsMap,\n            }\n          : undefined,\n    });\n  }\n\n  /**\n   * Adds resource to the Terraform JSON output at Synth time.\n   *\n   * called by TerraformStack.prepareStack()\n   */\n  public toTerraform(): any {\n    /**\n     * A preparing resolve might add new resources to the stack\n     */\n    for (const target of this.targets) {\n      // note: targetId is calculated in addTarget()\n      // TODO: Ideally we should have used IResolvable.resolve and use the IResolveContext.preparing flag\n      // ref: https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-iam/lib/policy-document.ts#L48\n      if (this.node.tryFindChild(target.targetId!)) continue; // ignore if already generated\n      new cloudwatchEventTarget.CloudwatchEventTarget(\n        this,\n        target.targetId!,\n        target,\n      );\n    }\n    return {};\n  }\n}\n"]}

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

@@ -0,0 +1,83 @@
+import { Construct } from "constructs";
+import { Duration } from "../..";
+/**
+ * Schedule for scheduled event rules
+ *
+ * Note that rates cannot be defined in fractions of minutes.
+ *
+ * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/scheduled-events.html
+ */
+export declare abstract class Schedule {
+    /**
+     * Construct a schedule from a literal schedule expression
+     *
+     * @param expression The expression to use. Must be in a format that EventBridge will recognize
+     */
+    static expression(expression: string): Schedule;
+    /**
+     * Construct a schedule from an interval and a time unit
+     *
+     * Rates may be defined with any unit of time, but when converted into minutes, the duration must be a positive whole number of minutes.
+     */
+    static rate(duration: Duration): Schedule;
+    /**
+     * Create a schedule from a set of cron fields
+     */
+    static cron(options: CronOptions): Schedule;
+    /**
+     * Retrieve the expression for this schedule
+     */
+    abstract readonly expressionString: string;
+    protected constructor();
+    /**
+     *
+     * @internal
+     */
+    abstract _bind(scope: Construct): void;
+}
+/**
+ * Options to configure a cron expression
+ *
+ * All fields are strings so you can use complex expressions. Absence of
+ * a field implies '*' or '?', whichever one is appropriate.
+ *
+ * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/scheduled-events.html#cron-expressions
+ */
+export interface CronOptions {
+    /**
+     * The minute to run this rule at
+     *
+     * @default - Every minute
+     */
+    readonly minute?: string;
+    /**
+     * The hour to run this rule at
+     *
+     * @default - Every hour
+     */
+    readonly hour?: string;
+    /**
+     * The day of the month to run this rule at
+     *
+     * @default - Every day of the month
+     */
+    readonly day?: string;
+    /**
+     * The month to run this rule at
+     *
+     * @default - Every month
+     */
+    readonly month?: string;
+    /**
+     * The year to run this rule at
+     *
+     * @default - Every year
+     */
+    readonly year?: string;
+    /**
+     * The day of the week to run this rule at
+     *
+     * @default - Any day of the week
+     */
+    readonly weekDay?: string;
+}

package/lib/aws/notify/schedule.js

@@ -0,0 +1,116 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Schedule = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.156.0/packages/aws-cdk-lib/aws-events/lib/schedule.ts
+const cdktf_1 = require("cdktf");
+/**
+ * Schedule for scheduled event rules
+ *
+ * Note that rates cannot be defined in fractions of minutes.
+ *
+ * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/scheduled-events.html
+ */
+class Schedule {
+    /**
+     * Construct a schedule from a literal schedule expression
+     *
+     * @param expression The expression to use. Must be in a format that EventBridge will recognize
+     */
+    static expression(expression) {
+        return new LiteralSchedule(expression);
+    }
+    /**
+     * Construct a schedule from an interval and a time unit
+     *
+     * Rates may be defined with any unit of time, but when converted into minutes, the duration must be a positive whole number of minutes.
+     */
+    static rate(duration) {
+        if (duration.isUnresolved()) {
+            const validDurationUnit = [
+                "minute",
+                "minutes",
+                "hour",
+                "hours",
+                "day",
+                "days",
+            ];
+            if (validDurationUnit.indexOf(duration.unitLabel()) === -1) {
+                throw new Error("Allowed units for scheduling are: 'minute', 'minutes', 'hour', 'hours', 'day', 'days'");
+            }
+            return new LiteralSchedule(`rate(${duration.formatTokenToNumber()})`);
+        }
+        if (duration.toMinutes() === 0) {
+            throw new Error("Duration cannot be 0");
+        }
+        let rate = maybeRate(duration.toDays({ integral: false }), "day");
+        if (rate === undefined) {
+            rate = maybeRate(duration.toHours({ integral: false }), "hour");
+        }
+        if (rate === undefined) {
+            rate = makeRate(duration.toMinutes({ integral: true }), "minute");
+        }
+        return new LiteralSchedule(rate);
+    }
+    /**
+     * Create a schedule from a set of cron fields
+     */
+    static cron(options) {
+        if (options.weekDay !== undefined && options.day !== undefined) {
+            throw new Error("Cannot supply both 'day' and 'weekDay', use at most one");
+        }
+        const minute = fallback(options.minute, "*");
+        const hour = fallback(options.hour, "*");
+        const month = fallback(options.month, "*");
+        const year = fallback(options.year, "*");
+        // Weekday defaults to '?' if not supplied. If it is supplied, day must become '?'
+        const day = fallback(options.day, options.weekDay !== undefined ? "?" : "*");
+        const weekDay = fallback(options.weekDay, "?");
+        return new (class extends Schedule {
+            constructor() {
+                super(...arguments);
+                this.expressionString = `cron(${minute} ${hour} ${day} ${month} ${weekDay} ${year})`;
+            }
+            _bind(scope) {
+                if (!options.minute) {
+                    // "@aws-cdk/aws-events:scheduleWillRunEveryMinute",
+                    cdktf_1.Annotations.of(scope).addWarning("cron: If you don't pass 'minute', by default the event runs every minute. Pass 'minute: '*'' if that's what you intend, or 'minute: 0' to run once per hour instead.");
+                }
+                return new LiteralSchedule(this.expressionString);
+            }
+        })();
+    }
+    constructor() { }
+}
+exports.Schedule = Schedule;
+_a = JSII_RTTI_SYMBOL_1;
+Schedule[_a] = { fqn: "terraconstructs.aws.notify.Schedule", version: "0.0.8" };
+class LiteralSchedule extends Schedule {
+    constructor(expressionString) {
+        super();
+        this.expressionString = expressionString;
+    }
+    _bind() { }
+}
+function fallback(x, def) {
+    return x ?? def;
+}
+/**
+ * Return the rate if the rate is whole number
+ */
+function maybeRate(interval, singular) {
+    if (interval === 0 || !Number.isInteger(interval)) {
+        return undefined;
+    }
+    return makeRate(interval, singular);
+}
+/**
+ * Return 'rate(${interval} ${singular}(s))` for the interval
+ */
+function makeRate(interval, singular) {
+    return interval === 1
+        ? `rate(1 ${singular})`
+        : `rate(${interval} ${singular}s)`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schedule.js","sourceRoot":"","sources":["../../../src/aws/notify/schedule.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.156.0/packages/aws-cdk-lib/aws-events/lib/schedule.ts\nimport { Annotations } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { Duration } from \"../..\";\n\n/**\n * Schedule for scheduled event rules\n *\n * Note that rates cannot be defined in fractions of minutes.\n *\n * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/scheduled-events.html\n */\nexport abstract class Schedule {\n  /**\n   * Construct a schedule from a literal schedule expression\n   *\n   * @param expression The expression to use. Must be in a format that EventBridge will recognize\n   */\n  public static expression(expression: string): Schedule {\n    return new LiteralSchedule(expression);\n  }\n\n  /**\n   * Construct a schedule from an interval and a time unit\n   *\n   * Rates may be defined with any unit of time, but when converted into minutes, the duration must be a positive whole number of minutes.\n   */\n  public static rate(duration: Duration): Schedule {\n    if (duration.isUnresolved()) {\n      const validDurationUnit = [\n        \"minute\",\n        \"minutes\",\n        \"hour\",\n        \"hours\",\n        \"day\",\n        \"days\",\n      ];\n      if (validDurationUnit.indexOf(duration.unitLabel()) === -1) {\n        throw new Error(\n          \"Allowed units for scheduling are: 'minute', 'minutes', 'hour', 'hours', 'day', 'days'\",\n        );\n      }\n      return new LiteralSchedule(`rate(${duration.formatTokenToNumber()})`);\n    }\n    if (duration.toMinutes() === 0) {\n      throw new Error(\"Duration cannot be 0\");\n    }\n\n    let rate = maybeRate(duration.toDays({ integral: false }), \"day\");\n    if (rate === undefined) {\n      rate = maybeRate(duration.toHours({ integral: false }), \"hour\");\n    }\n    if (rate === undefined) {\n      rate = makeRate(duration.toMinutes({ integral: true }), \"minute\");\n    }\n    return new LiteralSchedule(rate);\n  }\n\n  /**\n   * Create a schedule from a set of cron fields\n   */\n  public static cron(options: CronOptions): Schedule {\n    if (options.weekDay !== undefined && options.day !== undefined) {\n      throw new Error(\n        \"Cannot supply both 'day' and 'weekDay', use at most one\",\n      );\n    }\n\n    const minute = fallback(options.minute, \"*\");\n    const hour = fallback(options.hour, \"*\");\n    const month = fallback(options.month, \"*\");\n    const year = fallback(options.year, \"*\");\n\n    // Weekday defaults to '?' if not supplied. If it is supplied, day must become '?'\n    const day = fallback(\n      options.day,\n      options.weekDay !== undefined ? \"?\" : \"*\",\n    );\n    const weekDay = fallback(options.weekDay, \"?\");\n\n    return new (class extends Schedule {\n      public readonly expressionString: string = `cron(${minute} ${hour} ${day} ${month} ${weekDay} ${year})`;\n      public _bind(scope: Construct) {\n        if (!options.minute) {\n          // \"@aws-cdk/aws-events:scheduleWillRunEveryMinute\",\n          Annotations.of(scope).addWarning(\n            \"cron: If you don't pass 'minute', by default the event runs every minute. Pass 'minute: '*'' if that's what you intend, or 'minute: 0' to run once per hour instead.\",\n          );\n        }\n        return new LiteralSchedule(this.expressionString);\n      }\n    })();\n  }\n\n  /**\n   * Retrieve the expression for this schedule\n   */\n  public abstract readonly expressionString: string;\n\n  protected constructor() {}\n\n  /**\n   *\n   * @internal\n   */\n  public abstract _bind(scope: Construct): void;\n}\n\n/**\n * Options to configure a cron expression\n *\n * All fields are strings so you can use complex expressions. Absence of\n * a field implies '*' or '?', whichever one is appropriate.\n *\n * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/scheduled-events.html#cron-expressions\n */\nexport interface CronOptions {\n  /**\n   * The minute to run this rule at\n   *\n   * @default - Every minute\n   */\n  readonly minute?: string;\n\n  /**\n   * The hour to run this rule at\n   *\n   * @default - Every hour\n   */\n  readonly hour?: string;\n\n  /**\n   * The day of the month to run this rule at\n   *\n   * @default - Every day of the month\n   */\n  readonly day?: string;\n\n  /**\n   * The month to run this rule at\n   *\n   * @default - Every month\n   */\n  readonly month?: string;\n\n  /**\n   * The year to run this rule at\n   *\n   * @default - Every year\n   */\n  readonly year?: string;\n\n  /**\n   * The day of the week to run this rule at\n   *\n   * @default - Any day of the week\n   */\n  readonly weekDay?: string;\n}\n\nclass LiteralSchedule extends Schedule {\n  constructor(public readonly expressionString: string) {\n    super();\n  }\n\n  public _bind() {}\n}\n\nfunction fallback<T>(x: T | undefined, def: T): T {\n  return x ?? def;\n}\n\n/**\n * Return the rate if the rate is whole number\n */\nfunction maybeRate(interval: number, singular: string) {\n  if (interval === 0 || !Number.isInteger(interval)) {\n    return undefined;\n  }\n  return makeRate(interval, singular);\n}\n\n/**\n * Return 'rate(${interval} ${singular}(s))` for the interval\n */\nfunction makeRate(interval: number, singular: string) {\n  return interval === 1\n    ? `rate(1 ${singular})`\n    : `rate(${interval} ${singular}s)`;\n}\n"]}

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

@@ -0,0 +1,102 @@
+import { cloudwatchEventTarget } from "@cdktf/provider-aws";
+import { IConstruct } from "constructs";
+import { IRule } from ".";
+import { RuleTargetInput } from "./input";
+import * as iam from "../iam";
+/**
+ * An abstract target for EventRules.
+ */
+export interface IRuleTarget {
+    /**
+     * Returns the rule target specification.
+     * NOTE: Do not use the various `inputXxx` options. They can be set in a call to `addTarget`.
+     *
+     * @param rule The EventBridge Rule that would trigger this target.
+     * @param id The id of the target that will be attached to the rule.
+     */
+    bind(rule: IRule, id?: string): RuleTargetConfig;
+}
+/**
+ * Properties for an event rule target
+ */
+export interface RuleTargetConfig {
+    /**
+     * The Amazon Resource Name (ARN) of the target.
+     */
+    readonly arn: string;
+    /**
+     * Role to use to invoke this event target
+     */
+    readonly role?: iam.IRole;
+    /**
+     * Parameters used when the rule invokes Amazon AWS Batch Job/Queue
+     * @default no parameters set
+     */
+    readonly batchParameters?: cloudwatchEventTarget.CloudwatchEventTargetBatchTarget;
+    /**
+     * Contains information about a dead-letter queue configuration.
+     * @default no dead-letter queue set
+     */
+    readonly deadLetterConfig?: cloudwatchEventTarget.CloudwatchEventTargetDeadLetterConfig;
+    /**
+     * A RetryPolicy object that includes information about the retry policy settings.
+     * @default EventBridge default retry policy
+     */
+    readonly retryPolicy?: cloudwatchEventTarget.CloudwatchEventTargetRetryPolicy;
+    /**
+     * Parameters used when you are using the rule to invoke Amazon EC2 Run Command.
+     * A maximum of 5 are allowed
+     */
+    readonly runCommandTargets?: cloudwatchEventTarget.CloudwatchEventTargetRunCommandTargets[];
+    /**
+     * The Amazon ECS task definition and task count to use, if the event target
+     * is an Amazon ECS task.
+     */
+    readonly ecsParameters?: cloudwatchEventTarget.CloudwatchEventTargetEcsTarget;
+    /**
+     * Contains the HTTP parameters to use when the target is a API Gateway REST endpoint
+     * or EventBridge API destination.
+     * @default - None
+     */
+    readonly httpParameters?: cloudwatchEventTarget.CloudwatchEventTargetHttpTarget;
+    /**
+     * Settings that control shard assignment, when the target is a Kinesis
+     * stream. If you don't include this parameter, eventId is used as the
+     * partition key.
+     */
+    readonly kinesisParameters?: cloudwatchEventTarget.CloudwatchEventTargetKinesisTarget;
+    /**
+     * Parameters used when the rule invokes Amazon EC2 Systems Manager Run
+     * Command.
+     */
+    readonly runCommandParameters?: cloudwatchEventTarget.CloudwatchEventTargetRunCommandTargets[];
+    /**
+     * Parameters used when the FIFO sqs queue is used an event target by the
+     * rule.
+     */
+    readonly sqsParameters?: cloudwatchEventTarget.CloudwatchEventTargetSqsTarget;
+    /**
+     * Parameters used when the rule invokes Amazon Redshift Queries
+     *
+     * @default - no parameters set
+     */
+    readonly redshiftDataParameters?: cloudwatchEventTarget.CloudwatchEventTargetRedshiftTarget;
+    /**
+     * What input to send to the event target
+     *
+     * @default the entire event
+     */
+    readonly input?: RuleTargetInput;
+    /**
+     * The resource that is backing this target.
+     * This is the resource that will actually have some action performed on it when used as a target
+     * (for example, start a build for a CodeBuild project).
+     * We need it to determine whether the rule belongs to a different account than the target -
+     * if so, we generate a more complex setup,
+     * including an additional stack containing the EventBusPolicy.
+     *
+     * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/eventbridge-cross-account-event-delivery.html
+     * @default the target is not backed by any resource
+     */
+    readonly targetResource?: IConstruct;
+}

package/lib/aws/notify/target.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/notify/targets/event-bus.d.ts

@@ -0,0 +1,39 @@
+import { IEventBus } from "../event-bus";
+import { IQueue } from "../queue";
+import { IRule } from "../rule";
+import { IRuleTarget, RuleTargetConfig } from "../target";
+import * as iam from "../../iam";
+/**
+ * Configuration properties of an Event Bus event
+ *
+ * Cannot extend TargetBaseProps. Retry policy is not supported for Event bus targets.
+ */
+export interface EventBusProps {
+    /**
+     * Role to be used to publish the event
+     *
+     * @default a new role is created.
+     */
+    readonly role?: iam.IRole;
+    /**
+     * The SQS queue to be used as deadLetterQueue.
+     * Check out the [considerations for using a dead-letter queue](https://docs.aws.amazon.com/eventbridge/latest/userguide/rule-dlq.html#dlq-considerations).
+     *
+     * The events not successfully delivered are automatically retried for a specified period of time,
+     * depending on the retry policy of the target.
+     * If an event is not delivered before all retry attempts are exhausted, it will be sent to the dead letter queue.
+     *
+     * @default - no dead-letter queue
+     */
+    readonly deadLetterQueue?: IQueue;
+}
+/**
+ * Notify an existing Event Bus of an event
+ */
+export declare class EventBus implements IRuleTarget {
+    private readonly eventBus;
+    private readonly props;
+    constructor(eventBus: IEventBus, props?: EventBusProps);
+    bind(rule: IRule, _id?: string): RuleTargetConfig;
+    private putEventStatement;
+}