@cdklabs/cdk-appmod-catalog-blueprints 1.0.0

package/lib/utilities/tests/data-loader.test.js

@@ -0,0 +1,284 @@
+"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 aws_cdk_lib_1 = require("aws-cdk-lib");
+const assertions_1 = require("aws-cdk-lib/assertions");
+const aws_ec2_1 = require("aws-cdk-lib/aws-ec2");
+const aws_rds_1 = require("aws-cdk-lib/aws-rds");
+const aws_secretsmanager_1 = require("aws-cdk-lib/aws-secretsmanager");
+const data_loader_1 = require("../data-loader");
+describe('DataLoader', () => {
+    let app;
+    let stack;
+    let vpc;
+    let cluster;
+    let secret;
+    let securityGroup;
+    let template;
+    // Use beforeAll instead of beforeEach to avoid recreating infrastructure
+    beforeAll(() => {
+        app = new aws_cdk_lib_1.App();
+        stack = new aws_cdk_lib_1.Stack(app, 'TestStack');
+        // Create VPC
+        vpc = new aws_ec2_1.Vpc(stack, 'TestVpc');
+        // Create security group for database access
+        securityGroup = new aws_ec2_1.SecurityGroup(stack, 'DatabaseSecurityGroup', {
+            vpc: vpc,
+            description: 'Security group for database access',
+        });
+        // Create database secret
+        secret = new aws_secretsmanager_1.Secret(stack, 'DatabaseSecret', {
+            generateSecretString: {
+                secretStringTemplate: JSON.stringify({ username: 'testuser' }),
+                generateStringKey: 'password',
+                excludeCharacters: '"@/\\',
+            },
+        });
+        // Create Aurora cluster
+        cluster = new aws_rds_1.DatabaseCluster(stack, 'TestCluster', {
+            engine: aws_rds_1.DatabaseClusterEngine.auroraPostgres({
+                version: aws_rds_1.AuroraPostgresEngineVersion.VER_13_7,
+            }),
+            credentials: {
+                username: 'testuser',
+                password: secret.secretValueFromJson('password'),
+            },
+            vpc,
+            writer: aws_rds_1.ClusterInstance.provisioned('writer', {
+                instanceType: aws_ec2_1.InstanceType.of(aws_ec2_1.InstanceClass.T3, aws_ec2_1.InstanceSize.MEDIUM),
+            }),
+        });
+        // Create all DataLoader instances first
+        new data_loader_1.DataLoader(stack, 'BasicDataLoader', {
+            databaseConfig: {
+                engine: data_loader_1.DatabaseEngine.POSTGRESQL,
+                cluster: cluster,
+                secret: secret,
+                databaseName: 'testdb',
+                vpc: vpc,
+                securityGroup: securityGroup,
+            },
+            fileInputs: [
+                {
+                    filePath: 's3://test-bucket/test-data.sql',
+                    fileType: data_loader_1.FileType.SQL,
+                },
+            ],
+        });
+        new data_loader_1.DataLoader(stack, 'MultiFileDataLoader', {
+            databaseConfig: {
+                engine: data_loader_1.DatabaseEngine.MYSQL,
+                cluster: cluster,
+                secret: secret,
+                databaseName: 'testdb',
+                vpc: vpc,
+                securityGroup: securityGroup,
+            },
+            fileInputs: [
+                {
+                    filePath: 's3://test-bucket/schema.sql',
+                    fileType: data_loader_1.FileType.SQL,
+                    executionOrder: 1,
+                },
+                {
+                    filePath: 's3://test-bucket/data.sql',
+                    fileType: data_loader_1.FileType.MYSQLDUMP,
+                    executionOrder: 2,
+                },
+            ],
+        });
+        new data_loader_1.DataLoader(stack, 'CustomDataLoader', {
+            databaseConfig: {
+                engine: data_loader_1.DatabaseEngine.POSTGRESQL,
+                cluster: cluster,
+                secret: secret,
+                databaseName: 'testdb',
+                vpc: vpc,
+                securityGroup: securityGroup,
+            },
+            fileInputs: [
+                {
+                    filePath: 's3://test-bucket/test-data.sql',
+                    fileType: data_loader_1.FileType.SQL,
+                },
+            ],
+            removalPolicy: aws_cdk_lib_1.RemovalPolicy.RETAIN,
+            memorySize: 2048,
+        });
+        // Generate template once after all constructs are created
+        template = assertions_1.Template.fromStack(stack);
+    });
+    describe('Basic functionality', () => {
+        test('creates DataLoader construct with minimal configuration', () => {
+            expect(stack.node.findChild('BasicDataLoader')).toBeDefined();
+        });
+        test('creates expected AWS resources', () => {
+            template.hasResourceProperties('AWS::S3::Bucket', {
+                BucketEncryption: {
+                    ServerSideEncryptionConfiguration: [
+                        {
+                            ServerSideEncryptionByDefault: {
+                                SSEAlgorithm: 'AES256',
+                            },
+                        },
+                    ],
+                },
+            });
+            template.hasResourceProperties('AWS::StepFunctions::StateMachine', {});
+            template.hasResourceProperties('AWS::Lambda::Function', {
+                Runtime: 'python3.11',
+                Handler: 'index.handler',
+            });
+        });
+        test('supports multiple file inputs with execution order', () => {
+            expect(stack.node.findChild('MultiFileDataLoader')).toBeDefined();
+        });
+        test('supports custom configuration options', () => {
+            expect(stack.node.findChild('CustomDataLoader')).toBeDefined();
+            template.hasResourceProperties('AWS::Lambda::Function', {
+                MemorySize: 2048,
+            });
+        });
+    });
+    describe('Validation', () => {
+        test('throws error when databaseConfig is missing', () => {
+            expect(() => {
+                new data_loader_1.DataLoader(stack, 'InvalidConfigDataLoader', {
+                    databaseConfig: undefined,
+                    fileInputs: [
+                        {
+                            filePath: 's3://test-bucket/test-data.sql',
+                            fileType: data_loader_1.FileType.SQL,
+                        },
+                    ],
+                });
+            }).toThrow('databaseConfig is required');
+        });
+        test('throws error when both cluster and instance are missing', () => {
+            expect(() => {
+                new data_loader_1.DataLoader(stack, 'NoClusterDataLoader', {
+                    databaseConfig: {
+                        engine: data_loader_1.DatabaseEngine.POSTGRESQL,
+                        secret: secret,
+                        databaseName: 'testdb',
+                        vpc: vpc,
+                        securityGroup: securityGroup,
+                    },
+                    fileInputs: [
+                        {
+                            filePath: 's3://test-bucket/test-data.sql',
+                            fileType: data_loader_1.FileType.SQL,
+                        },
+                    ],
+                });
+            }).toThrow('Either cluster or instance must be provided in databaseConfig');
+        });
+        test('throws error when fileInputs is empty', () => {
+            expect(() => {
+                new data_loader_1.DataLoader(stack, 'EmptyInputsDataLoader', {
+                    databaseConfig: {
+                        engine: data_loader_1.DatabaseEngine.POSTGRESQL,
+                        cluster: cluster,
+                        secret: secret,
+                        databaseName: 'testdb',
+                        vpc: vpc,
+                        securityGroup: securityGroup,
+                    },
+                    fileInputs: [],
+                });
+            }).toThrow('At least one file input is required');
+        });
+        test('throws error when MySQL engine is used with PostgreSQL dump', () => {
+            expect(() => {
+                new data_loader_1.DataLoader(stack, 'MySQLPgDumpDataLoader', {
+                    databaseConfig: {
+                        engine: data_loader_1.DatabaseEngine.MYSQL,
+                        cluster: cluster,
+                        secret: secret,
+                        databaseName: 'testdb',
+                        vpc: vpc,
+                        securityGroup: securityGroup,
+                    },
+                    fileInputs: [
+                        {
+                            filePath: 's3://test-bucket/test-data.sql',
+                            fileType: data_loader_1.FileType.PGDUMP,
+                        },
+                    ],
+                });
+            }).toThrow('PostgreSQL dump files cannot be used with MySQL databases');
+        });
+        test('throws error when PostgreSQL engine is used with MySQL dump', () => {
+            expect(() => {
+                new data_loader_1.DataLoader(stack, 'PostgreSQLMySQLDumpDataLoader', {
+                    databaseConfig: {
+                        engine: data_loader_1.DatabaseEngine.POSTGRESQL,
+                        cluster: cluster,
+                        secret: secret,
+                        databaseName: 'testdb',
+                        vpc: vpc,
+                        securityGroup: securityGroup,
+                    },
+                    fileInputs: [
+                        {
+                            filePath: 's3://test-bucket/test-data.sql',
+                            fileType: data_loader_1.FileType.MYSQLDUMP,
+                        },
+                    ],
+                });
+            }).toThrow('MySQL dump files cannot be used with PostgreSQL databases');
+        });
+    });
+    describe('Removal Policy', () => {
+        test('applies custom removal policy to resources', () => {
+            expect(stack.node.findChild('CustomDataLoader')).toBeDefined();
+            template.hasResource('AWS::S3::Bucket', {
+                DeletionPolicy: 'Retain',
+                UpdateReplacePolicy: 'Retain',
+            });
+        });
+        test('uses default DESTROY removal policy when not specified', () => {
+            expect(stack.node.findChild('BasicDataLoader')).toBeDefined();
+            template.hasResource('AWS::S3::Bucket', {
+                DeletionPolicy: 'Delete',
+                UpdateReplacePolicy: 'Delete',
+            });
+        });
+    });
+    describe('Security', () => {
+        test('creates resources with proper security configurations', () => {
+            template.hasResourceProperties('AWS::S3::Bucket', {
+                PublicAccessBlockConfiguration: {
+                    BlockPublicAcls: true,
+                    BlockPublicPolicy: true,
+                    IgnorePublicAcls: true,
+                    RestrictPublicBuckets: true,
+                },
+            });
+            template.hasResourceProperties('AWS::Lambda::Function', {
+                Handler: 'index.handler',
+                Runtime: 'python3.11',
+            });
+            const lambdaFunctions = template.findResources('AWS::Lambda::Function');
+            const hasVpcConfig = Object.values(lambdaFunctions).some((fn) => fn.Properties?.VpcConfig?.SubnetIds);
+            expect(hasVpcConfig).toBe(true);
+        });
+        test('grants appropriate IAM permissions', () => {
+            template.hasResourceProperties('AWS::IAM::Role', {
+                AssumeRolePolicyDocument: {
+                    Statement: [
+                        {
+                            Action: 'sts:AssumeRole',
+                            Effect: 'Allow',
+                            Principal: {
+                                Service: 'lambda.amazonaws.com',
+                            },
+                        },
+                    ],
+                },
+            });
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-loader.test.js","sourceRoot":"","sources":["../../../use-cases/utilities/tests/data-loader.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 { App, RemovalPolicy, Stack } from 'aws-cdk-lib';\nimport { Template } from 'aws-cdk-lib/assertions';\nimport { InstanceClass, InstanceSize, InstanceType, Vpc, SecurityGroup } from 'aws-cdk-lib/aws-ec2';\nimport { DatabaseCluster, DatabaseClusterEngine, AuroraPostgresEngineVersion, ClusterInstance } from 'aws-cdk-lib/aws-rds';\nimport { Secret } from 'aws-cdk-lib/aws-secretsmanager';\nimport { DataLoader, DatabaseEngine, FileType } from '../data-loader';\n\ndescribe('DataLoader', () => {\n  let app: App;\n  let stack: Stack;\n  let vpc: Vpc;\n  let cluster: DatabaseCluster;\n  let secret: Secret;\n  let securityGroup: SecurityGroup;\n  let template: Template;\n\n  // Use beforeAll instead of beforeEach to avoid recreating infrastructure\n  beforeAll(() => {\n    app = new App();\n    stack = new Stack(app, 'TestStack');\n\n    // Create VPC\n    vpc = new Vpc(stack, 'TestVpc');\n\n    // Create security group for database access\n    securityGroup = new SecurityGroup(stack, 'DatabaseSecurityGroup', {\n      vpc: vpc,\n      description: 'Security group for database access',\n    });\n\n    // Create database secret\n    secret = new Secret(stack, 'DatabaseSecret', {\n      generateSecretString: {\n        secretStringTemplate: JSON.stringify({ username: 'testuser' }),\n        generateStringKey: 'password',\n        excludeCharacters: '\"@/\\\\',\n      },\n    });\n\n    // Create Aurora cluster\n    cluster = new DatabaseCluster(stack, 'TestCluster', {\n      engine: DatabaseClusterEngine.auroraPostgres({\n        version: AuroraPostgresEngineVersion.VER_13_7,\n      }),\n      credentials: {\n        username: 'testuser',\n        password: secret.secretValueFromJson('password'),\n      },\n      vpc,\n      writer: ClusterInstance.provisioned('writer', {\n        instanceType: InstanceType.of(InstanceClass.T3, InstanceSize.MEDIUM),\n      }),\n    });\n\n    // Create all DataLoader instances first\n    new DataLoader(stack, 'BasicDataLoader', {\n      databaseConfig: {\n        engine: DatabaseEngine.POSTGRESQL,\n        cluster: cluster,\n        secret: secret,\n        databaseName: 'testdb',\n        vpc: vpc,\n        securityGroup: securityGroup,\n      },\n      fileInputs: [\n        {\n          filePath: 's3://test-bucket/test-data.sql',\n          fileType: FileType.SQL,\n        },\n      ],\n    });\n\n    new DataLoader(stack, 'MultiFileDataLoader', {\n      databaseConfig: {\n        engine: DatabaseEngine.MYSQL,\n        cluster: cluster,\n        secret: secret,\n        databaseName: 'testdb',\n        vpc: vpc,\n        securityGroup: securityGroup,\n      },\n      fileInputs: [\n        {\n          filePath: 's3://test-bucket/schema.sql',\n          fileType: FileType.SQL,\n          executionOrder: 1,\n        },\n        {\n          filePath: 's3://test-bucket/data.sql',\n          fileType: FileType.MYSQLDUMP,\n          executionOrder: 2,\n        },\n      ],\n    });\n\n    new DataLoader(stack, 'CustomDataLoader', {\n      databaseConfig: {\n        engine: DatabaseEngine.POSTGRESQL,\n        cluster: cluster,\n        secret: secret,\n        databaseName: 'testdb',\n        vpc: vpc,\n        securityGroup: securityGroup,\n      },\n      fileInputs: [\n        {\n          filePath: 's3://test-bucket/test-data.sql',\n          fileType: FileType.SQL,\n        },\n      ],\n      removalPolicy: RemovalPolicy.RETAIN,\n      memorySize: 2048,\n    });\n\n    // Generate template once after all constructs are created\n    template = Template.fromStack(stack);\n  });\n\n  describe('Basic functionality', () => {\n\n    test('creates DataLoader construct with minimal configuration', () => {\n      expect(stack.node.findChild('BasicDataLoader')).toBeDefined();\n    });\n\n    test('creates expected AWS resources', () => {\n      template.hasResourceProperties('AWS::S3::Bucket', {\n        BucketEncryption: {\n          ServerSideEncryptionConfiguration: [\n            {\n              ServerSideEncryptionByDefault: {\n                SSEAlgorithm: 'AES256',\n              },\n            },\n          ],\n        },\n      });\n\n      template.hasResourceProperties('AWS::StepFunctions::StateMachine', {});\n      template.hasResourceProperties('AWS::Lambda::Function', {\n        Runtime: 'python3.11',\n        Handler: 'index.handler',\n      });\n    });\n\n    test('supports multiple file inputs with execution order', () => {\n      expect(stack.node.findChild('MultiFileDataLoader')).toBeDefined();\n    });\n\n    test('supports custom configuration options', () => {\n      expect(stack.node.findChild('CustomDataLoader')).toBeDefined();\n      template.hasResourceProperties('AWS::Lambda::Function', {\n        MemorySize: 2048,\n      });\n    });\n  });\n\n  describe('Validation', () => {\n    test('throws error when databaseConfig is missing', () => {\n      expect(() => {\n        new DataLoader(stack, 'InvalidConfigDataLoader', {\n          databaseConfig: undefined as any,\n          fileInputs: [\n            {\n              filePath: 's3://test-bucket/test-data.sql',\n              fileType: FileType.SQL,\n            },\n          ],\n        });\n      }).toThrow('databaseConfig is required');\n    });\n\n    test('throws error when both cluster and instance are missing', () => {\n      expect(() => {\n        new DataLoader(stack, 'NoClusterDataLoader', {\n          databaseConfig: {\n            engine: DatabaseEngine.POSTGRESQL,\n            secret: secret,\n            databaseName: 'testdb',\n            vpc: vpc,\n            securityGroup: securityGroup,\n          },\n          fileInputs: [\n            {\n              filePath: 's3://test-bucket/test-data.sql',\n              fileType: FileType.SQL,\n            },\n          ],\n        });\n      }).toThrow('Either cluster or instance must be provided in databaseConfig');\n    });\n\n    test('throws error when fileInputs is empty', () => {\n      expect(() => {\n        new DataLoader(stack, 'EmptyInputsDataLoader', {\n          databaseConfig: {\n            engine: DatabaseEngine.POSTGRESQL,\n            cluster: cluster,\n            secret: secret,\n            databaseName: 'testdb',\n            vpc: vpc,\n            securityGroup: securityGroup,\n          },\n          fileInputs: [],\n        });\n      }).toThrow('At least one file input is required');\n    });\n\n    test('throws error when MySQL engine is used with PostgreSQL dump', () => {\n      expect(() => {\n        new DataLoader(stack, 'MySQLPgDumpDataLoader', {\n          databaseConfig: {\n            engine: DatabaseEngine.MYSQL,\n            cluster: cluster,\n            secret: secret,\n            databaseName: 'testdb',\n            vpc: vpc,\n            securityGroup: securityGroup,\n          },\n          fileInputs: [\n            {\n              filePath: 's3://test-bucket/test-data.sql',\n              fileType: FileType.PGDUMP,\n            },\n          ],\n        });\n      }).toThrow('PostgreSQL dump files cannot be used with MySQL databases');\n    });\n\n    test('throws error when PostgreSQL engine is used with MySQL dump', () => {\n      expect(() => {\n        new DataLoader(stack, 'PostgreSQLMySQLDumpDataLoader', {\n          databaseConfig: {\n            engine: DatabaseEngine.POSTGRESQL,\n            cluster: cluster,\n            secret: secret,\n            databaseName: 'testdb',\n            vpc: vpc,\n            securityGroup: securityGroup,\n          },\n          fileInputs: [\n            {\n              filePath: 's3://test-bucket/test-data.sql',\n              fileType: FileType.MYSQLDUMP,\n            },\n          ],\n        });\n      }).toThrow('MySQL dump files cannot be used with PostgreSQL databases');\n    });\n  });\n\n  describe('Removal Policy', () => {\n    test('applies custom removal policy to resources', () => {\n      expect(stack.node.findChild('CustomDataLoader')).toBeDefined();\n\n      template.hasResource('AWS::S3::Bucket', {\n        DeletionPolicy: 'Retain',\n        UpdateReplacePolicy: 'Retain',\n      });\n    });\n\n    test('uses default DESTROY removal policy when not specified', () => {\n      expect(stack.node.findChild('BasicDataLoader')).toBeDefined();\n\n      template.hasResource('AWS::S3::Bucket', {\n        DeletionPolicy: 'Delete',\n        UpdateReplacePolicy: 'Delete',\n      });\n    });\n  });\n\n  describe('Security', () => {\n    test('creates resources with proper security configurations', () => {\n      template.hasResourceProperties('AWS::S3::Bucket', {\n        PublicAccessBlockConfiguration: {\n          BlockPublicAcls: true,\n          BlockPublicPolicy: true,\n          IgnorePublicAcls: true,\n          RestrictPublicBuckets: true,\n        },\n      });\n\n      template.hasResourceProperties('AWS::Lambda::Function', {\n        Handler: 'index.handler',\n        Runtime: 'python3.11',\n      });\n\n      const lambdaFunctions = template.findResources('AWS::Lambda::Function');\n      const hasVpcConfig = Object.values(lambdaFunctions).some((fn: any) =>\n        fn.Properties?.VpcConfig?.SubnetIds,\n      );\n      expect(hasVpcConfig).toBe(true);\n    });\n\n    test('grants appropriate IAM permissions', () => {\n      template.hasResourceProperties('AWS::IAM::Role', {\n        AssumeRolePolicyDocument: {\n          Statement: [\n            {\n              Action: 'sts:AssumeRole',\n              Effect: 'Allow',\n              Principal: {\n                Service: 'lambda.amazonaws.com',\n              },\n            },\n          ],\n        },\n      });\n    });\n  });\n});\n"]}

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

@@ -0,0 +1,136 @@
+import { RemovalPolicy } from 'aws-cdk-lib';
+import { ICertificate } from 'aws-cdk-lib/aws-certificatemanager';
+import { Distribution, ErrorResponse, PriceClass } from 'aws-cdk-lib/aws-cloudfront';
+import { IHostedZone } from 'aws-cdk-lib/aws-route53';
+import { Bucket } from 'aws-cdk-lib/aws-s3';
+import { Asset } from 'aws-cdk-lib/aws-s3-assets';
+import { BucketDeployment } from 'aws-cdk-lib/aws-s3-deployment';
+import { Construct } from 'constructs';
+/**
+ * Default CloudFront error responses for Single Page Applications
+ */
+export declare const DEFAULT_SPA_ERROR_RESPONSES: ErrorResponse[];
+/**
+ * Custom domain configuration for the frontend
+ */
+export interface CustomDomainConfig {
+    /** Domain name for the frontend (e.g., 'app.example.com') */
+    readonly domainName: string;
+    /** SSL certificate for the domain (required when domainName is provided) */
+    readonly certificate: ICertificate;
+    /** Optional hosted zone for automatic DNS record creation */
+    readonly hostedZone?: IHostedZone;
+}
+/**
+ * Additional CloudFront distribution properties
+ */
+export interface AdditionalDistributionProps {
+    /** Optional comment for the distribution */
+    readonly comment?: string;
+    /** Optional enabled flag for the distribution */
+    readonly enabled?: boolean;
+    /** Optional price class for the distribution */
+    readonly priceClass?: PriceClass;
+    /** Optional web ACL ID for the distribution */
+    readonly webAclId?: string;
+}
+/**
+ * Properties for the Frontend construct
+ */
+export interface FrontendProps {
+    /** Base directory of the frontend source code */
+    readonly sourceDirectory: string;
+    /** Directory where build artifacts are located after build command completes (defaults to '{sourceDirectory}/build') */
+    readonly buildOutputDirectory?: string;
+    /** Optional build command (defaults to 'npm run build') */
+    readonly buildCommand?: string;
+    /** Optional custom domain configuration */
+    readonly customDomain?: CustomDomainConfig;
+    /** Optional CloudFront error responses (defaults to SPA-friendly responses) */
+    readonly errorResponses?: ErrorResponse[];
+    /** Optional additional CloudFront distribution properties */
+    readonly distributionProps?: AdditionalDistributionProps;
+    /** Optional flag to skip the build process (useful for pre-built artifacts) */
+    readonly skipBuild?: boolean;
+    /** Optional removal policy for all resources (defaults to DESTROY) */
+    readonly removalPolicy?: RemovalPolicy;
+    /**
+     * Enable logging and tracing for all supporting resource
+     * @default false
+     */
+    readonly enableObservability?: boolean;
+}
+/**
+ * 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
+ */
+export declare class Frontend extends Construct {
+    /** The S3 bucket hosting the frontend assets */
+    readonly bucket: Bucket;
+    /** The CloudFront distribution */
+    readonly distribution: Distribution;
+    /** The bucket deployment that uploads the frontend assets */
+    readonly bucketDeployment: BucketDeployment;
+    /** The custom domain name (if configured) */
+    readonly domainName?: string;
+    /** The Asset containing the frontend source code */
+    readonly asset?: Asset;
+    /**
+     * Creates a new Frontend
+     * @param scope The construct scope
+     * @param id The construct ID
+     * @param props The frontend properties
+     */
+    constructor(scope: Construct, id: string, props: FrontendProps);
+    /**
+     * Validates the construct properties
+     * @param props The frontend properties
+     * @private
+     */
+    private _validateProps;
+    /**
+     * Creates an Asset for the frontend source code with bundling
+     * @param props The frontend properties
+     * @returns The Asset containing the built frontend
+     * @private
+     */
+    private _createAsset;
+    /**
+     * Creates the CloudFront distribution
+     * @param props The frontend properties
+     * @param removalPolicy The removal policy to apply
+     * @returns The CloudFront distribution
+     * @private
+     */
+    private _createDistribution;
+    /**
+     * Sets up custom domain with Route53 record
+     * @param customDomain The custom domain configuration
+     * @param removalPolicy The removal policy to apply
+     * @private
+     */
+    private _setupCustomDomain;
+    /**
+     * Gets the URL of the frontend application
+     * @returns The frontend URL
+     */
+    url(): string;
+    /**
+     * Gets the CloudFront distribution domain name
+     * @returns The CloudFront domain name
+     */
+    distributionDomainName(): string;
+    /**
+     * Gets the S3 bucket name
+     * @returns The S3 bucket name
+     */
+    bucketName(): string;
+}