@aws-cdk/aws-events/lib/rule.js

"use strict";
var _a;
Object.defineProperty(exports, "__esModule", { value: true });
exports.Rule = void 0;
const jsiiDeprecationWarnings = require("../.warnings.jsii.js");
const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
const aws_iam_1 = require("@aws-cdk/aws-iam");
const core_1 = require("@aws-cdk/core");
const constructs_1 = require("constructs");
const events_generated_1 = require("./events.generated");
const schedule_1 = require("./schedule");
const util_1 = require("./util");
/**
 * Defines an EventBridge Rule in this stack.
 *
 * @resource AWS::Events::Rule
 */
class Rule extends core_1.Resource {
    constructor(scope, id, props = {}) {
        var _b, _c;
        super(scope, id, {
            physicalName: props.ruleName,
        });
        this.targets = new Array();
        this.eventPattern = {};
        /** Set to keep track of what target accounts and regions we've already created event buses for */
        this._xEnvTargetsAdded = new Set();
        try {
            jsiiDeprecationWarnings._aws_cdk_aws_events_RuleProps(props);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.constructor);
            }
            throw error;
        }
        if (props.eventBus && props.schedule) {
            throw new Error('Cannot associate rule with \'eventBus\' when using \'schedule\'');
        }
        this.description = props.description;
        this.scheduleExpression = (_b = props.schedule) === null || _b === void 0 ? void 0 : _b.expressionString;
        // add a warning on synth when minute is not defined in a cron schedule
        (_c = props.schedule) === null || _c === void 0 ? void 0 : _c._bind(this);
        const resource = new events_generated_1.CfnRule(this, 'Resource', {
            name: this.physicalName,
            description: this.description,
            state: props.enabled == null ? 'ENABLED' : (props.enabled ? 'ENABLED' : 'DISABLED'),
            scheduleExpression: this.scheduleExpression,
            eventPattern: core_1.Lazy.any({ produce: () => this._renderEventPattern() }),
            targets: core_1.Lazy.any({ produce: () => this.renderTargets() }),
            eventBusName: props.eventBus && props.eventBus.eventBusName,
        });
        this.ruleArn = this.getResourceArnAttribute(resource.attrArn, {
            service: 'events',
            resource: 'rule',
            resourceName: this.physicalName,
        });
        this.ruleName = this.getResourceNameAttribute(resource.ref);
        this.addEventPattern(props.eventPattern);
        for (const target of props.targets || []) {
            this.addTarget(target);
        }
    }
    /**
     * 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 = core_1.Stack.of(scope).splitArn(eventRuleArn, core_1.ArnFormat.SLASH_RESOURCE_NAME);
        class Import extends core_1.Resource {
            constructor() {
                super(...arguments);
                this.ruleArn = eventRuleArn;
                this.ruleName = parts.resourceName || '';
            }
        }
        return new Import(scope, id);
    }
    /**
     * 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) {
        var _b, _c, _d;
        try {
            jsiiDeprecationWarnings._aws_cdk_aws_events_IRuleTarget(target);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.addTarget);
            }
            throw error;
        }
        if (!target) {
            return;
        }
        // Simply increment id for each `addTarget` call. This is guaranteed to be unique.
        const autoGeneratedId = `Target${this.targets.length}`;
        const targetProps = target.bind(this, autoGeneratedId);
        const inputProps = targetProps.input && targetProps.input.bind(this);
        const roleArn = (_b = targetProps.role) === null || _b === void 0 ? void 0 : _b.roleArn;
        const id = targetProps.id || autoGeneratedId;
        if (targetProps.targetResource) {
            const targetStack = core_1.Stack.of(targetProps.targetResource);
            const targetAccount = ((_c = targetProps.targetResource.env) === null || _c === void 0 ? void 0 : _c.account) || targetStack.account;
            const targetRegion = ((_d = targetProps.targetResource.env) === null || _d === void 0 ? void 0 : _d.region) || targetStack.region;
            const sourceStack = core_1.Stack.of(this);
            const sourceAccount = sourceStack.account;
            const sourceRegion = sourceStack.region;
            // if the target is in a different account or region and is defined in this CDK App
            // we can generate all the needed components:
            // - forwarding rule in the source stack (target: default event bus of the receiver region)
            // - eventbus permissions policy (creating an extra stack)
            // - receiver rule in the target stack (target: the actual target)
            if (!util_1.sameEnvDimension(sourceAccount, targetAccount) || !util_1.sameEnvDimension(sourceRegion, targetRegion)) {
                // cross-account and/or cross-region event - strap in, this works differently than regular events!
                // based on:
                // https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-cross-account.html
                // for cross-account or cross-region events, we require a concrete target account and region
                if (!targetAccount || core_1.Token.isUnresolved(targetAccount)) {
                    throw new Error('You need to provide a concrete account for the target stack when using cross-account or cross-region events');
                }
                if (!targetRegion || core_1.Token.isUnresolved(targetRegion)) {
                    throw new Error('You need to provide a concrete region for the target stack when using cross-account or cross-region events');
                }
                if (core_1.Token.isUnresolved(sourceAccount)) {
                    throw new Error('You need to provide a concrete account for the source stack when using cross-account or cross-region events');
                }
                // Don't exactly understand why this code was here (seems unlikely this rule would be violated), but
                // let's leave it in nonetheless.
                const sourceApp = this.node.root;
                if (!sourceApp || !core_1.App.isApp(sourceApp)) {
                    throw new Error('Event stack which uses cross-account or cross-region targets must be part of a CDK app');
                }
                const targetApp = constructs_1.Node.of(targetProps.targetResource).root;
                if (!targetApp || !core_1.App.isApp(targetApp)) {
                    throw new Error('Target stack which uses cross-account or cross-region event targets must be part of a CDK app');
                }
                if (sourceApp !== targetApp) {
                    throw new Error('Event stack and target stack must belong to the same CDK app');
                }
                // The target of this Rule will be the default event bus of the target environment
                this.ensureXEnvTargetEventBus(targetStack, targetAccount, targetRegion, id);
                // The actual rule lives in the target stack. Other than the account, it's identical to this one,
                // but only evaluated at render time (via a special subclass).
                //
                // FIXME: the MirrorRule is a bit silly, forwarding the exact same event to another event bus
                // and trigger on it there (there will be issues with construct references, for example). Especially
                // in the case of scheduled events, we will just trigger both rules in parallel in both environments.
                //
                // A better solution would be to have the source rule add a unique token to the the event,
                // and have the mirror rule trigger on that token only (thereby properly separating triggering, which
                // happens in the source env; and activating, which happens in the target env).
                //
                // Don't have time to do that right now.
                const mirrorRuleScope = this.obtainMirrorRuleScope(targetStack, targetAccount, targetRegion);
                new MirrorRule(mirrorRuleScope, `${core_1.Names.uniqueId(this)}-${id}`, {
                    targets: [target],
                    eventPattern: this.eventPattern,
                    schedule: this.scheduleExpression ? schedule_1.Schedule.expression(this.scheduleExpression) : undefined,
                    description: this.description,
                }, this);
                return;
            }
        }
        // Here only if the target does not have a targetResource defined.
        // In such case we don't have to generate any extra component.
        // Note that this can also be an imported resource (i.e: EventBus target)
        this.targets.push({
            id,
            arn: targetProps.arn,
            roleArn,
            ecsParameters: targetProps.ecsParameters,
            httpParameters: targetProps.httpParameters,
            kinesisParameters: targetProps.kinesisParameters,
            runCommandParameters: targetProps.runCommandParameters,
            batchParameters: targetProps.batchParameters,
            deadLetterConfig: targetProps.deadLetterConfig,
            retryPolicy: targetProps.retryPolicy,
            sqsParameters: targetProps.sqsParameters,
            input: inputProps && inputProps.input,
            inputPath: inputProps && inputProps.inputPath,
            inputTransformer: (inputProps === null || inputProps === void 0 ? void 0 : inputProps.inputTemplate) !== undefined ? {
                inputTemplate: inputProps.inputTemplate,
                inputPathsMap: inputProps.inputPathsMap,
            } : undefined,
        });
    }
    /**
     * 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) {
        try {
            jsiiDeprecationWarnings._aws_cdk_aws_events_EventPattern(eventPattern);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.addEventPattern);
            }
            throw error;
        }
        if (!eventPattern) {
            return;
        }
        util_1.mergeEventPattern(this.eventPattern, eventPattern);
    }
    /**
     * Not private only to be overrideen in CopyRule.
     *
     * @internal
     */
    _renderEventPattern() {
        return util_1.renderEventPattern(this.eventPattern);
    }
    validate() {
        if (Object.keys(this.eventPattern).length === 0 && !this.scheduleExpression) {
            return ['Either \'eventPattern\' or \'schedule\' must be defined'];
        }
        return [];
    }
    renderTargets() {
        if (this.targets.length === 0) {
            return undefined;
        }
        return this.targets;
    }
    /**
     * Make sure we add the target environments event bus as a target, and the target has permissions set up to receive our events
     *
     * For cross-account rules, uses a support stack to set up a policy on the target event bus.
     */
    ensureXEnvTargetEventBus(targetStack, targetAccount, targetRegion, id) {
        // the _actual_ target is just the event bus of the target's account
        // make sure we only add it once per account per region
        const key = `${targetAccount}:${targetRegion}`;
        if (this._xEnvTargetsAdded.has(key)) {
            return;
        }
        this._xEnvTargetsAdded.add(key);
        const eventBusArn = targetStack.formatArn({
            service: 'events',
            resource: 'event-bus',
            resourceName: 'default',
            region: targetRegion,
            account: targetAccount,
        });
        // For some reason, cross-region requires a Role (with `PutEvents` on the
        // target event bus) while cross-account doesn't
        const roleArn = !util_1.sameEnvDimension(targetRegion, core_1.Stack.of(this).region)
            ? this.crossRegionPutEventsRole(eventBusArn).roleArn
            : undefined;
        this.targets.push({
            id,
            arn: eventBusArn,
            roleArn,
        });
        // Add a policy to the target Event Bus to allow the source account/region to publish into it.
        //
        // Since this Event Bus permission needs to be deployed before the stack containing the Rule is deployed
        // (as EventBridge verifies whether you have permissions to the targets on rule creation), this needs
        // to be in a support stack.
        const sourceApp = this.node.root;
        const sourceAccount = core_1.Stack.of(this).account;
        // If different accounts, we need to add the permissions to the target eventbus
        //
        // For different region, no need for a policy on the target event bus (but a need
        // for a role).
        if (!util_1.sameEnvDimension(sourceAccount, targetAccount)) {
            const stackId = `EventBusPolicy-${sourceAccount}-${targetRegion}-${targetAccount}`;
            let eventBusPolicyStack = sourceApp.node.tryFindChild(stackId);
            if (!eventBusPolicyStack) {
                eventBusPolicyStack = new core_1.Stack(sourceApp, stackId, {
                    env: {
                        account: targetAccount,
                        region: targetRegion,
                    },
                    // The region in the stack name is rather redundant (it will always be the target region)
                    // Leaving it in for backwards compatibility.
                    stackName: `${targetStack.stackName}-EventBusPolicy-support-${targetRegion}-${sourceAccount}`,
                });
                new events_generated_1.CfnEventBusPolicy(eventBusPolicyStack, 'GivePermToOtherAccount', {
                    action: 'events:PutEvents',
                    statementId: `Allow-account-${sourceAccount}-${this.node.addr}`,
                    principal: sourceAccount,
                });
            }
            // deploy the event bus permissions before the source stack
            core_1.Stack.of(this).addDependency(eventBusPolicyStack);
        }
    }
    /**
     * Return the scope where the mirror rule should be created for x-env event targets
     *
     * This is the target resource's containing stack if it shares the same region (owned
     * resources), or should be a fresh support stack for imported resources.
     *
     * We don't implement the second yet, as I have to think long and hard on whether we
     * can reuse the existing support stack or not, and I don't have time for that right now.
     */
    obtainMirrorRuleScope(targetStack, targetAccount, targetRegion) {
        // for cross-account or cross-region events, we cannot create new components for an imported resource
        // because we don't have the target stack
        if (util_1.sameEnvDimension(targetStack.account, targetAccount) && util_1.sameEnvDimension(targetStack.region, targetRegion)) {
            return targetStack;
        }
        // For now, we don't do the work for the support stack yet
        throw new Error('Cannot create a cross-account or cross-region rule for an imported resource (create a stack with the right environment for the imported resource)');
    }
    /**
     * Obtain the Role for the EventBridge event
     *
     * If a role already exists, it will be returned. This ensures that if multiple
     * events have the same target, they will share a role.
     * @internal
     */
    crossRegionPutEventsRole(eventBusArn) {
        const id = 'EventsRole';
        let role = this.node.tryFindChild(id);
        if (!role) {
            role = new aws_iam_1.Role(this, id, {
                roleName: core_1.PhysicalName.GENERATE_IF_NEEDED,
                assumedBy: new aws_iam_1.ServicePrincipal('events.amazonaws.com'),
            });
        }
        role.addToPrincipalPolicy(new aws_iam_1.PolicyStatement({
            actions: ['events:PutEvents'],
            resources: [eventBusArn],
        }));
        return role;
    }
}
exports.Rule = Rule;
_a = JSII_RTTI_SYMBOL_1;
Rule[_a] = { fqn: "@aws-cdk/aws-events.Rule", version: "1.155.0" };
/**
 * A rule that mirrors another rule
 */
