@fjall/components-infrastructure 0.79.1 → 0.80.4

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

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CdnFactory = exports.Cdn = void 0;
+const cdn_1 = require("../../resources/aws/cdn");
+const storage_1 = require("./storage");
+const compute_1 = require("./compute");
+/**
+ * Validates CDN props and logs warnings for misconfigured options.
+ */
+function validateCdnProps(props) {
+    // Validate certificate region warning
+    if (props.certificate && props.domainNames && props.domainNames.length > 0) {
+        console.info("[Fjall] Note: CloudFront certificates must be in us-east-1 region. " +
+            "Ensure your certificate was created in us-east-1.");
+    }
+    // Validate domain names require certificate
+    if (props.domainNames && props.domainNames.length > 0 && !props.certificate) {
+        console.warn("[Fjall] Warning: 'domainNames' provided but no 'certificate' specified. " +
+            "Custom domain names require an ACM certificate in us-east-1.");
+    }
+    // Validate ALB origin
+    if (props.originType === "alb") {
+        const albProps = props;
+        if (albProps.loadBalancer instanceof compute_1.Compute) {
+            const lb = albProps.loadBalancer.getLoadBalancer();
+            if (!lb) {
+                throw new Error("Compute resource does not have a load balancer. " +
+                    "Ensure ECS compute has loadBalancer enabled for CDN origin.");
+            }
+        }
+    }
+    // Validate smart origin
+    if (props.originType === "auto") {
+        const smartProps = props;
+        if (smartProps.origin instanceof compute_1.Compute) {
+            const computeType = smartProps.origin.getComputeType();
+            if (computeType === "ec2") {
+                throw new Error("EC2 compute type is not supported for CDN origin. " +
+                    "Use ECS with load balancer or Lambda with function URL.");
+            }
+            if (computeType === "ecs" && !smartProps.origin.getLoadBalancer()) {
+                throw new Error("ECS compute must have a load balancer for CDN origin. " +
+                    "Enable loadBalancer in your ECS compute configuration.");
+            }
+            if (computeType === "lambda" && !smartProps.origin.getFunctionUrl()) {
+                throw new Error("Lambda compute must have a function URL for CDN origin. " +
+                    "Enable functionUrl in your Lambda compute configuration.");
+            }
+        }
+    }
+}
+/**
+ * CDN wrapper class that extends CloudFrontDistribution with Fjall patterns.
+ */
+class Cdn extends cdn_1.CloudFrontDistribution {
+    constructor(scope, id, props) {
+        const resolvedProps = Cdn.resolveProps(props);
+        super(scope, id, resolvedProps);
+    }
+    /**
+     * Resolve ICdnProps to CloudFrontDistributionProps.
+     */
+    static resolveProps(props) {
+        const defaultOrigin = Cdn.resolveDefaultOrigin(props);
+        return {
+            defaultOrigin,
+            defaultCachePolicy: props.cachePolicy,
+            behaviours: props.behaviours,
+            domainNames: props.domainNames,
+            certificate: props.certificate,
+            comment: props.comment,
+            enableLogging: props.enableLogging,
+            logBucket: props.logBucket
+        };
+    }
+    /**
+     * Resolve the default origin from ICdnProps.
+     */
+    static resolveDefaultOrigin(props) {
+        switch (props.originType) {
+            case "s3": {
+                const s3Props = props;
+                const bucket = s3Props.bucket instanceof storage_1.S3Storage
+                    ? s3Props.bucket.getBucket()
+                    : s3Props.bucket;
+                return {
+                    type: "s3",
+                    bucket,
+                    originPath: s3Props.originPath
+                };
+            }
+            case "alb": {
+                const albProps = props;
+                const loadBalancer = albProps.loadBalancer instanceof compute_1.Compute
+                    ? albProps.loadBalancer.getLoadBalancer()
+                    : albProps.loadBalancer;
+                return {
+                    type: "alb",
+                    loadBalancer,
+                    protocolPolicy: albProps.protocolPolicy
+                };
+            }
+            case "http": {
+                const httpProps = props;
+                return {
+                    type: "http",
+                    domainName: httpProps.domainName,
+                    originPath: httpProps.originPath,
+                    protocolPolicy: httpProps.protocolPolicy
+                };
+            }
+            case "auto": {
+                const smartProps = props;
+                return Cdn.detectOriginFromResource(smartProps.origin);
+            }
+        }
+    }
+    /**
+     * Auto-detect origin configuration from a Fjall resource.
+     */
+    static detectOriginFromResource(resource) {
+        // String → HTTP origin
+        if (typeof resource === "string") {
+            return {
+                type: "http",
+                domainName: resource
+            };
+        }
+        // S3Storage → S3 origin
+        if (resource instanceof storage_1.S3Storage) {
+            return {
+                type: "s3",
+                bucket: resource.getBucket()
+            };
+        }
+        // Compute → ALB or Lambda origin
+        if (resource instanceof compute_1.Compute) {
+            const computeType = resource.getComputeType();
+            if (computeType === "ecs") {
+                const loadBalancer = resource.getLoadBalancer();
+                if (loadBalancer) {
+                    return {
+                        type: "alb",
+                        loadBalancer
+                    };
+                }
+            }
+            if (computeType === "lambda") {
+                const functionUrl = resource.getFunctionUrl();
+                if (functionUrl) {
+                    // Lambda function URL is an HTTP origin
+                    const url = new URL(functionUrl);
+                    return {
+                        type: "http",
+                        domainName: url.hostname
+                    };
+                }
+            }
+        }
+        throw new Error(`Unable to detect CDN origin from resource: ${typeof resource}. ` +
+            "Provide explicit origin configuration using originType.");
+    }
+}
+exports.Cdn = Cdn;
+/**
+ * Factory for creating CDN (CloudFront) distributions.
+ *
+ * @example
+ * // S3 origin
+ * const assets = app.addStorage(StorageFactory.build("Assets", { bucketType: "private" }));
+ * app.addCdn(CdnFactory.build("AssetsCdn", {
+ *   originType: "s3",
+ *   bucket: assets
+ * }));
+ *
+ * @example
+ * // ALB origin (ECS)
+ * const api = app.addCompute(ComputeFactory.build("Api", { type: "ecs", ... }));
+ * app.addCdn(CdnFactory.build("ApiCdn", {
+ *   originType: "alb",
+ *   loadBalancer: api
+ * }));
+ *
+ * @example
+ * // Smart detection
+ * app.addCdn(CdnFactory.build("AppCdn", {
+ *   originType: "auto",
+ *   origin: assets
+ * }));
+ *
+ * @example
+ * // Custom domain
+ * app.addCdn(CdnFactory.build("AppCdn", {
+ *   originType: "s3",
+ *   bucket: assets,
+ *   domainNames: ["app.example.com"],
+ *   certificate: myCert
+ * }));
+ */
+class CdnFactory {
+    /**
+     * Build a CDN factory function.
+     *
+     * @param id - Unique identifier for the CDN
+     * @param props - CDN configuration properties
+     * @returns Factory function that creates the CDN when invoked
+     */
+    static build(id, props) {
+        return (_app, scope) => {
+            validateCdnProps(props);
+            return new Cdn(scope, id, props);
+        };
+    }
+}
+exports.CdnFactory = CdnFactory;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cdn.js","sourceRoot":"","sources":["../../../../lib/patterns/aws/cdn.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from \"constructs\";\nimport { type IBucket } from \"aws-cdk-lib/aws-s3\";\nimport { type IApplicationLoadBalancer } from \"aws-cdk-lib/aws-elasticloadbalancingv2\";\nimport { type ICertificate } from \"aws-cdk-lib/aws-certificatemanager\";\nimport { type ICachePolicy } from \"aws-cdk-lib/aws-cloudfront\";\n\nimport type App from \"../../app\";\nimport {\n  CloudFrontDistribution,\n  type CloudFrontDistributionProps,\n  type CdnOriginConfig,\n  type CdnBehaviour,\n  type CachePolicyPreset\n} from \"../../resources/aws/cdn\";\nimport { S3Storage } from \"./storage\";\nimport { Compute } from \"./compute\";\n\n/**\n * S3 origin CDN props - use with S3 bucket\n */\nexport interface S3CdnProps {\n  originType: \"s3\";\n  bucket: IBucket | S3Storage;\n  originPath?: string;\n  cachePolicy?: CachePolicyPreset | ICachePolicy;\n  behaviours?: CdnBehaviour[];\n  domainNames?: string[];\n  certificate?: ICertificate;\n  comment?: string;\n  enableLogging?: boolean;\n  logBucket?: IBucket;\n}\n\n/**\n * ALB origin CDN props - use with Application Load Balancer\n */\nexport interface AlbCdnProps {\n  originType: \"alb\";\n  loadBalancer: IApplicationLoadBalancer | Compute;\n  protocolPolicy?: \"HTTP_ONLY\" | \"HTTPS_ONLY\" | \"MATCH_VIEWER\";\n  cachePolicy?: CachePolicyPreset | ICachePolicy;\n  behaviours?: CdnBehaviour[];\n  domainNames?: string[];\n  certificate?: ICertificate;\n  comment?: string;\n  enableLogging?: boolean;\n  logBucket?: IBucket;\n}\n\n/**\n * HTTP origin CDN props - use with custom HTTP endpoint\n */\nexport interface HttpCdnProps {\n  originType: \"http\";\n  domainName: string;\n  originPath?: string;\n  protocolPolicy?: \"HTTP_ONLY\" | \"HTTPS_ONLY\" | \"MATCH_VIEWER\";\n  cachePolicy?: CachePolicyPreset | ICachePolicy;\n  behaviours?: CdnBehaviour[];\n  domainNames?: string[];\n  certificate?: ICertificate;\n  comment?: string;\n  enableLogging?: boolean;\n  logBucket?: IBucket;\n}\n\n/**\n * Smart origin CDN props - auto-detect origin type from Fjall resource\n */\nexport interface SmartCdnProps {\n  originType: \"auto\";\n  origin: S3Storage | Compute | string;\n  cachePolicy?: CachePolicyPreset | ICachePolicy;\n  behaviours?: CdnBehaviour[];\n  domainNames?: string[];\n  certificate?: ICertificate;\n  comment?: string;\n  enableLogging?: boolean;\n  logBucket?: IBucket;\n}\n\nexport type ICdnProps = S3CdnProps | AlbCdnProps | HttpCdnProps | SmartCdnProps;\n\n/**\n * Validates CDN props and logs warnings for misconfigured options.\n */\nfunction validateCdnProps(props: ICdnProps): void {\n  // Validate certificate region warning\n  if (props.certificate && props.domainNames && props.domainNames.length > 0) {\n    console.info(\n      \"[Fjall] Note: CloudFront certificates must be in us-east-1 region. \" +\n        \"Ensure your certificate was created in us-east-1.\"\n    );\n  }\n\n  // Validate domain names require certificate\n  if (props.domainNames && props.domainNames.length > 0 && !props.certificate) {\n    console.warn(\n      \"[Fjall] Warning: 'domainNames' provided but no 'certificate' specified. \" +\n        \"Custom domain names require an ACM certificate in us-east-1.\"\n    );\n  }\n\n  // Validate ALB origin\n  if (props.originType === \"alb\") {\n    const albProps = props as AlbCdnProps;\n    if (albProps.loadBalancer instanceof Compute) {\n      const lb = albProps.loadBalancer.getLoadBalancer();\n      if (!lb) {\n        throw new Error(\n          \"Compute resource does not have a load balancer. \" +\n            \"Ensure ECS compute has loadBalancer enabled for CDN origin.\"\n        );\n      }\n    }\n  }\n\n  // Validate smart origin\n  if (props.originType === \"auto\") {\n    const smartProps = props as SmartCdnProps;\n    if (smartProps.origin instanceof Compute) {\n      const computeType = smartProps.origin.getComputeType();\n      if (computeType === \"ec2\") {\n        throw new Error(\n          \"EC2 compute type is not supported for CDN origin. \" +\n            \"Use ECS with load balancer or Lambda with function URL.\"\n        );\n      }\n      if (computeType === \"ecs\" && !smartProps.origin.getLoadBalancer()) {\n        throw new Error(\n          \"ECS compute must have a load balancer for CDN origin. \" +\n            \"Enable loadBalancer in your ECS compute configuration.\"\n        );\n      }\n      if (computeType === \"lambda\" && !smartProps.origin.getFunctionUrl()) {\n        throw new Error(\n          \"Lambda compute must have a function URL for CDN origin. \" +\n            \"Enable functionUrl in your Lambda compute configuration.\"\n        );\n      }\n    }\n  }\n}\n\n/**\n * CDN wrapper class that extends CloudFrontDistribution with Fjall patterns.\n */\nexport class Cdn extends CloudFrontDistribution {\n  constructor(scope: Construct, id: string, props: ICdnProps) {\n    const resolvedProps = Cdn.resolveProps(props);\n    super(scope, id, resolvedProps);\n  }\n\n  /**\n   * Resolve ICdnProps to CloudFrontDistributionProps.\n   */\n  private static resolveProps(props: ICdnProps): CloudFrontDistributionProps {\n    const defaultOrigin = Cdn.resolveDefaultOrigin(props);\n\n    return {\n      defaultOrigin,\n      defaultCachePolicy: props.cachePolicy,\n      behaviours: props.behaviours,\n      domainNames: props.domainNames,\n      certificate: props.certificate,\n      comment: props.comment,\n      enableLogging: props.enableLogging,\n      logBucket: props.logBucket\n    };\n  }\n\n  /**\n   * Resolve the default origin from ICdnProps.\n   */\n  private static resolveDefaultOrigin(props: ICdnProps): CdnOriginConfig {\n    switch (props.originType) {\n      case \"s3\": {\n        const s3Props = props as S3CdnProps;\n        const bucket =\n          s3Props.bucket instanceof S3Storage\n            ? s3Props.bucket.getBucket()\n            : s3Props.bucket;\n        return {\n          type: \"s3\",\n          bucket,\n          originPath: s3Props.originPath\n        };\n      }\n\n      case \"alb\": {\n        const albProps = props as AlbCdnProps;\n        const loadBalancer =\n          albProps.loadBalancer instanceof Compute\n            ? albProps.loadBalancer.getLoadBalancer()!\n            : albProps.loadBalancer;\n        return {\n          type: \"alb\",\n          loadBalancer,\n          protocolPolicy: albProps.protocolPolicy\n        };\n      }\n\n      case \"http\": {\n        const httpProps = props as HttpCdnProps;\n        return {\n          type: \"http\",\n          domainName: httpProps.domainName,\n          originPath: httpProps.originPath,\n          protocolPolicy: httpProps.protocolPolicy\n        };\n      }\n\n      case \"auto\": {\n        const smartProps = props as SmartCdnProps;\n        return Cdn.detectOriginFromResource(smartProps.origin);\n      }\n    }\n  }\n\n  /**\n   * Auto-detect origin configuration from a Fjall resource.\n   */\n  private static detectOriginFromResource(\n    resource: S3Storage | Compute | string\n  ): CdnOriginConfig {\n    // String → HTTP origin\n    if (typeof resource === \"string\") {\n      return {\n        type: \"http\",\n        domainName: resource\n      };\n    }\n\n    // S3Storage → S3 origin\n    if (resource instanceof S3Storage) {\n      return {\n        type: \"s3\",\n        bucket: resource.getBucket()\n      };\n    }\n\n    // Compute → ALB or Lambda origin\n    if (resource instanceof Compute) {\n      const computeType = resource.getComputeType();\n\n      if (computeType === \"ecs\") {\n        const loadBalancer = resource.getLoadBalancer();\n        if (loadBalancer) {\n          return {\n            type: \"alb\",\n            loadBalancer\n          };\n        }\n      }\n\n      if (computeType === \"lambda\") {\n        const functionUrl = resource.getFunctionUrl();\n        if (functionUrl) {\n          // Lambda function URL is an HTTP origin\n          const url = new URL(functionUrl);\n          return {\n            type: \"http\",\n            domainName: url.hostname\n          };\n        }\n      }\n    }\n\n    throw new Error(\n      `Unable to detect CDN origin from resource: ${typeof resource}. ` +\n        \"Provide explicit origin configuration using originType.\"\n    );\n  }\n}\n\n/**\n * Factory for creating CDN (CloudFront) distributions.\n *\n * @example\n * // S3 origin\n * const assets = app.addStorage(StorageFactory.build(\"Assets\", { bucketType: \"private\" }));\n * app.addCdn(CdnFactory.build(\"AssetsCdn\", {\n *   originType: \"s3\",\n *   bucket: assets\n * }));\n *\n * @example\n * // ALB origin (ECS)\n * const api = app.addCompute(ComputeFactory.build(\"Api\", { type: \"ecs\", ... }));\n * app.addCdn(CdnFactory.build(\"ApiCdn\", {\n *   originType: \"alb\",\n *   loadBalancer: api\n * }));\n *\n * @example\n * // Smart detection\n * app.addCdn(CdnFactory.build(\"AppCdn\", {\n *   originType: \"auto\",\n *   origin: assets\n * }));\n *\n * @example\n * // Custom domain\n * app.addCdn(CdnFactory.build(\"AppCdn\", {\n *   originType: \"s3\",\n *   bucket: assets,\n *   domainNames: [\"app.example.com\"],\n *   certificate: myCert\n * }));\n */\nexport class CdnFactory {\n  /**\n   * Build a CDN factory function.\n   *\n   * @param id - Unique identifier for the CDN\n   * @param props - CDN configuration properties\n   * @returns Factory function that creates the CDN when invoked\n   */\n  static build(id: string, props: ICdnProps) {\n    return (_app: App, scope: Construct): Cdn => {\n      validateCdnProps(props);\n      return new Cdn(scope, id, props);\n    };\n  }\n}\n"]}

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

