@gradientedge/cdk-utils-aws 1.0.0

package/dist/src/construct/site-with-lambda-backend/main.d.ts

@@ -0,0 +1,116 @@
+import { ICertificate } from 'aws-cdk-lib/aws-certificatemanager';
+import { CachePolicy, IFunction as CfIFunction, Distribution, FunctionAssociation, OriginRequestPolicy, ResponseHeadersPolicy } from 'aws-cdk-lib/aws-cloudfront';
+import { HttpOrigin } from 'aws-cdk-lib/aws-cloudfront-origins';
+import { PolicyDocument, Role } from 'aws-cdk-lib/aws-iam';
+import { AssetCode, FunctionUrl, IFunction, ILayerVersion } from 'aws-cdk-lib/aws-lambda';
+import { IHostedZone } from 'aws-cdk-lib/aws-route53';
+import { IBucket } from 'aws-cdk-lib/aws-s3';
+import { BucketDeployment } from 'aws-cdk-lib/aws-s3-deployment';
+import { Construct } from 'constructs';
+import { CommonConstruct } from '../../common/index.js';
+import { SiteWithLambdaBackendCachePolicyProps, SiteWithLambdaBackendProps, SiteWithLambdaBackendResponseHeadersPolicyProps } from './types.js';
+/**
+ * @classdesc Provides a construct to create and deploy a site hosted with an clustered ECS/ELB backend
+ * @example
+ * import { SiteWithLambdaBackend, SiteWithLambdaBackendProps } '@gradientedge/cdk-utils'
+ * import { Construct } from 'constructs'
+ *
+ * class CustomConstruct extends SiteWithLambdaBackend {
+ *   constructor(parent: Construct, id: string, props: SiteWithLambdaBackendProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.id = id
+ *     this.initResources()
+ *   }
+ * }
+ */
+export declare class SiteWithLambdaBackend extends CommonConstruct {
+    props: SiteWithLambdaBackendProps;
+    id: string;
+    siteHostedZone: IHostedZone;
+    siteCertificate: ICertificate;
+    siteRegionalCertificate: ICertificate;
+    siteSecrets: any;
+    siteLogBucket: IBucket;
+    siteOrigin: HttpOrigin;
+    siteDistribution: Distribution;
+    siteInternalDomainName: string;
+    siteExternalDomainName: string;
+    siteDomainNames: string[];
+    siteCloudfrontFunction: CfIFunction;
+    siteFunctionAssociations: FunctionAssociation[];
+    siteOriginRequestPolicy: OriginRequestPolicy;
+    siteOriginResponseHeadersPolicy?: ResponseHeadersPolicy;
+    siteCachePolicy: CachePolicy;
+    siteStaticAssetDeployment: BucketDeployment;
+    siteLambdaPolicy: PolicyDocument;
+    siteLambdaRole: Role;
+    siteLambdaEnvironment: any;
+    siteLambdaLayers: ILayerVersion[];
+    siteLambdaApplication: AssetCode;
+    siteLambdaFunction: IFunction;
+    siteLambdaUrl: FunctionUrl;
+    constructor(parent: Construct, id: string, props: SiteWithLambdaBackendProps);
+    /**
+     * @summary Initialise and provision resources
+     */
+    initResources(): 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;
+    protected resolveGlobalCertificate(): void;
+    protected resolveRegionalCertificate(): void;
+    /**
+     * @summary Method to resolve secrets from SecretsManager
+     * - To be implemented in the overriding method in the implementation class
+     */
+    protected resolveSiteSecrets(): void;
+    /**
+     * @summary Method to resolve site domain names
+     */
+    protected resolveSiteDomainNames(): void;
+    /**
+     * Method to create log bucket for site distribution
+     */
+    protected createSiteLogBucket(): void;
+    protected createSiteCachePolicy(id: string, siteCachePolicy: SiteWithLambdaBackendCachePolicyProps): CachePolicy;
+    protected createSiteOriginCachePolicy(): void;
+    protected createSiteOriginRequestPolicy(): void;
+    protected createResponseHeaderPolicy(props: SiteWithLambdaBackendResponseHeadersPolicyProps): ResponseHeadersPolicy | undefined;
+    protected createSiteOriginResponseHeadersPolicy(): void;
+    protected createSiteOrigin(): void;
+    protected createSiteOriginResources(): void;
+    protected createSiteStaticAssetDeployment(): void;
+    protected createSiteLambdaPolicy(): void;
+    protected createSiteLambdaRole(): void;
+    protected createSiteLambdaEnvironment(): void;
+    protected createSiteLambdaLayers(): void;
+    protected createSiteLambdaApplication(): void;
+    protected createSiteLambda(): void;
+    protected createSiteLambdaUrl(): void;
+    /**
+     * @summary Method to create a site cloudfront function
+     */
+    protected createSiteCloudfrontFunction(): void;
+    /**
+     * @summary Method to create a site cloudfront function associations
+     */
+    protected resolveSiteFunctionAssociations(): void;
+    /**
+     * Method to create Site distribution
+     */
+    protected createDistribution(): void;
+    /**
+     * Method to create Route53 records for distribution
+     */
+    protected createNetworkMappings(): void;
+    /**
+     * Method to invalidation the cloudfront distribution cache after a deployment
+     */
+    protected invalidateDistributionCache(): void;
+}

