@gradientedge/cdk-utils-aws 1.0.0

package/dist/src/construct/piped-event-handler/types.d.ts

@@ -0,0 +1,9 @@
+import { QueueProps } from 'aws-cdk-lib/aws-sqs';
+import { SqsToLambdaPipeProps, SqsToSfnPipeProps } from '../../services/index.js';
+import { EventHandlerProps } from '../event-handler/index.js';
+export interface PipedEventHandlerProps extends EventHandlerProps {
+    pipedDlq: QueueProps;
+    pipedQueue: QueueProps;
+    sqsToLambdaPipe: SqsToLambdaPipeProps;
+    sqsToSfnPipe: SqsToSfnPipeProps;
+}

package/dist/src/construct/piped-event-handler/types.js

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

package/dist/src/construct/rest-api-lambda/index.d.ts

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

package/dist/src/construct/rest-api-lambda/index.js

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

package/dist/src/construct/rest-api-lambda/main.d.ts

@@ -0,0 +1,96 @@
+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 { IFunction, ILayerVersion } 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/index.js';
+import { RestApiLambdaEnvironment, RestApiLambdaProps } from './types.js';
+/**
+ * @classdesc Provides a construct to create and deploy a RestApi as Lambda
+ *
+ * <b>Architecture</b><br/> ![Architecture](./RestApiLambda.jpg)
+ * @example
+ * import { RestApiLambda, RestApiLambdaProps } '@gradientedge/cdk-utils'
+ * import { Construct } from 'constructs'
+ *
+ * class CustomConstruct extends RestApiLambda {
+ *   constructor(parent: Construct, id: string, props: RestApiLambdaProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.id = id
+ *     this.initResources()
+ *   }
+ * }
+ */
+export declare abstract class RestApiLambda extends CommonConstruct {
+    props: RestApiLambdaProps;
+    id: string;
+    applicationSecrets: ISecret[];
+    restApiLambdaPolicy: PolicyDocument;
+    restApiLambdaRole: Role;
+    restApiLambdaEnvironment: RestApiLambdaEnvironment;
+    restApiLambdaLayers: ILayerVersion[];
+    restApiLambdaFunction: IFunction;
+    restApi: RestApi;
+    restApiHostedZone: IHostedZone;
+    restApiCertificate: ICertificate;
+    restApiDomain: DomainName;
+    restApiBasePathMappings: BasePathMapping[];
+    protected constructor(parent: Construct, id: string, props: RestApiLambdaProps);
+    /**
+     * @summary Initialise and provision resources
+     */
+    initResources(): void;
+    /**
+     * @summary Method to resolve secrets from SecretsManager
+     * - To be implemented in the overriding method in the implementation class
+     */
+    protected resolveSecrets(): void;
+    /**
+     * @summary Method to resolve a hosted zone based on domain attributes
+     */
+    protected resolveHostedZone(): void;
+    /**
+     * @summary Method to resolve a certificate based on attributes
+     */
+    protected resolveCertificate(): void;
+    /**
+     * @summary Method to create iam policy for RestApi Lambda function
+     */
+    protected createLambdaPolicy(): void;
+    /**
+     * @summary Method to create iam role for RestApi Lambda function
+     */
+    protected createLambdaRole(): void;
+    /**
+     * @summary Method to create environment variables for RestApi Lambda function
+     */
+    protected createLambdaEnvironment(): void;
+    /**
+     * @summary Method to create layers for RestApi Lambda function
+     */
+    protected createLambdaLayers(): void;
+    /**
+     * @summary Method to create lambda function for RestApi
+     */
+    protected createLambdaFunction(): void;
+    /**
+     * @summary Method to create rest restApiLambda for RestApi
+     */
+    protected createRestApi(): void;
+    protected abstract createRestApiResources(): void;
+    /**
+     * @summary Method to create custom restApiLambda domain for RestApi
+     */
+    protected createApiDomain(): void;
+    /**
+     * @summary Method to create base path mappings for RestApi
+     */
+    protected createApiBasePathMapping(): void;
+    /**
+     * @summary Method to create route53 records for RestApi
+     */
+    protected createApiRouteAssets(): void;
+}

package/dist/src/construct/rest-api-lambda/main.js