class MirrorRule extends Rule {
    constructor(scope, id, props, source) {
        super(scope, id, props);
        this.source = source;
    }
    _renderEventPattern() {
        return this.source._renderEventPattern();
    }
    /**
     * Override validate to be a no-op
     *
     * The rules are never stored on this object so there's nothing to validate.
     *
     * Instead, we mirror the other rule at render time.
     */
    validate() {
        return [];
    }
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.js","sourceRoot":"","sources":["rule.ts"],"names":[],"mappings":"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","sourcesContent":["import { IRole, PolicyStatement, Role, ServicePrincipal } from '@aws-cdk/aws-iam';\nimport { App, IResource, Lazy, Names, Resource, Stack, Token, PhysicalName, ArnFormat } from '@aws-cdk/core';\nimport { Node, Construct } from 'constructs';\nimport { IEventBus } from './event-bus';\nimport { EventPattern } from './event-pattern';\nimport { CfnEventBusPolicy, CfnRule } from './events.generated';\nimport { IRule } from './rule-ref';\nimport { Schedule } from './schedule';\nimport { IRuleTarget } from './target';\nimport { mergeEventPattern, renderEventPattern, sameEnvDimension } from './util';\n\n/**\n * Properties for defining an EventBridge Rule\n */\nexport interface RuleProps {\n  /**\n   * A description of the rule's purpose.\n   *\n   * @default - No description.\n   */\n  readonly description?: string;\n\n  /**\n   * A name for the rule.\n   *\n   * @default - AWS CloudFormation generates a unique physical ID and uses that ID\n   * for the rule name. For more information, see Name Type.\n   */\n  readonly ruleName?: string;\n\n  /**\n   * Indicates whether the rule is enabled.\n   *\n   * @default true\n   */\n  readonly enabled?: boolean;\n\n  /**\n   * The schedule or rate (frequency) that determines when EventBridge\n   * runs the rule. 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   * You must specify this property, the `eventPattern` property, or both.\n   *\n   * @default - None.\n   */\n  readonly schedule?: Schedule;\n\n  /**\n   * Describes which events EventBridge routes to the specified target.\n   * These routed events are matched events. For more information, see Events\n   * and Event Patterns in the Amazon EventBridge User Guide.\n   *\n   * @see\n   * https://docs.aws.amazon.com/eventbridge/latest/userguide/eventbridge-and-event-patterns.html\n   *\n   * You must specify this property (either via props or via\n   * `addEventPattern`), the `scheduleExpression` property, or both. The\n   * method `addEventPattern` can be used to add filter values to the event\n   * pattern.\n   *\n   * @default - None.\n   */\n  readonly eventPattern?: EventPattern;\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/**\n * Defines an EventBridge Rule in this stack.\n *\n * @resource AWS::Events::Rule\n */\nexport class Rule extends Resource implements IRule {\n\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(scope: Construct, id: string, eventRuleArn: string): IRule {\n    const parts = Stack.of(scope).splitArn(eventRuleArn, ArnFormat.SLASH_RESOURCE_NAME);\n\n    class Import extends Resource implements IRule {\n      public ruleArn = eventRuleArn;\n      public ruleName = parts.resourceName || '';\n    }\n    return new Import(scope, id);\n  }\n\n  public readonly ruleArn: string;\n  public readonly ruleName: string;\n\n  private readonly targets = new Array<CfnRule.TargetProperty>();\n  private readonly eventPattern: EventPattern = { };\n  private readonly scheduleExpression?: string;\n  private readonly description?: string;\n\n  /** Set to keep track of what target accounts and regions we've already created event buses for */\n  private readonly _xEnvTargetsAdded = new Set<string>();\n\n  constructor(scope: Construct, id: string, props: RuleProps = { }) {\n    super(scope, id, {\n      physicalName: props.ruleName,\n    });\n\n    if (props.eventBus && props.schedule) {\n      throw new Error('Cannot associate rule with \\'eventBus\\' when using \\'schedule\\'');\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    const resource = new CfnRule(this, 'Resource', {\n      name: this.physicalName,\n      description: this.description,\n      state: props.enabled == null ? 'ENABLED' : (props.enabled ? 'ENABLED' : 'DISABLED'),\n      scheduleExpression: this.scheduleExpression,\n      eventPattern: Lazy.any({ produce: () => this._renderEventPattern() }),\n      targets: Lazy.any({ produce: () => this.renderTargets() }),\n      eventBusName: props.eventBus && props.eventBus.eventBusName,\n    });\n\n    this.ruleArn = this.getResourceArnAttribute(resource.attrArn, {\n      service: 'events',\n      resource: 'rule',\n      resourceName: this.physicalName,\n    });\n    this.ruleName = this.getResourceNameAttribute(resource.ref);\n\n    this.addEventPattern(props.eventPattern);\n\n    for (const target of props.targets || []) {\n      this.addTarget(target);\n    }\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) { return; }\n\n    // Simply increment id for each `addTarget` call. This is guaranteed to be unique.\n    const autoGeneratedId = `Target${this.targets.length}`;\n\n    const targetProps = target.bind(this, autoGeneratedId);\n    const inputProps = targetProps.input && targetProps.input.bind(this);\n\n    const roleArn = targetProps.role?.roleArn;\n    const id = targetProps.id || autoGeneratedId;\n\n    if (targetProps.targetResource) {\n      const targetStack = Stack.of(targetProps.targetResource);\n\n      const targetAccount = (targetProps.targetResource as IResource).env?.account || targetStack.account;\n      const targetRegion = (targetProps.targetResource as IResource).env?.region || targetStack.region;\n\n      const sourceStack = Stack.of(this);\n      const sourceAccount = sourceStack.account;\n      const sourceRegion = sourceStack.region;\n\n      // if the target is in a different account or region and is defined in this CDK App\n      // we can generate all the needed components:\n      // - forwarding rule in the source stack (target: default event bus of the receiver region)\n      // - eventbus permissions policy (creating an extra stack)\n      // - receiver rule in the target stack (target: the actual target)\n      if (!sameEnvDimension(sourceAccount, targetAccount) || !sameEnvDimension(sourceRegion, targetRegion)) {\n        // cross-account and/or cross-region event - strap in, this works differently than regular events!\n        // based on:\n        // https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-cross-account.html\n\n        // for cross-account or cross-region events, we require a concrete target account and region\n        if (!targetAccount || Token.isUnresolved(targetAccount)) {\n          throw new Error('You need to provide a concrete account for the target stack when using cross-account or cross-region events');\n        }\n        if (!targetRegion || Token.isUnresolved(targetRegion)) {\n          throw new Error('You need to provide a concrete region for the target stack when using cross-account or cross-region events');\n        }\n        if (Token.isUnresolved(sourceAccount)) {\n          throw new Error('You need to provide a concrete account for the source stack when using cross-account or cross-region events');\n        }\n\n        // Don't exactly understand why this code was here (seems unlikely this rule would be violated), but\n        // let's leave it in nonetheless.\n        const sourceApp = this.node.root;\n        if (!sourceApp || !App.isApp(sourceApp)) {\n          throw new Error('Event stack which uses cross-account or cross-region targets must be part of a CDK app');\n        }\n        const targetApp = Node.of(targetProps.targetResource).root;\n        if (!targetApp || !App.isApp(targetApp)) {\n          throw new Error('Target stack which uses cross-account or cross-region event targets must be part of a CDK app');\n        }\n        if (sourceApp !== targetApp) {\n          throw new Error('Event stack and target stack must belong to the same CDK app');\n        }\n\n        // The target of this Rule will be the default event bus of the target environment\n        this.ensureXEnvTargetEventBus(targetStack, targetAccount, targetRegion, id);\n\n        // The actual rule lives in the target stack. Other than the account, it's identical to this one,\n        // but only evaluated at render time (via a special subclass).\n        //\n        // FIXME: the MirrorRule is a bit silly, forwarding the exact same event to another event bus\n        // and trigger on it there (there will be issues with construct references, for example). Especially\n        // in the case of scheduled events, we will just trigger both rules in parallel in both environments.\n        //\n        // A better solution would be to have the source rule add a unique token to the the event,\n        // and have the mirror rule trigger on that token only (thereby properly separating triggering, which\n        // happens in the source env; and activating, which happens in the target env).\n        //\n        // Don't have time to do that right now.\n        const mirrorRuleScope = this.obtainMirrorRuleScope(targetStack, targetAccount, targetRegion);\n        new MirrorRule(mirrorRuleScope, `${Names.uniqueId(this)}-${id}`, {\n          targets: [target],\n          eventPattern: this.eventPattern,\n          schedule: this.scheduleExpression ? Schedule.expression(this.scheduleExpression) : undefined,\n          description: this.description,\n        }, this);\n\n        return;\n      }\n    }\n\n    // Here only if the target does not have a targetResource defined.\n    // In such case we don't have to generate any extra component.\n    // Note that this can also be an imported resource (i.e: EventBus target)\n\n    this.targets.push({\n      id,\n      arn: targetProps.arn,\n      roleArn,\n      ecsParameters: targetProps.ecsParameters,\n      httpParameters: targetProps.httpParameters,\n      kinesisParameters: targetProps.kinesisParameters,\n      runCommandParameters: targetProps.runCommandParameters,\n      batchParameters: targetProps.batchParameters,\n      deadLetterConfig: targetProps.deadLetterConfig,\n      retryPolicy: targetProps.retryPolicy,\n      sqsParameters: targetProps.sqsParameters,\n      input: inputProps && inputProps.input,\n      inputPath: inputProps && inputProps.inputPath,\n      inputTransformer: inputProps?.inputTemplate !== undefined ? {\n        inputTemplate: inputProps.inputTemplate,\n        inputPathsMap: inputProps.inputPathsMap,\n      } : undefined,\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 validate() {\n    if (Object.keys(this.eventPattern).length === 0 && !this.scheduleExpression) {\n      return ['Either \\'eventPattern\\' or \\'schedule\\' must be defined'];\n    }\n\n    return [];\n  }\n\n  private renderTargets() {\n    if (this.targets.length === 0) {\n      return undefined;\n    }\n\n    return this.targets;\n  }\n\n  /**\n   * Make sure we add the target environments event bus as a target, and the target has permissions set up to receive our events\n   *\n   * For cross-account rules, uses a support stack to set up a policy on the target event bus.\n   */\n  private ensureXEnvTargetEventBus(targetStack: Stack, targetAccount: string, targetRegion: string, id: string) {\n    // the _actual_ target is just the event bus of the target's account\n    // make sure we only add it once per account per region\n    const key = `${targetAccount}:${targetRegion}`;\n    if (this._xEnvTargetsAdded.has(key)) { return; }\n    this._xEnvTargetsAdded.add(key);\n\n    const eventBusArn = targetStack.formatArn({\n      service: 'events',\n      resource: 'event-bus',\n      resourceName: 'default',\n      region: targetRegion,\n      account: targetAccount,\n    });\n\n    // For some reason, cross-region requires a Role (with `PutEvents` on the\n    // target event bus) while cross-account doesn't\n    const roleArn = !sameEnvDimension(targetRegion, Stack.of(this).region)\n      ? this.crossRegionPutEventsRole(eventBusArn).roleArn\n      : undefined;\n\n    this.targets.push({\n      id,\n      arn: eventBusArn,\n      roleArn,\n    });\n\n    // Add a policy to the target Event Bus to allow the source account/region to publish into it.\n    //\n    // Since this Event Bus permission needs to be deployed before the stack containing the Rule is deployed\n    // (as EventBridge verifies whether you have permissions to the targets on rule creation), this needs\n    // to be in a support stack.\n\n    const sourceApp = this.node.root as App;\n    const sourceAccount = Stack.of(this).account;\n\n    // If different accounts, we need to add the permissions to the target eventbus\n    //\n    // For different region, no need for a policy on the target event bus (but a need\n    // for a role).\n    if (!sameEnvDimension(sourceAccount, targetAccount)) {\n      const stackId = `EventBusPolicy-${sourceAccount}-${targetRegion}-${targetAccount}`;\n      let eventBusPolicyStack: Stack = sourceApp.node.tryFindChild(stackId) as Stack;\n      if (!eventBusPolicyStack) {\n        eventBusPolicyStack = new Stack(sourceApp, stackId, {\n          env: {\n            account: targetAccount,\n            region: targetRegion,\n          },\n          // The region in the stack name is rather redundant (it will always be the target region)\n          // Leaving it in for backwards compatibility.\n          stackName: `${targetStack.stackName}-EventBusPolicy-support-${targetRegion}-${sourceAccount}`,\n        });\n        new CfnEventBusPolicy(eventBusPolicyStack, 'GivePermToOtherAccount', {\n          action: 'events:PutEvents',\n          statementId: `Allow-account-${sourceAccount}-${this.node.addr}`,\n          principal: sourceAccount,\n        });\n      }\n      // deploy the event bus permissions before the source stack\n      Stack.of(this).addDependency(eventBusPolicyStack);\n    }\n  }\n\n  /**\n   * Return the scope where the mirror rule should be created for x-env event targets\n   *\n   * This is the target resource's containing stack if it shares the same region (owned\n   * resources), or should be a fresh support stack for imported resources.\n   *\n   * We don't implement the second yet, as I have to think long and hard on whether we\n   * can reuse the existing support stack or not, and I don't have time for that right now.\n   */\n  private obtainMirrorRuleScope(targetStack: Stack, targetAccount: string, targetRegion: string): Construct {\n    // for cross-account or cross-region events, we cannot create new components for an imported resource\n    // because we don't have the target stack\n    if (sameEnvDimension(targetStack.account, targetAccount) && sameEnvDimension(targetStack.region, targetRegion)) {\n      return targetStack;\n    }\n\n    // For now, we don't do the work for the support stack yet\n    throw new Error('Cannot create a cross-account or cross-region rule for an imported resource (create a stack with the right environment for the imported resource)');\n  }\n\n  /**\n   * Obtain the Role for the EventBridge event\n   *\n   * If a role already exists, it will be returned. This ensures that if multiple\n   * events have the same target, they will share a role.\n   * @internal\n   */\n  private crossRegionPutEventsRole(eventBusArn: string): IRole {\n    const id = 'EventsRole';\n    let role = this.node.tryFindChild(id) as IRole;\n    if (!role) {\n      role = new Role(this, id, {\n        roleName: PhysicalName.GENERATE_IF_NEEDED,\n        assumedBy: new ServicePrincipal('events.amazonaws.com'),\n      });\n    }\n\n    role.addToPrincipalPolicy(new PolicyStatement({\n      actions: ['events:PutEvents'],\n      resources: [eventBusArn],\n    }));\n\n    return role;\n  }\n}\n\n/**\n * A rule that mirrors another rule\n */\nclass MirrorRule extends Rule {\n  constructor(scope: Construct, id: string, props: RuleProps, private readonly source: Rule) {\n    super(scope, id, props);\n  }\n\n  public _renderEventPattern(): any {\n    return this.source._renderEventPattern();\n  }\n\n  /**\n   * Override validate to be a no-op\n   *\n   * The rules are never stored on this object so there's nothing to validate.\n   *\n   * Instead, we mirror the other rule at render time.\n   */\n  protected validate(): string[] {\n    return [];\n  }\n}\n"]}