@gradientedge/cdk-utils-aws 1.0.0

package/dist/src/services/key-management-service/main.d.ts

@@ -0,0 +1,28 @@
+import { Key } from 'aws-cdk-lib/aws-kms';
+import { CommonConstruct } from '../../common/index.js';
+import { KmsKeyProps } from './types.js';
+/**
+ * @classdesc Provides operations on AWS KMS.
+ * - 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.kms.createKey('MyKey', this)
+ *   }
+ * }
+ * @see [CDK KMS Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kms-readme.html}
+ */
+export declare class KmsManager {
+    /**
+     * @summary Method to create a KMS key
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props KMS key props
+     */
+    createKey(id: string, scope: CommonConstruct, props: KmsKeyProps): Key;
+}

package/dist/src/services/key-management-service/main.js

@@ -0,0 +1,39 @@
+import { Key } from 'aws-cdk-lib/aws-kms';
+import { createCfnOutput } from '../../utils/index.js';
+/**
+ * @classdesc Provides operations on AWS KMS.
+ * - 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.kms.createKey('MyKey', this)
+ *   }
+ * }
+ * @see [CDK KMS Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kms-readme.html}
+ */
+export class KmsManager {
+    /**
+     * @summary Method to create a KMS key
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props KMS key props
+     */
+    createKey(id, scope, props) {
+        if (!props)
+            throw `KMS Key props undefined for ${id}`;
+        if (!props.alias)
+            throw `KMS Key alias undefined for ${id}`;
+        const key = new Key(scope, `${id}`, {
+            ...props,
+            alias: scope.resourceNameFormatter.format(props.alias, scope.props.resourceNameOptions?.kms),
+        });
+        createCfnOutput(`${id}-keyId`, scope, key.keyId);
+        createCfnOutput(`${id}-keyArn`, scope, key.keyArn);
+        return key;
+    }
+}

package/dist/src/services/key-management-service/types.d.ts

@@ -0,0 +1,5 @@
+import { KeyProps } from 'aws-cdk-lib/aws-kms';
+/**
+ */
+export interface KmsKeyProps extends KeyProps {
+}

package/dist/src/services/key-management-service/types.js

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

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

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

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

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

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

@@ -0,0 +1,89 @@
+import { experimental } from 'aws-cdk-lib/aws-cloudfront';
+import { ISecurityGroup, IVpc, SubnetSelection } from 'aws-cdk-lib/aws-ec2';
+import { IAccessPoint } from 'aws-cdk-lib/aws-efs';
+import { CfnRole, Role } from 'aws-cdk-lib/aws-iam';
+import { Alias, Architecture, AssetCode, DockerImageCode, DockerImageFunction, Function, ILayerVersion, IVersion, LayerVersion } from 'aws-cdk-lib/aws-lambda';
+import { CommonConstruct } from '../../common/index.js';
+import { LambdaAliasProps, LambdaEdgeProps, LambdaProps } from './types.js';
+/**
+ * @classdesc Provides operations on AWS Lambda
+ * - 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.lambdaManager.createLambdaFunction('MyFunction', this, role, layers, code)
+ *   }
+ * }
+ * @see [CDK Lambda Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html}
+ */
+export declare class LambdaManager {
+    /**
+     * @summary Method to create a lambda layer (nodejs)
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param code
+     * @param architectures
+     */
+    createLambdaLayer(id: string, scope: CommonConstruct, code: AssetCode, architectures?: Architecture[]): LayerVersion;
+    createWebAdapterLayer(id: string, scope: CommonConstruct): ILayerVersion[];
+    /**
+     * @summary Method to create a lambda function (nodejs)
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param role
+     * @param layers
+     * @param code
+     * @param handler
+     * @param environment
+     * @param vpc
+     * @param securityGroups
+     * @param accessPoint
+     * @param mountPath
+     * @param vpcSubnets
+     */
+    createLambdaFunction(id: string, scope: CommonConstruct, props: LambdaProps, role: Role | CfnRole, layers: ILayerVersion[], code: AssetCode, handler?: string, environment?: any, vpc?: IVpc, securityGroups?: ISecurityGroup[], accessPoint?: IAccessPoint, mountPath?: string, vpcSubnets?: SubnetSelection): Function;
+    /**
+     * @summary Method to provision a Lambda@Edge function
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props lambda@edge properties
+     * @param layers
+     * @param code
+     * @param role
+     * @param environment
+     * @param vpc
+     * @param securityGroups
+     * @param accessPoint
+     * @param mountPath
+     */
+    createEdgeFunction(id: string, scope: CommonConstruct, props: LambdaEdgeProps, layers: ILayerVersion[], code: AssetCode, role: Role, environment?: any, vpc?: IVpc, securityGroups?: ISecurityGroup[], accessPoint?: IAccessPoint, mountPath?: string): experimental.EdgeFunction;
+    /**
+     * @summary Method to create a lambda function (nodejs) with docker image
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param role
+     * @param code
+     * @param environment
+     * @param vpc
+     * @param securityGroups
+     * @param accessPoint
+     * @param mountPath
+     * @param vpcSubnets
+     */
+    createLambdaDockerFunction(id: string, scope: CommonConstruct, props: LambdaProps, role: Role | CfnRole, code: DockerImageCode, environment?: any, vpc?: IVpc, securityGroups?: ISecurityGroup[], accessPoint?: IAccessPoint, mountPath?: string, vpcSubnets?: SubnetSelection): DockerImageFunction;
+    /**
+     * @summary Method to create a lambda function Alias
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param lambdaVersion
+     */
+    createLambdaFunctionAlias(id: string, scope: CommonConstruct, props: LambdaAliasProps, lambdaVersion: IVersion): Alias;
+}

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

