@gradientedge/cdk-utils 8.118.0 → 8.120.0

package/src/lib/construct/api-to-lambda-target/api.ts

@@ -1,32 +1,42 @@
-import * as apig from 'aws-cdk-lib/aws-apigateway'
-import * as acm from 'aws-cdk-lib/aws-certificatemanager'
-import * as iam from 'aws-cdk-lib/aws-iam'
-import * as lambda from 'aws-cdk-lib/aws-lambda'
-import * as route53 from 'aws-cdk-lib/aws-route53'
-import * as sns from 'aws-cdk-lib/aws-sns'
+import {
+  BasePathMapping,
+  DomainName,
+  Integration,
+  IntegrationResponse,
+  Method,
+  MethodResponse,
+  Model,
+  Resource,
+  RestApi,
+} from 'aws-cdk-lib/aws-apigateway'
+import { ICertificate } from 'aws-cdk-lib/aws-certificatemanager'
+import { Role } from 'aws-cdk-lib/aws-iam'
+import { IFunction } from 'aws-cdk-lib/aws-lambda'
+import { IHostedZone } from 'aws-cdk-lib/aws-route53'
+import { Topic } from 'aws-cdk-lib/aws-sns'
 import { ApiToLambdaTargetRestApiType } from './types'
 
 /**
  * @classdesc Provides a construct to contain api resources for ApiToLambdaTarget
  */
 export class ApiToLambdaTargetRestApi implements ApiToLambdaTargetRestApiType {
-  api: apig.RestApi
-  basePathMappings: apig.BasePathMapping[] = []
-  certificate: acm.ICertificate
-  domain: apig.DomainName
-  errorResponseModel: apig.Model
-  hostedZone: route53.IHostedZone
-  integration: apig.Integration
-  integrationErrorResponse: apig.IntegrationResponse
+  api: RestApi
+  basePathMappings: BasePathMapping[] = []
+  certificate: ICertificate
+  domain: DomainName
+  errorResponseModel: Model
+  hostedZone: IHostedZone
+  integration: Integration
+  integrationErrorResponse: IntegrationResponse
   integrationRequestParameters: { [p: string]: string }
   integrationRequestTemplates: { [p: string]: string }
-  integrationResponse: apig.IntegrationResponse
-  lambda: lambda.IFunction
-  method: apig.Method
-  methodErrorResponse: apig.MethodResponse
-  methodResponse: apig.MethodResponse
-  resource: apig.Resource
-  responseModel: apig.Model
-  topic: sns.Topic
-  role: iam.Role
+  integrationResponse: IntegrationResponse
+  lambda: IFunction
+  method: Method
+  methodErrorResponse: MethodResponse
+  methodResponse: MethodResponse
+  resource: Resource
+  responseModel: Model
+  topic: Topic
+  role: Role
 }

package/src/lib/construct/api-to-lambda-target/main.ts

@@ -1,8 +1,14 @@
-import * as cdk from 'aws-cdk-lib'
-import * as apig from 'aws-cdk-lib/aws-apigateway'
-import * as iam from 'aws-cdk-lib/aws-iam'
-import * as lambda from 'aws-cdk-lib/aws-lambda'
-import * as secretsmanager from 'aws-cdk-lib/aws-secretsmanager'
+import { Fn, RemovalPolicy } from 'aws-cdk-lib'
+import {
+  BasePathMapping,
+  LambdaIntegration,
+  LogGroupLogDestination,
+  Resource,
+  RestApi,
+} from 'aws-cdk-lib/aws-apigateway'
+import { PolicyDocument, Role, ServicePrincipal } from 'aws-cdk-lib/aws-iam'
+import { Function } from 'aws-cdk-lib/aws-lambda'
+import { ISecret } from 'aws-cdk-lib/aws-secretsmanager'
 import { Construct } from 'constructs'
 import { CommonConstruct } from '../../common'
 import { ApiToLambdaTargetRestApi } from './api'
