@gradientedge/cdk-utils 8.91.0 → 8.92.0

package/dist/src/lib/services/aws/elastic-kubernetes-service/main.d.ts

@@ -4,9 +4,6 @@ import * as eks from 'aws-cdk-lib/aws-eks';
 import { CommonConstruct } from '../../../common';
 import { EksClusterProps } from './types';
 /**
- * @stability stable
- * @category cdk-utils.eks-manager
- * @subcategory Construct
  * @classdesc Provides operations on AWS Elastic Kubernetes Service.
  * - A new instance of this class is injected into {@link CommonConstruct} constructor.
  * - If a custom construct extends {@link CommonConstruct}, an instance is available within the context.
@@ -20,17 +17,16 @@ import { EksClusterProps } from './types';
  *     this.eksManager.createEksDeployment('MyEksDeployment', this, image, vpc)
  *   }
  * }
- *
  * @see [CDK EKS Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_eks-readme.html}
  */
 export declare class EksManager {
     /**
      * @summary Method to create an eks deployment
-     * @param {string} id scoped id of the resource
-     * @param {CommonConstruct} scope scope in which this resource is defined
-     * @param {EksClusterProps} props
-     * @param {ecr.DockerImageAsset} image
-     * @param {ec2.IVpc} vpc
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param image
+     * @param vpc
      */
     createEksDeployment(id: string, scope: CommonConstruct, props: EksClusterProps, image: ecr.DockerImageAsset, vpc: ec2.IVpc): eks.Cluster;
 }

package/dist/src/lib/services/aws/elastic-kubernetes-service/main.js