@@ -0,0 +1,170 @@
+import { BasePathMapping } from 'aws-cdk-lib/aws-apigateway';
+import { PolicyDocument } from 'aws-cdk-lib/aws-iam';
+import _ from 'lodash';
+import { CommonConstruct } from '../../common/index.js';
+/**
+ * @classdesc Provides a construct to create and deploy a RestApi as Lambda
+ *
+ * <b>Architecture</b><br/> ![Architecture](./RestApiLambda.jpg)
+ * @example
+ * import { RestApiLambda, RestApiLambdaProps } '@gradientedge/cdk-utils'
+ * import { Construct } from 'constructs'
+ *
+ * class CustomConstruct extends RestApiLambda {
+ *   constructor(parent: Construct, id: string, props: RestApiLambdaProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.id = id
+ *     this.initResources()
+ *   }
+ * }
+ */
+export class RestApiLambda extends CommonConstruct {
+    /* restApiLambda props */
+    props;
+    id;
+    /* restApiLambda resources */
+    applicationSecrets;
+    restApiLambdaPolicy;
+    restApiLambdaRole;
+    restApiLambdaEnvironment;
+    restApiLambdaLayers = [];
+    restApiLambdaFunction;
+    restApi;
+    restApiHostedZone;
+    restApiCertificate;
+    restApiDomain;
+    restApiBasePathMappings = [];
+    constructor(parent, id, props) {
+        super(parent, id, props);
+        this.props = props;
+        this.id = id;
+    }
+    /**
+     * @summary Initialise and provision resources
+     */
+    initResources() {
+        this.resolveSecrets();
+        this.resolveHostedZone();
+        this.resolveCertificate();
+        this.createLambdaPolicy();
+        this.createLambdaRole();
+        this.createLambdaEnvironment();
+        this.createLambdaLayers();
+        this.createLambdaFunction();
+        this.createRestApi();
+        this.createRestApiResources();
+        this.createApiDomain();
+        this.createApiBasePathMapping();
+        this.createApiRouteAssets();
+    }
+    /**
+     * @summary Method to resolve secrets from SecretsManager
+     * - To be implemented in the overriding method in the implementation class
+     */
+    resolveSecrets() {
+        this.applicationSecrets = [];
+    }
+    /**
+     * @summary Method to resolve a hosted zone based on domain attributes
+     */
+    resolveHostedZone() {
+        this.restApiHostedZone = this.route53Manager.withHostedZoneFromFullyQualifiedDomainName(`${this.id}-hosted-zone`, this, this.props.useExistingHostedZone);
+    }
+    /**
+     * @summary Method to resolve a certificate based on attributes
+     */
+    resolveCertificate() {
+        if (this.props.restApiCertificate.useExistingCertificate &&
+            this.props.restApiCertificate.certificateSsmName &&
+            this.props.restApiCertificate.certificateRegion) {
+            this.props.restApiCertificate.certificateArn = this.ssmManager.readStringParameterFromRegion(`${this.id}-certificate-param`, this, this.props.restApiCertificate.certificateSsmName, this.props.restApiCertificate.certificateRegion);
+        }
+        this.restApiCertificate = this.acmManager.resolveCertificate(`${this.id}-certificate`, this, this.props.restApiCertificate);
+    }
+    /**
+     * @summary Method to create iam policy for RestApi Lambda function
+     */
+    createLambdaPolicy() {
+        this.restApiLambdaPolicy = new PolicyDocument({
+            statements: [this.iamManager.statementForCreateAnyLogStream()],
+        });
+    }
+    /**
+     * @summary Method to create iam role for RestApi Lambda function
+     */
+    createLambdaRole() {
+        this.restApiLambdaRole = this.iamManager.createRoleForLambda(`${this.id}-lambda-role`, this, this.restApiLambdaPolicy);
+    }
+    /**
+     * @summary Method to create environment variables for RestApi Lambda function
+     */
+    createLambdaEnvironment() {
+        this.restApiLambdaEnvironment = {
+            LOG_LEVEL: this.props.logLevel,
+            NODE_ENV: this.props.nodeEnv,
+            TZ: this.props.timezone,
+        };
+    }
+    /**
+     * @summary Method to create layers for RestApi Lambda function
+     */
+    createLambdaLayers() {
+        const layers = [];
+        if (!this.props.restApiLambdaLayerSources)
+            return;
+        _.forEach(this.props.restApiLambdaLayerSources, (source, index) => {
+            layers.push(this.lambdaManager.createLambdaLayer(`${this.id}-layer-${index}`, this, source));
+        });
+        this.restApiLambdaLayers = layers;
+    }
+    /**
+     * @summary Method to create lambda function for RestApi
+     */
+    createLambdaFunction() {
+        this.restApiLambdaFunction = this.lambdaManager.createLambdaFunction(`${this.id}-restapi-server`, this, this.props.restApiLambda, this.restApiLambdaRole, this.restApiLambdaLayers, this.props.restApiSource, this.props.restApiHandler || 'index.handler', this.restApiLambdaEnvironment);
+    }
+    /**
+     * @summary Method to create rest restApiLambda for RestApi
+     */
+    createRestApi() {
+        this.restApi = this.apiManager.createLambdaRestApi(`${this.id}-lambda-rest-api`, this, this.props.restApi, this.restApiLambdaFunction);
+    }
+    /**
+     * @summary Method to create custom restApiLambda domain for RestApi
+     */
+    createApiDomain() {
+        this.restApiDomain = this.apiManager.createApiDomain(`${this.id}-api-domain`, this, this.isProductionStage() || this.props.skipStageForARecords
+            ? `${this.props.apiSubDomain}.${this.fullyQualifiedDomainName}`
+            : `${this.props.apiSubDomain}-${this.props.stage}.${this.fullyQualifiedDomainName}`, this.restApiCertificate);
+    }
+    /**
+     * @summary Method to create base path mappings for RestApi
+     */
+    createApiBasePathMapping() {
+        const apiRootPaths = this.props.apiRootPaths;
+        if (apiRootPaths && !_.isEmpty(apiRootPaths)) {
+            _.forEach(apiRootPaths, (apiRootPath) => {
+                this.restApiBasePathMappings.push(new BasePathMapping(this, `${this.id}-base-bath-mapping-${apiRootPath}`, {
+                    basePath: apiRootPath,
+                    domainName: this.restApiDomain,
+                    restApi: this.restApi,
+                    stage: this.restApi.deploymentStage,
+                }));
+            });
+            return;
+        }
+        // add default mapping if apiRootPaths not set
+        new BasePathMapping(this, `${this.id}-base-bath-mapping`, {
+            domainName: this.restApiDomain,
+            restApi: this.restApi,
+            stage: this.restApi.deploymentStage,
+        });
+    }
+    /**
+     * @summary Method to create route53 records for RestApi
+     */
+    createApiRouteAssets() {
+        this.route53Manager.createApiGatewayARecord(`${this.id}-custom-domain-a-record`, this, this.props.apiSubDomain, this.restApiDomain, this.restApiHostedZone, this.props.skipStageForARecords);
+    }
+}

