@gradientedge/cdk-utils-aws 1.0.0

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

@@ -0,0 +1,63 @@
+import { CfnApplication, CfnConfigurationProfile, CfnEnvironment, DeploymentStrategy } from 'aws-cdk-lib/aws-appconfig';
+import { CommonConstruct } from '../../common/index.js';
+import { Architecture } from '../constants.js';
+import { AppConfigProps } from './types.js';
+/**
+ * @classdesc Provides operations on AWS
+ * - 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.appConfigManager.createApplication('MyApplication', this)
+ *   }
+ * }
+ * @see [CDK AppConfig Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appconfig-readme.html}
+ */
+export declare class AppConfigManager {
+    /**
+     * Method to get static ARNs for AppConfig extensions
+     * @param scope scope in which this resource is defined
+     * @param type type of the architecture
+     */
+    getArnForAppConfigExtension(scope: CommonConstruct, type: Architecture): string;
+    /**
+     * @summary Method to create an AppConfig Application
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @returns the appconfig application
+     */
+    createApplication(id: string, scope: CommonConstruct, props: AppConfigProps): CfnApplication;
+    /**
+     * @summary Method to create an AppConfig Environment for a given application
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param applicationId id of the application
+     * @param props
+     * @returns the appconfig environment
+     */
+    createEnvironment(id: string, scope: CommonConstruct, applicationId: string, props: AppConfigProps): CfnEnvironment;
+    /**
+     * @summary Method to create an AppConfig Configuration Profile for a given application
+     * - The <b>locationUri</b> is defaulted to <i>hosted</i> if undefined</p>
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param applicationId id of the application
+     * @param props
+     * @returns the appconfig configuration profile
+     */
+    createConfigurationProfile(id: string, scope: CommonConstruct, applicationId: string, props: AppConfigProps): CfnConfigurationProfile;
+    /**
+     * @summary Method to create an AppConfig Deployment Strategy
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @returns the appconfig deployment strategy
+     */
+    createDeploymentStrategy(id: string, scope: CommonConstruct, props: AppConfigProps): DeploymentStrategy;
+}

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

