@gradientedge/cdk-utils-aws 1.0.0

package/dist/src/services/simple-storage-service/main.js

@@ -0,0 +1,191 @@
+import { Duration, RemovalPolicy, Stack, Tags } from 'aws-cdk-lib';
+import { Effect, PolicyDocument, PolicyStatement, ServicePrincipal } from 'aws-cdk-lib/aws-iam';
+import { BlockPublicAccess, Bucket, BucketEncryption, CfnBucketPolicy } from 'aws-cdk-lib/aws-s3';
+import { BucketDeployment, ServerSideEncryption, Source } from 'aws-cdk-lib/aws-s3-deployment';
+import _ from 'lodash';
+import { createCfnOutput } from '../../utils/index.js';
+/**
+ * @classdesc Provides operations on AWS S3
+ * - 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.s3Manager.createS3Bucket('MyBucket', this)
+ *   }
+ * }
+ * @see [CDK S3 Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3-readme.html}
+ */
+export class S3Manager {
+    /**
+     * @summary Method to determine S3 Bucket lifecycle properties
+     * @param props bucket properties
+     */
+    determineBucketLifecycleRules(props) {
+        if (!props.lifecycleRules)
+            return undefined;
+        const bucketLifecycleRules = [];
+        _.forEach(props.lifecycleRules, lifecycleRule => {
+            bucketLifecycleRules.push({
+                ...lifecycleRule,
+                expiration: lifecycleRule.expirationInDays ? Duration.days(lifecycleRule.expirationInDays) : undefined,
+                noncurrentVersionExpiration: lifecycleRule.noncurrentVersionExpirationInDays
+                    ? Duration.days(lifecycleRule.noncurrentVersionExpirationInDays)
+                    : undefined,
+            });
+        });
+        return bucketLifecycleRules;
+    }
+    /**
+     * @summary Method to determine the bucket name using account and region
+     * @param scope scope in which this resource is defined
+     * @param bucketName the bucket name
+     */
+    static determineBucketNameByAccountAndRegion(scope, bucketName) {
+        return `${bucketName}-${Stack.of(scope).account}-${scope.props.region}-${scope.props.stage}`;
+    }
+    /**
+     * @summary Method to determine the bucket name using domain name
+     * @param scope scope in which this resource is defined
+     * @param bucketName the bucket name
+     */
+    static determineBucketNameByDomainName(scope, bucketName) {
+        return scope.isProductionStage()
+            ? `${bucketName}.${scope.fullyQualifiedDomainName}`
+            : `${bucketName}-${scope.props.stage}.${scope.fullyQualifiedDomainName}`;
+    }
+    /**
+     * @summary Method to determine the bucket name
+     * @param scope scope in which this resource is defined
+     * @param bucketName the bucket name
+     */
+    static determineBucketName(scope, props, bucketName) {
+        if (!scope.props.excludeDomainNameForBuckets) {
+            return S3Manager.determineBucketNameByDomainName(scope, bucketName);
+        }
+        if (!scope.props.excludeAccountNumberForBuckets) {
+            return S3Manager.determineBucketNameByAccountAndRegion(scope, bucketName);
+        }
+        return scope.resourceNameFormatter.format(bucketName, scope.props.resourceNameOptions?.s3);
+    }
+    /**
+     * @summary Method to create a s3 bucket
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props bucket properties
+     */
+    createS3Bucket(id, scope, props) {
+        if (!props)
+            throw `S3 props undefined for ${id}`;
+        let bucket;
+        const bucketName = S3Manager.determineBucketName(scope, props, props.bucketName);
+        if (props.existingBucket && props.bucketName) {
+            bucket = Bucket.fromBucketName(scope, `${id}`, S3Manager.determineBucketName(scope, props, props.bucketName));
+        }
+        else {
+            let logBucket;
+            if (props.logBucketName) {
+                logBucket = Bucket.fromBucketName(scope, `${id}-logs`, S3Manager.determineBucketName(scope, props, props.logBucketName));
+            }
+            bucket = new Bucket(scope, `${id}-bucket`, {
+                ...props,
+                blockPublicAccess: props.blockPublicAccess || BlockPublicAccess.BLOCK_ALL,
+                bucketName,
+                encryption: props.encryption || BucketEncryption.S3_MANAGED,
+                lifecycleRules: this.determineBucketLifecycleRules(props),
+                removalPolicy: props.removalPolicy || RemovalPolicy.RETAIN,
+                serverAccessLogsBucket: logBucket,
+            });
+            const cfnBucket = bucket.node.defaultChild;
+            cfnBucket.notificationConfiguration = {
+                eventBridgeConfiguration: {
+                    eventBridgeEnabled: props.enableEventBridge ?? false,
+                },
+            };
+        }
+        if (props.tags && !_.isEmpty(props.tags)) {
+            _.forEach(props.tags, tag => {
+                Tags.of(bucket).add(tag.key, tag.value);
+            });
+        }
+        createCfnOutput(`${id}-bucketName`, scope, bucket.bucketName);
+        createCfnOutput(`${id}-bucketArn`, scope, bucket.bucketArn);
+        return bucket;
+    }
+    /**
+     * @summary Method to create an iam bucket policy for cloudtrail
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param bucket
+     */
+    createBucketPolicyForCloudTrail(id, scope, bucket) {
+        const bucketPolicyDocument = new PolicyDocument({
+            statements: [
+                new PolicyStatement({
+                    actions: ['s3:GetBucketAcl'],
+                    effect: Effect.ALLOW,
+                    principals: [new ServicePrincipal('cloudtrail.amazonaws.com')],
+                    resources: [bucket.bucketArn],
+                    sid: 'AWSCloudTrailAclCheck20150319',
+                }),
+                new PolicyStatement({
+                    actions: ['s3:PutObject'],
+                    effect: Effect.ALLOW,
+                    principals: [new ServicePrincipal('cloudtrail.amazonaws.com')],
+                    resources: [bucket.arnForObjects('*')],
+                    sid: 'AWSCloudTrailWrite20150319',
+                }),
+            ],
+        });
+        return new CfnBucketPolicy(scope, `${id}`, {
+            bucket: bucket.bucketName,
+            policyDocument: bucketPolicyDocument,
+        });
+    }
+    /**
+     * @summary Method to create a s3 bucket deployment
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param siteBucket
+     * @param distribution
+     * @param sources
+     * @param prefix
+     * @param prune
+     */
+    doBucketDeployment(id, scope, siteBucket, distribution, sources, prefix, prune) {
+        new BucketDeployment(scope, `${id}`, {
+            destinationBucket: siteBucket,
+            destinationKeyPrefix: prefix,
+            distribution: distribution,
+            distributionPaths: ['/*'],
+            memoryLimit: 1024,
+            prune: !!prune,
+            serverSideEncryption: ServerSideEncryption.AES_256,
+            sources: sources,
+        });
+    }
+    /**
+     *
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param bucket bucket to create the folders in
+     * @param folders list of folder names to be created in the bucket
+     */
+    createBucketFolders(id, scope, bucket, folders) {
+        if (!folders || folders.length == 0) {
+            throw `Folder unspecified for ${id}`;
+        }
+        _.forEach(folders, folder => {
+            new BucketDeployment(scope, `${id}-${folder}`, {
+                destinationBucket: bucket,
+                destinationKeyPrefix: folder,
+                prune: false,
+                sources: [Source.data('README.md', `This is the ${folder} folder for ${id}`)],
+            });
+        });
+    }
+}