package/dist/src/construct/rest-api-lambda/types.d.ts

@@ -0,0 +1,23 @@
+import { AcmProps, LambdaEnvironment, LambdaProps, LambdaRestApiProps } from '../../services/index.js';
+import { CommonStackProps } from '../../common/index.js';
+import { AssetCode } from 'aws-cdk-lib/aws-lambda';
+/**
+ */
+export interface RestApiLambdaEnvironment extends LambdaEnvironment {
+}
+/**
+ */
+export interface RestApiLambdaProps extends CommonStackProps {
+    apiRootPaths?: string[];
+    apiSubDomain: string;
+    logLevel: string;
+    nodeEnv: string;
+    restApi: LambdaRestApiProps;
+    restApiCertificate: AcmProps;
+    restApiHandler: string;
+    restApiLambda: LambdaProps;
+    restApiLambdaLayerSources?: AssetCode[];
+    restApiSource: AssetCode;
+    timezone: string;
+    useExistingHostedZone: boolean;
+}

package/dist/src/construct/rest-api-lambda/types.js

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

package/dist/src/construct/rest-api-lambda-with-cache/index.d.ts

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

package/dist/src/construct/rest-api-lambda-with-cache/index.js

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

package/dist/src/construct/rest-api-lambda-with-cache/main.d.ts

