cdk-cost-analyzer 0.1.1

package/dist/pricing/calculators/EC2Calculator.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EC2Calculator = void 0;
+class EC2Calculator {
+    supports(resourceType) {
+        return resourceType === 'AWS::EC2::Instance';
+    }
+    async calculateCost(resource, region, pricingClient) {
+        const instanceType = resource.properties.InstanceType;
+        if (!instanceType) {
+            return {
+                amount: 0,
+                currency: 'USD',
+                confidence: 'unknown',
+                assumptions: ['Instance type not specified'],
+            };
+        }
+        try {
+            const hourlyRate = await pricingClient.getPrice({
+                serviceCode: 'AmazonEC2',
+                region: this.normalizeRegion(region),
+                filters: [
+                    { field: 'instanceType', value: instanceType },
+                    { field: 'operatingSystem', value: 'Linux' },
+                    { field: 'tenancy', value: 'Shared' },
+                    { field: 'preInstalledSw', value: 'NA' },
+                    { field: 'capacitystatus', value: 'Used' },
+                ],
+            });
+            if (hourlyRate === null) {
+                return {
+                    amount: 0,
+                    currency: 'USD',
+                    confidence: 'unknown',
+                    assumptions: [`Pricing data not available for instance type ${instanceType} in region ${region}`],
+                };
+            }
+            const monthlyHours = 730;
+            const monthlyCost = hourlyRate * monthlyHours;
+            return {
+                amount: monthlyCost,
+                currency: 'USD',
+                confidence: 'high',
+                assumptions: [
+                    `Assumes ${monthlyHours} hours per month (24/7 operation)`,
+                    'Assumes Linux OS, shared tenancy, on-demand pricing',
+                ],
+            };
+        }
+        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.EC2Calculator = EC2Calculator;
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/dist/pricing/calculators/ECSCalculator.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ECSCalculator = void 0;
+class ECSCalculator {
+    supports(resourceType) {
+        return resourceType === 'AWS::ECS::Service';
+    }
+    async calculateCost(resource, region, pricingClient) {
+        const desiredCount = resource.properties.DesiredCount || 1;
+        const launchType = resource.properties.LaunchType || 'FARGATE';
+        if (launchType === 'FARGATE') {
+            return this.calculateFargateCost(resource, desiredCount, region, pricingClient);
+        }
+        else if (launchType === 'EC2') {
+            return this.calculateEC2Cost(desiredCount);
+        }
+        else {
+            return {
+                amount: 0,
+                currency: 'USD',
+                confidence: 'unknown',
+                assumptions: [`Unsupported launch type: ${launchType}`],
+            };
+        }
+    }
+    async calculateFargateCost(_resource, desiredCount, region, pricingClient) {
+        try {
+            // Default assumptions for Fargate task
+            const assumedVCpu = 0.25; // 0.25 vCPU
+            const assumedMemoryGB = 0.5; // 0.5 GB
+            const vCpuCostPerHour = await pricingClient.getPrice({
+                serviceCode: 'AmazonECS',
+                region: this.normalizeRegion(region),
+                filters: [
+                    { field: 'productFamily', value: 'Compute' },
+                    { field: 'usagetype', value: `${region}-Fargate-vCPU-Hours:perCPU` },
+                ],
+            });
+            const memoryCostPerHour = await pricingClient.getPrice({
+                serviceCode: 'AmazonECS',
+                region: this.normalizeRegion(region),
+                filters: [
+                    { field: 'productFamily', value: 'Compute' },
+                    { field: 'usagetype', value: `${region}-Fargate-GB-Hours:perGB` },
+                ],
+            });
+            if (vCpuCostPerHour === null || memoryCostPerHour === null) {
+                return {
+                    amount: 0,
+                    currency: 'USD',
+                    confidence: 'unknown',
+                    assumptions: ['Pricing data not available for ECS Fargate'],
+                };
+            }
+            const hoursPerMonth = 730;
+            const vCpuCost = assumedVCpu * vCpuCostPerHour * hoursPerMonth * desiredCount;
+            const memoryCost = assumedMemoryGB * memoryCostPerHour * hoursPerMonth * desiredCount;
+            const monthlyCost = vCpuCost + memoryCost;
+            return {
+                amount: monthlyCost,
+                currency: 'USD',
+                confidence: 'medium',
+                assumptions: [
+                    `${desiredCount} task(s) running`,
+                    `Assumes ${assumedVCpu} vCPU per task`,
+                    `Assumes ${assumedMemoryGB} GB memory per task`,
+                    `Assumes ${hoursPerMonth} hours per month (24/7 operation)`,
+                    'Fargate launch type',
+                    'Does not include data transfer or storage costs',
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                amount: 0,
+                currency: 'USD',
+                confidence: 'unknown',
+                assumptions: [`Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`],
+            };
+        }
+    }
+    calculateEC2Cost(desiredCount) {
+        return {
+            amount: 0,
+            currency: 'USD',
+            confidence: 'low',
+            assumptions: [
+                `${desiredCount} task(s) running on EC2 launch type`,
+                'EC2 launch type costs depend on underlying EC2 instances',
+                'Refer to EC2 instance costs for actual pricing',
+                'Does not include ECS task-specific costs (minimal for EC2 launch type)',
+            ],
+        };
+    }
+    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.ECSCalculator = ECSCalculator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ECSCalculator.js","sourceRoot":"","sources":["../../../src/pricing/calculators/ECSCalculator.ts"],"names":[],"mappings":"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","sourcesContent":["import { ResourceWithId } from '../../diff/types';\nimport { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';\n\nexport class ECSCalculator implements ResourceCostCalculator {\n  supports(resourceType: string): boolean {\n    return resourceType === 'AWS::ECS::Service';\n  }\n\n  async calculateCost(\n    resource: ResourceWithId,\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    const desiredCount = (resource.properties.DesiredCount as number) || 1;\n    const launchType = (resource.properties.LaunchType as string) || 'FARGATE';\n\n    if (launchType === 'FARGATE') {\n      return this.calculateFargateCost(resource, desiredCount, region, pricingClient);\n    } else if (launchType === 'EC2') {\n      return this.calculateEC2Cost(desiredCount);\n    } else {\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'unknown',\n        assumptions: [`Unsupported launch type: ${launchType}`],\n      };\n    }\n  }\n\n  private async calculateFargateCost(\n    _resource: ResourceWithId,\n    desiredCount: number,\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    try {\n      // Default assumptions for Fargate task\n      const assumedVCpu = 0.25; // 0.25 vCPU\n      const assumedMemoryGB = 0.5; // 0.5 GB\n\n      const vCpuCostPerHour = await pricingClient.getPrice({\n        serviceCode: 'AmazonECS',\n        region: this.normalizeRegion(region),\n        filters: [\n          { field: 'productFamily', value: 'Compute' },\n          { field: 'usagetype', value: `${region}-Fargate-vCPU-Hours:perCPU` },\n        ],\n      });\n\n      const memoryCostPerHour = await pricingClient.getPrice({\n        serviceCode: 'AmazonECS',\n        region: this.normalizeRegion(region),\n        filters: [\n          { field: 'productFamily', value: 'Compute' },\n          { field: 'usagetype', value: `${region}-Fargate-GB-Hours:perGB` },\n        ],\n      });\n\n      if (vCpuCostPerHour === null || memoryCostPerHour === null) {\n        return {\n          amount: 0,\n          currency: 'USD',\n          confidence: 'unknown',\n          assumptions: ['Pricing data not available for ECS Fargate'],\n        };\n      }\n\n      const hoursPerMonth = 730;\n      const vCpuCost = assumedVCpu * vCpuCostPerHour * hoursPerMonth * desiredCount;\n      const memoryCost = assumedMemoryGB * memoryCostPerHour * hoursPerMonth * desiredCount;\n      const monthlyCost = vCpuCost + memoryCost;\n\n      return {\n        amount: monthlyCost,\n        currency: 'USD',\n        confidence: 'medium',\n        assumptions: [\n          `${desiredCount} task(s) running`,\n          `Assumes ${assumedVCpu} vCPU per task`,\n          `Assumes ${assumedMemoryGB} GB memory per task`,\n          `Assumes ${hoursPerMonth} hours per month (24/7 operation)`,\n          'Fargate launch type',\n          'Does not include data transfer or storage 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 calculateEC2Cost(desiredCount: number): MonthlyCost {\n    return {\n      amount: 0,\n      currency: 'USD',\n      confidence: 'low',\n      assumptions: [\n        `${desiredCount} task(s) running on EC2 launch type`,\n        'EC2 launch type costs depend on underlying EC2 instances',\n        'Refer to EC2 instance costs for actual pricing',\n        'Does not include ECS task-specific costs (minimal for EC2 launch type)',\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/ElastiCacheCalculator.d.ts

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

package/dist/pricing/calculators/ElastiCacheCalculator.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElastiCacheCalculator = void 0;
+class ElastiCacheCalculator {
+    supports(resourceType) {
+        return resourceType === 'AWS::ElastiCache::CacheCluster';
+    }
+    async calculateCost(resource, region, pricingClient) {
+        const cacheNodeType = resource.properties.CacheNodeType;
+        const engine = resource.properties.Engine;
+        const numCacheNodes = resource.properties.NumCacheNodes || 1;
+        const azMode = resource.properties.AZMode;
+        if (!cacheNodeType || !engine) {
+            return {
+                amount: 0,
+                currency: 'USD',
+                confidence: 'unknown',
+                assumptions: ['Cache node type or engine not specified'],
+            };
+        }
+        try {
+            // Query AWS Pricing API for node hourly rates
+            const hourlyRate = await pricingClient.getPrice({
+                serviceCode: 'AmazonElastiCache',
+                region: this.normalizeRegion(region),
+                filters: [
+                    { field: 'instanceType', value: cacheNodeType },
+                    { field: 'cacheEngine', value: this.normalizeEngine(engine) },
+                ],
+            });
+            if (hourlyRate === null) {
+                return {
+                    amount: 0,
+                    currency: 'USD',
+                    confidence: 'unknown',
+                    assumptions: [
+                        `Pricing data not available for node type ${cacheNodeType} with engine ${engine} in region ${region}`,
+                    ],
+                };
+            }
+            const monthlyHours = 730;
+            const perNodeCost = hourlyRate * monthlyHours;
+            let totalCost = perNodeCost * numCacheNodes;
+            const assumptions = [
+                `Assumes ${monthlyHours} hours per month (24/7 operation)`,
+                `Node type: ${cacheNodeType}`,
+                `Engine: ${engine}`,
+                `Number of cache nodes: ${numCacheNodes}`,
+                `Per-node monthly cost: $${perNodeCost.toFixed(2)}`,
+            ];
+            // Account for multi-AZ replica costs when configured
+            if (azMode === 'cross-az') {
+                // Multi-AZ adds replica nodes (typically doubles the cost)
+                totalCost *= 2;
+                assumptions.push('Multi-AZ deployment with replica nodes (cost doubled)');
+            }
+            else {
+                assumptions.push('Single-AZ deployment');
+            }
+            return {
+                amount: totalCost,
+                currency: 'USD',
+                confidence: 'high',
+                assumptions,
+            };
+        }
+        catch (error) {
+            return {
+                amount: 0,
+                currency: 'USD',
+                confidence: 'unknown',
+                assumptions: [
+                    `Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`,
+                ],
+            };
+        }
+    }
+    normalizeEngine(engine) {
+        const engineMap = {
+            redis: 'Redis',
+            memcached: 'Memcached',
+        };
+        return engineMap[engine.toLowerCase()] || engine;
+    }
+    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.ElastiCacheCalculator = ElastiCacheCalculator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ElastiCacheCalculator.js","sourceRoot":"","sources":["../../../src/pricing/calculators/ElastiCacheCalculator.ts"],"names":[],"mappings":"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","sourcesContent":["import { ResourceWithId } from '../../diff/types';\nimport { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';\n\nexport class ElastiCacheCalculator implements ResourceCostCalculator {\n  supports(resourceType: string): boolean {\n    return resourceType === 'AWS::ElastiCache::CacheCluster';\n  }\n\n  async calculateCost(\n    resource: ResourceWithId,\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    const cacheNodeType = resource.properties.CacheNodeType as string;\n    const engine = resource.properties.Engine as string;\n    const numCacheNodes = (resource.properties.NumCacheNodes as number) || 1;\n    const azMode = resource.properties.AZMode as string;\n\n    if (!cacheNodeType || !engine) {\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'unknown',\n        assumptions: ['Cache node type or engine not specified'],\n      };\n    }\n\n    try {\n      // Query AWS Pricing API for node hourly rates\n      const hourlyRate = await pricingClient.getPrice({\n        serviceCode: 'AmazonElastiCache',\n        region: this.normalizeRegion(region),\n        filters: [\n          { field: 'instanceType', value: cacheNodeType },\n          { field: 'cacheEngine', value: this.normalizeEngine(engine) },\n        ],\n      });\n\n      if (hourlyRate === null) {\n        return {\n          amount: 0,\n          currency: 'USD',\n          confidence: 'unknown',\n          assumptions: [\n            `Pricing data not available for node type ${cacheNodeType} with engine ${engine} in region ${region}`,\n          ],\n        };\n      }\n\n      const monthlyHours = 730;\n      const perNodeCost = hourlyRate * monthlyHours;\n      let totalCost = perNodeCost * numCacheNodes;\n\n      const assumptions = [\n        `Assumes ${monthlyHours} hours per month (24/7 operation)`,\n        `Node type: ${cacheNodeType}`,\n        `Engine: ${engine}`,\n        `Number of cache nodes: ${numCacheNodes}`,\n        `Per-node monthly cost: $${perNodeCost.toFixed(2)}`,\n      ];\n\n      // Account for multi-AZ replica costs when configured\n      if (azMode === 'cross-az') {\n        // Multi-AZ adds replica nodes (typically doubles the cost)\n        totalCost *= 2;\n        assumptions.push('Multi-AZ deployment with replica nodes (cost doubled)');\n      } else {\n        assumptions.push('Single-AZ deployment');\n      }\n\n      return {\n        amount: totalCost,\n        currency: 'USD',\n        confidence: 'high',\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  private normalizeEngine(engine: string): string {\n    const engineMap: Record<string, string> = {\n      redis: 'Redis',\n      memcached: 'Memcached',\n    };\n\n    return engineMap[engine.toLowerCase()] || engine;\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/LambdaCalculator.d.ts

@@ -0,0 +1,13 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+export declare class LambdaCalculator implements ResourceCostCalculator {
+    private readonly customInvocationsPerMonth?;
+    private readonly customAverageDurationMs?;
+    private readonly DEFAULT_INVOCATIONS;
+    private readonly DEFAULT_DURATION_MS;
+    private readonly DEFAULT_MEMORY_MB;
+    constructor(customInvocationsPerMonth?: number | undefined, customAverageDurationMs?: number | undefined);
+    supports(resourceType: string): boolean;
+    calculateCost(resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+    private normalizeRegion;
+}

package/dist/pricing/calculators/LambdaCalculator.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LambdaCalculator = void 0;
+class LambdaCalculator {
+    customInvocationsPerMonth;
+    customAverageDurationMs;
+    DEFAULT_INVOCATIONS = 1000000;
+    DEFAULT_DURATION_MS = 1000;
+    DEFAULT_MEMORY_MB = 128;
+    constructor(customInvocationsPerMonth, customAverageDurationMs) {
+        this.customInvocationsPerMonth = customInvocationsPerMonth;
+        this.customAverageDurationMs = customAverageDurationMs;
+    }
+    supports(resourceType) {
+        return resourceType === 'AWS::Lambda::Function';
+    }
+    async calculateCost(resource, region, pricingClient) {
+        const memorySize = resource.properties.MemorySize || this.DEFAULT_MEMORY_MB;
+        const invocations = this.customInvocationsPerMonth ?? this.DEFAULT_INVOCATIONS;
+        const durationMs = this.customAverageDurationMs ?? this.DEFAULT_DURATION_MS;
+        try {
+            const requestPrice = await pricingClient.getPrice({
+                serviceCode: 'AWSLambda',
+                region: this.normalizeRegion(region),
+                filters: [
+                    { field: 'group', value: 'AWS-Lambda-Requests' },
+                ],
+            });
+            const computePrice = await pricingClient.getPrice({
+                serviceCode: 'AWSLambda',
+                region: this.normalizeRegion(region),
+                filters: [
+                    { field: 'group', value: 'AWS-Lambda-Duration' },
+                ],
+            });
+            const assumptions = [
+                `Assumes ${invocations.toLocaleString()} invocations per month`,
+                `Assumes ${durationMs}ms average execution time`,
+                `Assumes ${memorySize}MB memory allocation`,
+            ];
+            if (this.customInvocationsPerMonth !== undefined) {
+                assumptions.push('Using custom invocation count assumption from configuration');
+            }
+            if (this.customAverageDurationMs !== undefined) {
+                assumptions.push('Using custom duration assumption from configuration');
+            }
+            if (requestPrice === null || computePrice === null) {
+                return {
+                    amount: 0,
+                    currency: 'USD',
+                    confidence: 'unknown',
+                    assumptions: [
+                        `Pricing data not available for Lambda in region ${region}`,
+                        ...assumptions,
+                    ],
+                };
+            }
+            const requestCost = (invocations / 1000000) * requestPrice;
+            const gbSeconds = (memorySize / 1024) * (durationMs / 1000) * invocations;
+            const computeCost = gbSeconds * computePrice;
+            const totalCost = requestCost + computeCost;
+            return {
+                amount: totalCost,
+                currency: 'USD',
+                confidence: 'medium',
+                assumptions,
+            };
+        }
+        catch (error) {
+            const assumptions = [
+                `Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`,
+                `Would assume ${invocations.toLocaleString()} invocations per month`,
+                `Would assume ${durationMs}ms average execution time`,
+                `Would assume ${memorySize}MB memory allocation`,
+            ];
+            if (this.customInvocationsPerMonth !== undefined) {
+                assumptions.push('Using custom invocation count assumption from configuration');
+            }
+            if (this.customAverageDurationMs !== undefined) {
+                assumptions.push('Using custom duration assumption from configuration');
+            }
+            return {
+                amount: 0,
+                currency: 'USD',
+                confidence: 'unknown',
+                assumptions,
+            };
+        }
+    }
+    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.LambdaCalculator = LambdaCalculator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"LambdaCalculator.js","sourceRoot":"","sources":["../../../src/pricing/calculators/LambdaCalculator.ts"],"names":[],"mappings":"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","sourcesContent":["import { ResourceWithId } from '../../diff/types';\nimport { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';\n\nexport class LambdaCalculator implements ResourceCostCalculator {\n  private readonly DEFAULT_INVOCATIONS = 1000000;\n  private readonly DEFAULT_DURATION_MS = 1000;\n  private readonly DEFAULT_MEMORY_MB = 128;\n\n  constructor(\n    private readonly customInvocationsPerMonth?: number,\n    private readonly customAverageDurationMs?: number,\n  ) {}\n\n  supports(resourceType: string): boolean {\n    return resourceType === 'AWS::Lambda::Function';\n  }\n\n  async calculateCost(\n    resource: ResourceWithId,\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    const memorySize = (resource.properties.MemorySize as number) || this.DEFAULT_MEMORY_MB;\n    const invocations = this.customInvocationsPerMonth ?? this.DEFAULT_INVOCATIONS;\n    const durationMs = this.customAverageDurationMs ?? this.DEFAULT_DURATION_MS;\n\n    try {\n      const requestPrice = await pricingClient.getPrice({\n        serviceCode: 'AWSLambda',\n        region: this.normalizeRegion(region),\n        filters: [\n          { field: 'group', value: 'AWS-Lambda-Requests' },\n        ],\n      });\n\n      const computePrice = await pricingClient.getPrice({\n        serviceCode: 'AWSLambda',\n        region: this.normalizeRegion(region),\n        filters: [\n          { field: 'group', value: 'AWS-Lambda-Duration' },\n        ],\n      });\n\n      const assumptions = [\n        `Assumes ${invocations.toLocaleString()} invocations per month`,\n        `Assumes ${durationMs}ms average execution time`,\n        `Assumes ${memorySize}MB memory allocation`,\n      ];\n\n      if (this.customInvocationsPerMonth !== undefined) {\n        assumptions.push('Using custom invocation count assumption from configuration');\n      }\n      if (this.customAverageDurationMs !== undefined) {\n        assumptions.push('Using custom duration assumption from configuration');\n      }\n\n      if (requestPrice === null || computePrice === null) {\n        return {\n          amount: 0,\n          currency: 'USD',\n          confidence: 'unknown',\n          assumptions: [\n            `Pricing data not available for Lambda in region ${region}`,\n            ...assumptions,\n          ],\n        };\n      }\n\n      const requestCost = (invocations / 1000000) * requestPrice;\n\n      const gbSeconds = (memorySize / 1024) * (durationMs / 1000) * invocations;\n      const computeCost = gbSeconds * computePrice;\n\n      const totalCost = requestCost + computeCost;\n\n      return {\n        amount: totalCost,\n        currency: 'USD',\n        confidence: 'medium',\n        assumptions,\n      };\n    } catch (error) {\n      const assumptions = [\n        `Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`,\n        `Would assume ${invocations.toLocaleString()} invocations per month`,\n        `Would assume ${durationMs}ms average execution time`,\n        `Would assume ${memorySize}MB memory allocation`,\n      ];\n\n      if (this.customInvocationsPerMonth !== undefined) {\n        assumptions.push('Using custom invocation count assumption from configuration');\n      }\n      if (this.customAverageDurationMs !== undefined) {\n        assumptions.push('Using custom duration assumption from configuration');\n      }\n\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'unknown',\n        assumptions,\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/NLBCalculator.d.ts

@@ -0,0 +1,16 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+export declare class NLBCalculator implements ResourceCostCalculator {
+    private customNewConnectionsPerSecond?;
+    private customActiveConnectionsPerMinute?;
+    private customProcessedBytesGB?;
+    private readonly DEFAULT_NEW_CONNECTIONS_PER_SECOND;
+    private readonly DEFAULT_ACTIVE_CONNECTIONS_PER_MINUTE;
+    private readonly DEFAULT_PROCESSED_BYTES_GB;
+    private readonly HOURS_PER_MONTH;
+    constructor(customNewConnectionsPerSecond?: number | undefined, customActiveConnectionsPerMinute?: number | undefined, customProcessedBytesGB?: number | undefined);
+    supports(resourceType: string): boolean;
+    calculateCost(resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+    private normalizeRegion;
+    private getRegionPrefix;
+}