@@ -0,0 +1,119 @@
+import { Fn } from 'aws-cdk-lib';
+import { CfnApplication, CfnConfigurationProfile, CfnEnvironment, DeploymentStrategy, RolloutStrategy, } from 'aws-cdk-lib/aws-appconfig';
+import { createCfnOutput } from '../../utils/index.js';
+import { Architecture } from '../constants.js';
+import { ArnsByRegionForArm64, ArnsByRegionForX86_64 } from './constants.js';
+/**
+ * @classdesc Provides operations on AWS
+ * - 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.appConfigManager.createApplication('MyApplication', this)
+ *   }
+ * }
+ * @see [CDK AppConfig Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appconfig-readme.html}
+ */
+export class AppConfigManager {
+    /**
+     * Method to get static ARNs for AppConfig extensions
+     * @param scope scope in which this resource is defined
+     * @param type type of the architecture
+     */
+    getArnForAppConfigExtension(scope, type) {
+        switch (type) {
+            case Architecture.ARM_64:
+                return ArnsByRegionForArm64[scope.props.region];
+            case Architecture.X86_64:
+                return ArnsByRegionForX86_64[scope.props.region];
+            default:
+                throw `Invalid type ${type} specified`;
+        }
+    }
+    /**
+     * @summary Method to create an AppConfig Application
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @returns the appconfig application
+     */
+    createApplication(id, scope, props) {
+        if (!props)
+            throw `AppConfig props undefined for ${id}`;
+        const application = new CfnApplication(scope, `${id}`, {
+            ...props.application,
+            name: scope.resourceNameFormatter.format(props.application.name, scope.props.resourceNameOptions?.appconfig),
+        });
+        createCfnOutput(`${id}-ApplicationId`, scope, Fn.ref(application.logicalId));
+        createCfnOutput(`${id}-ApplicationName`, scope, application.name);
+        return application;
+    }
+    /**
+     * @summary Method to create an AppConfig Environment for a given application
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param applicationId id of the application
+     * @param props
+     * @returns the appconfig environment
+     */
+    createEnvironment(id, scope, applicationId, props) {
+        if (!props)
+            throw `AppConfig props undefined for ${id}`;
+        const environment = new CfnEnvironment(scope, `${id}`, {
+            ...props.environment,
+            applicationId,
+            name: props.environment.name ?? scope.props.stage,
+        });
+        createCfnOutput(`${id}-configurationEnvironmentId`, scope, Fn.ref(environment.logicalId));
+        createCfnOutput(`${id}-configurationEnvironmentName`, scope, environment.name);
+        return environment;
+    }
+    /**
+     * @summary Method to create an AppConfig Configuration Profile for a given application
+     * - The <b>locationUri</b> is defaulted to <i>hosted</i> if undefined</p>
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param applicationId id of the application
+     * @param props
+     * @returns the appconfig configuration profile
+     */
+    createConfigurationProfile(id, scope, applicationId, props) {
+        if (!props)
+            throw `AppConfig props undefined for ${id}`;
+        const profile = new CfnConfigurationProfile(scope, `${id}`, {
+            ...props.configurationProfile,
+            applicationId,
+            locationUri: props.configurationProfile.locationUri || 'hosted',
+            name: scope.resourceNameFormatter.format(props.configurationProfile.name, scope.props.resourceNameOptions?.appconfig),
+        });
+        createCfnOutput(`${id}-configurationProfileId`, scope, Fn.ref(profile.logicalId));
+        createCfnOutput(`${id}-configurationProfileName`, scope, profile.name);
+        return profile;
+    }
+    /**
+     * @summary Method to create an AppConfig Deployment Strategy
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     * @returns the appconfig deployment strategy
+     */
+    createDeploymentStrategy(id, scope, props) {
+        if (!props)
+            throw `AppConfig props undefined for ${id}`;
+        if (!props.deploymentStrategy)
+            throw `AppConfig deploymentStrategy props undefined for ${id}`;
+        const deploymentStrategy = new DeploymentStrategy(scope, `${id}`, {
+            ...props,
+            deploymentStrategyName: scope.resourceNameFormatter.format(props.deploymentStrategy.deploymentStrategyName ?? 'common-deployment-strategy', scope.props.resourceNameOptions?.appconfig),
+            rolloutStrategy: props.deploymentStrategy.rolloutStrategy ?? RolloutStrategy.ALL_AT_ONCE,
+        });
+        createCfnOutput(`${id}-deploymentStrategyId`, scope, deploymentStrategy.deploymentStrategyId);
+        createCfnOutput(`${id}-deploymentStrategyArn`, scope, deploymentStrategy.deploymentStrategyArn);
+        return deploymentStrategy;
+    }
+}

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

@@ -0,0 +1,17 @@
+import { CfnApplicationProps, CfnConfigurationProfileProps, CfnDeploymentProps, CfnEnvironmentProps, DeploymentStrategyProps } from 'aws-cdk-lib/aws-appconfig';
+/**
+ *
+ */
+export interface AppConfigDeploymentStrategyProps extends DeploymentStrategyProps {
+    deploymentStrategyArn?: string;
+}
+/**
+ */
+export interface AppConfigProps {
+    application: CfnApplicationProps;
+    configurationProfile: CfnConfigurationProfileProps;
+    deployment: CfnDeploymentProps;
+    deploymentStrategy: AppConfigDeploymentStrategyProps;
+    environment: CfnEnvironmentProps;
+    id: string;
+}

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

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

package/dist/src/services/certificate-manager/index.d.ts

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

package/dist/src/services/certificate-manager/index.js

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

package/dist/src/services/certificate-manager/main.d.ts

@@ -0,0 +1,41 @@
+import { ICertificate } from 'aws-cdk-lib/aws-certificatemanager';
+import { IHostedZone } from 'aws-cdk-lib/aws-route53';
+import { CommonConstruct } from '../../common/index.js';
+import { AcmProps } from './types.js';
+/**
+ * @classdesc Provides operations on AWS Certificates.
+ * - 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.acmManager.createCertificate('MyCertificate', this)
+ *   }
+ * }
+ * @see [CDK Certificate Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_certificatemanager-readme.html}
+ */
+export declare class AcmManager {
+    /**
+     * @summary Method to create/import a certificate
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props certificate props
+     * @param hostedZone optional hosted zone to perform DNS validation
+     * @returns the resolved certificate
+     * @mermaid
+     *   graph LR;
+     *     A((Start)) --> B{Valid Properties?};
+     *     B -- Yes --> C(Fetch By ARN);
+     *     B -- No --> D[Throw Error];
+     *     D --> G((Stop));
+     *     C --> E{Valid ARN?};
+     *     E -- Yes --> F(Return Certificate);
+     *     E -- No --> D;
+     *     F --> G;
+     */
+    resolveCertificate(id: string, scope: CommonConstruct, props: AcmProps, hostedZone?: IHostedZone): ICertificate;
+}