@@ -0,0 +1,232 @@
+import { Duration, RemovalPolicy, Tags } from 'aws-cdk-lib';
+import { Role } from 'aws-cdk-lib/aws-iam';
+import { Alias, Architecture, DockerImageFunction, FileSystem, Function, LayerVersion, } from 'aws-cdk-lib/aws-lambda';
+import { SqsEventSource } from 'aws-cdk-lib/aws-lambda-event-sources';
+import _ from 'lodash';
+import { CommonStack } from '../../common/index.js';
+import { createCfnOutput } from '../../utils/index.js';
+import { CloudFrontManager } from '../cloudfront/index.js';
+/**
+ * @classdesc Provides operations on AWS Lambda
+ * - 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.lambdaManager.createLambdaFunction('MyFunction', this, role, layers, code)
+ *   }
+ * }
+ * @see [CDK Lambda Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html}
+ */
+export class LambdaManager {
+    /**
+     * @summary Method to create a lambda layer (nodejs)
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param code
+     * @param architectures
+     */
+    createLambdaLayer(id, scope, code, architectures) {
+        const lambdaLayer = new LayerVersion(scope, `${id}`, {
+            code: code,
+            compatibleArchitectures: architectures ?? [Architecture.ARM_64],
+            compatibleRuntimes: [scope.props.nodejsRuntime ?? CommonStack.NODEJS_RUNTIME],
+            description: `${id}`,
+            layerVersionName: scope.resourceNameFormatter.format(id, scope.props.resourceNameOptions?.lambdaLayer),
+        });
+        createCfnOutput(`${id}-lambdaLayerArn`, scope, lambdaLayer.layerVersionArn);
+        return lambdaLayer;
+    }
+    createWebAdapterLayer(id, scope) {
+        return [
+            LayerVersion.fromLayerVersionArn(scope, `${id}-${Architecture.X86_64}`, `arn:aws:lambda:${scope.props.region}:753240598075:layer:LambdaAdapterLayerX86:17`),
+            LayerVersion.fromLayerVersionArn(scope, `${id}-${Architecture.ARM_64}`, `arn:aws:lambda:${scope.props.region}:753240598075:layer:LambdaAdapterLayerArm64:17`),
+        ];
+    }
+    /**
+     * @summary Method to create a lambda function (nodejs)
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param role
+     * @param layers
+     * @param code
+     * @param handler
+     * @param environment
+     * @param vpc
+     * @param securityGroups
+     * @param accessPoint
+     * @param mountPath
+     * @param vpcSubnets
+     */
+    createLambdaFunction(id, scope, props, role, layers, code, handler, environment, vpc, securityGroups, accessPoint, mountPath, vpcSubnets) {
+        if (!props)
+            throw `Lambda props undefined for ${id}`;
+        if (!props.functionName)
+            throw `Lambda functionName undefined for ${id}`;
+        const functionName = scope.resourceNameFormatter.format(props.functionName, scope.props.resourceNameOptions?.lambdaFunction);
+        let deadLetterQueue;
+        if (props.deadLetterQueueEnabled) {
+            const redriveQueue = scope.sqsManager.createRedriveQueueForLambda(`${id}-rdq`, scope, props);
+            deadLetterQueue = scope.sqsManager.createDeadLetterQueueForLambda(`${id}-dlq`, scope, props, redriveQueue);
+        }
+        const lambdaFunction = new Function(scope, `${id}`, {
+            ...props,
+            allowPublicSubnet: !!vpc,
+            architecture: props.architecture ?? Architecture.ARM_64,
+            code,
+            deadLetterQueue,
+            environment: {
+                LOG_LEVEL: props.logLevel,
+                REGION: scope.props.region,
+                STAGE: scope.props.stage,
+                ...environment,
+            },
+            filesystem: accessPoint ? FileSystem.fromEfsAccessPoint(accessPoint, mountPath || '/mnt/msg') : undefined,
+            functionName,
+            handler: handler || 'index.lambda_handler',
+            layers,
+            logGroup: scope.logManager.createLogGroup(`${id}-log-group`, scope, {
+                logGroupName: functionName,
+                removalPolicy: RemovalPolicy.DESTROY,
+                retention: scope.props.logRetention ?? props.logRetentionInDays,
+            }),
+            reservedConcurrentExecutions: props.reservedConcurrentExecutions ?? scope.props.defaultReservedLambdaConcurrentExecutions,
+            role: role instanceof Role ? role : undefined,
+            runtime: props.runtime ?? scope.props.nodejsRuntime ?? CommonStack.NODEJS_RUNTIME,
+            securityGroups,
+            timeout: props.timeoutInSecs ? Duration.seconds(props.timeoutInSecs) : Duration.minutes(15),
+            tracing: scope.props.defaultTracing ?? props.tracing,
+            vpc,
+            vpcSubnets,
+        });
+        if (lambdaFunction.deadLetterQueue && props.dlq?.retriesEnabled) {
+            lambdaFunction.addEventSource(new SqsEventSource(lambdaFunction.deadLetterQueue, {
+                batchSize: props.dlq.retryBatchSize ?? 1,
+                reportBatchItemFailures: true,
+            }));
+        }
+        if (props.lambdaAliases && !_.isEmpty(props.lambdaAliases)) {
+            props.lambdaAliases.forEach(alias => {
+                const aliasId = alias.id ?? `${id}-${alias.aliasName}`;
+                const functionAlias = this.createLambdaFunctionAlias(`${aliasId}`, scope, alias, lambdaFunction.currentVersion);
+                createCfnOutput(`${id}-${alias.aliasName}AliasArn`, scope, functionAlias.functionArn);
+                createCfnOutput(`${id}-${alias.aliasName}AliasName`, scope, functionAlias.aliasName);
+                if (alias.provisionedConcurrency) {
+                    const functionAutoScaling = functionAlias.addAutoScaling(alias.provisionedConcurrency);
+                    functionAutoScaling.scaleOnUtilization({
+                        utilizationTarget: alias.provisionedConcurrency.utilizationTarget,
+                    });
+                }
+            });
+        }
+        if (props.tags && !_.isEmpty(props.tags)) {
+            _.forEach(props.tags, tag => {
+                Tags.of(lambdaFunction).add(tag.key, tag.value);
+            });
+        }
+        createCfnOutput(`${id}-lambdaArn`, scope, lambdaFunction.functionArn);
+        createCfnOutput(`${id}-lambdaName`, scope, lambdaFunction.functionName);
+        return lambdaFunction;
+    }
+    /**
+     * @summary Method to provision a Lambda@Edge function
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props lambda@edge properties
+     * @param layers
+     * @param code
+     * @param role
+     * @param environment
+     * @param vpc
+     * @param securityGroups
+     * @param accessPoint
+     * @param mountPath
+     */
+    createEdgeFunction(id, scope, props, layers, code, role, environment, vpc, securityGroups, accessPoint, mountPath) {
+        return new CloudFrontManager().createEdgeFunction(id, scope, props, layers, code, role, environment, vpc, securityGroups, accessPoint, mountPath);
+    }
+    /**
+     * @summary Method to create a lambda function (nodejs) with docker image
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param role
+     * @param code
+     * @param environment
+     * @param vpc
+     * @param securityGroups
+     * @param accessPoint
+     * @param mountPath
+     * @param vpcSubnets
+     */
+    createLambdaDockerFunction(id, scope, props, role, code, environment, vpc, securityGroups, accessPoint, mountPath, vpcSubnets) {
+        if (!props)
+            throw `Lambda props undefined for ${id}`;
+        if (!props.functionName)
+            throw `Lambda functionName undefined for ${id}`;
+        const functionName = scope.resourceNameFormatter.format(props.functionName, scope.props.resourceNameOptions?.lambdaFunction);
+        let deadLetterQueue;
+        if (props.deadLetterQueueEnabled) {
+            const redriveQueue = scope.sqsManager.createRedriveQueueForLambda(`${id}-rdq`, scope, props);
+            deadLetterQueue = scope.sqsManager.createDeadLetterQueueForLambda(`${id}-dlq`, scope, props, redriveQueue);
+        }
+        const lambdaFunction = new DockerImageFunction(scope, `${id}`, {
+            ...props,
+            allowPublicSubnet: !!vpc,
+            architecture: props.architecture ?? Architecture.ARM_64,
+            code,
+            deadLetterQueue,
+            environment: {
+                LOG_LEVEL: props.logLevel,
+                REGION: scope.props.region,
+                STAGE: scope.props.stage,
+                ...environment,
+            },
+            filesystem: accessPoint ? FileSystem.fromEfsAccessPoint(accessPoint, mountPath || '/mnt/msg') : undefined,
+            functionName,
+            logGroup: scope.logManager.createLogGroup(`${id}-log-group`, scope, {
+                logGroupName: functionName,
+                removalPolicy: RemovalPolicy.DESTROY,
+                retention: scope.props.logRetention ?? props.logRetentionInDays,
+            }),
+            role: role instanceof Role ? role : undefined,
+            securityGroups: securityGroups,
+            timeout: props.timeoutInSecs ? Duration.seconds(props.timeoutInSecs) : Duration.minutes(1),
+            tracing: props.tracing,
+            vpc,
+            vpcSubnets,
+        });
+        if (lambdaFunction.deadLetterQueue && props.dlq?.retriesEnabled) {
+            lambdaFunction.addEventSource(new SqsEventSource(lambdaFunction.deadLetterQueue, {
+                batchSize: props.dlq.retryBatchSize ?? 1,
+                reportBatchItemFailures: true,
+            }));
+        }
+        createCfnOutput(`${id}-lambdaArn`, scope, lambdaFunction.functionArn);
+        createCfnOutput(`${id}-lambdaName`, scope, lambdaFunction.functionName);
+        return lambdaFunction;
+    }
+    /**
+     * @summary Method to create a lambda function Alias
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @param lambdaVersion
+     */
+    createLambdaFunctionAlias(id, scope, props, lambdaVersion) {
+        if (!props)
+            throw `Lambda Alias props undefined for ${id}`;
+        const lambdaFunctionAlias = new Alias(scope, `${id}`, {
+            ...props,
+            version: lambdaVersion,
+        });
+        createCfnOutput(`${id}-lambdaAliasName`, scope, lambdaFunctionAlias.functionArn);
+        createCfnOutput(`${id}-lambdaAliasArn`, scope, lambdaFunctionAlias.functionName);
+        return lambdaFunctionAlias;
+    }
+}

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

