cdk-cost-analyzer 0.1.1

package/dist/pricing/calculators/VPCEndpointCalculator.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VPCEndpointCalculator = void 0;
+class VPCEndpointCalculator {
+    customDataProcessedGB;
+    DEFAULT_DATA_PROCESSED_GB = 100;
+    HOURS_PER_MONTH = 730;
+    constructor(customDataProcessedGB) {
+        this.customDataProcessedGB = customDataProcessedGB;
+    }
+    supports(resourceType) {
+        return resourceType === 'AWS::EC2::VPCEndpoint';
+    }
+    async calculateCost(resource, region, pricingClient) {
+        const explicitEndpointType = resource.properties?.VpcEndpointType;
+        const serviceName = resource.properties?.ServiceName || '';
+        // Determine if this is a Gateway endpoint
+        // Priority: explicit type > inferred from service name
+        const isGatewayEndpoint = explicitEndpointType === 'Gateway' ||
+            (explicitEndpointType === undefined &&
+                (serviceName.includes('s3') || serviceName.includes('dynamodb')));
+        // Gateway endpoints (S3 and DynamoDB) are free
+        if (isGatewayEndpoint) {
+            return {
+                amount: 0,
+                currency: 'USD',
+                confidence: 'high',
+                assumptions: [
+                    'Gateway VPC endpoints for S3 and DynamoDB are free',
+                    'No data processing charges for gateway endpoints',
+                ],
+            };
+        }
+        // Interface endpoints have hourly and data processing costs
+        try {
+            // Get hourly rate per endpoint
+            const hourlyRate = await pricingClient.getPrice({
+                serviceCode: 'AmazonVPC',
+                region: this.normalizeRegion(region),
+                filters: [
+                    { field: 'productFamily', value: 'VpcEndpoint' },
+                    { field: 'usagetype', value: `${this.getRegionPrefix(region)}VpcEndpoint-Hours` },
+                ],
+            });
+            // Get data processing rate
+            const dataProcessingRate = await pricingClient.getPrice({
+                serviceCode: 'AmazonVPC',
+                region: this.normalizeRegion(region),
+                filters: [
+                    { field: 'productFamily', value: 'VpcEndpoint' },
+                    { field: 'usagetype', value: `${this.getRegionPrefix(region)}VpcEndpoint-Bytes` },
+                ],
+            });
+            if (hourlyRate === null || dataProcessingRate === null) {
+                return {
+                    amount: 0,
+                    currency: 'USD',
+                    confidence: 'unknown',
+                    assumptions: [
+                        `Pricing data not available for VPC Endpoint in region ${region}`,
+                    ],
+                };
+            }
+            const dataProcessedGB = this.customDataProcessedGB || this.DEFAULT_DATA_PROCESSED_GB;
+            const hourlyCost = hourlyRate * this.HOURS_PER_MONTH;
+            const dataProcessingCost = dataProcessingRate * dataProcessedGB;
+            const totalCost = hourlyCost + dataProcessingCost;
+            return {
+                amount: totalCost,
+                currency: 'USD',
+                confidence: 'medium',
+                assumptions: [
+                    'Interface VPC Endpoint type',
+                    `Hourly rate: $${hourlyRate.toFixed(4)}/hour × ${this.HOURS_PER_MONTH} hours = $${hourlyCost.toFixed(2)}/month`,
+                    `Data processing: $${dataProcessingRate.toFixed(4)}/GB × ${dataProcessedGB} GB = $${dataProcessingCost.toFixed(2)}/month`,
+                    `Total: $${totalCost.toFixed(2)}/month`,
+                ],
+            };
+        }
+        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;
+    }
+    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.VPCEndpointCalculator = VPCEndpointCalculator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"VPCEndpointCalculator.js","sourceRoot":"","sources":["../../../src/pricing/calculators/VPCEndpointCalculator.ts"],"names":[],"mappings":"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","sourcesContent":["import { ResourceWithId } from '../../diff/types';\nimport { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';\n\nexport class VPCEndpointCalculator implements ResourceCostCalculator {\n  private readonly DEFAULT_DATA_PROCESSED_GB = 100;\n  private readonly HOURS_PER_MONTH = 730;\n\n  constructor(private customDataProcessedGB?: number) {}\n\n  supports(resourceType: string): boolean {\n    return resourceType === 'AWS::EC2::VPCEndpoint';\n  }\n\n  async calculateCost(\n    resource: ResourceWithId,\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    const explicitEndpointType = resource.properties?.VpcEndpointType as string | undefined;\n    const serviceName = (resource.properties?.ServiceName as string | undefined) || '';\n\n    // Determine if this is a Gateway endpoint\n    // Priority: explicit type > inferred from service name\n    const isGatewayEndpoint =\n      explicitEndpointType === 'Gateway' ||\n      (explicitEndpointType === undefined &&\n        (serviceName.includes('s3') || serviceName.includes('dynamodb')));\n\n    // Gateway endpoints (S3 and DynamoDB) are free\n    if (isGatewayEndpoint) {\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'high',\n        assumptions: [\n          'Gateway VPC endpoints for S3 and DynamoDB are free',\n          'No data processing charges for gateway endpoints',\n        ],\n      };\n    }\n\n    // Interface endpoints have hourly and data processing costs\n    try {\n      // Get hourly rate per endpoint\n      const hourlyRate = await pricingClient.getPrice({\n        serviceCode: 'AmazonVPC',\n        region: this.normalizeRegion(region),\n        filters: [\n          { field: 'productFamily', value: 'VpcEndpoint' },\n          { field: 'usagetype', value: `${this.getRegionPrefix(region)}VpcEndpoint-Hours` },\n        ],\n      });\n\n      // Get data processing rate\n      const dataProcessingRate = await pricingClient.getPrice({\n        serviceCode: 'AmazonVPC',\n        region: this.normalizeRegion(region),\n        filters: [\n          { field: 'productFamily', value: 'VpcEndpoint' },\n          { field: 'usagetype', value: `${this.getRegionPrefix(region)}VpcEndpoint-Bytes` },\n        ],\n      });\n\n      if (hourlyRate === null || dataProcessingRate === null) {\n        return {\n          amount: 0,\n          currency: 'USD',\n          confidence: 'unknown',\n          assumptions: [\n            `Pricing data not available for VPC Endpoint in region ${region}`,\n          ],\n        };\n      }\n\n      const dataProcessedGB = this.customDataProcessedGB || this.DEFAULT_DATA_PROCESSED_GB;\n      const hourlyCost = hourlyRate * this.HOURS_PER_MONTH;\n      const dataProcessingCost = dataProcessingRate * dataProcessedGB;\n      const totalCost = hourlyCost + dataProcessingCost;\n\n      return {\n        amount: totalCost,\n        currency: 'USD',\n        confidence: 'medium',\n        assumptions: [\n          'Interface VPC Endpoint type',\n          `Hourly rate: $${hourlyRate.toFixed(4)}/hour × ${this.HOURS_PER_MONTH} hours = $${hourlyCost.toFixed(2)}/month`,\n          `Data processing: $${dataProcessingRate.toFixed(4)}/GB × ${dataProcessedGB} GB = $${dataProcessingCost.toFixed(2)}/month`,\n          `Total: $${totalCost.toFixed(2)}/month`,\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  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/index.d.ts

@@ -0,0 +1,10 @@
+export { PricingService } from './PricingService';
+export { PricingClient } from './PricingClient';
+export { CacheManager } from './CacheManager';
+export { EC2Calculator } from './calculators/EC2Calculator';
+export { S3Calculator } from './calculators/S3Calculator';
+export { LambdaCalculator } from './calculators/LambdaCalculator';
+export { RDSCalculator } from './calculators/RDSCalculator';
+export { CloudFrontCalculator } from './calculators/CloudFrontCalculator';
+export { ElastiCacheCalculator } from './calculators/ElastiCacheCalculator';
+export * from './types';

package/dist/pricing/index.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElastiCacheCalculator = exports.CloudFrontCalculator = exports.RDSCalculator = exports.LambdaCalculator = exports.S3Calculator = exports.EC2Calculator = exports.CacheManager = exports.PricingClient = exports.PricingService = void 0;
+var PricingService_1 = require("./PricingService");
+Object.defineProperty(exports, "PricingService", { enumerable: true, get: function () { return PricingService_1.PricingService; } });
+var PricingClient_1 = require("./PricingClient");
+Object.defineProperty(exports, "PricingClient", { enumerable: true, get: function () { return PricingClient_1.PricingClient; } });
+var CacheManager_1 = require("./CacheManager");
+Object.defineProperty(exports, "CacheManager", { enumerable: true, get: function () { return CacheManager_1.CacheManager; } });
+var EC2Calculator_1 = require("./calculators/EC2Calculator");
+Object.defineProperty(exports, "EC2Calculator", { enumerable: true, get: function () { return EC2Calculator_1.EC2Calculator; } });
+var S3Calculator_1 = require("./calculators/S3Calculator");
+Object.defineProperty(exports, "S3Calculator", { enumerable: true, get: function () { return S3Calculator_1.S3Calculator; } });
+var LambdaCalculator_1 = require("./calculators/LambdaCalculator");
+Object.defineProperty(exports, "LambdaCalculator", { enumerable: true, get: function () { return LambdaCalculator_1.LambdaCalculator; } });
+var RDSCalculator_1 = require("./calculators/RDSCalculator");
+Object.defineProperty(exports, "RDSCalculator", { enumerable: true, get: function () { return RDSCalculator_1.RDSCalculator; } });
+var CloudFrontCalculator_1 = require("./calculators/CloudFrontCalculator");
+Object.defineProperty(exports, "CloudFrontCalculator", { enumerable: true, get: function () { return CloudFrontCalculator_1.CloudFrontCalculator; } });
+var ElastiCacheCalculator_1 = require("./calculators/ElastiCacheCalculator");
+Object.defineProperty(exports, "ElastiCacheCalculator", { enumerable: true, get: function () { return ElastiCacheCalculator_1.ElastiCacheCalculator; } });
+__exportStar(require("./types"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJpY2luZy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLG1EQUFrRDtBQUF6QyxnSEFBQSxjQUFjLE9BQUE7QUFDdkIsaURBQWdEO0FBQXZDLDhHQUFBLGFBQWEsT0FBQTtBQUN0QiwrQ0FBOEM7QUFBckMsNEdBQUEsWUFBWSxPQUFBO0FBQ3JCLDZEQUE0RDtBQUFuRCw4R0FBQSxhQUFhLE9BQUE7QUFDdEIsMkRBQTBEO0FBQWpELDRHQUFBLFlBQVksT0FBQTtBQUNyQixtRUFBa0U7QUFBekQsb0hBQUEsZ0JBQWdCLE9BQUE7QUFDekIsNkRBQTREO0FBQW5ELDhHQUFBLGFBQWEsT0FBQTtBQUN0QiwyRUFBMEU7QUFBakUsNEhBQUEsb0JBQW9CLE9BQUE7QUFDN0IsNkVBQTRFO0FBQW5FLDhIQUFBLHFCQUFxQixPQUFBO0FBQzlCLDBDQUF3QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IFByaWNpbmdTZXJ2aWNlIH0gZnJvbSAnLi9QcmljaW5nU2VydmljZSc7XG5leHBvcnQgeyBQcmljaW5nQ2xpZW50IH0gZnJvbSAnLi9QcmljaW5nQ2xpZW50JztcbmV4cG9ydCB7IENhY2hlTWFuYWdlciB9IGZyb20gJy4vQ2FjaGVNYW5hZ2VyJztcbmV4cG9ydCB7IEVDMkNhbGN1bGF0b3IgfSBmcm9tICcuL2NhbGN1bGF0b3JzL0VDMkNhbGN1bGF0b3InO1xuZXhwb3J0IHsgUzNDYWxjdWxhdG9yIH0gZnJvbSAnLi9jYWxjdWxhdG9ycy9TM0NhbGN1bGF0b3InO1xuZXhwb3J0IHsgTGFtYmRhQ2FsY3VsYXRvciB9IGZyb20gJy4vY2FsY3VsYXRvcnMvTGFtYmRhQ2FsY3VsYXRvcic7XG5leHBvcnQgeyBSRFNDYWxjdWxhdG9yIH0gZnJvbSAnLi9jYWxjdWxhdG9ycy9SRFNDYWxjdWxhdG9yJztcbmV4cG9ydCB7IENsb3VkRnJvbnRDYWxjdWxhdG9yIH0gZnJvbSAnLi9jYWxjdWxhdG9ycy9DbG91ZEZyb250Q2FsY3VsYXRvcic7XG5leHBvcnQgeyBFbGFzdGlDYWNoZUNhbGN1bGF0b3IgfSBmcm9tICcuL2NhbGN1bGF0b3JzL0VsYXN0aUNhY2hlQ2FsY3VsYXRvcic7XG5leHBvcnQgKiBmcm9tICcuL3R5cGVzJztcbiJdfQ==

package/dist/pricing/types.d.ts

@@ -0,0 +1,53 @@
+import { ResourceWithId, ResourceDiff } from '../diff/types';
+export interface PricingService {
+    getResourceCost(resource: ResourceWithId, region: string): Promise<MonthlyCost>;
+    getCostDelta(diff: ResourceDiff, region: string): Promise<CostDelta>;
+}
+export interface MonthlyCost {
+    amount: number;
+    currency: string;
+    confidence: 'high' | 'medium' | 'low' | 'unknown';
+    assumptions: string[];
+}
+export interface CostDelta {
+    totalDelta: number;
+    currency: string;
+    addedCosts: ResourceCost[];
+    removedCosts: ResourceCost[];
+    modifiedCosts: ModifiedResourceCost[];
+}
+export interface ResourceCost {
+    logicalId: string;
+    type: string;
+    monthlyCost: MonthlyCost;
+}
+export interface ModifiedResourceCost extends ResourceCost {
+    oldMonthlyCost: MonthlyCost;
+    newMonthlyCost: MonthlyCost;
+    costDelta: number;
+}
+export interface ResourceCostCalculator {
+    supports(resourceType: string): boolean;
+    calculateCost(resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+}
+export interface PricingClient {
+    getPrice(params: PriceQueryParams): Promise<number | null>;
+}
+export interface PriceQueryParams {
+    serviceCode: string;
+    region: string;
+    filters: PriceFilter[];
+}
+export interface PriceFilter {
+    field: string;
+    value: string;
+    type?: 'TERM_MATCH';
+}
+export declare class PricingAPIError extends Error {
+    retryable: boolean;
+    constructor(message: string, retryable?: boolean);
+}
+export declare class UnsupportedResourceError extends Error {
+    resourceType: string;
+    constructor(resourceType: string);
+}

package/dist/pricing/types.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsupportedResourceError = exports.PricingAPIError = void 0;
+class PricingAPIError extends Error {
+    retryable;
+    constructor(message, retryable = true) {
+        super(message);
+        this.retryable = retryable;
+        this.name = 'PricingAPIError';
+    }
+}
+exports.PricingAPIError = PricingAPIError;
+class UnsupportedResourceError extends Error {
+    resourceType;
+    constructor(resourceType) {
+        super(`Resource type ${resourceType} is not supported`);
+        this.resourceType = resourceType;
+        this.name = 'UnsupportedResourceError';
+    }
+}
+exports.UnsupportedResourceError = UnsupportedResourceError;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/releasetag.txt

@@ -0,0 +1 @@
+v0.1.1

package/dist/reporter/Reporter.d.ts

@@ -0,0 +1,18 @@
+import { Reporter as IReporter, ReportFormat, ReportOptions } from './types';
+import { CostDelta } from '../pricing/types';
+export declare class Reporter implements IReporter {
+    generateReport(costDelta: CostDelta, format: ReportFormat, options?: ReportOptions): string;
+    private generateTextReport;
+    private generateJsonReport;
+    private generateMarkdownReport;
+    private formatResourceLine;
+    private formatModifiedResourceLine;
+    private formatCurrency;
+    private formatDelta;
+    private formatConfigSummaryText;
+    private formatThresholdStatusText;
+    private formatConfigSummaryMarkdown;
+    private formatThresholdStatusMarkdown;
+    private getTopCostContributors;
+    private formatStackDetailsMarkdown;
+}