@gradientedge/cdk-utils 8.118.0 → 8.119.0

package/src/lib/services/aws/elastic-container-service/main.ts

@@ -1,11 +1,21 @@
-import * as cdk from 'aws-cdk-lib'
-import * as ec2 from 'aws-cdk-lib/aws-ec2'
-import * as ecs from 'aws-cdk-lib/aws-ecs'
-import * as ecsPatterns from 'aws-cdk-lib/aws-ecs-patterns'
-import * as iam from 'aws-cdk-lib/aws-iam'
-import * as logs from 'aws-cdk-lib/aws-logs'
-import * as utils from '../../../utils'
+import { Duration, Tags } from 'aws-cdk-lib'
+import { IVpc } from 'aws-cdk-lib/aws-ec2'
+import {
+  Cluster,
+  Compatibility,
+  ContainerImage,
+  CpuArchitecture,
+  ICluster,
+  LogDriver,
+  NetworkMode,
+  OperatingSystemFamily,
+  TaskDefinition,
+} from 'aws-cdk-lib/aws-ecs'
+import { ApplicationLoadBalancedFargateService } from 'aws-cdk-lib/aws-ecs-patterns'
+import { Role } from 'aws-cdk-lib/aws-iam'
+import { ILogGroup } from 'aws-cdk-lib/aws-logs'
 import { CommonConstruct } from '../../../common'
+import { createCfnOutput } from '../../../utils'
 import { EcsApplicationLoadBalancedFargateServiceProps, EcsClusterProps, EcsTaskProps } from './types'
 
 /**
@@ -16,7 +26,7 @@ import { EcsApplicationLoadBalancedFargateServiceProps, EcsClusterProps, EcsTask
  * import { CommonConstruct } from '@gradientedge/cdk-utils'
  *
  * class CustomConstruct extends CommonConstruct {
- *   constructor(parent: cdk.Construct, id: string, props: common.CommonStackProps) {
+ *   constructor(parent: Construct, id: string, props: common.CommonStackProps) {
  *     super(parent, id, props)
  *     this.props = props
  *     this.ecsManager.createEcsCluster('MyCluster', this, vpc)
@@ -32,10 +42,10 @@ export class EcsManager {
    * @param props
    * @param vpc
    */