@@ -0,0 +1,54 @@
+import { AliasProps, FunctionProps } from 'aws-cdk-lib/aws-lambda';
+import { SqsEventSourceProps } from 'aws-cdk-lib/aws-lambda-event-sources';
+import { TagProps } from '../../types/index.js';
+import { QueueProps } from '../simple-queue-service/index.js';
+/**
+ * Props for Lambda@Edge function, matching aws-cdk-lib experimental EdgeFunctionProps.
+ * Inlined because aws-cdk-lib does not export this subpath via its package exports map.
+ */
+export interface EdgeFunctionProps extends FunctionProps {
+    readonly stackId?: string;
+}
+/**
+ */
+export interface ProvisionedConcurrencyProps {
+    maxCapacity: number;
+    minCapacity: number;
+    utilizationTarget: number;
+}
+/**
+ */
+export interface LambdaProps extends FunctionProps {
+    dlq?: QueueProps;
+    excludeLastModifiedTimestamp?: boolean;
+    lambdaAliases?: LambdaAliasProps[];
+    logLevel?: string;
+    logRetentionInDays?: number;
+    redriveq?: QueueProps;
+    tags?: TagProps[];
+    timeoutInSecs?: number;
+}
+/**
+ */
+export interface LambdaAliasProps extends AliasProps {
+    id?: string;
+    provisionedConcurrency?: ProvisionedConcurrencyProps;
+}
+/**
+ */
+export interface LambdaEdgeProps extends EdgeFunctionProps {
+    tags?: TagProps[];
+    timeoutInSecs?: number;
+}
+/**
+ */
+export interface LambdaEnvironment {
+    LOG_LEVEL: string;
+    NODE_ENV: string;
+    REGION?: string;
+    STAGE?: string;
+    TZ: string;
+}
+export interface SQSEventSourceProps extends SqsEventSourceProps {
+    maxBatchingWindowInSecs: number;
+}

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

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

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

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

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

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

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