@@ -28,9 +28,6 @@ const ec2 = __importStar(require("aws-cdk-lib/aws-ec2"));
 const eks = __importStar(require("aws-cdk-lib/aws-eks"));
 const utils = __importStar(require("../../../utils"));
 /**
- * @stability stable
- * @category cdk-utils.eks-manager
- * @subcategory Construct
  * @classdesc Provides operations on AWS Elastic Kubernetes Service.
  * - A new instance of this class is injected into {@link CommonConstruct} constructor.
  * - If a custom construct extends {@link CommonConstruct}, an instance is available within the context.
@@ -44,17 +41,16 @@ const utils = __importStar(require("../../../utils"));
  *     this.eksManager.createEksDeployment('MyEksDeployment', this, image, vpc)
  *   }
  * }
- *
  * @see [CDK EKS Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_eks-readme.html}
  */
 class EksManager {
     /**
      * @summary Method to create an eks deployment
-     * @param {string} id scoped id of the resource
-     * @param {CommonConstruct} scope scope in which this resource is defined
-     * @param {EksClusterProps} props
-     * @param {ecr.DockerImageAsset} image
-     * @param {ec2.IVpc} vpc
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param image
+     * @param vpc
      */
     createEksDeployment(id, scope, props, image, vpc) {
         if (!props)
@@ -71,8 +67,8 @@ class EksManager {
                     spec: {
                         containers: [
                             {
-                                name: `${id}`.toLowerCase(),
                                 image: image.imageUri,
+                                name: `${id}`.toLowerCase(),
                                 ports: [{ containerPort: props.appContainerPort }],
                             },
                         ],
@@ -85,16 +81,16 @@ class EksManager {
             kind: 'Service',
             metadata: { name: `${id}`.toLowerCase() },
             spec: {
-                type: 'LoadBalancer',
                 ports: [
                     {
                         name: 'http-port',
-                        protocol: 'TCP',
                         port: 80,
+                        protocol: 'TCP',
                         targetPort: props.appContainerPort,
                     },
                 ],
                 selector: appLabel,
+                type: 'LoadBalancer',
             },
         };
         const cluster = new eks.Cluster(scope, `${id}Cluster`, {

package/dist/src/lib/services/aws/elastic-kubernetes-service/types.d.ts

@@ -1,9 +1,7 @@
 import { ClusterProps } from 'aws-cdk-lib/aws-eks';
 /**
- * @category cdk-utils.eks-manager
- * @subcategory Properties
  */
 export interface EksClusterProps extends ClusterProps {
-    appContainerPort: number;
     appCapacity: number;
+    appContainerPort: number;
 }

package/dist/src/lib/services/aws/elasticache/main.d.ts

@@ -2,9 +2,6 @@ import * as elasticache from 'aws-cdk-lib/aws-elasticache';
 import { CommonConstruct } from '../../../common';
 import { ElastiCacheProps, ReplicatedElastiCacheProps } from './types';
 /**
- * @stability stable
- * @category cdk-utils.elasticache-manager
- * @subcategory Construct
  * @summary Provides operations on AWS ElastiCache Service.
  * - A new instance of scope class is injected into {@link CommonConstruct} constructor.
  * - If a custom construct extends {@link CommonConstruct}, an instance is available within the context.
@@ -18,34 +15,33 @@ import { ElastiCacheProps, ReplicatedElastiCacheProps } from './types';
  *     this.elasticacheManager.createElastiCache('MyElastiCache', scope, props)
  *   }
  * }
- *
  * @see [CDK ElastiCache Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_elasticache-readme.html}
  */
 export declare class ElastiCacheManager {
     /**
      * @summary Method to create an elasticache resource
-     * @param {string} id scoped id of the resource
-     * @param {CommonConstruct} scope scope in which scope resource is defined
-     * @param {string[]} subnetIds
+     * @param id scoped id of the resource
+     * @param scope scope in which scope resource is defined
+     * @param subnetIds
      */
     createElastiCacheSubnetGroup(id: string, scope: CommonConstruct, subnetIds: string[]): elasticache.CfnSubnetGroup;
     /**
      * @summary Method to create an elasticache resource
-     * @param {string} id scoped id of the resource
-     * @param {CommonConstruct} scope scope in which scope resource is defined
-     * @param {ElastiCacheProps} props
-     * @param {string[]} subnetIds
-     * @param {string[]} securityGroupIds
-     * @param {string[]} logDeliveryConfigurations
+     * @param id scoped id of the resource
+     * @param scope scope in which scope resource is defined
+     * @param props
+     * @param subnetIds
+     * @param securityGroupIds
+     * @param logDeliveryConfigurations
      */
     createElastiCache(id: string, scope: CommonConstruct, props: ElastiCacheProps, subnetIds: string[], securityGroupIds: string[], logDeliveryConfigurations?: any): elasticache.CfnCacheCluster;
     /**
      * @summary Method to create an replicated elasticache resource
-     * @param {string} id scoped id of the resource
-     * @param {CommonConstruct} scope scope in which scope resource is defined
-     * @param {ReplicatedElastiCacheProps} props
-     * @param {string[]} subnetIds
-     * @param {string[]} securityGroupIds
+     * @param id scoped id of the resource
+     * @param scope scope in which scope resource is defined
+     * @param props
+     * @param subnetIds
+     * @param securityGroupIds
      */
     createReplicatedElastiCache(id: string, scope: CommonConstruct, props: ReplicatedElastiCacheProps, subnetIds: string[], securityGroupIds: string[]): elasticache.CfnReplicationGroup;
 }

package/dist/src/lib/services/aws/elasticache/main.js

@@ -28,9 +28,6 @@ const elasticache = __importStar(require("aws-cdk-lib/aws-elasticache"));
 const utils = __importStar(require("../../../utils"));
 const cdk = __importStar(require("aws-cdk-lib"));
 /**
- * @stability stable
- * @category cdk-utils.elasticache-manager
- * @subcategory Construct
  * @summary Provides operations on AWS ElastiCache Service.
  * - A new instance of scope class is injected into {@link CommonConstruct} constructor.
  * - If a custom construct extends {@link CommonConstruct}, an instance is available within the context.
@@ -44,56 +41,55 @@ const cdk = __importStar(require("aws-cdk-lib"));
  *     this.elasticacheManager.createElastiCache('MyElastiCache', scope, props)
  *   }
  * }
- *
  * @see [CDK ElastiCache Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_elasticache-readme.html}
  */
 class ElastiCacheManager {
     /**
      * @summary Method to create an elasticache resource
-     * @param {string} id scoped id of the resource
-     * @param {CommonConstruct} scope scope in which scope resource is defined
-     * @param {string[]} subnetIds
+     * @param id scoped id of the resource
+     * @param scope scope in which scope resource is defined
+     * @param subnetIds
      */
     createElastiCacheSubnetGroup(id, scope, subnetIds) {
         return new elasticache.CfnSubnetGroup(scope, `${id}`, {
             cacheSubnetGroupName: `${id}-subnet-group-${scope.props.stage}`,
-            subnetIds: subnetIds,
             description: `${id}-subnet-group-${scope.props.stage}`,
+            subnetIds: subnetIds,
         });
     }
     /**
      * @summary Method to create an elasticache resource
-     * @param {string} id scoped id of the resource
-     * @param {CommonConstruct} scope scope in which scope resource is defined
-     * @param {ElastiCacheProps} props
-     * @param {string[]} subnetIds
-     * @param {string[]} securityGroupIds
-     * @param {string[]} logDeliveryConfigurations
+     * @param id scoped id of the resource
+     * @param scope scope in which scope resource is defined
+     * @param props
+     * @param subnetIds
+     * @param securityGroupIds
+     * @param logDeliveryConfigurations
      */
     createElastiCache(id, scope, props, subnetIds, securityGroupIds, logDeliveryConfigurations) {
         if (!props)
             throw `ElastiCache props undefined for ${id}`;
         const subnetGroup = this.createElastiCacheSubnetGroup(`${id}-subnetGroup`, scope, subnetIds);
         const elasticacheCluster = new elasticache.CfnCacheCluster(scope, `${id}`, {
+            autoMinorVersionUpgrade: props.autoMinorVersionUpgrade,
+            azMode: props.azMode,
+            cacheNodeType: props.cacheNodeType,
+            cacheParameterGroupName: props.cacheParameterGroupName,
+            cacheSecurityGroupNames: props.cacheSecurityGroupNames,
+            cacheSubnetGroupName: subnetGroup.cacheSubnetGroupName,
+            clusterName: `${id}-${scope.props.stage}`,
             engine: props.engine,
             engineVersion: props.engineVersion,
-            cacheNodeType: props.cacheNodeType,
+            logDeliveryConfigurations: logDeliveryConfigurations,
             numCacheNodes: props.numCacheNodes,
-            clusterName: `${id}-${scope.props.stage}`,
-            vpcSecurityGroupIds: securityGroupIds,
-            cacheSubnetGroupName: subnetGroup.cacheSubnetGroupName,
-            azMode: props.azMode,
+            port: props.port,
             preferredAvailabilityZones: props.preferredAvailabilityZones,
             preferredMaintenanceWindow: props.preferredMaintenanceWindow,
-            autoMinorVersionUpgrade: props.autoMinorVersionUpgrade,
-            cacheParameterGroupName: props.cacheParameterGroupName,
-            cacheSecurityGroupNames: props.cacheSecurityGroupNames,
-            port: props.port,
             snapshotArns: props.snapshotArns,
             snapshotName: props.snapshotName,
             snapshotRetentionLimit: props.snapshotRetentionLimit,
             snapshotWindow: props.snapshotWindow,
-            logDeliveryConfigurations: logDeliveryConfigurations,
+            vpcSecurityGroupIds: securityGroupIds,
         });
         elasticacheCluster.addDependency(subnetGroup);
         if (props.tags && props.tags.length > 0) {
@@ -108,38 +104,38 @@ class ElastiCacheManager {
     }
     /**
      * @summary Method to create an replicated elasticache resource
-     * @param {string} id scoped id of the resource
-     * @param {CommonConstruct} scope scope in which scope resource is defined
-     * @param {ReplicatedElastiCacheProps} props
-     * @param {string[]} subnetIds
-     * @param {string[]} securityGroupIds
+     * @param id scoped id of the resource
+     * @param scope scope in which scope resource is defined
+     * @param props
+     * @param subnetIds
+     * @param securityGroupIds
      */
     createReplicatedElastiCache(id, scope, props, subnetIds, securityGroupIds) {
         if (!props)
             throw `ElastiCache props undefined for ${id}`;
         const subnetGroup = this.createElastiCacheSubnetGroup(`${id}-subnetGroup`, scope, subnetIds);
         const elasticacheCluster = new elasticache.CfnReplicationGroup(scope, `${id}`, {
-            replicationGroupDescription: `${id} Redis Replication Cluster`,
-            replicationGroupId: `${id}-${scope.props.stage}`,
-            cacheNodeType: props.cacheNodeType,
-            engine: props.engine,
-            cacheSubnetGroupName: subnetGroup.cacheSubnetGroupName,
-            securityGroupIds: securityGroupIds,
-            numNodeGroups: props.numNodeGroups,
-            replicasPerNodeGroup: props.replicasPerNodeGroup,
+            autoMinorVersionUpgrade: props.autoMinorVersionUpgrade,
             automaticFailoverEnabled: props.automaticFailoverEnabled,
-            multiAzEnabled: props.multiAzEnabled,
+            cacheNodeType: props.cacheNodeType,
             cacheParameterGroupName: props.cacheParameterGroupName,
             cacheSecurityGroupNames: props.cacheSecurityGroupNames,
+            cacheSubnetGroupName: subnetGroup.cacheSubnetGroupName,
+            engine: props.engine,
             engineVersion: props.engineVersion,
             globalReplicationGroupId: props.globalReplicationGroupId,
             logDeliveryConfigurations: props.logDeliveryConfigurations,
+            multiAzEnabled: props.multiAzEnabled,
             numCacheClusters: props.numCacheClusters,
+            numNodeGroups: props.numNodeGroups,
             port: props.port,
             preferredCacheClusterAZs: props.preferredCacheClusterAZs,
             preferredMaintenanceWindow: props.preferredMaintenanceWindow,
             primaryClusterId: props.primaryClusterId,
-            autoMinorVersionUpgrade: props.autoMinorVersionUpgrade,
+            replicasPerNodeGroup: props.replicasPerNodeGroup,
+            replicationGroupDescription: `${id} Redis Replication Cluster`,
+            replicationGroupId: `${id}-${scope.props.stage}`,
+            securityGroupIds: securityGroupIds,
         });
         elasticacheCluster.addDependency(subnetGroup);
         return elasticacheCluster;

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

@@ -1,13 +1,9 @@
 import { CfnCacheClusterProps, CfnReplicationGroupProps } from 'aws-cdk-lib/aws-elasticache';
 /**
- * @category cdk-utils.elasticache-manager
- * @category Compute
  */
 export interface ElastiCacheProps extends CfnCacheClusterProps {
 }
 /**
- * @category cdk-utils.elasticache-manager
- * @category Compute
  */
 export interface ReplicatedElastiCacheProps extends CfnReplicationGroupProps {
 }

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

@@ -8,9 +8,6 @@ import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
 import { CommonConstruct } from '../../../common';
 import { EventBusProps, EventRuleProps, RuleProps, SqsToSfnPipeProps } from './types';
 /**
- * @stability stable
- * @category cdk-utils.event-manager
- * @subcategory Construct
  * @classdesc Provides operations on AWS EventBridge.
  * - A new instance of this class is injected into {@link CommonConstruct} constructor.
  * - If a custom construct extends {@link CommonConstruct}, an instance is available within the context.
@@ -24,53 +21,52 @@ import { EventBusProps, EventRuleProps, RuleProps, SqsToSfnPipeProps } from './t
  *     this.eventManager.createLambdaRule('MyLambdaRule', this, lambdaFunction)
  *   }
  * }
- *
  * @see [CDK EventBridge Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events-readme.html}
  */
 export declare class EventManager {
     /**
      * Method to create an event bus
-     * @param {string} id scoped id of the resource
-     * @param {CommonConstruct} scope scope in which this resource is defined
-     * @param {EventBusProps} props event bus properties
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props event bus properties
      */
     createEventBus(id: string, scope: CommonConstruct, props: EventBusProps): events.EventBus;
     /**
      * Method to create an event rule
-     * @param {string} id scoped id of the resource
-     * @param {CommonConstruct} scope scope in which this resource is defined
-     * @param {EventRuleProps} props event rule properties
-     * @param {events.IEventBus?} eventBus optional custom event bus
-     * @param {events.IRuleTarget[]?} targets optional event targets
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props event rule properties
+     * @param eventBus optional custom event bus
+     * @param targets optional event targets
      */
     createRule(id: string, scope: CommonConstruct, props: EventRuleProps, eventBus?: events.IEventBus, targets?: events.IRuleTarget[]): events.Rule;
     /**
      * @summary Method to create an eventbridge rule with lambda target
-     * @param {string} id scoped id of the resource
-     * @param {CommonConstruct} scope scope in which this resource is defined
-     * @param {RuleProps} props
-     * @param {lambda.Function} lambdaFunction
-     * @param {string} eventBusName
-     * @param {any} eventPattern
-     * @param {string} scheduleExpression
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param lambdaFunction
+     * @param eventBusName
+     * @param eventPattern
+     * @param scheduleExpression
      */
     createLambdaRule(id: string, scope: CommonConstruct, props: RuleProps, lambdaFunction: lambda.Function, eventBusName?: string, eventPattern?: any, scheduleExpression?: string): events.CfnRule;
     /**
      * @summary Method to create an eventbridge rule with fargate task target
-     * @param {string} id scoped id of the resource
-     * @param {CommonConstruct} scope scope in which this resource is defined
-     * @param {EventRuleProps} props
-     * @param {ecs.ICluster} cluster
-     * @param {ecs.ITaskDefinition} task
-     * @param {string[]} subnetIds
-     * @param {iam.Role | iam.CfnRole} role
-     * @param {any} eventPattern
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param cluster
+     * @param task
+     * @param subnetIds
+     * @param role
+     * @param eventPattern
      */
     createFargateTaskRule(id: string, scope: CommonConstruct, props: RuleProps, cluster: ecs.ICluster, task: ecs.ITaskDefinition, subnetIds: string[], role: iam.Role | iam.CfnRole, eventPattern?: any): events.CfnRule;
     /**
      * @summary Method to create an eventbridge pipe with sqs queue as source and step function as target
-     * @param {string} id scoped id of the resource
-     * @param {CommonConstruct} scope scope in which this resource is defined
+     * @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 targetStepFunction the target step function

package/dist/src/lib/services/aws/eventbridge/main.js

@@ -31,9 +31,6 @@ const utils = __importStar(require("../../../utils"));
 const cdk = __importStar(require("aws-cdk-lib"));
 const pipes = __importStar(require("aws-cdk-lib/aws-pipes"));
 /**
- * @stability stable
- * @category cdk-utils.event-manager
- * @subcategory Construct
  * @classdesc Provides operations on AWS EventBridge.
  * - A new instance of this class is injected into {@link CommonConstruct} constructor.
  * - If a custom construct extends {@link CommonConstruct}, an instance is available within the context.
@@ -47,15 +44,14 @@ const pipes = __importStar(require("aws-cdk-lib/aws-pipes"));
  *     this.eventManager.createLambdaRule('MyLambdaRule', this, lambdaFunction)
  *   }
  * }
- *
  * @see [CDK EventBridge Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events-readme.html}
  */
 class EventManager {
     /**
      * Method to create an event bus
-     * @param {string} id scoped id of the resource
-     * @param {CommonConstruct} scope scope in which this resource is defined
-     * @param {EventBusProps} props event bus properties
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props event bus properties
      */
     createEventBus(id, scope, props) {
         if (!props)
@@ -69,21 +65,21 @@ class EventManager {
     }
     /**
      * Method to create an event rule
-     * @param {string} id scoped id of the resource
-     * @param {CommonConstruct} scope scope in which this resource is defined
-     * @param {EventRuleProps} props event rule properties
-     * @param {events.IEventBus?} eventBus optional custom event bus
-     * @param {events.IRuleTarget[]?} targets optional event targets
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props event rule properties
+     * @param eventBus optional custom event bus
+     * @param targets optional event targets
      */
     createRule(id, scope, props, eventBus, targets) {
         if (!props)
             throw `EventRule props undefined for ${id}`;
         const rule = new events.Rule(scope, `${id}`, {
-            eventBus: eventBus,
             description: props.description,
-            ruleName: `${props.ruleName}-${scope.props.stage}`,
-            eventPattern: props.eventPattern,
             enabled: props.enabled,
+            eventBus: eventBus,
+            eventPattern: props.eventPattern,
+            ruleName: `${props.ruleName}-${scope.props.stage}`,
             schedule: props.schedule,
         });
         if (targets && targets.length > 0) {
@@ -102,13 +98,13 @@ class EventManager {
     }
     /**
      * @summary Method to create an eventbridge rule with lambda target
-     * @param {string} id scoped id of the resource
-     * @param {CommonConstruct} scope scope in which this resource is defined
-     * @param {RuleProps} props
-     * @param {lambda.Function} lambdaFunction
-     * @param {string} eventBusName
-     * @param {any} eventPattern
-     * @param {string} scheduleExpression
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param lambdaFunction
+     * @param eventBusName
+     * @param eventPattern
+     * @param scheduleExpression
      */
     createLambdaRule(id, scope, props, lambdaFunction, eventBusName, eventPattern, scheduleExpression) {
         if (!props)
@@ -117,8 +113,8 @@ class EventManager {
             description: 'Rule to send notification to lambda function target',
             eventBusName: eventBusName,
             eventPattern: eventPattern,
-            scheduleExpression: scheduleExpression,
             name: `${props.name}-${scope.props.stage}`,
+            scheduleExpression: scheduleExpression,
             state: props.state,
             targets: [
                 {
@@ -140,14 +136,14 @@ class EventManager {
     }
     /**
      * @summary Method to create an eventbridge rule with fargate task target
-     * @param {string} id scoped id of the resource
-     * @param {CommonConstruct} scope scope in which this resource is defined
-     * @param {EventRuleProps} props
-     * @param {ecs.ICluster} cluster
-     * @param {ecs.ITaskDefinition} task
-     * @param {string[]} subnetIds
-     * @param {iam.Role | iam.CfnRole} role
-     * @param {any} eventPattern
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param cluster
+     * @param task
+     * @param subnetIds
+     * @param role
+     * @param eventPattern
      */
     createFargateTaskRule(id, scope, props, cluster, task, subnetIds, role, eventPattern) {
         if (!props)
@@ -160,7 +156,6 @@ class EventManager {
             targets: [
                 {
                     arn: cluster.clusterArn,
-                    id: `${id}-${scope.props.stage}`,
                     ecsParameters: {
                         launchType: 'FARGATE',
                         networkConfiguration: {
@@ -169,6 +164,7 @@ class EventManager {
                         taskCount: 1,
                         taskDefinitionArn: task.taskDefinitionArn,
                     },
+                    id: `${id}-${scope.props.stage}`,
                     roleArn: role instanceof iam.Role ? role.roleArn : role.attrArn,
                 },
             ],
@@ -179,8 +175,8 @@ class EventManager {
     }
     /**
      * @summary Method to create an eventbridge pipe with sqs queue as source and step function as target
-     * @param {string} id scoped id of the resource
-     * @param {CommonConstruct} scope scope in which this resource is defined
+     * @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 targetStepFunction the target step function
@@ -189,8 +185,11 @@ class EventManager {
         const pipeRole = scope.iamManager.createRoleForSqsToSfnPipe(`${id}-role`, scope, sourceQueue.queueArn, targetStepFunction.stateMachineArn);
         const pipe = new pipes.CfnPipe(scope, `${id}`, {
             ...props,
-            name: `${props.name}-${scope.props.stage}`,
             description: props.description,
+            enrichment: props.enrichment,
+            enrichmentParameters: props.enrichmentParameters,
+            name: `${props.name}-${scope.props.stage}`,
+            roleArn: pipeRole.roleArn,
             source: sourceQueue.queueArn,
             sourceParameters: {
                 filterCriteria: props.pipeFilterPattern
@@ -214,9 +213,6 @@ class EventManager {
                     invocationType: props.sfnInvocationType ?? 'FIRE_AND_FORGET',
                 },
             },
-            enrichment: props.enrichment,
-            enrichmentParameters: props.enrichmentParameters,
-            roleArn: pipeRole.roleArn,
         });
         utils.createCfnOutput(`${id}-pipeArn`, scope, pipe.attrArn);
         utils.createCfnOutput(`${id}-pipeName`, scope, pipe.name);

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

@@ -3,9 +3,6 @@ import * as targets from 'aws-cdk-lib/aws-events-targets';
 import * as logs from 'aws-cdk-lib/aws-logs';
 import { CommonConstruct } from '../../../common';
 /**
- * @stability stable
- * @category cdk-utils.event-taeget-manager
- * @subcategory Construct
  * @classdesc Provides operations on AWS EventBridge Targets.
  * - A new instance of this class is injected into {@link CommonConstruct} constructor.
  * - If a custom construct extends {@link CommonConstruct}, an instance is available within the context.
@@ -19,17 +16,16 @@ import { CommonConstruct } from '../../../common';
  *     this.eventTargetManager.createCloudWatchLogGroupNoPolicy('MyLogGrouptarget', this, myLogGroup)
  *   }
  * }
- *
  * @see [CDK EventBridge Target Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events_targets-readme.html}
  */
 export declare class EventTargetManager {
     /**
      * @summary Method to create a cloud watch log group target without a policy.
      * - This method is created as a workaround for cdk issue - https://github.com/aws/aws-cdk/issues/17002
-     * @param {string} id scoped id of the resource
-     * @param {CommonConstruct} scope scope in which this resource is defined
-     * @param {logs.ILogGroup} logGroup the log group
-     * @param {LogGroupNoPolicyProps} props the log group target properties
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param logGroup the log group
+     * @param props the log group target properties
      */
     createCloudWatchLogGroupNoPolicy(id: string, scope: CommonConstruct, logGroup: logs.ILogGroup, props?: LogGroupNoPolicyProps): CloudWatchLogGroupNoPolicy;
 }
@@ -41,7 +37,6 @@ export interface LogGroupNoPolicyProps extends targets.TargetBaseProps {
      * The event to send to the CloudWatch LogGroup
      *
      * This will be the event logged into the CloudWatch LogGroup
-     *
      * @default - the entire EventBridge event
      */
     readonly event?: events.RuleTargetInput;
@@ -55,6 +50,8 @@ export declare class CloudWatchLogGroupNoPolicy implements events.IRuleTarget {
     constructor(logGroup: logs.ILogGroup, props?: LogGroupNoPolicyProps);
     /**
      * Returns a RuleTarget that can be used to log an event into a CloudWatch LogGroup
+     * @param _rule
+     * @param _id
      */
     bind(_rule: events.IRule, _id?: string): events.RuleTargetConfig;
 }