@aws-cdk/aws-events-targets/lib/util.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.addToDeadLetterQueueResourcePolicy = exports.addLambdaPermission = exports.singletonEventRole = exports.bindBaseTargetConfig = void 0;
const iam = require("@aws-cdk/aws-iam");
const core_1 = require("@aws-cdk/core");
// keep this import separate from other imports to reduce chance for merge conflicts with v2-main
// eslint-disable-next-line no-duplicate-imports, import/order
const core_2 = require("@aws-cdk/core");
/**
 * Bind props to base rule target config.
 * @internal
 */
function bindBaseTargetConfig(props) {
    let { deadLetterQueue, retryAttempts, maxEventAge } = props;
    return {
        deadLetterConfig: deadLetterQueue ? { arn: deadLetterQueue?.queueArn } : undefined,
        retryPolicy: retryAttempts || maxEventAge
            ? {
                maximumRetryAttempts: retryAttempts,
                maximumEventAgeInSeconds: maxEventAge?.toSeconds({ integral: true }),
            }
            : undefined,
    };
}
exports.bindBaseTargetConfig = bindBaseTargetConfig;
/**
 * 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
 */
function singletonEventRole(scope) {
    const id = 'EventsRole';
    const existing = scope.node.tryFindChild(id);
    if (existing) {
        return existing;
    }
    const role = new iam.Role(scope, id, {
        roleName: core_1.PhysicalName.GENERATE_IF_NEEDED,
        assumedBy: new iam.ServicePrincipal('events.amazonaws.com'),
    });
    return role;
}
exports.singletonEventRole = singletonEventRole;
/**
 * Allows a Lambda function to be called from a rule
 * @internal
 */
function addLambdaPermission(rule, handler) {
    let scope;
    let node = handler.permissionsNode;
    let permissionId = `AllowEventRule${core_1.Names.nodeUniqueId(rule.node)}`;
    if (rule instanceof core_2.Construct) {
        // Place the Permission resource in the same stack as Rule rather than the Function
        // This is to reduce circular dependency when the lambda handler and the rule are across stacks.
        scope = rule;
        node = rule.node;
        permissionId = `AllowEventRule${core_1.Names.nodeUniqueId(handler.node)}`;
    }
    if (!node.tryFindChild(permissionId)) {
        handler.addPermission(permissionId, {
            scope,
            action: 'lambda:InvokeFunction',
            principal: new iam.ServicePrincipal('events.amazonaws.com'),
            sourceArn: rule.ruleArn,
        });
    }
}
exports.addLambdaPermission = addLambdaPermission;
/**
 * Allow a rule to send events with failed invocation to an Amazon SQS queue.
 * @internal
 */
function addToDeadLetterQueueResourcePolicy(rule, queue) {
    if (!sameEnvDimension(rule.env.region, queue.env.region)) {
        throw new Error(`Cannot assign Dead Letter Queue in region ${queue.env.region} to the rule ${core_1.Names.nodeUniqueId(rule.node)} in region ${rule.env.region}. Both the queue and the rule must be in the same region.`);
    }
    // Skip Resource Policy creation if the Queue is not in the same account.
    // There is no way to add a target onto an imported rule, so we can assume we will run the following code only
    // in the account where the rule is created.
    if (sameEnvDimension(rule.env.account, queue.env.account)) {
        const policyStatementId = `AllowEventRule${core_1.Names.nodeUniqueId(rule.node)}`;
        queue.addToResourcePolicy(new iam.PolicyStatement({
            sid: policyStatementId,
            principals: [new iam.ServicePrincipal('events.amazonaws.com')],
            effect: iam.Effect.ALLOW,
            actions: ['sqs:SendMessage'],
            resources: [queue.queueArn],
            conditions: {
                ArnEquals: {
                    'aws:SourceArn': rule.ruleArn,
                },
            },
        }));
    }
    else {
        core_1.Annotations.of(rule).addWarning(`Cannot add a resource policy to your dead letter queue associated with rule ${rule.ruleName} because the queue is in a different account. You must add the resource policy manually to the dead letter queue in account ${queue.env.account}.`);
    }
}
exports.addToDeadLetterQueueResourcePolicy = addToDeadLetterQueueResourcePolicy;
/**
 * Whether two string probably contain the same environment dimension (region or account)
 *
 * Used to compare either accounts or regions, and also returns true if both
 * are unresolved (in which case both are expted to be "current region" or "current account").
 * @internal
 */
