fix(events-targets): rename KinesisFirehoseStreamV2 to FirehoseDeliveryStream

packages/@aws-cdk-testing/framework-integ/test/aws-events-targets/test/firehose/integ.firehose-delivery-stream.ts

@@ -0,0 +1,51 @@
+import * as events from 'aws-cdk-lib/aws-events';
+import * as firehose from 'aws-cdk-lib/aws-kinesisfirehose';
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as cdk from 'aws-cdk-lib';
+import * as targets from 'aws-cdk-lib/aws-events-targets';
+import { IntegTest, ExpectedResult, AwsApiCall } from '@aws-cdk/integ-tests-alpha';
+
+// ---------------------------------
+// Define a rule that triggers a put to a Kinesis stream every 1min.
+
+const app = new cdk.App();
+
+const stack = new cdk.Stack(app, 'aws-cdk-firehose-event-target');
+
+const bucket = new s3.Bucket(stack, 'firehose-bucket', {
+  autoDeleteObjects: true,
+  removalPolicy: cdk.RemovalPolicy.DESTROY,
+});
+const stream = new firehose.DeliveryStream(stack, 'MyStream', {
+  destination: new firehose.S3Bucket(bucket, {
+    bufferingInterval: cdk.Duration.seconds(30),
+  }),
+});
+
+const event = new events.Rule(stack, 'EveryMinute', {
+  schedule: events.Schedule.rate(cdk.Duration.minutes(1)),
+});
+
+event.addTarget(new targets.FirehoseDeliveryStream(stream));
+
+const testCase = new IntegTest(app, 'firehose-event-target-integ', {
+  testCases: [stack],
+});
+
+const s3ApiCall = testCase.assertions.awsApiCall('S3', 'listObjectsV2', {
+  Bucket: bucket.bucketName,
+  MaxKeys: 1,
+}).expect(ExpectedResult.objectLike({
+  KeyCount: 1,
+})).waitForAssertions({
+  interval: cdk.Duration.seconds(30),
+  totalTimeout: cdk.Duration.minutes(10),
+});
+
+if (s3ApiCall instanceof AwsApiCall) {
+  s3ApiCall.waiterProvider?.addToRolePolicy({
+    Effect: 'Allow',
+    Action: ['s3:GetObject', 's3:ListBucket'],
+    Resource: ['*'],
+  });
+}

packages/aws-cdk-lib/aws-events-targets/README.md

