@fjall/components-infrastructure 0.86.0 → 0.87.3

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

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CdnFactory = exports.Cdn = void 0;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const cdn_1 = require("../../resources/aws/cdn");
+const storage_1 = require("./storage");
+const compute_1 = require("./compute");
+const validationLogger_js_1 = require("../../utils/validationLogger.js");
+/**
+ * Type guard to check if a value is a Fjall storage resource.
+ */
+function isStorageResource(value) {
+    return (value instanceof storage_1.PrivateStorage ||
+        value instanceof storage_1.WebsiteStorage ||
+        value instanceof storage_1.PublicStorage);
+}
+/**
+ * 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) {
+        validationLogger_js_1.FjallLogger.info("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) {
+        validationLogger_js_1.FjallLogger.warn("'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 ((0, compute_1.isCompute)(albProps.loadBalancer) &&
+            (0, compute_1.isEcsCompute)(albProps.loadBalancer)) {
+            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 ((0, compute_1.isCompute)(smartProps.origin)) {
+            if ((0, compute_1.isEcsCompute)(smartProps.origin)) {
+                if (!smartProps.origin.getLoadBalancer()) {
+                    throw new Error("ECS compute must have a load balancer for CDN origin. " +
+                        "Enable loadBalancer in your ECS compute configuration.");
+                }
+            }
+            else if ((0, compute_1.isLambdaCompute)(smartProps.origin)) {
+                if (!smartProps.origin.getFunctionUrl()) {
+                    throw new Error("Lambda compute must have a function URL for CDN origin. " +
+                        "Enable functionUrl in your Lambda compute configuration.");
+                }
+            }
+            else {
+                // Must be EC2
+                throw new Error("EC2 compute type is not supported for CDN origin. " +
+                    "Use ECS with load balancer or Lambda with function URL.");
+            }
+        }
+    }
+}
+/**
+ * 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);
+        const behaviours = Cdn.resolveBehaviours(props.behaviours);
+        return {
+            defaultOrigin,
+            defaultCachePolicy: props.cachePolicy,
+            defaultAllowedMethods: props.defaultAllowedMethods,
+            behaviours,
+            domainNames: props.domainNames,
+            certificate: props.certificate,
+            comment: props.comment,
+            enableLogging: props.enableLogging,
+            logBucket: props.logBucket,
+            priceClass: props.priceClass,
+            forwardHostHeader: props.forwardHostHeader
+        };
+    }
+    /**
+     * Transform smart behaviours to CdnBehaviour objects.
+     */
+    static resolveBehaviours(behaviours) {
+        if (!behaviours || behaviours.length === 0) {
+            return undefined;
+        }
+        return behaviours.map((behaviour) => ({
+            pathPattern: behaviour.pathPattern,
+            origin: Cdn.detectOriginFromResource(behaviour.origin),
+            cachePolicy: behaviour.cachePolicy,
+            allowedMethods: behaviour.allowedMethods
+        }));
+    }
+    /**
+     * Resolve the default origin from ICdnProps.
+     */
+    static resolveDefaultOrigin(props) {
+        switch (props.originType) {
+            case "s3": {
+                const bucket = isStorageResource(props.bucket)
+                    ? props.bucket.getBucket()
+                    : props.bucket;
+                return {
+                    type: "s3",
+                    bucket,
+                    originPath: props.originPath
+                };
+            }
+            case "alb": {
+                let loadBalancer;
+                if ((0, compute_1.isCompute)(props.loadBalancer)) {
+                    if ((0, compute_1.isEcsCompute)(props.loadBalancer)) {
+                        const lb = props.loadBalancer.getLoadBalancer();
+                        if (!lb) {
+                            throw new Error("Compute resource does not have a load balancer. " +
+                                "Ensure ECS compute has loadBalancer enabled for CDN origin.");
+                        }
+                        loadBalancer = lb;
+                    }
+                    else {
+                        throw new Error("Only ECS compute with load balancer is supported for ALB origin. " +
+                            "Lambda and EC2 compute types are not supported.");
+                    }
+                }
+                else {
+                    loadBalancer = props.loadBalancer;
+                }
+                return {
+                    type: "alb",
+                    loadBalancer,
+                    protocolPolicy: props.protocolPolicy
+                };
+            }
+            case "http":
+                return {
+                    type: "http",
+                    domainName: props.domainName,
+                    originPath: props.originPath,
+                    protocolPolicy: props.protocolPolicy
+                };
+            case "auto":
+                return Cdn.detectOriginFromResource(props.origin);
+            default: {
+                const _exhaustive = props;
+                throw new Error(`Unsupported CDN origin type: ${props.originType}`);
+            }
+        }
+    }
+    /**
+     * Auto-detect origin configuration from a Fjall resource.
+     */
+    static detectOriginFromResource(resource) {
+        // String → HTTP origin
+        if (typeof resource === "string") {
+            return {
+                type: "http",
+                domainName: resource
+            };
+        }
+        // StorageResource → S3 origin
+        if (isStorageResource(resource)) {
+            return {
+                type: "s3",
+                bucket: resource.getBucket()
+            };
+        }
+        // ECS Compute → ALB origin
+        if ((0, compute_1.isEcsCompute)(resource)) {
+            const loadBalancer = resource.getLoadBalancer();
+            if (loadBalancer) {
+                return {
+                    type: "alb",
+                    loadBalancer
+                };
+            }
+        }
+        // Lambda Compute → HTTP origin (function URL)
+        if ((0, compute_1.isLambdaCompute)(resource)) {
+            const functionUrl = resource.getFunctionUrl();
+            if (functionUrl) {
+                // Lambda function URL is an HTTP origin
+                // Extract domain from URL token using CloudFormation intrinsics
+                // URL format: https://<domain>/
+                // Split by "/" gives ["https:", "", "<domain>", ""]
+                // Select index 2 to get the domain
+                const domainName = aws_cdk_lib_1.Fn.select(2, aws_cdk_lib_1.Fn.split("/", functionUrl));
+                return {
+                    type: "http",
+                    domainName
+                };
+            }
+        }
+        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 { type Construct } from \"constructs\";\nimport { Fn } from \"aws-cdk-lib\";\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 { PrivateStorage, WebsiteStorage, PublicStorage } from \"./storage\";\nimport {\n  type AnyCompute,\n  isCompute,\n  isEcsCompute,\n  isLambdaCompute\n} from \"./compute\";\nimport { FjallLogger } from \"../../utils/validationLogger.js\";\n\n/**\n * Union type for Fjall S3 storage classes.\n */\ntype StorageResource = PrivateStorage | WebsiteStorage | PublicStorage;\n\n/**\n * Type guard to check if a value is a Fjall storage resource.\n */\nfunction isStorageResource(\n  value: unknown\n): value is PrivateStorage | WebsiteStorage | PublicStorage {\n  return (\n    value instanceof PrivateStorage ||\n    value instanceof WebsiteStorage ||\n    value instanceof PublicStorage\n  );\n}\n\n/**\n * S3 origin CDN props - use with S3 bucket\n */\nexport interface S3CdnProps {\n  originType: \"s3\";\n  bucket: IBucket | StorageResource;\n  originPath?: string;\n  cachePolicy?: CachePolicyPreset | ICachePolicy;\n  defaultAllowedMethods?: \"GET_HEAD\" | \"GET_HEAD_OPTIONS\" | \"ALL\";\n  behaviours?: SmartCdnBehaviour[];\n  domainNames?: string[];\n  certificate?: ICertificate;\n  comment?: string;\n  enableLogging?: boolean;\n  logBucket?: IBucket;\n  priceClass?: \"PriceClass_100\" | \"PriceClass_200\" | \"PriceClass_All\";\n  forwardHostHeader?: boolean;\n}\n\n/**\n * ALB origin CDN props - use with Application Load Balancer\n */\nexport interface AlbCdnProps {\n  originType: \"alb\";\n  loadBalancer: IApplicationLoadBalancer | AnyCompute;\n  protocolPolicy?: \"HTTP_ONLY\" | \"HTTPS_ONLY\" | \"MATCH_VIEWER\";\n  cachePolicy?: CachePolicyPreset | ICachePolicy;\n  defaultAllowedMethods?: \"GET_HEAD\" | \"GET_HEAD_OPTIONS\" | \"ALL\";\n  behaviours?: SmartCdnBehaviour[];\n  domainNames?: string[];\n  certificate?: ICertificate;\n  comment?: string;\n  enableLogging?: boolean;\n  logBucket?: IBucket;\n  priceClass?: \"PriceClass_100\" | \"PriceClass_200\" | \"PriceClass_All\";\n  forwardHostHeader?: boolean;\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  defaultAllowedMethods?: \"GET_HEAD\" | \"GET_HEAD_OPTIONS\" | \"ALL\";\n  behaviours?: SmartCdnBehaviour[];\n  domainNames?: string[];\n  certificate?: ICertificate;\n  comment?: string;\n  enableLogging?: boolean;\n  logBucket?: IBucket;\n  priceClass?: \"PriceClass_100\" | \"PriceClass_200\" | \"PriceClass_All\";\n  forwardHostHeader?: boolean;\n}\n\n/**\n * Smart origin CDN props - auto-detect origin type from Fjall resource\n */\nexport interface SmartCdnProps {\n  originType: \"auto\";\n  origin: StorageResource | AnyCompute | string;\n  cachePolicy?: CachePolicyPreset | ICachePolicy;\n  defaultAllowedMethods?: \"GET_HEAD\" | \"GET_HEAD_OPTIONS\" | \"ALL\";\n  behaviours?: SmartCdnBehaviour[];\n  domainNames?: string[];\n  certificate?: ICertificate;\n  comment?: string;\n  enableLogging?: boolean;\n  logBucket?: IBucket;\n  priceClass?: \"PriceClass_100\" | \"PriceClass_200\" | \"PriceClass_All\";\n  forwardHostHeader?: boolean;\n}\n\nexport type ICdnProps = S3CdnProps | AlbCdnProps | HttpCdnProps | SmartCdnProps;\n\n/**\n * Smart behaviour type that accepts Fjall resources as origins.\n * The factory will transform these to proper CdnBehaviour objects.\n */\nexport interface SmartCdnBehaviour {\n  pathPattern: string;\n  origin: StorageResource | AnyCompute | string;\n  cachePolicy?: CachePolicyPreset | ICachePolicy;\n  allowedMethods?: \"GET_HEAD\" | \"GET_HEAD_OPTIONS\" | \"ALL\";\n}\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    FjallLogger.info(\n      \"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    FjallLogger.warn(\n      \"'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 (\n      isCompute(albProps.loadBalancer) &&\n      isEcsCompute(albProps.loadBalancer)\n    ) {\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 (isCompute(smartProps.origin)) {\n      if (isEcsCompute(smartProps.origin)) {\n        if (!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      } else if (isLambdaCompute(smartProps.origin)) {\n        if (!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      } else {\n        // Must be 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    }\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    const behaviours = Cdn.resolveBehaviours(props.behaviours);\n\n    return {\n      defaultOrigin,\n      defaultCachePolicy: props.cachePolicy,\n      defaultAllowedMethods: props.defaultAllowedMethods,\n      behaviours,\n      domainNames: props.domainNames,\n      certificate: props.certificate,\n      comment: props.comment,\n      enableLogging: props.enableLogging,\n      logBucket: props.logBucket,\n      priceClass: props.priceClass,\n      forwardHostHeader: props.forwardHostHeader\n    };\n  }\n\n  /**\n   * Transform smart behaviours to CdnBehaviour objects.\n   */\n  private static resolveBehaviours(\n    behaviours?: SmartCdnBehaviour[]\n  ): CdnBehaviour[] | undefined {\n    if (!behaviours || behaviours.length === 0) {\n      return undefined;\n    }\n\n    return behaviours.map((behaviour) => ({\n      pathPattern: behaviour.pathPattern,\n      origin: Cdn.detectOriginFromResource(behaviour.origin),\n      cachePolicy: behaviour.cachePolicy,\n      allowedMethods: behaviour.allowedMethods\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 bucket = isStorageResource(props.bucket)\n          ? props.bucket.getBucket()\n          : props.bucket;\n        return {\n          type: \"s3\",\n          bucket,\n          originPath: props.originPath\n        };\n      }\n\n      case \"alb\": {\n        let loadBalancer: IApplicationLoadBalancer;\n        if (isCompute(props.loadBalancer)) {\n          if (isEcsCompute(props.loadBalancer)) {\n            const lb = props.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            loadBalancer = lb;\n          } else {\n            throw new Error(\n              \"Only ECS compute with load balancer is supported for ALB origin. \" +\n                \"Lambda and EC2 compute types are not supported.\"\n            );\n          }\n        } else {\n          loadBalancer = props.loadBalancer;\n        }\n        return {\n          type: \"alb\",\n          loadBalancer,\n          protocolPolicy: props.protocolPolicy\n        };\n      }\n\n      case \"http\":\n        return {\n          type: \"http\",\n          domainName: props.domainName,\n          originPath: props.originPath,\n          protocolPolicy: props.protocolPolicy\n        };\n\n      case \"auto\":\n        return Cdn.detectOriginFromResource(props.origin);\n\n      default: {\n        const _exhaustive: never = props;\n        throw new Error(\n          `Unsupported CDN origin type: ${(props as ICdnProps).originType}`\n        );\n      }\n    }\n  }\n\n  /**\n   * Auto-detect origin configuration from a Fjall resource.\n   */\n  private static detectOriginFromResource(\n    resource: StorageResource | AnyCompute | string\n  ): CdnOriginConfig {\n    // String → HTTP origin\n    if (typeof resource === \"string\") {\n      return {\n        type: \"http\",\n        domainName: resource\n      };\n    }\n\n    // StorageResource → S3 origin\n    if (isStorageResource(resource)) {\n      return {\n        type: \"s3\",\n        bucket: resource.getBucket()\n      };\n    }\n\n    // ECS Compute → ALB origin\n    if (isEcsCompute(resource)) {\n      const loadBalancer = resource.getLoadBalancer();\n      if (loadBalancer) {\n        return {\n          type: \"alb\",\n          loadBalancer\n        };\n      }\n    }\n\n    // Lambda Compute → HTTP origin (function URL)\n    if (isLambdaCompute(resource)) {\n      const functionUrl = resource.getFunctionUrl();\n      if (functionUrl) {\n        // Lambda function URL is an HTTP origin\n        // Extract domain from URL token using CloudFormation intrinsics\n        // URL format: https://<domain>/\n        // Split by \"/\" gives [\"https:\", \"\", \"<domain>\", \"\"]\n        // Select index 2 to get the domain\n        const domainName = Fn.select(2, Fn.split(\"/\", functionUrl));\n        return {\n          type: \"http\",\n          domainName\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"]}