package/dist/src/construct/site-with-lambda-backend/main.js

@@ -0,0 +1,316 @@
+import { Duration, Fn } from 'aws-cdk-lib';
+import { CachePolicy, FunctionEventType, OriginProtocolPolicy, OriginRequestPolicy, ResponseHeadersPolicy, } from 'aws-cdk-lib/aws-cloudfront';
+import { HttpOrigin } from 'aws-cdk-lib/aws-cloudfront-origins';
+import { AnyPrincipal, Effect, PolicyDocument, PolicyStatement } from 'aws-cdk-lib/aws-iam';
+import { Function, FunctionUrlAuthType } from 'aws-cdk-lib/aws-lambda';
+import _ from 'lodash';
+import { CommonConstruct } from '../../common/index.js';
+import { LAMBDA_ALIAS_NAME_CURRENT } from './constants.js';
+/**
+ * @classdesc Provides a construct to create and deploy a site hosted with an clustered ECS/ELB backend
+ * @example
+ * import { SiteWithLambdaBackend, SiteWithLambdaBackendProps } '@gradientedge/cdk-utils'
+ * import { Construct } from 'constructs'
+ *
+ * class CustomConstruct extends SiteWithLambdaBackend {
+ *   constructor(parent: Construct, id: string, props: SiteWithLambdaBackendProps) {
+ *     super(parent, id, props)
+ *     this.props = props
+ *     this.id = id
+ *     this.initResources()
+ *   }
+ * }
+ */
+export class SiteWithLambdaBackend extends CommonConstruct {
+    /* site properties */
+    props;
+    id;
+    /* site resources */
+    siteHostedZone;
+    siteCertificate;
+    siteRegionalCertificate;
+    siteSecrets;
+    siteLogBucket;
+    siteOrigin;
+    siteDistribution;
+    siteInternalDomainName;
+    siteExternalDomainName;
+    siteDomainNames;
+    siteCloudfrontFunction;
+    siteFunctionAssociations;
+    siteOriginRequestPolicy;
+    siteOriginResponseHeadersPolicy;
+    siteCachePolicy;
+    siteStaticAssetDeployment;
+    siteLambdaPolicy;
+    siteLambdaRole;
+    siteLambdaEnvironment;
+    siteLambdaLayers;
+    siteLambdaApplication;
+    siteLambdaFunction;
+    siteLambdaUrl;
+    constructor(parent, id, props) {
+        super(parent, id, props);
+        this.props = props;
+        this.id = id;
+    }
+    /**
+     * @summary Initialise and provision resources
+     */
+    initResources() {
+        this.resolveHostedZone();
+        this.resolveCertificate();
+        this.resolveSiteSecrets();
+        this.resolveSiteDomainNames();
+        this.createSiteLogBucket();
+        this.createSiteOriginCachePolicy();
+        this.createSiteOriginRequestPolicy();
+        this.createSiteOriginResponseHeadersPolicy();
+        this.createSiteOrigin();
+        this.createSiteCloudfrontFunction();
+        this.resolveSiteFunctionAssociations();
+        this.createDistribution();
+        this.createNetworkMappings();
+        this.invalidateDistributionCache();
+    }
+    /**
+     * @summary Method to resolve a hosted zone based on domain attributes
+     */
+    resolveHostedZone() {
+        this.siteHostedZone = this.route53Manager.withHostedZoneFromFullyQualifiedDomainName(`${this.id}-hosted-zone`, this, this.props.useExistingHostedZone);
+    }
+    /**
+     * @summary Method to resolve a certificate based on attributes
+     */
+    resolveCertificate() {
+        this.resolveGlobalCertificate();
+        this.resolveRegionalCertificate();
+    }
+    resolveGlobalCertificate() {
+        if (this.props.siteCertificate.useExistingCertificate &&
+            this.props.siteCertificate.certificateSsmName &&
+            this.props.siteCertificate.certificateRegion) {
+            this.props.siteCertificate.certificateArn = this.ssmManager.readStringParameterFromRegion(`${this.id}-certificate-parameter`, this, this.props.siteCertificate.certificateSsmName, this.props.siteCertificate.certificateRegion);
+        }
+        this.siteCertificate = this.acmManager.resolveCertificate(`${this.id}-certificate`, this, this.props.siteCertificate);
+    }
+    resolveRegionalCertificate() {
+        if (this.props.siteRegionalCertificate.useExistingCertificate &&
+            this.props.siteRegionalCertificate.certificateSsmName &&
+            this.props.siteRegionalCertificate.certificateRegion) {
+            this.props.siteRegionalCertificate.certificateArn = this.ssmManager.readStringParameterFromRegion(`${this.id}-regional-certificate-parameter`, this, this.props.siteRegionalCertificate.certificateSsmName, this.props.siteRegionalCertificate.certificateRegion);
+        }
+        this.siteRegionalCertificate = this.acmManager.resolveCertificate(`${this.id}-regional-certificate`, this, this.props.siteRegionalCertificate, this.siteHostedZone);
+    }
+    /**
+     * @summary Method to resolve secrets from SecretsManager
+     * - To be implemented in the overriding method in the implementation class
+     */
+    resolveSiteSecrets() { }
+    /**
+     * @summary Method to resolve site domain names
+     */
+    resolveSiteDomainNames() {
+        /* the internal domain name used by ELB */
+        this.siteInternalDomainName =
+            this.isProductionStage() || this.props.skipStageForARecords
+                ? `${this.props.siteSubDomain}-internal.${this.fullyQualifiedDomainName}`
+                : `${this.props.siteSubDomain}-internal-${this.props.stage}.${this.fullyQualifiedDomainName}`;
+        /* the external domain name exposed to CloudFront */
+        this.siteExternalDomainName =
+            this.isProductionStage() || this.props.skipStageForARecords
+                ? `${this.props.siteSubDomain}.${this.fullyQualifiedDomainName}`
+                : `${this.props.siteSubDomain}-${this.props.stage}.${this.fullyQualifiedDomainName}`;
+        this.siteDomainNames = [this.siteExternalDomainName];
+    }
+    /**
+     * Method to create log bucket for site distribution
+     */
+    createSiteLogBucket() {
+        this.siteLogBucket = this.s3Manager.createS3Bucket(`${this.id}-site-logs`, this, this.props.siteLogBucket);
+    }
+    createSiteCachePolicy(id, siteCachePolicy) {
+        if (!siteCachePolicy.cachePolicyName)
+            throw `SiteCachePolicy cachePolicyName undefined for ${id}`;
+        return new CachePolicy(this, `${id}`, {
+            cachePolicyName: this.resourceNameFormatter.format(siteCachePolicy.cachePolicyName),
+            comment: `Policy for ${this.id}-distribution - ${this.props.stage} stage`,
+            cookieBehavior: siteCachePolicy.cookieBehavior,
+            enableAcceptEncodingBrotli: siteCachePolicy.enableAcceptEncodingBrotli,
+            enableAcceptEncodingGzip: siteCachePolicy.enableAcceptEncodingGzip,
+            headerBehavior: siteCachePolicy.headerBehavior,
+            maxTtl: Duration.seconds(siteCachePolicy.maxTtlInSeconds),
+            minTtl: Duration.seconds(siteCachePolicy.minTtlInSeconds),
+            queryStringBehavior: siteCachePolicy.queryStringBehavior,
+        });
+    }
+    createSiteOriginCachePolicy() {
+        if (!this.props.siteCachePolicy)
+            return;
+        this.siteCachePolicy = this.createSiteCachePolicy(`${this.id}-site-cache-policy`, this.props.siteCachePolicy);
+        _.assign(this.props.siteDistribution.defaultBehavior, {
+            cachePolicy: this.siteCachePolicy,
+        });
+    }
+    createSiteOriginRequestPolicy() {
+        if (!this.props.siteOriginRequestPolicy)
+            return;
+        if (!this.props.siteOriginRequestPolicy.originRequestPolicyName)
+            throw `SiteOriginRequestPolicy originRequestPolicyName undefined for ${this.id}`;
+        this.siteOriginRequestPolicy = new OriginRequestPolicy(this, `${this.id}-sorp`, {
+            comment: `Request Policy for ${this.id}-distribution - ${this.props.stage} stage`,
+            cookieBehavior: this.props.siteOriginRequestPolicy.cookieBehavior,
+            headerBehavior: this.props.siteOriginRequestPolicy.headerBehavior,
+            originRequestPolicyName: this.resourceNameFormatter.format(this.props.siteOriginRequestPolicy.originRequestPolicyName),
+            queryStringBehavior: this.props.siteOriginRequestPolicy.queryStringBehavior,
+        });
+        _.assign(this.props.siteDistribution.defaultBehavior, {
+            originRequestPolicy: this.siteOriginRequestPolicy,
+        });
+    }
+    createResponseHeaderPolicy(props) {
+        if (!props)
+            return undefined;
+        if (!props.responseHeadersPolicyName)
+            throw `SiteResponseHeadersPolicy responseHeadersPolicyName undefined for ${this.id}`;
+        return new ResponseHeadersPolicy(this, `${this.id}-${props.type}-srhp`, {
+            ...props,
+            comment: `Response Header Policy for ${props.type} for ${this.id}-distribution - ${this.props.stage} stage`,
+            responseHeadersPolicyName: this.resourceNameFormatter.format(props.responseHeadersPolicyName),
+            securityHeadersBehavior: {
+                ...props.securityHeadersBehavior,
+                strictTransportSecurity: {
+                    ...props.securityHeadersBehavior?.strictTransportSecurity,
+                    accessControlMaxAge: Duration.seconds(props.securityHeadersBehavior?.strictTransportSecurity?.accessControlMaxAgeInSeconds),
+                },
+            },
+        });
+    }
+    createSiteOriginResponseHeadersPolicy() {
+        if (!this.props.siteOriginResponseHeadersPolicy)
+            return;
+        this.siteOriginResponseHeadersPolicy = this.createResponseHeaderPolicy(this.props.siteOriginResponseHeadersPolicy);
+        _.assign(this.props.siteDistribution.defaultBehavior, {
+            responseHeadersPolicy: this.siteOriginResponseHeadersPolicy,
+        });
+    }
+    createSiteOrigin() {
+        this.createSiteOriginResources();
+        this.siteOrigin = new HttpOrigin(Fn.select(2, Fn.split('/', this.siteLambdaUrl.url)), {
+            httpPort: 443,
+            originId: `${this.id}-server`,
+            protocolPolicy: OriginProtocolPolicy.HTTPS_ONLY,
+        });
+    }
+    createSiteOriginResources() {
+        this.createSiteStaticAssetDeployment();
+        this.createSiteLambdaPolicy();
+        this.createSiteLambdaRole();
+        this.createSiteLambdaEnvironment();
+        this.createSiteLambdaLayers();
+        this.createSiteLambdaApplication();
+        this.createSiteLambda();
+        this.createSiteLambdaUrl();
+    }
+    createSiteStaticAssetDeployment() { }
+    createSiteLambdaPolicy() {
+        this.siteLambdaPolicy = new PolicyDocument({
+            statements: [
+                new PolicyStatement({
+                    actions: ['lambda:InvokeFunctionUrl'],
+                    effect: Effect.ALLOW,
+                    resources: ['*'],
+                }),
+            ],
+        });
+    }
+    createSiteLambdaRole() {
+        this.siteLambdaRole = this.iamManager.createRoleForLambda(`${this.id}-role`, this, this.siteLambdaPolicy);
+    }
+    createSiteLambdaEnvironment() {
+        this.siteLambdaEnvironment = {
+            AWS_LAMBDA_EXEC_WRAPPER: this.props.siteExecWrapperPath ?? '/opt/bootstrap',
+            LOG_LEVEL: this.props.logLevel,
+            NODE_ENV: this.props.nodeEnv,
+            PORT: this.props.sitePort,
+            READINESS_CHECK_PATH: this.props.siteHealthEndpoint,
+            READINESS_CHECK_PORT: this.props.sitePort,
+            STAGE: this.props.stage,
+            TZ: this.props.timezone,
+        };
+    }
+    createSiteLambdaLayers() {
+        this.siteLambdaLayers = this.lambdaManager.createWebAdapterLayer(`${this.id}-web-adapter`, this);
+    }
+    createSiteLambdaApplication() { }
+    createSiteLambda() {
+        this.siteLambdaFunction = this.lambdaManager.createLambdaFunction(`${this.id}-lambda`, this, this.props.siteLambda, this.siteLambdaRole, this.siteLambdaLayers, this.siteLambdaApplication, this.props.siteLambda.handler, this.siteLambdaEnvironment);
+    }
+    createSiteLambdaUrl() {
+        const lambdaAlias = _.find(this.props.siteLambda.lambdaAliases, alias => alias.aliasName === LAMBDA_ALIAS_NAME_CURRENT);
+        const lambdaFn = lambdaAlias
+            ? Function.fromFunctionAttributes(this, `${this.id}-fn-alias`, {
+                functionArn: `${this.siteLambdaFunction.functionArn}:${lambdaAlias.aliasName}`,
+                sameEnvironment: true,
+            })
+            : this.siteLambdaFunction;
+        lambdaFn.node.addDependency(this.siteLambdaFunction);
+        this.siteLambdaUrl = lambdaFn.addFunctionUrl({
+            authType: FunctionUrlAuthType.NONE,
+        });
+        this.siteLambdaUrl.node.addDependency(this.siteLambdaFunction);
+        this.siteLambdaUrl.node.addDependency(lambdaFn);
+        const principal = new AnyPrincipal();
+        principal.addToPolicy(new PolicyStatement({
+            actions: ['lambda:InvokeFunctionUrl'],
+            conditions: { StringEquals: { 'lambda:FunctionUrlAuthType': FunctionUrlAuthType.NONE } },
+            effect: Effect.ALLOW,
+            resources: ['*'],
+        }));
+        lambdaFn.grantInvokeUrl({ grantPrincipal: principal });
+        this.addCfnOutput(`${this.id}-url`, this.siteLambdaUrl.url);
+    }
+    /**
+     * @summary Method to create a site cloudfront function
+     */
+    createSiteCloudfrontFunction() {
+        if (this.props.siteCloudfrontFunctionProps) {
+            this.siteCloudfrontFunction = this.cloudFrontManager.createCloudfrontFunction(`${this.id}-function`, this, this.props.siteCloudfrontFunctionProps);
+        }
+    }
+    /**
+     * @summary Method to create a site cloudfront function associations
+     */
+    resolveSiteFunctionAssociations() {
+        if (this.props.siteCloudfrontFunctionProps) {
+            this.siteFunctionAssociations = [
+                {
+                    eventType: FunctionEventType.VIEWER_REQUEST,
+                    function: this.siteCloudfrontFunction,
+                },
+            ];
+        }
+    }
+    /**
+     * Method to create Site distribution
+     */
+    createDistribution() {
+        this.siteDistribution = this.cloudFrontManager.createDistributionWithHttpOrigin(`${this.id}-distribution`, this, this.props.siteDistribution, this.siteOrigin, this.siteDomainNames, this.siteLogBucket, this.siteCertificate, this.siteFunctionAssociations, this.props.siteDistribution.defaultBehavior.responseHeadersPolicy);
+        this.siteDistribution.node.addDependency(this.siteLambdaFunction);
+        this.siteDistribution.node.addDependency(this.siteLambdaUrl);
+    }
+    /**
+     * Method to create Route53 records for distribution
+     */
+    createNetworkMappings() {
+        this.route53Manager.createCloudFrontTargetARecord(`${this.id}-a-record`, this, this.siteDistribution, this.siteHostedZone, this.props.siteRecordName, this.props.skipStageForARecords);
+    }
+    /**
+     * Method to invalidation the cloudfront distribution cache after a deployment
+     */
+    invalidateDistributionCache() {
+        if (this.props.siteCacheInvalidationDockerFilePath) {
+            this.cloudFrontManager.invalidateCache(`${this.id}-cache-invalidation`, this, this.props.siteCacheInvalidationDockerFilePath, this.siteDistribution.distributionId);
+        }
+    }
+}