package/dist/src/services/certificate-manager/main.js

@@ -0,0 +1,62 @@
+import { Stack } from 'aws-cdk-lib';
+import { Certificate, CertificateValidation } from 'aws-cdk-lib/aws-certificatemanager';
+import { createCfnOutput } from '../../utils/index.js';
+/**
+ * @classdesc Provides operations on AWS Certificates.
+ * - 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.acmManager.createCertificate('MyCertificate', this)
+ *   }
+ * }
+ * @see [CDK Certificate Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_certificatemanager-readme.html}
+ */
+export class AcmManager {
+    /**
+     * @summary Method to create/import a certificate
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props certificate props
+     * @param hostedZone optional hosted zone to perform DNS validation
+     * @returns the resolved certificate
+     * @mermaid
+     *   graph LR;
+     *     A((Start)) --> B{Valid Properties?};
+     *     B -- Yes --> C(Fetch By ARN);
+     *     B -- No --> D[Throw Error];
+     *     D --> G((Stop));
+     *     C --> E{Valid ARN?};
+     *     E -- Yes --> F(Return Certificate);
+     *     E -- No --> D;
+     *     F --> G;
+     */
+    resolveCertificate(id, scope, props, hostedZone) {
+        if (!props)
+            throw `Certificate props undefined for ${id}`;
+        let certificate;
+        if (props.useExistingCertificate) {
+            let certificateArn = props.certificateArn;
+            if (!certificateArn) {
+                const certificateAccount = props.certificateAccount ? props.certificateAccount : Stack.of(scope).account;
+                const certificateRegion = props.certificateRegion ? props.certificateRegion : Stack.of(scope).region;
+                certificateArn = `arn:aws:acm:${certificateRegion}:${certificateAccount}:certificate/${props.certificateId}`;
+            }
+            certificate = Certificate.fromCertificateArn(scope, `${id}`, certificateArn);
+        }
+        else {
+            certificate = new Certificate(scope, `${id}`, {
+                domainName: props.domainName,
+                subjectAlternativeNames: props.subjectAlternativeNames,
+                validation: CertificateValidation.fromDns(hostedZone),
+            });
+        }
+        createCfnOutput(`${id}-certificateArn`, scope, certificate.certificateArn);
+        return certificate;
+    }
+}

package/dist/src/services/certificate-manager/types.d.ts

@@ -0,0 +1,11 @@
+import { CertificateProps } from 'aws-cdk-lib/aws-certificatemanager';
+/**
+ */
+export interface AcmProps extends CertificateProps {
+    certificateAccount?: string;
+    certificateArn?: string;
+    certificateId?: string;
+    certificateRegion?: string;
+    certificateSsmName?: string;
+    useExistingCertificate: boolean;
+}

package/dist/src/services/certificate-manager/types.js

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

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

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

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

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

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