package/dist/src/services/simple-storage-service/types.d.ts

@@ -0,0 +1,25 @@
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as s3deploy from 'aws-cdk-lib/aws-s3-deployment';
+import { TagProps } from '../../types/index.js';
+/**
+ */
+export interface LifecycleRule extends s3.LifecycleRule {
+    expirationInDays?: number;
+    noncurrentVersionExpirationInDays?: number;
+}
+/**
+ */
+export interface BucketDeploymentProps extends s3deploy.BucketDeploymentProps {
+    expirationInDays?: number;
+    noncurrentVersionExpirationInDays?: number;
+}
+/**
+ */
+export interface S3BucketProps extends s3.BucketProps {
+    bucketName: string;
+    enableEventBridge?: boolean;
+    existingBucket?: boolean;
+    lifecycleRules?: LifecycleRule[];
+    logBucketName?: string;
+    tags?: TagProps[];
+}

package/dist/src/services/simple-storage-service/types.js

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

package/dist/src/services/step-function/index.d.ts

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

package/dist/src/services/step-function/index.js

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

package/dist/src/services/step-function/main.d.ts

@@ -0,0 +1,161 @@
+import { IRestApi } from 'aws-cdk-lib/aws-apigateway';
+import { ITable } from 'aws-cdk-lib/aws-dynamodb';
+import { IRole } from 'aws-cdk-lib/aws-iam';
+import { IFunction } from 'aws-cdk-lib/aws-lambda';
+import { ILogGroup } from 'aws-cdk-lib/aws-logs';
+import { IQueue } from 'aws-cdk-lib/aws-sqs';
+import { Choice, Fail, IChainable, IStateMachine, Map, Parallel, Pass, StateMachine, Succeed, Wait } from 'aws-cdk-lib/aws-stepfunctions';
+import { CallApiGatewayRestApiEndpoint, DynamoAttributeValue, DynamoDeleteItem, DynamoGetItem, DynamoPutItem, LambdaInvoke, SqsSendMessage, StepFunctionsStartExecution } from 'aws-cdk-lib/aws-stepfunctions-tasks';
+import { CommonConstruct } from '../../common/index.js';
+import { SfnCallApiGatewayRestApiEndpointProps, SfnChoiceProps, SfnDynamoDeleteItemProps, SfnDynamoGetItemProps, SfnDynamoPutItemProps, SfnFailProps, SfnLambdaInvokeProps, SfnMapProps, SfnParallelProps, SfnPassProps, SfnSqsSendMessageProps, SfnStartExecutionProps, SfnStateMachineProps, SfnSucceedProps, SfnWaitProps } from './types.js';
+/**
+ * @classdesc Provides operations on AWS Step Functions 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: Construct, id: string, props: common.CommonStackProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.sfnManager.createSuccessStep('MyStep', this, myStepProps)
+ *   }
+ * }
+ * @see [CDK Step Functions Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_stepfunctions-readme.html}
+ */
+export declare class SfnManager {
+    /**
+     * @summary Method to create a success step
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     */
+    createSuccessStep(id: string, scope: CommonConstruct, props: SfnSucceedProps): Succeed;
+    /**
+     * @summary Method to create a failure step
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     */
+    createFailStep(id: string, scope: CommonConstruct, props: SfnFailProps): Fail;
+    /**
+     * @summary Method to create a pass step
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     */
+    createPassStep(id: string, scope: CommonConstruct, props: SfnPassProps): Pass;
+    /**
+     * @summary Method to create a parallel step
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     */
+    createParallelStep(id: string, scope: CommonConstruct, props: SfnParallelProps): Parallel;
+    /**
+     * @summary Method to create a choice step
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     */
+    createChoiceStep(id: string, scope: CommonConstruct, props: SfnChoiceProps): Choice;
+    /**
+     * @summary Method to create a wait step
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     */
+    createWaitStep(id: string, scope: CommonConstruct, props: SfnWaitProps): Wait;
+    /**
+     * @summary Method to create a DynamoDB get item step
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param table The table to get the item from
+     * @param tableKey The table key for query/scan
+     */
+    createDynamoDbGetItemStep(id: string, scope: CommonConstruct, props: SfnDynamoGetItemProps, table: ITable, tableKey: {
+        [key: string]: DynamoAttributeValue;
+    }): DynamoGetItem;
+    /**
+     * @summary Method to create a DynamoDB put item step
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param table The table to put the item in
+     * @param tableItem The item to add to the table
+     */
+    createDynamoDbPutItemStep(id: string, scope: CommonConstruct, props: SfnDynamoPutItemProps, table: ITable, tableItem: {
+        [key: string]: DynamoAttributeValue;
+    }): DynamoPutItem;
+    /**
+     * @summary Method to create a DynamoDB delete item step
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param table The table to put the item in
+     * @param tableKey The table key for query/scan
+     */
+    createDynamoDbDeleteItemStep(id: string, scope: CommonConstruct, props: SfnDynamoDeleteItemProps, table: ITable, tableKey: {
+        [key: string]: DynamoAttributeValue;
+    }): DynamoDeleteItem;
+    /**
+     * @summary Method to send a message to SQS step
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param queue The queue to send the message to
+     */
+    createSendSqsMessageStep(id: string, scope: CommonConstruct, props: SfnSqsSendMessageProps, queue: IQueue): SqsSendMessage;
+    /**
+     * @summary Method to create a lambda invoke step
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param lambdaFunction
+     */
+    createLambdaStep(id: string, scope: CommonConstruct, props: SfnLambdaInvokeProps, lambdaFunction: IFunction): LambdaInvoke;
+    /**
+     * @summary Method to create a lambda invoke step
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param lambdaFunction
+     * @param skipExecution
+     */
+    createSkippableLambdaStep(id: string, scope: CommonConstruct, props: SfnLambdaInvokeProps, lambdaFunction: IFunction, skipExecution?: boolean): Pass | LambdaInvoke;
+    /**
+     * @summary Method to create a API Gateway invoke step
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param api
+     */
+    createApiStep(id: string, scope: CommonConstruct, props: SfnCallApiGatewayRestApiEndpointProps, api: IRestApi): CallApiGatewayRestApiEndpoint;
+    /**
+     * @summary Method to create a step function execution step
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props props for the step
+     * @param stateMachine the state machine to execute
+     */
+    createSfnExecutionStep(id: string, scope: CommonConstruct, props: SfnStartExecutionProps, stateMachine: IStateMachine): StepFunctionsStartExecution;
+    /**
+     * @summary Method to create a step function map state
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props props for the map state
+     */
+    createMapState(id: string, scope: CommonConstruct, props: SfnMapProps): Map;
+    /**
+     * @summary Method to create a state machine
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param definition
+     * @param logGroup
+     * @param role
+     */
+    createStateMachine(id: string, scope: CommonConstruct, props: SfnStateMachineProps, definition: IChainable, logGroup: ILogGroup, role?: IRole): StateMachine;
+}