npm - @cdklabs/cdk-appmod-catalog-blueprints - Versions diffs - 1.0.0 - Mend

@cdklabs/cdk-appmod-catalog-blueprints 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (105) hide show

package/lib/webapp/tests/frontend-construct.test.js ADDED Viewed

@@ -0,0 +1,385 @@
+"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_cloudfront_1 = require("aws-cdk-lib/aws-cloudfront");
+const aws_route53_1 = require("aws-cdk-lib/aws-route53");
+const aws_s3_1 = require("aws-cdk-lib/aws-s3");
+const aws_s3_deployment_1 = require("aws-cdk-lib/aws-s3-deployment");
+const frontend_construct_1 = require("../frontend-construct");
+// Mock execSync to avoid actual build execution during tests
+jest.mock('child_process', () => ({
+    execSync: jest.fn(),
+}));
+describe('@webapp Frontend', () => {
+    let app;
+    let stack;
+    let template;
+    let testBuildDir;
+    let testSrcDir;
+    beforeAll(() => {
+        // Create a temporary build directory for tests
+        testBuildDir = '/tmp/test-frontend-build';
+        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 a temporary source directory for tests
+        testSrcDir = '/tmp/test-frontend-src';
+        if (!fs.existsSync(testSrcDir)) {
+            fs.mkdirSync(testSrcDir, { recursive: true });
+        }
+        // Create default build directory inside source directory
+        const defaultBuildDir = path.join(testSrcDir, 'build');
+        if (!fs.existsSync(defaultBuildDir)) {
+            fs.mkdirSync(defaultBuildDir, { recursive: true });
+        }
+        fs.writeFileSync(path.join(defaultBuildDir, 'index.html'), '<!DOCTYPE html><html><head><title>Default Test</title></head><body><h1>Default Test App</h1></body></html>');
+    });
+    beforeEach(() => {
+        app = new aws_cdk_lib_1.App();
+        stack = new aws_cdk_lib_1.Stack(app, 'TestStack');
+    });
+    describe('@webapp Basic functionality', () => {
+        test('@webapp creates frontend construct with minimal configuration', () => {
+            const frontend = new frontend_construct_1.Frontend(stack, 'Frontend', {
+                sourceDirectory: '/tmp/test-frontend-src',
+                buildOutputDirectory: testBuildDir,
+                skipBuild: true, // Skip build for testing
+            });
+            template = assertions_1.Template.fromStack(stack);
+            // Verify S3 bucket is created
+            template.hasResourceProperties('AWS::S3::Bucket', {
+                BucketEncryption: {
+                    ServerSideEncryptionConfiguration: [
+                        {
+                            ServerSideEncryptionByDefault: {
+                                SSEAlgorithm: 'AES256',
+                            },
+                        },
+                    ],
+                },
+                PublicAccessBlockConfiguration: {
+                    BlockPublicAcls: true,
+                    BlockPublicPolicy: true,
+                    IgnorePublicAcls: true,
+                    RestrictPublicBuckets: true,
+                },
+            });
+            // Verify CloudFront distribution is created
+            template.hasResourceProperties('AWS::CloudFront::Distribution', {
+                DistributionConfig: {
+                    DefaultRootObject: 'index.html',
+                    CustomErrorResponses: [
+                        {
+                            ErrorCode: 403,
+                            ResponseCode: 200,
+                            ResponsePagePath: '/index.html',
+                        },
+                        {
+                            ErrorCode: 404,
+                            ResponseCode: 200,
+                            ResponsePagePath: '/index.html',
+                        },
+                    ],
+                },
+            });
+            // Verify security headers function is created
+            template.hasResourceProperties('AWS::CloudFront::Function', {
+                FunctionConfig: {
+                    Runtime: 'cloudfront-js-1.0',
+                },
+            });
+            // Verify bucket deployment is created
+            template.hasResource('Custom::CDKBucketDeployment', {});
+            // Test public methods
+            expect(frontend.bucket).toBeInstanceOf(aws_s3_1.Bucket);
+            expect(frontend.distribution).toBeInstanceOf(aws_cloudfront_1.Distribution);
+            expect(frontend.bucketDeployment).toBeInstanceOf(aws_s3_deployment_1.BucketDeployment);
+            expect(typeof frontend.distributionDomainName()).toBe('string');
+            expect(typeof frontend.bucketName()).toBe('string');
+            expect(frontend.url()).toContain('https://');
+        });
+        test('@webapp creates frontend construct with custom build command', () => {
+            new frontend_construct_1.Frontend(stack, 'Frontend', {
+                sourceDirectory: '/tmp/test-frontend-src',
+                buildOutputDirectory: testBuildDir,
+                buildCommand: 'yarn build',
+                skipBuild: true,
+            });
+            template = assertions_1.Template.fromStack(stack);
+            // Should still create the same resources
+            template.resourceCountIs('AWS::S3::Bucket', 1);
+            template.resourceCountIs('AWS::CloudFront::Distribution', 1);
+        });
+        test('@webapp creates frontend construct with custom error responses', () => {
+            const customErrorResponses = [
+                {
+                    httpStatus: 500,
+                    responseHttpStatus: 200,
+                    responsePagePath: '/error.html',
+                },
+            ];
+            new frontend_construct_1.Frontend(stack, 'Frontend', {
+                sourceDirectory: '/tmp/test-frontend-src',
+                buildOutputDirectory: testBuildDir,
+                errorResponses: customErrorResponses,
+                skipBuild: true,
+            });
+            template = assertions_1.Template.fromStack(stack);
+            template.hasResourceProperties('AWS::CloudFront::Distribution', {
+                DistributionConfig: {
+                    CustomErrorResponses: [
+                        {
+                            ErrorCode: 500,
+                            ResponseCode: 200,
+                            ResponsePagePath: '/error.html',
+                        },
+                    ],
+                },
+            });
+        });
+    });
+    describe('@webapp Custom domain functionality', () => {
+        test('@webapp creates frontend construct with custom domain', () => {
+            const certificate = aws_certificatemanager_1.Certificate.fromCertificateArn(stack, 'Certificate', 'arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012');
+            const frontend = new frontend_construct_1.Frontend(stack, 'Frontend', {
+                sourceDirectory: '/tmp/test-frontend-src',
+                buildOutputDirectory: testBuildDir,
+                customDomain: {
+                    domainName: 'app.example.com',
+                    certificate,
+                },
+                skipBuild: true,
+            });
+            template = assertions_1.Template.fromStack(stack);
+            // Verify CloudFront distribution has custom domain
+            template.hasResourceProperties('AWS::CloudFront::Distribution', {
+                DistributionConfig: {
+                    Aliases: ['app.example.com'],
+                    ViewerCertificate: {
+                        AcmCertificateArn: 'arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012',
+                        SslSupportMethod: 'sni-only',
+                    },
+                },
+            });
+            expect(frontend.domainName).toBe('app.example.com');
+            expect(frontend.url()).toBe('https://app.example.com');
+        });
+        test('@webapp creates frontend construct with custom domain and hosted zone', () => {
+            const certificate = aws_certificatemanager_1.Certificate.fromCertificateArn(stack, 'Certificate', 'arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012');
+            const hostedZone = aws_route53_1.HostedZone.fromHostedZoneAttributes(stack, 'HostedZone', {
+                hostedZoneId: 'Z123456789',
+                zoneName: 'example.com',
+            });
+            new frontend_construct_1.Frontend(stack, 'Frontend', {
+                sourceDirectory: '/tmp/test-frontend-src',
+                buildOutputDirectory: testBuildDir,
+                customDomain: {
+                    domainName: 'app.example.com',
+                    certificate,
+                    hostedZone,
+                },
+                skipBuild: true,
+            });
+            template = assertions_1.Template.fromStack(stack);
+            // Verify Route53 A record is created
+            template.hasResourceProperties('AWS::Route53::RecordSet', {
+                Type: 'A',
+                Name: 'app.example.com.',
+                HostedZoneId: 'Z123456789',
+            });
+        });
+    });
+    describe('@webapp Validation', () => {
+        test('@webapp throws error when sourceDirectory is missing', () => {
+            expect(() => {
+                new frontend_construct_1.Frontend(stack, 'Frontend', {
+                    sourceDirectory: '',
+                    buildOutputDirectory: testBuildDir,
+                    skipBuild: true,
+                });
+            }).toThrow('sourceDirectory is required');
+        });
+        test('@webapp uses default buildOutputDirectory when not provided', () => {
+            // Use the existing test build directory
+            const frontend = new frontend_construct_1.Frontend(stack, 'Frontend', {
+                sourceDirectory: testSrcDir,
+                // buildOutputDirectory not provided - should use default './build/'
+                skipBuild: true,
+            });
+            expect(frontend).toBeDefined();
+            // The construct should be created successfully with default buildOutputDirectory
+        });
+        test('@webapp applies custom removal policy to resources', () => {
+            const retainStack = new aws_cdk_lib_1.Stack(app, 'RetainTestStack');
+            const frontend = new frontend_construct_1.Frontend(retainStack, 'Frontend', {
+                sourceDirectory: testSrcDir,
+                buildOutputDirectory: testBuildDir,
+                skipBuild: true,
+                removalPolicy: aws_cdk_lib_1.RemovalPolicy.RETAIN,
+            });
+            expect(frontend).toBeDefined();
+            // Check that the bucket has the correct removal policy
+            const retainTemplate = assertions_1.Template.fromStack(retainStack);
+            retainTemplate.hasResource('AWS::S3::Bucket', {
+                DeletionPolicy: 'Retain',
+                UpdateReplacePolicy: 'Retain',
+            });
+        });
+        test('@webapp uses default DESTROY removal policy when not specified', () => {
+            const destroyStack = new aws_cdk_lib_1.Stack(app, 'DestroyTestStack');
+            const frontend = new frontend_construct_1.Frontend(destroyStack, 'Frontend', {
+                sourceDirectory: testSrcDir,
+                buildOutputDirectory: testBuildDir,
+                skipBuild: true,
+                // removalPolicy not specified - should default to DESTROY
+            });
+            expect(frontend).toBeDefined();
+            // Check that the bucket has the default DESTROY removal policy
+            const destroyTemplate = assertions_1.Template.fromStack(destroyStack);
+            destroyTemplate.hasResource('AWS::S3::Bucket', {
+                DeletionPolicy: 'Delete',
+                UpdateReplacePolicy: 'Delete',
+            });
+        });
+        test('@webapp throws error when domainName is provided without certificate', () => {
+            expect(() => {
+                new frontend_construct_1.Frontend(stack, 'Frontend', {
+                    sourceDirectory: '/tmp/test-frontend-src',
+                    buildOutputDirectory: testBuildDir,
+                    customDomain: {
+                        domainName: 'app.example.com',
+                    }, // Type assertion to bypass TypeScript validation for testing
+                    skipBuild: true,
+                });
+            }).toThrow('certificate is required when domainName is provided');
+        });
+    });
+    describe('@webapp Security features', () => {
+        test('@webapp creates S3 bucket with security best practices', () => {
+            new frontend_construct_1.Frontend(stack, 'Frontend', {
+                sourceDirectory: '/tmp/test-frontend-src',
+                buildOutputDirectory: testBuildDir,
+                skipBuild: true,
+            });
+            template = assertions_1.Template.fromStack(stack);
+            // Verify S3 bucket security settings
+            template.hasResourceProperties('AWS::S3::Bucket', {
+                BucketEncryption: {
+                    ServerSideEncryptionConfiguration: [
+                        {
+                            ServerSideEncryptionByDefault: {
+                                SSEAlgorithm: 'AES256',
+                            },
+                        },
+                    ],
+                },
+                PublicAccessBlockConfiguration: {
+                    BlockPublicAcls: true,
+                    BlockPublicPolicy: true,
+                    IgnorePublicAcls: true,
+                    RestrictPublicBuckets: true,
+                },
+            });
+        });
+        test('@webapp creates CloudFront distribution with security headers', () => {
+            new frontend_construct_1.Frontend(stack, 'Frontend', {
+                sourceDirectory: '/tmp/test-frontend-src',
+                buildOutputDirectory: testBuildDir,
+                skipBuild: true,
+            });
+            template = assertions_1.Template.fromStack(stack);
+            // Verify security headers function exists
+            template.hasResourceProperties('AWS::CloudFront::Function', {
+                FunctionConfig: {
+                    Runtime: 'cloudfront-js-1.0',
+                },
+            });
+            // Verify HTTPS redirect is enabled
+            template.hasResourceProperties('AWS::CloudFront::Distribution', {
+                DistributionConfig: {
+                    DefaultCacheBehavior: {
+                        ViewerProtocolPolicy: 'redirect-to-https',
+                    },
+                },
+            });
+        });
+        test('@webapp enables auto delete objects on S3 bucket', () => {
+            new frontend_construct_1.Frontend(stack, 'Frontend', {
+                sourceDirectory: '/tmp/test-frontend-src',
+                buildOutputDirectory: testBuildDir,
+                skipBuild: true,
+            });
+            template = assertions_1.Template.fromStack(stack);
+            // Verify auto delete objects custom resource is created
+            template.hasResource('Custom::S3AutoDeleteObjects', {});
+        });
+    });
+    describe('@webapp Default values', () => {
+        test('@webapp uses default SPA error responses', () => {
+            new frontend_construct_1.Frontend(stack, 'Frontend', {
+                sourceDirectory: '/tmp/test-frontend-src',
+                buildOutputDirectory: testBuildDir,
+                skipBuild: true,
+            });
+            template = assertions_1.Template.fromStack(stack);
+            template.hasResourceProperties('AWS::CloudFront::Distribution', {
+                DistributionConfig: {
+                    CustomErrorResponses: [
+                        {
+                            ErrorCode: 403,
+                            ResponseCode: 200,
+                            ResponsePagePath: '/index.html',
+                        },
+                        {
+                            ErrorCode: 404,
+                            ResponseCode: 200,
+                            ResponsePagePath: '/index.html',
+                        },
+                    ],
+                },
+            });
+        });
+        test('@webapp exports default SPA error responses', () => {
+            expect(frontend_construct_1.DEFAULT_SPA_ERROR_RESPONSES).toEqual([
+                {
+                    httpStatus: 403,
+                    responseHttpStatus: 200,
+                    responsePagePath: '/index.html',
+                },
+                {
+                    httpStatus: 404,
+                    responseHttpStatus: 200,
+                    responsePagePath: '/index.html',
+                },
+            ]);
+        });
+    });
+    describe('@webapp Additional distribution properties', () => {
+        test('@webapp accepts additional CloudFront distribution properties', () => {
+            new frontend_construct_1.Frontend(stack, 'Frontend', {
+                sourceDirectory: '/tmp/test-frontend-src',
+                buildOutputDirectory: testBuildDir,
+                distributionProps: {
+                    comment: 'Custom frontend distribution',
+                    enabled: true,
+                },
+                skipBuild: true,
+            });
+            template = assertions_1.Template.fromStack(stack);
+            template.hasResourceProperties('AWS::CloudFront::Distribution', {
+                DistributionConfig: {
+                    Comment: 'Custom frontend distribution',
+                    Enabled: true,
+                },
+            });
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"frontend-construct.test.js","sourceRoot":"","sources":["../../../use-cases/webapp/tests/frontend-construct.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, RemovalPolicy, Stack } from 'aws-cdk-lib';\nimport { Template } from 'aws-cdk-lib/assertions';\nimport { Certificate } from 'aws-cdk-lib/aws-certificatemanager';\nimport { Distribution } from 'aws-cdk-lib/aws-cloudfront';\nimport { HostedZone } from 'aws-cdk-lib/aws-route53';\nimport { Bucket } from 'aws-cdk-lib/aws-s3';\nimport { BucketDeployment } from 'aws-cdk-lib/aws-s3-deployment';\nimport { Frontend, DEFAULT_SPA_ERROR_RESPONSES } from '../frontend-construct';\n\n// Mock execSync to avoid actual build execution during tests\njest.mock('child_process', () => ({\n  execSync: jest.fn(),\n}));\n\ndescribe('@webapp Frontend', () => {\n  let app: App;\n  let stack: Stack;\n  let template: Template;\n  let testBuildDir: string;\n  let testSrcDir: string;\n\n  beforeAll(() => {\n    // Create a temporary build directory for tests\n    testBuildDir = '/tmp/test-frontend-build';\n    if (!fs.existsSync(testBuildDir)) {\n      fs.mkdirSync(testBuildDir, { recursive: true });\n    }\n    fs.writeFileSync(path.join(testBuildDir, 'index.html'), '<!DOCTYPE html><html><head><title>Test</title></head><body><h1>Test App</h1></body></html>');\n\n    // Create a temporary source directory for tests\n    testSrcDir = '/tmp/test-frontend-src';\n    if (!fs.existsSync(testSrcDir)) {\n      fs.mkdirSync(testSrcDir, { recursive: true });\n    }\n\n    // Create default build directory inside source directory\n    const defaultBuildDir = path.join(testSrcDir, 'build');\n    if (!fs.existsSync(defaultBuildDir)) {\n      fs.mkdirSync(defaultBuildDir, { recursive: true });\n    }\n    fs.writeFileSync(path.join(defaultBuildDir, 'index.html'), '<!DOCTYPE html><html><head><title>Default Test</title></head><body><h1>Default Test App</h1></body></html>');\n  });\n\n  beforeEach(() => {\n    app = new App();\n    stack = new Stack(app, 'TestStack');\n  });\n\n  describe('@webapp Basic functionality', () => {\n    test('@webapp creates frontend construct with minimal configuration', () => {\n      const frontend = new Frontend(stack, 'Frontend', {\n        sourceDirectory: '/tmp/test-frontend-src',\n        buildOutputDirectory: testBuildDir,\n        skipBuild: true, // Skip build for testing\n      });\n\n      template = Template.fromStack(stack);\n\n      // Verify S3 bucket is created\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 is created\n      template.hasResourceProperties('AWS::CloudFront::Distribution', {\n        DistributionConfig: {\n          DefaultRootObject: 'index.html',\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 security headers function is created\n      template.hasResourceProperties('AWS::CloudFront::Function', {\n        FunctionConfig: {\n          Runtime: 'cloudfront-js-1.0',\n        },\n      });\n\n      // Verify bucket deployment is created\n      template.hasResource('Custom::CDKBucketDeployment', {});\n\n      // Test public methods\n      expect(frontend.bucket).toBeInstanceOf(Bucket);\n      expect(frontend.distribution).toBeInstanceOf(Distribution);\n      expect(frontend.bucketDeployment).toBeInstanceOf(BucketDeployment);\n      expect(typeof frontend.distributionDomainName()).toBe('string');\n      expect(typeof frontend.bucketName()).toBe('string');\n      expect(frontend.url()).toContain('https://');\n    });\n\n    test('@webapp creates frontend construct with custom build command', () => {\n      new Frontend(stack, 'Frontend', {\n        sourceDirectory: '/tmp/test-frontend-src',\n        buildOutputDirectory: testBuildDir,\n        buildCommand: 'yarn build',\n        skipBuild: true,\n      });\n\n      template = Template.fromStack(stack);\n\n      // Should still create the same resources\n      template.resourceCountIs('AWS::S3::Bucket', 1);\n      template.resourceCountIs('AWS::CloudFront::Distribution', 1);\n    });\n\n    test('@webapp creates frontend construct with custom error responses', () => {\n      const customErrorResponses = [\n        {\n          httpStatus: 500,\n          responseHttpStatus: 200,\n          responsePagePath: '/error.html',\n        },\n      ];\n\n      new Frontend(stack, 'Frontend', {\n        sourceDirectory: '/tmp/test-frontend-src',\n        buildOutputDirectory: testBuildDir,\n        errorResponses: customErrorResponses,\n        skipBuild: true,\n      });\n\n      template = Template.fromStack(stack);\n\n      template.hasResourceProperties('AWS::CloudFront::Distribution', {\n        DistributionConfig: {\n          CustomErrorResponses: [\n            {\n              ErrorCode: 500,\n              ResponseCode: 200,\n              ResponsePagePath: '/error.html',\n            },\n          ],\n        },\n      });\n    });\n  });\n\n  describe('@webapp Custom domain functionality', () => {\n    test('@webapp creates frontend construct with custom domain', () => {\n      const certificate = Certificate.fromCertificateArn(\n        stack,\n        'Certificate',\n        'arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012',\n      );\n\n      const frontend = new Frontend(stack, 'Frontend', {\n        sourceDirectory: '/tmp/test-frontend-src',\n        buildOutputDirectory: testBuildDir,\n        customDomain: {\n          domainName: 'app.example.com',\n          certificate,\n        },\n        skipBuild: true,\n      });\n\n      template = Template.fromStack(stack);\n\n      // Verify CloudFront distribution has custom domain\n      template.hasResourceProperties('AWS::CloudFront::Distribution', {\n        DistributionConfig: {\n          Aliases: ['app.example.com'],\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      expect(frontend.domainName).toBe('app.example.com');\n      expect(frontend.url()).toBe('https://app.example.com');\n    });\n\n    test('@webapp creates frontend construct with custom domain and hosted zone', () => {\n      const certificate = Certificate.fromCertificateArn(\n        stack,\n        'Certificate',\n        'arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012',\n      );\n\n      const hostedZone = HostedZone.fromHostedZoneAttributes(stack, 'HostedZone', {\n        hostedZoneId: 'Z123456789',\n        zoneName: 'example.com',\n      });\n\n      new Frontend(stack, 'Frontend', {\n        sourceDirectory: '/tmp/test-frontend-src',\n        buildOutputDirectory: testBuildDir,\n        customDomain: {\n          domainName: 'app.example.com',\n          certificate,\n          hostedZone,\n        },\n        skipBuild: true,\n      });\n\n      template = Template.fromStack(stack);\n\n      // Verify Route53 A record is created\n      template.hasResourceProperties('AWS::Route53::RecordSet', {\n        Type: 'A',\n        Name: 'app.example.com.',\n        HostedZoneId: 'Z123456789',\n      });\n    });\n  });\n\n  describe('@webapp Validation', () => {\n    test('@webapp throws error when sourceDirectory is missing', () => {\n      expect(() => {\n        new Frontend(stack, 'Frontend', {\n          sourceDirectory: '',\n          buildOutputDirectory: testBuildDir,\n          skipBuild: true,\n        });\n      }).toThrow('sourceDirectory is required');\n    });\n\n    test('@webapp uses default buildOutputDirectory when not provided', () => {\n      // Use the existing test build directory\n      const frontend = new Frontend(stack, 'Frontend', {\n        sourceDirectory: testSrcDir,\n        // buildOutputDirectory not provided - should use default './build/'\n        skipBuild: true,\n      });\n\n      expect(frontend).toBeDefined();\n      // The construct should be created successfully with default buildOutputDirectory\n    });\n\n    test('@webapp applies custom removal policy to resources', () => {\n      const retainStack = new Stack(app, 'RetainTestStack');\n      const frontend = new Frontend(retainStack, 'Frontend', {\n        sourceDirectory: testSrcDir,\n        buildOutputDirectory: testBuildDir,\n        skipBuild: true,\n        removalPolicy: RemovalPolicy.RETAIN,\n      });\n\n      expect(frontend).toBeDefined();\n\n      // Check that the bucket has the correct removal policy\n      const retainTemplate = Template.fromStack(retainStack);\n      retainTemplate.hasResource('AWS::S3::Bucket', {\n        DeletionPolicy: 'Retain',\n        UpdateReplacePolicy: 'Retain',\n      });\n    });\n\n    test('@webapp uses default DESTROY removal policy when not specified', () => {\n      const destroyStack = new Stack(app, 'DestroyTestStack');\n      const frontend = new Frontend(destroyStack, 'Frontend', {\n        sourceDirectory: testSrcDir,\n        buildOutputDirectory: testBuildDir,\n        skipBuild: true,\n        // removalPolicy not specified - should default to DESTROY\n      });\n\n      expect(frontend).toBeDefined();\n\n      // Check that the bucket has the default DESTROY removal policy\n      const destroyTemplate = Template.fromStack(destroyStack);\n      destroyTemplate.hasResource('AWS::S3::Bucket', {\n        DeletionPolicy: 'Delete',\n        UpdateReplacePolicy: 'Delete',\n      });\n    });\n\n    test('@webapp throws error when domainName is provided without certificate', () => {\n      expect(() => {\n        new Frontend(stack, 'Frontend', {\n          sourceDirectory: '/tmp/test-frontend-src',\n          buildOutputDirectory: testBuildDir,\n          customDomain: {\n            domainName: 'app.example.com',\n          } as any, // Type assertion to bypass TypeScript validation for testing\n          skipBuild: true,\n        });\n      }).toThrow('certificate is required when domainName is provided');\n    });\n  });\n\n  describe('@webapp Security features', () => {\n    test('@webapp creates S3 bucket with security best practices', () => {\n      new Frontend(stack, 'Frontend', {\n        sourceDirectory: '/tmp/test-frontend-src',\n        buildOutputDirectory: testBuildDir,\n        skipBuild: true,\n      });\n\n      template = Template.fromStack(stack);\n\n      // Verify S3 bucket security settings\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\n    test('@webapp creates CloudFront distribution with security headers', () => {\n      new Frontend(stack, 'Frontend', {\n        sourceDirectory: '/tmp/test-frontend-src',\n        buildOutputDirectory: testBuildDir,\n        skipBuild: true,\n      });\n\n      template = Template.fromStack(stack);\n\n      // Verify security headers function exists\n      template.hasResourceProperties('AWS::CloudFront::Function', {\n        FunctionConfig: {\n          Runtime: 'cloudfront-js-1.0',\n        },\n      });\n\n      // Verify HTTPS redirect is enabled\n      template.hasResourceProperties('AWS::CloudFront::Distribution', {\n        DistributionConfig: {\n          DefaultCacheBehavior: {\n            ViewerProtocolPolicy: 'redirect-to-https',\n          },\n        },\n      });\n    });\n\n    test('@webapp enables auto delete objects on S3 bucket', () => {\n      new Frontend(stack, 'Frontend', {\n        sourceDirectory: '/tmp/test-frontend-src',\n        buildOutputDirectory: testBuildDir,\n        skipBuild: true,\n      });\n\n      template = Template.fromStack(stack);\n\n      // Verify auto delete objects custom resource is created\n      template.hasResource('Custom::S3AutoDeleteObjects', {});\n    });\n  });\n\n  describe('@webapp Default values', () => {\n    test('@webapp uses default SPA error responses', () => {\n      new Frontend(stack, 'Frontend', {\n        sourceDirectory: '/tmp/test-frontend-src',\n        buildOutputDirectory: testBuildDir,\n        skipBuild: true,\n      });\n\n      template = Template.fromStack(stack);\n\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\n    test('@webapp exports default SPA error responses', () => {\n      expect(DEFAULT_SPA_ERROR_RESPONSES).toEqual([\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\n  describe('@webapp Additional distribution properties', () => {\n    test('@webapp accepts additional CloudFront distribution properties', () => {\n      new Frontend(stack, 'Frontend', {\n        sourceDirectory: '/tmp/test-frontend-src',\n        buildOutputDirectory: testBuildDir,\n        distributionProps: {\n          comment: 'Custom frontend distribution',\n          enabled: true,\n        },\n        skipBuild: true,\n      });\n\n      template = Template.fromStack(stack);\n\n      template.hasResourceProperties('AWS::CloudFront::Distribution', {\n        DistributionConfig: {\n          Comment: 'Custom frontend distribution',\n          Enabled: true,\n        },\n      });\n    });\n  });\n});\n"]}

package/package.json ADDED Viewed

@@ -0,0 +1,183 @@
+{
+  "name": "@cdklabs/cdk-appmod-catalog-blueprints",
+  "description": "Serverless infrastructure components organized by business use cases",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:cdklabs/cdk-appmod-catalog-blueprints.git"
+  },
+  "scripts": {
+    "build": "npx projen build",
+    "build:fast": "npx projen build:fast",
+    "bump": "npx projen bump",
+    "clobber": "npx projen clobber",
+    "compat": "npx projen compat",
+    "compile": "npx projen compile",
+    "default": "npx projen default",
+    "docgen": "npx projen docgen",
+    "eject": "npx projen eject",
+    "eslint": "npx projen eslint",
+    "integ": "npx projen integ",
+    "integ:update": "npx projen integ:update",
+    "package": "npx projen package",
+    "package-all": "npx projen package-all",
+    "package:dotnet": "npx projen package:dotnet",
+    "package:go": "npx projen package:go",
+    "package:java": "npx projen package:java",
+    "package:js": "npx projen package:js",
+    "package:python": "npx projen package:python",
+    "post-compile": "npx projen post-compile",
+    "post-upgrade": "npx projen post-upgrade",
+    "pre-compile": "npx projen pre-compile",
+    "release": "npx projen release",
+    "rosetta:extract": "npx projen rosetta:extract",
+    "test": "npx projen test",
+    "test:cdk-nag:all": "npx projen test:cdk-nag:all",
+    "test:cdk-nag:document-processing": "npx projen test:cdk-nag:document-processing",
+    "test:cdk-nag:webapp": "npx projen test:cdk-nag:webapp",
+    "test:document-processing": "npx projen test:document-processing",
+    "test:document-processing:unit": "npx projen test:document-processing:unit",
+    "test:security": "npx projen test:security",
+    "test:watch": "npx projen test:watch",
+    "test:webapp": "npx projen test:webapp",
+    "test:webapp:core": "npx projen test:webapp:core",
+    "test:webapp:frontend": "npx projen test:webapp:frontend",
+    "test:webapp:quickstart": "npx projen test:webapp:quickstart",
+    "test:webapp:unit": "npx projen test:webapp:unit",
+    "unbump": "npx projen unbump",
+    "upgrade": "npx projen upgrade",
+    "upgrade-cdklabs-projen-project-types": "npx projen upgrade-cdklabs-projen-project-types",
+    "upgrade-dev-deps": "npx projen upgrade-dev-deps",
+    "watch": "npx projen watch",
+    "projen": "npx projen"
+  },
+  "author": {
+    "name": "Amazon Web Services",
+    "email": "aws-cdk-dev@amazon.com",
+    "organization": true
+  },
+  "devDependencies": {
+    "@aws-cdk/aws-lambda-python-alpha": "2.192.0-alpha.0",
+    "@aws-cdk/integ-runner": "latest",
+    "@aws-cdk/integ-tests-alpha": "latest",
+    "@stylistic/eslint-plugin": "^2",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^18",
+    "@typescript-eslint/eslint-plugin": "^8",
+    "@typescript-eslint/parser": "^8",
+    "aws-cdk-lib": "2.216.0",
+    "cdk-nag": "^2.37.35",
+    "cdklabs-projen-project-types": "^0.3.1",
+    "commit-and-tag-version": "^12",
+    "constructs": "10.0.5",
+    "eslint": "^9",
+    "eslint-import-resolver-typescript": "^4.2.5",
+    "eslint-plugin-import": "^2.31.0",
+    "jest": "^29.7.0",
+    "jest-junit": "^16",
+    "jsii": "~5.9.5",
+    "jsii-diff": "^1.110.0",
+    "jsii-docgen": "^10.5.0",
+    "jsii-pacmak": "^1.110.0",
+    "jsii-rosetta": "~5.8.0",
+    "projen": "^0.95.2",
+    "ts-jest": "^29.3.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.2"
+  },
+  "peerDependencies": {
+    "@aws-cdk/aws-lambda-python-alpha": "2.192.0-alpha.0",
+    "aws-cdk-lib": "^2.216.0",
+    "constructs": "^10.0.5"
+  },
+  "keywords": [
+    "cdk"
+  ],
+  "engines": {
+    "node": ">= 18.12.0"
+  },
+  "main": "lib/index.js",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "1.0.0",
+  "jest": {
+    "coverageProvider": "v8",
+    "testMatch": [
+      "<rootDir>/@(use-cases|test)/**/*(*.)@(spec|test).ts?(x)",
+      "<rootDir>/@(use-cases|test)/**/__tests__/**/*.ts?(x)",
+      "<rootDir>/@(projenrc)/**/*(*.)@(spec|test).ts?(x)",
+      "<rootDir>/@(projenrc)/**/__tests__/**/*.ts?(x)"
+    ],
+    "clearMocks": true,
+    "collectCoverage": true,
+    "coverageReporters": [
+      "json",
+      "lcov",
+      "clover",
+      "cobertura",
+      "text"
+    ],
+    "coverageDirectory": "coverage",
+    "coveragePathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "testPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "watchPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "reporters": [
+      "default",
+      [
+        "jest-junit",
+        {
+          "outputDirectory": "test-reports"
+        }
+      ]
+    ],
+    "transform": {
+      "^.+\\.[t]sx?$": [
+        "ts-jest",
+        {
+          "tsconfig": "tsconfig.dev.json"
+        }
+      ]
+    }
+  },
+  "types": "lib/index.d.ts",
+  "stability": "experimental",
+  "jsii": {
+    "outdir": "dist",
+    "targets": {
+      "java": {
+        "package": "io.github.cdklabs.appmod.catalog.blueprints",
+        "maven": {
+          "groupId": "io.github.cdklabs",
+          "artifactId": "appmod-catalog-blueprints"
+        }
+      },
+      "python": {
+        "distName": "appmod-catalog-blueprints",
+        "module": "appmod_catalog_blueprints"
+      },
+      "dotnet": {
+        "namespace": "CdklabsAppmodCatalogBlueprints",
+        "packageId": "CdklabsAppmodCatalogBlueprints"
+      },
+      "go": {
+        "moduleName": "github.com/cdklabs/appmod-catalog-blueprints-go"
+      }
+    },
+    "tsc": {
+      "outDir": "lib",
+      "rootDir": "use-cases"
+    }
+  },
+  "files": [
+    "lib/",
+    ".jsii"
+  ],
+  "//": "~~ Generated by projen. To modify, edit .projenrc.ts and run \"npx projen\"."
+}