@@ -0,0 +1,56 @@
+import { ISecurityGroup, IVpc } from 'aws-cdk-lib/aws-ec2';
+import { CfnReplicationGroup } from 'aws-cdk-lib/aws-elasticache';
+import { Construct } from 'constructs';
+import { RestApiLambdaWithCacheProps } from './types.js';
+import { RestApiLambda } from '../rest-api-lambda/index.js';
+/**
+ * @classdesc Provides a construct to create and deploy a RestApi API as Lambda with Caching
+ *
+ * <b>Architecture</b><br/> ![Architecture](./RestApiLambda.jpg)
+ * @example
+ * import { RestApiLambdaWithCacheProps } '@gradientedge/cdk-utils'
+ * import { Construct } from 'constructs'
+ *
+ * class CustomConstruct extends RestApiLambdaWithCache {
+ *   constructor(parent: Construct, id: string, props: RestApiLambdaWithCacheProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.id = id
+ *     this.initResources()
+ *   }
+ * }
+ */
+export declare abstract class RestApiLambdaWithCache extends RestApiLambda {
+    props: RestApiLambdaWithCacheProps;
+    id: string;
+    restApivpc: IVpc;
+    restApiCache: CfnReplicationGroup;
+    restApiSecurityGroup: ISecurityGroup;
+    restApiSecurityGroupExportName: string;
+    protected constructor(parent: Construct, id: string, props: RestApiLambdaWithCacheProps);
+    initResources(): void;
+    /**
+     * Create VPC
+     */
+    protected resolveVpc(): void;
+    /**
+     * Resolve Security Group
+     */
+    protected resolveSecurityGroup(): void;
+    /**
+     * Create ElastiCache
+     */
+    protected createElastiCache(): void;
+    /**
+     * Create Lambda Role
+     */
+    protected createLambdaRole(): void;
+    /**
+     * @summary Method to create environment variables for RestApi Lambda function
+     */
+    protected createLambdaEnvironment(): void;
+    /**
+     * @summary Method to create lambda function for RestApi API
+     */
+    protected createLambdaFunction(): void;
+}

package/dist/src/construct/rest-api-lambda-with-cache/main.js

