@gradientedge/cdk-utils 10.8.0 → 11.1.0

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

@@ -1,100 +0,0 @@
-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/index.js'
-import { createCfnOutput } from '../../utils/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 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
-   */
-  public createEksDeployment(
-    id: string,
-    scope: CommonConstruct,
-    props: EksClusterProps,
-    image: DockerImageAsset,
-    vpc: IVpc
-  ) {
-    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/src/lib/aws/services/elastic-kubernetes-service/types.ts

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

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

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

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

@@ -1,115 +0,0 @@
-import { Tags } from 'aws-cdk-lib'
-import { CfnCacheCluster, CfnReplicationGroup, CfnSubnetGroup } from 'aws-cdk-lib/aws-elasticache'
-import _ from 'lodash'
-import { CommonConstruct } from '../../common/index.js'
-import { createCfnOutput } from '../../utils/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 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
-   */
-  public createElastiCacheSubnetGroup(id: string, scope: CommonConstruct, subnetIds: string[]) {
-    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
-   */
-  public createElastiCache(
-    id: string,
-    scope: CommonConstruct,
-    props: ElastiCacheProps,
-    subnetIds: string[],
-    securityGroupIds: string[],
-    logDeliveryConfigurations?: any
-  ) {
-    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
-   */
-  public createReplicatedElastiCache(
-    id: string,
-    scope: CommonConstruct,
-    props: ReplicatedElastiCacheProps,
-    subnetIds: string[],
-    securityGroupIds: string[]
-  ) {
-    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/src/lib/aws/services/elasticache/types.ts

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

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

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

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

@@ -1,387 +0,0 @@
-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 _ from 'lodash'
-import { CommonConstruct } from '../../common/index.js'
-import { createCfnOutput } from '../../utils/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 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
-   */
-  public createEventBus(id: string, scope: CommonConstruct, props: EventBusProps) {
-    if (!props) throw `EventBus props undefined for ${id}`
-    if (!props.eventBusName) throw `EventBus eventBusName undefined for ${id}`
-
-    let eventBusName = props.eventBusName
-    if (eventBusName != 'default') {
-      eventBusName = scope.resourceNameFormatter.format(
-        props.eventBusName,
-        scope.props.resourceNameOptions?.eventbridgeBus
-      )
-    }
-    const eventBus = new EventBus(scope, `${id}`, {
-      ...props,
-      eventBusName,
-    })
-
-    createCfnOutput(`${id}-eventBusName`, scope, eventBusName)
-    createCfnOutput(`${id}-eventBusArn`, scope, eventBus.eventBusArn)
-
-    return 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
-   */
-  public createRule(
-    id: string,
-    scope: CommonConstruct,
-    props: EventRuleProps,
-    eventBus?: IEventBus,
-    targets?: IRuleTarget[]
-  ) {
-    if (!props) throw `EventRule props undefined for ${id}`
-    if (!props.ruleName) throw `EventRule ruleName undefined for ${id}`
-
-    const rule = new Rule(scope, `${id}`, {
-      ...props,
-      eventBus,
-      ruleName: scope.resourceNameFormatter.format(props.ruleName, scope.props.resourceNameOptions?.eventbridgeRule),
-    })
-
-    if (targets && !_.isEmpty(targets)) {
-      _.forEach(targets, target => {
-        rule.addTarget(target)
-      })
-    }
-
-    if (props.tags && !_.isEmpty(props.tags)) {
-      _.forEach(props.tags, tag => {
-        Tags.of(rule).add(tag.key, tag.value)
-      })
-    }
-
-    createCfnOutput(`${id}-ruleArn`, scope, rule.ruleArn)
-    createCfnOutput(`${id}-ruleName`, scope, rule.ruleName)
-
-    return 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
-   */
-  public createLambdaRule(
-    id: string,
-    scope: CommonConstruct,
-    props: RuleProps,
-    lambdaFunction: IFunction,
-    eventBusName?: string,
-    eventPattern?: any,
-    scheduleExpression?: string
-  ) {
-    if (!props) throw `EventRule props undefined for ${id}`
-    if (!props.name) throw `EventRule name undefined for ${id}`
-
-    const eventRule = new CfnRule(scope, `${id}`, {
-      ...props,
-      description: 'Rule to send notification to lambda function target',
-      eventBusName,
-      eventPattern,
-      name: scope.resourceNameFormatter.format(props.name, scope.props.resourceNameOptions?.eventbridgeRule),
-      scheduleExpression,
-      targets: [
-        {
-          arn: lambdaFunction.functionArn,
-          id: scope.resourceNameFormatter.format(props.name, scope.props.resourceNameOptions?.eventbridgeRule),
-          input: props.input ?? undefined,
-        },
-      ],
-    })
-
-    if (props.tags && !_.isEmpty(props.tags)) {
-      _.forEach(props.tags, tag => {
-        Tags.of(eventRule).add(tag.key, tag.value)
-      })
-    }
-
-    new CfnPermission(scope, `${id}LambdaPermission`, {
-      action: 'lambda:InvokeFunction',
-      functionName: lambdaFunction.functionName,
-      principal: 'events.amazonaws.com',
-      sourceArn: eventRule.attrArn,
-    })
-
-    createCfnOutput(`${id}-ruleArn`, scope, eventRule.attrArn)
-    createCfnOutput(`${id}-ruleName`, scope, eventRule.name)
-
-    return eventRule
-  }
-
-  /**
-   * @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
-   */
-  public createFargateTaskRule(
-    id: string,
-    scope: CommonConstruct,
-    props: RuleProps,
-    cluster: ICluster,
-    task: ITaskDefinition,
-    subnetIds: string[],
-    role: Role | CfnRole,
-    eventPattern?: any
-  ) {
-    if (!props) throw `EventRule props undefined for ${id}`
-    if (!props.name) throw `EventRule name undefined for ${id}`
-
-    const eventRule = new CfnRule(scope, `${id}`, {
-      ...props,
-      description: 'Rule to send notification on new objects in data bucket to ecs task target',
-      eventPattern,
-      name: scope.resourceNameFormatter.format(props.name, scope.props.resourceNameOptions?.eventbridgeRule),
-      targets: [
-        {
-          arn: cluster.clusterArn,
-          ecsParameters: {
-            launchType: 'FARGATE',
-            networkConfiguration: {
-              awsVpcConfiguration: { assignPublicIp: 'ENABLED', subnets: subnetIds },
-            },
-            taskCount: 1,
-            taskDefinitionArn: task.taskDefinitionArn,
-          },
-          id: scope.resourceNameFormatter.format(props.name, scope.props.resourceNameOptions?.eventbridgeRule),
-          roleArn: role instanceof Role ? role.roleArn : role.attrArn,
-        },
-      ],
-    })
-
-    createCfnOutput(`${id}-ruleArn`, scope, eventRule.attrArn)
-    createCfnOutput(`${id}-ruleName`, scope, eventRule.name)
-
-    return eventRule
-  }
-
-  /**
-   * @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
-   */
-  public createSqsToSfnCfnPipe(
-    id: string,
-    scope: CommonConstruct,
-    props: SqsToSfnPipeProps,
-    sourceQueue: IQueue,
-    targetStepFunction: IStateMachine
-  ) {
-    if (!props) throw `Pipe props undefined for ${id}`
-    if (!props.name) throw `Pipe name undefined for ${id}`
-
-    const pipeRole = scope.iamManager.createRoleForSqsToSfnPipe(
-      `${id}-role`,
-      scope,
-      sourceQueue.queueArn,
-      targetStepFunction.stateMachineArn
-    )
-
-    const pipe = new CfnPipe(scope, `${id}`, {
-      ...props,
-      name: scope.resourceNameFormatter.format(props.name, scope.props.resourceNameOptions?.eventbridgePipe),
-      roleArn: pipeRole.roleArn,
-      source: sourceQueue.queueArn,
-      sourceParameters: {
-        filterCriteria: props.pipeFilterPattern
-          ? {
-              filters: [
-                {
-                  pattern: JSON.stringify(props.pipeFilterPattern),
-                },
-              ],
-            }
-          : undefined,
-        sqsQueueParameters: {
-          batchSize: props.sqsBatchSize,
-          maximumBatchingWindowInSeconds: props.sqsMaximumBatchingWindowInSeconds,
-        },
-      },
-      target: targetStepFunction.stateMachineArn,
-      targetParameters: {
-        inputTemplate: props.sfnInputTemplate,
-        stepFunctionStateMachineParameters: {
-          invocationType: props.sfnInvocationType ?? 'FIRE_AND_FORGET',
-        },
-      },
-    })
-
-    createCfnOutput(`${id}-pipeArn`, scope, pipe.attrArn)
-    createCfnOutput(`${id}-pipeName`, scope, pipe.name)
-
-    return pipe
-  }
-
-  /**
-   * @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
-   */
-  public createSqsToLambdaCfnPipe(
-    id: string,
-    scope: CommonConstruct,
-    props: SqsToLambdaPipeProps,
-    sourceQueue: IQueue,
-    targetLambdaFunction: IFunction
-  ) {
-    if (!props) throw `Pipe props undefined for ${id}`
-    if (!props.name) throw `Pipe name undefined for ${id}`
-
-    const pipeRole = scope.iamManager.createRoleForSqsToLambdaPipe(
-      `${id}-role`,
-      scope,
-      sourceQueue.queueArn,
-      targetLambdaFunction.functionArn
-    )
-
-    const pipe = new CfnPipe(scope, `${id}`, {
-      ...props,
-      name: scope.resourceNameFormatter.format(props.name, scope.props.resourceNameOptions?.eventbridgePipe),
-      roleArn: pipeRole.roleArn,
-      source: sourceQueue.queueArn,
-      sourceParameters: {
-        filterCriteria: props.pipeFilterPattern
-          ? {
-              filters: [
-                {
-                  pattern: JSON.stringify(props.pipeFilterPattern),
-                },
-              ],
-            }
-          : undefined,
-        sqsQueueParameters: {
-          batchSize: props.sqsBatchSize,
-          maximumBatchingWindowInSeconds: props.sqsMaximumBatchingWindowInSeconds,
-        },
-      },
-      target: targetLambdaFunction.functionArn,
-      targetParameters: {
-        inputTemplate: props.lambdaInputTemplate,
-      },
-    })
-
-    createCfnOutput(`${id}-pipeArn`, scope, pipe.attrArn)
-    createCfnOutput(`${id}-pipeName`, scope, pipe.name)
-
-    return pipe
-  }
-
-  /**
-   * @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
-   */
-  public createDynamoDbToLambdaCfnPipe(
-    id: string,
-    scope: CommonConstruct,
-    props: DynamoDbToLambdaPipeProps,
-    sourceDynamoDbStreamArn: string,
-    targetLambdaFunction: IFunction
-  ) {
-    if (!props) throw `Pipe props undefined for ${id}`
-    if (!props.name) throw `Pipe name undefined for ${id}`
-
-    const pipeRole = scope.iamManager.createRoleForDynamoDbToLambdaPipe(
-      `${id}-role`,
-      scope,
-      sourceDynamoDbStreamArn,
-      targetLambdaFunction.functionArn
-    )
-
-    const pipe = new CfnPipe(scope, `${id}`, {
-      ...props,
-      name: scope.resourceNameFormatter.format(props.name, scope.props.resourceNameOptions?.eventbridgePipe),
-      roleArn: pipeRole.roleArn,
-      source: sourceDynamoDbStreamArn,
-      sourceParameters: {
-        filterCriteria: props.pipeFilterPattern
-          ? {
-              filters: [
-                {
-                  pattern: JSON.stringify(props.pipeFilterPattern),
-                },
-              ],
-            }
-          : undefined,
-        dynamoDbStreamParameters: {
-          startingPosition: props.dynamoDbStartingPosition,
-          batchSize: props.dynamoDbBatchSize,
-        },
-      },
-      target: targetLambdaFunction.functionArn,
-    })
-
-    createCfnOutput(`${id}-pipeArn`, scope, pipe.attrArn)
-    createCfnOutput(`${id}-pipeName`, scope, pipe.name)
-
-    return pipe
-  }
-}