@gradientedge/cdk-utils-aws 1.0.0

package/dist/src/services/elastic-file-system/main.js

@@ -0,0 +1,76 @@
+import { RemovalPolicy } from 'aws-cdk-lib';
+import { FileSystem, LifecyclePolicy, OutOfInfrequentAccessPolicy, PerformanceMode } from 'aws-cdk-lib/aws-efs';
+import _ from 'lodash';
+import { createCfnOutput } from '../../utils/index.js';
+export const DEFAULT_CREATE_ACL = {
+    ownerGid: '1000',
+    ownerUid: '1000',
+    permissions: '755',
+};
+export const DEFAULT_POSIX_USER = {
+    gid: '1000',
+    uid: '1000',
+};
+/**
+ * @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.
+ * @example
+ * import { CommonConstruct } from '@gradientedge/cdk-utils'
+ *
+ * class CustomConstruct extends CommonConstruct {
+ *   constructor(parent: cdk.Construct, id: string, props: common.CommonStackProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     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 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
+     */
+    createFileSystem(id, scope, props, vpc, accessPointOptions, securityGroup, vpcSubnets) {
+        if (!props)
+            throw `EFS props undefined for ${id}`;
+        if (!props.fileSystemName)
+            throw `EFS fileSystemName undefined for ${id}`;
+        const fileSystemId = props.provisionNewOnDeployment ? `${id}-${new Date().getMilliseconds()}` : `${id}`;
+        const fileSystem = new FileSystem(scope, `${fileSystemId}`, {
+            ...props,
+            fileSystemName: scope.resourceNameFormatter.format(props.fileSystemName, scope.props.resourceNameOptions?.efs),
+            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,
+        });
+        createCfnOutput(`${id}-fileSystemArn`, scope, fileSystem.fileSystemArn);
+        createCfnOutput(`${id}-fileSystemId`, scope, fileSystem.fileSystemId);
+        /* provision access points if specified */
+        if (accessPointOptions && !_.isEmpty(accessPointOptions)) {
+            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}`, {
+                    createAcl: accessPointOption.createAcl ?? DEFAULT_CREATE_ACL,
+                    path: accessPointOption.path,
+                    posixUser: accessPointOption.posixUser ?? DEFAULT_POSIX_USER,
+                });
+                createCfnOutput(`${id}-accessPointArn-${index}`, scope, accessPoint.accessPointArn);
+                createCfnOutput(`${id}-accessPointId-${index}`, scope, accessPoint.accessPointId);
+            }
+        }
+        return fileSystem;
+    }
+}

package/dist/src/services/elastic-file-system/types.d.ts

@@ -0,0 +1,15 @@
+import { AuthorizationConfig } from 'aws-cdk-lib/aws-ecs';
+import { AccessPointOptions, FileSystemProps } from 'aws-cdk-lib/aws-efs';
+/**
+ */
+export interface EfsFileSystemProps extends FileSystemProps {
+    authorizationConfig?: AuthorizationConfig;
+    provisionNewOnDeployment?: boolean;
+    rootDirectory?: string;
+    transitEncryption?: string;
+    transitEncryptionPort?: number;
+}
+/**
+ */
+export interface EfsAccessPointOptions extends AccessPointOptions {
+}

package/dist/src/services/elastic-file-system/types.js

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

package/dist/src/services/elastic-kubernetes-service/index.d.ts

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

package/dist/src/services/elastic-kubernetes-service/index.js

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

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

@@ -0,0 +1,32 @@
+import { IVpc } from 'aws-cdk-lib/aws-ec2';
+import { DockerImageAsset } from 'aws-cdk-lib/aws-ecr-assets';
+import { Cluster } from 'aws-cdk-lib/aws-eks';
+import { CommonConstruct } from '../../common/index.js';
+import { EksClusterProps } from './types.js';
+/**
+ * @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.
+ * @example
+ * import { CommonConstruct } from '@gradientedge/cdk-utils'
+ *
+ * class CustomConstruct extends CommonConstruct {
+ *   constructor(parent: cdk.Construct, id: string, props: common.CommonStackProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     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 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: DockerImageAsset, vpc: IVpc): Cluster;
+}

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

@@ -0,0 +1,85 @@
+import { InstanceClass, InstanceSize, InstanceType } from 'aws-cdk-lib/aws-ec2';
+import { Cluster, KubernetesVersion } from 'aws-cdk-lib/aws-eks';
+import { createCfnOutput } from '../../utils/index.js';
+/**
+ * @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.
+ * @example
+ * import { CommonConstruct } from '@gradientedge/cdk-utils'
+ *
+ * class CustomConstruct extends CommonConstruct {
+ *   constructor(parent: cdk.Construct, id: string, props: common.CommonStackProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     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 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)
+            throw `EksCluster props undefined for ${id}`;
+        if (!props.clusterName)
+            throw `EksCluster clusterName undefined for ${id}`;
+        const appLabel = { app: `${id}`.toLowerCase() };
+        const deployment = {
+            apiVersion: 'apps/v1',
+            kind: 'Deployment',
+            metadata: { name: `${id}`.toLowerCase() },
+            spec: {
+                selector: { matchLabels: appLabel },
+                template: {
+                    metadata: { labels: appLabel },
+                    spec: {
+                        containers: [
+                            {
+                                image: image.imageUri,
+                                name: `${id}`.toLowerCase(),
+                                ports: [{ containerPort: props.appContainerPort }],
+                            },
+                        ],
+                    },
+                },
+            },
+        };
+        const service = {
+            apiVersion: 'v1',
+            kind: 'Service',
+            metadata: { name: `${id}`.toLowerCase() },
+            spec: {
+                ports: [
+                    {
+                        name: 'http-port',
+                        port: 80,
+                        protocol: 'TCP',
+                        targetPort: props.appContainerPort,
+                    },
+                ],
+                selector: appLabel,
+                type: 'LoadBalancer',
+            },
+        };
+        const cluster = new Cluster(scope, `${id}Cluster`, {
+            clusterName: scope.resourceNameFormatter.format(props.clusterName, scope.props.resourceNameOptions?.eks),
+            defaultCapacity: props.appCapacity,
+            defaultCapacityInstance: InstanceType.of(InstanceClass.T3, InstanceSize.LARGE),
+            kubectlLayer: props.kubectlLayer,
+            version: KubernetesVersion.V1_27,
+            vpc,
+        });
+        cluster.addManifest(`${id}Pod`, service, deployment);
+        createCfnOutput(`${id}-clusterArn`, scope, cluster.clusterArn);
+        createCfnOutput(`${id}-clusterEndpoint`, scope, cluster.clusterEndpoint);
+        return cluster;
+    }
+}

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

@@ -0,0 +1,7 @@
+import { ClusterProps } from 'aws-cdk-lib/aws-eks';
+/**
+ */
+export interface EksClusterProps extends ClusterProps {
+    appCapacity: number;
+    appContainerPort: number;
+}

package/dist/src/services/elastic-kubernetes-service/types.js

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

package/dist/src/services/elasticache/index.d.ts

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

package/dist/src/services/elasticache/index.js

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

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

@@ -0,0 +1,47 @@
+import { CfnCacheCluster, CfnReplicationGroup, CfnSubnetGroup } from 'aws-cdk-lib/aws-elasticache';
+import { CommonConstruct } from '../../common/index.js';
+import { ElastiCacheProps, ReplicatedElastiCacheProps } from './types.js';
+/**
+ * @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.
+ * @example
+ * import { CommonConstruct } from '@gradientedge/cdk-utils'
+ *
+ * class CustomConstruct extends CommonConstruct {
+ *   constructor(parent: cdk.Construct, id: string, props: common.CommonStackProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     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 id scoped id of the resource
+     * @param scope scope in which scope resource is defined
+     * @param subnetIds
+     */
+    createElastiCacheSubnetGroup(id: string, scope: CommonConstruct, subnetIds: string[]): CfnSubnetGroup;
+    /**
+     * @summary Method to create an elasticache resource
+     * @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): CfnCacheCluster;
+    /**
+     * @summary Method to create an replicated elasticache resource
+     * @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[]): CfnReplicationGroup;
+}

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

@@ -0,0 +1,90 @@
+import { Tags } from 'aws-cdk-lib';
+import { CfnCacheCluster, CfnReplicationGroup, CfnSubnetGroup } from 'aws-cdk-lib/aws-elasticache';
+import _ from 'lodash';
+import { createCfnOutput } from '../../utils/index.js';
+/**
+ * @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.
+ * @example
+ * import { CommonConstruct } from '@gradientedge/cdk-utils'
+ *
+ * class CustomConstruct extends CommonConstruct {
+ *   constructor(parent: cdk.Construct, id: string, props: common.CommonStackProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     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 id scoped id of the resource
+     * @param scope scope in which scope resource is defined
+     * @param subnetIds
+     */
+    createElastiCacheSubnetGroup(id, scope, subnetIds) {
+        return new CfnSubnetGroup(scope, `${id}`, {
+            cacheSubnetGroupName: `${id}-subnet-group-${scope.props.stage}`,
+            description: `${id}-subnet-group-${scope.props.stage}`,
+            subnetIds: subnetIds,
+        });
+    }
+    /**
+     * @summary Method to create an elasticache resource
+     * @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}`;
+        if (!props.clusterName)
+            throw `ElastiCache clusterName undefined for ${id}`;
+        const subnetGroup = this.createElastiCacheSubnetGroup(`${id}-subnetGroup`, scope, subnetIds);
+        const elasticacheCluster = new CfnCacheCluster(scope, `${id}`, {
+            ...props,
+            cacheSubnetGroupName: subnetGroup.cacheSubnetGroupName,
+            clusterName: scope.resourceNameFormatter.format(props.clusterName, scope.props.resourceNameOptions?.elasticache),
+            logDeliveryConfigurations,
+            vpcSecurityGroupIds: securityGroupIds,
+        });
+        elasticacheCluster.addDependency(subnetGroup);
+        if (props.tags && !_.isEmpty(props.tags)) {
+            _.forEach(props.tags, tag => {
+                Tags.of(elasticacheCluster).add(tag.key, tag.value);
+            });
+        }
+        createCfnOutput(`${id}-clusterName`, scope, elasticacheCluster.clusterName);
+        createCfnOutput(`${id}-redisEndpointPort`, scope, elasticacheCluster.attrRedisEndpointPort);
+        createCfnOutput(`${id}-redisEndpointAddress`, scope, elasticacheCluster.attrRedisEndpointAddress);
+        return elasticacheCluster;
+    }
+    /**
+     * @summary Method to create an replicated elasticache resource
+     * @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 CfnReplicationGroup(scope, `${id}`, {
+            ...props,
+            cacheSubnetGroupName: subnetGroup.cacheSubnetGroupName,
+            replicationGroupDescription: `${id} Redis Replication Cluster`,
+            replicationGroupId: `${id}-${scope.props.stage}`,
+            securityGroupIds,
+        });
+        elasticacheCluster.addDependency(subnetGroup);
+        return elasticacheCluster;
+    }
+}

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

@@ -0,0 +1,9 @@
+import { CfnCacheClusterProps, CfnReplicationGroupProps } from 'aws-cdk-lib/aws-elasticache';
+/**
+ */
+export interface ElastiCacheProps extends CfnCacheClusterProps {
+}
+/**
+ */
+export interface ReplicatedElastiCacheProps extends CfnReplicationGroupProps {
+}

