@cdklabs/cdk-appmod-catalog-blueprints 1.0.0

package/lib/webapp/frontend-construct.js

@@ -0,0 +1,253 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Frontend = exports.DEFAULT_SPA_ERROR_RESPONSES = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+const path = require("path");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_cloudfront_1 = require("aws-cdk-lib/aws-cloudfront");
+const aws_cloudfront_origins_1 = require("aws-cdk-lib/aws-cloudfront-origins");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const aws_route53_1 = require("aws-cdk-lib/aws-route53");
+const aws_route53_targets_1 = require("aws-cdk-lib/aws-route53-targets");
+const aws_s3_1 = require("aws-cdk-lib/aws-s3");
+const aws_s3_assets_1 = require("aws-cdk-lib/aws-s3-assets");
+const aws_s3_deployment_1 = require("aws-cdk-lib/aws-s3-deployment");
+const constructs_1 = require("constructs");
+const utilities_1 = require("../utilities");
+/**
+ * Default CloudFront error responses for Single Page Applications
+ */
+exports.DEFAULT_SPA_ERROR_RESPONSES = [
+    {
+        httpStatus: 403,
+        responseHttpStatus: 200,
+        responsePagePath: '/index.html',
+    },
+    {
+        httpStatus: 404,
+        responseHttpStatus: 200,
+        responsePagePath: '/index.html',
+    },
+];
+/**
+ * Frontend construct that deploys a frontend application to S3 and CloudFront
+ *
+ * This construct provides a complete solution for hosting static frontend applications
+ * with the following features:
+ * - S3 bucket for hosting static assets with security best practices
+ * - CloudFront distribution for global content delivery
+ * - Optional custom domain with SSL certificate
+ * - Automatic build process execution
+ * - SPA-friendly error handling by default
+ * - Security configurations
+ */
+class Frontend extends constructs_1.Construct {
+    /**
+     * Creates a new Frontend
+     * @param scope The construct scope
+     * @param id The construct ID
+     * @param props The frontend properties
+     */
+    constructor(scope, id, props) {
+        super(scope, id);
+        if (props.enableObservability) {
+            aws_cdk_lib_1.PropertyInjectors.of(this).add(new utilities_1.CloudfrontDistributionObservabilityPropertyInjector());
+        }
+        // Validate required parameters
+        this._validateProps(props);
+        // Get removal policy with default
+        const removalPolicy = props.removalPolicy || aws_cdk_lib_1.RemovalPolicy.DESTROY;
+        // Create asset for source code with optional bundling
+        if (!props.skipBuild) {
+            this.asset = this._createAsset(props);
+        }
+        // Create S3 bucket for hosting
+        this.bucket = new aws_s3_1.Bucket(this, 'FrontendBucket', {
+            encryption: aws_s3_1.BucketEncryption.S3_MANAGED,
+            blockPublicAccess: aws_s3_1.BlockPublicAccess.BLOCK_ALL,
+            removalPolicy: removalPolicy,
+            autoDeleteObjects: removalPolicy === aws_cdk_lib_1.RemovalPolicy.DESTROY,
+        });
+        // Create CloudFront distribution
+        this.distribution = this._createDistribution(props, removalPolicy);
+        // Deploy frontend assets to S3
+        const buildOutputDirectory = props.buildOutputDirectory || path.join(props.sourceDirectory, 'build');
+        this.bucketDeployment = new aws_s3_deployment_1.BucketDeployment(this, 'FrontendDeployment', {
+            sources: this.asset
+                ? [aws_s3_deployment_1.Source.bucket(this.asset.bucket, this.asset.s3ObjectKey)]
+                : [aws_s3_deployment_1.Source.asset(buildOutputDirectory)],
+            destinationBucket: this.bucket,
+            distribution: this.distribution,
+            distributionPaths: ['/*'],
+        });
+        this.bucketDeployment.handlerRole.addToPrincipalPolicy(new aws_iam_1.PolicyStatement({
+            effect: aws_iam_1.Effect.ALLOW,
+            actions: [
+                'cloudfront:GetInvalidation',
+                'cloudfront:CreateInvalidation',
+            ],
+            resources: ['*'],
+        }));
+        // Note: BucketDeployment doesn't support applyRemovalPolicy directly
+        // It will be cleaned up when the bucket is deleted due to autoDeleteObjects
+        // Setup custom domain if provided
+        if (props.customDomain) {
+            this.domainName = props.customDomain.domainName;
+            this._setupCustomDomain(props.customDomain, removalPolicy);
+        }
+    }
+    /**
+     * Validates the construct properties
+     * @param props The frontend properties
+     * @private
+     */
+    _validateProps(props) {
+        if (!props.sourceDirectory) {
+            throw new Error('sourceDirectory is required');
+        }
+        if (props.customDomain?.domainName && !props.customDomain.certificate) {
+            throw new Error('certificate is required when domainName is provided');
+        }
+    }
+    /**
+     * Creates an Asset for the frontend source code with bundling
+     * @param props The frontend properties
+     * @returns The Asset containing the built frontend
+     * @private
+     */
+    _createAsset(props) {
+        const buildCommand = props.buildCommand || 'npm run build';
+        const buildOutputDirectory = props.buildOutputDirectory || path.join(props.sourceDirectory, 'build');
+        // Extract the build directory name from the full path
+        const buildDirName = path.basename(buildOutputDirectory);
+        const asset = new aws_s3_assets_1.Asset(this, 'FrontendAsset', {
+            path: props.sourceDirectory,
+            bundling: {
+                image: aws_cdk_lib_1.DockerImage.fromRegistry('public.ecr.aws/docker/library/node:lts-alpine'),
+                command: [
+                    'sh', '-c', [
+                        'cd /asset-input',
+                        'npm ci --only=production',
+                        buildCommand,
+                        `cp -r ./${buildDirName}/* /asset-output/`,
+                    ].join(' && '),
+                ],
+                user: 'root',
+            },
+        });
+        // Note: Asset doesn't support applyRemovalPolicy directly
+        // The underlying S3 objects will be managed by the asset bucket's removal policy
+        return asset;
+    }
+    /**
+     * Creates the CloudFront distribution
+     * @param props The frontend properties
+     * @param removalPolicy The removal policy to apply
+     * @returns The CloudFront distribution
+     * @private
+     */
+    _createDistribution(props, removalPolicy) {
+        const errorResponses = props.errorResponses || exports.DEFAULT_SPA_ERROR_RESPONSES;
+        // Create a CloudFront function for security headers
+        const securityHeadersFunction = new aws_cloudfront_1.Function(this, 'SecurityHeadersFunction', {
+            code: aws_cloudfront_1.FunctionCode.fromInline(`
+        function handler(event) {
+          var response = event.response;
+          var headers = response.headers;
+          
+          // Add security headers
+          headers['strict-transport-security'] = { value: 'max-age=63072000; includeSubdomains; preload' };
+          headers['content-type-options'] = { value: 'nosniff' };
+          headers['x-frame-options'] = { value: 'DENY' };
+          headers['x-content-type-options'] = { value: 'nosniff' };
+          headers['referrer-policy'] = { value: 'strict-origin-when-cross-origin' };
+          headers['permissions-policy'] = { value: 'camera=(), microphone=(), geolocation=()' };
+          
+          return response;
+        }
+      `),
+        });
+        // Apply removal policy to CloudFront function
+        securityHeadersFunction.applyRemovalPolicy(removalPolicy);
+        const distributionConfig = {
+            defaultBehavior: {
+                origin: aws_cloudfront_origins_1.S3BucketOrigin.withOriginAccessControl(this.bucket),
+                viewerProtocolPolicy: aws_cloudfront_1.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+                functionAssociations: [
+                    {
+                        function: securityHeadersFunction,
+                        eventType: aws_cloudfront_1.FunctionEventType.VIEWER_RESPONSE,
+                    },
+                ],
+            },
+            defaultRootObject: 'index.html',
+            errorResponses,
+            comment: props.distributionProps?.comment,
+            enabled: props.distributionProps?.enabled,
+            priceClass: props.distributionProps?.priceClass,
+            webAclId: props.distributionProps?.webAclId,
+        };
+        // Add custom domain configuration if provided
+        let distribution;
+        if (props.customDomain) {
+            distribution = new aws_cloudfront_1.Distribution(this, 'FrontendDistribution', {
+                ...distributionConfig,
+                domainNames: [props.customDomain.domainName],
+                certificate: props.customDomain.certificate,
+            });
+        }
+        else {
+            distribution = new aws_cloudfront_1.Distribution(this, 'FrontendDistribution', distributionConfig);
+        }
+        // Apply removal policy to distribution
+        distribution.applyRemovalPolicy(removalPolicy);
+        return distribution;
+    }
+    /**
+     * Sets up custom domain with Route53 record
+     * @param customDomain The custom domain configuration
+     * @param removalPolicy The removal policy to apply
+     * @private
+     */
+    _setupCustomDomain(customDomain, removalPolicy) {
+        if (customDomain.hostedZone) {
+            const aliasRecord = new aws_route53_1.ARecord(this, 'FrontendAliasRecord', {
+                zone: customDomain.hostedZone,
+                recordName: customDomain.domainName,
+                target: aws_route53_1.RecordTarget.fromAlias(new aws_route53_targets_1.CloudFrontTarget(this.distribution)),
+            });
+            // Apply removal policy to Route53 record
+            aliasRecord.applyRemovalPolicy(removalPolicy);
+        }
+    }
+    /**
+     * Gets the URL of the frontend application
+     * @returns The frontend URL
+     */
+    url() {
+        return this.domainName
+            ? `https://${this.domainName}`
+            : `https://${this.distribution.distributionDomainName}`;
+    }
+    /**
+     * Gets the CloudFront distribution domain name
+     * @returns The CloudFront domain name
+     */
+    distributionDomainName() {
+        return this.distribution.distributionDomainName;
+    }
+    /**
+     * Gets the S3 bucket name
+     * @returns The S3 bucket name
+     */
+    bucketName() {
+        return this.bucket.bucketName;
+    }
+}
+exports.Frontend = Frontend;
+_a = JSII_RTTI_SYMBOL_1;
+Frontend[_a] = { fqn: "@cdklabs/cdk-appmod-catalog-blueprints.Frontend", version: "1.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"frontend-construct.js","sourceRoot":"","sources":["../../use-cases/webapp/frontend-construct.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// SPDX-License-Identifier: Apache-2.0\n\nimport * as path from 'path';\nimport { DockerImage, PropertyInjectors, RemovalPolicy } from 'aws-cdk-lib';\nimport { ICertificate } from 'aws-cdk-lib/aws-certificatemanager';\nimport {\n  Distribution,\n  DistributionProps,\n  ErrorResponse,\n  Function as CloudFrontFunction,\n  FunctionCode,\n  FunctionEventType,\n  PriceClass,\n  ViewerProtocolPolicy,\n} from 'aws-cdk-lib/aws-cloudfront';\nimport { S3BucketOrigin } from 'aws-cdk-lib/aws-cloudfront-origins';\nimport { Effect, PolicyStatement } from 'aws-cdk-lib/aws-iam';\nimport { ARecord, IHostedZone, RecordTarget } from 'aws-cdk-lib/aws-route53';\nimport { CloudFrontTarget } from 'aws-cdk-lib/aws-route53-targets';\nimport { BlockPublicAccess, Bucket, BucketEncryption } from 'aws-cdk-lib/aws-s3';\nimport { Asset } from 'aws-cdk-lib/aws-s3-assets';\nimport { BucketDeployment, Source } from 'aws-cdk-lib/aws-s3-deployment';\nimport { Construct } from 'constructs';\nimport { CloudfrontDistributionObservabilityPropertyInjector } from '../utilities';\n\n/**\n * Default CloudFront error responses for Single Page Applications\n */\nexport const DEFAULT_SPA_ERROR_RESPONSES: ErrorResponse[] = [\n  {\n    httpStatus: 403,\n    responseHttpStatus: 200,\n    responsePagePath: '/index.html',\n  },\n  {\n    httpStatus: 404,\n    responseHttpStatus: 200,\n    responsePagePath: '/index.html',\n  },\n];\n\n/**\n * Custom domain configuration for the frontend\n */\nexport interface CustomDomainConfig {\n  /** Domain name for the frontend (e.g., 'app.example.com') */\n  readonly domainName: string;\n  /** SSL certificate for the domain (required when domainName is provided) */\n  readonly certificate: ICertificate;\n  /** Optional hosted zone for automatic DNS record creation */\n  readonly hostedZone?: IHostedZone;\n}\n\n/**\n * Additional CloudFront distribution properties\n */\nexport interface AdditionalDistributionProps {\n  /** Optional comment for the distribution */\n  readonly comment?: string;\n  /** Optional enabled flag for the distribution */\n  readonly enabled?: boolean;\n  /** Optional price class for the distribution */\n  readonly priceClass?: PriceClass;\n  /** Optional web ACL ID for the distribution */\n  readonly webAclId?: string;\n}\n\n/**\n * Properties for the Frontend construct\n */\nexport interface FrontendProps {\n  /** Base directory of the frontend source code */\n  readonly sourceDirectory: string;\n  /** Directory where build artifacts are located after build command completes (defaults to '{sourceDirectory}/build') */\n  readonly buildOutputDirectory?: string;\n  /** Optional build command (defaults to 'npm run build') */\n  readonly buildCommand?: string;\n  /** Optional custom domain configuration */\n  readonly customDomain?: CustomDomainConfig;\n  /** Optional CloudFront error responses (defaults to SPA-friendly responses) */\n  readonly errorResponses?: ErrorResponse[];\n  /** Optional additional CloudFront distribution properties */\n  readonly distributionProps?: AdditionalDistributionProps;\n  /** Optional flag to skip the build process (useful for pre-built artifacts) */\n  readonly skipBuild?: boolean;\n  /** Optional removal policy for all resources (defaults to DESTROY) */\n  readonly removalPolicy?: RemovalPolicy;\n  /**\n   * Enable logging and tracing for all supporting resource\n   * @default false\n   */\n  readonly enableObservability?: boolean;\n}\n\n/**\n * Frontend construct that deploys a frontend application to S3 and CloudFront\n *\n * This construct provides a complete solution for hosting static frontend applications\n * with the following features:\n * - S3 bucket for hosting static assets with security best practices\n * - CloudFront distribution for global content delivery\n * - Optional custom domain with SSL certificate\n * - Automatic build process execution\n * - SPA-friendly error handling by default\n * - Security configurations\n */\nexport class Frontend extends Construct {\n  /** The S3 bucket hosting the frontend assets */\n  public readonly bucket: Bucket;\n  /** The CloudFront distribution */\n  public readonly distribution: Distribution;\n  /** The bucket deployment that uploads the frontend assets */\n  public readonly bucketDeployment: BucketDeployment;\n  /** The custom domain name (if configured) */\n  public readonly domainName?: string;\n  /** The Asset containing the frontend source code */\n  public readonly asset?: Asset;\n\n  /**\n   * Creates a new Frontend\n   * @param scope The construct scope\n   * @param id The construct ID\n   * @param props The frontend properties\n   */\n  constructor(scope: Construct, id: string, props: FrontendProps) {\n    super(scope, id);\n\n    if (props.enableObservability) {\n      PropertyInjectors.of(this).add(\n        new CloudfrontDistributionObservabilityPropertyInjector(),\n      );\n    }\n\n    // Validate required parameters\n    this._validateProps(props);\n\n    // Get removal policy with default\n    const removalPolicy = props.removalPolicy || RemovalPolicy.DESTROY;\n\n    // Create asset for source code with optional bundling\n    if (!props.skipBuild) {\n      this.asset = this._createAsset(props);\n    }\n\n    // Create S3 bucket for hosting\n    this.bucket = new Bucket(this, 'FrontendBucket', {\n      encryption: BucketEncryption.S3_MANAGED,\n      blockPublicAccess: BlockPublicAccess.BLOCK_ALL,\n      removalPolicy: removalPolicy,\n      autoDeleteObjects: removalPolicy === RemovalPolicy.DESTROY,\n    });\n\n    // Create CloudFront distribution\n    this.distribution = this._createDistribution(props, removalPolicy);\n\n    // Deploy frontend assets to S3\n    const buildOutputDirectory = props.buildOutputDirectory || path.join(props.sourceDirectory, 'build');\n    this.bucketDeployment = new BucketDeployment(this, 'FrontendDeployment', {\n      sources: this.asset\n        ? [Source.bucket(this.asset.bucket, this.asset.s3ObjectKey)]\n        : [Source.asset(buildOutputDirectory)],\n      destinationBucket: this.bucket,\n      distribution: this.distribution,\n      distributionPaths: ['/*'],\n    });\n\n    this.bucketDeployment.handlerRole.addToPrincipalPolicy(new PolicyStatement({\n      effect: Effect.ALLOW,\n      actions: [\n        'cloudfront:GetInvalidation',\n        'cloudfront:CreateInvalidation',\n      ],\n      resources: ['*'],\n    }));\n\n    // Note: BucketDeployment doesn't support applyRemovalPolicy directly\n    // It will be cleaned up when the bucket is deleted due to autoDeleteObjects\n\n    // Setup custom domain if provided\n    if (props.customDomain) {\n      this.domainName = props.customDomain.domainName;\n      this._setupCustomDomain(props.customDomain, removalPolicy);\n    }\n  }\n\n  /**\n   * Validates the construct properties\n   * @param props The frontend properties\n   * @private\n   */\n  private _validateProps(props: FrontendProps): void {\n    if (!props.sourceDirectory) {\n      throw new Error('sourceDirectory is required');\n    }\n\n    if (props.customDomain?.domainName && !props.customDomain.certificate) {\n      throw new Error('certificate is required when domainName is provided');\n    }\n  }\n\n  /**\n   * Creates an Asset for the frontend source code with bundling\n   * @param props The frontend properties\n   * @returns The Asset containing the built frontend\n   * @private\n   */\n  private _createAsset(props: FrontendProps): Asset {\n    const buildCommand = props.buildCommand || 'npm run build';\n    const buildOutputDirectory = props.buildOutputDirectory || path.join(props.sourceDirectory, 'build');\n\n    // Extract the build directory name from the full path\n    const buildDirName = path.basename(buildOutputDirectory);\n\n    const asset = new Asset(this, 'FrontendAsset', {\n      path: props.sourceDirectory,\n      bundling: {\n        image: DockerImage.fromRegistry('public.ecr.aws/docker/library/node:lts-alpine'),\n        command: [\n          'sh', '-c', [\n            'cd /asset-input',\n            'npm ci --only=production',\n            buildCommand,\n            `cp -r ./${buildDirName}/* /asset-output/`,\n          ].join(' && '),\n        ],\n        user: 'root',\n      },\n    });\n\n    // Note: Asset doesn't support applyRemovalPolicy directly\n    // The underlying S3 objects will be managed by the asset bucket's removal policy\n\n    return asset;\n  }\n\n  /**\n   * Creates the CloudFront distribution\n   * @param props The frontend properties\n   * @param removalPolicy The removal policy to apply\n   * @returns The CloudFront distribution\n   * @private\n   */\n  private _createDistribution(props: FrontendProps, removalPolicy: RemovalPolicy): Distribution {\n    const errorResponses = props.errorResponses || DEFAULT_SPA_ERROR_RESPONSES;\n\n    // Create a CloudFront function for security headers\n    const securityHeadersFunction = new CloudFrontFunction(this, 'SecurityHeadersFunction', {\n      code: FunctionCode.fromInline(`\n        function handler(event) {\n          var response = event.response;\n          var headers = response.headers;\n          \n          // Add security headers\n          headers['strict-transport-security'] = { value: 'max-age=63072000; includeSubdomains; preload' };\n          headers['content-type-options'] = { value: 'nosniff' };\n          headers['x-frame-options'] = { value: 'DENY' };\n          headers['x-content-type-options'] = { value: 'nosniff' };\n          headers['referrer-policy'] = { value: 'strict-origin-when-cross-origin' };\n          headers['permissions-policy'] = { value: 'camera=(), microphone=(), geolocation=()' };\n          \n          return response;\n        }\n      `),\n    });\n\n    // Apply removal policy to CloudFront function\n    securityHeadersFunction.applyRemovalPolicy(removalPolicy);\n\n    const distributionConfig: DistributionProps = {\n      defaultBehavior: {\n        origin: S3BucketOrigin.withOriginAccessControl(this.bucket),\n        viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n        functionAssociations: [\n          {\n            function: securityHeadersFunction,\n            eventType: FunctionEventType.VIEWER_RESPONSE,\n          },\n        ],\n      },\n      defaultRootObject: 'index.html',\n      errorResponses,\n      comment: props.distributionProps?.comment,\n      enabled: props.distributionProps?.enabled,\n      priceClass: props.distributionProps?.priceClass,\n      webAclId: props.distributionProps?.webAclId,\n    };\n\n    // Add custom domain configuration if provided\n    let distribution: Distribution;\n    if (props.customDomain) {\n      distribution = new Distribution(this, 'FrontendDistribution', {\n        ...distributionConfig,\n        domainNames: [props.customDomain.domainName],\n        certificate: props.customDomain.certificate,\n      });\n    } else {\n      distribution = new Distribution(this, 'FrontendDistribution', distributionConfig);\n    }\n\n    // Apply removal policy to distribution\n    distribution.applyRemovalPolicy(removalPolicy);\n\n    return distribution;\n  }\n\n  /**\n   * Sets up custom domain with Route53 record\n   * @param customDomain The custom domain configuration\n   * @param removalPolicy The removal policy to apply\n   * @private\n   */\n  private _setupCustomDomain(customDomain: CustomDomainConfig, removalPolicy: RemovalPolicy): void {\n    if (customDomain.hostedZone) {\n      const aliasRecord = new ARecord(this, 'FrontendAliasRecord', {\n        zone: customDomain.hostedZone,\n        recordName: customDomain.domainName,\n        target: RecordTarget.fromAlias(new CloudFrontTarget(this.distribution)),\n      });\n\n      // Apply removal policy to Route53 record\n      aliasRecord.applyRemovalPolicy(removalPolicy);\n    }\n  }\n\n  /**\n   * Gets the URL of the frontend application\n   * @returns The frontend URL\n   */\n  public url(): string {\n    return this.domainName\n      ? `https://${this.domainName}`\n      : `https://${this.distribution.distributionDomainName}`;\n  }\n\n  /**\n   * Gets the CloudFront distribution domain name\n   * @returns The CloudFront domain name\n   */\n  public distributionDomainName(): string {\n    return this.distribution.distributionDomainName;\n  }\n\n  /**\n   * Gets the S3 bucket name\n   * @returns The S3 bucket name\n   */\n  public bucketName(): string {\n    return this.bucket.bucketName;\n  }\n}\n"]}

package/lib/webapp/index.d.ts

@@ -0,0 +1 @@
+export * from './frontend-construct';

package/lib/webapp/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./frontend-construct"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi91c2UtY2FzZXMvd2ViYXBwL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSx1REFBcUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2Zyb250ZW5kLWNvbnN0cnVjdCc7Il19

package/lib/webapp/tests/frontend-construct-nag.test.d.ts

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

package/lib/webapp/tests/frontend-construct-nag.test.js

@@ -0,0 +1,266 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+const path = require("path");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const assertions_1 = require("aws-cdk-lib/assertions");
+const aws_certificatemanager_1 = require("aws-cdk-lib/aws-certificatemanager");
+const aws_route53_1 = require("aws-cdk-lib/aws-route53");
+const cdk_nag_1 = require("cdk-nag");
+const frontend_construct_1 = require("../frontend-construct");
+// Create temporary build directory for tests
+const testBuildDir = '/tmp/test-frontend-build-nag';
+if (!fs.existsSync(testBuildDir)) {
+    fs.mkdirSync(testBuildDir, { recursive: true });
+}
+fs.writeFileSync(path.join(testBuildDir, 'index.html'), '<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Test App</h1></body></html>');
+// Create app and stack
+const app = new aws_cdk_lib_1.App();
+const stack = new aws_cdk_lib_1.Stack(app, 'TestStack', {
+    env: {
+        account: '123456789012',
+        region: 'us-east-1',
+    },
+});
+// Create SSL certificate for custom domain testing
+const certificate = aws_certificatemanager_1.Certificate.fromCertificateArn(stack, 'Certificate', 'arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012');
+// Create hosted zone for DNS testing
+const hostedZone = aws_route53_1.HostedZone.fromHostedZoneAttributes(stack, 'HostedZone', {
+    hostedZoneId: 'Z123456789',
+    zoneName: 'example.com',
+});
+// Create the main Frontend construct
+const frontend = new frontend_construct_1.Frontend(stack, 'TestFrontend', {
+    sourceDirectory: '/tmp/test-frontend-src',
+    buildOutputDirectory: testBuildDir,
+    customDomain: {
+        domainName: 'app.example.com',
+        certificate,
+        hostedZone,
+    },
+    skipBuild: true, // Skip build for testing
+});
+// Add CDK Nag suppressions for known acceptable violations
+cdk_nag_1.NagSuppressions.addResourceSuppressions(stack, [
+    {
+        id: 'AwsSolutions-CFR1',
+        reason: 'CloudFront geo restrictions are configured based on application requirements',
+    },
+    {
+        id: 'AwsSolutions-CFR2',
+        reason: 'CloudFront WAF integration is configured based on security requirements',
+    },
+    {
+        id: 'AwsSolutions-CFR3',
+        reason: 'CloudFront access logging is configured based on compliance requirements',
+    },
+    {
+        id: 'AwsSolutions-CFR4',
+        reason: 'CloudFront viewer protocol policy is set to redirect-to-https for security',
+    },
+    {
+        id: 'AwsSolutions-S1',
+        reason: 'S3 bucket access logging is configured based on compliance requirements',
+    },
+    {
+        id: 'AwsSolutions-S2',
+        reason: 'S3 bucket public access is blocked and access is controlled via CloudFront OAC',
+    },
+    {
+        id: 'AwsSolutions-S3',
+        reason: 'S3 bucket SSL requests only policy is enforced via CloudFront HTTPS redirect',
+    },
+    {
+        id: 'AwsSolutions-S10',
+        reason: 'S3 bucket MFA delete is managed through organizational security policies',
+    },
+    {
+        id: 'AwsSolutions-IAM4',
+        reason: 'AWS managed policies are acceptable for standard Lambda execution roles',
+        appliesTo: ['Policy::arn:<AWS::Partition>:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole'],
+    },
+    {
+        id: 'AwsSolutions-IAM5',
+        reason: 'BucketDeployment requires broad S3 permissions to manage deployment assets',
+        appliesTo: [
+            'Action::s3:GetObject*',
+            'Action::s3:GetBucket*',
+            'Action::s3:List*',
+            'Action::s3:DeleteObject*',
+            'Action::s3:Abort*',
+            'Resource::arn:<AWS::Partition>:s3:::cdk-hnb659fds-assets-<AWS::AccountId>-<AWS::Region>/*',
+            'Resource::arn:<AWS::Partition>:s3:::cdk-hnb659fds-assets-123456789012-us-east-1/*',
+            'Resource::<TestFrontendFrontendBucketD37D22DE.Arn>/*',
+            'Resource::*',
+        ],
+    },
+    {
+        id: 'AwsSolutions-L1',
+        reason: 'Lambda runtime versions are managed at the application deployment level',
+    },
+], true);
+// Apply CDK Nag checks
+aws_cdk_lib_1.Aspects.of(app).add(new cdk_nag_1.AwsSolutionsChecks({ verbose: true }));
+// Synthesize the stack
+assertions_1.Template.fromStack(stack);
+// Check for unsuppressed warnings and errors
+const warnings = assertions_1.Annotations.fromStack(stack).findWarning('*', assertions_1.Match.stringLikeRegexp('AwsSolutions-.*'));
+const errors = assertions_1.Annotations.fromStack(stack).findError('*', assertions_1.Match.stringLikeRegexp('AwsSolutions-.*'));
+// Test: Frontend construct is properly created and accessible
+test('Frontend construct is created successfully', () => {
+    expect(frontend).toBeDefined();
+    expect(frontend.node.id).toBe('TestFrontend');
+    expect(frontend.bucket).toBeDefined();
+    expect(frontend.distribution).toBeDefined();
+    expect(frontend.bucketDeployment).toBeDefined();
+});
+// Test: Frontend construct has expected properties
+test('Frontend construct has expected properties', () => {
+    expect(frontend.bucket.bucketName).toBeDefined();
+    expect(frontend.distribution.distributionId).toBeDefined();
+    expect(frontend.domainName).toBe('app.example.com');
+    expect(frontend.url()).toBe('https://app.example.com');
+    expect(typeof frontend.bucketName()).toBe('string');
+    expect(typeof frontend.distributionDomainName()).toBe('string');
+});
+// Test: Template contains expected frontend resources
+test('Template contains expected frontend resources', () => {
+    const template = assertions_1.Template.fromStack(stack);
+    // Verify S3 bucket exists with security configuration
+    template.hasResourceProperties('AWS::S3::Bucket', {
+        BucketEncryption: {
+            ServerSideEncryptionConfiguration: [
+                {
+                    ServerSideEncryptionByDefault: {
+                        SSEAlgorithm: 'AES256',
+                    },
+                },
+            ],
+        },
+        PublicAccessBlockConfiguration: {
+            BlockPublicAcls: true,
+            BlockPublicPolicy: true,
+            IgnorePublicAcls: true,
+            RestrictPublicBuckets: true,
+        },
+    });
+    // Verify CloudFront distribution exists with security configuration
+    template.hasResourceProperties('AWS::CloudFront::Distribution', {
+        DistributionConfig: {
+            Aliases: ['app.example.com'],
+            DefaultRootObject: 'index.html',
+            DefaultCacheBehavior: {
+                ViewerProtocolPolicy: 'redirect-to-https',
+            },
+            CustomErrorResponses: [
+                {
+                    ErrorCode: 403,
+                    ResponseCode: 200,
+                    ResponsePagePath: '/index.html',
+                },
+                {
+                    ErrorCode: 404,
+                    ResponseCode: 200,
+                    ResponsePagePath: '/index.html',
+                },
+            ],
+            ViewerCertificate: {
+                AcmCertificateArn: 'arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012',
+                SslSupportMethod: 'sni-only',
+            },
+        },
+    });
+    // Verify CloudFront security headers function exists
+    template.hasResourceProperties('AWS::CloudFront::Function', {
+        FunctionConfig: {
+            Runtime: 'cloudfront-js-1.0',
+        },
+    });
+    // Verify Route53 A record exists for custom domain
+    template.hasResourceProperties('AWS::Route53::RecordSet', {
+        Type: 'A',
+        Name: 'app.example.com.',
+        HostedZoneId: 'Z123456789',
+    });
+    // Verify bucket deployment exists
+    template.hasResource('Custom::CDKBucketDeployment', {});
+    // Verify auto delete objects custom resource exists
+    template.hasResource('Custom::S3AutoDeleteObjects', {});
+});
+// Test: Frontend construct enforces security best practices
+test('Frontend construct enforces security best practices', () => {
+    const template = assertions_1.Template.fromStack(stack);
+    // Verify HTTPS redirect is enforced
+    template.hasResourceProperties('AWS::CloudFront::Distribution', {
+        DistributionConfig: {
+            DefaultCacheBehavior: {
+                ViewerProtocolPolicy: 'redirect-to-https',
+            },
+        },
+    });
+    // Verify S3 bucket blocks public access
+    template.hasResourceProperties('AWS::S3::Bucket', {
+        PublicAccessBlockConfiguration: {
+            BlockPublicAcls: true,
+            BlockPublicPolicy: true,
+            IgnorePublicAcls: true,
+            RestrictPublicBuckets: true,
+        },
+    });
+    // Verify S3 bucket has encryption
+    template.hasResourceProperties('AWS::S3::Bucket', {
+        BucketEncryption: {
+            ServerSideEncryptionConfiguration: [
+                {
+                    ServerSideEncryptionByDefault: {
+                        SSEAlgorithm: 'AES256',
+                    },
+                },
+            ],
+        },
+    });
+});
+// Test: Frontend construct supports SPA applications
+test('Frontend construct supports SPA applications', () => {
+    const template = assertions_1.Template.fromStack(stack);
+    // Verify SPA-friendly error responses
+    template.hasResourceProperties('AWS::CloudFront::Distribution', {
+        DistributionConfig: {
+            CustomErrorResponses: [
+                {
+                    ErrorCode: 403,
+                    ResponseCode: 200,
+                    ResponsePagePath: '/index.html',
+                },
+                {
+                    ErrorCode: 404,
+                    ResponseCode: 200,
+                    ResponsePagePath: '/index.html',
+                },
+            ],
+        },
+    });
+    // Verify default root object is set
+    template.hasResourceProperties('AWS::CloudFront::Distribution', {
+        DistributionConfig: {
+            DefaultRootObject: 'index.html',
+        },
+    });
+});
+// Test: No unsuppressed warnings
+test('No unsuppressed warnings', () => {
+    if (warnings.length > 0) {
+        console.log('CDK Nag Warnings:', JSON.stringify(warnings, null, 2));
+    }
+    expect(warnings).toHaveLength(0);
+});
+// Test: No unsuppressed errors
+test('No unsuppressed errors', () => {
+    if (errors.length > 0) {
+        console.log('CDK Nag Errors:', JSON.stringify(errors, null, 2));
+    }
+    expect(errors).toHaveLength(0);
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"frontend-construct-nag.test.js","sourceRoot":"","sources":["../../../use-cases/webapp/tests/frontend-construct-nag.test.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// SPDX-License-Identifier: Apache-2.0\n\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport { App, Stack, Aspects } from 'aws-cdk-lib';\nimport { Template, Annotations, Match } from 'aws-cdk-lib/assertions';\nimport { Certificate } from 'aws-cdk-lib/aws-certificatemanager';\nimport { HostedZone } from 'aws-cdk-lib/aws-route53';\nimport { AwsSolutionsChecks, NagSuppressions } from 'cdk-nag';\nimport { Frontend } from '../frontend-construct';\n\n// Create temporary build directory for tests\nconst testBuildDir = '/tmp/test-frontend-build-nag';\nif (!fs.existsSync(testBuildDir)) {\n  fs.mkdirSync(testBuildDir, { recursive: true });\n}\nfs.writeFileSync(path.join(testBuildDir, 'index.html'), '<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Test App</h1></body></html>');\n\n// Create app and stack\nconst app = new App();\nconst stack = new Stack(app, 'TestStack', {\n  env: {\n    account: '123456789012',\n    region: 'us-east-1',\n  },\n});\n\n// Create SSL certificate for custom domain testing\nconst certificate = Certificate.fromCertificateArn(\n  stack,\n  'Certificate',\n  'arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012',\n);\n\n// Create hosted zone for DNS testing\nconst hostedZone = HostedZone.fromHostedZoneAttributes(stack, 'HostedZone', {\n  hostedZoneId: 'Z123456789',\n  zoneName: 'example.com',\n});\n\n// Create the main Frontend construct\nconst frontend = new Frontend(stack, 'TestFrontend', {\n  sourceDirectory: '/tmp/test-frontend-src',\n  buildOutputDirectory: testBuildDir,\n  customDomain: {\n    domainName: 'app.example.com',\n    certificate,\n    hostedZone,\n  },\n  skipBuild: true, // Skip build for testing\n});\n\n// Add CDK Nag suppressions for known acceptable violations\nNagSuppressions.addResourceSuppressions(stack, [\n  {\n    id: 'AwsSolutions-CFR1',\n    reason: 'CloudFront geo restrictions are configured based on application requirements',\n  },\n  {\n    id: 'AwsSolutions-CFR2',\n    reason: 'CloudFront WAF integration is configured based on security requirements',\n  },\n  {\n    id: 'AwsSolutions-CFR3',\n    reason: 'CloudFront access logging is configured based on compliance requirements',\n  },\n  {\n    id: 'AwsSolutions-CFR4',\n    reason: 'CloudFront viewer protocol policy is set to redirect-to-https for security',\n  },\n  {\n    id: 'AwsSolutions-S1',\n    reason: 'S3 bucket access logging is configured based on compliance requirements',\n  },\n  {\n    id: 'AwsSolutions-S2',\n    reason: 'S3 bucket public access is blocked and access is controlled via CloudFront OAC',\n  },\n  {\n    id: 'AwsSolutions-S3',\n    reason: 'S3 bucket SSL requests only policy is enforced via CloudFront HTTPS redirect',\n  },\n  {\n    id: 'AwsSolutions-S10',\n    reason: 'S3 bucket MFA delete is managed through organizational security policies',\n  },\n  {\n    id: 'AwsSolutions-IAM4',\n    reason: 'AWS managed policies are acceptable for standard Lambda execution roles',\n    appliesTo: ['Policy::arn:<AWS::Partition>:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole'],\n  },\n  {\n    id: 'AwsSolutions-IAM5',\n    reason: 'BucketDeployment requires broad S3 permissions to manage deployment assets',\n    appliesTo: [\n      'Action::s3:GetObject*',\n      'Action::s3:GetBucket*',\n      'Action::s3:List*',\n      'Action::s3:DeleteObject*',\n      'Action::s3:Abort*',\n      'Resource::arn:<AWS::Partition>:s3:::cdk-hnb659fds-assets-<AWS::AccountId>-<AWS::Region>/*',\n      'Resource::arn:<AWS::Partition>:s3:::cdk-hnb659fds-assets-123456789012-us-east-1/*',\n      'Resource::<TestFrontendFrontendBucketD37D22DE.Arn>/*',\n      'Resource::*',\n    ],\n  },\n  {\n    id: 'AwsSolutions-L1',\n    reason: 'Lambda runtime versions are managed at the application deployment level',\n  },\n], true);\n\n// Apply CDK Nag checks\nAspects.of(app).add(new AwsSolutionsChecks({ verbose: true }));\n\n// Synthesize the stack\nTemplate.fromStack(stack);\n\n// Check for unsuppressed warnings and errors\nconst warnings = Annotations.fromStack(stack).findWarning('*', Match.stringLikeRegexp('AwsSolutions-.*'));\nconst errors = Annotations.fromStack(stack).findError('*', Match.stringLikeRegexp('AwsSolutions-.*'));\n\n// Test: Frontend construct is properly created and accessible\ntest('Frontend construct is created successfully', () => {\n  expect(frontend).toBeDefined();\n  expect(frontend.node.id).toBe('TestFrontend');\n  expect(frontend.bucket).toBeDefined();\n  expect(frontend.distribution).toBeDefined();\n  expect(frontend.bucketDeployment).toBeDefined();\n});\n\n// Test: Frontend construct has expected properties\ntest('Frontend construct has expected properties', () => {\n  expect(frontend.bucket.bucketName).toBeDefined();\n  expect(frontend.distribution.distributionId).toBeDefined();\n  expect(frontend.domainName).toBe('app.example.com');\n  expect(frontend.url()).toBe('https://app.example.com');\n  expect(typeof frontend.bucketName()).toBe('string');\n  expect(typeof frontend.distributionDomainName()).toBe('string');\n});\n\n// Test: Template contains expected frontend resources\ntest('Template contains expected frontend resources', () => {\n  const template = Template.fromStack(stack);\n\n  // Verify S3 bucket exists with security configuration\n  template.hasResourceProperties('AWS::S3::Bucket', {\n    BucketEncryption: {\n      ServerSideEncryptionConfiguration: [\n        {\n          ServerSideEncryptionByDefault: {\n            SSEAlgorithm: 'AES256',\n          },\n        },\n      ],\n    },\n    PublicAccessBlockConfiguration: {\n      BlockPublicAcls: true,\n      BlockPublicPolicy: true,\n      IgnorePublicAcls: true,\n      RestrictPublicBuckets: true,\n    },\n  });\n\n  // Verify CloudFront distribution exists with security configuration\n  template.hasResourceProperties('AWS::CloudFront::Distribution', {\n    DistributionConfig: {\n      Aliases: ['app.example.com'],\n      DefaultRootObject: 'index.html',\n      DefaultCacheBehavior: {\n        ViewerProtocolPolicy: 'redirect-to-https',\n      },\n      CustomErrorResponses: [\n        {\n          ErrorCode: 403,\n          ResponseCode: 200,\n          ResponsePagePath: '/index.html',\n        },\n        {\n          ErrorCode: 404,\n          ResponseCode: 200,\n          ResponsePagePath: '/index.html',\n        },\n      ],\n      ViewerCertificate: {\n        AcmCertificateArn: 'arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012',\n        SslSupportMethod: 'sni-only',\n      },\n    },\n  });\n\n  // Verify CloudFront security headers function exists\n  template.hasResourceProperties('AWS::CloudFront::Function', {\n    FunctionConfig: {\n      Runtime: 'cloudfront-js-1.0',\n    },\n  });\n\n  // Verify Route53 A record exists for custom domain\n  template.hasResourceProperties('AWS::Route53::RecordSet', {\n    Type: 'A',\n    Name: 'app.example.com.',\n    HostedZoneId: 'Z123456789',\n  });\n\n  // Verify bucket deployment exists\n  template.hasResource('Custom::CDKBucketDeployment', {});\n\n  // Verify auto delete objects custom resource exists\n  template.hasResource('Custom::S3AutoDeleteObjects', {});\n});\n\n// Test: Frontend construct enforces security best practices\ntest('Frontend construct enforces security best practices', () => {\n  const template = Template.fromStack(stack);\n\n  // Verify HTTPS redirect is enforced\n  template.hasResourceProperties('AWS::CloudFront::Distribution', {\n    DistributionConfig: {\n      DefaultCacheBehavior: {\n        ViewerProtocolPolicy: 'redirect-to-https',\n      },\n    },\n  });\n\n  // Verify S3 bucket blocks public access\n  template.hasResourceProperties('AWS::S3::Bucket', {\n    PublicAccessBlockConfiguration: {\n      BlockPublicAcls: true,\n      BlockPublicPolicy: true,\n      IgnorePublicAcls: true,\n      RestrictPublicBuckets: true,\n    },\n  });\n\n  // Verify S3 bucket has encryption\n  template.hasResourceProperties('AWS::S3::Bucket', {\n    BucketEncryption: {\n      ServerSideEncryptionConfiguration: [\n        {\n          ServerSideEncryptionByDefault: {\n            SSEAlgorithm: 'AES256',\n          },\n        },\n      ],\n    },\n  });\n});\n\n// Test: Frontend construct supports SPA applications\ntest('Frontend construct supports SPA applications', () => {\n  const template = Template.fromStack(stack);\n\n  // Verify SPA-friendly error responses\n  template.hasResourceProperties('AWS::CloudFront::Distribution', {\n    DistributionConfig: {\n      CustomErrorResponses: [\n        {\n          ErrorCode: 403,\n          ResponseCode: 200,\n          ResponsePagePath: '/index.html',\n        },\n        {\n          ErrorCode: 404,\n          ResponseCode: 200,\n          ResponsePagePath: '/index.html',\n        },\n      ],\n    },\n  });\n\n  // Verify default root object is set\n  template.hasResourceProperties('AWS::CloudFront::Distribution', {\n    DistributionConfig: {\n      DefaultRootObject: 'index.html',\n    },\n  });\n});\n\n// Test: No unsuppressed warnings\ntest('No unsuppressed warnings', () => {\n  if (warnings.length > 0) {\n    console.log('CDK Nag Warnings:', JSON.stringify(warnings, null, 2));\n  }\n  expect(warnings).toHaveLength(0);\n});\n\n// Test: No unsuppressed errors\ntest('No unsuppressed errors', () => {\n  if (errors.length > 0) {\n    console.log('CDK Nag Errors:', JSON.stringify(errors, null, 2));\n  }\n  expect(errors).toHaveLength(0);\n});\n"]}

package/lib/webapp/tests/frontend-construct.test.d.ts

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