@gradientedge/cdk-utils 8.153.0 → 8.155.0

package/dist/src/lib/aws/services/eventbridge/types.d.ts

@@ -2,7 +2,6 @@ import { CfnPipeProps } from 'aws-cdk-lib/aws-pipes';
 import { CfnRuleProps, EventBusProps as EBProps, RuleProps as EBRuleProps } from 'aws-cdk-lib/aws-events';
 import { TagProps } from '../../types';
 /**
- }
  */
 export interface SqsToSfnPipeProps extends CfnPipeProps {
     pipeFilterPattern?: any;
@@ -11,6 +10,13 @@ export interface SqsToSfnPipeProps extends CfnPipeProps {
     sqsBatchSize?: number;
     sqsMaximumBatchingWindowInSeconds?: number;
 }
+/**
+ */
+export interface SqsToLambdaPipeProps extends CfnPipeProps {
+    pipeFilterPattern?: any;
+    sqsBatchSize?: number;
+    sqsMaximumBatchingWindowInSeconds?: number;
+}
 /**
  */
 export interface EventRuleProps extends EBRuleProps {

package/dist/src/lib/aws/services/identity-access-management/main.d.ts

@@ -235,6 +235,14 @@ export declare class IamManager {
      * @param stepFunctionArn the arn of the step function
      */
     createRoleForSqsToSfnPipe(id: string, scope: CommonConstruct, queueArn: string, stepFunctionArn: string): Role;
+    /**
+     * @summary Method to create iam statement for sqs to lambda pipe
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param queueArn the arn of the sqs queue
+     * @param lambdaArn the arn of the lambda function
+     */
+    createRoleForSqsToLambdaPipe(id: string, scope: CommonConstruct, queueArn: string, lambdaArn: string): Role;
     /**
      * @summary Method to create iam policy for sqs
      * @param id scoped id of the resource

package/dist/src/lib/aws/services/identity-access-management/main.js

@@ -545,6 +545,25 @@ class IamManager {
         (0, utils_1.createCfnOutput)(`${id}Name`, scope, role.roleName);
         return role;
     }
+    /**
+     * @summary Method to create iam statement for sqs to lambda pipe
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param queueArn the arn of the sqs queue
+     * @param lambdaArn the arn of the lambda function
+     */
+    createRoleForSqsToLambdaPipe(id, scope, queueArn, lambdaArn) {
+        const role = new aws_iam_1.Role(scope, `${id}`, {
+            assumedBy: new aws_iam_1.ServicePrincipal('pipes.amazonaws.com'),
+            description: `Role for ${id} Pipe`,
+            roleName: `${id}-${scope.props.stage}`,
+        });
+        role.addToPolicy(this.statementForPollQueue([queueArn]));
+        role.addToPolicy(this.statementForInvokeLambda([lambdaArn]));
+        (0, utils_1.createCfnOutput)(`${id}Arn`, scope, role.roleArn);
+        (0, utils_1.createCfnOutput)(`${id}Name`, scope, role.roleName);
+        return role;
+    }
     /**
      * @summary Method to create iam policy for sqs
      * @param id scoped id of the resource

package/dist/src/lib/aws/services/lambda/types.d.ts

@@ -2,6 +2,7 @@ import { AliasProps, FunctionProps } from 'aws-cdk-lib/aws-lambda';
 import { TagProps } from '../../types';
 import { EdgeFunctionProps } from 'aws-cdk-lib/aws-cloudfront/lib/experimental';
 import { QueueProps } from '../simple-queue-service';
+import { SqsEventSourceProps } from 'aws-cdk-lib/aws-lambda-event-sources';
 /**
  */
 export interface ProvisionedConcurrencyProps {
@@ -41,3 +42,6 @@ export interface LambdaEnvironment {
     STAGE?: string;
     TZ: string;
 }
+export interface SQSEventSourceProps extends SqsEventSourceProps {
+    maxBatchingWindowInSecs: number;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gradientedge/cdk-utils",
-  "version": "8.153.0",
+  "version": "8.155.0",
   "description": "Utilities for AWS CDK provisioning",
   "main": "dist/index.js",
   "engines": {
@@ -47,19 +47,19 @@
     }
   },
   "dependencies": {
-    "@aws-sdk/client-secrets-manager": "^3.484.0",
-    "@aws-sdk/credential-providers": "^3.484.0",
-    "@aws-sdk/types": "^3.468.0",
-    "@cdktf/provider-aws": "^18.2.0",
-    "@cdktf/provider-azurerm": "^11.2.0",
-    "@cdktf/provider-cloudflare": "^10.0.4",
+    "@aws-sdk/client-secrets-manager": "^3.496.0",
+    "@aws-sdk/credential-providers": "^3.496.0",
+    "@aws-sdk/types": "^3.496.0",
+    "@cdktf/provider-aws": "^19.2.0",
+    "@cdktf/provider-azurerm": "^12.2.0",
+    "@cdktf/provider-cloudflare": "^11.0.0",
     "@types/lodash": "^4.14.202",
-    "@types/node": "^20.10.6",
+    "@types/node": "^20.11.5",
     "@types/uuid": "^9.0.7",
     "app-root-path": "^3.1.0",
-    "aws-cdk-lib": "^2.117.0",
-    "cdktf": "^0.19.2",
-    "cdktf-local-exec": "^0.4.14",
+    "aws-cdk-lib": "^2.122.0",
+    "cdktf": "^0.20.1",
+    "cdktf-local-exec": "^0.5.2",
     "constructs": "^10.3.0",
     "lodash": "^4.17.21",
     "moment": "^2.30.1",
@@ -73,18 +73,18 @@
     "@babel/eslint-parser": "^7.23.3",
     "@babel/plugin-proposal-class-properties": "^7.18.6",
     "@types/jest": "^29.5.11",
-    "@typescript-eslint/eslint-plugin": "^6.17.0",
-    "@typescript-eslint/parser": "^6.17.0",
-    "aws-cdk": "^2.117.0",
+    "@typescript-eslint/eslint-plugin": "^6.19.0",
+    "@typescript-eslint/parser": "^6.19.0",
+    "aws-cdk": "^2.122.0",
     "better-docs": "^2.7.3",
     "codecov": "^3.8.3",
     "commitizen": "^4.3.0",
     "docdash": "^2.0.2",
-    "dotenv": "^16.3.1",
+    "dotenv": "^16.3.2",
     "eslint": "^8.56.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-jsdoc": "^47.0.2",
+    "eslint-plugin-jsdoc": "^48.0.2",
     "husky": "^8.0.3",
     "jest": "^29.7.0",
     "jest-extended": "^4.0.2",
@@ -94,10 +94,10 @@
     "jsdoc-mermaid": "^1.0.0",
     "jsdoc-plugin-typescript": "^2.2.1",
     "jsdoc-to-markdown": "^8.0.0",
-    "prettier": "^3.1.1",
+    "prettier": "^3.2.4",
     "prettier-plugin-organize-imports": "^3.2.4",
     "rimraf": "^5.0.5",
-    "semantic-release": "^22.0.12",
+    "semantic-release": "^23.0.0",
     "taffydb": "^2.7.3",
     "ts-jest": "^29.1.1",
     "ts-node": "^10.9.2",

package/src/lib/aws/construct/event-handler/handler.ts

@@ -0,0 +1,30 @@
+import { Archive, IEventBus, IRuleTarget, Rule } from 'aws-cdk-lib/aws-events'
+import { CloudWatchLogGroup, EcsTask, LambdaFunction, SfnStateMachine, SqsQueue } from 'aws-cdk-lib/aws-events-targets'
+import { PolicyDocument, Role } from 'aws-cdk-lib/aws-iam'
+import { IFunction } from 'aws-cdk-lib/aws-lambda'
+import { LogGroup } from 'aws-cdk-lib/aws-logs'
+import { Queue } from 'aws-cdk-lib/aws-sqs'
+import { Chain, Map, StateMachine } from 'aws-cdk-lib/aws-stepfunctions'
+import { EventHandlerType } from './types'
+
+export class Handler implements EventHandlerType {
+  archive: Archive
+  ecsTargets: EcsTask[] = []
+  eventBus: IEventBus
+  eventWorkflowDefinition: Chain
+  lambdaFunctions: IFunction[] = []
+  lambdaTargets: LambdaFunction[] = []
+  logTargets: CloudWatchLogGroup[] = []
+  queue: Queue
+  rule: Rule
+  rulePattern: any
+  sqsTargets: SqsQueue[] = []
+  stepFunctionTargets: SfnStateMachine[] = []
+  targets: IRuleTarget[] = []
+  workflow: StateMachine
+  workflowDefinition: Chain
+  workflowLogGroup: LogGroup
+  workflowMapState: Map
+  workflowPolicy: PolicyDocument
+  workflowRole: Role
+}

package/src/lib/aws/construct/event-handler/index.ts

@@ -0,0 +1,3 @@
+export * from './handler'
+export * from './main'
+export * from './types'

package/src/lib/aws/construct/event-handler/main.ts

@@ -0,0 +1,243 @@
+import { Duration, Fn } from 'aws-cdk-lib'
+import { ISecurityGroup, IVpc, SecurityGroup } from 'aws-cdk-lib/aws-ec2'
+import { Archive, EventBus, Schedule } from 'aws-cdk-lib/aws-events'
+import { SfnStateMachine, SqsQueue } from 'aws-cdk-lib/aws-events-targets'
+import { CfnQueuePolicy } from 'aws-cdk-lib/aws-sqs'
+import { JsonPath, Map } from 'aws-cdk-lib/aws-stepfunctions'
+import { Construct } from 'constructs'
+import _ from 'lodash'
+import { CommonConstruct } from '../../common'
+import { Handler } from './handler'
+import { EventHandlerProps } from './types'
+
+/**
+ * @classdesc Provides a construct to create and deploy an EventBridge Event Handler
+ * @example
+ * import { EventHandler, EventHandlerProps } '@gradientedge/cdk-utils'
+ * import { Construct } from 'constructs'
+ *
+ * class CustomConstruct extends EventHandler {
+ *   constructor(parent: Construct, id: string, props: EventHandlerProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.id = id
+ *     this.initResources()
+ *   }
+ * }
+ */
+export class EventHandler extends CommonConstruct {
+  props: EventHandlerProps
+  id: string
+  handler: Handler
+  provisionTarget: boolean = true
+  securityGroup: ISecurityGroup
+  useMapState: boolean
+  vpc: IVpc
+
+  constructor(parent: Construct, id: string, props: EventHandlerProps) {
+    super(parent, id, props)
+    this.props = props
+    this.id = id
+    this.handler = new Handler()
+  }
+
+  protected initResources() {
+    this.createSQSEventSource()
+    this.createWorkflow()
+    this.createEventRulePattern()
+    this.createEventRuleTargets()
+    this.resolveEventBus()
+    this.createEventArchive()
+    this.createEventRule()
+  }
+
+  /**
+   * @summary Method to resolve common vpc  or create a new one.
+   */
+  protected resolveVpc() {
+    if (this.props.useExistingVpc) {
+      this.vpc = this.vpcManager.retrieveCommonVpc(`${this.id}-vpc`, this, this.props.vpcName)
+    } else {
+      this.vpc = this.vpcManager.createCommonVpc(this, this.props.vpc, this.props.vpc.vpcName)
+    }
+  }
+
+  /**
+   * @summary Method to resolve the exported security group.
+   */
+  protected resolveSecurityGroup() {
+    if (this.props.securityGroupExportName) {
+      this.securityGroup = SecurityGroup.fromSecurityGroupId(
+        this,
+        `${this.id}-security-group`,
+        Fn.importValue(this.props.securityGroupExportName)
+      )
+    }
+  }
+
+  /**
+   * @summary Method to create sqs event source if queue targets are defined.
+   */
+  protected createSQSEventSource() {
+    if (!this.props.eventSqs) return
+
+    this.handler.queue = this.sqsManager.createQueue(`${this.id}-sqs-queue`, this, this.props.eventSqs)
+    const sqsPolicyDocument = this.iamManager.createPolicyForSqsEvent(
+      `${this.id}-sqs-policy-document`,
+      this,
+      this.handler.queue,
+      this.handler.rule
+    )
+    new CfnQueuePolicy(this, `${this.id}-sqs-queue-policy`, {
+      policyDocument: sqsPolicyDocument.toJSON(),
+      queues: [this.handler.queue.queueUrl],
+    })
+    this.handler.sqsTargets = [new SqsQueue(this.handler.queue)]
+  }
+
+  /**
+   * @summary Method to create the event rule pattern.
+   */
+  protected createEventRulePattern() {
+    this.handler.rulePattern = this.props.eventRule.eventPattern
+  }
+
+  /**
+   * @summary Method to create the event rule targets.
+   */
+  protected createEventRuleTargets() {
+    this.handler.targets = [
+      ...this.handler.stepFunctionTargets,
+      ...this.handler.lambdaTargets,
+      ...this.handler.sqsTargets,
+      ...this.handler.ecsTargets,
+      ...this.handler.logTargets,
+    ]
+  }
+
+  /**
+   * @summary Method to resolve the event bus name or use the default bus.
+   */
+  protected resolveEventBus() {
+    this.handler.eventBus = EventBus.fromEventBusName(this, `${this.id}-bus`, this.props.eventBusName ?? 'default')
+  }
+
+  /**
+   * @summary Method to create an event archive if the event rule is not a scheduled one.
+   */
+  protected createEventArchive() {
+    /* do not enable for scheduled events */
+    if (this.props.eventRule.schedule || this.props.eventRuleSchedule || !this.props.eventRuleArchiveEnabled) return
+    this.handler.archive = new Archive(this, `${this.id}-archive`, {
+      archiveName: `${this.props.eventRule.ruleName}-${this.props.stage}`.replace(
+        `${this.node.tryGetContext('stackName')}-`,
+        ''
+      ),
+      description: `Archive of events for ${this.props.eventRule.ruleName}`,
+      eventPattern: this.handler.rulePattern,
+      retention: Duration.days(this.props.eventRetentionInDays ?? 7),
+      sourceEventBus: this.handler.eventBus,
+    })
+  }
+
+  /**
+   * @summary Method to create the event rule.
+   */
+  protected createEventRule() {
+    let schedule
+    if (this.props.eventRuleSchedule) {
+      schedule = Schedule.expression(this.props.eventRuleSchedule)
+    }
+    this.handler.rule = this.eventManager.createRule(
+      `${this.id}-rule`,
+      this,
+      {
+        ...this.props.eventRule,
+        eventPattern: this.handler.rulePattern,
+        schedule: schedule,
+      },
+      this.props.eventBusName ? this.handler.eventBus : undefined,
+      this.handler.targets
+    )
+  }
+
+  /**
+   * @summary Method to create the workflow steps.
+   */
+  protected createWorkflowSteps() {}
+
+  /**
+   * @summary Method to create the workflow definition.
+   */
+  protected createWorkflowDefinition() {
+    if (this.useMapState) {
+      this.handler.workflowMapState = new Map(this, `Map Iterator`, {
+        ...this.props.workflowMapState,
+        itemsPath: JsonPath.entirePayload,
+      })
+    }
+
+    this.handler.workflowDefinition = this.handler.eventWorkflowDefinition
+    if (this.useMapState) {
+      this.handler.workflowMapState.itemProcessor(this.handler.workflowDefinition)
+    }
+  }
+
+  /**
+   * @summary Method to create the workflow policy.
+   */
+  protected createWorkflowPolicy() {}
+
+  /**
+   * @summary Method to create the workflow role.
+   */
+  protected createWorkflowRole() {
+    this.handler.workflowRole = this.iamManager.createRoleForStepFunction(
+      `${this.id}-workflow-role`,
+      this,
+      this.handler.workflowPolicy
+    )
+  }
+
+  /**
+   * @summary Method to create the workflow log group.
+   */
+  protected createWorkflowLogGroup() {
+    this.handler.workflowLogGroup = this.logManager.createLogGroup(
+      `${this.id}-workflow-log`,
+      this,
+      this.props.workflowLog
+    )
+  }
+
+  /**
+   * @summary Method to create the workflow state machine.
+   */
+  protected createWorkflowStateMachine() {
+    this.handler.workflow = this.sfnManager.createStateMachine(
+      `${this.id}-workflow`,
+      this,
+      this.props.workflow,
+      this.useMapState ? this.handler.workflowMapState : this.handler.workflowDefinition,
+      this.handler.workflowLogGroup,
+      this.handler.workflowRole
+    )
+  }
+
+  /**
+   * @summary Method to create the workflow.
+   */
+  protected createWorkflow() {
+    if (_.isEmpty(this.props.workflow)) return
+
+    this.createWorkflowSteps()
+    this.createWorkflowDefinition()
+    this.createWorkflowPolicy()
+    this.createWorkflowRole()
+    this.createWorkflowLogGroup()
+    this.createWorkflowStateMachine()
+    if (this.provisionTarget) {
+      this.handler.stepFunctionTargets = [new SfnStateMachine(this.handler.workflow)]
+    }
+  }
+}

package/src/lib/aws/construct/event-handler/types.ts

@@ -0,0 +1,44 @@
+import { Archive, IEventBus, IRuleTarget, Rule } from 'aws-cdk-lib/aws-events'
+import { CloudWatchLogGroup, EcsTask, LambdaFunction, SfnStateMachine, SqsQueue } from 'aws-cdk-lib/aws-events-targets'
+import { PolicyDocument, Role } from 'aws-cdk-lib/aws-iam'
+import { LogGroup } from 'aws-cdk-lib/aws-logs'
+import { Queue } from 'aws-cdk-lib/aws-sqs'
+import { Chain, Map, StateMachine } from 'aws-cdk-lib/aws-stepfunctions'
+import { CommonStackProps } from '../../common'
+import { EventRuleProps, LogProps, QueueProps, SfnMapProps, SfnStateMachineProps, VpcProps } from '../../services'
+
+export interface EventHandlerProps extends CommonStackProps {
+  eventBusName: string
+  eventRetentionInDays: number
+  eventRule: EventRuleProps
+  eventRuleArchiveEnabled: boolean
+  eventRuleSchedule: string
+  eventSqs: QueueProps
+  securityGroupExportName: string
+  useExistingVpc: boolean
+  vpc: VpcProps
+  vpcName: string
+  workflow: SfnStateMachineProps
+  workflowLog: LogProps
+  workflowMapState: SfnMapProps
+}
+
+export interface EventHandlerType {
+  archive: Archive
+  ecsTargets: EcsTask[]
+  eventBus: IEventBus
+  lambdaTargets: LambdaFunction[]
+  logTargets: CloudWatchLogGroup[]
+  queue: Queue
+  rule: Rule
+  rulePattern: any
+  sqsTargets: SqsQueue[]
+  stepFunctionTargets: SfnStateMachine[]
+  targets: IRuleTarget[]
+  workflow: StateMachine
+  workflowDefinition: Chain
+  workflowLogGroup: LogGroup
+  workflowMapState: Map
+  workflowPolicy: PolicyDocument
+  workflowRole: Role
+}

package/src/lib/aws/construct/index.ts

@@ -3,9 +3,11 @@ export * from './api-to-eventbridge-target'
 export * from './api-to-eventbridge-target-with-sns'
 export * from './api-to-lambda-target'
 export * from './application-configuration'
+export * from './event-handler'
 export * from './graphql-api-lambda'
 export * from './graphql-api-lambda-with-cache'
 export * from './lambda-with-iam-access'
+export * from './piped-event-handler'
 export * from './rest-api-lambda'
 export * from './rest-api-lambda-with-cache'
 export * from './site-with-ecs-backend'

package/src/lib/aws/construct/piped-event-handler/index.ts

@@ -0,0 +1,2 @@
+export * from './main'
+export * from './types'

package/src/lib/aws/construct/piped-event-handler/main.ts

@@ -0,0 +1,81 @@
+import { SqsQueue } from 'aws-cdk-lib/aws-events-targets'
+import { IQueue } from 'aws-cdk-lib/aws-sqs'
+import { Construct } from 'constructs'
+import _ from 'lodash'
+import { EventHandler } from '../event-handler'
+import { PipedEventHandlerProps } from './types'
+
+/**
+ * @classdesc Provides a construct to create and deploy an EventBridge Piped Event Handler
+ * @example
+ * import { PipedEventHandler, PipedEventHandlerProps } '@gradientedge/cdk-utils'
+ * import { Construct } from 'constructs'
+ *
+ * class CustomConstruct extends PipedEventHandler {
+ *   constructor(parent: Construct, id: string, props: PipedEventHandlerProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.id = id
+ *     this.initResources()
+ *   }
+ * }
+ */
+export class PipedEventHandler extends EventHandler {
+  props: PipedEventHandlerProps
+  pipedDlq: IQueue
+  pipedQueue: IQueue
+
+  protected constructor(parent: Construct, id: string, props: PipedEventHandlerProps) {
+    super(parent, id, props)
+    this.props = props
+    this.id = id
+    this.useMapState = true
+    this.provisionTarget = false
+  }
+
+  protected initResources() {
+    this.createPipedQueue()
+    this.handler.sqsTargets = [new SqsQueue(this.pipedQueue)]
+    super.initResources()
+    this.createSqsToSfnPipe()
+    this.createSqsToLambdaPipe()
+  }
+
+  /**
+   * @summary Method to create the piped queue and dlq.
+   */
+  protected createPipedQueue() {
+    this.pipedDlq = this.sqsManager.createQueue(`${this.id}-pipe-queue-dlq`, this, this.props.pipedDlq)
+    this.pipedQueue = this.sqsManager.createQueue(`${this.id}-pipe-queue`, this, this.props.pipedQueue, this.pipedDlq)
+  }
+
+  /**
+   * @summary Method to create the SQS to SFN pipe.
+   */
+  protected createSqsToSfnPipe() {
+    if (_.isEmpty(this.props.sqsToSfnPipe) || !this.handler.workflow) return
+    this.eventManager.createSqsToSfnCfnPipe(
+      `${this.id}-pipe-sfn`,
+      this,
+      this.props.sqsToSfnPipe,
+      this.pipedQueue,
+      this.handler.workflow
+    )
+  }
+
+  /**
+   * @summary Method to create the SQS to Lambda pipe.
+   */
+  protected createSqsToLambdaPipe() {
+    if (_.isEmpty(this.props.sqsToLambdaPipe) || _.isEmpty(this.handler.lambdaFunctions)) return
+    _.forEach(this.handler.lambdaFunctions, (lambdaFunction, index) => {
+      this.eventManager.createSqsToLambdaCfnPipe(
+        `${this.id}-pipe-lambda-${index}`,
+        this,
+        this.props.sqsToLambdaPipe,
+        this.pipedQueue,
+        lambdaFunction
+      )
+    })
+  }
+}

package/src/lib/aws/construct/piped-event-handler/types.ts

@@ -0,0 +1,10 @@
+import { QueueProps } from 'aws-cdk-lib/aws-sqs'
+import { SqsToLambdaPipeProps, SqsToSfnPipeProps } from '../../services'
+import { EventHandlerProps } from '../event-handler'
+
+export interface PipedEventHandlerProps extends EventHandlerProps {
+  pipedDlq: QueueProps
+  pipedQueue: QueueProps
+  sqsToLambdaPipe: SqsToLambdaPipeProps
+  sqsToSfnPipe: SqsToSfnPipeProps
+}

package/src/lib/aws/services/eventbridge/main.ts

@@ -9,7 +9,14 @@ import { IStateMachine } from 'aws-cdk-lib/aws-stepfunctions'
 import _ from 'lodash'
 import { CommonConstruct } from '../../common'
 import { createCfnOutput } from '../../utils'
-import { EventBusProps, EventRuleProps, RuleProps, SqsToSfnPipeProps, DynamoDbToLambdaPipeProps } from './types'
+import {
+  DynamoDbToLambdaPipeProps,
+  EventBusProps,
+  EventRuleProps,
+  RuleProps,
+  SqsToLambdaPipeProps,
+  SqsToSfnPipeProps,
+} from './types'
 
 /**
  * @classdesc Provides operations on AWS EventBridge.
@@ -247,6 +254,57 @@ export class EventManager {
     return pipe
   }
 
+  /**
+   * @summary Method to create an eventbridge pipe with sqs queue as source and lambda function as target
+   * @param id scoped id of the resource
+   * @param scope scope in which this resource is defined
+   * @param props the props for the pipe
+   * @param sourceQueue the source sqs queue
+   * @param targetLambdaFunction the target lambda function
+   */
+  public createSqsToLambdaCfnPipe(
+    id: string,
+    scope: CommonConstruct,
+    props: SqsToLambdaPipeProps,
+    sourceQueue: IQueue,
+    targetLambdaFunction: IFunction
+  ) {
+    const pipeRole = scope.iamManager.createRoleForSqsToLambdaPipe(
+      `${id}-role`,
+      scope,
+      sourceQueue.queueArn,
+      targetLambdaFunction.functionArn
+    )
+
+    const pipe = new CfnPipe(scope, `${id}`, {
+      ...props,
+      name: `${props.name}-${scope.props.stage}`,
+      roleArn: pipeRole.roleArn,
+      source: sourceQueue.queueArn,
+      sourceParameters: {
+        filterCriteria: props.pipeFilterPattern
+          ? {
+              filters: [
+                {
+                  pattern: JSON.stringify(props.pipeFilterPattern),
+                },
+              ],
+            }
+          : undefined,
+        sqsQueueParameters: {
+          batchSize: props.sqsBatchSize,
+          maximumBatchingWindowInSeconds: props.sqsMaximumBatchingWindowInSeconds,
+        },
+      },
+      target: targetLambdaFunction.functionArn,
+    })
+
+    createCfnOutput(`${id}-pipeArn`, scope, pipe.attrArn)
+    createCfnOutput(`${id}-pipeName`, scope, pipe.name)
+
+    return pipe
+  }
+
   /**
    * @summary Method to create an eventbridge pipe with DynamoDb stream as source and lambda function as target
    * @param id scoped id of the resource

package/src/lib/aws/services/eventbridge/types.ts

@@ -3,7 +3,6 @@ import { CfnRuleProps, EventBusProps as EBProps, RuleProps as EBRuleProps } from
 import { TagProps } from '../../types'
 
 /**
- }
  */
 export interface SqsToSfnPipeProps extends CfnPipeProps {
   pipeFilterPattern?: any
@@ -13,6 +12,14 @@ export interface SqsToSfnPipeProps extends CfnPipeProps {
   sqsMaximumBatchingWindowInSeconds?: number
 }
 
+/**
+ */
+export interface SqsToLambdaPipeProps extends CfnPipeProps {
+  pipeFilterPattern?: any
+  sqsBatchSize?: number
+  sqsMaximumBatchingWindowInSeconds?: number
+}
+
 /**
  */
 export interface EventRuleProps extends EBRuleProps {