package/dist/src/construct/site-with-lambda-backend/types.d.ts

@@ -0,0 +1,45 @@
+import { CachePolicyProps, OriginRequestPolicyProps, ResponseHeadersPolicyProps, ResponseHeadersStrictTransportSecurity, ResponseSecurityHeadersBehavior } from 'aws-cdk-lib/aws-cloudfront';
+import { CommonStackProps } from '../../common/index.js';
+import { AcmProps, CloudfrontFunctionProps, DistributionProps, LambdaProps, LogProps, S3BucketProps } from '../../services/index.js';
+import { SiteWithLambdaBackendResponseHeaderPolicyType } from './constants.js';
+/**
+ */
+export interface SiteWithLambdaBackendProps extends CommonStackProps {
+    logLevel: string;
+    nodeEnv: string;
+    siteCacheInvalidationDockerFilePath?: string;
+    siteCertificate: AcmProps;
+    siteCloudfrontFunctionProps?: CloudfrontFunctionProps;
+    siteDistribution: DistributionProps;
+    siteExecWrapperPath: string;
+    siteFunctionFilePath?: string;
+    siteHealthEndpoint: string;
+    siteLambda: LambdaProps;
+    siteLog: LogProps;
+    siteLogBucket: S3BucketProps;
+    sitePort: string;
+    siteCachePolicy?: SiteWithLambdaBackendCachePolicyProps;
+    siteOriginRequestPolicy: OriginRequestPolicyProps;
+    siteOriginResponseHeadersPolicy: SiteWithLambdaBackendResponseHeadersPolicyProps;
+    siteRecordName?: string;
+    siteRegionalCertificate: AcmProps;
+    siteSubDomain: string;
+    timezone: string;
+    useExistingHostedZone: boolean;
+    useExistingVpc: boolean;
+}
+export interface SiteWithLambdaBackendResponseHeadersStrictTransportSecurity extends ResponseHeadersStrictTransportSecurity {
+    accessControlMaxAgeInSeconds: number;
+}
+export interface SiteWithLambdaBackendSecurityHeadersBehavior extends ResponseSecurityHeadersBehavior {
+    strictTransportSecurity: SiteWithLambdaBackendResponseHeadersStrictTransportSecurity;
+}
+export interface SiteWithLambdaBackendResponseHeadersPolicyProps extends ResponseHeadersPolicyProps {
+    securityHeadersBehavior: SiteWithLambdaBackendSecurityHeadersBehavior;
+    type: SiteWithLambdaBackendResponseHeaderPolicyType;
+}
+export interface SiteWithLambdaBackendCachePolicyProps extends CachePolicyProps {
+    defaultTtlInSeconds: number;
+    minTtlInSeconds: number;
+    maxTtlInSeconds: number;
+}

