@fjall/components-infrastructure 0.88.4 → 0.89.2

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

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EcsCompute = exports.ECS_CAPACITY_PROVIDER_CONFIG = exports.ScalingType = void 0;
+exports.getEcsCapacityProviderConfig = getEcsCapacityProviderConfig;
+exports.validateEcsProps = validateEcsProps;
+exports.buildContainerConfigs = buildContainerConfigs;
+exports.resolveScalingConfig = resolveScalingConfig;
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const constructs_1 = require("constructs");
+const ecs_1 = require("../../resources/aws/compute/ecs");
+Object.defineProperty(exports, "ScalingType", { enumerable: true, get: function () { return ecs_1.ScalingType; } });
+const validationLogger_js_1 = require("../../utils/validationLogger.js");
+const compute_js_1 = require("./compute.js");
+exports.ECS_CAPACITY_PROVIDER_CONFIG = {
+    FARGATE: {
+        usesSpot: false,
+        usesEc2Instances: false
+    },
+    FARGATE_SPOT: {
+        usesSpot: true,
+        usesEc2Instances: false
+    },
+    EC2: {
+        usesSpot: false,
+        usesEc2Instances: true
+    }
+};
+function getEcsCapacityProviderConfig(provider) {
+    return exports.ECS_CAPACITY_PROVIDER_CONFIG[provider];
+}
+/**
+ * Validates ECS-specific props.
+ * Extracted for clarity and detail parity with database/network patterns.
+ */
+function validateEcsProps(props) {
+    // 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) => {
+            const rules = Array.isArray(s.routing)
+                ? s.routing
+                : s.routing
+                    ? [s.routing]
+                    : [];
+            return !rules.some((r) => r.path || r.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(", ")}`);
+            }
+        }
+        if (service.capacityProvider === "EC2" && !service.ec2Config) {
+            throw new Error(`Service '${service.name}' uses EC2 capacity provider but no ec2Config is defined. ` +
+                "Provide ec2Config on the service.");
+        }
+        // Warn if service ec2Config is defined but capacityProvider is not EC2
+        if (service.ec2Config && service.capacityProvider !== "EC2") {
+            validationLogger_js_1.FjallLogger.warn(`Service '${service.name}' has ec2Config but capacityProvider is not 'EC2'. ` +
+                "The ec2Config will be ignored unless capacityProvider is set to 'EC2'.");
+        }
+    }
+}
+/**
+ * Build container configurations for an ECS service.
+ * Converts user-facing EcsContainerConfig to internal EcsClusterProps format.
+ * @internal Exported for testing only
+ */
+function buildContainerConfigs(service) {
+    if (service.containers && service.containers.length > 0) {
+        return service.containers.map((c, index) => ({
+            name: c.name || `${service.name}Container${index > 0 ? index : ""}`,
+            image: c.image,
+            port: c.port,
+            environment: c.environment,
+            secrets: c.secrets,
+            secretsImport: c.secretsImport,
+            command: c.command,
+            entryPoint: c.entryPoint,
+            essential: c.essential,
+            healthCheck: c.healthCheck
+        }));
+    }
+    // Default container (no port = worker)
+    return [{ name: `${service.name}Container` }];
+}
+/**
+ * Resolve scaling configuration from service props.
+ * Handles the three cases: explicit config, disabled (false), or default (undefined).
+ * @internal Exported for testing only
+ */
+function resolveScalingConfig(scaling) {
+    if (scaling === false) {
+        return {
+            scalingType: undefined,
+            minCapacity: undefined,
+            maxCapacity: undefined
+        };
+    }
+    if (scaling === undefined) {
+        return {
+            scalingType: ecs_1.ScalingType.CPU,
+            minCapacity: undefined,
+            maxCapacity: undefined
+        };
+    }
+    return {
+        scalingType: scaling.scalingType ?? ecs_1.ScalingType.CPU,
+        minCapacity: scaling.minCapacity,
+        maxCapacity: scaling.maxCapacity
+    };
+}
+/**
+ * ECS compute wrapper implementing IEcsCompute.
+ * Provides type-safe access to ECS-specific resources.
+ */
+class EcsCompute extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.computeType = "ecs";
+        // Transform EcsServiceConfig[] to EcsServiceProps[] for EcsCluster
+        const services = props.services.map((service) => {
+            const containers = buildContainerConfigs(service);
+            const { scalingType, minCapacity, maxCapacity } = resolveScalingConfig(service.scaling);
+            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,
+                capacityProvider: service.capacityProvider,
+                ec2Config: service.ec2Config,
+                ssmSecretsPath: service.ssmSecretsPath,
+                dockerTarget: service.dockerTarget
+            };
+        });
+        // Build cluster config
+        const cluster = props.cluster
+            ? {
+                domain: props.cluster.domain,
+                loadBalancer: props.cluster.loadBalancer,
+                directAccess: props.cluster.directAccess,
+                domainConfig: props.cluster.domainConfig
+            }
+            : undefined;
+        const ecsProps = {
+            clusterName: id,
+            appName: props.appName,
+            vpc: props.vpc,
+            ecrRepository: props.ecrRepository || compute_js_1.COMPUTE_DEFAULTS.ECS.FALLBACK_IMAGE,
+            cluster,
+            services
+        };
+        this.ecsCluster = new ecs_1.default(scope, `${id}Ecs`, ecsProps);
+        this.connections = this.ecsCluster.connections;
+    }
+    /** Get the ECS cluster. */
+    getCluster() {
+        return this.ecsCluster.getCluster();
+    }
+    /** Get the Application Load Balancer if one was created. */
+    getLoadBalancer() {
+        return this.ecsCluster.getLoadBalancer();
+    }
+    /** Get a specific service by name. */
+    getService(name) {
+        return this.ecsCluster.getService(name);
+    }
+    /** Get all services in the cluster. */
+    getAllServices() {
+        const servicesMap = this.ecsCluster.getServices();
+        return Array.from(servicesMap.values());
+    }
+    /** Get the security group for the cluster. */
+    getSecurityGroup() {
+        // Return the first security group from connections
+        const securityGroups = this.connections.securityGroups;
+        if (securityGroups.length === 0) {
+            throw new Error("No security groups found for ECS cluster");
+        }
+        return securityGroups[0];
+    }
+    /**
+     * Get the ALB listener if this is an ECS compute with ALB.
+     */
+    getListener() {
+        return this.ecsCluster.getListener();
+    }
+    /**
+     * Get the underlying ECS cluster construct.
+     */
+    getEcsCluster() {
+        return this.ecsCluster;
+    }
+    /**
+     * Grants ecs:ExecuteCommand permission for ECS services.
+     * Uses wildcard resource because ecs:ExecuteCommand targets task ARNs
+     * which are not known until runtime (tasks are ephemeral).
+     */
+    grantExecuteCommand(grantee) {
+        return aws_iam_1.Grant.addToPrincipal({
+            grantee,
+            actions: ["ecs:ExecuteCommand"],
+            resourceArns: ["*"]
+        });
+    }
+}
+exports.EcsCompute = EcsCompute;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"computeEcs.js","sourceRoot":"","sources":["../../../../lib/patterns/aws/computeEcs.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  type RepositoryImage,\n  type ICluster,\n  type IBaseService\n} from \"aws-cdk-lib/aws-ecs\";\nimport { type Repository } from \"aws-cdk-lib/aws-ecr\";\nimport {\n  type Connections,\n  type IVpc,\n  type ISecurityGroup\n} from \"aws-cdk-lib/aws-ec2\";\nimport {\n  type PolicyDocument,\n  type IManagedPolicy,\n  type IGrantable,\n  Grant\n} from \"aws-cdk-lib/aws-iam\";\nimport {\n  type IApplicationLoadBalancer,\n  type ApplicationListener\n} from \"aws-cdk-lib/aws-elasticloadbalancingv2\";\n\nimport { Construct } from \"constructs\";\n\nimport { type IEcsCompute } from \"./interfaces/compute.js\";\nimport { type ConnectionSpec } from \"./interfaces/connector.js\";\n\nimport EcsCluster, {\n  type EcsClusterProps,\n  ScalingType,\n  type DomainConfig,\n  type EcsCapacityProvider,\n  type Ec2CapacityConfig\n} from \"../../resources/aws/compute/ecs\";\nimport { type SecretImport } from \"../../resources/aws/secrets\";\nimport { FjallLogger } from \"../../utils/validationLogger.js\";\n\nimport { COMPUTE_DEFAULTS } from \"./compute.js\";\n\n// Re-export from ecs.ts to maintain single source of truth\nexport { ScalingType };\nexport type { EcsCapacityProvider, Ec2CapacityConfig };\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 getEcsCapacityProviderConfig(\n  provider: EcsCapacityProvider\n): EcsCapacityProviderConfig {\n  return ECS_CAPACITY_PROVIDER_CONFIG[provider];\n}\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  /**\n   * Secrets from AWS SSM Parameter Store.\n   * Array of secret names that will be fetched from the service's SSM namespace.\n   * The namespace path is auto-determined from app/cluster/service names.\n   *\n   * @example\n   * // Secrets at /myapp/api-cluster/users/API_KEY and /myapp/api-cluster/users/DB_PASSWORD\n   * secrets: [\"API_KEY\", \"DB_PASSWORD\"]\n   */\n  secrets?: string[];\n  /** Secrets imported from other CDK resources (AWS Secrets Manager) */\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 * 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   * Advanced domain configuration for routing policies (latency, weighted, geo).\n   * Only used when domain is specified.\n   * Allows for multi-region deployments with advanced DNS routing.\n   */\n  domainConfig?: DomainConfig;\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 multiple routing rules (same target group)\n * { name: \"web\", containers: [{ port: 3000 }], routing: [\n *   { path: \"/api/v2/*\", priority: 50 },\n *   { path: \"/*\", priority: 200 },\n * ]}\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   * Can be a single rule or an array of rules pointing to the same target group.\n   *\n   * @example\n   * // Multiple routes for the same service\n   * routing: [\n   *   { path: \"/api/v2/*\", priority: 50 },\n   *   { path: \"/*\", priority: 200 },\n   * ]\n   */\n  routing?: EcsRoutingConfig | 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   * Docker build target stage for multi-stage Dockerfiles.\n   * When specified, the CLI builds with `--target <dockerTarget>`.\n   * The image tag suffix is also updated: `<service>-<target>-latest`.\n   *\n   * @example\n   * // Dockerfile: FROM node AS base ... FROM base AS api ... FROM base AS worker\n   * { name: \"api\", dockerTarget: \"api\" }   // builds: myapp-api-api-latest\n   * { name: \"worker\", dockerTarget: \"worker\" }  // builds: myapp-worker-worker-latest\n   */\n  dockerTarget?: 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, S3 buckets, SQS queues).\n   * Creates security group rules for IConnectable resources and IAM grants for IAM resources.\n   * Follows least-privilege - only this service gets access, not all services in the cluster.\n   *\n   * Supports:\n   * - IConnectable: Security group resources (RDS, ECS, etc.)\n   * - IStorageConnector: S3 buckets (IAM grants)\n   * - IDynamoDBConnector: DynamoDB tables (IAM grants)\n   * - IQueueConnector: SQS queues (IAM grants)\n   * - ConnectionConfig: Explicit access level configuration\n   *\n   * @example\n   * // Simple connections (default permissions)\n   * connections: [database, bucket, cache, queue]\n   *\n   * @example\n   * // Explicit access levels\n   * connections: [\n   *   database,                              // Security group (RDS)\n   *   { resource: cache, access: \"read\" },   // Read-only DynamoDB\n   *   { resource: bucket, access: \"write\" }, // Write-only S3\n   *   { resource: queue, access: \"consume\" } // Consume-only SQS\n   * ]\n   */\n  connections?: ConnectionSpec[];\n\n  /**\n   * Capacity provider for this service. REQUIRED.\n   * Each service specifies its own capacity provider.\n   *\n   * @example\n   * // Mixed FARGATE and EC2 services in same cluster\n   * {\n   *   services: [\n   *     { name: \"api\", capacityProvider: \"FARGATE\" },\n   *     { name: \"worker\", capacityProvider: \"EC2\", ec2Config: { instanceType: \"t4g.micro\" } }\n   *   ]\n   * }\n   */\n  capacityProvider: EcsCapacityProvider;\n\n  /**\n   * EC2 capacity configuration for this service.\n   * Only used when service capacityProvider is \"EC2\".\n   * Services with matching ec2Config share an ASG for efficiency.\n   */\n  ec2Config?: Ec2CapacityConfig;\n\n  /**\n   * SSM Parameter Store path for secrets.\n   * If not specified, secrets are fetched from /<app>/<cluster>/<service>.\n   * Use this to override the default convention.\n   *\n   * @example\n   * // Override default path\n   * ssmSecretsPath: \"/custom/path/to/secrets\"\n   */\n  ssmSecretsPath?: string;\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 {\n  type: \"ecs\";\n  vpc?: IVpc;\n\n  /**\n   * Application name for SSM secrets namespace.\n   * When containers use secrets, the path is derived as: /<appName>/<clusterName>/<serviceName>\n   * Auto-derived from App.getName() if not specified.\n   */\n  appName?: string;\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   * Each service MUST specify its own capacityProvider.\n   * All services share the cluster's ALB (unless disabled).\n   */\n  services: EcsServiceConfig[];\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\n/**\n * Validates ECS-specific props.\n * Extracted for clarity and detail parity with database/network patterns.\n */\nexport function validateEcsProps(props: EcsComputeProps): void {\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((s) => {\n      const rules = Array.isArray(s.routing)\n        ? s.routing\n        : s.routing\n          ? [s.routing]\n          : [];\n      return !rules.some((r) => r.path || r.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    if (service.capacityProvider === \"EC2\" && !service.ec2Config) {\n      throw new Error(\n        `Service '${service.name}' uses EC2 capacity provider but no ec2Config is defined. ` +\n          \"Provide ec2Config on the service.\"\n      );\n    }\n\n    // Warn if service ec2Config is defined but capacityProvider is not EC2\n    if (service.ec2Config && service.capacityProvider !== \"EC2\") {\n      FjallLogger.warn(\n        `Service '${service.name}' has ec2Config but capacityProvider is not 'EC2'. ` +\n          \"The ec2Config will be ignored unless capacityProvider is set to 'EC2'.\"\n      );\n    }\n  }\n}\n\n/**\n * Build container configurations for an ECS service.\n * Converts user-facing EcsContainerConfig to internal EcsClusterProps format.\n * @internal Exported for testing only\n */\nexport function buildContainerConfigs(\n  service: EcsServiceConfig\n): EcsClusterProps[\"services\"][number][\"containers\"] {\n  if (service.containers && service.containers.length > 0) {\n    return 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      secrets: c.secrets,\n      secretsImport: c.secretsImport,\n      command: c.command,\n      entryPoint: c.entryPoint,\n      essential: c.essential,\n      healthCheck: c.healthCheck\n    }));\n  }\n  // Default container (no port = worker)\n  return [{ name: `${service.name}Container` }];\n}\n\n/**\n * Resolved scaling configuration for an ECS service.\n * @internal Exported for testing only\n */\nexport interface ResolvedScalingConfig {\n  scalingType: ScalingType | undefined;\n  minCapacity: number | undefined;\n  maxCapacity: number | undefined;\n}\n\n/**\n * Resolve scaling configuration from service props.\n * Handles the three cases: explicit config, disabled (false), or default (undefined).\n * @internal Exported for testing only\n */\nexport function resolveScalingConfig(\n  scaling: EcsScalingConfig | false | undefined\n): ResolvedScalingConfig {\n  if (scaling === false) {\n    return {\n      scalingType: undefined,\n      minCapacity: undefined,\n      maxCapacity: undefined\n    };\n  }\n  if (scaling === undefined) {\n    return {\n      scalingType: ScalingType.CPU,\n      minCapacity: undefined,\n      maxCapacity: undefined\n    };\n  }\n  return {\n    scalingType: scaling.scalingType ?? ScalingType.CPU,\n    minCapacity: scaling.minCapacity,\n    maxCapacity: scaling.maxCapacity\n  };\n}\n\n/**\n * ECS compute wrapper implementing IEcsCompute.\n * Provides type-safe access to ECS-specific resources.\n */\nexport class EcsCompute extends Construct implements IEcsCompute {\n  public readonly computeType = \"ecs\" as const;\n  public readonly connections: Connections;\n\n  private readonly ecsCluster: EcsCluster;\n\n  constructor(scope: Construct, id: string, props: EcsComputeProps) {\n    super(scope, id);\n\n    // Transform EcsServiceConfig[] to EcsServiceProps[] for EcsCluster\n    const services: EcsClusterProps[\"services\"] = props.services.map(\n      (service) => {\n        const containers = buildContainerConfigs(service);\n        const { scalingType, minCapacity, maxCapacity } = resolveScalingConfig(\n          service.scaling\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          capacityProvider: service.capacityProvider,\n          ec2Config: service.ec2Config,\n          ssmSecretsPath: service.ssmSecretsPath,\n          dockerTarget: service.dockerTarget\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          domainConfig: props.cluster.domainConfig\n        }\n      : undefined;\n\n    const ecsProps: EcsClusterProps = {\n      clusterName: id,\n      appName: props.appName,\n      vpc: props.vpc,\n      ecrRepository: props.ecrRepository || COMPUTE_DEFAULTS.ECS.FALLBACK_IMAGE,\n      cluster,\n      services\n    };\n\n    this.ecsCluster = new EcsCluster(scope, `${id}Ecs`, ecsProps);\n    this.connections = this.ecsCluster.connections;\n  }\n\n  /** Get the ECS cluster. */\n  getCluster(): ICluster {\n    return this.ecsCluster.getCluster();\n  }\n\n  /** Get the Application Load Balancer if one was created. */\n  getLoadBalancer(): IApplicationLoadBalancer | undefined {\n    return this.ecsCluster.getLoadBalancer();\n  }\n\n  /** Get a specific service by name. */\n  getService(name: string): IBaseService | undefined {\n    return this.ecsCluster.getService(name);\n  }\n\n  /** Get all services in the cluster. */\n  getAllServices(): IBaseService[] {\n    const servicesMap = this.ecsCluster.getServices();\n    return Array.from(servicesMap.values());\n  }\n\n  /** Get the security group for the cluster. */\n  getSecurityGroup(): ISecurityGroup {\n    // Return the first security group from connections\n    const securityGroups = this.connections.securityGroups;\n    if (securityGroups.length === 0) {\n      throw new Error(\"No security groups found for ECS cluster\");\n    }\n    return securityGroups[0];\n  }\n\n  /**\n   * Get the ALB listener if this is an ECS compute with ALB.\n   */\n  getListener(): ApplicationListener | undefined {\n    return this.ecsCluster.getListener();\n  }\n\n  /**\n   * Get the underlying ECS cluster construct.\n   */\n  getEcsCluster(): EcsCluster {\n    return this.ecsCluster;\n  }\n\n  /**\n   * Grants ecs:ExecuteCommand permission for ECS services.\n   * Uses wildcard resource because ecs:ExecuteCommand targets task ARNs\n   * which are not known until runtime (tasks are ephemeral).\n   */\n  grantExecuteCommand(grantee: IGrantable): Grant {\n    return Grant.addToPrincipal({\n      grantee,\n      actions: [\"ecs:ExecuteCommand\"],\n      resourceArns: [\"*\"]\n    });\n  }\n}\n"]}

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

@@ -0,0 +1,220 @@
+import { Code, Runtime, type Architecture, type FunctionUrlAuthType, type FunctionUrlCorsOptions, type IFunction, type InvokeMode } from "aws-cdk-lib/aws-lambda";
+import { type PolicyStatement, type IGrantable, type Grant } from "aws-cdk-lib/aws-iam";
+import { Connections, type IVpc, type ISecurityGroup } from "aws-cdk-lib/aws-ec2";
+import { Repository } from "aws-cdk-lib/aws-ecr";
+import { type RepositoryImage } from "aws-cdk-lib/aws-ecs";
+import { Construct } from "constructs";
+import { type ILambdaCompute } from "./interfaces/compute.js";
+import { type ConnectionSpec } from "./interfaces/connector.js";
+import { LambdaFunction } from "../../resources/aws/compute/lambda";
+import { type SecretImport } from "../../resources/aws/secrets";
+export { Architecture, HttpMethod, InvokeMode, type FunctionUrlCorsOptions } from "aws-cdk-lib/aws-lambda";
+/**
+ * Lambda function URL configuration.
+ * - Omit: disabled (default)
+ * - `{}`: enabled with IAM auth
+ * - `{ authType: "NONE", cors: {...} }`: public with CORS
+ * - `false`: explicitly disabled
+ */
+export interface FunctionUrlConfig {
+    /** Authentication type. Default: AWS_IAM */
+    authType?: FunctionUrlAuthType;
+    /** CORS configuration */
+    cors?: FunctionUrlCorsOptions;
+    /** Invoke mode. Use RESPONSE_STREAM for Lambda streaming. Default: BUFFERED */
+    invokeMode?: InvokeMode;
+}
+/**
+ * Base Lambda configuration shared by both container and code deployments.
+ */
+interface BaseLambdaProps {
+    type: "lambda";
+    vpc?: IVpc;
+    /** Timeout in seconds. Default: 3 */
+    timeout?: number;
+    /** Memory size in MB. Default: 128 */
+    memorySize?: number;
+    ephemeralStorageSize?: number;
+    /** CPU architecture. Default: x86_64. Use Architecture.ARM_64 for Graviton2. */
+    architecture?: Architecture;
+    /** Lambda function description */
+    description?: string;
+    /** IAM role description */
+    roleDescription?: string;
+    /** Inline IAM policy statements */
+    inlinePolicy?: PolicyStatement[];
+    /**
+     * Function URL configuration.
+     * - Omit: disabled (default)
+     * - `{}`: enabled with IAM auth
+     * - `{ authType: "NONE" }`: public access
+     * - `false`: explicitly disabled
+     */
+    functionUrl?: FunctionUrlConfig | false;
+    /** Environment variables */
+    environment?: Record<string, string>;
+    /**
+     * Secrets from AWS SSM Parameter Store.
+     * Array of secret names that will be fetched from the Lambda's SSM namespace.
+     * The namespace path is auto-determined as: /<appName>/lambda/<functionName>
+     *
+     * @example
+     * secrets: ["API_KEY", "STRIPE_SECRET"]
+     */
+    secrets?: string[];
+    /**
+     * SSM Parameter Store path for secrets.
+     * If secrets are defined, this path is used as the base path.
+     * If not specified, uses: /<appName>/lambda/<functionName>
+     *
+     * @example
+     * ssmSecretsPath: "/myapp/custom/path"
+     */
+    ssmSecretsPath?: string;
+    /**
+     * Secrets imported from other CDK resources (AWS Secrets Manager).
+     * Used for CDK-managed secrets like database credentials.
+     *
+     * @example
+     * secretsImport: {
+     *   DATABASE_USERNAME: database.getCredentials().getImport("username"),
+     *   DATABASE_PASSWORD: database.getCredentials().getImport("password")
+     * }
+     */
+    secretsImport?: Record<string, SecretImport>;
+    /**
+     * Application name for SSM secrets path derivation.
+     * Auto-derived from App instance when using ComputeFactory.
+     * Only specify for advanced use cases.
+     */
+    appName?: string;
+    /**
+     * Resources this Lambda needs to connect to (e.g., databases, S3 buckets, SQS queues).
+     * Creates security group rules for IConnectable resources and IAM grants for IAM resources.
+     *
+     * Supports:
+     * - IConnectable: Security group resources (RDS, ECS, etc.)
+     * - IStorageConnector: S3 buckets (IAM grants)
+     * - IDynamoDBConnector: DynamoDB tables (IAM grants)
+     * - IQueueConnector: SQS queues (IAM grants)
+     * - ConnectionConfig: Explicit access level configuration
+     *
+     * @example
+     * connections: [
+     *   database,
+     *   { resource: queue, access: "send" }
+     * ]
+     */
+    connections?: ConnectionSpec[];
+    /**
+     * EventBridge schedule expression for scheduled Lambda invocations.
+     * Uses cron or rate syntax: "rate(1 hour)" or "cron(0 12 * * ? *)".
+     */
+    scheduleExpression?: string;
+}
+/**
+ * Container-based Lambda using ECR image.
+ *
+ * Uses Docker image from ECR repository. Handler and runtime are
+ * automatically set to FROM_IMAGE.
+ *
+ * @example
+ * app.addCompute(ComputeFactory.build("ImageLambda", {
+ *   type: "lambda",
+ *   deployment: "container",
+ *   ecrRepository: app.getDefaultContainerRegistry()
+ * }));
+ */
+export interface ContainerLambdaProps extends BaseLambdaProps {
+    /** Container-based deployment using ECR image */
+    deployment: "container";
+    /** ECR repository containing the Lambda container image */
+    ecrRepository: Repository | RepositoryImage;
+}
+/**
+ * Code-based Lambda using inline code or S3.
+ *
+ * Uses traditional Lambda deployment with code, handler, and runtime.
+ *
+ * @example
+ * app.addCompute(ComputeFactory.build("CodeLambda", {
+ *   type: "lambda",
+ *   deployment: "code",
+ *   code: Code.fromAsset("./lambda"),
+ *   handler: "index.handler",
+ *   runtime: Runtime.NODEJS_20_X
+ * }));
+ */
+export interface CodeLambdaProps extends BaseLambdaProps {
+    /** Code-based deployment */
+    deployment: "code";
+    /** Lambda code (from asset, S3, or inline) */
+    code: Code;
+    /** Handler function. Default: "index.handler" */
+    handler?: string;
+    /** Lambda runtime. Default: NODEJS_22_X */
+    runtime?: Runtime;
+}
+/**
+ * Lambda compute configuration.
+ *
+ * Discriminated union ensuring type-safe Lambda configuration:
+ * - `deployment: "container"` requires `ecrRepository`
+ * - `deployment: "code"` requires `code` and allows `handler`/`runtime`
+ *
+ * @example
+ * // Container-based Lambda
+ * { type: "lambda", deployment: "container", ecrRepository: ecr }
+ *
+ * @example
+ * // Code-based Lambda
+ * { type: "lambda", deployment: "code", code: Code.fromAsset("./lambda") }
+ */
+export type LambdaComputeProps = ContainerLambdaProps | CodeLambdaProps;
+/**
+ * Resolved Lambda deployment configuration.
+ */
+export interface ResolvedLambdaDeployment {
+    code: Code;
+    handler: string;
+    runtime: Runtime;
+}
+/**
+ * Resolve Lambda deployment configuration from props.
+ * Handles container vs code deployment types.
+ */
+export declare function resolveLambdaDeployment(props: LambdaComputeProps): ResolvedLambdaDeployment;
+/**
+ * Lambda compute wrapper implementing ILambdaCompute.
+ * Provides type-safe access to Lambda-specific resources.
+ */
+export declare class LambdaCompute extends Construct implements ILambdaCompute {
+    readonly computeType: "lambda";
+    readonly connections: Connections;
+    private readonly lambdaFunction;
+    constructor(scope: Construct, id: string, props: LambdaComputeProps);
+    /**
+     * Get a Lambda function by name.
+     * Since we only have one function, name is ignored.
+     */
+    getFunction(_name?: string): IFunction | undefined;
+    /** Get all Lambda functions. */
+    getAllFunctions(): IFunction[];
+    /**
+     * Get the function URL for a Lambda function.
+     */
+    getFunctionUrl(_name?: string): string | undefined;
+    /**
+     * Grant invoke permissions to a grantee.
+     */
+    grantInvoke(grantee: IGrantable, _functionName?: string): Grant;
+    /**
+     * Get the security group for VPC-enabled Lambda functions.
+     * Returns undefined if the Lambda is not VPC-enabled.
+     */
+    getSecurityGroup(): ISecurityGroup | undefined;
+    /**
+     * Get the underlying Lambda function construct.
+     */
+    getLambdaFunction(): LambdaFunction;
+}