-  public createEcsCluster(id: string, scope: CommonConstruct, props: EcsClusterProps, vpc: ec2.IVpc) {
+  public createEcsCluster(id: string, scope: CommonConstruct, props: EcsClusterProps, vpc: IVpc) {
     if (!props) throw `Ecs Cluster props undefined for ${id}`
 
-    const ecsCluster = new ecs.Cluster(scope, `${id}`, {
+    const ecsCluster = new Cluster(scope, `${id}`, {
       capacity: props.capacity,
       clusterName: `${props.clusterName}-${scope.props.stage}`,
       containerInsights: props.containerInsights,
@@ -47,12 +57,12 @@ export class EcsManager {
 
     if (props.tags && props.tags.length > 0) {
       props.tags.forEach(tag => {
-        cdk.Tags.of(ecsCluster).add(tag.key, tag.value)
+        Tags.of(ecsCluster).add(tag.key, tag.value)
       })
     }
 
-    utils.createCfnOutput(`${id}-clusterArn`, scope, ecsCluster.clusterArn)
-    utils.createCfnOutput(`${id}-clusterName`, scope, ecsCluster.clusterName)
+    createCfnOutput(`${id}-clusterArn`, scope, ecsCluster.clusterArn)
+    createCfnOutput(`${id}-clusterName`, scope, ecsCluster.clusterName)
 
     return ecsCluster
   }
@@ -74,18 +84,18 @@ export class EcsManager {
     id: string,
     scope: CommonConstruct,
     props: EcsTaskProps,
-    cluster: ecs.ICluster,
-    role: iam.Role,
-    logGroup: logs.ILogGroup,
-    containerImage: ecs.ContainerImage,
+    cluster: ICluster,
+    role: Role,
+    logGroup: ILogGroup,
+    containerImage: ContainerImage,
     environment?: any,
     secrets?: any,
     command?: string[]
   ) {
     if (!props) throw `EcsTask props undefined for ${id}`
 
-    const ecsTask = new ecs.TaskDefinition(scope, `${id}`, {
-      compatibility: ecs.Compatibility.FARGATE,
+    const ecsTask = new TaskDefinition(scope, `${id}`, {
+      compatibility: Compatibility.FARGATE,
       cpu: props.cpu,
       ephemeralStorageGiB: props.ephemeralStorageGiB,
       executionRole: role,
@@ -93,13 +103,13 @@ export class EcsManager {
       inferenceAccelerators: props.inferenceAccelerators,
       ipcMode: props.ipcMode,
       memoryMiB: props.memoryMiB,
-      networkMode: ecs.NetworkMode.AWS_VPC,
+      networkMode: NetworkMode.AWS_VPC,
       pidMode: props.pidMode,
       placementConstraints: props.placementConstraints,
       proxyConfiguration: props.proxyConfiguration,
       runtimePlatform: {
-        cpuArchitecture: props.runtimePlatform?.cpuArchitecture ?? ecs.CpuArchitecture.X86_64,
-        operatingSystemFamily: props.runtimePlatform?.operatingSystemFamily ?? ecs.OperatingSystemFamily.LINUX,
+        cpuArchitecture: props.runtimePlatform?.cpuArchitecture ?? CpuArchitecture.X86_64,
+        operatingSystemFamily: props.runtimePlatform?.operatingSystemFamily ?? OperatingSystemFamily.LINUX,
       },
       taskRole: role,
       volumes: props.volumes,
@@ -111,7 +121,7 @@ export class EcsManager {
       disableNetworking: false,
       environment: environment,
       image: containerImage,
-      logging: ecs.LogDriver.awsLogs({
+      logging: LogDriver.awsLogs({
         logGroup: logGroup,
         logRetention: props.logging?.logRetention,
         multilinePattern: props.logging?.multilinePattern,
@@ -124,17 +134,17 @@ export class EcsManager {
 
     if (props.tags && props.tags.length > 0) {
       props.tags.forEach(tag => {
-        cdk.Tags.of(ecsTask).add(tag.key, tag.value)
+        Tags.of(ecsTask).add(tag.key, tag.value)
       })
     }
 
-    utils.createCfnOutput(`${id}-taskArn`, scope, ecsTask.taskDefinitionArn)
+    createCfnOutput(`${id}-taskArn`, scope, ecsTask.taskDefinitionArn)
 
     return ecsTask
   }
 
   /**
-   * @summary Method to create an application loadbalanced ecs fargate task
+   * @summary Method to create an application load balanced ecs fargate task
    * @param id scoped id of the resource
    * @param scope scope in which this resource is defined
    * @param props
@@ -145,13 +155,14 @@ export class EcsManager {
     id: string,
     scope: CommonConstruct,
     props: EcsApplicationLoadBalancedFargateServiceProps,
-    cluster: ecs.ICluster,
-    logGroup: logs.ILogGroup
+    cluster: ICluster,
+    logGroup: ILogGroup
   ) {
-    if (!props) throw `EcsLoadbalanced Fargate Serivice props undefined for ${id}`
-    if (!props.taskImageOptions) throw `TaskImageOptions for EcsLoadbalanced Fargate Serivice props undefined for ${id}`
+    if (!props) throw `Ecs Load balanced Fargate Service props undefined for ${id}`
+    if (!props.taskImageOptions)
+      throw `TaskImageOptions for Ecs Load balanced Fargate Service props undefined for ${id}`
 
-    const fargateService = new ecsPatterns.ApplicationLoadBalancedFargateService(scope, `${id}-ecs-service`, {
+    const fargateService = new ApplicationLoadBalancedFargateService(scope, `${id}-ecs-service`, {
       assignPublicIp: props.assignPublicIp ?? true,
       certificate: props.certificate,
       cluster: cluster,
@@ -160,13 +171,13 @@ export class EcsManager {
       domainName: props.domainName,
       domainZone: props.domainZone,
       enableECSManagedTags: true,
-      healthCheckGracePeriod: props.healthCheckGracePeriod ?? cdk.Duration.seconds(60),
+      healthCheckGracePeriod: props.healthCheckGracePeriod ?? Duration.seconds(60),
       listenerPort: props.listenerPort,
       loadBalancerName: `${id}-${scope.props.stage}`,
       memoryLimitMiB: props.memoryLimitMiB,
       runtimePlatform: {
-        cpuArchitecture: props.runtimePlatform?.cpuArchitecture ?? ecs.CpuArchitecture.X86_64,
-        operatingSystemFamily: props.runtimePlatform?.operatingSystemFamily ?? ecs.OperatingSystemFamily.LINUX,
+        cpuArchitecture: props.runtimePlatform?.cpuArchitecture ?? CpuArchitecture.X86_64,
+        operatingSystemFamily: props.runtimePlatform?.operatingSystemFamily ?? OperatingSystemFamily.LINUX,
       },
       serviceName: `${id}-${scope.props.stage}`,
       taskImageOptions: {
@@ -177,7 +188,7 @@ export class EcsManager {
         image: props.taskImageOptions.image,
         logDriver:
           props.taskImageOptions?.logDriver ??
-          ecs.LogDriver.awsLogs({
+          LogDriver.awsLogs({
             logGroup: logGroup,
             logRetention: props.logging?.logRetention,
             multilinePattern: props.logging?.multilinePattern,
@@ -194,11 +205,11 @@ export class EcsManager {
         healthyGrpcCodes: props.healthCheck.healthyGrpcCodes,
         healthyHttpCodes: props.healthCheck.healthyHttpCodes,
         healthyThresholdCount: props.healthCheck.healthyThresholdCount,
-        interval: props.healthCheck.interval ?? cdk.Duration.seconds(props.healthCheck.intervalInSecs),
+        interval: props.healthCheck.interval ?? Duration.seconds(props.healthCheck.intervalInSecs),
         path: props.healthCheck.path ?? '/',
         port: props.healthCheck.port,
         protocol: props.healthCheck.protocol,
-        timeout: props.healthCheck.timeout ?? cdk.Duration.seconds(props.healthCheck.timeoutInSecs),
+        timeout: props.healthCheck.timeout ?? Duration.seconds(props.healthCheck.timeoutInSecs),
         unhealthyThresholdCount: props.healthCheck.unhealthyThresholdCount,
       })
     }

package/src/lib/services/aws/elastic-container-service/types.ts

@@ -1,8 +1,8 @@
-import { TagProps } from '../../../types'
-import { AwsLogDriverProps, ClusterProps, MountPoint, TaskDefinitionProps } from 'aws-cdk-lib/aws-ecs'
 import { ScalingSchedule } from 'aws-cdk-lib/aws-applicationautoscaling'
+import { AwsLogDriverProps, ClusterProps, MountPoint, TaskDefinitionProps } from 'aws-cdk-lib/aws-ecs'
 import { ApplicationLoadBalancedFargateServiceProps } from 'aws-cdk-lib/aws-ecs-patterns'
-import * as elb from 'aws-cdk-lib/aws-elasticloadbalancingv2'
+import { HealthCheck as ElbHealthCheck } from 'aws-cdk-lib/aws-elasticloadbalancingv2'
+import { TagProps } from '../../../types'
 
 /**
  */
@@ -28,7 +28,7 @@ export interface EcsScalingProps {
 
 /**
  */
-export interface HealthCheck extends elb.HealthCheck {
+export interface HealthCheck extends ElbHealthCheck {
   intervalInSecs: number
   timeoutInSecs: number
 }

package/src/lib/services/aws/elastic-file-system/main.ts

@@ -1,8 +1,8 @@
-import * as ec2 from 'aws-cdk-lib/aws-ec2'
-import * as efs from 'aws-cdk-lib/aws-efs'
-import * as cdk from 'aws-cdk-lib'
-import * as utils from '../../../utils'
+import { RemovalPolicy } from 'aws-cdk-lib'
+import { ISecurityGroup, IVpc, SubnetSelection } from 'aws-cdk-lib/aws-ec2'
+import { FileSystem, LifecyclePolicy, OutOfInfrequentAccessPolicy, PerformanceMode } from 'aws-cdk-lib/aws-efs'
 import { CommonConstruct } from '../../../common'
+import { createCfnOutput } from '../../../utils'
 import { EfsAccessPointOptions, EfsFileSystemProps } from './types'
 
 export const DEFAULT_CREATE_ACL = {
@@ -47,28 +47,28 @@ export class EfsManager {
     id: string,
     scope: CommonConstruct,
     props: EfsFileSystemProps,
-    vpc: ec2.IVpc,
+    vpc: IVpc,
     accessPointOptions?: EfsAccessPointOptions[],
-    securityGroup?: ec2.ISecurityGroup,
-    vpcSubnets?: ec2.SubnetSelection
+    securityGroup?: ISecurityGroup,
+    vpcSubnets?: SubnetSelection
   ) {
     if (!props) throw `EFS props undefined for ${id}`
 
     const fileSystemId = props.provisionNewOnDeployment ? `${id}-${new Date().getMilliseconds()}` : `${id}`
-    const fileSystem = new efs.FileSystem(scope, `${fileSystemId}`, {
+    const fileSystem = new FileSystem(scope, `${fileSystemId}`, {
       ...props,
       fileSystemName: props.fileSystemName ? `${props.fileSystemName}-${scope.props.stage}` : undefined,
-      lifecyclePolicy: props.lifecyclePolicy ?? efs.LifecyclePolicy.AFTER_7_DAYS,
-      outOfInfrequentAccessPolicy: props.outOfInfrequentAccessPolicy ?? efs.OutOfInfrequentAccessPolicy.AFTER_1_ACCESS,
-      performanceMode: props.performanceMode ?? efs.PerformanceMode.GENERAL_PURPOSE,
-      removalPolicy: props.removalPolicy ?? cdk.RemovalPolicy.DESTROY,
+      lifecyclePolicy: props.lifecyclePolicy ?? LifecyclePolicy.AFTER_7_DAYS,
+      outOfInfrequentAccessPolicy: props.outOfInfrequentAccessPolicy ?? OutOfInfrequentAccessPolicy.AFTER_1_ACCESS,
+      performanceMode: props.performanceMode ?? PerformanceMode.GENERAL_PURPOSE,
+      removalPolicy: props.removalPolicy ?? RemovalPolicy.DESTROY,
       securityGroup,
       vpc,
       vpcSubnets,
     })
 
-    utils.createCfnOutput(`${id}-fileSystemArn`, scope, fileSystem.fileSystemArn)
-    utils.createCfnOutput(`${id}-fileSystemId`, scope, fileSystem.fileSystemId)
+    createCfnOutput(`${id}-fileSystemArn`, scope, fileSystem.fileSystemArn)
+    createCfnOutput(`${id}-fileSystemId`, scope, fileSystem.fileSystemId)
 
     /* provision access points if specified */
     if (accessPointOptions && accessPointOptions.length > 0) {
@@ -80,8 +80,8 @@ export class EfsManager {
           posixUser: accessPointOption.posixUser ?? DEFAULT_POSIX_USER,
         })
 
-        utils.createCfnOutput(`${id}-accessPointArn-${index}`, scope, accessPoint.accessPointArn)
-        utils.createCfnOutput(`${id}-accessPointId-${index}`, scope, accessPoint.accessPointId)
+        createCfnOutput(`${id}-accessPointArn-${index}`, scope, accessPoint.accessPointArn)
+        createCfnOutput(`${id}-accessPointId-${index}`, scope, accessPoint.accessPointId)
       }
     }
 

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

@@ -1,8 +1,8 @@
-import * as ec2 from 'aws-cdk-lib/aws-ec2'
-import * as ecr from 'aws-cdk-lib/aws-ecr-assets'
-import * as eks from 'aws-cdk-lib/aws-eks'
-import * as utils from '../../../utils'
+import { IVpc, InstanceClass, InstanceSize, InstanceType } from 'aws-cdk-lib/aws-ec2'
+import { DockerImageAsset } from 'aws-cdk-lib/aws-ecr-assets'
+import { Cluster, KubernetesVersion } from 'aws-cdk-lib/aws-eks'
 import { CommonConstruct } from '../../../common'
+import { createCfnOutput } from '../../../utils'
 import { EksClusterProps } from './types'
 
 /**
@@ -34,8 +34,8 @@ export class EksManager {
     id: string,
     scope: CommonConstruct,
     props: EksClusterProps,
-    image: ecr.DockerImageAsset,
-    vpc: ec2.IVpc
+    image: DockerImageAsset,
+    vpc: IVpc
   ) {
     if (!props) throw `EksCluster props undefined for ${id}`
 
@@ -80,18 +80,18 @@ export class EksManager {
       },
     }
 
-    const cluster = new eks.Cluster(scope, `${id}Cluster`, {
+    const cluster = new Cluster(scope, `${id}Cluster`, {
       clusterName: `${id.toLowerCase()}-${scope.props.stage}`,
       defaultCapacity: props.appCapacity,
-      defaultCapacityInstance: ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.LARGE),
-      version: eks.KubernetesVersion.V1_18,
+      defaultCapacityInstance: InstanceType.of(InstanceClass.T3, InstanceSize.LARGE),
+      version: KubernetesVersion.V1_27,
       vpc,
     })
 
     cluster.addManifest(`${id}Pod`, service, deployment)
 
-    utils.createCfnOutput(`${id}-clusterArn`, scope, cluster.clusterArn)
-    utils.createCfnOutput(`${id}-clusterEndpoint`, scope, cluster.clusterEndpoint)
+    createCfnOutput(`${id}-clusterArn`, scope, cluster.clusterArn)
+    createCfnOutput(`${id}-clusterEndpoint`, scope, cluster.clusterEndpoint)
 
     return cluster
   }

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

@@ -1,7 +1,7 @@
-import * as elasticache from 'aws-cdk-lib/aws-elasticache'
-import * as utils from '../../../utils'
-import * as cdk from 'aws-cdk-lib'
+import { Tags } from 'aws-cdk-lib'
+import { CfnCacheCluster, CfnReplicationGroup, CfnSubnetGroup } from 'aws-cdk-lib/aws-elasticache'
 import { CommonConstruct } from '../../../common'
+import { createCfnOutput } from '../../../utils'
 import { ElastiCacheProps, ReplicatedElastiCacheProps } from './types'
 
 /**
@@ -28,7 +28,7 @@ export class ElastiCacheManager {
    * @param subnetIds
    */
   public createElastiCacheSubnetGroup(id: string, scope: CommonConstruct, subnetIds: string[]) {
-    return new elasticache.CfnSubnetGroup(scope, `${id}`, {
+    return new CfnSubnetGroup(scope, `${id}`, {
       cacheSubnetGroupName: `${id}-subnet-group-${scope.props.stage}`,
       description: `${id}-subnet-group-${scope.props.stage}`,
       subnetIds: subnetIds,
@@ -56,7 +56,7 @@ export class ElastiCacheManager {
 
     const subnetGroup = this.createElastiCacheSubnetGroup(`${id}-subnetGroup`, scope, subnetIds)
 
-    const elasticacheCluster = new elasticache.CfnCacheCluster(scope, `${id}`, {
+    const elasticacheCluster = new CfnCacheCluster(scope, `${id}`, {
       autoMinorVersionUpgrade: props.autoMinorVersionUpgrade,
       azMode: props.azMode,
       cacheNodeType: props.cacheNodeType,
@@ -82,13 +82,13 @@ export class ElastiCacheManager {
 
     if (props.tags && props.tags.length > 0) {
       props.tags.forEach(tag => {
-        cdk.Tags.of(elasticacheCluster).add(tag.key, tag.value)
+        Tags.of(elasticacheCluster).add(tag.key, tag.value)
       })
     }
 
-    utils.createCfnOutput(`${id}-clusterName`, scope, elasticacheCluster.clusterName)
-    utils.createCfnOutput(`${id}-redisEndpointPort`, scope, elasticacheCluster.attrRedisEndpointPort)
-    utils.createCfnOutput(`${id}-redisEndpointAddress`, scope, elasticacheCluster.attrRedisEndpointAddress)
+    createCfnOutput(`${id}-clusterName`, scope, elasticacheCluster.clusterName)
+    createCfnOutput(`${id}-redisEndpointPort`, scope, elasticacheCluster.attrRedisEndpointPort)
+    createCfnOutput(`${id}-redisEndpointAddress`, scope, elasticacheCluster.attrRedisEndpointAddress)
 
     return elasticacheCluster
   }
@@ -112,7 +112,7 @@ export class ElastiCacheManager {
 
     const subnetGroup = this.createElastiCacheSubnetGroup(`${id}-subnetGroup`, scope, subnetIds)
 
-    const elasticacheCluster = new elasticache.CfnReplicationGroup(scope, `${id}`, {
+    const elasticacheCluster = new CfnReplicationGroup(scope, `${id}`, {
       autoMinorVersionUpgrade: props.autoMinorVersionUpgrade,
       automaticFailoverEnabled: props.automaticFailoverEnabled,
       cacheNodeType: props.cacheNodeType,

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

@@ -1,13 +1,13 @@
-import * as ecs from 'aws-cdk-lib/aws-ecs'
-import * as events from 'aws-cdk-lib/aws-events'
-import * as iam from 'aws-cdk-lib/aws-iam'
-import * as lambda from 'aws-cdk-lib/aws-lambda'
-import * as utils from '../../../utils'
-import * as cdk from 'aws-cdk-lib'
-import * as pipes from 'aws-cdk-lib/aws-pipes'
-import * as sqs from 'aws-cdk-lib/aws-sqs'
-import * as sfn from 'aws-cdk-lib/aws-stepfunctions'
+import { Tags } from 'aws-cdk-lib'
+import { ICluster, ITaskDefinition } from 'aws-cdk-lib/aws-ecs'
+import { CfnRule, EventBus, IEventBus, IRuleTarget, Rule } from 'aws-cdk-lib/aws-events'
+import { CfnRole, Role } from 'aws-cdk-lib/aws-iam'
+import { CfnPermission, IFunction } from 'aws-cdk-lib/aws-lambda'
+import { CfnPipe } from 'aws-cdk-lib/aws-pipes'
+import { IQueue } from 'aws-cdk-lib/aws-sqs'
+import { IStateMachine } from 'aws-cdk-lib/aws-stepfunctions'
 import { CommonConstruct } from '../../../common'
+import { createCfnOutput } from '../../../utils'
 import { EventBusProps, EventRuleProps, RuleProps, SqsToSfnPipeProps } from './types'
 
 /**
@@ -18,7 +18,7 @@ import { EventBusProps, EventRuleProps, RuleProps, SqsToSfnPipeProps } from './t
  * import { CommonConstruct } from '@gradientedge/cdk-utils'
  *
  * class CustomConstruct extends CommonConstruct {
- *   constructor(parent: cdk.Construct, id: string, props: common.CommonStackProps) {
+ *   constructor(parent: Construct, id: string, props: common.CommonStackProps) {
  *     super(parent, id, props)
  *     this.props = props
  *     this.eventManager.createLambdaRule('MyLambdaRule', this, lambdaFunction)
@@ -36,12 +36,12 @@ export class EventManager {
   public createEventBus(id: string, scope: CommonConstruct, props: EventBusProps) {
     if (!props) throw `EventBus props undefined for ${id}`
 
-    const eventBus = new events.EventBus(scope, `${id}`, {
+    const eventBus = new EventBus(scope, `${id}`, {
       eventBusName: `${props.eventBusName}-${scope.props.stage}`,
     })
 
-    utils.createCfnOutput(`${id}-eventBusName`, scope, `${props.eventBusName}-${scope.props.stage}`)
-    utils.createCfnOutput(`${id}-eventBusArn`, scope, eventBus.eventBusArn)
+    createCfnOutput(`${id}-eventBusName`, scope, `${props.eventBusName}-${scope.props.stage}`)
+    createCfnOutput(`${id}-eventBusArn`, scope, eventBus.eventBusArn)
 
     return eventBus
   }
@@ -58,12 +58,12 @@ export class EventManager {
     id: string,
     scope: CommonConstruct,
     props: EventRuleProps,
-    eventBus?: events.IEventBus,
-    targets?: events.IRuleTarget[]
+    eventBus?: IEventBus,
+    targets?: IRuleTarget[]
   ) {
     if (!props) throw `EventRule props undefined for ${id}`
 
-    const rule = new events.Rule(scope, `${id}`, {
+    const rule = new Rule(scope, `${id}`, {
       description: props.description,
       enabled: props.enabled,
       eventBus: eventBus,
@@ -80,12 +80,12 @@ export class EventManager {
 
     if (props.tags && props.tags.length > 0) {
       props.tags.forEach(tag => {
-        cdk.Tags.of(rule).add(tag.key, tag.value)
+        Tags.of(rule).add(tag.key, tag.value)
       })
     }
 
-    utils.createCfnOutput(`${id}-ruleArn`, scope, rule.ruleArn)
-    utils.createCfnOutput(`${id}-ruleName`, scope, rule.ruleName)
+    createCfnOutput(`${id}-ruleArn`, scope, rule.ruleArn)
+    createCfnOutput(`${id}-ruleName`, scope, rule.ruleName)
 
     return rule
   }
@@ -104,14 +104,14 @@ export class EventManager {
     id: string,
     scope: CommonConstruct,
     props: RuleProps,
-    lambdaFunction: lambda.Function,
+    lambdaFunction: IFunction,
     eventBusName?: string,
     eventPattern?: any,
     scheduleExpression?: string
   ) {
     if (!props) throw `EventRule props undefined for ${id}`
 
-    const eventRule = new events.CfnRule(scope, `${id}`, {
+    const eventRule = new CfnRule(scope, `${id}`, {
       description: 'Rule to send notification to lambda function target',
       eventBusName: eventBusName,
       eventPattern: eventPattern,
@@ -127,15 +127,15 @@ export class EventManager {
       ],
     })
 
-    new lambda.CfnPermission(scope, `${id}LambdaPermission`, {
+    new CfnPermission(scope, `${id}LambdaPermission`, {
       action: 'lambda:InvokeFunction',
       functionName: lambdaFunction.functionName,
-      principal: 'events.amazonaws.com',
+      principal: 'amazonaws.com',
       sourceArn: eventRule.attrArn,
     })
 
-    utils.createCfnOutput(`${id}-ruleArn`, scope, eventRule.attrArn)
-    utils.createCfnOutput(`${id}-ruleName`, scope, eventRule.name)
+    createCfnOutput(`${id}-ruleArn`, scope, eventRule.attrArn)
+    createCfnOutput(`${id}-ruleName`, scope, eventRule.name)
 
     return eventRule
   }
@@ -155,15 +155,15 @@ export class EventManager {
     id: string,
     scope: CommonConstruct,
     props: RuleProps,
-    cluster: ecs.ICluster,
-    task: ecs.ITaskDefinition,
+    cluster: ICluster,
+    task: ITaskDefinition,
     subnetIds: string[],
-    role: iam.Role | iam.CfnRole,
+    role: Role | CfnRole,
     eventPattern?: any
   ) {
     if (!props) throw `EventRule props undefined for ${id}`
 
-    const eventRule = new events.CfnRule(scope, `${id}`, {
+    const eventRule = new CfnRule(scope, `${id}`, {
       description: 'Rule to send notification on new objects in data bucket to ecs task target',
       eventPattern: eventPattern,
       name: `${props.name}-${scope.props.stage}`,
@@ -180,13 +180,13 @@ export class EventManager {
             taskDefinitionArn: task.taskDefinitionArn,
           },
           id: `${id}-${scope.props.stage}`,
-          roleArn: role instanceof iam.Role ? role.roleArn : role.attrArn,
+          roleArn: role instanceof Role ? role.roleArn : role.attrArn,
         },
       ],
     })
 
-    utils.createCfnOutput(`${id}-ruleArn`, scope, eventRule.attrArn)
-    utils.createCfnOutput(`${id}-ruleName`, scope, eventRule.name)
+    createCfnOutput(`${id}-ruleArn`, scope, eventRule.attrArn)
+    createCfnOutput(`${id}-ruleName`, scope, eventRule.name)
 
     return eventRule
   }
@@ -203,8 +203,8 @@ export class EventManager {
     id: string,
     scope: CommonConstruct,
     props: SqsToSfnPipeProps,
-    sourceQueue: sqs.IQueue,
-    targetStepFunction: sfn.IStateMachine
+    sourceQueue: IQueue,
+    targetStepFunction: IStateMachine
   ) {
     const pipeRole = scope.iamManager.createRoleForSqsToSfnPipe(
       `${id}-role`,
@@ -213,7 +213,7 @@ export class EventManager {
       targetStepFunction.stateMachineArn
     )
 
-    const pipe = new pipes.CfnPipe(scope, `${id}`, {
+    const pipe = new CfnPipe(scope, `${id}`, {
       ...props,
       description: props.description,
       enrichment: props.enrichment,
@@ -245,8 +245,8 @@ export class EventManager {
       },
     })
 
-    utils.createCfnOutput(`${id}-pipeArn`, scope, pipe.attrArn)
-    utils.createCfnOutput(`${id}-pipeName`, scope, pipe.name)
+    createCfnOutput(`${id}-pipeArn`, scope, pipe.attrArn)
+    createCfnOutput(`${id}-pipeName`, scope, pipe.name)
 
     return pipe
   }

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

@@ -1,11 +1,11 @@
-import * as cdk from 'aws-cdk-lib'
-import * as events from 'aws-cdk-lib/aws-events'
-import * as targets from 'aws-cdk-lib/aws-events-targets'
-import * as logs from 'aws-cdk-lib/aws-logs'
+import { ArnFormat, Stack } from 'aws-cdk-lib'
+import { IRule, IRuleTarget, RuleTargetConfig, RuleTargetInput } from 'aws-cdk-lib/aws-events'
+import { TargetBaseProps, bindBaseTargetConfig } from 'aws-cdk-lib/aws-events-targets'
+import { ILogGroup } from 'aws-cdk-lib/aws-logs'
 import { CommonConstruct } from '../../../common'
 
 /**
- * @classdesc Provides operations on AWS EventBridge Targets.
+ * @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.
  * @example
@@ -32,7 +32,7 @@ export class EventTargetManager {
   public createCloudWatchLogGroupNoPolicy(
     id: string,
     scope: CommonConstruct,
-    logGroup: logs.ILogGroup,
+    logGroup: ILogGroup,
     props?: LogGroupNoPolicyProps
   ) {
     return new CloudWatchLogGroupNoPolicy(logGroup, props)
@@ -42,22 +42,22 @@ export class EventTargetManager {
 /**
  * Customize the CloudWatch LogGroup Event Target
  */
-export interface LogGroupNoPolicyProps extends targets.TargetBaseProps {
+export interface LogGroupNoPolicyProps extends 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
+  readonly event?: RuleTargetInput
 }
 
 /**
  * Use an AWS CloudWatch LogGroup as an event rule target, but don't apply a policy.
  */
-export class CloudWatchLogGroupNoPolicy implements events.IRuleTarget {
+export class CloudWatchLogGroupNoPolicy implements IRuleTarget {
   constructor(
-    private readonly logGroup: logs.ILogGroup,
+    private readonly logGroup: ILogGroup,
     private readonly props: LogGroupNoPolicyProps = {}
   ) {}
 
@@ -66,13 +66,13 @@ export class CloudWatchLogGroupNoPolicy implements events.IRuleTarget {
    * @param _rule
    * @param _id
    */
-  public bind(_rule: events.IRule, _id?: string): events.RuleTargetConfig {
-    const logGroupStack = cdk.Stack.of(this.logGroup)
+  public bind(_rule: IRule, _id?: string): RuleTargetConfig {
+    const logGroupStack = Stack.of(this.logGroup)
 
     return {
-      ...targets.bindBaseTargetConfig(this.props),
+      ...bindBaseTargetConfig(this.props),
       arn: logGroupStack.formatArn({
-        arnFormat: cdk.ArnFormat.COLON_RESOURCE_NAME,
+        arnFormat: ArnFormat.COLON_RESOURCE_NAME,
         resource: 'log-group',
         resourceName: this.logGroup.logGroupName,
         service: 'logs',