package/dist/src/construct/site-with-lambda-backend/types.js

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

package/dist/src/construct/static-asset-deployment/index.d.ts

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

package/dist/src/construct/static-asset-deployment/index.js

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

package/dist/src/construct/static-asset-deployment/main.d.ts

@@ -0,0 +1,41 @@
+import { IBucket } from 'aws-cdk-lib/aws-s3';
+import { IDistribution } from 'aws-cdk-lib/aws-cloudfront';
+import { Construct } from 'constructs';
+import { CommonConstruct } from '../../common/index.js';
+import { StaticAssetDeploymentProps } from './types.js';
+/**
+ * @classdesc Provides a construct to create and deploy static assets into S3 bucket
+ * @example
+ * import { StaticAssetDeployment, StaticAssetDeploymentProps } '@gradientedge/cdk-utils'
+ * import { Construct } from 'constructs'
+ *
+ * class CustomConstruct extends StaticAssetDeployment {
+ *   constructor(parent: Construct, id: string, props: StaticAssetDeploymentProps) {
+ *     super(parent, id, props)
+ *     this.initResources()
+ *   }
+ * }
+ */
+export declare class StaticAssetDeployment extends CommonConstruct {
+    staticAssetBucket: IBucket;
+    cloudfrontDistribution?: IDistribution;
+    props: StaticAssetDeploymentProps;
+    id: string;
+    constructor(parent: Construct, id: string, props: StaticAssetDeploymentProps);
+    /**
+     * @summary Initialise and provision resources
+     */
+    initResources(): void;
+    /**
+     * @summary Create the static asset bucket
+     */
+    protected createAssetBucket(): void;
+    /**
+     * @summary Distribute the load for the static asset bucket if both distribution and paths are provided
+     */
+    protected resolveDistribution(): void;
+    /**
+     * @summary Deploy the static assets into the static asset bucket
+     */
+    protected deployStaticAssets(): void;
+}