@@ -1,6 +1,6 @@
 import { type RepositoryImage } from "aws-cdk-lib/aws-ecs";
 import { Repository } from "aws-cdk-lib/aws-ecr";
-import { Connections, type IConnectable, type IVpc, type UserData, type IMachineImage } from "aws-cdk-lib/aws-ec2";
+import { type Connections, type IConnectable, type IVpc, type UserData, type IMachineImage } from "aws-cdk-lib/aws-ec2";
 import { Code, Runtime, type FunctionUrlAuthType, type FunctionUrlCorsOptions } from "aws-cdk-lib/aws-lambda";
 import { type PolicyStatement, type PolicyDocument, type IManagedPolicy } from "aws-cdk-lib/aws-iam";
 import { Construct } from "constructs";
@@ -273,6 +273,26 @@ export interface EcsServiceConfig {
      * ]
      */
     connections?: IConnectable[];
+    /**
+     * Capacity provider for this service. REQUIRED.
+     * Each service specifies its own capacity provider.
+     *
+     * @example
+     * // Mixed FARGATE and EC2 services in same cluster
+     * {
+     *   services: [
+     *     { name: "api", capacityProvider: "FARGATE" },
+     *     { name: "worker", capacityProvider: "EC2", ec2Config: { instanceType: "t3.micro" } }
+     *   ]
+     * }
+     */
+    capacityProvider: EcsCapacityProvider;
+    /**
+     * EC2 capacity configuration for this service.
+     * Only used when service capacityProvider is "EC2".
+     * Services with matching ec2Config share an ASG for efficiency.
+     */
+    ec2Config?: Ec2CapacityConfig;
 }
 /**
  * SSH access configuration for EC2 instances.
@@ -347,21 +367,10 @@ export interface EcsComputeProps extends BaseComputeProps {
     /**
      * Services in this cluster.
      * Each service gets its own task definition, scaling, and target group.
+     * Each service MUST specify its own capacityProvider.
      * All services share the cluster's ALB (unless disabled).
      */
     services: EcsServiceConfig[];
