cdk-cost-analyzer 0.1.1

package/dist/pricing/PricingClient.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PricingClient = void 0;
+const client_pricing_1 = require("@aws-sdk/client-pricing");
+const types_1 = require("./types");
+class PricingClient {
+    cache = new Map();
+    client;
+    cacheManager;
+    constructor(region = 'us-east-1', cacheManager, awsClient) {
+        this.client = awsClient || new client_pricing_1.PricingClient({ region });
+        this.cacheManager = cacheManager;
+    }
+    /**
+     * Clean up resources and connections
+     */
+    destroy() {
+        this.cache.clear();
+        // AWS SDK v3 clients automatically clean up their connections
+        // but we can help by clearing references
+        if (this.client && typeof this.client.destroy === 'function') {
+            this.client.destroy();
+        }
+    }
+    async getPrice(params) {
+        const cacheKey = this.getCacheKey(params);
+        // Check in-memory cache first
+        if (this.cache.has(cacheKey)) {
+            return this.cache.get(cacheKey);
+        }
+        // Check persistent cache if cache manager is available
+        if (this.cacheManager) {
+            const cachedPrice = this.cacheManager.getCachedPrice(params);
+            if (cachedPrice !== null) {
+                // Store in memory cache for faster subsequent access
+                this.cache.set(cacheKey, cachedPrice);
+                return cachedPrice;
+            }
+        }
+        try {
+            const price = await this.fetchPriceWithRetry(params);
+            if (price !== null) {
+                // Store in both memory and persistent cache
+                this.cache.set(cacheKey, price);
+                if (this.cacheManager) {
+                    this.cacheManager.setCachedPrice(params, price);
+                }
+            }
+            return price;
+        }
+        catch (error) {
+            // On API failure, try to use cached data even if stale
+            if (this.cache.has(cacheKey)) {
+                return this.cache.get(cacheKey);
+            }
+            if (this.cacheManager) {
+                const cachedPrice = this.cacheManager.getCachedPrice(params);
+                if (cachedPrice !== null) {
+                    return cachedPrice;
+                }
+            }
+            return null;
+        }
+    }
+    async fetchPriceWithRetry(params, maxRetries = 3) {
+        let lastError = null;
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                return await this.fetchPrice(params);
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt < maxRetries - 1) {
+                    const delay = Math.pow(2, attempt) * 1000;
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                }
+            }
+        }
+        throw new types_1.PricingAPIError(`Failed to fetch pricing after ${maxRetries} attempts: ${lastError?.message}`, false);
+    }
+    async fetchPrice(params) {
+        const filters = params.filters.map(f => ({
+            Type: f.type || 'TERM_MATCH',
+            Field: f.field,
+            Value: f.value,
+        }));
+        const command = new client_pricing_1.GetProductsCommand({
+            ServiceCode: params.serviceCode,
+            Filters: filters,
+            MaxResults: 1,
+        });
+        const response = await this.client.send(command);
+        if (!response.PriceList || response.PriceList.length === 0) {
+            return null;
+        }
+        const priceItem = JSON.parse(response.PriceList[0]);
+        const onDemand = priceItem?.terms?.OnDemand;
+        if (!onDemand) {
+            return null;
+        }
+        const termKey = Object.keys(onDemand)[0];
+        const priceDimensions = onDemand[termKey]?.priceDimensions;
+        if (!priceDimensions) {
+            return null;
+        }
+        const dimensionKey = Object.keys(priceDimensions)[0];
+        const pricePerUnit = priceDimensions[dimensionKey]?.pricePerUnit?.USD;
+        if (!pricePerUnit) {
+            return null;
+        }
+        return parseFloat(pricePerUnit);
+    }
+    getCacheKey(params) {
+        const filterStr = params.filters
+            .map(f => `${f.field}:${f.value}`)
+            .sort()
+            .join('|');
+        return `${params.serviceCode}:${params.region}:${filterStr}`;
+    }
+}
+exports.PricingClient = PricingClient;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PricingClient.js","sourceRoot":"","sources":["../../src/pricing/PricingClient.ts"],"names":[],"mappings":"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","sourcesContent":["import { PricingClient as AWSPricingClient, GetProductsCommand } from '@aws-sdk/client-pricing';\nimport { CacheManager } from './CacheManager';\nimport { PricingClient as IPricingClient, PriceQueryParams, PricingAPIError } from './types';\n\nexport class PricingClient implements IPricingClient {\n  private cache: Map<string, number> = new Map();\n  private client: AWSPricingClient;\n  private cacheManager?: CacheManager;\n\n  constructor(\n    region: string = 'us-east-1',\n    cacheManager?: CacheManager,\n    awsClient?: AWSPricingClient,\n  ) {\n    this.client = awsClient || new AWSPricingClient({ region });\n    this.cacheManager = cacheManager;\n  }\n\n  /**\n   * Clean up resources and connections\n   */\n  destroy(): void {\n    this.cache.clear();\n    // AWS SDK v3 clients automatically clean up their connections\n    // but we can help by clearing references\n    if (this.client && typeof (this.client as any).destroy === 'function') {\n      (this.client as any).destroy();\n    }\n  }\n\n  async getPrice(params: PriceQueryParams): Promise<number | null> {\n    const cacheKey = this.getCacheKey(params);\n\n    // Check in-memory cache first\n    if (this.cache.has(cacheKey)) {\n      return this.cache.get(cacheKey)!;\n    }\n\n    // Check persistent cache if cache manager is available\n    if (this.cacheManager) {\n      const cachedPrice = this.cacheManager.getCachedPrice(params);\n      if (cachedPrice !== null) {\n        // Store in memory cache for faster subsequent access\n        this.cache.set(cacheKey, cachedPrice);\n        return cachedPrice;\n      }\n    }\n\n    try {\n      const price = await this.fetchPriceWithRetry(params);\n      if (price !== null) {\n        // Store in both memory and persistent cache\n        this.cache.set(cacheKey, price);\n        if (this.cacheManager) {\n          this.cacheManager.setCachedPrice(params, price);\n        }\n      }\n      return price;\n    } catch (error) {\n      // On API failure, try to use cached data even if stale\n      if (this.cache.has(cacheKey)) {\n        return this.cache.get(cacheKey)!;\n      }\n      if (this.cacheManager) {\n        const cachedPrice = this.cacheManager.getCachedPrice(params);\n        if (cachedPrice !== null) {\n          return cachedPrice;\n        }\n      }\n      return null;\n    }\n  }\n\n  private async fetchPriceWithRetry(params: PriceQueryParams, maxRetries: number = 3): Promise<number | null> {\n    let lastError: Error | null = null;\n\n    for (let attempt = 0; attempt < maxRetries; attempt++) {\n      try {\n        return await this.fetchPrice(params);\n      } catch (error) {\n        lastError = error as Error;\n        if (attempt < maxRetries - 1) {\n          const delay = Math.pow(2, attempt) * 1000;\n          await new Promise(resolve => setTimeout(resolve, delay));\n        }\n      }\n    }\n\n    throw new PricingAPIError(\n      `Failed to fetch pricing after ${maxRetries} attempts: ${lastError?.message}`,\n      false,\n    );\n  }\n\n  private async fetchPrice(params: PriceQueryParams): Promise<number | null> {\n    const filters = params.filters.map(f => ({\n      Type: f.type || 'TERM_MATCH',\n      Field: f.field,\n      Value: f.value,\n    }));\n\n    const command = new GetProductsCommand({\n      ServiceCode: params.serviceCode,\n      Filters: filters,\n      MaxResults: 1,\n    });\n\n    const response = await this.client.send(command);\n\n    if (!response.PriceList || response.PriceList.length === 0) {\n      return null;\n    }\n\n    const priceItem = JSON.parse(response.PriceList[0]);\n    const onDemand = priceItem?.terms?.OnDemand;\n\n    if (!onDemand) {\n      return null;\n    }\n\n    const termKey = Object.keys(onDemand)[0];\n    const priceDimensions = onDemand[termKey]?.priceDimensions;\n\n    if (!priceDimensions) {\n      return null;\n    }\n\n    const dimensionKey = Object.keys(priceDimensions)[0];\n    const pricePerUnit = priceDimensions[dimensionKey]?.pricePerUnit?.USD;\n\n    if (!pricePerUnit) {\n      return null;\n    }\n\n    return parseFloat(pricePerUnit);\n  }\n\n  private getCacheKey(params: PriceQueryParams): string {\n    const filterStr = params.filters\n      .map(f => `${f.field}:${f.value}`)\n      .sort()\n      .join('|');\n    return `${params.serviceCode}:${params.region}:${filterStr}`;\n  }\n}\n"]}

package/dist/pricing/PricingService.d.ts

@@ -0,0 +1,16 @@
+import { PricingClient } from './PricingClient';
+import { PricingService as IPricingService, MonthlyCost, CostDelta } from './types';
+import { UsageAssumptionsConfig, CacheConfig } from '../config/types';
+import { ResourceWithId, ResourceDiff } from '../diff/types';
+export declare class PricingService implements IPricingService {
+    private calculators;
+    private pricingClient;
+    private excludedResourceTypes;
+    constructor(region?: string, usageAssumptions?: UsageAssumptionsConfig, excludedResourceTypes?: string[], cacheConfig?: CacheConfig, pricingClient?: PricingClient);
+    getResourceCost(resource: ResourceWithId, region: string): Promise<MonthlyCost>;
+    getCostDelta(diff: ResourceDiff, region: string): Promise<CostDelta>;
+    /**
+     * Clean up resources and connections
+     */
+    destroy(): void;
+}

package/dist/pricing/PricingService.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PricingService = void 0;
+const CacheManager_1 = require("./CacheManager");
+const ALBCalculator_1 = require("./calculators/ALBCalculator");
+const APIGatewayCalculator_1 = require("./calculators/APIGatewayCalculator");
+const CloudFrontCalculator_1 = require("./calculators/CloudFrontCalculator");
+const DynamoDBCalculator_1 = require("./calculators/DynamoDBCalculator");
+const EC2Calculator_1 = require("./calculators/EC2Calculator");
+const ECSCalculator_1 = require("./calculators/ECSCalculator");
+const ElastiCacheCalculator_1 = require("./calculators/ElastiCacheCalculator");
+const LambdaCalculator_1 = require("./calculators/LambdaCalculator");
+const NatGatewayCalculator_1 = require("./calculators/NatGatewayCalculator");
+const NLBCalculator_1 = require("./calculators/NLBCalculator");
+const RDSCalculator_1 = require("./calculators/RDSCalculator");
+const S3Calculator_1 = require("./calculators/S3Calculator");
+const VPCEndpointCalculator_1 = require("./calculators/VPCEndpointCalculator");
+const PricingClient_1 = require("./PricingClient");
+class PricingService {
+    calculators;
+    pricingClient;
+    excludedResourceTypes;
+    constructor(region = 'us-east-1', usageAssumptions, excludedResourceTypes, cacheConfig, pricingClient) {
+        // Use provided pricing client or create a new one
+        if (pricingClient) {
+            this.pricingClient = pricingClient;
+        }
+        else {
+            // Initialize cache manager if caching is enabled
+            let cacheManager;
+            if (cacheConfig?.enabled !== false) {
+                const cacheDuration = cacheConfig?.durationHours ?? 24;
+                cacheManager = new CacheManager_1.CacheManager('.cdk-cost-analyzer-cache', cacheDuration);
+            }
+            this.pricingClient = new PricingClient_1.PricingClient(region, cacheManager);
+        }
+        this.excludedResourceTypes = new Set(excludedResourceTypes || []);
+        this.calculators = [
+            new EC2Calculator_1.EC2Calculator(),
+            new S3Calculator_1.S3Calculator(),
+            new LambdaCalculator_1.LambdaCalculator(usageAssumptions?.lambda?.invocationsPerMonth, usageAssumptions?.lambda?.averageDurationMs),
+            new RDSCalculator_1.RDSCalculator(),
+            new DynamoDBCalculator_1.DynamoDBCalculator(),
+            new ECSCalculator_1.ECSCalculator(),
+            new APIGatewayCalculator_1.APIGatewayCalculator(),
+            new NatGatewayCalculator_1.NatGatewayCalculator(usageAssumptions?.natGateway?.dataProcessedGB),
+            new ALBCalculator_1.ALBCalculator(usageAssumptions?.alb?.newConnectionsPerSecond, usageAssumptions?.alb?.activeConnectionsPerMinute, usageAssumptions?.alb?.processedBytesGB),
+            new NLBCalculator_1.NLBCalculator(usageAssumptions?.nlb?.newConnectionsPerSecond, usageAssumptions?.nlb?.activeConnectionsPerMinute, usageAssumptions?.nlb?.processedBytesGB),
+            new VPCEndpointCalculator_1.VPCEndpointCalculator(usageAssumptions?.vpcEndpoint?.dataProcessedGB),
+            new CloudFrontCalculator_1.CloudFrontCalculator(usageAssumptions?.cloudfront?.dataTransferGB, usageAssumptions?.cloudfront?.requests),
+            new ElastiCacheCalculator_1.ElastiCacheCalculator(),
+        ];
+    }
+    async getResourceCost(resource, region) {
+        // Check if resource type is excluded
+        if (this.excludedResourceTypes.has(resource.type)) {
+            return {
+                amount: 0,
+                currency: 'USD',
+                confidence: 'high',
+                assumptions: [`Resource type ${resource.type} is excluded from cost analysis`],
+            };
+        }
+        const calculator = this.calculators.find(calc => calc.supports(resource.type));
+        if (!calculator) {
+            return {
+                amount: 0,
+                currency: 'USD',
+                confidence: 'unknown',
+                assumptions: [`Resource type ${resource.type} is not supported`],
+            };
+        }
+        try {
+            return await calculator.calculateCost(resource, region, this.pricingClient);
+        }
+        catch (error) {
+            return {
+                amount: 0,
+                currency: 'USD',
+                confidence: 'unknown',
+                assumptions: [`Failed to calculate cost: ${error instanceof Error ? error.message : String(error)}`],
+            };
+        }
+    }
+    async getCostDelta(diff, region) {
+        // Filter out excluded resources before processing
+        const filteredAdded = diff.added.filter(r => !this.excludedResourceTypes.has(r.type));
+        const filteredRemoved = diff.removed.filter(r => !this.excludedResourceTypes.has(r.type));
+        const filteredModified = diff.modified.filter(r => !this.excludedResourceTypes.has(r.type));
+        const addedCosts = await Promise.all(filteredAdded.map(async (resource) => {
+            const monthlyCost = await this.getResourceCost(resource, region);
+            return {
+                logicalId: resource.logicalId,
+                type: resource.type,
+                monthlyCost,
+            };
+        }));
+        const removedCosts = await Promise.all(filteredRemoved.map(async (resource) => {
+            const monthlyCost = await this.getResourceCost(resource, region);
+            return {
+                logicalId: resource.logicalId,
+                type: resource.type,
+                monthlyCost,
+            };
+        }));
+        const modifiedCosts = await Promise.all(filteredModified.map(async (resource) => {
+            const oldResource = {
+                logicalId: resource.logicalId,
+                type: resource.type,
+                properties: resource.oldProperties,
+            };
+            const newResource = {
+                logicalId: resource.logicalId,
+                type: resource.type,
+                properties: resource.newProperties,
+            };
+            const oldMonthlyCost = await this.getResourceCost(oldResource, region);
+            const newMonthlyCost = await this.getResourceCost(newResource, region);
+            const costDelta = newMonthlyCost.amount - oldMonthlyCost.amount;
+            return {
+                logicalId: resource.logicalId,
+                type: resource.type,
+                monthlyCost: newMonthlyCost,
+                oldMonthlyCost,
+                newMonthlyCost,
+                costDelta,
+            };
+        }));
+        const totalAddedCost = addedCosts.reduce((sum, r) => sum + r.monthlyCost.amount, 0);
+        const totalRemovedCost = removedCosts.reduce((sum, r) => sum + r.monthlyCost.amount, 0);
+        const totalModifiedDelta = modifiedCosts.reduce((sum, r) => sum + r.costDelta, 0);
+        const totalDelta = totalAddedCost - totalRemovedCost + totalModifiedDelta;
+        return {
+            totalDelta,
+            currency: 'USD',
+            addedCosts,
+            removedCosts,
+            modifiedCosts,
+        };
+    }
+    /**
+     * Clean up resources and connections
+     */
+    destroy() {
+        this.pricingClient.destroy();
+    }
+}
+exports.PricingService = PricingService;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PricingService.js","sourceRoot":"","sources":["../../src/pricing/PricingService.ts"],"names":[],"mappings":"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","sourcesContent":["import { CacheManager } from './CacheManager';\nimport { ALBCalculator } from './calculators/ALBCalculator';\nimport { APIGatewayCalculator } from './calculators/APIGatewayCalculator';\nimport { CloudFrontCalculator } from './calculators/CloudFrontCalculator';\nimport { DynamoDBCalculator } from './calculators/DynamoDBCalculator';\nimport { EC2Calculator } from './calculators/EC2Calculator';\nimport { ECSCalculator } from './calculators/ECSCalculator';\nimport { ElastiCacheCalculator } from './calculators/ElastiCacheCalculator';\nimport { LambdaCalculator } from './calculators/LambdaCalculator';\nimport { NatGatewayCalculator } from './calculators/NatGatewayCalculator';\nimport { NLBCalculator } from './calculators/NLBCalculator';\nimport { RDSCalculator } from './calculators/RDSCalculator';\nimport { S3Calculator } from './calculators/S3Calculator';\nimport { VPCEndpointCalculator } from './calculators/VPCEndpointCalculator';\nimport { PricingClient } from './PricingClient';\nimport {\n  PricingService as IPricingService,\n  MonthlyCost,\n  CostDelta,\n  ResourceCostCalculator,\n} from './types';\nimport { UsageAssumptionsConfig, CacheConfig } from '../config/types';\nimport { ResourceWithId, ResourceDiff } from '../diff/types';\n\nexport class PricingService implements IPricingService {\n  private calculators: ResourceCostCalculator[];\n  private pricingClient: PricingClient;\n  private excludedResourceTypes: Set<string>;\n\n  constructor(\n    region: string = 'us-east-1',\n    usageAssumptions?: UsageAssumptionsConfig,\n    excludedResourceTypes?: string[],\n    cacheConfig?: CacheConfig,\n    pricingClient?: PricingClient,\n  ) {\n    // Use provided pricing client or create a new one\n    if (pricingClient) {\n      this.pricingClient = pricingClient;\n    } else {\n      // Initialize cache manager if caching is enabled\n      let cacheManager: CacheManager | undefined;\n      if (cacheConfig?.enabled !== false) {\n        const cacheDuration = cacheConfig?.durationHours ?? 24;\n        cacheManager = new CacheManager('.cdk-cost-analyzer-cache', cacheDuration);\n      }\n\n      this.pricingClient = new PricingClient(region, cacheManager);\n    }\n    this.excludedResourceTypes = new Set(excludedResourceTypes || []);\n    this.calculators = [\n      new EC2Calculator(),\n      new S3Calculator(),\n      new LambdaCalculator(\n        usageAssumptions?.lambda?.invocationsPerMonth,\n        usageAssumptions?.lambda?.averageDurationMs,\n      ),\n      new RDSCalculator(),\n      new DynamoDBCalculator(),\n      new ECSCalculator(),\n      new APIGatewayCalculator(),\n      new NatGatewayCalculator(usageAssumptions?.natGateway?.dataProcessedGB),\n      new ALBCalculator(\n        usageAssumptions?.alb?.newConnectionsPerSecond,\n        usageAssumptions?.alb?.activeConnectionsPerMinute,\n        usageAssumptions?.alb?.processedBytesGB,\n      ),\n      new NLBCalculator(\n        usageAssumptions?.nlb?.newConnectionsPerSecond,\n        usageAssumptions?.nlb?.activeConnectionsPerMinute,\n        usageAssumptions?.nlb?.processedBytesGB,\n      ),\n      new VPCEndpointCalculator(usageAssumptions?.vpcEndpoint?.dataProcessedGB),\n      new CloudFrontCalculator(\n        usageAssumptions?.cloudfront?.dataTransferGB,\n        usageAssumptions?.cloudfront?.requests,\n      ),\n      new ElastiCacheCalculator(),\n    ];\n  }\n\n  async getResourceCost(resource: ResourceWithId, region: string): Promise<MonthlyCost> {\n    // Check if resource type is excluded\n    if (this.excludedResourceTypes.has(resource.type)) {\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'high',\n        assumptions: [`Resource type ${resource.type} is excluded from cost analysis`],\n      };\n    }\n\n    const calculator = this.calculators.find(calc => calc.supports(resource.type));\n\n    if (!calculator) {\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'unknown',\n        assumptions: [`Resource type ${resource.type} is not supported`],\n      };\n    }\n\n    try {\n      return await calculator.calculateCost(resource, region, this.pricingClient);\n    } catch (error) {\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'unknown',\n        assumptions: [`Failed to calculate cost: ${error instanceof Error ? error.message : String(error)}`],\n      };\n    }\n  }\n\n  async getCostDelta(diff: ResourceDiff, region: string): Promise<CostDelta> {\n    // Filter out excluded resources before processing\n    const filteredAdded = diff.added.filter(r => !this.excludedResourceTypes.has(r.type));\n    const filteredRemoved = diff.removed.filter(r => !this.excludedResourceTypes.has(r.type));\n    const filteredModified = diff.modified.filter(r => !this.excludedResourceTypes.has(r.type));\n\n    const addedCosts = await Promise.all(\n      filteredAdded.map(async (resource) => {\n        const monthlyCost = await this.getResourceCost(resource, region);\n        return {\n          logicalId: resource.logicalId,\n          type: resource.type,\n          monthlyCost,\n        };\n      }),\n    );\n\n    const removedCosts = await Promise.all(\n      filteredRemoved.map(async (resource) => {\n        const monthlyCost = await this.getResourceCost(resource, region);\n        return {\n          logicalId: resource.logicalId,\n          type: resource.type,\n          monthlyCost,\n        };\n      }),\n    );\n\n    const modifiedCosts = await Promise.all(\n      filteredModified.map(async (resource) => {\n        const oldResource: ResourceWithId = {\n          logicalId: resource.logicalId,\n          type: resource.type,\n          properties: resource.oldProperties,\n        };\n        const newResource: ResourceWithId = {\n          logicalId: resource.logicalId,\n          type: resource.type,\n          properties: resource.newProperties,\n        };\n\n        const oldMonthlyCost = await this.getResourceCost(oldResource, region);\n        const newMonthlyCost = await this.getResourceCost(newResource, region);\n        const costDelta = newMonthlyCost.amount - oldMonthlyCost.amount;\n\n        return {\n          logicalId: resource.logicalId,\n          type: resource.type,\n          monthlyCost: newMonthlyCost,\n          oldMonthlyCost,\n          newMonthlyCost,\n          costDelta,\n        };\n      }),\n    );\n\n    const totalAddedCost = addedCosts.reduce((sum, r) => sum + r.monthlyCost.amount, 0);\n    const totalRemovedCost = removedCosts.reduce((sum, r) => sum + r.monthlyCost.amount, 0);\n    const totalModifiedDelta = modifiedCosts.reduce((sum, r) => sum + r.costDelta, 0);\n\n    const totalDelta = totalAddedCost - totalRemovedCost + totalModifiedDelta;\n\n    return {\n      totalDelta,\n      currency: 'USD',\n      addedCosts,\n      removedCosts,\n      modifiedCosts,\n    };\n  }\n\n  /**\n   * Clean up resources and connections\n   */\n  destroy(): void {\n    this.pricingClient.destroy();\n  }\n}\n"]}

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

@@ -0,0 +1,16 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+export declare class ALBCalculator 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;
+}

package/dist/pricing/calculators/ALBCalculator.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALBCalculator = void 0;
+class ALBCalculator {
+    customNewConnectionsPerSecond;
+    customActiveConnectionsPerMinute;
+    customProcessedBytesGB;
+    DEFAULT_NEW_CONNECTIONS_PER_SECOND = 25;
+    DEFAULT_ACTIVE_CONNECTIONS_PER_MINUTE = 3000;
+    DEFAULT_PROCESSED_BYTES_GB = 100;
+    HOURS_PER_MONTH = 730;
+    constructor(customNewConnectionsPerSecond, customActiveConnectionsPerMinute, customProcessedBytesGB) {
+        this.customNewConnectionsPerSecond = customNewConnectionsPerSecond;
+        this.customActiveConnectionsPerMinute = customActiveConnectionsPerMinute;
+        this.customProcessedBytesGB = customProcessedBytesGB;
+    }
+    supports(resourceType) {
+        return resourceType === 'AWS::ElasticLoadBalancingV2::LoadBalancer';
+    }
+    async calculateCost(resource, region, pricingClient) {
+        // Check if this is an Application Load Balancer (not Network Load Balancer)
+        const loadBalancerType = resource.properties?.Type;
+        if (loadBalancerType && loadBalancerType !== 'application') {
+            return {
+                amount: 0,
+                currency: 'USD',
+                confidence: 'unknown',
+                assumptions: ['This calculator only supports Application Load Balancers'],
+            };
+        }
+        try {
+            // Get hourly rate
+            const hourlyRate = await pricingClient.getPrice({
+                serviceCode: 'AWSELB',
+                region: this.normalizeRegion(region),
+                filters: [
+                    { field: 'productFamily', value: 'Load Balancer-Application' },
+                    { field: 'usagetype', value: `${this.getRegionPrefix(region)}LoadBalancerUsage` },
+                ],
+            });
+            // Get LCU rate
+            const lcuRate = await pricingClient.getPrice({
+                serviceCode: 'AWSELB',
+                region: this.normalizeRegion(region),
+                filters: [
+                    { field: 'productFamily', value: 'Load Balancer-Application' },
+                    { field: 'usagetype', value: `${this.getRegionPrefix(region)}LCUUsage` },
+                ],
+            });
+            const newConnectionsPerSecond = this.customNewConnectionsPerSecond || this.DEFAULT_NEW_CONNECTIONS_PER_SECOND;
+            const activeConnectionsPerMinute = this.customActiveConnectionsPerMinute || this.DEFAULT_ACTIVE_CONNECTIONS_PER_MINUTE;
+            const processedBytesGB = this.customProcessedBytesGB || this.DEFAULT_PROCESSED_BYTES_GB;
+            if (hourlyRate === null || lcuRate === null) {
+                // Calculate LCU consumption for assumptions even when pricing fails
+                const lcuFromNewConnections = newConnectionsPerSecond / 25;
+                const lcuFromActiveConnections = activeConnectionsPerMinute / 3000;
+                const gbPerHour = processedBytesGB / this.HOURS_PER_MONTH;
+                const lcuFromProcessedBytes = gbPerHour;
+                const lcuPerHour = Math.max(lcuFromNewConnections, lcuFromActiveConnections, lcuFromProcessedBytes);
+                return {
+                    amount: 0,
+                    currency: 'USD',
+                    confidence: 'unknown',
+                    assumptions: [
+                        `Pricing data not available for Application Load Balancer in region ${region}`,
+                        `Would use LCU consumption: ${lcuPerHour.toFixed(2)} LCU/hour based on:`,
+                        `  - New connections: ${newConnectionsPerSecond}/sec → ${lcuFromNewConnections.toFixed(2)} LCU`,
+                        `  - Active connections: ${activeConnectionsPerMinute}/min → ${lcuFromActiveConnections.toFixed(2)} LCU`,
+                        `  - Processed data: ${processedBytesGB} GB/month → ${lcuFromProcessedBytes.toFixed(2)} LCU`,
+                    ],
+                };
+            }
+            // Calculate LCU consumption
+            // 1 LCU provides: 25 new connections/sec, 3000 active connections/min, 1 GB processed/hour, 1000 rule evaluations/sec
+            const lcuFromNewConnections = newConnectionsPerSecond / 25;
+            const lcuFromActiveConnections = activeConnectionsPerMinute / 3000;
+            const gbPerHour = processedBytesGB / this.HOURS_PER_MONTH;
+            const lcuFromProcessedBytes = gbPerHour;
+            // Use the highest LCU consumption
+            const lcuPerHour = Math.max(lcuFromNewConnections, lcuFromActiveConnections, lcuFromProcessedBytes);
+            const hourlyCost = hourlyRate * this.HOURS_PER_MONTH;
+            const lcuCost = lcuRate * lcuPerHour * this.HOURS_PER_MONTH;
+            const totalCost = hourlyCost + lcuCost;
+            return {
+                amount: totalCost,
+                currency: 'USD',
+                confidence: 'medium',
+                assumptions: [
+                    `Hourly rate: $${hourlyRate.toFixed(4)}/hour × ${this.HOURS_PER_MONTH} hours = $${hourlyCost.toFixed(2)}/month`,
+                    `LCU consumption: ${lcuPerHour.toFixed(2)} LCU/hour based on:`,
+                    `  - New connections: ${newConnectionsPerSecond}/sec → ${lcuFromNewConnections.toFixed(2)} LCU`,
+                    `  - Active connections: ${activeConnectionsPerMinute}/min → ${lcuFromActiveConnections.toFixed(2)} LCU`,
+                    `  - Processed data: ${processedBytesGB} GB/month → ${lcuFromProcessedBytes.toFixed(2)} LCU`,
+                    `LCU cost: $${lcuRate.toFixed(4)}/LCU/hour × ${lcuPerHour.toFixed(2)} LCU × ${this.HOURS_PER_MONTH} hours = $${lcuCost.toFixed(2)}/month`,
+                    `Total: $${totalCost.toFixed(2)}/month`,
+                ],
+            };
+        }
+        catch (error) {
+            const newConnectionsPerSecond = this.customNewConnectionsPerSecond || this.DEFAULT_NEW_CONNECTIONS_PER_SECOND;
+            const activeConnectionsPerMinute = this.customActiveConnectionsPerMinute || this.DEFAULT_ACTIVE_CONNECTIONS_PER_MINUTE;
+            const processedBytesGB = this.customProcessedBytesGB || this.DEFAULT_PROCESSED_BYTES_GB;
+            // Calculate LCU consumption for assumptions even when error occurs
+            const lcuFromNewConnections = newConnectionsPerSecond / 25;
+            const lcuFromActiveConnections = activeConnectionsPerMinute / 3000;
+            const gbPerHour = processedBytesGB / this.HOURS_PER_MONTH;
+            const lcuFromProcessedBytes = gbPerHour;
+            const lcuPerHour = Math.max(lcuFromNewConnections, lcuFromActiveConnections, lcuFromProcessedBytes);
+            return {
+                amount: 0,
+                currency: 'USD',
+                confidence: 'unknown',
+                assumptions: [
+                    `Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`,
+                    `Would use LCU consumption: ${lcuPerHour.toFixed(2)} LCU/hour based on:`,
+                    `  - New connections: ${newConnectionsPerSecond}/sec → ${lcuFromNewConnections.toFixed(2)} LCU`,
+                    `  - Active connections: ${activeConnectionsPerMinute}/min → ${lcuFromActiveConnections.toFixed(2)} LCU`,
+                    `  - Processed data: ${processedBytesGB} GB/month → ${lcuFromProcessedBytes.toFixed(2)} LCU`,
+                ],
+            };
+        }
+    }
+    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;
+    }
+    getRegionPrefix(region) {
+        const prefixMap = {
+            'us-east-1': 'USE1',
+            'us-east-2': 'USE2',
+            'us-west-1': 'USW1',
+            'us-west-2': 'USW2',
+            'eu-west-1': 'EUW1',
+            'eu-west-2': 'EUW2',
+            'eu-west-3': 'EUW3',
+            'eu-central-1': 'EUC1',
+            'eu-north-1': 'EUN1',
+            'ap-south-1': 'APS1',
+            'ap-southeast-1': 'APS2',
+            'ap-southeast-2': 'APS3',
+            'ap-northeast-1': 'APN1',
+            'ap-northeast-2': 'APN2',
+        };
+        return prefixMap[region] || '';
+    }
+}
+exports.ALBCalculator = ALBCalculator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ALBCalculator.js","sourceRoot":"","sources":["../../../src/pricing/calculators/ALBCalculator.ts"],"names":[],"mappings":"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","sourcesContent":["import { ResourceWithId } from '../../diff/types';\nimport { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';\n\nexport class ALBCalculator implements ResourceCostCalculator {\n  private readonly DEFAULT_NEW_CONNECTIONS_PER_SECOND = 25;\n  private readonly DEFAULT_ACTIVE_CONNECTIONS_PER_MINUTE = 3000;\n  private readonly DEFAULT_PROCESSED_BYTES_GB = 100;\n  private readonly HOURS_PER_MONTH = 730;\n\n  constructor(\n    private customNewConnectionsPerSecond?: number,\n    private customActiveConnectionsPerMinute?: number,\n    private customProcessedBytesGB?: number,\n  ) {}\n\n  supports(resourceType: string): boolean {\n    return resourceType === 'AWS::ElasticLoadBalancingV2::LoadBalancer';\n  }\n\n  async calculateCost(\n    resource: ResourceWithId,\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    // Check if this is an Application Load Balancer (not Network Load Balancer)\n    const loadBalancerType = resource.properties?.Type;\n    if (loadBalancerType && loadBalancerType !== 'application') {\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'unknown',\n        assumptions: ['This calculator only supports Application Load Balancers'],\n      };\n    }\n\n    try {\n      // Get hourly rate\n      const hourlyRate = await pricingClient.getPrice({\n        serviceCode: 'AWSELB',\n        region: this.normalizeRegion(region),\n        filters: [\n          { field: 'productFamily', value: 'Load Balancer-Application' },\n          { field: 'usagetype', value: `${this.getRegionPrefix(region)}LoadBalancerUsage` },\n        ],\n      });\n\n      // Get LCU rate\n      const lcuRate = await pricingClient.getPrice({\n        serviceCode: 'AWSELB',\n        region: this.normalizeRegion(region),\n        filters: [\n          { field: 'productFamily', value: 'Load Balancer-Application' },\n          { field: 'usagetype', value: `${this.getRegionPrefix(region)}LCUUsage` },\n        ],\n      });\n\n      const newConnectionsPerSecond =\n        this.customNewConnectionsPerSecond || this.DEFAULT_NEW_CONNECTIONS_PER_SECOND;\n      const activeConnectionsPerMinute =\n        this.customActiveConnectionsPerMinute || this.DEFAULT_ACTIVE_CONNECTIONS_PER_MINUTE;\n      const processedBytesGB =\n        this.customProcessedBytesGB || this.DEFAULT_PROCESSED_BYTES_GB;\n\n      if (hourlyRate === null || lcuRate === null) {\n        // Calculate LCU consumption for assumptions even when pricing fails\n        const lcuFromNewConnections = newConnectionsPerSecond / 25;\n        const lcuFromActiveConnections = activeConnectionsPerMinute / 3000;\n        const gbPerHour = processedBytesGB / this.HOURS_PER_MONTH;\n        const lcuFromProcessedBytes = gbPerHour;\n        const lcuPerHour = Math.max(\n          lcuFromNewConnections,\n          lcuFromActiveConnections,\n          lcuFromProcessedBytes,\n        );\n\n        return {\n          amount: 0,\n          currency: 'USD',\n          confidence: 'unknown',\n          assumptions: [\n            `Pricing data not available for Application Load Balancer in region ${region}`,\n            `Would use LCU consumption: ${lcuPerHour.toFixed(2)} LCU/hour based on:`,\n            `  - New connections: ${newConnectionsPerSecond}/sec → ${lcuFromNewConnections.toFixed(2)} LCU`,\n            `  - Active connections: ${activeConnectionsPerMinute}/min → ${lcuFromActiveConnections.toFixed(2)} LCU`,\n            `  - Processed data: ${processedBytesGB} GB/month → ${lcuFromProcessedBytes.toFixed(2)} LCU`,\n          ],\n        };\n      }\n\n      // Calculate LCU consumption\n      // 1 LCU provides: 25 new connections/sec, 3000 active connections/min, 1 GB processed/hour, 1000 rule evaluations/sec\n      const lcuFromNewConnections = newConnectionsPerSecond / 25;\n      const lcuFromActiveConnections = activeConnectionsPerMinute / 3000;\n      const gbPerHour = processedBytesGB / this.HOURS_PER_MONTH;\n      const lcuFromProcessedBytes = gbPerHour;\n\n      // Use the highest LCU consumption\n      const lcuPerHour = Math.max(\n        lcuFromNewConnections,\n        lcuFromActiveConnections,\n        lcuFromProcessedBytes,\n      );\n\n      const hourlyCost = hourlyRate * this.HOURS_PER_MONTH;\n      const lcuCost = lcuRate * lcuPerHour * this.HOURS_PER_MONTH;\n      const totalCost = hourlyCost + lcuCost;\n\n      return {\n        amount: totalCost,\n        currency: 'USD',\n        confidence: 'medium',\n        assumptions: [\n          `Hourly rate: $${hourlyRate.toFixed(4)}/hour × ${this.HOURS_PER_MONTH} hours = $${hourlyCost.toFixed(2)}/month`,\n          `LCU consumption: ${lcuPerHour.toFixed(2)} LCU/hour based on:`,\n          `  - New connections: ${newConnectionsPerSecond}/sec → ${lcuFromNewConnections.toFixed(2)} LCU`,\n          `  - Active connections: ${activeConnectionsPerMinute}/min → ${lcuFromActiveConnections.toFixed(2)} LCU`,\n          `  - Processed data: ${processedBytesGB} GB/month → ${lcuFromProcessedBytes.toFixed(2)} LCU`,\n          `LCU cost: $${lcuRate.toFixed(4)}/LCU/hour × ${lcuPerHour.toFixed(2)} LCU × ${this.HOURS_PER_MONTH} hours = $${lcuCost.toFixed(2)}/month`,\n          `Total: $${totalCost.toFixed(2)}/month`,\n        ],\n      };\n    } catch (error) {\n      const newConnectionsPerSecond =\n        this.customNewConnectionsPerSecond || this.DEFAULT_NEW_CONNECTIONS_PER_SECOND;\n      const activeConnectionsPerMinute =\n        this.customActiveConnectionsPerMinute || this.DEFAULT_ACTIVE_CONNECTIONS_PER_MINUTE;\n      const processedBytesGB =\n        this.customProcessedBytesGB || this.DEFAULT_PROCESSED_BYTES_GB;\n\n      // Calculate LCU consumption for assumptions even when error occurs\n      const lcuFromNewConnections = newConnectionsPerSecond / 25;\n      const lcuFromActiveConnections = activeConnectionsPerMinute / 3000;\n      const gbPerHour = processedBytesGB / this.HOURS_PER_MONTH;\n      const lcuFromProcessedBytes = gbPerHour;\n      const lcuPerHour = Math.max(\n        lcuFromNewConnections,\n        lcuFromActiveConnections,\n        lcuFromProcessedBytes,\n      );\n\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          `Would use LCU consumption: ${lcuPerHour.toFixed(2)} LCU/hour based on:`,\n          `  - New connections: ${newConnectionsPerSecond}/sec → ${lcuFromNewConnections.toFixed(2)} LCU`,\n          `  - Active connections: ${activeConnectionsPerMinute}/min → ${lcuFromActiveConnections.toFixed(2)} LCU`,\n          `  - Processed data: ${processedBytesGB} GB/month → ${lcuFromProcessedBytes.toFixed(2)} LCU`,\n        ],\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  private getRegionPrefix(region: string): string {\n    const prefixMap: Record<string, string> = {\n      'us-east-1': 'USE1',\n      'us-east-2': 'USE2',\n      'us-west-1': 'USW1',\n      'us-west-2': 'USW2',\n      'eu-west-1': 'EUW1',\n      'eu-west-2': 'EUW2',\n      'eu-west-3': 'EUW3',\n      'eu-central-1': 'EUC1',\n      'eu-north-1': 'EUN1',\n      'ap-south-1': 'APS1',\n      'ap-southeast-1': 'APS2',\n      'ap-southeast-2': 'APS3',\n      'ap-northeast-1': 'APN1',\n      'ap-northeast-2': 'APN2',\n    };\n\n    return prefixMap[region] || '';\n  }\n}\n"]}

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

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