cdk-cost-analyzer 0.1.1

package/dist/pricing/calculators/APIGatewayCalculator.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIGatewayCalculator = void 0;
+class APIGatewayCalculator {
+    supports(resourceType) {
+        return resourceType === 'AWS::ApiGateway::RestApi' ||
+            resourceType === 'AWS::ApiGatewayV2::Api';
+    }
+    async calculateCost(resource, region, pricingClient) {
+        const isV2 = resource.type === 'AWS::ApiGatewayV2::Api';
+        const protocolType = isV2 ? resource.properties.ProtocolType : 'REST';
+        if (protocolType === 'WEBSOCKET') {
+            return this.calculateWebSocketCost(region, pricingClient);
+        }
+        else if (protocolType === 'HTTP') {
+            return this.calculateHttpApiCost(region, pricingClient);
+        }
+        else {
+            return this.calculateRestApiCost(region, pricingClient);
+        }
+    }
+    async calculateRestApiCost(region, pricingClient) {
+        try {
+            const assumedRequests = 1_000_000; // 1M requests per month
+            const costPerMillion = await pricingClient.getPrice({
+                serviceCode: 'AmazonApiGateway',
+                region: this.normalizeRegion(region),
+                filters: [
+                    { field: 'productFamily', value: 'API Calls' },
+                    { field: 'groupDescription', value: 'ApiGatewayRequest' },
+                ],
+            });
+            if (costPerMillion === null) {
+                return {
+                    amount: 0,
+                    currency: 'USD',
+                    confidence: 'unknown',
+                    assumptions: ['Pricing data not available for API Gateway REST API'],
+                };
+            }
+            const monthlyCost = (assumedRequests / 1_000_000) * costPerMillion;
+            return {
+                amount: monthlyCost,
+                currency: 'USD',
+                confidence: 'medium',
+                assumptions: [
+                    `Assumes ${assumedRequests.toLocaleString()} REST API requests per month`,
+                    'REST API type',
+                    'Does not include data transfer, caching, or other features',
+                    'First 333M requests may have tiered pricing (not calculated)',
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                amount: 0,
+                currency: 'USD',
+                confidence: 'unknown',
+                assumptions: [`Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`],
+            };
+        }
+    }
+    async calculateHttpApiCost(region, pricingClient) {
+        try {
+            const assumedRequests = 1_000_000; // 1M requests per month
+            const costPerMillion = await pricingClient.getPrice({
+                serviceCode: 'AmazonApiGateway',
+                region: this.normalizeRegion(region),
+                filters: [
+                    { field: 'productFamily', value: 'API Calls' },
+                    { field: 'groupDescription', value: 'ApiGatewayHttpRequest' },
+                ],
+            });
+            if (costPerMillion === null) {
+                return {
+                    amount: 0,
+                    currency: 'USD',
+                    confidence: 'unknown',
+                    assumptions: ['Pricing data not available for API Gateway HTTP API'],
+                };
+            }
+            const monthlyCost = (assumedRequests / 1_000_000) * costPerMillion;
+            return {
+                amount: monthlyCost,
+                currency: 'USD',
+                confidence: 'medium',
+                assumptions: [
+                    `Assumes ${assumedRequests.toLocaleString()} HTTP API requests per month`,
+                    'HTTP API type',
+                    'Does not include data transfer costs',
+                    'First 300M requests may have tiered pricing (not calculated)',
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                amount: 0,
+                currency: 'USD',
+                confidence: 'unknown',
+                assumptions: [`Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`],
+            };
+        }
+    }
+    async calculateWebSocketCost(region, pricingClient) {
+        try {
+            const assumedMessages = 1_000_000; // 1M messages per month
+            const assumedConnectionMinutes = 100_000; // 100K connection minutes
+            const messageCostPerMillion = await pricingClient.getPrice({
+                serviceCode: 'AmazonApiGateway',
+                region: this.normalizeRegion(region),
+                filters: [
+                    { field: 'productFamily', value: 'WebSocket' },
+                    { field: 'groupDescription', value: 'ApiGatewayMessage' },
+                ],
+            });
+            const connectionCostPerMinute = await pricingClient.getPrice({
+                serviceCode: 'AmazonApiGateway',
+                region: this.normalizeRegion(region),
+                filters: [
+                    { field: 'productFamily', value: 'WebSocket' },
+                    { field: 'groupDescription', value: 'ApiGatewayConnectionMinute' },
+                ],
+            });
+            if (messageCostPerMillion === null || connectionCostPerMinute === null) {
+                return {
+                    amount: 0,
+                    currency: 'USD',
+                    confidence: 'unknown',
+                    assumptions: ['Pricing data not available for API Gateway WebSocket API'],
+                };
+            }
+            const messageCost = (assumedMessages / 1_000_000) * messageCostPerMillion;
+            const connectionCost = assumedConnectionMinutes * connectionCostPerMinute;
+            const monthlyCost = messageCost + connectionCost;
+            return {
+                amount: monthlyCost,
+                currency: 'USD',
+                confidence: 'medium',
+                assumptions: [
+                    `Assumes ${assumedMessages.toLocaleString()} WebSocket messages per month`,
+                    `Assumes ${assumedConnectionMinutes.toLocaleString()} connection minutes per month`,
+                    'WebSocket API type',
+                    'Does not include data transfer costs',
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                amount: 0,
+                currency: 'USD',
+                confidence: 'unknown',
+                assumptions: [`Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`],
+            };
+        }
+    }
+    normalizeRegion(region) {
+        const regionMap = {
+            'us-east-1': 'US East (N. Virginia)',
+            'us-east-2': 'US East (Ohio)',
+            'us-west-1': 'US West (N. California)',
+            'us-west-2': 'US West (Oregon)',
+            'eu-west-1': 'EU (Ireland)',
+            'eu-west-2': 'EU (London)',
+            'eu-west-3': 'EU (Paris)',
+            'eu-central-1': 'EU (Frankfurt)',
+            'eu-north-1': 'EU (Stockholm)',
+            'ap-south-1': 'Asia Pacific (Mumbai)',
+            'ap-southeast-1': 'Asia Pacific (Singapore)',
+            'ap-southeast-2': 'Asia Pacific (Sydney)',
+            'ap-northeast-1': 'Asia Pacific (Tokyo)',
+            'ap-northeast-2': 'Asia Pacific (Seoul)',
+        };
+        return regionMap[region] || region;
+    }
+}
+exports.APIGatewayCalculator = APIGatewayCalculator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"APIGatewayCalculator.js","sourceRoot":"","sources":["../../../src/pricing/calculators/APIGatewayCalculator.ts"],"names":[],"mappings":"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","sourcesContent":["import { ResourceWithId } from '../../diff/types';\nimport { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';\n\nexport class APIGatewayCalculator implements ResourceCostCalculator {\n  supports(resourceType: string): boolean {\n    return resourceType === 'AWS::ApiGateway::RestApi' ||\n           resourceType === 'AWS::ApiGatewayV2::Api';\n  }\n\n  async calculateCost(\n    resource: ResourceWithId,\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    const isV2 = resource.type === 'AWS::ApiGatewayV2::Api';\n    const protocolType = isV2 ? (resource.properties.ProtocolType as string) : 'REST';\n\n    if (protocolType === 'WEBSOCKET') {\n      return this.calculateWebSocketCost(region, pricingClient);\n    } else if (protocolType === 'HTTP') {\n      return this.calculateHttpApiCost(region, pricingClient);\n    } else {\n      return this.calculateRestApiCost(region, pricingClient);\n    }\n  }\n\n  private async calculateRestApiCost(\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    try {\n      const assumedRequests = 1_000_000; // 1M requests per month\n\n      const costPerMillion = await pricingClient.getPrice({\n        serviceCode: 'AmazonApiGateway',\n        region: this.normalizeRegion(region),\n        filters: [\n          { field: 'productFamily', value: 'API Calls' },\n          { field: 'groupDescription', value: 'ApiGatewayRequest' },\n        ],\n      });\n\n      if (costPerMillion === null) {\n        return {\n          amount: 0,\n          currency: 'USD',\n          confidence: 'unknown',\n          assumptions: ['Pricing data not available for API Gateway REST API'],\n        };\n      }\n\n      const monthlyCost = (assumedRequests / 1_000_000) * costPerMillion;\n\n      return {\n        amount: monthlyCost,\n        currency: 'USD',\n        confidence: 'medium',\n        assumptions: [\n          `Assumes ${assumedRequests.toLocaleString()} REST API requests per month`,\n          'REST API type',\n          'Does not include data transfer, caching, or other features',\n          'First 333M requests may have tiered pricing (not calculated)',\n        ],\n      };\n    } catch (error) {\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'unknown',\n        assumptions: [`Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`],\n      };\n    }\n  }\n\n  private async calculateHttpApiCost(\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    try {\n      const assumedRequests = 1_000_000; // 1M requests per month\n\n      const costPerMillion = await pricingClient.getPrice({\n        serviceCode: 'AmazonApiGateway',\n        region: this.normalizeRegion(region),\n        filters: [\n          { field: 'productFamily', value: 'API Calls' },\n          { field: 'groupDescription', value: 'ApiGatewayHttpRequest' },\n        ],\n      });\n\n      if (costPerMillion === null) {\n        return {\n          amount: 0,\n          currency: 'USD',\n          confidence: 'unknown',\n          assumptions: ['Pricing data not available for API Gateway HTTP API'],\n        };\n      }\n\n      const monthlyCost = (assumedRequests / 1_000_000) * costPerMillion;\n\n      return {\n        amount: monthlyCost,\n        currency: 'USD',\n        confidence: 'medium',\n        assumptions: [\n          `Assumes ${assumedRequests.toLocaleString()} HTTP API requests per month`,\n          'HTTP API type',\n          'Does not include data transfer costs',\n          'First 300M requests may have tiered pricing (not calculated)',\n        ],\n      };\n    } catch (error) {\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'unknown',\n        assumptions: [`Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`],\n      };\n    }\n  }\n\n  private async calculateWebSocketCost(\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    try {\n      const assumedMessages = 1_000_000; // 1M messages per month\n      const assumedConnectionMinutes = 100_000; // 100K connection minutes\n\n      const messageCostPerMillion = await pricingClient.getPrice({\n        serviceCode: 'AmazonApiGateway',\n        region: this.normalizeRegion(region),\n        filters: [\n          { field: 'productFamily', value: 'WebSocket' },\n          { field: 'groupDescription', value: 'ApiGatewayMessage' },\n        ],\n      });\n\n      const connectionCostPerMinute = await pricingClient.getPrice({\n        serviceCode: 'AmazonApiGateway',\n        region: this.normalizeRegion(region),\n        filters: [\n          { field: 'productFamily', value: 'WebSocket' },\n          { field: 'groupDescription', value: 'ApiGatewayConnectionMinute' },\n        ],\n      });\n\n      if (messageCostPerMillion === null || connectionCostPerMinute === null) {\n        return {\n          amount: 0,\n          currency: 'USD',\n          confidence: 'unknown',\n          assumptions: ['Pricing data not available for API Gateway WebSocket API'],\n        };\n      }\n\n      const messageCost = (assumedMessages / 1_000_000) * messageCostPerMillion;\n      const connectionCost = assumedConnectionMinutes * connectionCostPerMinute;\n      const monthlyCost = messageCost + connectionCost;\n\n      return {\n        amount: monthlyCost,\n        currency: 'USD',\n        confidence: 'medium',\n        assumptions: [\n          `Assumes ${assumedMessages.toLocaleString()} WebSocket messages per month`,\n          `Assumes ${assumedConnectionMinutes.toLocaleString()} connection minutes per month`,\n          'WebSocket API type',\n          'Does not include data transfer costs',\n        ],\n      };\n    } catch (error) {\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'unknown',\n        assumptions: [`Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`],\n      };\n    }\n  }\n\n  private normalizeRegion(region: string): string {\n    const regionMap: Record<string, string> = {\n      'us-east-1': 'US East (N. Virginia)',\n      'us-east-2': 'US East (Ohio)',\n      'us-west-1': 'US West (N. California)',\n      'us-west-2': 'US West (Oregon)',\n      'eu-west-1': 'EU (Ireland)',\n      'eu-west-2': 'EU (London)',\n      'eu-west-3': 'EU (Paris)',\n      'eu-central-1': 'EU (Frankfurt)',\n      'eu-north-1': 'EU (Stockholm)',\n      'ap-south-1': 'Asia Pacific (Mumbai)',\n      'ap-southeast-1': 'Asia Pacific (Singapore)',\n      'ap-southeast-2': 'Asia Pacific (Sydney)',\n      'ap-northeast-1': 'Asia Pacific (Tokyo)',\n      'ap-northeast-2': 'Asia Pacific (Seoul)',\n    };\n\n    return regionMap[region] || region;\n  }\n}\n"]}

package/dist/pricing/calculators/CloudFrontCalculator.d.ts

@@ -0,0 +1,59 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+/**
+ * Calculator for AWS CloudFront distribution costs.
+ *
+ * Estimates monthly costs based on data transfer and request volumes.
+ * CloudFront pricing includes:
+ * - Data transfer out to internet (per GB)
+ * - HTTP/HTTPS requests (per 10,000 requests)
+ *
+ * @see https://aws.amazon.com/cloudfront/pricing/
+ */
+export declare class CloudFrontCalculator implements ResourceCostCalculator {
+    private readonly dataTransferGB?;
+    private readonly requests?;
+    private readonly DEFAULT_DATA_TRANSFER_GB;
+    private readonly DEFAULT_REQUESTS;
+    /**
+     * Creates a CloudFront cost calculator.
+     *
+     * @param dataTransferGB - Optional custom data transfer volume in GB per month
+     * @param requests - Optional custom request count per month
+     */
+    constructor(dataTransferGB?: number | undefined, requests?: number | undefined);
+    /**
+     * Checks if this calculator supports the given resource type.
+     *
+     * @param resourceType - CloudFormation resource type
+     * @returns true if resource type is AWS::CloudFront::Distribution
+     */
+    supports(resourceType: string): boolean;
+    /**
+     * Calculates monthly cost for a CloudFront distribution.
+     *
+     * Cost components:
+     * - Data transfer out to internet (based on volume in GB)
+     * - HTTP/HTTPS requests (per 10,000 requests)
+     *
+     * Default assumptions:
+     * - 100 GB data transfer per month
+     * - 1,000,000 requests per month
+     *
+     * @param _resource - CloudFormation resource (properties not used for CloudFront)
+     * @param region - AWS region for pricing (CloudFront is global but pricing varies by region)
+     * @param pricingClient - Client for querying AWS Pricing API
+     * @returns Monthly cost estimate with assumptions and confidence level
+     */
+    calculateCost(_resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+    /**
+     * Normalizes AWS region code to AWS Pricing API region name.
+     *
+     * CloudFront is a global service, but pricing varies by region and the
+     * AWS Pricing API requires region names in specific format.
+     *
+     * @param region - AWS region code (e.g., 'us-east-1')
+     * @returns AWS Pricing API region name (e.g., 'US East (N. Virginia)')
+     */
+    private normalizeRegion;
+}

package/dist/pricing/calculators/CloudFrontCalculator.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudFrontCalculator = void 0;
+/**
+ * Calculator for AWS CloudFront distribution costs.
+ *
+ * Estimates monthly costs based on data transfer and request volumes.
+ * CloudFront pricing includes:
+ * - Data transfer out to internet (per GB)
+ * - HTTP/HTTPS requests (per 10,000 requests)
+ *
+ * @see https://aws.amazon.com/cloudfront/pricing/
+ */
+class CloudFrontCalculator {
+    dataTransferGB;
+    requests;
+    DEFAULT_DATA_TRANSFER_GB = 100;
+    DEFAULT_REQUESTS = 1000000;
+    /**
+     * Creates a CloudFront cost calculator.
+     *
+     * @param dataTransferGB - Optional custom data transfer volume in GB per month
+     * @param requests - Optional custom request count per month
+     */
+    constructor(dataTransferGB, requests) {
+        this.dataTransferGB = dataTransferGB;
+        this.requests = requests;
+    }
+    /**
+     * Checks if this calculator supports the given resource type.
+     *
+     * @param resourceType - CloudFormation resource type
+     * @returns true if resource type is AWS::CloudFront::Distribution
+     */
+    supports(resourceType) {
+        return resourceType === 'AWS::CloudFront::Distribution';
+    }
+    /**
+     * Calculates monthly cost for a CloudFront distribution.
+     *
+     * Cost components:
+     * - Data transfer out to internet (based on volume in GB)
+     * - HTTP/HTTPS requests (per 10,000 requests)
+     *
+     * Default assumptions:
+     * - 100 GB data transfer per month
+     * - 1,000,000 requests per month
+     *
+     * @param _resource - CloudFormation resource (properties not used for CloudFront)
+     * @param region - AWS region for pricing (CloudFront is global but pricing varies by region)
+     * @param pricingClient - Client for querying AWS Pricing API
+     * @returns Monthly cost estimate with assumptions and confidence level
+     */
+    async calculateCost(_resource, region, pricingClient) {
+        const dataTransfer = this.dataTransferGB ?? this.DEFAULT_DATA_TRANSFER_GB;
+        const requestCount = this.requests ?? this.DEFAULT_REQUESTS;
+        try {
+            // Query pricing for data transfer out to internet
+            const dataTransferPrice = await pricingClient.getPrice({
+                serviceCode: 'AmazonCloudFront',
+                region: this.normalizeRegion(region),
+                filters: [{ field: 'transferType', value: 'CloudFront to Internet' }],
+            });
+            // Query pricing for HTTP/HTTPS requests
+            const requestPrice = await pricingClient.getPrice({
+                serviceCode: 'AmazonCloudFront',
+                region: this.normalizeRegion(region),
+                filters: [{ field: 'requestType', value: 'HTTP-Requests' }],
+            });
+            if (dataTransferPrice === null || requestPrice === null) {
+                const assumptions = [
+                    `Pricing data not available for CloudFront in region ${region}`,
+                    `Would assume ${dataTransfer} GB of data transfer out to internet`,
+                    `Would assume ${requestCount.toLocaleString()} HTTP/HTTPS requests per month`,
+                ];
+                if (this.dataTransferGB !== undefined) {
+                    assumptions.push(`Using custom data transfer assumption: ${dataTransfer} GB from configuration`);
+                }
+                if (this.requests !== undefined) {
+                    assumptions.push(`Using custom request count assumption: ${requestCount.toLocaleString()} requests from configuration`);
+                }
+                return {
+                    amount: 0,
+                    currency: 'USD',
+                    confidence: 'unknown',
+                    assumptions,
+                };
+            }
+            // Calculate costs
+            const dataTransferCost = dataTransfer * dataTransferPrice;
+            const requestCost = (requestCount / 10000) * requestPrice; // Pricing is per 10,000 requests
+            const totalCost = dataTransferCost + requestCost;
+            const assumptions = [
+                `Assumes ${dataTransfer} GB of data transfer out to internet`,
+                `Assumes ${requestCount.toLocaleString()} HTTP/HTTPS requests per month`,
+            ];
+            if (this.dataTransferGB !== undefined) {
+                assumptions.push(`Using custom data transfer assumption: ${dataTransfer} GB from configuration`);
+            }
+            if (this.requests !== undefined) {
+                assumptions.push(`Using custom request count assumption: ${requestCount.toLocaleString()} requests from configuration`);
+            }
+            return {
+                amount: totalCost,
+                currency: 'USD',
+                confidence: 'medium',
+                assumptions,
+            };
+        }
+        catch (error) {
+            return {
+                amount: 0,
+                currency: 'USD',
+                confidence: 'unknown',
+                assumptions: [
+                    `Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`,
+                ],
+            };
+        }
+    }
+    /**
+     * Normalizes AWS region code to AWS Pricing API region name.
+     *
+     * CloudFront is a global service, but pricing varies by region and the
+     * AWS Pricing API requires region names in specific format.
+     *
+     * @param region - AWS region code (e.g., 'us-east-1')
+     * @returns AWS Pricing API region name (e.g., 'US East (N. Virginia)')
+     */
+    normalizeRegion(region) {
+        const regionMap = {
+            'us-east-1': 'US East (N. Virginia)',
+            'us-east-2': 'US East (Ohio)',
+            'us-west-1': 'US West (N. California)',
+            'us-west-2': 'US West (Oregon)',
+            'eu-west-1': 'EU (Ireland)',
+            'eu-west-2': 'EU (London)',
+            'eu-west-3': 'EU (Paris)',
+            'eu-central-1': 'EU (Frankfurt)',
+            'eu-north-1': 'EU (Stockholm)',
+            'ap-south-1': 'Asia Pacific (Mumbai)',
+            'ap-southeast-1': 'Asia Pacific (Singapore)',
+            'ap-southeast-2': 'Asia Pacific (Sydney)',
+            'ap-northeast-1': 'Asia Pacific (Tokyo)',
+            'ap-northeast-2': 'Asia Pacific (Seoul)',
+        };
+        return regionMap[region] || region;
+    }
+}
+exports.CloudFrontCalculator = CloudFrontCalculator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CloudFrontCalculator.js","sourceRoot":"","sources":["../../../src/pricing/calculators/CloudFrontCalculator.ts"],"names":[],"mappings":"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","sourcesContent":["import { ResourceWithId } from '../../diff/types';\nimport { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';\n\n/**\n * Calculator for AWS CloudFront distribution costs.\n *\n * Estimates monthly costs based on data transfer and request volumes.\n * CloudFront pricing includes:\n * - Data transfer out to internet (per GB)\n * - HTTP/HTTPS requests (per 10,000 requests)\n *\n * @see https://aws.amazon.com/cloudfront/pricing/\n */\nexport class CloudFrontCalculator implements ResourceCostCalculator {\n  private readonly DEFAULT_DATA_TRANSFER_GB = 100;\n  private readonly DEFAULT_REQUESTS = 1000000;\n\n  /**\n   * Creates a CloudFront cost calculator.\n   *\n   * @param dataTransferGB - Optional custom data transfer volume in GB per month\n   * @param requests - Optional custom request count per month\n   */\n  constructor(\n    private readonly dataTransferGB?: number,\n    private readonly requests?: number,\n  ) {}\n\n  /**\n   * Checks if this calculator supports the given resource type.\n   *\n   * @param resourceType - CloudFormation resource type\n   * @returns true if resource type is AWS::CloudFront::Distribution\n   */\n  supports(resourceType: string): boolean {\n    return resourceType === 'AWS::CloudFront::Distribution';\n  }\n\n  /**\n   * Calculates monthly cost for a CloudFront distribution.\n   *\n   * Cost components:\n   * - Data transfer out to internet (based on volume in GB)\n   * - HTTP/HTTPS requests (per 10,000 requests)\n   *\n   * Default assumptions:\n   * - 100 GB data transfer per month\n   * - 1,000,000 requests per month\n   *\n   * @param _resource - CloudFormation resource (properties not used for CloudFront)\n   * @param region - AWS region for pricing (CloudFront is global but pricing varies by region)\n   * @param pricingClient - Client for querying AWS Pricing API\n   * @returns Monthly cost estimate with assumptions and confidence level\n   */\n  async calculateCost(\n    _resource: ResourceWithId,\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    const dataTransfer = this.dataTransferGB ?? this.DEFAULT_DATA_TRANSFER_GB;\n    const requestCount = this.requests ?? this.DEFAULT_REQUESTS;\n\n    try {\n      // Query pricing for data transfer out to internet\n      const dataTransferPrice = await pricingClient.getPrice({\n        serviceCode: 'AmazonCloudFront',\n        region: this.normalizeRegion(region),\n        filters: [{ field: 'transferType', value: 'CloudFront to Internet' }],\n      });\n\n      // Query pricing for HTTP/HTTPS requests\n      const requestPrice = await pricingClient.getPrice({\n        serviceCode: 'AmazonCloudFront',\n        region: this.normalizeRegion(region),\n        filters: [{ field: 'requestType', value: 'HTTP-Requests' }],\n      });\n\n      if (dataTransferPrice === null || requestPrice === null) {\n        const assumptions = [\n          `Pricing data not available for CloudFront in region ${region}`,\n          `Would assume ${dataTransfer} GB of data transfer out to internet`,\n          `Would assume ${requestCount.toLocaleString()} HTTP/HTTPS requests per month`,\n        ];\n\n        if (this.dataTransferGB !== undefined) {\n          assumptions.push(\n            `Using custom data transfer assumption: ${dataTransfer} GB from configuration`,\n          );\n        }\n        if (this.requests !== undefined) {\n          assumptions.push(\n            `Using custom request count assumption: ${requestCount.toLocaleString()} requests from configuration`,\n          );\n        }\n\n        return {\n          amount: 0,\n          currency: 'USD',\n          confidence: 'unknown',\n          assumptions,\n        };\n      }\n\n      // Calculate costs\n      const dataTransferCost = dataTransfer * dataTransferPrice;\n      const requestCost = (requestCount / 10000) * requestPrice; // Pricing is per 10,000 requests\n\n      const totalCost = dataTransferCost + requestCost;\n\n      const assumptions = [\n        `Assumes ${dataTransfer} GB of data transfer out to internet`,\n        `Assumes ${requestCount.toLocaleString()} HTTP/HTTPS requests per month`,\n      ];\n\n      if (this.dataTransferGB !== undefined) {\n        assumptions.push(\n          `Using custom data transfer assumption: ${dataTransfer} GB from configuration`,\n        );\n      }\n      if (this.requests !== undefined) {\n        assumptions.push(\n          `Using custom request count assumption: ${requestCount.toLocaleString()} requests from configuration`,\n        );\n      }\n\n      return {\n        amount: totalCost,\n        currency: 'USD',\n        confidence: 'medium',\n        assumptions,\n      };\n    } catch (error) {\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'unknown',\n        assumptions: [\n          `Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`,\n        ],\n      };\n    }\n  }\n\n  /**\n   * Normalizes AWS region code to AWS Pricing API region name.\n   *\n   * CloudFront is a global service, but pricing varies by region and the\n   * AWS Pricing API requires region names in specific format.\n   *\n   * @param region - AWS region code (e.g., 'us-east-1')\n   * @returns AWS Pricing API region name (e.g., 'US East (N. Virginia)')\n   */\n  private normalizeRegion(region: string): string {\n    const regionMap: Record<string, string> = {\n      'us-east-1': 'US East (N. Virginia)',\n      'us-east-2': 'US East (Ohio)',\n      'us-west-1': 'US West (N. California)',\n      'us-west-2': 'US West (Oregon)',\n      'eu-west-1': 'EU (Ireland)',\n      'eu-west-2': 'EU (London)',\n      'eu-west-3': 'EU (Paris)',\n      'eu-central-1': 'EU (Frankfurt)',\n      'eu-north-1': 'EU (Stockholm)',\n      'ap-south-1': 'Asia Pacific (Mumbai)',\n      'ap-southeast-1': 'Asia Pacific (Singapore)',\n      'ap-southeast-2': 'Asia Pacific (Sydney)',\n      'ap-northeast-1': 'Asia Pacific (Tokyo)',\n      'ap-northeast-2': 'Asia Pacific (Seoul)',\n    };\n\n    return regionMap[region] || region;\n  }\n}\n"]}

package/dist/pricing/calculators/DynamoDBCalculator.d.ts

@@ -0,0 +1,9 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+export declare class DynamoDBCalculator implements ResourceCostCalculator {
+    supports(resourceType: string): boolean;
+    calculateCost(resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+    private calculateOnDemandCost;
+    private calculateProvisionedCost;
+    private normalizeRegion;
+}

package/dist/pricing/calculators/DynamoDBCalculator.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamoDBCalculator = void 0;
+class DynamoDBCalculator {
+    supports(resourceType) {
+        return resourceType === 'AWS::DynamoDB::Table';
+    }
+    async calculateCost(resource, region, pricingClient) {
+        const billingMode = resource.properties.BillingMode || 'PROVISIONED';
+        if (billingMode === 'PAY_PER_REQUEST') {
+            return this.calculateOnDemandCost(resource, region, pricingClient);
+        }
+        else {
+            return this.calculateProvisionedCost(resource, region, pricingClient);
+        }
+    }
+    async calculateOnDemandCost(_resource, region, pricingClient) {
+        try {
+            // Default assumptions for on-demand mode
+            const assumedReadRequests = 10_000_000; // 10M read requests per month
+            const assumedWriteRequests = 1_000_000; // 1M write requests per month
+            const readCostPerMillion = await pricingClient.getPrice({
+                serviceCode: 'AmazonDynamoDB',
+                region: this.normalizeRegion(region),
+                filters: [
+                    { field: 'group', value: 'DDB-ReadUnits' },
+                    { field: 'groupDescription', value: 'OnDemand ReadRequestUnits' },
+                ],
+            });
+            const writeCostPerMillion = await pricingClient.getPrice({
+                serviceCode: 'AmazonDynamoDB',
+                region: this.normalizeRegion(region),
+                filters: [
+                    { field: 'group', value: 'DDB-WriteUnits' },
+                    { field: 'groupDescription', value: 'OnDemand WriteRequestUnits' },
+                ],
+            });
+            if (readCostPerMillion === null || writeCostPerMillion === null) {
+                return {
+                    amount: 0,
+                    currency: 'USD',
+                    confidence: 'unknown',
+                    assumptions: ['Pricing data not available for DynamoDB on-demand mode'],
+                };
+            }
+            const readCost = (assumedReadRequests / 1_000_000) * readCostPerMillion;
+            const writeCost = (assumedWriteRequests / 1_000_000) * writeCostPerMillion;
+            const monthlyCost = readCost + writeCost;
+            return {
+                amount: monthlyCost,
+                currency: 'USD',
+                confidence: 'medium',
+                assumptions: [
+                    `Assumes ${assumedReadRequests.toLocaleString()} read requests per month`,
+                    `Assumes ${assumedWriteRequests.toLocaleString()} write requests per month`,
+                    'On-demand billing mode',
+                    'Does not include storage costs or other features (streams, backups, etc.)',
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                amount: 0,
+                currency: 'USD',
+                confidence: 'unknown',
+                assumptions: [`Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`],
+            };
+        }
+    }
+    async calculateProvisionedCost(resource, region, pricingClient) {
+        try {
+            const provisionedThroughput = resource.properties.ProvisionedThroughput;
+            const readCapacity = provisionedThroughput?.ReadCapacityUnits || 5;
+            const writeCapacity = provisionedThroughput?.WriteCapacityUnits || 5;
+            const readCostPerHour = await pricingClient.getPrice({
+                serviceCode: 'AmazonDynamoDB',
+                region: this.normalizeRegion(region),
+                filters: [
+                    { field: 'group', value: 'DDB-ReadUnits' },
+                    { field: 'groupDescription', value: 'Provisioned ReadCapacityUnit-Hrs' },
+                ],
+            });
+            const writeCostPerHour = await pricingClient.getPrice({
+                serviceCode: 'AmazonDynamoDB',
+                region: this.normalizeRegion(region),
+                filters: [
+                    { field: 'group', value: 'DDB-WriteUnits' },
+                    { field: 'groupDescription', value: 'Provisioned WriteCapacityUnit-Hrs' },
+                ],
+            });
+            if (readCostPerHour === null || writeCostPerHour === null) {
+                return {
+                    amount: 0,
+                    currency: 'USD',
+                    confidence: 'unknown',
+                    assumptions: ['Pricing data not available for DynamoDB provisioned mode'],
+                };
+            }
+            const hoursPerMonth = 730;
+            const readCost = readCapacity * hoursPerMonth * readCostPerHour;
+            const writeCost = writeCapacity * hoursPerMonth * writeCostPerHour;
+            const monthlyCost = readCost + writeCost;
+            return {
+                amount: monthlyCost,
+                currency: 'USD',
+                confidence: 'high',
+                assumptions: [
+                    `${readCapacity} provisioned read capacity units`,
+                    `${writeCapacity} provisioned write capacity units`,
+                    `Assumes ${hoursPerMonth} hours per month (24/7 operation)`,
+                    'Provisioned billing mode',
+                    'Does not include storage costs or other features (streams, backups, etc.)',
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                amount: 0,
+                currency: 'USD',
+                confidence: 'unknown',
+                assumptions: [`Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`],
+            };
+        }
+    }
+    normalizeRegion(region) {
+        const regionMap = {
+            'us-east-1': 'US East (N. Virginia)',
+            'us-east-2': 'US East (Ohio)',
+            'us-west-1': 'US West (N. California)',
+            'us-west-2': 'US West (Oregon)',
+            'eu-west-1': 'EU (Ireland)',
+            'eu-west-2': 'EU (London)',
+            'eu-west-3': 'EU (Paris)',
+            'eu-central-1': 'EU (Frankfurt)',
+            'eu-north-1': 'EU (Stockholm)',
+            'ap-south-1': 'Asia Pacific (Mumbai)',
+            'ap-southeast-1': 'Asia Pacific (Singapore)',
+            'ap-southeast-2': 'Asia Pacific (Sydney)',
+            'ap-northeast-1': 'Asia Pacific (Tokyo)',
+            'ap-northeast-2': 'Asia Pacific (Seoul)',
+        };
+        return regionMap[region] || region;
+    }
+}
+exports.DynamoDBCalculator = DynamoDBCalculator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DynamoDBCalculator.js","sourceRoot":"","sources":["../../../src/pricing/calculators/DynamoDBCalculator.ts"],"names":[],"mappings":";;;AAGA,MAAa,kBAAkB;IAC7B,QAAQ,CAAC,YAAoB;QAC3B,OAAO,YAAY,KAAK,sBAAsB,CAAC;IACjD,CAAC;IAED,KAAK,CAAC,aAAa,CACjB,QAAwB,EACxB,MAAc,EACd,aAA4B;QAE5B,MAAM,WAAW,GAAI,QAAQ,CAAC,UAAU,CAAC,WAAsB,IAAI,aAAa,CAAC;QAEjF,IAAI,WAAW,KAAK,iBAAiB,EAAE,CAAC;YACtC,OAAO,IAAI,CAAC,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC;QACrE,CAAC;aAAM,CAAC;YACN,OAAO,IAAI,CAAC,wBAAwB,CAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC;QACxE,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,qBAAqB,CACjC,SAAyB,EACzB,MAAc,EACd,aAA4B;QAE5B,IAAI,CAAC;YACH,yCAAyC;YACzC,MAAM,mBAAmB,GAAG,UAAU,CAAC,CAAC,8BAA8B;YACtE,MAAM,oBAAoB,GAAG,SAAS,CAAC,CAAC,8BAA8B;YAEtE,MAAM,kBAAkB,GAAG,MAAM,aAAa,CAAC,QAAQ,CAAC;gBACtD,WAAW,EAAE,gBAAgB;gBAC7B,MAAM,EAAE,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC;gBACpC,OAAO,EAAE;oBACP,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,eAAe,EAAE;oBAC1C,EAAE,KAAK,EAAE,kBAAkB,EAAE,KAAK,EAAE,2BAA2B,EAAE;iBAClE;aACF,CAAC,CAAC;YAEH,MAAM,mBAAmB,GAAG,MAAM,aAAa,CAAC,QAAQ,CAAC;gBACvD,WAAW,EAAE,gBAAgB;gBAC7B,MAAM,EAAE,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC;gBACpC,OAAO,EAAE;oBACP,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,gBAAgB,EAAE;oBAC3C,EAAE,KAAK,EAAE,kBAAkB,EAAE,KAAK,EAAE,4BAA4B,EAAE;iBACnE;aACF,CAAC,CAAC;YAEH,IAAI,kBAAkB,KAAK,IAAI,IAAI,mBAAmB,KAAK,IAAI,EAAE,CAAC;gBAChE,OAAO;oBACL,MAAM,EAAE,CAAC;oBACT,QAAQ,EAAE,KAAK;oBACf,UAAU,EAAE,SAAS;oBACrB,WAAW,EAAE,CAAC,wDAAwD,CAAC;iBACxE,CAAC;YACJ,CAAC;YAED,MAAM,QAAQ,GAAG,CAAC,mBAAmB,GAAG,SAAS,CAAC,GAAG,kBAAkB,CAAC;YACxE,MAAM,SAAS,GAAG,CAAC,oBAAoB,GAAG,SAAS,CAAC,GAAG,mBAAmB,CAAC;YAC3E,MAAM,WAAW,GAAG,QAAQ,GAAG,SAAS,CAAC;YAEzC,OAAO;gBACL,MAAM,EAAE,WAAW;gBACnB,QAAQ,EAAE,KAAK;gBACf,UAAU,EAAE,QAAQ;gBACpB,WAAW,EAAE;oBACX,WAAW,mBAAmB,CAAC,cAAc,EAAE,0BAA0B;oBACzE,WAAW,oBAAoB,CAAC,cAAc,EAAE,2BAA2B;oBAC3E,wBAAwB;oBACxB,2EAA2E;iBAC5E;aACF,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO;gBACL,MAAM,EAAE,CAAC;gBACT,QAAQ,EAAE,KAAK;gBACf,UAAU,EAAE,SAAS;gBACrB,WAAW,EAAE,CAAC,4BAA4B,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;aACpG,CAAC;QACJ,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,wBAAwB,CACpC,QAAwB,EACxB,MAAc,EACd,aAA4B;QAE5B,IAAI,CAAC;YACH,MAAM,qBAAqB,GAAG,QAAQ,CAAC,UAAU,CAAC,qBAA4B,CAAC;YAC/E,MAAM,YAAY,GAAG,qBAAqB,EAAE,iBAAiB,IAAI,CAAC,CAAC;YACnE,MAAM,aAAa,GAAG,qBAAqB,EAAE,kBAAkB,IAAI,CAAC,CAAC;YAErE,MAAM,eAAe,GAAG,MAAM,aAAa,CAAC,QAAQ,CAAC;gBACnD,WAAW,EAAE,gBAAgB;gBAC7B,MAAM,EAAE,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC;gBACpC,OAAO,EAAE;oBACP,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,eAAe,EAAE;oBAC1C,EAAE,KAAK,EAAE,kBAAkB,EAAE,KAAK,EAAE,kCAAkC,EAAE;iBACzE;aACF,CAAC,CAAC;YAEH,MAAM,gBAAgB,GAAG,MAAM,aAAa,CAAC,QAAQ,CAAC;gBACpD,WAAW,EAAE,gBAAgB;gBAC7B,MAAM,EAAE,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC;gBACpC,OAAO,EAAE;oBACP,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,gBAAgB,EAAE;oBAC3C,EAAE,KAAK,EAAE,kBAAkB,EAAE,KAAK,EAAE,mCAAmC,EAAE;iBAC1E;aACF,CAAC,CAAC;YAEH,IAAI,eAAe,KAAK,IAAI,IAAI,gBAAgB,KAAK,IAAI,EAAE,CAAC;gBAC1D,OAAO;oBACL,MAAM,EAAE,CAAC;oBACT,QAAQ,EAAE,KAAK;oBACf,UAAU,EAAE,SAAS;oBACrB,WAAW,EAAE,CAAC,0DAA0D,CAAC;iBAC1E,CAAC;YACJ,CAAC;YAED,MAAM,aAAa,GAAG,GAAG,CAAC;YAC1B,MAAM,QAAQ,GAAG,YAAY,GAAG,aAAa,GAAG,eAAe,CAAC;YAChE,MAAM,SAAS,GAAG,aAAa,GAAG,aAAa,GAAG,gBAAgB,CAAC;YACnE,MAAM,WAAW,GAAG,QAAQ,GAAG,SAAS,CAAC;YAEzC,OAAO;gBACL,MAAM,EAAE,WAAW;gBACnB,QAAQ,EAAE,KAAK;gBACf,UAAU,EAAE,MAAM;gBAClB,WAAW,EAAE;oBACX,GAAG,YAAY,kCAAkC;oBACjD,GAAG,aAAa,mCAAmC;oBACnD,WAAW,aAAa,mCAAmC;oBAC3D,0BAA0B;oBAC1B,2EAA2E;iBAC5E;aACF,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO;gBACL,MAAM,EAAE,CAAC;gBACT,QAAQ,EAAE,KAAK;gBACf,UAAU,EAAE,SAAS;gBACrB,WAAW,EAAE,CAAC,4BAA4B,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;aACpG,CAAC;QACJ,CAAC;IACH,CAAC;IAEO,eAAe,CAAC,MAAc;QACpC,MAAM,SAAS,GAA2B;YACxC,WAAW,EAAE,uBAAuB;YACpC,WAAW,EAAE,gBAAgB;YAC7B,WAAW,EAAE,yBAAyB;YACtC,WAAW,EAAE,kBAAkB;YAC/B,WAAW,EAAE,cAAc;YAC3B,WAAW,EAAE,aAAa;YAC1B,WAAW,EAAE,YAAY;YACzB,cAAc,EAAE,gBAAgB;YAChC,YAAY,EAAE,gBAAgB;YAC9B,YAAY,EAAE,uBAAuB;YACrC,gBAAgB,EAAE,0BAA0B;YAC5C,gBAAgB,EAAE,uBAAuB;YACzC,gBAAgB,EAAE,sBAAsB;YACxC,gBAAgB,EAAE,sBAAsB;SACzC,CAAC;QAEF,OAAO,SAAS,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC;IACrC,CAAC;CACF;AArKD,gDAqKC","sourcesContent":["import { ResourceWithId } from '../../diff/types';\nimport { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';\n\nexport class DynamoDBCalculator implements ResourceCostCalculator {\n  supports(resourceType: string): boolean {\n    return resourceType === 'AWS::DynamoDB::Table';\n  }\n\n  async calculateCost(\n    resource: ResourceWithId,\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    const billingMode = (resource.properties.BillingMode as string) || 'PROVISIONED';\n\n    if (billingMode === 'PAY_PER_REQUEST') {\n      return this.calculateOnDemandCost(resource, region, pricingClient);\n    } else {\n      return this.calculateProvisionedCost(resource, region, pricingClient);\n    }\n  }\n\n  private async calculateOnDemandCost(\n    _resource: ResourceWithId,\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    try {\n      // Default assumptions for on-demand mode\n      const assumedReadRequests = 10_000_000; // 10M read requests per month\n      const assumedWriteRequests = 1_000_000; // 1M write requests per month\n\n      const readCostPerMillion = await pricingClient.getPrice({\n        serviceCode: 'AmazonDynamoDB',\n        region: this.normalizeRegion(region),\n        filters: [\n          { field: 'group', value: 'DDB-ReadUnits' },\n          { field: 'groupDescription', value: 'OnDemand ReadRequestUnits' },\n        ],\n      });\n\n      const writeCostPerMillion = await pricingClient.getPrice({\n        serviceCode: 'AmazonDynamoDB',\n        region: this.normalizeRegion(region),\n        filters: [\n          { field: 'group', value: 'DDB-WriteUnits' },\n          { field: 'groupDescription', value: 'OnDemand WriteRequestUnits' },\n        ],\n      });\n\n      if (readCostPerMillion === null || writeCostPerMillion === null) {\n        return {\n          amount: 0,\n          currency: 'USD',\n          confidence: 'unknown',\n          assumptions: ['Pricing data not available for DynamoDB on-demand mode'],\n        };\n      }\n\n      const readCost = (assumedReadRequests / 1_000_000) * readCostPerMillion;\n      const writeCost = (assumedWriteRequests / 1_000_000) * writeCostPerMillion;\n      const monthlyCost = readCost + writeCost;\n\n      return {\n        amount: monthlyCost,\n        currency: 'USD',\n        confidence: 'medium',\n        assumptions: [\n          `Assumes ${assumedReadRequests.toLocaleString()} read requests per month`,\n          `Assumes ${assumedWriteRequests.toLocaleString()} write requests per month`,\n          'On-demand billing mode',\n          'Does not include storage costs or other features (streams, backups, etc.)',\n        ],\n      };\n    } catch (error) {\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'unknown',\n        assumptions: [`Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`],\n      };\n    }\n  }\n\n  private async calculateProvisionedCost(\n    resource: ResourceWithId,\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    try {\n      const provisionedThroughput = resource.properties.ProvisionedThroughput as any;\n      const readCapacity = provisionedThroughput?.ReadCapacityUnits || 5;\n      const writeCapacity = provisionedThroughput?.WriteCapacityUnits || 5;\n\n      const readCostPerHour = await pricingClient.getPrice({\n        serviceCode: 'AmazonDynamoDB',\n        region: this.normalizeRegion(region),\n        filters: [\n          { field: 'group', value: 'DDB-ReadUnits' },\n          { field: 'groupDescription', value: 'Provisioned ReadCapacityUnit-Hrs' },\n        ],\n      });\n\n      const writeCostPerHour = await pricingClient.getPrice({\n        serviceCode: 'AmazonDynamoDB',\n        region: this.normalizeRegion(region),\n        filters: [\n          { field: 'group', value: 'DDB-WriteUnits' },\n          { field: 'groupDescription', value: 'Provisioned WriteCapacityUnit-Hrs' },\n        ],\n      });\n\n      if (readCostPerHour === null || writeCostPerHour === null) {\n        return {\n          amount: 0,\n          currency: 'USD',\n          confidence: 'unknown',\n          assumptions: ['Pricing data not available for DynamoDB provisioned mode'],\n        };\n      }\n\n      const hoursPerMonth = 730;\n      const readCost = readCapacity * hoursPerMonth * readCostPerHour;\n      const writeCost = writeCapacity * hoursPerMonth * writeCostPerHour;\n      const monthlyCost = readCost + writeCost;\n\n      return {\n        amount: monthlyCost,\n        currency: 'USD',\n        confidence: 'high',\n        assumptions: [\n          `${readCapacity} provisioned read capacity units`,\n          `${writeCapacity} provisioned write capacity units`,\n          `Assumes ${hoursPerMonth} hours per month (24/7 operation)`,\n          'Provisioned billing mode',\n          'Does not include storage costs or other features (streams, backups, etc.)',\n        ],\n      };\n    } catch (error) {\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'unknown',\n        assumptions: [`Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`],\n      };\n    }\n  }\n\n  private normalizeRegion(region: string): string {\n    const regionMap: Record<string, string> = {\n      'us-east-1': 'US East (N. Virginia)',\n      'us-east-2': 'US East (Ohio)',\n      'us-west-1': 'US West (N. California)',\n      'us-west-2': 'US West (Oregon)',\n      'eu-west-1': 'EU (Ireland)',\n      'eu-west-2': 'EU (London)',\n      'eu-west-3': 'EU (Paris)',\n      'eu-central-1': 'EU (Frankfurt)',\n      'eu-north-1': 'EU (Stockholm)',\n      'ap-south-1': 'Asia Pacific (Mumbai)',\n      'ap-southeast-1': 'Asia Pacific (Singapore)',\n      'ap-southeast-2': 'Asia Pacific (Sydney)',\n      'ap-northeast-1': 'Asia Pacific (Tokyo)',\n      'ap-northeast-2': 'Asia Pacific (Seoul)',\n    };\n\n    return regionMap[region] || region;\n  }\n}\n"]}

package/dist/pricing/calculators/EC2Calculator.d.ts

@@ -0,0 +1,7 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+export declare class EC2Calculator implements ResourceCostCalculator {
+    supports(resourceType: string): boolean;
+    calculateCost(resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+    private normalizeRegion;
+}