@gradientedge/cdk-utils 8.91.0 → 8.92.0

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

@@ -3,9 +3,6 @@ import * as codebuild from 'aws-cdk-lib/aws-codebuild'
 import { CommonConstruct } from '../../../common'
 
 /**
- * @stability stable
- * @category cdk-utils.codebuild-manager
- * @subcategory Construct
  * @classdesc Provides operations on AWS Code Build.
  * - 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,7 +16,6 @@ import { CommonConstruct } from '../../../common'
  *     this.codeBuildManager.createImageForCloudfrontInvalidation('MyInvalidation', this, './docker ')
  *   }
  * }
- *
  * @see [CDK Codebuild Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_codebuild-readme.html}
  */
 export class CodeBuildManager {
@@ -50,9 +46,7 @@ export class CodeBuildManager {
   ) {
     const invalidationPaths = paths ?? '/*'
     return new codebuild.Project(scope, `${id}-install-deps-project`, {
-      role: scope.iamManager.roleForCloudfrontInvalidation(id, scope),
       buildSpec: codebuild.BuildSpec.fromObject({
-        version: '0.1',
         phases: {
           build: {
             commands: [
@@ -60,6 +54,7 @@ export class CodeBuildManager {
             ],
           },
         },
+        version: '0.1',
       }),
       environment: {
         buildImage: codebuild.LinuxBuildImage.fromDockerRegistry(
@@ -70,12 +65,13 @@ export class CodeBuildManager {
       },
       logging: {
         cloudWatch: {
+          enabled: true,
           logGroup: scope.logManager.createLogGroup(`${id}-project-log-group`, scope, {
             logGroupName: `${id}-cloudfront-invalidation`,
           }),
-          enabled: true,
         },
       },
+      role: scope.iamManager.roleForCloudfrontInvalidation(id, scope),
       timeout: cdk.Duration.minutes(5),
     })
   }

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

@@ -5,9 +5,6 @@ import { CommonConstruct } from '../../../common'
 import { TableProps } from './types'
 
 /**
- * @stability stable
- * @category cdk-utils.dynamodb-manager
- * @subcategory Construct
  * @classdesc Provides operations on AWS DynamoDB.
  * - 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.
@@ -21,37 +18,36 @@ import { TableProps } from './types'
  *     this.dynamodbManager.createTable('MyTable', this, tableProps)
  *   }
  * }
- *
  * @see [CDK Certificate Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb-readme.html}
  */
 export class DynamodbManager {
   /**
    * @summary Method to create a table
-   * @param {string} id scoped id of the resource
-   * @param {CommonConstruct} scope scope in which this resource is defined
-   * @param {TableProps} props table props
+   * @param id scoped id of the resource
+   * @param scope scope in which this resource is defined
+   * @param props table props
    */
   public createTable(id: string, scope: CommonConstruct, props: TableProps) {
     if (!props) throw `Table props undefined for ${id}`
 
     const table = new dynamodb.Table(scope, `${id}`, {
-      tableName: `${props.tableName}-${scope.props.stage}`,
-      partitionKey: props.partitionKey,
-      sortKey: props.sortKey,
-      kinesisStream: props.kinesisStream,
-      readCapacity: props.readCapacity,
-      writeCapacity: props.writeCapacity,
       billingMode: props.billingMode,
-      pointInTimeRecovery: props.pointInTimeRecovery,
+      contributorInsightsEnabled: props.contributorInsightsEnabled,
       encryption: props.encryption,
       encryptionKey: props.encryptionKey,
-      timeToLiveAttribute: props.timeToLiveAttribute,
-      stream: props.stream,
+      kinesisStream: props.kinesisStream,
+      partitionKey: props.partitionKey,
+      pointInTimeRecovery: props.pointInTimeRecovery,
+      readCapacity: props.readCapacity,
       removalPolicy: props.removalPolicy,
       replicationRegions: props.replicationRegions,
       replicationTimeout: props.replicationTimeout,
+      sortKey: props.sortKey,
+      stream: props.stream,
+      tableName: `${props.tableName}-${scope.props.stage}`,
+      timeToLiveAttribute: props.timeToLiveAttribute,
       waitForReplicationToFinish: props.waitForReplicationToFinish,
-      contributorInsightsEnabled: props.contributorInsightsEnabled,
+      writeCapacity: props.writeCapacity,
     })
 
     if (props.tags && props.tags.length > 0) {

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

@@ -2,8 +2,6 @@ import * as dynamodb from 'aws-cdk-lib/aws-dynamodb'
 import { TagProps } from '../../../types'
 
 /**
- * @category cdk-utils.dynamodb-manager
- * @subcategory Properties
  */
 export interface TableProps extends dynamodb.TableProps {
   tags?: TagProps[]

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

@@ -3,9 +3,6 @@ import * as utils from '../../../utils'
 import { CommonConstruct } from '../../../common'
 
 /**
- * @stability stable
- * @category cdk-utils.ecr-manager
- * @subcategory Construct
  * @classdesc Provides operations on AWS Elastic Container Registry.
  * - 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,15 +16,14 @@ import { CommonConstruct } from '../../../common'
  *     this.ecrManager.createDockerImage('MyImage', this, dockerfilePath)
  *   }
  * }
- *
  * @see [CDK ECR Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecr-readme.html}
  */
 export class EcrManager {
   /**
    * @summary Method to create a docker image in ecr
-   * @param {string} id scoped id of the resource
-   * @param {CommonConstruct} scope scope in which this resource is defined
-   * @param {string} dockerfilePath
+   * @param id scoped id of the resource
+   * @param scope scope in which this resource is defined
+   * @param dockerfilePath
    */
   public createDockerImage(id: string, scope: CommonConstruct, dockerfilePath: string) {
     const asset = new ecr.DockerImageAsset(scope, `${id}`, {

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

@@ -9,9 +9,6 @@ import { CommonConstruct } from '../../../common'
 import { EcsApplicationLoadBalancedFargateServiceProps, EcsClusterProps, EcsTaskProps } from './types'
 
 /**
- * @stability stable
- * @category cdk-utils.ecs-manager
- * @subcategory Construct
  * @classdesc Provides operations on AWS Elastic Container 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.
@@ -25,28 +22,27 @@ import { EcsApplicationLoadBalancedFargateServiceProps, EcsClusterProps, EcsTask
  *     this.ecsManager.createEcsCluster('MyCluster', this, vpc)
  *   }
  * }
- *
  * @see [CDK ECS Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs-readme.html}
  */
 export class EcsManager {
   /**
    * @summary Method to create an ecs cluster
-   * @param {string} id scoped id of the resource
-   * @param {CommonConstruct} scope scope in which this resource is defined
-   * @param {EcsClusterProps} props
-   * @param {ec2.IVpc} vpc
+   * @param id scoped id of the resource
+   * @param scope scope in which this resource is defined
+   * @param props
+   * @param vpc
    */
   public createEcsCluster(id: string, scope: CommonConstruct, props: EcsClusterProps, vpc: ec2.IVpc) {
     if (!props) throw `Ecs Cluster props undefined for ${id}`
 
     const ecsCluster = new ecs.Cluster(scope, `${id}`, {
+      capacity: props.capacity,
       clusterName: `${props.clusterName}-${scope.props.stage}`,
-      vpc: vpc,
+      containerInsights: props.containerInsights,
       defaultCloudMapNamespace: props.defaultCloudMapNamespace,
-      capacity: props.capacity,
       enableFargateCapacityProviders: props.enableFargateCapacityProviders,
-      containerInsights: props.containerInsights,
       executeCommandConfiguration: props.executeCommandConfiguration,
+      vpc: vpc,
     })
 
     if (props.tags && props.tags.length > 0) {
@@ -63,16 +59,16 @@ export class EcsManager {
 
   /**
    * @summary Method to create an ecs fargate task
-   * @param {string} id scoped id of the resource
-   * @param {CommonConstruct} scope scope in which this resource is defined
-   * @param {EcsTaskProps} props
-   * @param {ecs.ICluster} cluster
-   * @param {iam.Role} role
-   * @param {logs.ILogGroup} logGroup
-   * @param {ecs.ContainerImage} containerImage
-   * @param {Map<string, string>} environment
-   * @param {Map<string, string>} secrets
-   * @param {string[]} command
+   * @param id scoped id of the resource
+   * @param scope scope in which this resource is defined
+   * @param props
+   * @param cluster
+   * @param role
+   * @param logGroup
+   * @param containerImage
+   * @param environment
+   * @param secrets
+   * @param command
    */
   public createEcsFargateTask(
     id: string,
@@ -94,36 +90,36 @@ export class EcsManager {
       ephemeralStorageGiB: props.ephemeralStorageGiB,
       executionRole: role,
       family: `${props.family}-${scope.props.stage}`,
-      ipcMode: props.ipcMode,
       inferenceAccelerators: props.inferenceAccelerators,
+      ipcMode: props.ipcMode,
       memoryMiB: props.memoryMiB,
       networkMode: ecs.NetworkMode.AWS_VPC,
       pidMode: props.pidMode,
       placementConstraints: props.placementConstraints,
       proxyConfiguration: props.proxyConfiguration,
       runtimePlatform: {
-        operatingSystemFamily: props.runtimePlatform?.operatingSystemFamily ?? ecs.OperatingSystemFamily.LINUX,
         cpuArchitecture: props.runtimePlatform?.cpuArchitecture ?? ecs.CpuArchitecture.X86_64,
+        operatingSystemFamily: props.runtimePlatform?.operatingSystemFamily ?? ecs.OperatingSystemFamily.LINUX,
       },
       taskRole: role,
       volumes: props.volumes,
     })
 
     ecsTask.addContainer('EcsContainer', {
+      command: command,
       cpu: props.cpu ? parseInt(props.cpu) : undefined,
       disableNetworking: false,
       environment: environment,
       image: containerImage,
       logging: ecs.LogDriver.awsLogs({
         logGroup: logGroup,
-        streamPrefix: `${id}`,
-        multilinePattern: props.logging?.multilinePattern,
         logRetention: props.logging?.logRetention,
+        multilinePattern: props.logging?.multilinePattern,
+        streamPrefix: `${id}`,
       }),
       memoryLimitMiB: props.memoryMiB ? parseInt(props.memoryMiB) : undefined,
       privileged: false,
       secrets: secrets,
-      command: command,
     })
 
     if (props.tags && props.tags.length > 0) {
@@ -139,11 +135,11 @@ export class EcsManager {
 
   /**
    * @summary Method to create an application loadbalanced ecs fargate task
-   * @param {string} id scoped id of the resource
-   * @param {CommonConstruct} scope scope in which this resource is defined
-   * @param {EcsApplicationLoadBalancedFargateServiceProps} props
-   * @param {ecs.ICluster} cluster
-   * @param {logs.ILogGroup} logGroup
+   * @param id scoped id of the resource
+   * @param scope scope in which this resource is defined
+   * @param props
+   * @param cluster
+   * @param logGroup
    */
   public createLoadBalancedFargateService(
     id: string,
@@ -169,26 +165,26 @@ export class EcsManager {
       loadBalancerName: `${id}-${scope.props.stage}`,
       memoryLimitMiB: props.memoryLimitMiB,
       runtimePlatform: {
-        operatingSystemFamily: props.runtimePlatform?.operatingSystemFamily ?? ecs.OperatingSystemFamily.LINUX,
         cpuArchitecture: props.runtimePlatform?.cpuArchitecture ?? ecs.CpuArchitecture.X86_64,
+        operatingSystemFamily: props.runtimePlatform?.operatingSystemFamily ?? ecs.OperatingSystemFamily.LINUX,
       },
       serviceName: `${id}-${scope.props.stage}`,
       taskImageOptions: {
+        containerPort: props.taskImageOptions?.containerPort,
         enableLogging: props.taskImageOptions?.enableLogging ?? true,
+        environment: props.taskImageOptions?.environment,
+        executionRole: props.taskImageOptions?.executionRole,
+        image: props.taskImageOptions.image,
         logDriver:
           props.taskImageOptions?.logDriver ??
           ecs.LogDriver.awsLogs({
             logGroup: logGroup,
-            streamPrefix: `${id}-${scope.props.stage}/ecs`,
-            multilinePattern: props.logging?.multilinePattern,
             logRetention: props.logging?.logRetention,
+            multilinePattern: props.logging?.multilinePattern,
+            streamPrefix: `${id}-${scope.props.stage}/ecs`,
           }),
-        image: props.taskImageOptions.image,
-        executionRole: props.taskImageOptions?.executionRole,
-        taskRole: props.taskImageOptions?.taskRole,
-        containerPort: props.taskImageOptions?.containerPort,
-        environment: props.taskImageOptions?.environment,
         secrets: props.taskImageOptions?.secrets,
+        taskRole: props.taskImageOptions?.taskRole,
       },
     })
 

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

@@ -5,16 +5,12 @@ import { ApplicationLoadBalancedFargateServiceProps } from 'aws-cdk-lib/aws-ecs-
 import * as elb from 'aws-cdk-lib/aws-elasticloadbalancingv2'
 
 /**
- * @category cdk-utils.ecs-manager
- * @subcategory Properties
  */
 export interface EcsClusterProps extends ClusterProps {
   tags?: TagProps[]
 }
 
 /**
- * @category cdk-utils.ecs-manager
- * @subcategory Properties
  */
 export interface EcsTaskProps extends TaskDefinitionProps {
   logging?: AwsLogDriverProps
@@ -22,8 +18,8 @@ export interface EcsTaskProps extends TaskDefinitionProps {
 }
 
 export interface EcsScalingProps {
-  minCapacity?: number
   maxCapacity?: number
+  minCapacity?: number
   scaleOnCpuUtilization?: number
   scaleOnMemoryUtilization?: number
   scaleOnRequestsPerTarget?: number
@@ -31,8 +27,6 @@ export interface EcsScalingProps {
 }
 
 /**
- * @category cdk-utils.site-with-ecs-backend
- * @subcategory Properties
  */
 export interface HealthCheck extends elb.HealthCheck {
   intervalInSecs: number
@@ -40,8 +34,6 @@ export interface HealthCheck extends elb.HealthCheck {
 }
 
 /**
- * @category cdk-utils.ecs-manager
- * @subcategory Properties
  */
 export interface EcsApplicationLoadBalancedFargateServiceProps extends ApplicationLoadBalancedFargateServiceProps {
   healthCheck?: HealthCheck

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

@@ -6,20 +6,17 @@ import { CommonConstruct } from '../../../common'
 import { EfsAccessPointOptions, EfsFileSystemProps } from './types'
 
 export const DEFAULT_CREATE_ACL = {
-  ownerUid: '1000',
   ownerGid: '1000',
+  ownerUid: '1000',
   permissions: '755',
 }
 
 export const DEFAULT_POSIX_USER = {
-  uid: '1000',
   gid: '1000',
+  uid: '1000',
 }
 
 /**
- * @stability stable
- * @category cdk-utils.efs-manager
- * @subcategory Construct
  * @classdesc Provides operations on AWS Elastic File System.
  * - 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.
@@ -33,19 +30,18 @@ export const DEFAULT_POSIX_USER = {
  *     this.efsManager.createFileSystem('MyFileSystem', this, fileSystemProps, vpc)
  *   }
  * }
- *
  * @see [CDK EFS Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_efs-readme.html}
  */
 export class EfsManager {
   /**
    * @summary Method to create an efs file system
-   * @param {string} id scoped id of the resource
-   * @param {CommonConstruct} scope scope in which this resource is defined
-   * @param {EfsFileSystemProps} props the file system props
-   * @param {ec2.IVpc} vpc the vpc to use for the file system
-   * @param {EfsAccessPointOptions[]} accessPointOptions optional access point configuration options for the file system
-   * @param {ec2.ISecurityGroup} securityGroup optional security groups to configure for the file system
-   * @param {ec2.SubnetSelection} vpcSubnets optional subnets to configure for the file system
+   * @param id scoped id of the resource
+   * @param scope scope in which this resource is defined
+   * @param props the file system props
+   * @param vpc the vpc to use for the file system
+   * @param accessPointOptions optional access point configuration options for the file system
+   * @param securityGroup optional security groups to configure for the file system
+   * @param vpcSubnets optional subnets to configure for the file system
    */
   public createFileSystem(
     id: string,
@@ -61,14 +57,14 @@ export class EfsManager {
     const fileSystemId = props.provisionNewOnDeployment ? `${id}-${new Date().getMilliseconds()}` : `${id}`
     const fileSystem = new efs.FileSystem(scope, `${fileSystemId}`, {
       ...props,
-      vpc,
-      securityGroup,
-      vpcSubnets,
       fileSystemName: props.fileSystemName ? `${props.fileSystemName}-${scope.props.stage}` : undefined,
       lifecyclePolicy: props.lifecyclePolicy ?? efs.LifecyclePolicy.AFTER_7_DAYS,
-      performanceMode: props.performanceMode ?? efs.PerformanceMode.GENERAL_PURPOSE,
       outOfInfrequentAccessPolicy: props.outOfInfrequentAccessPolicy ?? efs.OutOfInfrequentAccessPolicy.AFTER_1_ACCESS,
+      performanceMode: props.performanceMode ?? efs.PerformanceMode.GENERAL_PURPOSE,
       removalPolicy: props.removalPolicy ?? cdk.RemovalPolicy.DESTROY,
+      securityGroup,
+      vpc,
+      vpcSubnets,
     })
 
     utils.createCfnOutput(`${id}-fileSystemArn`, scope, fileSystem.fileSystemArn)
@@ -79,8 +75,8 @@ export class EfsManager {
       for (const [index, accessPointOption] of accessPointOptions.entries()) {
         if (!accessPointOption.path) throw `Undefined access point path for option: [${accessPointOption}], id: [${id}]`
         const accessPoint = fileSystem.addAccessPoint(`${id}-ap-${index}`, {
-          path: accessPointOption.path,
           createAcl: accessPointOption.createAcl ?? DEFAULT_CREATE_ACL,
+          path: accessPointOption.path,
           posixUser: accessPointOption.posixUser ?? DEFAULT_POSIX_USER,
         })
 

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

@@ -2,19 +2,15 @@ import { AccessPointOptions, FileSystemProps } from 'aws-cdk-lib/aws-efs'
 import { AuthorizationConfig } from 'aws-cdk-lib/aws-ecs'
 
 /**
- * @category cdk-utils.efs-manager
- * @subcategory Properties
  */
 export interface EfsFileSystemProps extends FileSystemProps {
+  authorizationConfig?: AuthorizationConfig
   provisionNewOnDeployment?: boolean
   rootDirectory?: string
   transitEncryption?: string
   transitEncryptionPort?: number
-  authorizationConfig?: AuthorizationConfig
 }
 
 /**
- * @category cdk-utils.efs-manager
- * @subcategory Properties
  */
 export interface EfsAccessPointOptions extends AccessPointOptions {}

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

@@ -6,9 +6,6 @@ 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.
@@ -22,17 +19,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 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
    */
   public createEksDeployment(
     id: string,
@@ -56,8 +52,8 @@ export class EksManager {
           spec: {
             containers: [
               {
-                name: `${id}`.toLowerCase(),
                 image: image.imageUri,
+                name: `${id}`.toLowerCase(),
                 ports: [{ containerPort: props.appContainerPort }],
               },
             ],
@@ -71,16 +67,16 @@ export 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',
       },
     }
 

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

@@ -1,10 +1,8 @@
 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/src/lib/services/aws/elasticache/main.ts

@@ -5,9 +5,6 @@ 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.
@@ -21,32 +18,31 @@ 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 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
    */
   public createElastiCacheSubnetGroup(id: string, scope: CommonConstruct, subnetIds: string[]) {
     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
    */
   public createElastiCache(
     id: string,
@@ -61,25 +57,25 @@ export class ElastiCacheManager {
     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)
@@ -99,11 +95,11 @@ export 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
    */
   public createReplicatedElastiCache(
     id: string,
@@ -117,27 +113,27 @@ export class ElastiCacheManager {
     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)