package/dist/src/services/elasticache/types.js

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

package/dist/src/services/eventbridge/index.d.ts

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

package/dist/src/services/eventbridge/index.js

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

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

@@ -0,0 +1,93 @@
+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 { 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/index.js';
+import { DynamoDbToLambdaPipeProps, EventBusProps, EventRuleProps, RuleProps, SqsToLambdaPipeProps, SqsToSfnPipeProps } from './types.js';
+/**
+ * @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.
+ * @example
+ * import { CommonConstruct } from '@gradientedge/cdk-utils'
+ *
+ * class CustomConstruct extends CommonConstruct {
+ *   constructor(parent: Construct, id: string, props: common.CommonStackProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     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 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): EventBus;
+    /**
+     * Method to create an event rule
+     * @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?: IEventBus, targets?: IRuleTarget[]): Rule;
+    /**
+     * @summary Method to create an eventbridge rule with lambda target
+     * @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: IFunction, eventBusName?: string, eventPattern?: any, scheduleExpression?: string): CfnRule;
+    /**
+     * @summary Method to create an eventbridge rule with fargate task target
+     * @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: ICluster, task: ITaskDefinition, subnetIds: string[], role: Role | CfnRole, eventPattern?: any): CfnRule;
+    /**
+     * @summary Method to create an eventbridge pipe with sqs queue as source and step function as target
+     * @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
+     */
+    createSqsToSfnCfnPipe(id: string, scope: CommonConstruct, props: SqsToSfnPipeProps, sourceQueue: IQueue, targetStepFunction: IStateMachine): CfnPipe;
+    /**
+     * @summary Method to create an eventbridge pipe with sqs queue as source and lambda function as target
+     * @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 targetLambdaFunction the target lambda function
+     */
+    createSqsToLambdaCfnPipe(id: string, scope: CommonConstruct, props: SqsToLambdaPipeProps, sourceQueue: IQueue, targetLambdaFunction: IFunction): CfnPipe;
+    /**
+     * @summary Method to create an eventbridge pipe with DynamoDb stream as source and lambda function as target
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props the props for the pipe
+     * @param dynamoDbStream the source dynamoDb stream
+     * @param targetLambdaFunction the target lambda function
+     */
+    createDynamoDbToLambdaCfnPipe(id: string, scope: CommonConstruct, props: DynamoDbToLambdaPipeProps, sourceDynamoDbStreamArn: string, targetLambdaFunction: IFunction): CfnPipe;
+}