@@ -0,0 +1,96 @@
+import { ICertificate } from 'aws-cdk-lib/aws-certificatemanager';
+import * as cf from 'aws-cdk-lib/aws-cloudfront';
+import { DistributionAttributes, FunctionAssociation, IDistribution, IResponseHeadersPolicyRef, OriginAccessIdentity } from 'aws-cdk-lib/aws-cloudfront';
+import { HttpOrigin } from 'aws-cdk-lib/aws-cloudfront-origins';
+import { ISecurityGroup, IVpc } from 'aws-cdk-lib/aws-ec2';
+import { IAccessPoint } from 'aws-cdk-lib/aws-efs';
+import { Role } from 'aws-cdk-lib/aws-iam';
+import { AssetCode, ILayerVersion } from 'aws-cdk-lib/aws-lambda';
+import { IBucket } from 'aws-cdk-lib/aws-s3';
+import { CommonConstruct } from '../../common/index.js';
+import { LambdaEdgeProps } from '../lambda/index.js';
+import { CloudfrontFunctionProps, DistributionProps } from './types.js';
+/**
+ * @classdesc Provides operations on AWS
+ * - 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.cloudFrontManager.createCloudFrontDistribution(
+ *       'MyDistribution',
+ *       this,
+ *       siteBucket,
+ *       logBucket,
+ *       originAccessIdentity,
+ *       certificate
+ *     )
+ *   }
+ * }
+ * @see [CDK CloudFront Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudfront-readme.html}
+ */
+export declare class CloudFrontManager {
+    createOriginAccessIdentity(id: string, scope: CommonConstruct, accessBucket?: IBucket): cf.OriginAccessIdentity;
+    /**
+     * Method to create a CloudFront distribution with S3 Origin
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props distribution properties
+     * @param siteBucket
+     * @param logBucket
+     * @param oai
+     * @param certificate
+     * @param aliases
+     * @param defaultFunctionAssociations
+     */
+    createDistributionWithS3Origin(id: string, scope: CommonConstruct, props: DistributionProps, siteBucket: IBucket, logBucket?: IBucket, oai?: OriginAccessIdentity, certificate?: ICertificate, aliases?: string[], defaultFunctionAssociations?: FunctionAssociation[]): cf.Distribution;
+    /**
+     * Method to create a CloudFront distribution with HTTP Origin
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props distribution properties
+     * @param origin
+     * @param domainNames
+     * @param logBucket
+     * @param certificate
+     * @param defaultFunctionAssociations
+     * @param responseHeadersPolicy
+     */
+    createDistributionWithHttpOrigin(id: string, scope: CommonConstruct, props: DistributionProps, origin: HttpOrigin, domainNames: string[], logBucket?: IBucket, certificate?: ICertificate, defaultFunctionAssociations?: FunctionAssociation[], responseHeadersPolicy?: IResponseHeadersPolicyRef): cf.Distribution;
+    /**
+     * @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): cf.experimental.EdgeFunction;
+    /**
+     *
+     * @param id
+     * @param scope
+     * @param dockerFilePath
+     * @param distributionId
+     * @param paths
+     */
+    invalidateCache(id: string, scope: CommonConstruct, dockerFilePath: string, distributionId: string, paths?: string): void;
+    /**
+     * @summary Method to provision a Cloudfront function
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     */
+    createCloudfrontFunction(id: string, scope: CommonConstruct, props: CloudfrontFunctionProps): cf.Function;
+    resolveDistribution(scope: CommonConstruct, props: DistributionAttributes): IDistribution;
+}

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