@@ -0,0 +1,66 @@
+import { DomainName } from 'aws-cdk-lib/aws-apigateway';
+import { IDistribution } from 'aws-cdk-lib/aws-cloudfront';
+import { ARecord, IHostedZone } from 'aws-cdk-lib/aws-route53';
+import { CommonConstruct } from '../../common/index.js';
+import { Route53Props } from './types.js';
+/**
+ * @classdesc Provides operations on AWS Route53
+ * - 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.route53Manager.createHostedZone('MyHostedZone', this)
+ *   }
+ * }
+ * @see [CDK Route53 Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_route53-readme.html}
+ */
+export declare class Route53Manager {
+    /**
+     * @summary Method to create a hosted zone
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     */
+    createHostedZone(id: string, scope: CommonConstruct, props: Route53Props): IHostedZone;
+    /**
+     * @summary Method to create/lookup a hosted zone
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param useExistingHostedZone Flag to indicate whether to lookup vs create new hosted zone
+     */
+    withHostedZoneFromFullyQualifiedDomainName(id: string, scope: CommonConstruct, useExistingHostedZone: boolean): IHostedZone;
+    /**
+     * @summary Method to create a-record for cloudfront target
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param distribution
+     * @param hostedZone
+     * @param recordName
+     * @param skipStageFromRecord
+     */
+    createCloudFrontTargetARecord(id: string, scope: CommonConstruct, distribution?: IDistribution, hostedZone?: IHostedZone, recordName?: string, skipStageFromRecord?: boolean): ARecord;
+    /**
+     * @summary Method to create a-record for cloudfront target
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param distribution
+     * @param hostedZone
+     * @param recordName
+     */
+    createCloudFrontTargetARecordV2(id: string, scope: CommonConstruct, distribution?: IDistribution, hostedZone?: IHostedZone, recordName?: string): ARecord;
+    /**
+     * @summary Method to create a-record for restApi gateway target
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param recordName
+     * @param apiDomain
+     * @param hostedZone
+     * @param skipStageFromRecord
+     */
+    createApiGatewayARecord(id: string, scope: CommonConstruct, recordName: string, apiDomain: DomainName, hostedZone: IHostedZone, skipStageFromRecord?: boolean): ARecord;
+}

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