@@ -0,0 +1,118 @@
+import { Fn } from 'aws-cdk-lib';
+import { Peer, Port, SecurityGroup } from 'aws-cdk-lib/aws-ec2';
+import { ManagedPolicy } from 'aws-cdk-lib/aws-iam';
+import _ from 'lodash';
+import { createCfnOutput } from '../../utils/index.js';
+import { RestApiLambda } from '../rest-api-lambda/index.js';
+/**
+ * @classdesc Provides a construct to create and deploy a RestApi API as Lambda with Caching
+ *
+ * <b>Architecture</b><br/> ![Architecture](./RestApiLambda.jpg)
+ * @example
+ * import { RestApiLambdaWithCacheProps } '@gradientedge/cdk-utils'
+ * import { Construct } from 'constructs'
+ *
+ * class CustomConstruct extends RestApiLambdaWithCache {
+ *   constructor(parent: Construct, id: string, props: RestApiLambdaWithCacheProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.id = id
+ *     this.initResources()
+ *   }
+ * }
+ */
+export class RestApiLambdaWithCache extends RestApiLambda {
+    /* restApiLambdaWithCache props */
+    props;
+    id;
+    /* restApiLambda resources */
+    restApivpc;
+    restApiCache;
+    restApiSecurityGroup;
+    restApiSecurityGroupExportName;
+    constructor(parent, id, props) {
+        super(parent, id, props);
+        this.props = props;
+        this.id = id;
+    }
+    initResources() {
+        this.resolveVpc();
+        this.resolveSecurityGroup();
+        this.createElastiCache();
+        super.initResources();
+    }
+    /**
+     * Create VPC
+     */
+    resolveVpc() {
+        if (this.props.useExistingVpc) {
+            this.restApivpc = this.vpcManager.retrieveCommonVpc(`${this.id}-vpc`, this, this.props.vpcName);
+        }
+        else {
+            this.restApivpc = this.vpcManager.createCommonVpc(`${this.id}-vpc`, this, this.props.restApiVpc, this.props.restApiVpc.vpcName);
+        }
+    }
+    /**
+     * Resolve Security Group
+     */
+    resolveSecurityGroup() {
+        if (this.props.securityGroupExportName) {
+            this.restApiSecurityGroup = SecurityGroup.fromSecurityGroupId(this, `${this.id}-security-group`, Fn.importValue(this.props.securityGroupExportName));
+        }
+        else {
+            this.restApiSecurityGroup = new SecurityGroup(this, `${this.id}-security-group-${this.props.stage}`, {
+                securityGroupName: `${this.id}-security-group-${this.props.stage}`,
+                vpc: this.restApivpc,
+            });
+            if (this.props.restApiVpc.isIPV6) {
+                this.restApiSecurityGroup.addIngressRule(Peer.anyIpv6(), Port.allTraffic(), 'All Traffic');
+            }
+            else {
+                this.restApiSecurityGroup.addIngressRule(Peer.anyIpv4(), Port.allTraffic(), 'All Traffic');
+            }
+            createCfnOutput(`${this.id}-security-group-id`, this, this.restApiSecurityGroup.securityGroupId);
+        }
+    }
+    /**
+     * Create ElastiCache
+     */
+    createElastiCache() {
+        if (!this.props.restApiCache) {
+            return;
+        }
+        this.restApiCache = this.elasticacheManager.createReplicatedElastiCache(`${this.id}-elasticache`, this, this.props.restApiCache, _.map(this.restApivpc.privateSubnets, subnet => subnet.subnetId), [this.restApiSecurityGroup.securityGroupId]);
+        this.ssmManager.writeStringToParameters(`${this.id}-elasticache-endpoint-address`, this, {
+            description: `Elasticache address to use by applications`,
+            parameterName: `${this.id}-elasticache-endpoint-address`,
+            stringValue: this.restApiCache.attrConfigurationEndPointAddress,
+        });
+        this.ssmManager.writeStringToParameters(`${this.id}-elasticache-endpoint-port`, this, {
+            description: `Elasticache port to use by applications`,
+            parameterName: `${this.id}-elasticache-endpoint-port`,
+            stringValue: this.restApiCache.attrConfigurationEndPointPort,
+        });
+    }
+    /**
+     * Create Lambda Role
+     */
+    createLambdaRole() {
+        super.createLambdaRole();
+        this.restApiLambdaRole.addManagedPolicy(ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaVPCAccessExecutionRole'));
+    }
+    /**
+     * @summary Method to create environment variables for RestApi Lambda function
+     */
+    createLambdaEnvironment() {
+        this.restApiLambdaEnvironment = {
+            LOG_LEVEL: this.props.logLevel,
+            NODE_ENV: this.props.nodeEnv,
+            TZ: this.props.timezone,
+        };
+    }
+    /**
+     * @summary Method to create lambda function for RestApi API
+     */
+    createLambdaFunction() {
+        this.restApiLambdaFunction = this.lambdaManager.createLambdaFunction(`${this.id}-restapi-server`, this, this.props.restApiLambda, this.restApiLambdaRole, this.restApiLambdaLayers, this.props.restApiSource, this.props.restApiHandler || 'index.handler', this.restApiLambdaEnvironment, this.restApivpc, [this.restApiSecurityGroup], undefined, undefined, this.restApivpc);
+    }
+}

package/dist/src/construct/rest-api-lambda-with-cache/types.d.ts

@@ -0,0 +1,11 @@
+import { RestApiLambdaProps } from '../rest-api-lambda/index.js';
+import { ReplicatedElastiCacheProps, VpcProps } from '../../services/index.js';
+/**
+ */
+export interface RestApiLambdaWithCacheProps extends RestApiLambdaProps {
+    restApiCache: ReplicatedElastiCacheProps;
+    restApiVpc: VpcProps;
+    securityGroupExportName: string;
+    useExistingVpc: boolean;
+    vpcName?: string;
+}

package/dist/src/construct/rest-api-lambda-with-cache/types.js

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

package/dist/src/construct/site-with-ecs-backend/constants.d.ts

@@ -0,0 +1,4 @@
+export declare enum SiteResponseHeaderPolicyType {
+    ORIGIN = "origin",
+    STATIC = "static"
+}

package/dist/src/construct/site-with-ecs-backend/constants.js

@@ -0,0 +1,5 @@
+export var SiteResponseHeaderPolicyType;
+(function (SiteResponseHeaderPolicyType) {
+    SiteResponseHeaderPolicyType["ORIGIN"] = "origin";
+    SiteResponseHeaderPolicyType["STATIC"] = "static";
+})(SiteResponseHeaderPolicyType || (SiteResponseHeaderPolicyType = {}));

package/dist/src/construct/site-with-ecs-backend/index.d.ts

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

package/dist/src/construct/site-with-ecs-backend/index.js

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