@@ -0,0 +1,233 @@
+import { Duration, RemovalPolicy, Tags } from 'aws-cdk-lib';
+import * as cf from 'aws-cdk-lib/aws-cloudfront';
+import { Distribution, Function, FunctionCode, HttpVersion, OriginAccessIdentity, PriceClass, SecurityPolicyProtocol, } from 'aws-cdk-lib/aws-cloudfront';
+import { S3BucketOrigin } from 'aws-cdk-lib/aws-cloudfront-origins';
+import { FileSystem } from 'aws-cdk-lib/aws-lambda';
+import { AwsCustomResource, AwsCustomResourcePolicy, PhysicalResourceId } from 'aws-cdk-lib/custom-resources';
+import _ from 'lodash';
+import { CommonStack } from '../../common/index.js';
+import { createCfnOutput } from '../../utils/index.js';
+/**
+ * @classdesc Provides operations on AWS
+ * - 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.cloudFrontManager.createCloudFrontDistribution(
+ *       'MyDistribution',
+ *       this,
+ *       siteBucket,
+ *       logBucket,
+ *       originAccessIdentity,
+ *       certificate
+ *     )
+ *   }
+ * }
+ * @see [CDK CloudFront Module]{@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudfront-readme.html}
+ */
+export class CloudFrontManager {
+    createOriginAccessIdentity(id, scope, accessBucket) {
+        const oai = new OriginAccessIdentity(scope, `${id}`, {
+            comment: `${id} - ${scope.props.stage} stage`,
+        });
+        if (accessBucket)
+            accessBucket.grantRead(oai);
+        return oai;
+    }
+    /**
+     * Method to create a CloudFront distribution with S3 Origin
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props distribution properties
+     * @param siteBucket
+     * @param logBucket
+     * @param oai
+     * @param certificate
+     * @param aliases
+     * @param defaultFunctionAssociations
+     */
+    createDistributionWithS3Origin(id, scope, props, siteBucket, logBucket, oai, certificate, aliases, defaultFunctionAssociations) {
+        const distribution = new Distribution(scope, `${id}`, {
+            ...props,
+            certificate,
+            comment: `${id} - ${scope.props.stage} stage`,
+            defaultBehavior: {
+                ...props.defaultBehavior,
+                functionAssociations: defaultFunctionAssociations ?? undefined,
+                origin: S3BucketOrigin.withOriginAccessIdentity(siteBucket, { originAccessIdentity: oai }),
+            },
+            domainNames: aliases,
+            enableLogging: props.enableLogging ?? true,
+            enabled: props.enabled ?? true,
+            httpVersion: props.httpVersion ?? HttpVersion.HTTP2,
+            logBucket,
+            logFilePrefix: props.logFilePrefix ?? `edge/`,
+            logIncludesCookies: props.logIncludesCookies ?? true,
+            minimumProtocolVersion: props.minimumProtocolVersion ?? SecurityPolicyProtocol.TLS_V1_2_2021,
+            priceClass: props.priceClass ?? PriceClass.PRICE_CLASS_ALL,
+        });
+        if (props.tags && !_.isEmpty(props.tags)) {
+            _.forEach(props.tags, tag => {
+                Tags.of(distribution).add(tag.key, tag.value);
+            });
+        }
+        createCfnOutput(`${id}-distributionId`, scope, distribution.distributionId);
+        createCfnOutput(`${id}-distributionDomainName`, scope, distribution.distributionDomainName);
+        return distribution;
+    }
+    /**
+     * Method to create a CloudFront distribution with HTTP Origin
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props distribution properties
+     * @param origin
+     * @param domainNames
+     * @param logBucket
+     * @param certificate
+     * @param defaultFunctionAssociations
+     * @param responseHeadersPolicy
+     */
+    createDistributionWithHttpOrigin(id, scope, props, origin, domainNames, logBucket, certificate, defaultFunctionAssociations, responseHeadersPolicy) {
+        const distribution = new Distribution(scope, `${id}`, {
+            additionalBehaviors: props.additionalBehaviors,
+            certificate: certificate,
+            comment: `${id} - ${scope.props.stage} stage`,
+            defaultBehavior: {
+                cachePolicy: props.defaultBehavior ? props.defaultBehavior.cachePolicy : undefined,
+                edgeLambdas: props.defaultBehavior ? props.defaultBehavior.edgeLambdas : undefined,
+                functionAssociations: defaultFunctionAssociations ?? undefined,
+                origin: origin,
+                originRequestPolicy: props.defaultBehavior ? props.defaultBehavior.originRequestPolicy : undefined,
+                responseHeadersPolicy: responseHeadersPolicy ?? undefined,
+                viewerProtocolPolicy: props.defaultBehavior ? props.defaultBehavior.viewerProtocolPolicy : undefined,
+            },
+            defaultRootObject: props.defaultRootObject,
+            domainNames: domainNames,
+            enableIpv6: props.enableIpv6,
+            enableLogging: props.enableLogging ?? true,
+            enabled: props.enabled ?? true,
+            errorResponses: props.errorResponses,
+            geoRestriction: props.geoRestriction,
+            httpVersion: props.httpVersion ?? HttpVersion.HTTP2,
+            logBucket: logBucket,
+            logFilePrefix: props.logFilePrefix ?? `edge/`,
+            logIncludesCookies: props.logIncludesCookies ?? true,
+            minimumProtocolVersion: props.minimumProtocolVersion ?? SecurityPolicyProtocol.TLS_V1_2_2021,
+            priceClass: props.priceClass ?? PriceClass.PRICE_CLASS_ALL,
+            webAclId: props.webAclId,
+        });
+        if (props.tags && !_.isEmpty(props.tags)) {
+            _.forEach(props.tags, tag => {
+                Tags.of(distribution).add(tag.key, tag.value);
+            });
+        }
+        createCfnOutput(`${id}-distributionId`, scope, distribution.distributionId);
+        createCfnOutput(`${id}-distributionDomainName`, scope, distribution.distributionDomainName);
+        return distribution;
+    }
+    /**
+     * @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) {
+        if (!props)
+            throw `EdgeFunction props undefined for ${id}`;
+        if (!props.functionName)
+            throw `EdgeFunction functionName undefined for ${id}`;
+        const functionName = scope.resourceNameFormatter.format(props.functionName, scope.props.resourceNameOptions?.cloudfront);
+        const edgeFunction = new cf.experimental.EdgeFunction(scope, `${id}`, {
+            code: code,
+            description: props.description,
+            environment: {
+                ...environment,
+            },
+            filesystem: accessPoint ? FileSystem.fromEfsAccessPoint(accessPoint, mountPath ?? '/mnt/msg') : undefined,
+            functionName,
+            handler: props.handler ?? 'index.handler',
+            layers: layers,
+            logGroup: scope.logManager.createLogGroup(`${id}-log-group`, scope, {
+                logGroupName: functionName,
+                removalPolicy: RemovalPolicy.DESTROY,
+                retention: scope.props.logRetention,
+            }),
+            memorySize: props.memorySize,
+            reservedConcurrentExecutions: props.reservedConcurrentExecutions,
+            role: role,
+            runtime: props.runtime ?? scope.props.nodejsRuntime ?? CommonStack.NODEJS_RUNTIME,
+            securityGroups: securityGroups,
+            stackId: `${id}-stack-id-${scope.props.stage}`,
+            timeout: props.timeoutInSecs ? Duration.seconds(props.timeoutInSecs) : Duration.minutes(1),
+            vpc: vpc,
+        });
+        if (props.tags && !_.isEmpty(props.tags)) {
+            props.tags.forEach(tag => {
+                Tags.of(edgeFunction).add(tag.key, tag.value);
+            });
+        }
+        createCfnOutput(`${id}-edgeArn`, scope, edgeFunction.edgeArn);
+        createCfnOutput(`${id}-edgeFunctionArn`, scope, edgeFunction.functionArn);
+        createCfnOutput(`${id}-edgeFunctionName`, scope, edgeFunction.functionName);
+        return edgeFunction;
+    }
+    /**
+     *
+     * @param id
+     * @param scope
+     * @param dockerFilePath
+     * @param distributionId
+     * @param paths
+     */
+    invalidateCache(id, scope, dockerFilePath, distributionId, paths) {
+        new AwsCustomResource(scope, `${id}-trigger-codebuild-${new Date().getTime()}`, {
+            onCreate: {
+                action: 'startBuild',
+                parameters: {
+                    projectName: scope.codeBuildManager.createProjectForCloudfrontInvalidation(id, scope, dockerFilePath, distributionId, paths).projectName,
+                },
+                physicalResourceId: PhysicalResourceId.fromResponse('build.id'),
+                service: 'CodeBuild',
+            },
+            policy: AwsCustomResourcePolicy.fromSdkCalls({ resources: AwsCustomResourcePolicy.ANY_RESOURCE }),
+        });
+    }
+    /**
+     * @summary Method to provision a Cloudfront function
+     * @param id scoped id of the resource
+     * @param scope scope in which this resource is defined
+     * @param props
+     */
+    createCloudfrontFunction(id, scope, props) {
+        if (!props)
+            throw `CloudFront Function props undefined for ${id}`;
+        if (!props.functionName)
+            throw `CloudFront Function functionName undefined for ${id}`;
+        const cloudfrontFunction = new Function(scope, `${id}`, {
+            ...props,
+            code: FunctionCode.fromFile({
+                filePath: props.functionFilePath,
+            }),
+            functionName: scope.resourceNameFormatter.format(props.functionName, scope.props.resourceNameOptions?.cloudfront),
+        });
+        createCfnOutput(`${id}-functionArn`, scope, cloudfrontFunction.functionArn);
+        createCfnOutput(`${id}-functionName`, scope, cloudfrontFunction.functionName);
+        return cloudfrontFunction;
+    }
+    resolveDistribution(scope, props) {
+        return Distribution.fromDistributionAttributes(scope, `${scope.node.id}-sa-distribution`, props);
+    }
+}