@@ -18,6 +18,7 @@ Currently supported are:
   - [Invoke an API Destination](#invoke-an-api-destination)
   - [Invoke an AppSync GraphQL API](#invoke-an-appsync-graphql-api)
   - [Put an event on an EventBridge bus](#put-an-event-on-an-eventbridge-bus)
+  - [Put an event on a Firehose delivery stream](#put-an-event-on-a-firehose-delivery-stream)
   - [Run an ECS Task](#run-an-ecs-task)
     - [Tagging Tasks](#tagging-tasks)
     - [Launch type for ECS Task](#launch-type-for-ecs-task)
@@ -447,6 +448,27 @@ rule.addTarget(new targets.EventBus(
 ));
 ```
 
+## Put an event on a Firehose delivery stream
+
+Use the `FirehoseDeliveryStream` target to put event to an Amazon Data Firehose delivery stream.
+
+The code snippet below creates the scheduled event rule that put events to an Amazon Data Firehose delivery stream.
+
+```ts
+import * as firehose from 'aws-cdk-lib/aws-kinesisfirehose';
+import * as s3 from 'aws-cdk-lib/aws-s3';
+
+declare const bucket: s3.Bucket;
+const stream = new firehose.DeliveryStream(this, 'DeliveryStream', {
+  destination: new firehose.S3Bucket(bucket),
+});
+
+const rule = new events.Rule(this, 'Rule', {
+  schedule: events.Schedule.expression('rate(1 minute)'),
+});
+rule.addTarget(new targets.FirehoseDeliveryStream(stream));
+```
+
 ## Run an ECS Task
 
 Use the `EcsTask` target to run an ECS Task.

packages/aws-cdk-lib/aws-events-targets/lib/kinesis-firehose-stream.ts → packages/aws-cdk-lib/aws-events-targets/lib/firehose-delivery-stream.ts

@@ -6,6 +6,8 @@ import { IResource } from '../../core';
 
 /**
  * Customize the Amazon Data Firehose Stream Event Target
+ *
+ * @deprecated Use FirehoseDeliveryStreamProps
  */
 export interface KinesisFirehoseStreamProps {
   /**
@@ -18,10 +20,24 @@ export interface KinesisFirehoseStreamProps {
   readonly message?: events.RuleTargetInput;
 }
 
+/**
+ * Customize the Amazon Data Firehose Stream Event Target
+ */
+export interface FirehoseDeliveryStreamProps {
+  /**
+   * The message to send to the stream.
+   *
+   * Must be a valid JSON text passed to the target stream.
+   *
+   * @default - the entire Event Bridge event
+   */
+  readonly message?: events.RuleTargetInput;
+}
+
 /**
  * Customize the Amazon Data Firehose Stream Event Target
  *
- * @deprecated Use KinesisFirehoseStreamV2
+ * @deprecated Use FirehoseDeliveryStream
  */
 export class KinesisFirehoseStream implements events.IRuleTarget {
   constructor(private readonly stream: firehose.CfnDeliveryStream, private readonly props: KinesisFirehoseStreamProps = {}) {
@@ -49,6 +65,8 @@ export class KinesisFirehoseStream implements events.IRuleTarget {
 
 /**
  * Represents an Amazon Data Firehose delivery stream.
+ *
+ * @deprecated Use aws_kinesisfirehose.IDeliveryStream
  */
 export interface IDeliveryStream extends IResource {
   /**
@@ -69,6 +87,8 @@ export interface IDeliveryStream extends IResource {
 /**
  * Customize the Amazon Data Firehose Stream Event Target V2 to support L2 Amazon Data Firehose Delivery Stream
  * instead of L1 Cfn Firehose Delivery Stream.
+ *
+ * @deprecated Use FirehoseDeliveryStream
  */
 export class KinesisFirehoseStreamV2 implements events.IRuleTarget {
   constructor(private readonly stream: IDeliveryStream, private readonly props: KinesisFirehoseStreamProps = {}) {
@@ -93,3 +113,27 @@ export class KinesisFirehoseStreamV2 implements events.IRuleTarget {
     };
   }
 }
+
+/**
+ * Customize the Amazon Data Firehose Stream Event Target.
+ */
+export class FirehoseDeliveryStream implements events.IRuleTarget {
+  constructor(private readonly stream: firehose.IDeliveryStream, private readonly props: FirehoseDeliveryStreamProps = {}) {
+  }
+
+  /**
+   * Returns a RuleTarget that can be used to trigger this Firehose Stream as a
+   * result from a Event Bridge event.
+   */
+  public bind(_rule: events.IRule, _id?: string): events.RuleTargetConfig {
+    const role = singletonEventRole(this.stream);
+    this.stream.grantPutRecords(role);
+
+    return {
+      arn: this.stream.deliveryStreamArn,
+      role,
+      input: this.props.message,
+      targetResource: this.stream,
+    };
+  }
+}

packages/aws-cdk-lib/aws-events-targets/lib/index.ts

@@ -11,7 +11,7 @@ export * from './event-bus';
 export * from './state-machine';
 export * from './kinesis-stream';
 export * from './log-group';
-export * from './kinesis-firehose-stream';
+export * from './firehose-delivery-stream';
 export * from './api-gateway';
 export * from './api-destination';
 export * from './appsync';

packages/aws-cdk-lib/aws-events-targets/test/kinesis-firehose/kinesis-firehose-stream.test.ts → packages/aws-cdk-lib/aws-events-targets/test/firehose/firehose-delivery-stream.test.ts

@@ -1,6 +1,7 @@
 import { Template } from '../../../assertions';
 import * as events from '../../../aws-events';
 import * as firehose from '../../../aws-kinesisfirehose';
+import * as s3 from '../../../aws-s3';
 import { Stack } from '../../../core';
 import * as targets from '../../lib';
 
@@ -78,3 +79,80 @@ describe('KinesisFirehoseStream event target', () => {
     });
   });
 });
+
+describe('FirehoseStream event target', () => {
+  let stack: Stack;
+  let stream: firehose.DeliveryStream;
+  let streamArn: any;
+
+  beforeEach(() => {
+    stack = new Stack();
+    stream = new firehose.DeliveryStream(stack, 'MyStream', {
+      destination: new firehose.S3Bucket(new s3.Bucket(stack, 'MyBucket')),
+    });
+    streamArn = { 'Fn::GetAtt': ['MyStream5C050E93', 'Arn'] };
+  });
+
+  describe('when added to an event rule as a target', () => {
+    let rule: events.Rule;
+
+    beforeEach(() => {
+      rule = new events.Rule(stack, 'rule', {
+        schedule: events.Schedule.expression('rate(1 minute)'),
+      });
+    });
+
+    describe('with default settings', () => {
+      beforeEach(() => {
+        rule.addTarget(new targets.FirehoseDeliveryStream(stream));
+      });
+
+      test("adds the stream's ARN and role to the targets of the rule", () => {
+        Template.fromStack(stack).hasResourceProperties('AWS::Events::Rule', {
+          Targets: [
+            {
+              Arn: streamArn,
+              Id: 'Target0',
+              RoleArn: { 'Fn::GetAtt': ['MyStreamEventsRole5B6CC6AF', 'Arn'] },
+            },
+          ],
+        });
+      });
+
+      test("creates a policy that has PutRecord and PutRecords permissions on the stream's ARN", () => {
+        Template.fromStack(stack).hasResourceProperties('AWS::IAM::Policy', {
+          PolicyDocument: {
+            Statement: [
+              {
+                Action: ['firehose:PutRecord', 'firehose:PutRecordBatch'],
+                Effect: 'Allow',
+                Resource: streamArn,
+              },
+            ],
+            Version: '2012-10-17',
+          },
+        });
+      });
+    });
+
+    describe('with an explicit message', () => {
+      beforeEach(() => {
+        rule.addTarget(new targets.FirehoseDeliveryStream(stream, {
+          message: events.RuleTargetInput.fromText('fooBar'),
+        }));
+      });
+
+      test('sets the input', () => {
+        Template.fromStack(stack).hasResourceProperties('AWS::Events::Rule', {
+          Targets: [
+            {
+              Arn: streamArn,
+              Id: 'Target0',
+              Input: '"fooBar"',
+            },
+          ],
+        });
+      });
+    });
+  });
+});