@gradientedge/cdk-utils-aws 1.0.0

package/dist/src/construct/event-handler/main.js

@@ -0,0 +1,196 @@
+import { Duration, Fn } from 'aws-cdk-lib';
+import { 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 _ from 'lodash';
+import { CommonConstruct } from '../../common/index.js';
+import { Handler } from './handler.js';
+/**
+ * @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;
+    id;
+    handler;
+    provisionTarget = true;
+    securityGroup;
+    useMapState;
+    vpc;
+    constructor(parent, id, props) {
+        super(parent, id, props);
+        this.props = props;
+        this.id = id;
+        this.handler = new Handler();
+    }
+    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.
+     */
+    resolveVpc() {
+        if (this.props.vpcName) {
+            this.vpc = this.vpcManager.retrieveCommonVpc(`${this.id}-vpc`, this, this.props.vpcName);
+        }
+    }
+    /**
+     * @summary Method to resolve the exported security group.
+     */
+    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.
+     */
+    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.
+     */
+    createEventRulePattern() {
+        if (!this.props.eventRule)
+            return;
+        this.handler.rulePattern = this.props.eventRule.eventPattern;
+    }
+    /**
+     * @summary Method to create the event rule targets.
+     */
+    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.
+     */
+    resolveEventBus() {
+        this.handler.eventBus = EventBus.fromEventBusName(this, `${this.id}-bus`, this.resourceNameFormatter.format(this.props.eventBusName, this.props.resourceNameOptions?.eventbridgeBus) ??
+            'default');
+    }
+    /**
+     * @summary Method to create an event archive if the event rule is not a scheduled one.
+     */
+    createEventArchive() {
+        /* do not enable for scheduled events */
+        if (!this.props.eventRule ||
+            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.
+     */
+    createEventRule() {
+        if (!this.props.eventRule)
+            return;
+        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.
+     */
+    createWorkflowSteps() { }
+    /**
+     * @summary Method to create the workflow definition.
+     */
+    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.
+     */
+    createWorkflowPolicy() { }
+    /**
+     * @summary Method to create the workflow role.
+     */
+    createWorkflowRole() {
+        this.handler.workflowRole = this.iamManager.createRoleForStepFunction(`${this.id}-workflow-role`, this, this.handler.workflowPolicy);
+    }
+    /**
+     * @summary Method to create the workflow log group.
+     */
+    createWorkflowLogGroup() {
+        this.handler.workflowLogGroup = this.logManager.createLogGroup(`${this.id}-workflow-log`, this, this.props.workflowLog);
+    }
+    /**
+     * @summary Method to create the workflow state machine.
+     */
+    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.
+     */
+    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/dist/src/construct/event-handler/types.d.ts

@@ -0,0 +1,41 @@
+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/index.js';
+import { EventRuleProps, LogProps, QueueProps, SfnMapProps, SfnStateMachineProps, VpcProps } from '../../services/index.js';
+export interface EventHandlerProps extends CommonStackProps {
+    eventBusName: string;
+    eventRetentionInDays: number;
+    eventRule?: EventRuleProps;
+    eventRuleArchiveEnabled: boolean;
+    eventRuleSchedule: string;
+    eventSqs: QueueProps;
+    securityGroupExportName: string;
+    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/dist/src/construct/event-handler/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/construct/index.d.ts

@@ -0,0 +1,14 @@
+export * from './api-to-any-target/index.js';
+export * from './api-to-eventbridge-target/index.js';
+export * from './api-to-eventbridge-target-with-sns/index.js';
+export * from './api-to-lambda-target/index.js';
+export * from './application-configuration/index.js';
+export * from './event-handler/index.js';
+export * from './lambda-with-iam-access/index.js';
+export * from './piped-event-handler/index.js';
+export * from './rest-api-lambda/index.js';
+export * from './rest-api-lambda-with-cache/index.js';
+export * from './site-with-ecs-backend/index.js';
+export * from './site-with-lambda-backend/index.js';
+export * from './static-asset-deployment/index.js';
+export * from './static-site/index.js';

package/dist/src/construct/index.js

@@ -0,0 +1,14 @@
+export * from './api-to-any-target/index.js';
+export * from './api-to-eventbridge-target/index.js';
+export * from './api-to-eventbridge-target-with-sns/index.js';
+export * from './api-to-lambda-target/index.js';
+export * from './application-configuration/index.js';
+export * from './event-handler/index.js';
+export * from './lambda-with-iam-access/index.js';
+export * from './piped-event-handler/index.js';
+export * from './rest-api-lambda/index.js';
+export * from './rest-api-lambda-with-cache/index.js';
+export * from './site-with-ecs-backend/index.js';
+export * from './site-with-lambda-backend/index.js';
+export * from './static-asset-deployment/index.js';
+export * from './static-site/index.js';

package/dist/src/construct/lambda-with-iam-access/index.d.ts

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

package/dist/src/construct/lambda-with-iam-access/index.js

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

package/dist/src/construct/lambda-with-iam-access/main.d.ts

@@ -0,0 +1,78 @@
+import { ISecurityGroup, IVpc, SubnetSelection } from 'aws-cdk-lib/aws-ec2';
+import { IAccessPoint } from 'aws-cdk-lib/aws-efs';
+import { CfnAccessKey, PolicyDocument, Role, User } from 'aws-cdk-lib/aws-iam';
+import { IFunction, ILayerVersion } from 'aws-cdk-lib/aws-lambda';
+import { Secret } from 'aws-cdk-lib/aws-secretsmanager';
+import { Construct } from 'constructs';
+import { CommonConstruct } from '../../common/index.js';
+import { LambdaWithIamAccessEnvironment, LambdaWithIamAccessProps } from './types.js';
+/**
+ * @classdesc Provides a construct to create a lambda function with IAM access
+ * @example
+ * import { LambdaWithIamAccess, LambdaWithIamAccessProps } '@gradientedge/cdk-utils'
+ * import { Construct } from 'constructs'
+ *
+ * class CustomConstruct extends LambdaWithIamAccess {
+ *   constructor(parent: Construct, id: string, props: LambdaWithIamAccessProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.id = id
+ *     this.initResources()
+ *   }
+ * }
+ */
+export declare class LambdaWithIamAccess extends CommonConstruct {
+    props: LambdaWithIamAccessProps;
+    id: string;
+    lambdaPolicy: PolicyDocument;
+    lambdaRole: Role;
+    lambdaEnvironment: LambdaWithIamAccessEnvironment;
+    lambdaLayers: ILayerVersion[];
+    lambdaFunction: IFunction;
+    lambdaIamUser: User;
+    lambdaUserAccessKey: CfnAccessKey;
+    lambdaUserAccessSecret: Secret;
+    lambdaVpc: IVpc;
+    lambdaSecurityGroups: ISecurityGroup[];
+    lambdaAccessPoint: IAccessPoint;
+    lambdaMountPath: string;
+    lambdaVpcSubnets: SubnetSelection;
+    constructor(parent: Construct, id: string, props: LambdaWithIamAccessProps);
+    /**
+     * @summary Initialise and provision resources
+     */
+    initResources(): void;
+    protected resolveVpc(): void;
+    protected resolveSecurityGroups(): void;
+    protected resolveAccessPoint(): void;
+    protected resolveMountPath(): void;
+    protected resolveVpcSubnets(): void;
+    /**
+     * @summary Method to create iam policy for Lambda function
+     */
+    protected createLambdaPolicy(): void;
+    /**
+     * @summary Method to create iam role for Lambda function
+     */
+    protected createLambdaRole(): void;
+    /**
+     * @summary Method to create environment variables for Lambda function
+     */
+    protected createLambdaEnvironment(): void;
+    /**
+     * @summary Method to create layers for Lambda function
+     */
+    protected createLambdaLayers(): void;
+    /**
+     * @summary Method to create lambda function
+     */
+    protected createLambdaFunction(): void;
+    /**
+     * @summary Method to create iam user for the lambda function
+     */
+    protected createIamUserForLambdaFunction(): void;
+    /**
+     * @summary Method to create iam secret for the lambda function
+     */
+    protected createIamSecretForLambdaFunction(): void;
+}

package/dist/src/construct/lambda-with-iam-access/main.js

@@ -0,0 +1,182 @@
+import { Fn } from 'aws-cdk-lib';
+import { SecurityGroup } from 'aws-cdk-lib/aws-ec2';
+import { CfnAccessKey, ManagedPolicy, Policy, PolicyDocument, PolicyStatement, User } from 'aws-cdk-lib/aws-iam';
+import { LayerVersion } from 'aws-cdk-lib/aws-lambda';
+import _ from 'lodash';
+import { CommonConstruct } from '../../common/index.js';
+import { Architecture } from '../../services/index.js';
+/**
+ * @classdesc Provides a construct to create a lambda function with IAM access
+ * @example
+ * import { LambdaWithIamAccess, LambdaWithIamAccessProps } '@gradientedge/cdk-utils'
+ * import { Construct } from 'constructs'
+ *
+ * class CustomConstruct extends LambdaWithIamAccess {
+ *   constructor(parent: Construct, id: string, props: LambdaWithIamAccessProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.id = id
+ *     this.initResources()
+ *   }
+ * }
+ */
+export class LambdaWithIamAccess extends CommonConstruct {
+    /* LambdaWithIamAccess props */
+    props;
+    id;
+    /* LambdaWithIamAccess resources */
+    lambdaPolicy;
+    lambdaRole;
+    lambdaEnvironment;
+    lambdaLayers = [];
+    lambdaFunction;
+    lambdaIamUser;
+    lambdaUserAccessKey;
+    lambdaUserAccessSecret;
+    lambdaVpc;
+    lambdaSecurityGroups;
+    lambdaAccessPoint;
+    lambdaMountPath;
+    lambdaVpcSubnets;
+    constructor(parent, id, props) {
+        super(parent, id, props);
+        this.props = props;
+        this.id = id;
+    }
+    /**
+     * @summary Initialise and provision resources
+     */
+    initResources() {
+        this.resolveVpc();
+        this.resolveSecurityGroups();
+        this.resolveAccessPoint();
+        this.resolveMountPath();
+        this.resolveVpcSubnets();
+        this.createLambdaPolicy();
+        this.createLambdaRole();
+        this.createLambdaEnvironment();
+        this.createLambdaLayers();
+        this.createLambdaFunction();
+        this.createIamUserForLambdaFunction();
+        this.createIamSecretForLambdaFunction();
+    }
+    resolveVpc() {
+        if (this.props.vpcName) {
+            this.lambdaVpc = this.vpcManager.retrieveCommonVpc(`${this.id}-vpc`, this, this.props.vpcName);
+        }
+    }
+    resolveSecurityGroups() {
+        if (this.props.securityGroupExportName) {
+            const lambdaSecurityGroup = SecurityGroup.fromSecurityGroupId(this, `${this.id}-security-group`, Fn.importValue(this.props.securityGroupExportName));
+            this.addCfnOutput(`${this.id}-sg`, lambdaSecurityGroup.securityGroupId);
+            this.lambdaSecurityGroups = [lambdaSecurityGroup];
+        }
+    }
+    resolveAccessPoint() { }
+    resolveMountPath() { }
+    resolveVpcSubnets() { }
+    /**
+     * @summary Method to create iam policy for Lambda function
+     */
+    createLambdaPolicy() {
+        this.lambdaPolicy = new PolicyDocument({
+            statements: [this.iamManager.statementForCreateAnyLogStream(), this.iamManager.statementForPutXrayTelemetry()],
+        });
+        if (this.props.configEnabled) {
+            this.lambdaPolicy.addStatements(this.iamManager.statementForReadAnyAppConfig(), this.iamManager.statementForAppConfigExecution());
+        }
+    }
+    /**
+     * @summary Method to create iam role for Lambda function
+     */
+    createLambdaRole() {
+        this.lambdaRole = this.iamManager.createRoleForLambda(`${this.id}-lambda-role`, this, this.lambdaPolicy);
+        if (this.props.vpcName) {
+            this.lambdaRole.addManagedPolicy(ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaVPCAccessExecutionRole'));
+        }
+    }
+    /**
+     * @summary Method to create environment variables for Lambda function
+     */
+    createLambdaEnvironment() {
+        this.lambdaEnvironment = {
+            LOG_LEVEL: this.props.logLevel,
+            NODE_ENV: this.props.nodeEnv,
+            TZ: this.props.timezone,
+        };
+    }
+    /**
+     * @summary Method to create layers for Lambda function
+     */
+    createLambdaLayers() {
+        const layers = [];
+        if (this.props.lambdaLayerSources) {
+            _.forEach(this.props.lambdaLayerSources, (source, index) => {
+                layers.push(this.lambdaManager.createLambdaLayer(`${this.id}-layer-${index}`, this, source));
+            });
+            this.lambdaLayers = layers;
+        }
+        if (this.props.configEnabled) {
+            const appConfigExtensionLayer = LayerVersion.fromLayerVersionArn(this, `${this.id}-ac-extlayer`, this.appConfigManager.getArnForAppConfigExtension(this, Architecture.ARM_64));
+            this.lambdaLayers.push(appConfigExtensionLayer);
+        }
+    }
+    /**
+     * @summary Method to create lambda function
+     */
+    createLambdaFunction() {
+        if (this.props.lambdaInsightsVersion) {
+            _.assign(this.props.lambda, {
+                insightsVersion: this.props.lambdaInsightsVersion,
+            });
+        }
+        this.lambdaFunction = this.lambdaManager.createLambdaFunction(`${this.id}-lambda`, this, this.props.lambda, this.lambdaRole, this.lambdaLayers, this.props.lambdaSource, this.props.lambdaHandler || 'index.handler', this.lambdaEnvironment, this.lambdaVpc, this.lambdaSecurityGroups, this.lambdaAccessPoint, this.lambdaMountPath, this.lambdaVpcSubnets);
+    }
+    /**
+     * @summary Method to create iam user for the lambda function
+     */
+    createIamUserForLambdaFunction() {
+        this.lambdaIamUser = new User(this, `${this.id}-lambda-user`, {
+            userName: this.resourceNameFormatter.format(`${this.id}-user`),
+        });
+        new Policy(this, `${this.id}-lambda-user-policy`, {
+            policyName: this.resourceNameFormatter.format(`${this.id}-policy`),
+            statements: [
+                new PolicyStatement({
+                    actions: ['lambda:InvokeFunction'],
+                    resources: [this.lambdaFunction.functionArn, `${this.lambdaFunction.functionArn}*`],
+                }),
+            ],
+            users: [this.lambdaIamUser],
+        });
+        if (this.props.lambda.lambdaAliases && !_.isEmpty(this.props.lambda.lambdaAliases)) {
+            _.forEach(this.props.lambda.lambdaAliases, (alias, index) => {
+                new Policy(this, `${this.id}-alias-user-policy`, {
+                    policyName: this.resourceNameFormatter.format(`${this.id}--alias-policy-${index}`),
+                    statements: [
+                        new PolicyStatement({
+                            actions: ['lambda:InvokeFunction'],
+                            resources: [
+                                `${this.lambdaFunction.functionArn}:${alias.aliasName}`,
+                                `${this.lambdaFunction.functionArn}:${alias.aliasName}*`,
+                            ],
+                        }),
+                    ],
+                    users: [this.lambdaIamUser],
+                });
+            });
+        }
+        this.lambdaUserAccessKey = new CfnAccessKey(this, `${this.id}-access-key-${this.props.stage}`, {
+            userName: this.lambdaIamUser.userName,
+        });
+    }
+    /**
+     * @summary Method to create iam secret for the lambda function
+     */
+    createIamSecretForLambdaFunction() {
+        this.lambdaUserAccessSecret = this.secretsManager.createSecret(`${this.id}-lambda-user-secret-${this.props.stage}`, this, this.props.lambdaSecret);
+        const cfnSecret = this.lambdaUserAccessSecret.node.defaultChild;
+        cfnSecret.generateSecretString = undefined;
+        cfnSecret.secretString = `{ "ACCESS_KEY_ID": "${this.lambdaUserAccessKey.ref}", "ACCESS_KEY_SECRET": "${this.lambdaUserAccessKey.attrSecretAccessKey}" }`;
+    }
+}

package/dist/src/construct/lambda-with-iam-access/types.d.ts

@@ -0,0 +1,20 @@
+import { AssetCode, LambdaInsightsVersion } from 'aws-cdk-lib/aws-lambda';
+import { SecretProps } from 'aws-cdk-lib/aws-secretsmanager';
+import { CommonStackProps } from '../../common/index.js';
+import { LambdaEnvironment, LambdaProps } from '../../services/index.js';
+export interface LambdaWithIamAccessProps extends CommonStackProps {
+    configEnabled?: boolean;
+    lambda: LambdaProps;
+    lambdaHandler?: string;
+    lambdaInsightsVersion?: LambdaInsightsVersion;
+    lambdaLayerSources: AssetCode[];
+    lambdaSecret: SecretProps;
+    lambdaSource: AssetCode;
+    logLevel: string;
+    nodeEnv: string;
+    securityGroupExportName?: string;
+    timezone: string;
+    vpcName?: string;
+}
+export interface LambdaWithIamAccessEnvironment extends LambdaEnvironment {
+}

package/dist/src/construct/lambda-with-iam-access/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/construct/piped-event-handler/index.d.ts

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

package/dist/src/construct/piped-event-handler/index.js

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

package/dist/src/construct/piped-event-handler/main.d.ts

@@ -0,0 +1,38 @@
+import { IQueue } from 'aws-cdk-lib/aws-sqs';
+import { Construct } from 'constructs';
+import { EventHandler } from '../event-handler/index.js';
+import { PipedEventHandlerProps } from './types.js';
+/**
+ * @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 declare class PipedEventHandler extends EventHandler {
+    props: PipedEventHandlerProps;
+    pipedDlq: IQueue;
+    pipedQueue: IQueue;
+    protected constructor(parent: Construct, id: string, props: PipedEventHandlerProps);
+    initResources(): void;
+    /**
+     * @summary Method to create the piped queue and dlq.
+     */
+    protected createPipedQueue(): void;
+    /**
+     * @summary Method to create the SQS to SFN pipe.
+     */
+    protected createSqsToSfnPipe(): void;
+    /**
+     * @summary Method to create the SQS to Lambda pipe.
+     */
+    protected createSqsToLambdaPipe(): void;
+}

package/dist/src/construct/piped-event-handler/main.js

@@ -0,0 +1,62 @@
+import { SqsQueue } from 'aws-cdk-lib/aws-events-targets';
+import _ from 'lodash';
+import { EventHandler } from '../event-handler/index.js';
+/**
+ * @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;
+    pipedDlq;
+    pipedQueue;
+    constructor(parent, id, props) {
+        super(parent, id, props);
+        this.props = props;
+        this.id = id;
+        this.useMapState = true;
+        this.provisionTarget = false;
+    }
+    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.
+     */
+    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.
+     */
+    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.
+     */
+    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);
+        });
+    }
+}