@@ -15,7 +21,7 @@ export class ApiToLambdaTarget extends CommonConstruct {
   id: string
 
   /* application related resources */
-  applicationSecrets: secretsmanager.ISecret[]
+  applicationSecrets: ISecret[]
 
   /* rest restApi related resources */
   apiToLambdaTargetRestApi: ApiToLambdaTargetRestApiType
@@ -129,7 +135,7 @@ export class ApiToLambdaTarget extends CommonConstruct {
   }
 
   protected resolveApiToLambdaTargetFunction() {
-    this.apiToLambdaTargetRestApi.lambda = lambda.Function.fromFunctionName(
+    this.apiToLambdaTargetRestApi.lambda = Function.fromFunctionName(
       this,
       `${this.id}-lambda`,
       this.props.lambdaFunctionName
@@ -141,17 +147,17 @@ export class ApiToLambdaTarget extends CommonConstruct {
    */
   protected createApiToLambdaTargetRestApi() {
     if (this.props.api.useExisting && this.props.api.importedRestApiRef) {
-      this.apiToLambdaTargetRestApi.api = apig.RestApi.fromRestApiId(
+      this.apiToLambdaTargetRestApi.api = RestApi.fromRestApiId(
         this,
         `${this.id}-rest-api`,
-        cdk.Fn.importValue(this.props.api.importedRestApiRef)
+        Fn.importValue(this.props.api.importedRestApiRef)
       )
       return
     }
 
     const accessLogGroup = this.logManager.createLogGroup(`${this.id}-rest-api-access-log`, this, {
       logGroupName: `/custom/api/${this.id}-rest-api-access`,
-      removalPolicy: cdk.RemovalPolicy.DESTROY,
+      removalPolicy: RemovalPolicy.DESTROY,
     })
 
     this.props.api.restApi = {
@@ -164,7 +170,7 @@ export class ApiToLambdaTarget extends CommonConstruct {
           ],
         },
         deployOptions: {
-          accessLogDestination: new apig.LogGroupLogDestination(accessLogGroup),
+          accessLogDestination: new LogGroupLogDestination(accessLogGroup),
         },
       },
     }
@@ -188,9 +194,9 @@ export class ApiToLambdaTarget extends CommonConstruct {
 
     let rootResource
     if (this.props.api.withResource && this.props.api.importedRestApiRootResourceRef) {
-      rootResource = apig.Resource.fromResourceAttributes(this, `${this.id}-root-resource`, {
+      rootResource = Resource.fromResourceAttributes(this, `${this.id}-root-resource`, {
         path: '/',
-        resourceId: cdk.Fn.importValue(this.props.api.importedRestApiRootResourceRef),
+        resourceId: Fn.importValue(this.props.api.importedRestApiRootResourceRef),
         restApi: this.apiToLambdaTargetRestApi.api,
       })
     } else {
@@ -201,7 +207,7 @@ export class ApiToLambdaTarget extends CommonConstruct {
   }
 
   protected createApiToLambdaTargetPolicy() {
-    this.apiToLambdaTargetRestApi.policy = new iam.PolicyDocument({
+    this.apiToLambdaTargetRestApi.policy = new PolicyDocument({
       statements: [
         this.iamManager.statementForPutEvents(),
         this.iamManager.statementForInvokeLambda([this.apiToLambdaTargetRestApi.lambda.functionArn]),
@@ -215,8 +221,8 @@ export class ApiToLambdaTarget extends CommonConstruct {
   protected createApiToLambdaTargetRole() {
     if (!this.apiToLambdaTargetRestApi.policy) throw 'Policy undefined'
 
-    this.apiToLambdaTargetRestApi.role = new iam.Role(this, `${this.id}-rest-api-role`, {
-      assumedBy: new iam.ServicePrincipal('apigateway.amazonaws.com'),
+    this.apiToLambdaTargetRestApi.role = new Role(this, `${this.id}-rest-api-role`, {
+      assumedBy: new ServicePrincipal('apigateway.amazonaws.com'),
       inlinePolicies: { policy: this.apiToLambdaTargetRestApi.policy },
     })
   }
@@ -225,7 +231,7 @@ export class ApiToLambdaTarget extends CommonConstruct {
    * @summary Method to create api integration resource method
    */
   protected createApiToLambdaTargetIntegration() {
-    this.apiToLambdaTargetRestApi.integration = new apig.LambdaIntegration(this.apiToLambdaTargetRestApi.lambda, {
+    this.apiToLambdaTargetRestApi.integration = new LambdaIntegration(this.apiToLambdaTargetRestApi.lambda, {
       allowTestInvoke: true,
       credentialsRole: this.apiToLambdaTargetRestApi.role,
     })
@@ -269,7 +275,7 @@ export class ApiToLambdaTarget extends CommonConstruct {
    */
   protected createApiBasePathMapping() {
     if (this.props.api.useExisting) return
-    new apig.BasePathMapping(this, `${this.id}-base-bath-mapping`, {
+    new BasePathMapping(this, `${this.id}-base-bath-mapping`, {
       basePath: '',
       domainName: this.apiToLambdaTargetRestApi.domain,
       restApi: this.apiToLambdaTargetRestApi.api,

package/src/lib/construct/application-configuration/main.ts

@@ -1,17 +1,24 @@
+import { Fn } from 'aws-cdk-lib'
+import {
+  CfnApplication,
+  CfnConfigurationProfile,
+  CfnDeployment,
+  CfnDeploymentStrategy,
+  CfnEnvironment,
+  CfnHostedConfigurationVersion,
+} from 'aws-cdk-lib/aws-appconfig'
 import { Construct } from 'constructs'
-import * as cdk from 'aws-cdk-lib'
-import * as appconfig from 'aws-cdk-lib/aws-appconfig'
-import { ApplicationConfigurationProps } from './types'
 import { CommonConstruct } from '../../common'
+import { ApplicationConfigurationProps } from './types'
 
 export class ApplicationConfiguration extends CommonConstruct {
-  props: ApplicationConfigurationProps
+  declare props: ApplicationConfigurationProps
   id: string
-  appConfigApplication: appconfig.CfnApplication
-  appConfigEnvironment: appconfig.CfnEnvironment
-  appConfigProfile: appconfig.CfnConfigurationProfile
-  appConfigVersion: appconfig.CfnHostedConfigurationVersion
-  appConfigDeploymentStrategy: appconfig.CfnDeploymentStrategy
+  appConfigApplication: CfnApplication
+  appConfigEnvironment: CfnEnvironment
+  appConfigProfile: CfnConfigurationProfile
+  appConfigVersion: CfnHostedConfigurationVersion
+  appConfigDeploymentStrategy: CfnDeploymentStrategy
 
   constructor(parent: Construct, id: string, props: ApplicationConfigurationProps) {
     super(parent, id, props)
@@ -45,7 +52,7 @@ export class ApplicationConfiguration extends CommonConstruct {
     this.appConfigEnvironment = this.appConfigManager.createEnvironment(
       `${this.id}-ac-environment`,
       this,
-      cdk.Fn.ref(this.appConfigApplication.logicalId),
+      Fn.ref(this.appConfigApplication.logicalId),
       this.props.appConfig
     )
   }
@@ -54,22 +61,22 @@ export class ApplicationConfiguration extends CommonConstruct {
     this.appConfigProfile = this.appConfigManager.createConfigurationProfile(
       `${this.id}-ac-profile`,
       this,
-      cdk.Fn.ref(this.appConfigApplication.logicalId),
+      Fn.ref(this.appConfigApplication.logicalId),
       this.props.appConfig
     )
   }
 
   protected createAppConfigVersion() {
-    this.appConfigVersion = new appconfig.CfnHostedConfigurationVersion(this, `${this.id}-ac-configuration`, {
-      applicationId: cdk.Fn.ref(this.appConfigApplication.logicalId),
-      configurationProfileId: cdk.Fn.ref(this.appConfigProfile.logicalId),
+    this.appConfigVersion = new CfnHostedConfigurationVersion(this, `${this.id}-ac-configuration`, {
+      applicationId: Fn.ref(this.appConfigApplication.logicalId),
+      configurationProfileId: Fn.ref(this.appConfigProfile.logicalId),
       content: JSON.stringify(this.props.appConfigContent),
       contentType: 'application/json',
     })
   }
 
   protected createAppConfigDeploymentStrategy() {
-    this.appConfigDeploymentStrategy = new appconfig.CfnDeploymentStrategy(this, `${this.id}-ac-deployment-strategy`, {
+    this.appConfigDeploymentStrategy = new CfnDeploymentStrategy(this, `${this.id}-ac-deployment-strategy`, {
       deploymentDurationInMinutes: this.props.appConfig.deploymentStrategy.deploymentDurationInMinutes,
       growthFactor: this.props.appConfig.deploymentStrategy.growthFactor,
       name: this.props.appConfig.deploymentStrategy.name,
@@ -78,20 +85,20 @@ export class ApplicationConfiguration extends CommonConstruct {
   }
 
   protected createAppConfigDeployment() {
-    new appconfig.CfnDeployment(this, `${this.id}-app-config-deployment`, {
-      applicationId: cdk.Fn.ref(this.appConfigApplication.logicalId),
-      configurationProfileId: cdk.Fn.ref(this.appConfigProfile.logicalId),
-      configurationVersion: cdk.Fn.ref(this.appConfigVersion.logicalId),
-      deploymentStrategyId: cdk.Fn.ref(this.appConfigDeploymentStrategy.logicalId),
-      environmentId: cdk.Fn.ref(this.appConfigEnvironment.logicalId),
+    new CfnDeployment(this, `${this.id}-app-config-deployment`, {
+      applicationId: Fn.ref(this.appConfigApplication.logicalId),
+      configurationProfileId: Fn.ref(this.appConfigProfile.logicalId),
+      configurationVersion: Fn.ref(this.appConfigVersion.logicalId),
+      deploymentStrategyId: Fn.ref(this.appConfigDeploymentStrategy.logicalId),
+      environmentId: Fn.ref(this.appConfigEnvironment.logicalId),
     })
   }
 
   public resolveEnvironmentVariables(): any {
     return {
-      APP_CONFIG_APPLICATION_ID: cdk.Fn.ref(this.appConfigApplication.logicalId),
-      APP_CONFIG_CONFIGURATION_PROFILE_ID: cdk.Fn.ref(this.appConfigProfile.logicalId),
-      APP_CONFIG_ENVIRONMENT_ID: cdk.Fn.ref(this.appConfigEnvironment.logicalId),
+      APP_CONFIG_APPLICATION_ID: Fn.ref(this.appConfigApplication.logicalId),
+      APP_CONFIG_CONFIGURATION_PROFILE_ID: Fn.ref(this.appConfigProfile.logicalId),
+      APP_CONFIG_ENVIRONMENT_ID: Fn.ref(this.appConfigEnvironment.logicalId),
     }
   }
 }

package/src/lib/construct/graphql-api-lambda/main.ts

@@ -1,9 +1,9 @@
-import * as apig from 'aws-cdk-lib/aws-apigateway'
-import * as acm from 'aws-cdk-lib/aws-certificatemanager'
-import * as iam from 'aws-cdk-lib/aws-iam'
-import * as lambda from 'aws-cdk-lib/aws-lambda'
-import * as route53 from 'aws-cdk-lib/aws-route53'
-import * as secretsmanager from 'aws-cdk-lib/aws-secretsmanager'
+import { BasePathMapping, DomainName, RestApi } from 'aws-cdk-lib/aws-apigateway'
+import { ICertificate } from 'aws-cdk-lib/aws-certificatemanager'
+import { PolicyDocument, Role } from 'aws-cdk-lib/aws-iam'
+import { AssetCode, IFunction, ILayerVersion, LayerVersion } from 'aws-cdk-lib/aws-lambda'
+import { IHostedZone } from 'aws-cdk-lib/aws-route53'
+import { ISecret } from 'aws-cdk-lib/aws-secretsmanager'
 import { Construct } from 'constructs'
 import { CommonConstruct } from '../../common'
 import { GraphQlApiLambdaEnvironment, GraphQlApiLambdaProps } from './types'
@@ -12,7 +12,7 @@ import { GraphQlApiLambdaEnvironment, GraphQlApiLambdaProps } from './types'
  * @deprecated Use RestApiLambda instead. This will be removed in a future release.
  * @classdesc Provides a construct to create and deploy a Graphql API as Lambda
  *
- * <b>Architecture</b><br/> ![Architecture](./GraphQLApiLambda.jpg)
+ * <b>Architecture</b><br/> ![Architecture](./GraphQLApi.jpg)
  * @example
  * import { GraphQLApiLambda, GraphQlApiLambdaProps } '@gradientedge/cdk-utils'
  * import { Construct } from 'constructs'
@@ -32,17 +32,17 @@ export class GraphQLApiLambda extends CommonConstruct {
   id: string
 
   /* graphql restApi resources */
-  applicationSecrets: secretsmanager.ISecret[]
-  graphQLApiLambdaPolicy: iam.PolicyDocument
-  graphQLApiLambdaRole: iam.Role
+  applicationSecrets: ISecret[]
+  graphQLApiLambdaPolicy: PolicyDocument
+  graphQLApiLambdaRole: Role
   graphQLApiLambdaEnvironment: GraphQlApiLambdaEnvironment
-  graphQLApiLambdaLayers: lambda.ILayerVersion[] = []
-  graphQLApiLambdaFunction: lambda.Function
-  graphQLApi: apig.RestApi
-  graphQLApiHostedZone: route53.IHostedZone
-  graphQLApiCertificate: acm.ICertificate
-  graphQLApiDomain: apig.DomainName
-  graphQLApiBasePathMappings: apig.BasePathMapping[] = []
+  graphQLApiLambdaLayers: ILayerVersion[] = []
+  graphQLApiLambdaFunction: IFunction
+  graphQLApi: RestApi
+  graphQLApiHostedZone: IHostedZone
+  graphQLApiCertificate: ICertificate
+  graphQLApiDomain: DomainName
+  graphQLApiBasePathMappings: BasePathMapping[] = []
 
   constructor(parent: Construct, id: string, props: GraphQlApiLambdaProps) {
     super(parent, id, props)
@@ -116,7 +116,7 @@ export class GraphQLApiLambda extends CommonConstruct {
    * @summary Method to create iam policy for GraphQL Lambda function
    */
   protected createLambdaPolicy() {
-    this.graphQLApiLambdaPolicy = new iam.PolicyDocument({
+    this.graphQLApiLambdaPolicy = new PolicyDocument({
       statements: [this.iamManager.statementForCreateAnyLogStream()],
     })
   }
@@ -147,11 +147,11 @@ export class GraphQLApiLambda extends CommonConstruct {
    * @summary Method to create layers for GraphQL Lambda function
    */
   protected createLambdaLayers() {
-    const layers: lambda.LayerVersion[] = []
+    const layers: LayerVersion[] = []
 
     if (!this.props.graphqlApiLambdaLayerSources) return
 
-    this.props.graphqlApiLambdaLayerSources.forEach((source: lambda.AssetCode, index: number) => {
+    this.props.graphqlApiLambdaLayerSources.forEach((source: AssetCode, index: number) => {
       layers.push(this.lambdaManager.createLambdaLayer(`${this.id}-layer-${index}`, this, source))
     })
 
@@ -208,7 +208,7 @@ export class GraphQLApiLambda extends CommonConstruct {
     if (apiRootPaths && apiRootPaths.length > 0) {
       apiRootPaths.forEach((apiRootPath: string) => {
         this.graphQLApiBasePathMappings.push(
-          new apig.BasePathMapping(this, `${this.id}-base-bath-mapping-${apiRootPath}`, {
+          new BasePathMapping(this, `${this.id}-base-bath-mapping-${apiRootPath}`, {
             basePath: apiRootPath,
             domainName: this.graphQLApiDomain,
             restApi: this.graphQLApi,
@@ -220,7 +220,7 @@ export class GraphQLApiLambda extends CommonConstruct {
     }
 
     // add default mapping if apiRootPaths not set
-    new apig.BasePathMapping(this, `${this.id}-base-bath-mapping`, {
+    new BasePathMapping(this, `${this.id}-base-bath-mapping`, {
       domainName: this.graphQLApiDomain,
       restApi: this.graphQLApi,
       stage: this.graphQLApi.deploymentStage,

package/src/lib/construct/graphql-api-lambda-with-cache/main.ts

@@ -1,11 +1,11 @@
-import * as cdk from 'aws-cdk-lib'
-import * as ec2 from 'aws-cdk-lib/aws-ec2'
-import * as elasticache from 'aws-cdk-lib/aws-elasticache'
-import * as iam from 'aws-cdk-lib/aws-iam'
+import { Fn } from 'aws-cdk-lib'
+import { ISecurityGroup, IVpc, Peer, Port, SecurityGroup } from 'aws-cdk-lib/aws-ec2'
+import { CfnReplicationGroup } from 'aws-cdk-lib/aws-elasticache'
+import { ManagedPolicy } from 'aws-cdk-lib/aws-iam'
 import { Construct } from 'constructs'
 import { GraphQLApiLambda } from '..'
-import { GraphQlApiLambdaWithCacheProps } from './types'
 import * as utils from '../../utils'
+import { GraphQlApiLambdaWithCacheProps } from './types'
 
 /**
  * @deprecated Use RestApiLambdaWithCache instead. This will be removed in a future release.
@@ -31,9 +31,9 @@ export class GraphQLApiLambdaWithCache extends GraphQLApiLambda {
   id: string
 
   /* graphql restApi resources */
-  graphQLVpc: ec2.IVpc
-  graphQLElastiCache: elasticache.CfnReplicationGroup
-  graphQLSecurityGroup: ec2.ISecurityGroup
+  graphQLVpc: IVpc
+  graphQLElastiCache: CfnReplicationGroup
+  graphQLSecurityGroup: ISecurityGroup
   securityGroupExportName: string
 
   constructor(parent: Construct, id: string, props: GraphQlApiLambdaWithCacheProps) {
@@ -66,18 +66,18 @@ export class GraphQLApiLambdaWithCache extends GraphQLApiLambda {
    */
   protected setSecurityGroup() {
     if (this.props.securityGroupExportName) {
-      this.graphQLSecurityGroup = ec2.SecurityGroup.fromSecurityGroupId(
+      this.graphQLSecurityGroup = SecurityGroup.fromSecurityGroupId(
         this,
         `${this.id}`,
-        cdk.Fn.importValue(this.props.securityGroupExportName)
+        Fn.importValue(this.props.securityGroupExportName)
       )
     } else {
-      this.graphQLSecurityGroup = new ec2.SecurityGroup(this, `${this.id}-security-group-${this.props.stage}`, {
+      this.graphQLSecurityGroup = new SecurityGroup(this, `${this.id}-security-group-${this.props.stage}`, {
         securityGroupName: `${this.id}-security-group-${this.props.stage}`,
         vpc: this.graphQLVpc,
       })
 
-      this.graphQLSecurityGroup.addIngressRule(ec2.Peer.anyIpv4(), ec2.Port.allTraffic(), 'All Traffic')
+      this.graphQLSecurityGroup.addIngressRule(Peer.anyIpv4(), Port.allTraffic(), 'All Traffic')
 
       utils.createCfnOutput(`${this.id}-security-group-id`, this, this.graphQLSecurityGroup.securityGroupId)
     }
@@ -103,7 +103,7 @@ export class GraphQLApiLambdaWithCache extends GraphQLApiLambda {
     super.createLambdaRole()
 
     this.graphQLApiLambdaRole.addManagedPolicy(
-      iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaVPCAccessExecutionRole')
+      ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaVPCAccessExecutionRole')
     )
   }
 

package/src/lib/construct/lambda-with-iam-access/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 iam from 'aws-cdk-lib/aws-iam'
-import * as lambda from 'aws-cdk-lib/aws-lambda'
-import * as secretsManager from 'aws-cdk-lib/aws-secretsmanager'
+import { ISecurityGroup, IVpc, SubnetSelection } from 'aws-cdk-lib/aws-ec2'
+import { IAccessPoint } from 'aws-cdk-lib/aws-efs'
+import { CfnAccessKey, Policy, PolicyDocument, PolicyStatement, Role, User } from 'aws-cdk-lib/aws-iam'
+import { AssetCode, IFunction, ILayerVersion, LayerVersion } from 'aws-cdk-lib/aws-lambda'
+import { CfnSecret, Secret } from 'aws-cdk-lib/aws-secretsmanager'
 import { Construct } from 'constructs'
 import { CommonConstruct } from '../../common'
 import { LambdaWithIamAccessEnvironment, LambdaWithIamAccessProps } from './types'
@@ -28,19 +28,19 @@ export class LambdaWithIamAccess extends CommonConstruct {
   id: string
 
   /* LambdaWithIamAccess resources */
-  lambdaPolicy: iam.PolicyDocument
-  lambdaRole: iam.Role
+  lambdaPolicy: PolicyDocument
+  lambdaRole: Role
   lambdaEnvironment: LambdaWithIamAccessEnvironment
-  lambdaLayers: lambda.ILayerVersion[]
-  lambdaFunction: lambda.Function
-  lambdaIamUser: iam.User
-  lambdaUserAccessKey: iam.CfnAccessKey
-  lambdaUserAccessSecret: secretsManager.Secret
-  lambdaVpc: ec2.IVpc
-  lambdaSecurityGroups: ec2.ISecurityGroup[]
-  lambdaAccessPoint: efs.IAccessPoint
+  lambdaLayers: ILayerVersion[]
+  lambdaFunction: IFunction
+  lambdaIamUser: User
+  lambdaUserAccessKey: CfnAccessKey
+  lambdaUserAccessSecret: Secret
+  lambdaVpc: IVpc
+  lambdaSecurityGroups: ISecurityGroup[]
+  lambdaAccessPoint: IAccessPoint
   lambdaMountPath: string
-  lambdaVpcSubnets: ec2.SubnetSelection
+  lambdaVpcSubnets: SubnetSelection
 
   constructor(parent: Construct, id: string, props: LambdaWithIamAccessProps) {
     super(parent, id, props)
@@ -81,7 +81,7 @@ export class LambdaWithIamAccess extends CommonConstruct {
    * @summary Method to create iam policy for Lambda function
    */
   protected createLambdaPolicy() {
-    this.lambdaPolicy = new iam.PolicyDocument({
+    this.lambdaPolicy = new PolicyDocument({
       statements: [this.iamManager.statementForCreateAnyLogStream()],
     })
   }
@@ -108,11 +108,11 @@ export class LambdaWithIamAccess extends CommonConstruct {
    * @summary Method to create layers for Lambda function
    */
   protected createLambdaLayers() {
-    const layers: lambda.LayerVersion[] = []
+    const layers: LayerVersion[] = []
 
     if (!this.props.lambdaLayerSources) return
 
-    this.props.lambdaLayerSources.forEach((source: lambda.AssetCode, index: number) => {
+    this.props.lambdaLayerSources.forEach((source: AssetCode, index: number) => {
       layers.push(this.lambdaManager.createLambdaLayer(`${this.id}-layer-${index}`, this, source))
     })
 
@@ -144,14 +144,14 @@ export class LambdaWithIamAccess extends CommonConstruct {
    * @summary Method to create iam user for the lambda function
    */
   protected createIamUserForLambdaFunction() {
-    this.lambdaIamUser = new iam.User(this, `${this.id}-lambda-user`, {
+    this.lambdaIamUser = new User(this, `${this.id}-lambda-user`, {
       userName: `${this.id}-user-${this.props.stage}`,
     })
 
-    new iam.Policy(this, `${this.id}-lambda-user-policy`, {
+    new Policy(this, `${this.id}-lambda-user-policy`, {
       policyName: `${this.id}-policy-${this.props.stage}`,
       statements: [
-        new iam.PolicyStatement({
+        new PolicyStatement({
           actions: ['lambda:InvokeFunction'],
           resources: [this.lambdaFunction.functionArn],
         }),
@@ -159,7 +159,7 @@ export class LambdaWithIamAccess extends CommonConstruct {
       users: [this.lambdaIamUser],
     })
 
-    this.lambdaUserAccessKey = new iam.CfnAccessKey(this, `${this.id}-access-key-${this.props.stage}`, {
+    this.lambdaUserAccessKey = new CfnAccessKey(this, `${this.id}-access-key-${this.props.stage}`, {
       userName: this.lambdaIamUser.userName,
     })
   }
@@ -168,13 +168,13 @@ export class LambdaWithIamAccess extends CommonConstruct {
    * @summary Method to create iam secret for the lambda function
    */
   protected createIamSecretForLambdaFunction() {
-    this.lambdaUserAccessSecret = new secretsManager.Secret(
+    this.lambdaUserAccessSecret = new Secret(
       this,
       `${this.id}-lambda-user-secret-${this.props.stage}`,
       this.props.lambdaSecret
     )
 
-    const cfnSecret = this.lambdaUserAccessSecret.node.defaultChild as secretsManager.CfnSecret
+    const cfnSecret = this.lambdaUserAccessSecret.node.defaultChild as CfnSecret
     cfnSecret.generateSecretString = undefined
     cfnSecret.secretString = `{ "ACCESS_KEY_ID": "${this.lambdaUserAccessKey.ref}", "ACCESS_KEY_SECRET": "${this.lambdaUserAccessKey.attrSecretAccessKey}" }`
   }

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

@@ -1,14 +1,14 @@
-import * as lambda from 'aws-cdk-lib/aws-lambda'
+import { AssetCode } from 'aws-cdk-lib/aws-lambda'
 import { SecretProps } from 'aws-cdk-lib/aws-secretsmanager'
-import { LambdaEnvironment, LambdaProps } from '../../services'
 import { CommonStackProps } from '../../common'
+import { LambdaEnvironment, LambdaProps } from '../../services'
 
 export interface LambdaWithIamAccessProps extends CommonStackProps {
   lambda: LambdaProps
   lambdaHandler?: string
-  lambdaLayerSources: lambda.AssetCode[]
+  lambdaLayerSources: AssetCode[]
   lambdaSecret: SecretProps
-  lambdaSource: lambda.AssetCode
+  lambdaSource: AssetCode
   logLevel: string
   nodeEnv: string
   timezone: string

package/src/lib/construct/rest-api-lambda/main.ts

@@ -1,9 +1,9 @@
-import * as apig from 'aws-cdk-lib/aws-apigateway'
-import * as acm from 'aws-cdk-lib/aws-certificatemanager'
-import * as iam from 'aws-cdk-lib/aws-iam'
-import * as lambda from 'aws-cdk-lib/aws-lambda'
-import * as route53 from 'aws-cdk-lib/aws-route53'
-import * as secretsmanager from 'aws-cdk-lib/aws-secretsmanager'
+import { BasePathMapping, DomainName, RestApi } from 'aws-cdk-lib/aws-apigateway'
+import { ICertificate } from 'aws-cdk-lib/aws-certificatemanager'
+import { PolicyDocument, Role } from 'aws-cdk-lib/aws-iam'
+import { AssetCode, IFunction, ILayerVersion, LayerVersion } from 'aws-cdk-lib/aws-lambda'
+import { IHostedZone } from 'aws-cdk-lib/aws-route53'
+import { ISecret } from 'aws-cdk-lib/aws-secretsmanager'
 import { Construct } from 'constructs'
 import { CommonConstruct } from '../../common'
 import { RestApiLambdaEnvironment, RestApiLambdaProps } from './types'
@@ -31,17 +31,17 @@ export abstract class RestApiLambda extends CommonConstruct {
   id: string
 
   /* restApiLambda resources */
-  applicationSecrets: secretsmanager.ISecret[]
-  restApiLambdaPolicy: iam.PolicyDocument
-  restApiLambdaRole: iam.Role
+  applicationSecrets: ISecret[]
+  restApiLambdaPolicy: PolicyDocument
+  restApiLambdaRole: Role
   restApiLambdaEnvironment: RestApiLambdaEnvironment
-  restApiLambdaLayers: lambda.ILayerVersion[] = []
-  restApiLambdaFunction: lambda.Function
-  restApi: apig.RestApi
-  restApiHostedZone: route53.IHostedZone
-  restApiCertificate: acm.ICertificate
-  restApiDomain: apig.DomainName
-  restApiBasePathMappings: apig.BasePathMapping[] = []
+  restApiLambdaLayers: ILayerVersion[] = []
+  restApiLambdaFunction: IFunction
+  restApi: RestApi
+  restApiHostedZone: IHostedZone
+  restApiCertificate: ICertificate
+  restApiDomain: DomainName
+  restApiBasePathMappings: BasePathMapping[] = []
 
   protected constructor(parent: Construct, id: string, props: RestApiLambdaProps) {
     super(parent, id, props)
@@ -117,7 +117,7 @@ export abstract class RestApiLambda extends CommonConstruct {
    * @summary Method to create iam policy for RestApi Lambda function
    */
   protected createLambdaPolicy() {
-    this.restApiLambdaPolicy = new iam.PolicyDocument({
+    this.restApiLambdaPolicy = new PolicyDocument({
       statements: [this.iamManager.statementForCreateAnyLogStream()],
     })
   }
@@ -148,11 +148,11 @@ export abstract class RestApiLambda extends CommonConstruct {
    * @summary Method to create layers for RestApi Lambda function
    */
   protected createLambdaLayers() {
-    const layers: lambda.LayerVersion[] = []
+    const layers: LayerVersion[] = []
 
     if (!this.props.restApiLambdaLayerSources) return
 
-    this.props.restApiLambdaLayerSources.forEach((source: lambda.AssetCode, index: number) => {
+    this.props.restApiLambdaLayerSources.forEach((source: AssetCode, index: number) => {
       layers.push(this.lambdaManager.createLambdaLayer(`${this.id}-layer-${index}`, this, source))
     })
 
@@ -211,7 +211,7 @@ export abstract class RestApiLambda extends CommonConstruct {
     if (apiRootPaths && apiRootPaths.length > 0) {
       apiRootPaths.forEach((apiRootPath: string) => {
         this.restApiBasePathMappings.push(
-          new apig.BasePathMapping(this, `${this.id}-base-bath-mapping-${apiRootPath}`, {
+          new BasePathMapping(this, `${this.id}-base-bath-mapping-${apiRootPath}`, {
             basePath: apiRootPath,
             domainName: this.restApiDomain,
             restApi: this.restApi,
@@ -223,7 +223,7 @@ export abstract class RestApiLambda extends CommonConstruct {
     }
 
     // add default mapping if apiRootPaths not set
-    new apig.BasePathMapping(this, `${this.id}-base-bath-mapping`, {
+    new BasePathMapping(this, `${this.id}-base-bath-mapping`, {
       domainName: this.restApiDomain,
       restApi: this.restApi,
       stage: this.restApi.deploymentStage,