-    /**
-     * Capacity provider determines infrastructure type.
-     * - "FARGATE": Serverless containers (default)
-     * - "FARGATE_SPOT": Serverless with Spot pricing
-     * - "EC2": EC2-backed containers
-     */
-    capacityProvider?: EcsCapacityProvider;
-    /**
-     * EC2 capacity configuration.
-     * Only used when capacityProvider is "EC2".
-     */
-    ec2Config?: Ec2CapacityConfig;
     /**
      * ECR repository for all services (default image).
      * Individual services can override with their own `image` property.
@@ -403,6 +412,7 @@ interface BaseLambdaProps extends BaseComputeProps {
     timeout?: number;
     /** Memory size in MB. Default: 128 */
     memorySize?: number;
+    ephemeralStorageSize?: number;
     /** Lambda function description */
     description?: string;
     /** IAM role description */
@@ -419,6 +429,15 @@ interface BaseLambdaProps extends BaseComputeProps {
     functionUrl?: FunctionUrlConfig | false;
     /** Environment variables */
     environment?: Record<string, string>;
+    /** Container secrets import (key: env var, value: SecretImport) */
+    containerSecretsImport?: {
+        [key: string]: SecretImport;
+    };
+    /**
+     * Resources this Lambda needs to connect to (e.g., databases).
+     * Creates security group rules to allow traffic from this Lambda.
+     */
+    connections?: IConnectable[];
 }
 /**
  * Container-based Lambda using ECR image.