@fjall/components-infrastructure 0.77.4 → 0.78.5

package/dist/lib/patterns/aws/compute.js

@@ -1,52 +1,207 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Compute = exports.ComputeFactory = void 0;
+exports.Compute = exports.ComputeFactory = exports.HttpMethod = exports.ECS_CAPACITY_PROVIDER_CONFIG = exports.COMPUTE_TYPE_CONFIG = void 0;
+exports.getComputeTypeConfig = getComputeTypeConfig;
+exports.getEcsCapacityProviderConfig = getEcsCapacityProviderConfig;
 const aws_ecr_1 = require("aws-cdk-lib/aws-ecr");
 const aws_ec2_1 = require("aws-cdk-lib/aws-ec2");
 const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
 const constructs_1 = require("constructs");
 const ecs_1 = require("../../resources/aws/compute/ecs");
-const ecsFreeTier_1 = require("../../resources/aws/compute/ecsFreeTier");
-const ecsSpot_1 = require("../../resources/aws/compute/ecsSpot");
 const ec2_1 = require("../../resources/aws/compute/ec2");
 const lambda_1 = require("../../resources/aws/compute/lambda");
-// Helper function to convert string HTTP methods to HttpMethod enum
-function convertHttpMethods(methods) {
-    const methodMap = {
-        GET: aws_lambda_1.HttpMethod.GET,
-        POST: aws_lambda_1.HttpMethod.POST,
-        PUT: aws_lambda_1.HttpMethod.PUT,
-        DELETE: aws_lambda_1.HttpMethod.DELETE,
-        HEAD: aws_lambda_1.HttpMethod.HEAD,
-        OPTIONS: aws_lambda_1.HttpMethod.OPTIONS,
-        PATCH: aws_lambda_1.HttpMethod.PATCH
-    };
-    return methods.map((method) => {
-        const httpMethod = methodMap[method];
-        if (!httpMethod) {
-            throw new Error(`Invalid HTTP method: ${method}. Valid methods are: ${Object.keys(methodMap).join(", ")}`);
+exports.COMPUTE_TYPE_CONFIG = {
+    ecs: {
+        defaultPort: 80,
+        defaultScaling: { minCapacity: 2, maxCapacity: 5 },
+        supportsConnections: true,
+        requiresVpc: true
+    },
+    ec2: {
+        defaultPort: 22,
+        defaultScaling: { minCapacity: 2, maxCapacity: 3 },
+        supportsConnections: true,
+        requiresVpc: true
+    },
+    lambda: {
+        defaultPort: 0,
+        defaultScaling: { minCapacity: 0, maxCapacity: 100 },
+        supportsConnections: false,
+        requiresVpc: false
+    }
+};
+exports.ECS_CAPACITY_PROVIDER_CONFIG = {
+    FARGATE: {
+        usesSpot: false,
+        usesEc2Instances: false
+    },
+    FARGATE_SPOT: {
+        usesSpot: true,
+        usesEc2Instances: false
+    },
+    EC2: {
+        usesSpot: false,
+        usesEc2Instances: true
+    }
+};
+function getComputeTypeConfig(type) {
+    return exports.COMPUTE_TYPE_CONFIG[type];
+}
+function getEcsCapacityProviderConfig(provider) {
+    return exports.ECS_CAPACITY_PROVIDER_CONFIG[provider];
+}
+// Re-export Lambda types from CDK for user convenience
+var aws_lambda_2 = require("aws-cdk-lib/aws-lambda");
+Object.defineProperty(exports, "HttpMethod", { enumerable: true, get: function () { return aws_lambda_2.HttpMethod; } });
+/**
+ * Validates compute props and logs warnings for ignored or misconfigured options.
+ * These checks help catch issues when props come from dynamic sources where
+ * TypeScript's compile-time checks may not apply.
+ */
+function validateComputeProps(props) {
+    const propsAny = props;
+    // ECS-specific options on non-ECS compute
+    if (props.type !== "ecs") {
+        if ("capacityProvider" in propsAny &&
+            propsAny.capacityProvider !== undefined) {
+            console.warn(`[Fjall] Warning: 'capacityProvider' is ignored for ${props.type} compute. ` +
+                "Capacity provider configuration only applies to ECS compute.");
+        }
+        if ("ec2Config" in propsAny && propsAny.ec2Config !== undefined) {
+            console.warn(`[Fjall] Warning: 'ec2Config' is ignored for ${props.type} compute. ` +
+                "EC2 capacity configuration only applies to ECS compute.");
+        }
+        if ("services" in propsAny && propsAny.services !== undefined) {
+            console.warn(`[Fjall] Warning: 'services' is ignored for ${props.type} compute. ` +
+                "Services configuration only applies to ECS compute.");
+        }
+        if ("cluster" in propsAny && propsAny.cluster !== undefined) {
+            console.warn(`[Fjall] Warning: 'cluster' is ignored for ${props.type} compute. ` +
+                "Cluster configuration only applies to ECS compute.");
+        }
+    }
+    // Lambda-specific options on non-Lambda compute
+    if (props.type !== "lambda") {
+        if ("functionUrl" in propsAny && propsAny.functionUrl !== undefined) {
+            console.warn(`[Fjall] Warning: 'functionUrl' is ignored for ${props.type} compute. ` +
+                "Function URL configuration only applies to Lambda compute.");
+        }
+        if ("handler" in propsAny && propsAny.handler !== undefined) {
+            console.warn(`[Fjall] Warning: 'handler' is ignored for ${props.type} compute. ` +
+                "Handler configuration only applies to Lambda compute.");
+        }
+        if ("runtime" in propsAny && propsAny.runtime !== undefined) {
+            console.warn(`[Fjall] Warning: 'runtime' is ignored for ${props.type} compute. ` +
+                "Runtime configuration only applies to Lambda compute.");
+        }
+    }
+    // EC2-specific options on non-EC2 compute
+    if (props.type !== "ec2") {
+        if ("ssh" in propsAny && propsAny.ssh !== undefined) {
+            console.warn(`[Fjall] Warning: 'ssh' is ignored for ${props.type} compute. ` +
+                "SSH configuration only applies to EC2 compute.");
         }
-        return httpMethod;
-    });
+        if ("userData" in propsAny && propsAny.userData !== undefined) {
+            console.warn(`[Fjall] Warning: 'userData' is ignored for ${props.type} compute. ` +
+                "User data only applies to EC2 compute.");
+        }
+        if ("machineImage" in propsAny && propsAny.machineImage !== undefined) {
+            console.warn(`[Fjall] Warning: 'machineImage' is ignored for ${props.type} compute. ` +
+                "Machine image only applies to EC2 compute.");
+        }
+    }
+    // ECS-specific validation
+    if (props.type === "ecs") {
+        validateEcsProps(props);
+    }
 }
-// Convert simplified CORS options to CDK CORS options
-function convertCorsOptions(simplifiedCors) {
-    if (!simplifiedCors)
-        return undefined;
-    return {
-        allowedOrigins: simplifiedCors.allowedOrigins,
-        allowedMethods: simplifiedCors.allowedMethods
-            ? convertHttpMethods(simplifiedCors.allowedMethods)
-            : undefined,
-        allowedHeaders: simplifiedCors.allowedHeaders,
-        maxAge: simplifiedCors.maxAge,
-        allowCredentials: simplifiedCors.allowCredentials,
-        exposedHeaders: simplifiedCors.exposeHeaders
-    };
+/**
+ * Validates ECS-specific props.
+ * Extracted for clarity and detail parity with database/network patterns.
+ */
+function validateEcsProps(props) {
+    // EC2 config validation
+    if (props.ec2Config && props.capacityProvider !== "EC2") {
+        console.warn("[Fjall] Warning: 'ec2Config' is ignored when capacityProvider is not 'EC2'. " +
+            "Set capacityProvider to 'EC2' to use EC2 capacity configuration.");
+    }
+    // Validate services array exists and is not empty
+    if (!props.services || props.services.length === 0) {
+        throw new Error("At least one service must be specified in 'services' array.");
+    }
+    // Validate unique service names
+    const serviceNames = props.services.map((s) => s.name);
+    const duplicateNames = serviceNames.filter((name, index) => serviceNames.indexOf(name) !== index);
+    if (duplicateNames.length > 0) {
+        throw new Error(`Duplicate service names: ${[...new Set(duplicateNames)].join(", ")}`);
+    }
+    // Validate service name format
+    const invalidNames = props.services.filter((s) => !/^[a-zA-Z][a-zA-Z0-9-]*$/.test(s.name));
+    if (invalidNames.length > 0) {
+        throw new Error(`Invalid service names: ${invalidNames.map((s) => s.name).join(", ")}. ` +
+            "Service names must start with a letter and contain only letters, numbers, and hyphens.");
+    }
+    // Validate routing when multiple services have ports
+    const servicesWithPorts = props.services.filter((s) => s.containers?.some((c) => c.port));
+    if (servicesWithPorts.length > 1) {
+        const missingRouting = servicesWithPorts.filter((s) => !s.routing?.path && !s.routing?.host);
+        if (missingRouting.length > 0) {
+            throw new Error(`Services with ports require routing config when cluster has multiple services: ` +
+                `${missingRouting.map((s) => s.name).join(", ")}. ` +
+                "Add routing: { path: '/...' } or routing: { host: '...' } to each service.");
+        }
+    }
+    // Validate each service's containers
+    for (const service of props.services) {
+        if (service.containers && service.containers.length > 0) {
+            // Check for duplicate container names within service (only named containers)
+            const containerNames = service.containers
+                .filter((c) => c.name)
+                .map((c) => c.name);
+            const duplicateContainerNames = containerNames.filter((name, index) => containerNames.indexOf(name) !== index);
+            if (duplicateContainerNames.length > 0) {
+                throw new Error(`Service '${service.name}': Duplicate container names: ` +
+                    `${[...new Set(duplicateContainerNames)].join(", ")}`);
+            }
+        }
+    }
 }
+/**
+ * Factory for creating compute resources.
+ *
+ * @example
+ * // Single service cluster
+ * app.addCompute(ComputeFactory.build("WebApp", {
+ *   type: "ecs",
+ *   cluster: { domain: "app.example.com" },
+ *   services: [{ name: "web", containers: [{ port: 3000 }] }]
+ * }));
+ *
+ * @example
+ * // Multi-service cluster with routing
+ * app.addCompute(ComputeFactory.build("ApiCluster", {
+ *   type: "ecs",
+ *   cluster: { domain: "api.example.com" },
+ *   services: [
+ *     { name: "users", containers: [{ port: 3000 }], routing: { path: "/users/*" } },
+ *     { name: "orders", containers: [{ port: 3001 }], routing: { path: "/orders/*" } }
+ *   ]
+ * }));
+ *
+ * @example
+ * // Worker cluster (no ALB)
+ * app.addCompute(ComputeFactory.build("Workers", {
+ *   type: "ecs",
+ *   cluster: { loadBalancer: false },
+ *   services: [
+ *     { name: "processor", containers: [{ command: ["node", "worker.js"] }] }
+ *   ]
+ * }));
+ */
 class ComputeFactory {
     static build(id, props) {
         return (app, scope) => {
+            validateComputeProps(props);
             const computeProps = {
                 ...{
                     vpc: app.getVpc(),
@@ -67,22 +222,28 @@ class Compute extends constructs_1.Construct {
         this.addCompute(props);
     }
     addCompute(props) {
-        const computeType = props.type || "ecs";
-        if (computeType === "ec2") {
-            this.addEc2Compute(props);
-        }
-        else if (computeType === "lambda") {
-            this.addLambdaCompute(props);
-        }
-        else {
-            this.addEcsCompute(props);
+        switch (props.type) {
+            case "ecs":
+                this.addEcsCompute(props);
+                break;
+            case "ec2":
+                this.addEc2Compute(props);
+                break;
+            case "lambda":
+                this.addLambdaCompute(props);
+                break;
+            default:
+                // Exhaustiveness check - TypeScript will error if a case is missing
+                const _exhaustive = props;
+                throw new Error(`Unsupported compute type: ${_exhaustive.type}`);
         }
     }
     addEc2Compute(props) {
+        const enableSSH = props.ssh !== undefined && props.ssh !== false;
         const ec2Props = {
             serviceName: `${this.id}Service`,
             instanceType: props.instanceType || "t3.micro",
-            enableSSH: props.enableSSH || false,
+            enableSSH,
             userData: props.userData,
             machineImage: props.machineImage,
             minCapacity: props.minCapacity || 1,
@@ -91,56 +252,90 @@ class Compute extends constructs_1.Construct {
         };
         this.compute = new ec2_1.Ec2Instance(this.scope, `${this.id}Ec2`, ec2Props);
         this.connections = this.compute.connections;
-        if (props.connections) {
-            for (const conn of props.connections) {
-                this.compute.connections.allowToDefaultPort(conn);
-            }
-        }
     }
     addEcsCompute(props) {
-        const ecsType = props.ecsType || "fargate";
-        // Common ECS props
-        const baseEcsProps = {
-            ...props,
-            containerPort: props.containerPort || 80,
-            serviceName: `${this.id}Service`,
+        const capacityProvider = props.capacityProvider || "FARGATE";
+        // Transform EcsServiceConfig[] to EcsServiceProps[] for EcsCluster
+        const services = props.services.map((service) => {
+            // Build container configurations for this service
+            let containers;
+            if (service.containers && service.containers.length > 0) {
+                // Map containers, auto-generating names if not provided
+                containers = service.containers.map((c, index) => ({
+                    name: c.name || `${service.name}Container${index > 0 ? index : ""}`,
+                    image: c.image,
+                    port: c.port,
+                    environment: c.environment,
+                    secretsImport: c.secretsImport,
+                    command: c.command,
+                    entryPoint: c.entryPoint,
+                    essential: c.essential,
+                    healthCheck: c.healthCheck
+                }));
+            }
+            else {
+                // Default container (no port = worker)
+                containers = [
+                    {
+                        name: `${service.name}Container`
+                    }
+                ];
+            }
+            // Determine scaling config
+            let scalingType;
+            let minCapacity;
+            let maxCapacity;
+            if (service.scaling !== false && service.scaling !== undefined) {
+                scalingType = service.scaling.scalingType ?? ecs_1.ScalingType.CPU;
+                minCapacity = service.scaling.minCapacity;
+                maxCapacity = service.scaling.maxCapacity;
+            }
+            else if (service.scaling === undefined) {
+                // Default: enable scaling with CPU
+                scalingType = ecs_1.ScalingType.CPU;
+            }
+            return {
+                name: service.name,
+                image: service.image,
+                containers,
+                cpu: service.cpu,
+                memoryLimitMiB: service.memoryLimitMiB,
+                desiredCount: service.desiredCount,
+                scalingType,
+                minCapacity,
+                maxCapacity,
+                routing: service.routing,
+                taskRoleInlinePolicies: service.taskRoleInlinePolicies,
+                taskRoleManagedPolicies: service.taskRoleManagedPolicies,
+                connections: service.connections
+            };
+        });
+        // Build cluster config
+        const cluster = props.cluster
+            ? {
+                domain: props.cluster.domain,
+                loadBalancer: props.cluster.loadBalancer,
+                directAccess: props.cluster.directAccess
+            }
+            : undefined;
+        const ecsProps = {
             clusterName: `${this.id}Cluster`,
+            vpc: props.vpc,
             ecrRepository: props.ecrRepository || "amazon/amazon-ecs-sample",
-            containerEnvironment: props.containerEnvironment || {},
-            containerSecretsImport: props.containerSecretsImport || {},
-            vpc: props.vpc
+            capacityProvider,
+            ec2Config: capacityProvider === "EC2" ? props.ec2Config : undefined,
+            cluster,
+            services
         };
-        if (ecsType === "freetier") {
-            // Use EC2-based ECS for free tier
-            this.compute = new ecsFreeTier_1.default(this.scope, `${this.id}EcsFreeTier`, baseEcsProps);
-        }
-        else if (ecsType === "spot") {
-            // Use EC2 Spot instances for cost optimization
-            this.compute = new ecsSpot_1.default(this.scope, `${this.id}EcsSpot`, baseEcsProps);
-        }
-        else {
-            // Default to Fargate
-            const fargateProps = {
-                ...baseEcsProps,
-                scalingType: ecs_1.ScalingType.CPU,
-                protocol: props.domainConfig ? ecs_1.Protocol.HTTPS : ecs_1.Protocol.HTTP,
-                domainConfig: props.domainConfig
-            };
-            this.compute = new ecs_1.default(this.scope, `${this.id}Fargate`, fargateProps);
-        }
-        if (props.connections) {
-            for (const conn of props.connections) {
-                this.compute.connections.allowToDefaultPort(conn);
-            }
-        }
+        this.compute = new ecs_1.default(this.scope, `${this.id}Ecs`, ecsProps);
         this.connections = this.compute.connections;
     }
     addLambdaCompute(props) {
-        let code = props.code;
-        if (!code) {
-            if (!props.ecrRepository) {
-                throw new Error("Either code or ecrRepository must be provided for Lambda compute type");
-            }
+        let code;
+        let handler;
+        let runtime;
+        if (props.deployment === "container") {
+            // Container-based Lambda using ECR
             if (props.ecrRepository instanceof aws_ecr_1.Repository) {
                 code = aws_lambda_1.Code.fromEcrImage(props.ecrRepository, {
                     tagOrDigest: "latest"
@@ -149,20 +344,38 @@ class Compute extends constructs_1.Construct {
             else {
                 throw new Error("ecrRepository must be a Repository instance for Lambda compute type");
             }
+            // Container Lambda requires these special values
+            handler = aws_lambda_1.Handler.FROM_IMAGE;
+            runtime = aws_lambda_1.Runtime.FROM_IMAGE;
+        }
+        else {
+            // Code-based Lambda - props.deployment === "code"
+            code = props.code;
+            handler = props.handler || "index.handler";
+            runtime = props.runtime || aws_lambda_1.Runtime.NODEJS_18_X;
         }
+        // Convert presence-based functionUrl config to legacy boolean format
+        const functionUrlConfig = props.functionUrl;
+        const enableFunctionUrl = functionUrlConfig !== undefined && functionUrlConfig !== false;
+        const functionUrlAuthType = enableFunctionUrl && typeof functionUrlConfig === "object"
+            ? functionUrlConfig.authType
+            : undefined;
+        const functionUrlCors = enableFunctionUrl && typeof functionUrlConfig === "object"
+            ? functionUrlConfig.cors
+            : undefined;
         const lambdaProps = {
             code: code,
-            handler: props.handler || "index.handler",
-            runtime: props.runtime || aws_lambda_1.Runtime.NODEJS_18_X,
+            handler,
+            runtime,
             timeout: props.timeout,
             memorySize: props.memorySize,
-            lambdaDescription: props.lambdaDescription,
+            lambdaDescription: props.description,
             roleDescription: props.roleDescription,
             inlinePolicy: props.inlinePolicy || [],
-            enableFunctionUrl: props.enableFunctionUrl,
-            functionUrlAuthType: props.functionUrlAuthType,
-            functionUrlCors: convertCorsOptions(props.functionUrlCors),
-            environment: props.containerEnvironment
+            enableFunctionUrl,
+            functionUrlAuthType,
+            functionUrlCors,
+            environment: props.environment
         };
         this.compute = new lambda_1.LambdaFunction(this.scope, `${this.id}Lambda`, lambdaProps);
         // Lambda functions don't use security groups unless VPC-enabled
@@ -171,4 +384,4 @@ class Compute extends constructs_1.Construct {
     }
 }
 exports.Compute = Compute;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compute.js","sourceRoot":"","sources":["../../../../lib/patterns/aws/compute.ts"],"names":[],"mappings":";;;AACA,iDAAiD;AACjD,iDAM6B;AAC7B,uDAMgC;AAIhC,2CAAuC;AAIvC,yDAKyC;AACzC,yEAAkE;AAClE,iEAA0D;AAC1D,yDAA8D;AAC9D,+DAAoE;AAoGpE,oEAAoE;AACpE,SAAS,kBAAkB,CAAC,OAA2B;IACrD,MAAM,SAAS,GAAyC;QACtD,GAAG,EAAE,uBAAU,CAAC,GAAG;QACnB,IAAI,EAAE,uBAAU,CAAC,IAAI;QACrB,GAAG,EAAE,uBAAU,CAAC,GAAG;QACnB,MAAM,EAAE,uBAAU,CAAC,MAAM;QACzB,IAAI,EAAE,uBAAU,CAAC,IAAI;QACrB,OAAO,EAAE,uBAAU,CAAC,OAAO;QAC3B,KAAK,EAAE,uBAAU,CAAC,KAAK;KACxB,CAAC;IAEF,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE;QAC5B,MAAM,UAAU,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;QACrC,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,MAAM,IAAI,KAAK,CACb,wBAAwB,MAAM,wBAAwB,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAC1F,CAAC;QACJ,CAAC;QACD,OAAO,UAAU,CAAC;IACpB,CAAC,CAAC,CAAC;AACL,CAAC;AAED,sDAAsD;AACtD,SAAS,kBAAkB,CACzB,cAAsC;IAEtC,IAAI,CAAC,cAAc;QAAE,OAAO,SAAS,CAAC;IAEtC,OAAO;QACL,cAAc,EAAE,cAAc,CAAC,cAAc;QAC7C,cAAc,EAAE,cAAc,CAAC,cAAc;YAC3C,CAAC,CAAC,kBAAkB,CAAC,cAAc,CAAC,cAAc,CAAC;YACnD,CAAC,CAAC,SAAS;QACb,cAAc,EAAE,cAAc,CAAC,cAAc;QAC7C,MAAM,EAAE,cAAc,CAAC,MAAM;QAC7B,gBAAgB,EAAE,cAAc,CAAC,gBAAgB;QACjD,cAAc,EAAE,cAAc,CAAC,aAAa;KAC7C,CAAC;AACJ,CAAC;AAED,MAAa,cAAc;IACzB,MAAM,CAAC,KAAK,CAAC,EAAU,EAAE,KAAoB;QAC3C,OAAO,CAAC,GAAQ,EAAE,KAAgB,EAAE,EAAE;YACpC,MAAM,YAAY,GAAG;gBACnB,GAAG;oBACD,GAAG,EAAE,GAAG,CAAC,MAAM,EAAE;oBACjB,aAAa,EAAE,GAAG,CAAC,2BAA2B,EAAE;iBACjD;gBACD,GAAG,KAAK;aACT,CAAC;YAEF,OAAO,IAAI,OAAO,CAAC,KAAK,EAAE,EAAE,EAAE,YAAY,CAAC,CAAC;QAC9C,CAAC,CAAC;IACJ,CAAC;CACF;AAdD,wCAcC;AAED,MAAa,OAAQ,SAAQ,sBAAS;IAcpC,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAoB;QAC5D,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACjB,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;QACb,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QAEnB,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IACzB,CAAC;IAED,UAAU,CAAC,KAAoB;QAC7B,MAAM,WAAW,GAAG,KAAK,CAAC,IAAI,IAAI,KAAK,CAAC;QAExC,IAAI,WAAW,KAAK,KAAK,EAAE,CAAC;YAC1B,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAC5B,CAAC;aAAM,IAAI,WAAW,KAAK,QAAQ,EAAE,CAAC;YACpC,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;QAC/B,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAC5B,CAAC;IACH,CAAC;IAEO,aAAa,CAAC,KAAoB;QACxC,MAAM,QAAQ,GAAG;YACf,WAAW,EAAE,GAAG,IAAI,CAAC,EAAE,SAAS;YAChC,YAAY,EAAE,KAAK,CAAC,YAAY,IAAI,UAAU;YAC9C,SAAS,EAAE,KAAK,CAAC,SAAS,IAAI,KAAK;YACnC,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,YAAY,EAAE,KAAK,CAAC,YAAY;YAChC,WAAW,EAAE,KAAK,CAAC,WAAW,IAAI,CAAC;YACnC,WAAW,EAAE,KAAK,CAAC,WAAW,IAAI,CAAC;YACnC,GAAG,EAAE,KAAK,CAAC,GAAG;SACf,CAAC;QAEF,IAAI,CAAC,OAAO,GAAG,IAAI,iBAAW,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;QACtE,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC;QAE5C,IAAI,KAAK,CAAC,WAAW,EAAE,CAAC;YACtB,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,WAAW,EAAE,CAAC;gBACrC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;YACpD,CAAC;QACH,CAAC;IACH,CAAC;IAEO,aAAa,CAAC,KAAoB;QACxC,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,IAAI,SAAS,CAAC;QAE3C,mBAAmB;QACnB,MAAM,YAAY,GAAG;YACnB,GAAG,KAAK;YACR,aAAa,EAAE,KAAK,CAAC,aAAa,IAAI,EAAE;YACxC,WAAW,EAAE,GAAG,IAAI,CAAC,EAAE,SAAS;YAChC,WAAW,EAAE,GAAG,IAAI,CAAC,EAAE,SAAS;YAChC,aAAa,EAAE,KAAK,CAAC,aAAa,IAAI,0BAA0B;YAChE,oBAAoB,EAAE,KAAK,CAAC,oBAAoB,IAAI,EAAE;YACtD,sBAAsB,EAAE,KAAK,CAAC,sBAAsB,IAAI,EAAE;YAC1D,GAAG,EAAE,KAAK,CAAC,GAAG;SACf,CAAC;QAEF,IAAI,OAAO,KAAK,UAAU,EAAE,CAAC;YAC3B,kCAAkC;YAClC,IAAI,CAAC,OAAO,GAAG,IAAI,qBAAW,CAC5B,IAAI,CAAC,KAAK,EACV,GAAG,IAAI,CAAC,EAAE,aAAa,EACvB,YAAY,CACb,CAAC;QACJ,CAAC;aAAM,IAAI,OAAO,KAAK,MAAM,EAAE,CAAC;YAC9B,+CAA+C;YAC/C,IAAI,CAAC,OAAO,GAAG,IAAI,iBAAO,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC;QAC5E,CAAC;aAAM,CAAC;YACN,qBAAqB;YACrB,MAAM,YAAY,GAAG;gBACnB,GAAG,YAAY;gBACf,WAAW,EAAE,iBAAW,CAAC,GAAG;gBAC5B,QAAQ,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC,cAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,cAAQ,CAAC,IAAI;gBAC7D,YAAY,EAAE,KAAK,CAAC,YAAY;aACV,CAAC;YAEzB,IAAI,CAAC,OAAO,GAAG,IAAI,aAAc,CAC/B,IAAI,CAAC,KAAK,EACV,GAAG,IAAI,CAAC,EAAE,SAAS,EACnB,YAAY,CACb,CAAC;QACJ,CAAC;QAED,IAAI,KAAK,CAAC,WAAW,EAAE,CAAC;YACtB,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,WAAW,EAAE,CAAC;gBACrC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;YACpD,CAAC;QACH,CAAC;QAED,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC;IAC9C,CAAC;IAEO,gBAAgB,CAAC,KAAoB;QAC3C,IAAI,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;QAEtB,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC;gBACzB,MAAM,IAAI,KAAK,CACb,uEAAuE,CACxE,CAAC;YACJ,CAAC;YAED,IAAI,KAAK,CAAC,aAAa,YAAY,oBAAU,EAAE,CAAC;gBAC9C,IAAI,GAAG,iBAAI,CAAC,YAAY,CAAC,KAAK,CAAC,aAAa,EAAE;oBAC5C,WAAW,EAAE,QAAQ;iBACtB,CAAC,CAAC;YACL,CAAC;iBAAM,CAAC;gBACN,MAAM,IAAI,KAAK,CACb,qEAAqE,CACtE,CAAC;YACJ,CAAC;QACH,CAAC;QAED,MAAM,WAAW,GAAG;YAClB,IAAI,EAAE,IAAI;YACV,OAAO,EAAE,KAAK,CAAC,OAAO,IAAI,eAAe;YACzC,OAAO,EAAE,KAAK,CAAC,OAAO,IAAI,oBAAO,CAAC,WAAW;YAC7C,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,UAAU,EAAE,KAAK,CAAC,UAAU;YAC5B,iBAAiB,EAAE,KAAK,CAAC,iBAAiB;YAC1C,eAAe,EAAE,KAAK,CAAC,eAAe;YACtC,YAAY,EAAE,KAAK,CAAC,YAAY,IAAI,EAAE;YACtC,iBAAiB,EAAE,KAAK,CAAC,iBAAiB;YAC1C,mBAAmB,EAAE,KAAK,CAAC,mBAAmB;YAC9C,eAAe,EAAE,kBAAkB,CAAC,KAAK,CAAC,eAAe,CAAC;YAC1D,WAAW,EAAE,KAAK,CAAC,oBAAoB;SACxC,CAAC;QAEF,IAAI,CAAC,OAAO,GAAG,IAAI,uBAAc,CAC/B,IAAI,CAAC,KAAK,EACV,GAAG,IAAI,CAAC,EAAE,QAAQ,EAClB,WAAW,CACZ,CAAC;QAEF,gEAAgE;QAChE,8DAA8D;QAC9D,IAAI,CAAC,WAAW,GAAG,IAAI,qBAAW,EAAE,CAAC;IACvC,CAAC;CACF;AAxJD,0BAwJC","sourcesContent":["import { type RepositoryImage } from \"aws-cdk-lib/aws-ecs\";\nimport { Repository } from \"aws-cdk-lib/aws-ecr\";\nimport {\n  Connections,\n  type IConnectable,\n  type IVpc,\n  type UserData,\n  type IMachineImage\n} from \"aws-cdk-lib/aws-ec2\";\nimport {\n  Code,\n  Runtime,\n  type FunctionUrlAuthType,\n  HttpMethod,\n  type FunctionUrlCorsOptions\n} from \"aws-cdk-lib/aws-lambda\";\nimport { type Duration } from \"aws-cdk-lib\";\nimport { type PolicyStatement } from \"aws-cdk-lib/aws-iam\";\n\nimport { Construct } from \"constructs\";\n\nimport type App from \"../../app\";\n\nimport FargateCluster, {\n  type FargateClusterProps,\n  Protocol,\n  ScalingType,\n  type DomainConfig\n} from \"../../resources/aws/compute/ecs\";\nimport EcsFreeTier from \"../../resources/aws/compute/ecsFreeTier\";\nimport EcsSpot from \"../../resources/aws/compute/ecsSpot\";\nimport { Ec2Instance } from \"../../resources/aws/compute/ec2\";\nimport { LambdaFunction } from \"../../resources/aws/compute/lambda\";\nimport { type SecretImport } from \"../../resources/aws/secrets\";\n\n// User-friendly HTTP method type\nexport type HttpMethodString =\n  | \"GET\"\n  | \"POST\"\n  | \"PUT\"\n  | \"DELETE\"\n  | \"HEAD\"\n  | \"OPTIONS\"\n  | \"PATCH\";\n\n// User-friendly CORS options that accept string methods\nexport interface SimplifiedCorsOptions {\n  allowedOrigins?: string[];\n  allowedMethods?: HttpMethodString[];\n  allowedHeaders?: string[];\n  maxAge?: Duration;\n  allowCredentials?: boolean;\n  exposeHeaders?: string[];\n}\n\ninterface IComputeProps {\n  vpc?: IVpc;\n  ecrRepository?: Repository | RepositoryImage;\n\n  // Compute type selection\n  type?: \"ecs\" | \"ec2\" | \"lambda\";\n\n  // ECS subtype selection (only applicable when type is \"ecs\")\n  ecsType?: \"fargate\" | \"freetier\" | \"spot\";\n\n  // ECS-specific properties\n  parentDomain?: string;\n  domainConfig?: DomainConfig;\n\n  /**\n   * Path to Dockerfile for building custom image.\n   * Note: This is metadata for the CLI build process,\n   * not used during CDK synthesis\n   */\n  dockerfilePath?: string;\n\n  /**\n   * Port the container listens on (default: 80)\n   */\n  containerPort?: number;\n\n  /**\n   * CPU units for Fargate tasks (256, 512, 1024, 2048, 4096)\n   */\n  cpu?: number;\n\n  /**\n   * Memory in MiB for Fargate tasks (512-30720)\n   */\n  memoryLimitMiB?: number;\n\n  /**\n   * Environmnet variables to pass to the container\n   */\n  containerEnvironment?: {\n    [key: string]: string;\n  };\n\n  /**\n   * Safely import secrets from another resource,\n   *  object key is used as name when passing to container\n   */\n  containerSecretsImport?: {\n    [key: string]: SecretImport;\n  };\n\n  // EC2-specific properties\n  instanceType?: string;\n  enableSSH?: boolean;\n  userData?: UserData;\n  machineImage?: IMachineImage;\n  minCapacity?: number;\n  maxCapacity?: number;\n\n  // Lambda-specific properties\n  runtime?: Runtime;\n  handler?: string;\n  code?: Code;\n  timeout?: number;\n  memorySize?: number;\n  lambdaDescription?: string;\n  roleDescription?: string;\n  inlinePolicy?: PolicyStatement[];\n\n  // Lambda URL properties\n  enableFunctionUrl?: boolean;\n  functionUrlAuthType?: FunctionUrlAuthType;\n  functionUrlCors?: SimplifiedCorsOptions;\n\n  connections?: IConnectable[];\n}\n\n// Helper function to convert string HTTP methods to HttpMethod enum\nfunction convertHttpMethods(methods: HttpMethodString[]): HttpMethod[] {\n  const methodMap: Record<HttpMethodString, HttpMethod> = {\n    GET: HttpMethod.GET,\n    POST: HttpMethod.POST,\n    PUT: HttpMethod.PUT,\n    DELETE: HttpMethod.DELETE,\n    HEAD: HttpMethod.HEAD,\n    OPTIONS: HttpMethod.OPTIONS,\n    PATCH: HttpMethod.PATCH\n  };\n\n  return methods.map((method) => {\n    const httpMethod = methodMap[method];\n    if (!httpMethod) {\n      throw new Error(\n        `Invalid HTTP method: ${method}. Valid methods are: ${Object.keys(methodMap).join(\", \")}`\n      );\n    }\n    return httpMethod;\n  });\n}\n\n// Convert simplified CORS options to CDK CORS options\nfunction convertCorsOptions(\n  simplifiedCors?: SimplifiedCorsOptions\n): FunctionUrlCorsOptions | undefined {\n  if (!simplifiedCors) return undefined;\n\n  return {\n    allowedOrigins: simplifiedCors.allowedOrigins,\n    allowedMethods: simplifiedCors.allowedMethods\n      ? convertHttpMethods(simplifiedCors.allowedMethods)\n      : undefined,\n    allowedHeaders: simplifiedCors.allowedHeaders,\n    maxAge: simplifiedCors.maxAge,\n    allowCredentials: simplifiedCors.allowCredentials,\n    exposedHeaders: simplifiedCors.exposeHeaders\n  };\n}\n\nexport class ComputeFactory {\n  static build(id: string, props: IComputeProps) {\n    return (app: App, scope: Construct) => {\n      const computeProps = {\n        ...{\n          vpc: app.getVpc(),\n          ecrRepository: app.getDefaultContainerRegistry()\n        },\n        ...props\n      };\n\n      return new Compute(scope, id, computeProps);\n    };\n  }\n}\n\nexport class Compute extends Construct implements IConnectable {\n  public id: string;\n  public scope: Construct;\n  public vpc: IVpc;\n\n  public connections: Connections;\n\n  private compute:\n    | FargateCluster\n    | EcsFreeTier\n    | EcsSpot\n    | Ec2Instance\n    | LambdaFunction;\n\n  constructor(scope: Construct, id: string, props: IComputeProps) {\n    super(scope, id);\n    this.id = id;\n    this.scope = scope;\n\n    this.addCompute(props);\n  }\n\n  addCompute(props: IComputeProps) {\n    const computeType = props.type || \"ecs\";\n\n    if (computeType === \"ec2\") {\n      this.addEc2Compute(props);\n    } else if (computeType === \"lambda\") {\n      this.addLambdaCompute(props);\n    } else {\n      this.addEcsCompute(props);\n    }\n  }\n\n  private addEc2Compute(props: IComputeProps) {\n    const ec2Props = {\n      serviceName: `${this.id}Service`,\n      instanceType: props.instanceType || \"t3.micro\",\n      enableSSH: props.enableSSH || false,\n      userData: props.userData,\n      machineImage: props.machineImage,\n      minCapacity: props.minCapacity || 1,\n      maxCapacity: props.maxCapacity || 1,\n      vpc: props.vpc\n    };\n\n    this.compute = new Ec2Instance(this.scope, `${this.id}Ec2`, ec2Props);\n    this.connections = this.compute.connections;\n\n    if (props.connections) {\n      for (const conn of props.connections) {\n        this.compute.connections.allowToDefaultPort(conn);\n      }\n    }\n  }\n\n  private addEcsCompute(props: IComputeProps) {\n    const ecsType = props.ecsType || \"fargate\";\n\n    // Common ECS props\n    const baseEcsProps = {\n      ...props,\n      containerPort: props.containerPort || 80,\n      serviceName: `${this.id}Service`,\n      clusterName: `${this.id}Cluster`,\n      ecrRepository: props.ecrRepository || \"amazon/amazon-ecs-sample\",\n      containerEnvironment: props.containerEnvironment || {},\n      containerSecretsImport: props.containerSecretsImport || {},\n      vpc: props.vpc\n    };\n\n    if (ecsType === \"freetier\") {\n      // Use EC2-based ECS for free tier\n      this.compute = new EcsFreeTier(\n        this.scope,\n        `${this.id}EcsFreeTier`,\n        baseEcsProps\n      );\n    } else if (ecsType === \"spot\") {\n      // Use EC2 Spot instances for cost optimization\n      this.compute = new EcsSpot(this.scope, `${this.id}EcsSpot`, baseEcsProps);\n    } else {\n      // Default to Fargate\n      const fargateProps = {\n        ...baseEcsProps,\n        scalingType: ScalingType.CPU,\n        protocol: props.domainConfig ? Protocol.HTTPS : Protocol.HTTP,\n        domainConfig: props.domainConfig\n      } as FargateClusterProps;\n\n      this.compute = new FargateCluster(\n        this.scope,\n        `${this.id}Fargate`,\n        fargateProps\n      );\n    }\n\n    if (props.connections) {\n      for (const conn of props.connections) {\n        this.compute.connections.allowToDefaultPort(conn);\n      }\n    }\n\n    this.connections = this.compute.connections;\n  }\n\n  private addLambdaCompute(props: IComputeProps) {\n    let code = props.code;\n\n    if (!code) {\n      if (!props.ecrRepository) {\n        throw new Error(\n          \"Either code or ecrRepository must be provided for Lambda compute type\"\n        );\n      }\n\n      if (props.ecrRepository instanceof Repository) {\n        code = Code.fromEcrImage(props.ecrRepository, {\n          tagOrDigest: \"latest\"\n        });\n      } else {\n        throw new Error(\n          \"ecrRepository must be a Repository instance for Lambda compute type\"\n        );\n      }\n    }\n\n    const lambdaProps = {\n      code: code,\n      handler: props.handler || \"index.handler\",\n      runtime: props.runtime || Runtime.NODEJS_18_X,\n      timeout: props.timeout,\n      memorySize: props.memorySize,\n      lambdaDescription: props.lambdaDescription,\n      roleDescription: props.roleDescription,\n      inlinePolicy: props.inlinePolicy || [],\n      enableFunctionUrl: props.enableFunctionUrl,\n      functionUrlAuthType: props.functionUrlAuthType,\n      functionUrlCors: convertCorsOptions(props.functionUrlCors),\n      environment: props.containerEnvironment\n    };\n\n    this.compute = new LambdaFunction(\n      this.scope,\n      `${this.id}Lambda`,\n      lambdaProps\n    );\n\n    // Lambda functions don't use security groups unless VPC-enabled\n    // Create empty connections object for interface compatibility\n    this.connections = new Connections();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compute.js","sourceRoot":"","sources":["../../../../lib/patterns/aws/compute.ts"],"names":[],"mappings":";;;AAwGA,oDAEC;AAED,oEAIC;AA/GD,iDAAiD;AACjD,iDAM6B;AAC7B,uDAMgC;AAOhC,2CAAuC;AAIvC,yDAIyC;AACzC,yDAA8D;AAC9D,+DAAoE;AAuBvD,QAAA,mBAAmB,GAA2C;IACzE,GAAG,EAAE;QACH,WAAW,EAAE,EAAE;QACf,cAAc,EAAE,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE;QAClD,mBAAmB,EAAE,IAAI;QACzB,WAAW,EAAE,IAAI;KAClB;IACD,GAAG,EAAE;QACH,WAAW,EAAE,EAAE;QACf,cAAc,EAAE,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE;QAClD,mBAAmB,EAAE,IAAI;QACzB,WAAW,EAAE,IAAI;KAClB;IACD,MAAM,EAAE;QACN,WAAW,EAAE,CAAC;QACd,cAAc,EAAE,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,EAAE,GAAG,EAAE;QACpD,mBAAmB,EAAE,KAAK;QAC1B,WAAW,EAAE,KAAK;KACnB;CACF,CAAC;AAYW,QAAA,4BAA4B,GAGrC;IACF,OAAO,EAAE;QACP,QAAQ,EAAE,KAAK;QACf,gBAAgB,EAAE,KAAK;KACxB;IACD,YAAY,EAAE;QACZ,QAAQ,EAAE,IAAI;QACd,gBAAgB,EAAE,KAAK;KACxB;IACD,GAAG,EAAE;QACH,QAAQ,EAAE,KAAK;QACf,gBAAgB,EAAE,IAAI;KACvB;CACF,CAAC;AAEF,SAAgB,oBAAoB,CAAC,IAAiB;IACpD,OAAO,2BAAmB,CAAC,IAAI,CAAC,CAAC;AACnC,CAAC;AAED,SAAgB,4BAA4B,CAC1C,QAA6B;IAE7B,OAAO,oCAA4B,CAAC,QAAQ,CAAC,CAAC;AAChD,CAAC;AAED,uDAAuD;AACvD,qDAGgC;AAF9B,wGAAA,UAAU,OAAA;AAkeZ;;;;GAIG;AACH,SAAS,oBAAoB,CAAC,KAAoB;IAChD,MAAM,QAAQ,GAAG,KAA2C,CAAC;IAE7D,0CAA0C;IAC1C,IAAI,KAAK,CAAC,IAAI,KAAK,KAAK,EAAE,CAAC;QACzB,IACE,kBAAkB,IAAI,QAAQ;YAC9B,QAAQ,CAAC,gBAAgB,KAAK,SAAS,EACvC,CAAC;YACD,OAAO,CAAC,IAAI,CACV,sDAAsD,KAAK,CAAC,IAAI,YAAY;gBAC1E,8DAA8D,CACjE,CAAC;QACJ,CAAC;QACD,IAAI,WAAW,IAAI,QAAQ,IAAI,QAAQ,CAAC,SAAS,KAAK,SAAS,EAAE,CAAC;YAChE,OAAO,CAAC,IAAI,CACV,+CAA+C,KAAK,CAAC,IAAI,YAAY;gBACnE,yDAAyD,CAC5D,CAAC;QACJ,CAAC;QACD,IAAI,UAAU,IAAI,QAAQ,IAAI,QAAQ,CAAC,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC9D,OAAO,CAAC,IAAI,CACV,8CAA8C,KAAK,CAAC,IAAI,YAAY;gBAClE,qDAAqD,CACxD,CAAC;QACJ,CAAC;QACD,IAAI,SAAS,IAAI,QAAQ,IAAI,QAAQ,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;YAC5D,OAAO,CAAC,IAAI,CACV,6CAA6C,KAAK,CAAC,IAAI,YAAY;gBACjE,oDAAoD,CACvD,CAAC;QACJ,CAAC;IACH,CAAC;IAED,gDAAgD;IAChD,IAAI,KAAK,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC5B,IAAI,aAAa,IAAI,QAAQ,IAAI,QAAQ,CAAC,WAAW,KAAK,SAAS,EAAE,CAAC;YACpE,OAAO,CAAC,IAAI,CACV,iDAAiD,KAAK,CAAC,IAAI,YAAY;gBACrE,4DAA4D,CAC/D,CAAC;QACJ,CAAC;QACD,IAAI,SAAS,IAAI,QAAQ,IAAI,QAAQ,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;YAC5D,OAAO,CAAC,IAAI,CACV,6CAA6C,KAAK,CAAC,IAAI,YAAY;gBACjE,uDAAuD,CAC1D,CAAC;QACJ,CAAC;QACD,IAAI,SAAS,IAAI,QAAQ,IAAI,QAAQ,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;YAC5D,OAAO,CAAC,IAAI,CACV,6CAA6C,KAAK,CAAC,IAAI,YAAY;gBACjE,uDAAuD,CAC1D,CAAC;QACJ,CAAC;IACH,CAAC;IAED,0CAA0C;IAC1C,IAAI,KAAK,CAAC,IAAI,KAAK,KAAK,EAAE,CAAC;QACzB,IAAI,KAAK,IAAI,QAAQ,IAAI,QAAQ,CAAC,GAAG,KAAK,SAAS,EAAE,CAAC;YACpD,OAAO,CAAC,IAAI,CACV,yCAAyC,KAAK,CAAC,IAAI,YAAY;gBAC7D,gDAAgD,CACnD,CAAC;QACJ,CAAC;QACD,IAAI,UAAU,IAAI,QAAQ,IAAI,QAAQ,CAAC,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC9D,OAAO,CAAC,IAAI,CACV,8CAA8C,KAAK,CAAC,IAAI,YAAY;gBAClE,wCAAwC,CAC3C,CAAC;QACJ,CAAC;QACD,IAAI,cAAc,IAAI,QAAQ,IAAI,QAAQ,CAAC,YAAY,KAAK,SAAS,EAAE,CAAC;YACtE,OAAO,CAAC,IAAI,CACV,kDAAkD,KAAK,CAAC,IAAI,YAAY;gBACtE,4CAA4C,CAC/C,CAAC;QACJ,CAAC;IACH,CAAC;IAED,0BAA0B;IAC1B,IAAI,KAAK,CAAC,IAAI,KAAK,KAAK,EAAE,CAAC;QACzB,gBAAgB,CAAC,KAAwB,CAAC,CAAC;IAC7C,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,SAAS,gBAAgB,CAAC,KAAsB;IAC9C,wBAAwB;IACxB,IAAI,KAAK,CAAC,SAAS,IAAI,KAAK,CAAC,gBAAgB,KAAK,KAAK,EAAE,CAAC;QACxD,OAAO,CAAC,IAAI,CACV,8EAA8E;YAC5E,kEAAkE,CACrE,CAAC;IACJ,CAAC;IAED,kDAAkD;IAClD,IAAI,CAAC,KAAK,CAAC,QAAQ,IAAI,KAAK,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACnD,MAAM,IAAI,KAAK,CACb,6DAA6D,CAC9D,CAAC;IACJ,CAAC;IAED,gCAAgC;IAChC,MAAM,YAAY,GAAG,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IACvD,MAAM,cAAc,GAAG,YAAY,CAAC,MAAM,CACxC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,KAAK,CACtD,CAAC;IACF,IAAI,cAAc,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CACb,4BAA4B,CAAC,GAAG,IAAI,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CACtE,CAAC;IACJ,CAAC;IAED,+BAA+B;IAC/B,MAAM,YAAY,GAAG,KAAK,CAAC,QAAQ,CAAC,MAAM,CACxC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,yBAAyB,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAC/C,CAAC;IACF,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC5B,MAAM,IAAI,KAAK,CACb,0BAA0B,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI;YACtE,wFAAwF,CAC3F,CAAC;IACJ,CAAC;IAED,qDAAqD;IACrD,MAAM,iBAAiB,GAAG,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CACpD,CAAC,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAClC,CAAC;IAEF,IAAI,iBAAiB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACjC,MAAM,cAAc,GAAG,iBAAiB,CAAC,MAAM,CAC7C,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,IAAI,IAAI,CAAC,CAAC,CAAC,OAAO,EAAE,IAAI,CAC5C,CAAC;QACF,IAAI,cAAc,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC9B,MAAM,IAAI,KAAK,CACb,iFAAiF;gBAC/E,GAAG,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI;gBACnD,4EAA4E,CAC/E,CAAC;QACJ,CAAC;IACH,CAAC;IAED,qCAAqC;IACrC,KAAK,MAAM,OAAO,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;QACrC,IAAI,OAAO,CAAC,UAAU,IAAI,OAAO,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACxD,6EAA6E;YAC7E,MAAM,cAAc,GAAG,OAAO,CAAC,UAAU;iBACtC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;iBACrB,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;YACtB,MAAM,uBAAuB,GAAG,cAAc,CAAC,MAAM,CACnD,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,cAAc,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,KAAK,CACxD,CAAC;YACF,IAAI,uBAAuB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACvC,MAAM,IAAI,KAAK,CACb,YAAY,OAAO,CAAC,IAAI,gCAAgC;oBACtD,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,uBAAuB,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CACxD,CAAC;YACJ,CAAC;QACH,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAa,cAAc;IACzB,MAAM,CAAC,KAAK,CAAC,EAAU,EAAE,KAAoB;QAC3C,OAAO,CAAC,GAAQ,EAAE,KAAgB,EAAW,EAAE;YAC7C,oBAAoB,CAAC,KAAK,CAAC,CAAC;YAE5B,MAAM,YAAY,GAAkB;gBAClC,GAAG;oBACD,GAAG,EAAE,GAAG,CAAC,MAAM,EAAE;oBACjB,aAAa,EAAE,GAAG,CAAC,2BAA2B,EAAE;iBACjD;gBACD,GAAG,KAAK;aACT,CAAC;YAEF,OAAO,IAAI,OAAO,CAAC,KAAK,EAAE,EAAE,EAAE,YAAY,CAAC,CAAC;QAC9C,CAAC,CAAC;IACJ,CAAC;CACF;AAhBD,wCAgBC;AAED,MAAa,OAAQ,SAAQ,sBAAS;IASpC,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAoB;QAC5D,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACjB,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;QACb,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QAEnB,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IACzB,CAAC;IAED,UAAU,CAAC,KAAoB;QAC7B,QAAQ,KAAK,CAAC,IAAI,EAAE,CAAC;YACnB,KAAK,KAAK;gBACR,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;gBAC1B,MAAM;YACR,KAAK,KAAK;gBACR,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;gBAC1B,MAAM;YACR,KAAK,QAAQ;gBACX,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;gBAC7B,MAAM;YACR;gBACE,oEAAoE;gBACpE,MAAM,WAAW,GAAU,KAAK,CAAC;gBACjC,MAAM,IAAI,KAAK,CACb,6BAA8B,WAA6B,CAAC,IAAI,EAAE,CACnE,CAAC;QACN,CAAC;IACH,CAAC;IAEO,aAAa,CAAC,KAAsB;QAC1C,MAAM,SAAS,GAAG,KAAK,CAAC,GAAG,KAAK,SAAS,IAAI,KAAK,CAAC,GAAG,KAAK,KAAK,CAAC;QAEjE,MAAM,QAAQ,GAAG;YACf,WAAW,EAAE,GAAG,IAAI,CAAC,EAAE,SAAS;YAChC,YAAY,EAAE,KAAK,CAAC,YAAY,IAAI,UAAU;YAC9C,SAAS;YACT,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,YAAY,EAAE,KAAK,CAAC,YAAY;YAChC,WAAW,EAAE,KAAK,CAAC,WAAW,IAAI,CAAC;YACnC,WAAW,EAAE,KAAK,CAAC,WAAW,IAAI,CAAC;YACnC,GAAG,EAAE,KAAK,CAAC,GAAG;SACf,CAAC;QAEF,IAAI,CAAC,OAAO,GAAG,IAAI,iBAAW,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;QACtE,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC;IAC9C,CAAC;IAEO,aAAa,CAAC,KAAsB;QAC1C,MAAM,gBAAgB,GACpB,KAAK,CAAC,gBAAgB,IAAI,SAAS,CAAC;QAEtC,mEAAmE;QACnE,MAAM,QAAQ,GAAgC,KAAK,CAAC,QAAQ,CAAC,GAAG,CAC9D,CAAC,OAAO,EAAE,EAAE;YACV,kDAAkD;YAClD,IAAI,UAA6D,CAAC;YAElE,IAAI,OAAO,CAAC,UAAU,IAAI,OAAO,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACxD,wDAAwD;gBACxD,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC;oBACjD,IAAI,EAAE,CAAC,CAAC,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,YAAY,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE;oBACnE,KAAK,EAAE,CAAC,CAAC,KAAK;oBACd,IAAI,EAAE,CAAC,CAAC,IAAI;oBACZ,WAAW,EAAE,CAAC,CAAC,WAAW;oBAC1B,aAAa,EAAE,CAAC,CAAC,aAAa;oBAC9B,OAAO,EAAE,CAAC,CAAC,OAAO;oBAClB,UAAU,EAAE,CAAC,CAAC,UAAU;oBACxB,SAAS,EAAE,CAAC,CAAC,SAAS;oBACtB,WAAW,EAAE,CAAC,CAAC,WAAW;iBAC3B,CAAC,CAAC,CAAC;YACN,CAAC;iBAAM,CAAC;gBACN,uCAAuC;gBACvC,UAAU,GAAG;oBACX;wBACE,IAAI,EAAE,GAAG,OAAO,CAAC,IAAI,WAAW;qBACjC;iBACF,CAAC;YACJ,CAAC;YAED,2BAA2B;YAC3B,IAAI,WAAoC,CAAC;YACzC,IAAI,WAA+B,CAAC;YACpC,IAAI,WAA+B,CAAC;YAEpC,IAAI,OAAO,CAAC,OAAO,KAAK,KAAK,IAAI,OAAO,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;gBAC/D,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,WAAW,IAAI,iBAAW,CAAC,GAAG,CAAC;gBAC7D,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC;gBAC1C,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC;YAC5C,CAAC;iBAAM,IAAI,OAAO,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;gBACzC,mCAAmC;gBACnC,WAAW,GAAG,iBAAW,CAAC,GAAG,CAAC;YAChC,CAAC;YAED,OAAO;gBACL,IAAI,EAAE,OAAO,CAAC,IAAI;gBAClB,KAAK,EAAE,OAAO,CAAC,KAAK;gBACpB,UAAU;gBACV,GAAG,EAAE,OAAO,CAAC,GAAG;gBAChB,cAAc,EAAE,OAAO,CAAC,cAAc;gBACtC,YAAY,EAAE,OAAO,CAAC,YAAY;gBAClC,WAAW;gBACX,WAAW;gBACX,WAAW;gBACX,OAAO,EAAE,OAAO,CAAC,OAAO;gBACxB,sBAAsB,EAAE,OAAO,CAAC,sBAAsB;gBACtD,uBAAuB,EAAE,OAAO,CAAC,uBAAuB;gBACxD,WAAW,EAAE,OAAO,CAAC,WAAW;aACjC,CAAC;QACJ,CAAC,CACF,CAAC;QAEF,uBAAuB;QACvB,MAAM,OAAO,GAA+B,KAAK,CAAC,OAAO;YACvD,CAAC,CAAC;gBACE,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,MAAM;gBAC5B,YAAY,EAAE,KAAK,CAAC,OAAO,CAAC,YAAY;gBACxC,YAAY,EAAE,KAAK,CAAC,OAAO,CAAC,YAAY;aACzC;YACH,CAAC,CAAC,SAAS,CAAC;QAEd,MAAM,QAAQ,GAAoB;YAChC,WAAW,EAAE,GAAG,IAAI,CAAC,EAAE,SAAS;YAChC,GAAG,EAAE,KAAK,CAAC,GAAG;YACd,aAAa,EAAE,KAAK,CAAC,aAAa,IAAI,0BAA0B;YAChE,gBAAgB;YAChB,SAAS,EAAE,gBAAgB,KAAK,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS;YACnE,OAAO;YACP,QAAQ;SACT,CAAC;QAEF,IAAI,CAAC,OAAO,GAAG,IAAI,aAAU,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;QACrE,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC;IAC9C,CAAC;IAEO,gBAAgB,CAAC,KAAyB;QAChD,IAAI,IAAU,CAAC;QACf,IAAI,OAAe,CAAC;QACpB,IAAI,OAAgB,CAAC;QAErB,IAAI,KAAK,CAAC,UAAU,KAAK,WAAW,EAAE,CAAC;YACrC,mCAAmC;YACnC,IAAI,KAAK,CAAC,aAAa,YAAY,oBAAU,EAAE,CAAC;gBAC9C,IAAI,GAAG,iBAAI,CAAC,YAAY,CAAC,KAAK,CAAC,aAAa,EAAE;oBAC5C,WAAW,EAAE,QAAQ;iBACtB,CAAC,CAAC;YACL,CAAC;iBAAM,CAAC;gBACN,MAAM,IAAI,KAAK,CACb,qEAAqE,CACtE,CAAC;YACJ,CAAC;YAED,iDAAiD;YACjD,OAAO,GAAG,oBAAO,CAAC,UAAU,CAAC;YAC7B,OAAO,GAAG,oBAAO,CAAC,UAAU,CAAC;QAC/B,CAAC;aAAM,CAAC;YACN,kDAAkD;YAClD,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;YAClB,OAAO,GAAG,KAAK,CAAC,OAAO,IAAI,eAAe,CAAC;YAC3C,OAAO,GAAG,KAAK,CAAC,OAAO,IAAI,oBAAO,CAAC,WAAW,CAAC;QACjD,CAAC;QAED,qEAAqE;QACrE,MAAM,iBAAiB,GAAG,KAAK,CAAC,WAAW,CAAC;QAC5C,MAAM,iBAAiB,GACrB,iBAAiB,KAAK,SAAS,IAAI,iBAAiB,KAAK,KAAK,CAAC;QACjE,MAAM,mBAAmB,GACvB,iBAAiB,IAAI,OAAO,iBAAiB,KAAK,QAAQ;YACxD,CAAC,CAAC,iBAAiB,CAAC,QAAQ;YAC5B,CAAC,CAAC,SAAS,CAAC;QAChB,MAAM,eAAe,GACnB,iBAAiB,IAAI,OAAO,iBAAiB,KAAK,QAAQ;YACxD,CAAC,CAAC,iBAAiB,CAAC,IAAI;YACxB,CAAC,CAAC,SAAS,CAAC;QAEhB,MAAM,WAAW,GAAG;YAClB,IAAI,EAAE,IAAI;YACV,OAAO;YACP,OAAO;YACP,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,UAAU,EAAE,KAAK,CAAC,UAAU;YAC5B,iBAAiB,EAAE,KAAK,CAAC,WAAW;YACpC,eAAe,EAAE,KAAK,CAAC,eAAe;YACtC,YAAY,EAAE,KAAK,CAAC,YAAY,IAAI,EAAE;YACtC,iBAAiB;YACjB,mBAAmB;YACnB,eAAe;YACf,WAAW,EAAE,KAAK,CAAC,WAAW;SAC/B,CAAC;QAEF,IAAI,CAAC,OAAO,GAAG,IAAI,uBAAc,CAC/B,IAAI,CAAC,KAAK,EACV,GAAG,IAAI,CAAC,EAAE,QAAQ,EAClB,WAAW,CACZ,CAAC;QAEF,gEAAgE;QAChE,8DAA8D;QAC9D,IAAI,CAAC,WAAW,GAAG,IAAI,qBAAW,EAAE,CAAC;IACvC,CAAC;CACF;AA/MD,0BA+MC","sourcesContent":["import { type RepositoryImage } from \"aws-cdk-lib/aws-ecs\";\nimport { Repository } from \"aws-cdk-lib/aws-ecr\";\nimport {\n  Connections,\n  type IConnectable,\n  type IVpc,\n  type UserData,\n  type IMachineImage\n} from \"aws-cdk-lib/aws-ec2\";\nimport {\n  Code,\n  Runtime,\n  Handler,\n  type FunctionUrlAuthType,\n  type FunctionUrlCorsOptions\n} from \"aws-cdk-lib/aws-lambda\";\nimport {\n  type PolicyStatement,\n  type PolicyDocument,\n  type IManagedPolicy\n} from \"aws-cdk-lib/aws-iam\";\n\nimport { Construct } from \"constructs\";\n\nimport type App from \"../../app\";\n\nimport EcsCluster, {\n  type EcsClusterProps,\n  ScalingType,\n  type EcsCapacityProvider as EcsCapacityProviderType\n} from \"../../resources/aws/compute/ecs\";\nimport { Ec2Instance } from \"../../resources/aws/compute/ec2\";\nimport { LambdaFunction } from \"../../resources/aws/compute/lambda\";\nimport { type SecretImport } from \"../../resources/aws/secrets\";\n\nexport type ComputeType = \"ecs\" | \"ec2\" | \"lambda\";\nexport type EcsCapacityProvider = \"FARGATE\" | \"FARGATE_SPOT\" | \"EC2\";\n\n/**\n * Configuration defaults for each compute type.\n */\nexport interface ComputeTypeConfig {\n  /** Default port for the compute type. ECS: 80, EC2: 22, Lambda: 0 (no port) */\n  defaultPort: number;\n  /** Default scaling limits */\n  defaultScaling: {\n    minCapacity: number;\n    maxCapacity: number;\n  };\n  /** Whether this compute type supports security group connections */\n  supportsConnections: boolean;\n  /** Whether this compute type requires a VPC */\n  requiresVpc: boolean;\n}\n\nexport const COMPUTE_TYPE_CONFIG: Record<ComputeType, ComputeTypeConfig> = {\n  ecs: {\n    defaultPort: 80,\n    defaultScaling: { minCapacity: 2, maxCapacity: 5 },\n    supportsConnections: true,\n    requiresVpc: true\n  },\n  ec2: {\n    defaultPort: 22,\n    defaultScaling: { minCapacity: 2, maxCapacity: 3 },\n    supportsConnections: true,\n    requiresVpc: true\n  },\n  lambda: {\n    defaultPort: 0,\n    defaultScaling: { minCapacity: 0, maxCapacity: 100 },\n    supportsConnections: false,\n    requiresVpc: false\n  }\n};\n\n/**\n * Configuration for ECS capacity providers.\n */\nexport interface EcsCapacityProviderConfig {\n  /** Whether this uses Spot pricing */\n  usesSpot: boolean;\n  /** Whether this runs on EC2 instances (vs serverless Fargate) */\n  usesEc2Instances: boolean;\n}\n\nexport const ECS_CAPACITY_PROVIDER_CONFIG: Record<\n  EcsCapacityProvider,\n  EcsCapacityProviderConfig\n> = {\n  FARGATE: {\n    usesSpot: false,\n    usesEc2Instances: false\n  },\n  FARGATE_SPOT: {\n    usesSpot: true,\n    usesEc2Instances: false\n  },\n  EC2: {\n    usesSpot: false,\n    usesEc2Instances: true\n  }\n};\n\nexport function getComputeTypeConfig(type: ComputeType): ComputeTypeConfig {\n  return COMPUTE_TYPE_CONFIG[type];\n}\n\nexport function getEcsCapacityProviderConfig(\n  provider: EcsCapacityProvider\n): EcsCapacityProviderConfig {\n  return ECS_CAPACITY_PROVIDER_CONFIG[provider];\n}\n\n// Re-export Lambda types from CDK for user convenience\nexport {\n  HttpMethod,\n  type FunctionUrlCorsOptions\n} from \"aws-cdk-lib/aws-lambda\";\n\n/**\n * Configuration for a container in an ECS task.\n *\n * For single-container services, `name` is optional and defaults to `${serviceName}Container`.\n * For multi-container tasks, the first container with a `port` is the **primary container**\n * that receives load balancer traffic.\n *\n * @example\n * // Single container (name auto-generated)\n * containers: [{ port: 3000 }]\n *\n * @example\n * // Multi-container with sidecars\n * containers: [\n *   { name: \"app\", port: 3000 },                    // Primary - receives ALB traffic\n *   { name: \"datadog\", image: \"datadog/agent\" }     // Sidecar - monitoring\n * ]\n */\nexport interface EcsContainerConfig {\n  /** Container name. Optional for single-container services. */\n  name?: string;\n  /**\n   * Container image. Options:\n   * - Omit: Uses app's default ECR repository (primary container only)\n   * - string: ECR repository name or public image URL\n   * - Repository: CDK ECR Repository construct\n   */\n  image?: string | Repository;\n  /**\n   * Port the container listens on.\n   * The first container with a port becomes the **primary container**\n   * and is registered with the load balancer.\n   */\n  port?: number;\n  /** Environment variables */\n  environment?: Record<string, string>;\n  /** Secrets imported from other resources */\n  secretsImport?: Record<string, SecretImport>;\n  /** Command to run in the container */\n  command?: string[];\n  /** Entry point for the container */\n  entryPoint?: string[];\n  /**\n   * Whether this container is essential.\n   * If an essential container stops, all containers in the task stop.\n   * Default: true\n   */\n  essential?: boolean;\n  /**\n   * Health check configuration.\n   * Default: For primary container with port, uses curl health check.\n   */\n  healthCheck?: {\n    command: string[];\n    interval?: number;\n    timeout?: number;\n    retries?: number;\n    startPeriod?: number;\n  };\n}\n\n/**\n * ECS scaling configuration.\n * - Omit: enabled with defaults\n * - `{}`: enabled with defaults\n * - `{ minCapacity: 2, maxCapacity: 10 }`: custom scaling\n * - `false`: explicitly disabled\n */\nexport interface EcsScalingConfig {\n  minCapacity?: number;\n  maxCapacity?: number;\n  scalingType?: ScalingType;\n}\n\n/**\n * EC2 capacity configuration for ECS EC2-backed clusters.\n * Only used when capacityProvider is \"EC2\".\n */\nexport interface Ec2CapacityConfig {\n  /** EC2 instance type. Default: \"t3.micro\" */\n  instanceType?: string;\n  /** AMI hardware type. Default: \"ARM\" (Graviton - better cost/performance) */\n  amiHardwareType?: \"ARM\" | \"STANDARD\";\n  /** Minimum number of instances. Default: 1 */\n  minCapacity?: number;\n  /** Maximum number of instances. Default: 3 */\n  maxCapacity?: number;\n  /** Desired number of EC2 instances. Default: 2 (for availability) */\n  desiredCount?: number;\n  /** Memory limit in MiB for the container. Default: 1024 */\n  memoryLimitMiB?: number;\n}\n\n/**\n * Cluster-level configuration.\n * Controls the shared ALB for all services in this cluster.\n */\nexport interface EcsClusterConfig {\n  /**\n   * Domain for HTTPS access.\n   * - Omit: ALB created with default DNS (*.elb.amazonaws.com)\n   * - Specified: Creates ACM certificate + Route53 DNS A record\n   */\n  domain?: string;\n\n  /**\n   * Load balancer configuration.\n   * - Omit or \"public\": Internet-facing ALB (default)\n   * - \"internal\": VPC-only ALB\n   * - false: No ALB (for workers/background processors)\n   */\n  loadBalancer?: false | \"public\" | \"internal\";\n\n  /**\n   * Enable direct EC2 access without ALB.\n   * Uses host network mode for predictable ports.\n   * Access via EC2 public IP at container port.\n   */\n  directAccess?: boolean;\n}\n\n/**\n * Routing configuration for path/host-based routing on the ALB.\n * Required when cluster has multiple services with ports.\n * Optional for single service (gets all traffic automatically).\n */\nexport interface EcsRoutingConfig {\n  /**\n   * Path pattern for routing (e.g., \"/api/*\", \"/users/*\").\n   * Uses ALB path-based routing.\n   */\n  path?: string;\n\n  /**\n   * Host header for routing (e.g., \"api.example.com\").\n   * Uses ALB host-based routing.\n   */\n  host?: string;\n\n  /**\n   * Priority for this routing rule (1-50000).\n   * Lower number = higher priority.\n   * Auto-assigned if omitted.\n   */\n  priority?: number;\n\n  /**\n   * Health check path for this service's target group.\n   * Default: \"/\"\n   */\n  healthCheckPath?: string;\n}\n\n/**\n * Configuration for a service in an ECS cluster.\n * Each service gets its own task definition, scaling config, and target group.\n *\n * @example\n * // Simple service\n * { name: \"api\", containers: [{ port: 3000 }] }\n *\n * @example\n * // Service with routing (for multi-service clusters)\n * { name: \"users\", containers: [{ port: 3000 }], routing: { path: \"/users/*\", priority: 100 } }\n *\n * @example\n * // Service with sidecars\n * {\n *   name: \"api\",\n *   containers: [\n *     { name: \"app\", port: 3000 },\n *     { name: \"datadog\", image: \"datadog/agent\" }\n *   ]\n * }\n */\nexport interface EcsServiceConfig {\n  /** Service name (unique within cluster) */\n  name: string;\n\n  /**\n   * Container image for this service (applies to first container without explicit image).\n   * - Omit: Uses app's default ECR repository\n   * - string: ECR repository name or public image URL\n   * - Repository: CDK ECR Repository construct\n   */\n  image?: string | Repository;\n\n  /**\n   * Container configuration(s) for this service.\n   * For single-container services, container name is optional and auto-generated.\n   * For multi-container services, the first container with a port is the primary container.\n   */\n  containers?: EcsContainerConfig[];\n\n  /**\n   * Routing rules for this service on the cluster's ALB.\n   * Required when cluster has multiple services with ports.\n   * Optional for single service (gets /* automatically).\n   */\n  routing?: EcsRoutingConfig;\n\n  /** CPU units for this service's tasks (256-4096) */\n  cpu?: number;\n\n  /** Memory in MiB for this service's tasks (512-30720) */\n  memoryLimitMiB?: number;\n\n  /** Desired number of tasks. Default: 2 */\n  desiredCount?: number;\n\n  /**\n   * Scaling configuration.\n   * - Omit: enabled with defaults\n   * - false: disabled\n   */\n  scaling?: EcsScalingConfig | false;\n\n  /**\n   * Path to Dockerfile for building this service's image.\n   * Metadata for CLI build process, not used during CDK synthesis.\n   */\n  dockerfilePath?: string;\n\n  /**\n   * Additional inline policies for this service's task role.\n   * Added on top of the default ECS Exec permissions.\n   * Use for service-specific AWS permissions (S3, DynamoDB, SQS, etc.).\n   */\n  taskRoleInlinePolicies?: Record<string, PolicyDocument>;\n\n  /**\n   * Additional managed policies for this service's task role.\n   * Added on top of the default ECS Exec permissions.\n   */\n  taskRoleManagedPolicies?: IManagedPolicy[];\n\n  /**\n   * Resources this service needs to connect to (e.g., databases).\n   * Creates security group rules to allow traffic from this service.\n   * Follows least-privilege - only this service gets access, not all services in the cluster.\n   *\n   * @example\n   * // Only backend service connects to database\n   * services: [\n   *   { name: \"frontend\" },\n   *   { name: \"backend\", connections: [appDatabase] }\n   * ]\n   */\n  connections?: IConnectable[];\n}\n\n/**\n * SSH access configuration for EC2 instances.\n * - Omit: disabled (default)\n * - `{}`: enabled with auto-generated key\n * - `{ keyName: \"my-key\" }`: enabled with existing key\n * - `false`: explicitly disabled\n */\nexport interface SshConfig {\n  /** SSH key pair name */\n  keyName?: string;\n  /** Allowed CIDR blocks for SSH access */\n  allowedCidrs?: string[];\n}\n\n/**\n * Lambda function URL configuration.\n * - Omit: disabled (default)\n * - `{}`: enabled with IAM auth\n * - `{ authType: \"NONE\", cors: {...} }`: public with CORS\n * - `false`: explicitly disabled\n */\nexport interface FunctionUrlConfig {\n  /** Authentication type. Default: AWS_IAM */\n  authType?: FunctionUrlAuthType;\n  /** CORS configuration */\n  cors?: FunctionUrlCorsOptions;\n}\n\ninterface BaseComputeProps {\n  vpc?: IVpc;\n}\n\n/**\n * ECS compute configuration.\n * Creates an ECS cluster with one or more services sharing a load balancer.\n *\n * @example\n * // Single service\n * app.addCompute(ComputeFactory.build(\"WebApp\", {\n *   type: \"ecs\",\n *   cluster: { domain: \"app.example.com\" },\n *   services: [{ name: \"web\", containers: [{ port: 3000 }] }]\n * }));\n *\n * @example\n * // Multi-service cluster with routing\n * app.addCompute(ComputeFactory.build(\"ApiCluster\", {\n *   type: \"ecs\",\n *   cluster: { domain: \"api.example.com\" },\n *   services: [\n *     { name: \"users\", containers: [{ port: 3000 }], routing: { path: \"/users/*\" } },\n *     { name: \"orders\", containers: [{ port: 3001 }], routing: { path: \"/orders/*\" } }\n *   ]\n * }));\n *\n * @example\n * // Internal workers (no ALB)\n * app.addCompute(ComputeFactory.build(\"Workers\", {\n *   type: \"ecs\",\n *   cluster: { loadBalancer: false },\n *   services: [{ name: \"processor\" }, { name: \"emailer\" }]\n * }));\n */\nexport interface EcsComputeProps extends BaseComputeProps {\n  type: \"ecs\";\n\n  /**\n   * Cluster configuration.\n   * Controls the shared ALB for all services in this cluster.\n   * - Omit: ALB created with default settings\n   * - `{ domain: \"...\" }`: ALB with HTTPS + DNS\n   * - `{ loadBalancer: false }`: No ALB (internal workers)\n   */\n  cluster?: EcsClusterConfig;\n\n  /**\n   * Services in this cluster.\n   * Each service gets its own task definition, scaling, and target group.\n   * All services share the cluster's ALB (unless disabled).\n   */\n  services: EcsServiceConfig[];\n\n  /**\n   * Capacity provider determines infrastructure type.\n   * - \"FARGATE\": Serverless containers (default)\n   * - \"FARGATE_SPOT\": Serverless with Spot pricing\n   * - \"EC2\": EC2-backed containers\n   */\n  capacityProvider?: EcsCapacityProvider;\n\n  /**\n   * EC2 capacity configuration.\n   * Only used when capacityProvider is \"EC2\".\n   */\n  ec2Config?: Ec2CapacityConfig;\n\n  /**\n   * ECR repository for all services (default image).\n   * Individual services can override with their own `image` property.\n   */\n  ecrRepository?: Repository | RepositoryImage;\n\n  /**\n   * Path to Dockerfile for building custom image.\n   * Note: This is metadata for the CLI build process,\n   * not used during CDK synthesis.\n   */\n  dockerfilePath?: string;\n}\n\nexport interface Ec2ComputeProps extends BaseComputeProps {\n  type: \"ec2\";\n\n  /** EC2 instance type. Default: \"t3.micro\" */\n  instanceType?: string;\n\n  /**\n   * SSH access configuration.\n   * - Omit: disabled (default)\n   * - `{}`: enabled with defaults\n   * - `false`: explicitly disabled\n   */\n  ssh?: SshConfig | false;\n  /** User data script */\n  userData?: UserData;\n  /** Machine image (AMI) */\n  machineImage?: IMachineImage;\n  /** Minimum number of instances. Default: 1 */\n  minCapacity?: number;\n  /** Maximum number of instances. Default: 1 */\n  maxCapacity?: number;\n}\n\n/**\n * Base Lambda configuration shared by both container and code deployments.\n */\ninterface BaseLambdaProps extends BaseComputeProps {\n  type: \"lambda\";\n  /** Timeout in seconds. Default: 3 */\n  timeout?: number;\n  /** Memory size in MB. Default: 128 */\n  memorySize?: number;\n  /** Lambda function description */\n  description?: string;\n  /** IAM role description */\n  roleDescription?: string;\n  /** Inline IAM policy statements */\n  inlinePolicy?: PolicyStatement[];\n  /**\n   * Function URL configuration.\n   * - Omit: disabled (default)\n   * - `{}`: enabled with IAM auth\n   * - `{ authType: \"NONE\" }`: public access\n   * - `false`: explicitly disabled\n   */\n  functionUrl?: FunctionUrlConfig | false;\n  /** Environment variables */\n  environment?: Record<string, string>;\n}\n\n/**\n * Container-based Lambda using ECR image.\n *\n * Uses Docker image from ECR repository. Handler and runtime are\n * automatically set to FROM_IMAGE.\n *\n * @example\n * app.addCompute(ComputeFactory.build(\"ImageLambda\", {\n *   type: \"lambda\",\n *   deployment: \"container\",\n *   ecrRepository: app.getDefaultContainerRegistry()\n * }));\n */\nexport interface ContainerLambdaProps extends BaseLambdaProps {\n  /** Container-based deployment using ECR image */\n  deployment: \"container\";\n  /** ECR repository containing the Lambda container image */\n  ecrRepository: Repository | RepositoryImage;\n}\n\n/**\n * Code-based Lambda using inline code or S3.\n *\n * Uses traditional Lambda deployment with code, handler, and runtime.\n *\n * @example\n * app.addCompute(ComputeFactory.build(\"CodeLambda\", {\n *   type: \"lambda\",\n *   deployment: \"code\",\n *   code: Code.fromAsset(\"./lambda\"),\n *   handler: \"index.handler\",\n *   runtime: Runtime.NODEJS_20_X\n * }));\n */\nexport interface CodeLambdaProps extends BaseLambdaProps {\n  /** Code-based deployment */\n  deployment: \"code\";\n  /** Lambda code (from asset, S3, or inline) */\n  code: Code;\n  /** Handler function. Default: \"index.handler\" */\n  handler?: string;\n  /** Lambda runtime. Default: NODEJS_18_X */\n  runtime?: Runtime;\n}\n\n/**\n * Lambda compute configuration.\n *\n * Discriminated union ensuring type-safe Lambda configuration:\n * - `deployment: \"container\"` requires `ecrRepository`\n * - `deployment: \"code\"` requires `code` and allows `handler`/`runtime`\n *\n * @example\n * // Container-based Lambda\n * { type: \"lambda\", deployment: \"container\", ecrRepository: ecr }\n *\n * @example\n * // Code-based Lambda\n * { type: \"lambda\", deployment: \"code\", code: Code.fromAsset(\"./lambda\") }\n */\nexport type LambdaComputeProps = ContainerLambdaProps | CodeLambdaProps;\n\nexport type IComputeProps =\n  | EcsComputeProps\n  | Ec2ComputeProps\n  | LambdaComputeProps;\n\n/**\n * Validates compute props and logs warnings for ignored or misconfigured options.\n * These checks help catch issues when props come from dynamic sources where\n * TypeScript's compile-time checks may not apply.\n */\nfunction validateComputeProps(props: IComputeProps): void {\n  const propsAny = props as unknown as Record<string, unknown>;\n\n  // ECS-specific options on non-ECS compute\n  if (props.type !== \"ecs\") {\n    if (\n      \"capacityProvider\" in propsAny &&\n      propsAny.capacityProvider !== undefined\n    ) {\n      console.warn(\n        `[Fjall] Warning: 'capacityProvider' is ignored for ${props.type} compute. ` +\n          \"Capacity provider configuration only applies to ECS compute.\"\n      );\n    }\n    if (\"ec2Config\" in propsAny && propsAny.ec2Config !== undefined) {\n      console.warn(\n        `[Fjall] Warning: 'ec2Config' is ignored for ${props.type} compute. ` +\n          \"EC2 capacity configuration only applies to ECS compute.\"\n      );\n    }\n    if (\"services\" in propsAny && propsAny.services !== undefined) {\n      console.warn(\n        `[Fjall] Warning: 'services' is ignored for ${props.type} compute. ` +\n          \"Services configuration only applies to ECS compute.\"\n      );\n    }\n    if (\"cluster\" in propsAny && propsAny.cluster !== undefined) {\n      console.warn(\n        `[Fjall] Warning: 'cluster' is ignored for ${props.type} compute. ` +\n          \"Cluster configuration only applies to ECS compute.\"\n      );\n    }\n  }\n\n  // Lambda-specific options on non-Lambda compute\n  if (props.type !== \"lambda\") {\n    if (\"functionUrl\" in propsAny && propsAny.functionUrl !== undefined) {\n      console.warn(\n        `[Fjall] Warning: 'functionUrl' is ignored for ${props.type} compute. ` +\n          \"Function URL configuration only applies to Lambda compute.\"\n      );\n    }\n    if (\"handler\" in propsAny && propsAny.handler !== undefined) {\n      console.warn(\n        `[Fjall] Warning: 'handler' is ignored for ${props.type} compute. ` +\n          \"Handler configuration only applies to Lambda compute.\"\n      );\n    }\n    if (\"runtime\" in propsAny && propsAny.runtime !== undefined) {\n      console.warn(\n        `[Fjall] Warning: 'runtime' is ignored for ${props.type} compute. ` +\n          \"Runtime configuration only applies to Lambda compute.\"\n      );\n    }\n  }\n\n  // EC2-specific options on non-EC2 compute\n  if (props.type !== \"ec2\") {\n    if (\"ssh\" in propsAny && propsAny.ssh !== undefined) {\n      console.warn(\n        `[Fjall] Warning: 'ssh' is ignored for ${props.type} compute. ` +\n          \"SSH configuration only applies to EC2 compute.\"\n      );\n    }\n    if (\"userData\" in propsAny && propsAny.userData !== undefined) {\n      console.warn(\n        `[Fjall] Warning: 'userData' is ignored for ${props.type} compute. ` +\n          \"User data only applies to EC2 compute.\"\n      );\n    }\n    if (\"machineImage\" in propsAny && propsAny.machineImage !== undefined) {\n      console.warn(\n        `[Fjall] Warning: 'machineImage' is ignored for ${props.type} compute. ` +\n          \"Machine image only applies to EC2 compute.\"\n      );\n    }\n  }\n\n  // ECS-specific validation\n  if (props.type === \"ecs\") {\n    validateEcsProps(props as EcsComputeProps);\n  }\n}\n\n/**\n * Validates ECS-specific props.\n * Extracted for clarity and detail parity with database/network patterns.\n */\nfunction validateEcsProps(props: EcsComputeProps): void {\n  // EC2 config validation\n  if (props.ec2Config && props.capacityProvider !== \"EC2\") {\n    console.warn(\n      \"[Fjall] Warning: 'ec2Config' is ignored when capacityProvider is not 'EC2'. \" +\n        \"Set capacityProvider to 'EC2' to use EC2 capacity configuration.\"\n    );\n  }\n\n  // Validate services array exists and is not empty\n  if (!props.services || props.services.length === 0) {\n    throw new Error(\n      \"At least one service must be specified in 'services' array.\"\n    );\n  }\n\n  // Validate unique service names\n  const serviceNames = props.services.map((s) => s.name);\n  const duplicateNames = serviceNames.filter(\n    (name, index) => serviceNames.indexOf(name) !== index\n  );\n  if (duplicateNames.length > 0) {\n    throw new Error(\n      `Duplicate service names: ${[...new Set(duplicateNames)].join(\", \")}`\n    );\n  }\n\n  // Validate service name format\n  const invalidNames = props.services.filter(\n    (s) => !/^[a-zA-Z][a-zA-Z0-9-]*$/.test(s.name)\n  );\n  if (invalidNames.length > 0) {\n    throw new Error(\n      `Invalid service names: ${invalidNames.map((s) => s.name).join(\", \")}. ` +\n        \"Service names must start with a letter and contain only letters, numbers, and hyphens.\"\n    );\n  }\n\n  // Validate routing when multiple services have ports\n  const servicesWithPorts = props.services.filter((s) =>\n    s.containers?.some((c) => c.port)\n  );\n\n  if (servicesWithPorts.length > 1) {\n    const missingRouting = servicesWithPorts.filter(\n      (s) => !s.routing?.path && !s.routing?.host\n    );\n    if (missingRouting.length > 0) {\n      throw new Error(\n        `Services with ports require routing config when cluster has multiple services: ` +\n          `${missingRouting.map((s) => s.name).join(\", \")}. ` +\n          \"Add routing: { path: '/...' } or routing: { host: '...' } to each service.\"\n      );\n    }\n  }\n\n  // Validate each service's containers\n  for (const service of props.services) {\n    if (service.containers && service.containers.length > 0) {\n      // Check for duplicate container names within service (only named containers)\n      const containerNames = service.containers\n        .filter((c) => c.name)\n        .map((c) => c.name);\n      const duplicateContainerNames = containerNames.filter(\n        (name, index) => containerNames.indexOf(name) !== index\n      );\n      if (duplicateContainerNames.length > 0) {\n        throw new Error(\n          `Service '${service.name}': Duplicate container names: ` +\n            `${[...new Set(duplicateContainerNames)].join(\", \")}`\n        );\n      }\n    }\n  }\n}\n\n/**\n * Factory for creating compute resources.\n *\n * @example\n * // Single service cluster\n * app.addCompute(ComputeFactory.build(\"WebApp\", {\n *   type: \"ecs\",\n *   cluster: { domain: \"app.example.com\" },\n *   services: [{ name: \"web\", containers: [{ port: 3000 }] }]\n * }));\n *\n * @example\n * // Multi-service cluster with routing\n * app.addCompute(ComputeFactory.build(\"ApiCluster\", {\n *   type: \"ecs\",\n *   cluster: { domain: \"api.example.com\" },\n *   services: [\n *     { name: \"users\", containers: [{ port: 3000 }], routing: { path: \"/users/*\" } },\n *     { name: \"orders\", containers: [{ port: 3001 }], routing: { path: \"/orders/*\" } }\n *   ]\n * }));\n *\n * @example\n * // Worker cluster (no ALB)\n * app.addCompute(ComputeFactory.build(\"Workers\", {\n *   type: \"ecs\",\n *   cluster: { loadBalancer: false },\n *   services: [\n *     { name: \"processor\", containers: [{ command: [\"node\", \"worker.js\"] }] }\n *   ]\n * }));\n */\nexport class ComputeFactory {\n  static build(id: string, props: IComputeProps) {\n    return (app: App, scope: Construct): Compute => {\n      validateComputeProps(props);\n\n      const computeProps: IComputeProps = {\n        ...{\n          vpc: app.getVpc(),\n          ecrRepository: app.getDefaultContainerRegistry()\n        },\n        ...props\n      };\n\n      return new Compute(scope, id, computeProps);\n    };\n  }\n}\n\nexport class Compute extends Construct implements IConnectable {\n  public id: string;\n  public scope: Construct;\n  public vpc: IVpc;\n\n  public connections: Connections;\n\n  private compute: EcsCluster | Ec2Instance | LambdaFunction;\n\n  constructor(scope: Construct, id: string, props: IComputeProps) {\n    super(scope, id);\n    this.id = id;\n    this.scope = scope;\n\n    this.addCompute(props);\n  }\n\n  addCompute(props: IComputeProps) {\n    switch (props.type) {\n      case \"ecs\":\n        this.addEcsCompute(props);\n        break;\n      case \"ec2\":\n        this.addEc2Compute(props);\n        break;\n      case \"lambda\":\n        this.addLambdaCompute(props);\n        break;\n      default:\n        // Exhaustiveness check - TypeScript will error if a case is missing\n        const _exhaustive: never = props;\n        throw new Error(\n          `Unsupported compute type: ${(_exhaustive as IComputeProps).type}`\n        );\n    }\n  }\n\n  private addEc2Compute(props: Ec2ComputeProps) {\n    const enableSSH = props.ssh !== undefined && props.ssh !== false;\n\n    const ec2Props = {\n      serviceName: `${this.id}Service`,\n      instanceType: props.instanceType || \"t3.micro\",\n      enableSSH,\n      userData: props.userData,\n      machineImage: props.machineImage,\n      minCapacity: props.minCapacity || 1,\n      maxCapacity: props.maxCapacity || 1,\n      vpc: props.vpc\n    };\n\n    this.compute = new Ec2Instance(this.scope, `${this.id}Ec2`, ec2Props);\n    this.connections = this.compute.connections;\n  }\n\n  private addEcsCompute(props: EcsComputeProps) {\n    const capacityProvider: EcsCapacityProviderType =\n      props.capacityProvider || \"FARGATE\";\n\n    // Transform EcsServiceConfig[] to EcsServiceProps[] for EcsCluster\n    const services: EcsClusterProps[\"services\"] = props.services.map(\n      (service) => {\n        // Build container configurations for this service\n        let containers: EcsClusterProps[\"services\"][number][\"containers\"];\n\n        if (service.containers && service.containers.length > 0) {\n          // Map containers, auto-generating names if not provided\n          containers = service.containers.map((c, index) => ({\n            name: c.name || `${service.name}Container${index > 0 ? index : \"\"}`,\n            image: c.image,\n            port: c.port,\n            environment: c.environment,\n            secretsImport: c.secretsImport,\n            command: c.command,\n            entryPoint: c.entryPoint,\n            essential: c.essential,\n            healthCheck: c.healthCheck\n          }));\n        } else {\n          // Default container (no port = worker)\n          containers = [\n            {\n              name: `${service.name}Container`\n            }\n          ];\n        }\n\n        // Determine scaling config\n        let scalingType: ScalingType | undefined;\n        let minCapacity: number | undefined;\n        let maxCapacity: number | undefined;\n\n        if (service.scaling !== false && service.scaling !== undefined) {\n          scalingType = service.scaling.scalingType ?? ScalingType.CPU;\n          minCapacity = service.scaling.minCapacity;\n          maxCapacity = service.scaling.maxCapacity;\n        } else if (service.scaling === undefined) {\n          // Default: enable scaling with CPU\n          scalingType = ScalingType.CPU;\n        }\n\n        return {\n          name: service.name,\n          image: service.image,\n          containers,\n          cpu: service.cpu,\n          memoryLimitMiB: service.memoryLimitMiB,\n          desiredCount: service.desiredCount,\n          scalingType,\n          minCapacity,\n          maxCapacity,\n          routing: service.routing,\n          taskRoleInlinePolicies: service.taskRoleInlinePolicies,\n          taskRoleManagedPolicies: service.taskRoleManagedPolicies,\n          connections: service.connections\n        };\n      }\n    );\n\n    // Build cluster config\n    const cluster: EcsClusterProps[\"cluster\"] = props.cluster\n      ? {\n          domain: props.cluster.domain,\n          loadBalancer: props.cluster.loadBalancer,\n          directAccess: props.cluster.directAccess\n        }\n      : undefined;\n\n    const ecsProps: EcsClusterProps = {\n      clusterName: `${this.id}Cluster`,\n      vpc: props.vpc,\n      ecrRepository: props.ecrRepository || \"amazon/amazon-ecs-sample\",\n      capacityProvider,\n      ec2Config: capacityProvider === \"EC2\" ? props.ec2Config : undefined,\n      cluster,\n      services\n    };\n\n    this.compute = new EcsCluster(this.scope, `${this.id}Ecs`, ecsProps);\n    this.connections = this.compute.connections;\n  }\n\n  private addLambdaCompute(props: LambdaComputeProps) {\n    let code: Code;\n    let handler: string;\n    let runtime: Runtime;\n\n    if (props.deployment === \"container\") {\n      // Container-based Lambda using ECR\n      if (props.ecrRepository instanceof Repository) {\n        code = Code.fromEcrImage(props.ecrRepository, {\n          tagOrDigest: \"latest\"\n        });\n      } else {\n        throw new Error(\n          \"ecrRepository must be a Repository instance for Lambda compute type\"\n        );\n      }\n\n      // Container Lambda requires these special values\n      handler = Handler.FROM_IMAGE;\n      runtime = Runtime.FROM_IMAGE;\n    } else {\n      // Code-based Lambda - props.deployment === \"code\"\n      code = props.code;\n      handler = props.handler || \"index.handler\";\n      runtime = props.runtime || Runtime.NODEJS_18_X;\n    }\n\n    // Convert presence-based functionUrl config to legacy boolean format\n    const functionUrlConfig = props.functionUrl;\n    const enableFunctionUrl =\n      functionUrlConfig !== undefined && functionUrlConfig !== false;\n    const functionUrlAuthType =\n      enableFunctionUrl && typeof functionUrlConfig === \"object\"\n        ? functionUrlConfig.authType\n        : undefined;\n    const functionUrlCors =\n      enableFunctionUrl && typeof functionUrlConfig === \"object\"\n        ? functionUrlConfig.cors\n        : undefined;\n\n    const lambdaProps = {\n      code: code,\n      handler,\n      runtime,\n      timeout: props.timeout,\n      memorySize: props.memorySize,\n      lambdaDescription: props.description,\n      roleDescription: props.roleDescription,\n      inlinePolicy: props.inlinePolicy || [],\n      enableFunctionUrl,\n      functionUrlAuthType,\n      functionUrlCors,\n      environment: props.environment\n    };\n\n    this.compute = new LambdaFunction(\n      this.scope,\n      `${this.id}Lambda`,\n      lambdaProps\n    );\n\n    // Lambda functions don't use security groups unless VPC-enabled\n    // Create empty connections object for interface compatibility\n    this.connections = new Connections();\n  }\n}\n"]}

package/dist/lib/patterns/aws/database.d.ts

@@ -110,6 +110,7 @@ type BaseDatabaseProps = {
     vpc?: IVpc;
     databaseName: string;
     instanceType?: string;
+    deletionProtection?: boolean;
 };
 export interface AuroraDatabaseProps extends BaseDatabaseProps {
     type: "Aurora";