package/dist/src/construct/static-asset-deployment/main.js

@@ -0,0 +1,113 @@
+import { Fn } from 'aws-cdk-lib';
+import { BucketDeployment, Source } from 'aws-cdk-lib/aws-s3-deployment';
+import _ from 'lodash';
+import { CommonConstruct } from '../../common/index.js';
+import appRoot from 'app-root-path';
+import path from 'path';
+/**
+ * @classdesc Provides a construct to create and deploy static assets into S3 bucket
+ * @example
+ * import { StaticAssetDeployment, StaticAssetDeploymentProps } '@gradientedge/cdk-utils'
+ * import { Construct } from 'constructs'
+ *
+ * class CustomConstruct extends StaticAssetDeployment {
+ *   constructor(parent: Construct, id: string, props: StaticAssetDeploymentProps) {
+ *     super(parent, id, props)
+ *     this.initResources()
+ *   }
+ * }
+ */
+export class StaticAssetDeployment extends CommonConstruct {
+    /* construct resources */
+    staticAssetBucket;
+    cloudfrontDistribution;
+    props;
+    id;
+    constructor(parent, id, props) {
+        super(parent, id, props);
+        this.id = id;
+        this.props = props;
+    }
+    /**
+     * @summary Initialise and provision resources
+     */
+    initResources() {
+        this.createAssetBucket();
+        this.resolveDistribution();
+        this.deployStaticAssets();
+    }
+    /**
+     * @summary Create the static asset bucket
+     */
+    createAssetBucket() {
+        this.staticAssetBucket = this.s3Manager.createS3Bucket(`${this.id}-sa-bucket`, this, this.props.staticAssetBucket);
+    }
+    /**
+     * @summary Distribute the load for the static asset bucket if both distribution and paths are provided
+     */
+    resolveDistribution() {
+        if (this.props.cloudFrontDistribution &&
+            (this.props.cloudFrontDistribution.domainName || this.props.cloudFrontDistribution.domainNameRef) &&
+            (this.props.cloudFrontDistribution.distributionId || this.props.cloudFrontDistribution.distributionIdRef) &&
+            this.props.cloudFrontDistribution.invalidationPaths &&
+            this.props.cloudFrontDistribution.invalidationPaths.length > 0) {
+            let domainName = this.props.cloudFrontDistribution.domainName;
+            if (this.props.cloudFrontDistribution.domainNameRef) {
+                domainName = Fn.importValue(this.props.cloudFrontDistribution.domainNameRef);
+            }
+            let distributionId = this.props.cloudFrontDistribution.distributionId;
+            if (this.props.cloudFrontDistribution.distributionIdRef) {
+                distributionId = Fn.importValue(this.props.cloudFrontDistribution.distributionIdRef);
+            }
+            const distributionAttributes = {
+                domainName: domainName,
+                distributionId: distributionId,
+            };
+            this.cloudfrontDistribution = this.cloudFrontManager.resolveDistribution(this, distributionAttributes);
+        }
+    }
+    /**
+     * @summary Deploy the static assets into the static asset bucket
+     */
+    deployStaticAssets() {
+        let sources = [];
+        if (Array.isArray(this.props.staticAssetSources) &&
+            this.props.staticAssetSources.length > 0 &&
+            typeof this.props.staticAssetSources[0] === 'string') {
+            sources = this.props.staticAssetSources.map(source => {
+                const resolvedPath = path.join(appRoot.path, source);
+                return Source.asset(resolvedPath);
+            });
+        }
+        else {
+            sources = this.props.staticAssetSources;
+        }
+        let distributionOptions = {};
+        if (this.cloudfrontDistribution) {
+            distributionOptions = {
+                distribution: this.cloudfrontDistribution,
+                distributionPaths: this.props.cloudFrontDistribution?.invalidationPaths,
+            };
+        }
+        let destinationKeyPrefixOptions = {};
+        if (this.props.destinationKeyPrefix) {
+            destinationKeyPrefixOptions = {
+                destinationKeyPrefix: this.props.destinationKeyPrefix,
+            };
+        }
+        new BucketDeployment(this, `${this.id}-static-deployment`, {
+            ...this.props.staticAssetDeployment,
+            destinationBucket: this.staticAssetBucket,
+            sources: sources,
+            ...destinationKeyPrefixOptions,
+            ...distributionOptions,
+        });
+        const staticAssetsForExport = this.props.staticAssetsForExport;
+        if (!staticAssetsForExport)
+            return;
+        /* optional additional exports needed for asset urls */
+        _.forEach(staticAssetsForExport, asset => {
+            this.addCfnOutput(asset.key, this.staticAssetBucket.s3UrlForObject(asset.value));
+        });
+    }
+}