function sameEnvDimension(dim1, dim2) {
    return [core_1.TokenComparison.SAME, core_1.TokenComparison.BOTH_UNRESOLVED].includes(core_1.Token.compareStrings(dim1, dim2));
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["util.ts"],"names":[],"mappings":";;;AACA,wCAAwC;AAGxC,wCAA8H;AAE9H,iGAAiG;AACjG,8DAA8D;AAC9D,wCAA0C;AAuC1C;;;GAGG;AACH,SAAgB,oBAAoB,CAAC,KAAsB;IACzD,IAAI,EAAE,eAAe,EAAE,aAAa,EAAE,WAAW,EAAE,GAAG,KAAK,CAAC;IAE5D,OAAO;QACL,gBAAgB,EAAE,eAAe,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,eAAe,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,SAAS;QAClF,WAAW,EAAE,aAAa,IAAI,WAAW;YACvC,CAAC,CAAC;gBACA,oBAAoB,EAAE,aAAa;gBACnC,wBAAwB,EAAE,WAAW,EAAE,SAAS,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;aACrE;YACD,CAAC,CAAC,SAAS;KACd,CAAC;AACJ,CAAC;AAZD,oDAYC;AAGD;;;;;;GAMG;AACH,SAAgB,kBAAkB,CAAC,KAAiB;IAClD,MAAM,EAAE,GAAG,YAAY,CAAC;IACxB,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,CAAc,CAAC;IAC1D,IAAI,QAAQ,EAAE;QAAE,OAAO,QAAQ,CAAC;KAAE;IAElC,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,KAAkB,EAAE,EAAE,EAAE;QAChD,QAAQ,EAAE,mBAAY,CAAC,kBAAkB;QACzC,SAAS,EAAE,IAAI,GAAG,CAAC,gBAAgB,CAAC,sBAAsB,CAAC;KAC5D,CAAC,CAAC;IAEH,OAAO,IAAI,CAAC;AACd,CAAC;AAXD,gDAWC;AAED;;;GAGG;AACH,SAAgB,mBAAmB,CAAC,IAAkB,EAAE,OAAyB;IAC/E,IAAI,KAA4B,CAAC;IACjC,IAAI,IAAI,GAAkB,OAAO,CAAC,eAAe,CAAC;IAClD,IAAI,YAAY,GAAG,iBAAiB,YAAK,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;IACpE,IAAI,IAAI,YAAY,gBAAS,EAAE;QAC7B,mFAAmF;QACnF,gGAAgG;QAChG,KAAK,GAAG,IAAI,CAAC;QACb,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACjB,YAAY,GAAG,iBAAiB,YAAK,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;KACpE;IACD,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,EAAE;QACpC,OAAO,CAAC,aAAa,CAAC,YAAY,EAAE;YAClC,KAAK;YACL,MAAM,EAAE,uBAAuB;YAC/B,SAAS,EAAE,IAAI,GAAG,CAAC,gBAAgB,CAAC,sBAAsB,CAAC;YAC3D,SAAS,EAAE,IAAI,CAAC,OAAO;SACxB,CAAC,CAAC;KACJ;AACH,CAAC;AAnBD,kDAmBC;AAED;;;GAGG;AACH,SAAgB,kCAAkC,CAAC,IAAkB,EAAE,KAAiB;IACtF,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE;QACxD,MAAM,IAAI,KAAK,CAAC,6CAA6C,KAAK,CAAC,GAAG,CAAC,MAAM,gBAAgB,YAAK,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,IAAI,CAAC,GAAG,CAAC,MAAM,2DAA2D,CAAC,CAAC;KACrN;IAED,yEAAyE;IACzE,8GAA8G;IAC9G,4CAA4C;IAC5C,IAAI,gBAAgB,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE;QACzD,MAAM,iBAAiB,GAAG,iBAAiB,YAAK,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QAE3E,KAAK,CAAC,mBAAmB,CAAC,IAAI,GAAG,CAAC,eAAe,CAAC;YAChD,GAAG,EAAE,iBAAiB;YACtB,UAAU,EAAE,CAAC,IAAI,GAAG,CAAC,gBAAgB,CAAC,sBAAsB,CAAC,CAAC;YAC9D,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,KAAK;YACxB,OAAO,EAAE,CAAC,iBAAiB,CAAC;YAC5B,SAAS,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC;YAC3B,UAAU,EAAE;gBACV,SAAS,EAAE;oBACT,eAAe,EAAE,IAAI,CAAC,OAAO;iBAC9B;aACF;SACF,CAAC,CAAC,CAAC;KACL;SAAM;QACL,kBAAW,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,+EAA+E,IAAI,CAAC,QAAQ,+HAA+H,KAAK,CAAC,GAAG,CAAC,OAAO,GAAG,CAAC,CAAC;KAClR;AACH,CAAC;AA1BD,gFA0BC;AAGD;;;;;;GAMG;AACH,SAAS,gBAAgB,CAAC,IAAY,EAAE,IAAY;IAClD,OAAO,CAAC,sBAAe,CAAC,IAAI,EAAE,sBAAe,CAAC,eAAe,CAAC,CAAC,QAAQ,CAAC,YAAK,CAAC,cAAc,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;AAC5G,CAAC","sourcesContent":["import * as events from '@aws-cdk/aws-events';\nimport * as iam from '@aws-cdk/aws-iam';\nimport * as lambda from '@aws-cdk/aws-lambda';\nimport * as sqs from '@aws-cdk/aws-sqs';\nimport { Annotations, ConstructNode, IConstruct, Names, Token, TokenComparison, Duration, PhysicalName } from '@aws-cdk/core';\n\n// keep this import separate from other imports to reduce chance for merge conflicts with v2-main\n// eslint-disable-next-line no-duplicate-imports, import/order\nimport { Construct } from '@aws-cdk/core';\n\n/**\n * The generic properties for an RuleTarget\n */\nexport interface TargetBaseProps {\n  /**\n   * The SQS queue to be used as deadLetterQueue.\n   * Check out the [considerations for using a dead-letter queue](https://docs.aws.amazon.com/eventbridge/latest/userguide/rule-dlq.html#dlq-considerations).\n   *\n   * The events not successfully delivered are automatically retried for a specified period of time,\n   * depending on the retry policy of the target.\n   * If an event is not delivered before all retry attempts are exhausted, it will be sent to the dead letter queue.\n   *\n   * @default - no dead-letter queue\n   */\n  readonly deadLetterQueue?: sqs.IQueue;\n  /**\n   * The maximum age of a request that Lambda sends to a function for\n   * processing.\n   *\n   * Minimum value of 60.\n   * Maximum value of 86400.\n   *\n   * @default Duration.hours(24)\n   */\n  readonly maxEventAge?: Duration;\n\n  /**\n   * The maximum number of times to retry when the function returns an error.\n   *\n   * Minimum value of 0.\n   * Maximum value of 185.\n   *\n   * @default 185\n   */\n  readonly retryAttempts?: number;\n}\n\n/**\n * Bind props to base rule target config.\n * @internal\n */\nexport function bindBaseTargetConfig(props: TargetBaseProps) {\n  let { deadLetterQueue, retryAttempts, maxEventAge } = props;\n\n  return {\n    deadLetterConfig: deadLetterQueue ? { arn: deadLetterQueue?.queueArn } : undefined,\n    retryPolicy: retryAttempts || maxEventAge\n      ? {\n        maximumRetryAttempts: retryAttempts,\n        maximumEventAgeInSeconds: maxEventAge?.toSeconds({ integral: true }),\n      }\n      : undefined,\n  };\n}\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 */\nexport function singletonEventRole(scope: IConstruct): iam.IRole {\n  const id = 'EventsRole';\n  const existing = scope.node.tryFindChild(id) as iam.IRole;\n  if (existing) { return existing; }\n\n  const role = new iam.Role(scope as Construct, id, {\n    roleName: PhysicalName.GENERATE_IF_NEEDED,\n    assumedBy: new iam.ServicePrincipal('events.amazonaws.com'),\n  });\n\n  return role;\n}\n\n/**\n * Allows a Lambda function to be called from a rule\n * @internal\n */\nexport function addLambdaPermission(rule: events.IRule, handler: lambda.IFunction): void {\n  let scope: Construct | undefined;\n  let node: ConstructNode = handler.permissionsNode;\n  let permissionId = `AllowEventRule${Names.nodeUniqueId(rule.node)}`;\n  if (rule instanceof Construct) {\n    // Place the Permission resource in the same stack as Rule rather than the Function\n    // This is to reduce circular dependency when the lambda handler and the rule are across stacks.\n    scope = rule;\n    node = rule.node;\n    permissionId = `AllowEventRule${Names.nodeUniqueId(handler.node)}`;\n  }\n  if (!node.tryFindChild(permissionId)) {\n    handler.addPermission(permissionId, {\n      scope,\n      action: 'lambda:InvokeFunction',\n      principal: new iam.ServicePrincipal('events.amazonaws.com'),\n      sourceArn: rule.ruleArn,\n    });\n  }\n}\n\n/**\n * Allow a rule to send events with failed invocation to an Amazon SQS queue.\n * @internal\n */\nexport function addToDeadLetterQueueResourcePolicy(rule: events.IRule, queue: sqs.IQueue) {\n  if (!sameEnvDimension(rule.env.region, queue.env.region)) {\n    throw new Error(`Cannot assign Dead Letter Queue in region ${queue.env.region} to the rule ${Names.nodeUniqueId(rule.node)} in region ${rule.env.region}. Both the queue and the rule must be in the same region.`);\n  }\n\n  // Skip Resource Policy creation if the Queue is not in the same account.\n  // There is no way to add a target onto an imported rule, so we can assume we will run the following code only\n  // in the account where the rule is created.\n  if (sameEnvDimension(rule.env.account, queue.env.account)) {\n    const policyStatementId = `AllowEventRule${Names.nodeUniqueId(rule.node)}`;\n\n    queue.addToResourcePolicy(new iam.PolicyStatement({\n      sid: policyStatementId,\n      principals: [new iam.ServicePrincipal('events.amazonaws.com')],\n      effect: iam.Effect.ALLOW,\n      actions: ['sqs:SendMessage'],\n      resources: [queue.queueArn],\n      conditions: {\n        ArnEquals: {\n          'aws:SourceArn': rule.ruleArn,\n        },\n      },\n    }));\n  } else {\n    Annotations.of(rule).addWarning(`Cannot add a resource policy to your dead letter queue associated with rule ${rule.ruleName} because the queue is in a different account. You must add the resource policy manually to the dead letter queue in account ${queue.env.account}.`);\n  }\n}\n\n\n/**\n * Whether two string probably contain the same environment dimension (region or account)\n *\n * Used to compare either accounts or regions, and also returns true if both\n * are unresolved (in which case both are expted to be \"current region\" or \"current account\").\n * @internal\n */\nfunction sameEnvDimension(dim1: string, dim2: string) {\n  return [TokenComparison.SAME, TokenComparison.BOTH_UNRESOLVED].includes(Token.compareStrings(dim1, dim2));\n}"]}