@@ -0,0 +1,136 @@
+import { ARecord, HostedZone, RecordTarget } from 'aws-cdk-lib/aws-route53';
+import { ApiGatewayDomain, CloudFrontTarget } from 'aws-cdk-lib/aws-route53-targets';
+import { createCfnOutput } from '../../utils/index.js';
+/**
+ * @classdesc Provides operations on AWS Route53
+ * - 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.route53Manager.createHostedZone('MyHostedZone', this)
+ *   }
+ * }
+ * @see [CDK Route53 Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_route53-readme.html}
+ */
+export class Route53Manager {
+    /**
+     * @summary Method to create a hosted zone
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     */
+    createHostedZone(id, scope, props) {
+        let hostedZone;
+        if (!props)
+            throw `Route53 props undefined for ${id}`;
+        if (props.useExistingHostedZone) {
+            hostedZone = HostedZone.fromLookup(scope, `${id}`, {
+                domainName: scope.props.domainName,
+            });
+        }
+        else {
+            hostedZone = new HostedZone(scope, `${id}`, {
+                comment: `Hosted zone for ${scope.props.domainName}`,
+                zoneName: scope.props.domainName,
+            });
+        }
+        createCfnOutput(`${id}-hostedZoneId`, scope, hostedZone.hostedZoneId);
+        createCfnOutput(`${id}-hostedZoneArn`, scope, hostedZone.hostedZoneArn);
+        return hostedZone;
+    }
+    /**
+     * @summary Method to create/lookup a hosted zone
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param useExistingHostedZone Flag to indicate whether to lookup vs create new hosted zone
+     */
+    withHostedZoneFromFullyQualifiedDomainName(id, scope, useExistingHostedZone) {
+        let hostedZone;
+        if (useExistingHostedZone) {
+            hostedZone = HostedZone.fromLookup(scope, `${id}`, {
+                domainName: scope.fullyQualifiedDomainName,
+            });
+        }
+        else {
+            hostedZone = new HostedZone(scope, `${id}`, {
+                comment: `Hosted zone for ${scope.fullyQualifiedDomainName}`,
+                zoneName: scope.fullyQualifiedDomainName,
+            });
+        }
+        createCfnOutput(`${id}-hostedZoneId`, scope, hostedZone.hostedZoneId);
+        createCfnOutput(`${id}-hostedZoneArn`, scope, hostedZone.hostedZoneArn);
+        return hostedZone;
+    }
+    /**
+     * @summary Method to create a-record for cloudfront target
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param distribution
+     * @param hostedZone
+     * @param recordName
+     * @param skipStageFromRecord
+     */
+    createCloudFrontTargetARecord(id, scope, distribution, hostedZone, recordName, skipStageFromRecord) {
+        if (!distribution)
+            throw `Distribution undefined for ${id}`;
+        if (!hostedZone)
+            throw `HostedZone undefined for ${id}`;
+        const aRecord = new ARecord(scope, `${id}`, {
+            recordName: (recordName && scope.isProductionStage()) || skipStageFromRecord
+                ? `${recordName}`
+                : `${recordName}-${scope.props.stage}`,
+            target: RecordTarget.fromAlias(new CloudFrontTarget(distribution)),
+            zone: hostedZone,
+        });
+        createCfnOutput(`${id}-aRecordDomainName`, scope, aRecord.domainName);
+        return aRecord;
+    }
+    /**
+     * @summary Method to create a-record for cloudfront target
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param distribution
+     * @param hostedZone
+     * @param recordName
+     */
+    createCloudFrontTargetARecordV2(id, scope, distribution, hostedZone, recordName) {
+        if (!distribution)
+            throw `Distribution undefined for ${id}`;
+        if (!hostedZone)
+            throw `HostedZone undefined for ${id}`;
+        const aRecord = new ARecord(scope, `${id}`, {
+            recordName: recordName,
+            target: RecordTarget.fromAlias(new CloudFrontTarget(distribution)),
+            zone: hostedZone,
+        });
+        createCfnOutput(`${id}-aRecordDomainName`, scope, aRecord.domainName);
+        return aRecord;
+    }
+    /**
+     * @summary Method to create a-record for restApi gateway target
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param recordName
+     * @param apiDomain
+     * @param hostedZone
+     * @param skipStageFromRecord
+     */
+    createApiGatewayARecord(id, scope, recordName, apiDomain, hostedZone, skipStageFromRecord) {
+        let apiRecordName = '';
+        if (recordName && recordName !== '')
+            apiRecordName =
+                scope.isProductionStage() || skipStageFromRecord ? `${recordName}` : `${recordName}-${scope.props.stage}`;
+        const apiARecord = new ARecord(scope, `${id}`, {
+            recordName: apiRecordName,
+            target: RecordTarget.fromAlias(new ApiGatewayDomain(apiDomain)),
+            zone: hostedZone,
+        });
+        createCfnOutput(`${id}-a-record-domain-name`, scope, apiARecord.domainName);
+        return apiARecord;
+    }
+}