cdk-cost-analyzer 0.1.39 → 0.1.41

package/dist/action/pricing/calculators/AuroraServerlessCalculator.d.ts

@@ -0,0 +1,20 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+export declare class AuroraServerlessCalculator implements ResourceCostCalculator {
+    private readonly customMinACU?;
+    private readonly customMaxACU?;
+    private readonly customStorageGB?;
+    private readonly HOURS_PER_MONTH;
+    private readonly DEFAULT_MIN_ACU;
+    private readonly DEFAULT_MAX_ACU;
+    private readonly DEFAULT_STORAGE_GB;
+    private readonly DEFAULT_MONTHLY_IO_REQUESTS;
+    private readonly FALLBACK_ACU_PRICE_V2;
+    private readonly FALLBACK_ACU_PRICE_V1;
+    private readonly STORAGE_PRICE_PER_GB;
+    private readonly IO_PRICE_PER_MILLION;
+    constructor(customMinACU?: number | undefined, customMaxACU?: number | undefined, customStorageGB?: number | undefined);
+    supports(resourceType: string): boolean;
+    canCalculate(resource: ResourceWithId): boolean;
+    calculateCost(resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+}

package/dist/action/pricing/calculators/EKSCalculator.d.ts

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

package/dist/action/pricing/calculators/KinesisCalculator.d.ts

@@ -0,0 +1,27 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+export declare class KinesisCalculator implements ResourceCostCalculator {
+    private readonly customShardCount?;
+    private readonly customIngestionGB?;
+    private readonly customRetrievalGB?;
+    private readonly customFirehoseGB?;
+    private readonly customKPUs?;
+    private readonly HOURS_PER_MONTH;
+    private readonly DEFAULT_SHARD_COUNT;
+    private readonly FALLBACK_SHARD_PRICE;
+    private readonly DEFAULT_INGESTION_GB;
+    private readonly DEFAULT_RETRIEVAL_GB;
+    private readonly FALLBACK_INGESTION_PRICE;
+    private readonly FALLBACK_RETRIEVAL_PRICE;
+    private readonly DEFAULT_FIREHOSE_GB;
+    private readonly FALLBACK_FIREHOSE_PRICE;
+    private readonly DEFAULT_KPUS;
+    private readonly FALLBACK_KPU_PRICE;
+    constructor(customShardCount?: number | undefined, customIngestionGB?: number | undefined, customRetrievalGB?: number | undefined, customFirehoseGB?: number | undefined, customKPUs?: number | undefined);
+    supports(resourceType: string): boolean;
+    calculateCost(resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+    private calculateDataStreamCost;
+    private calculateOnDemandStreamCost;
+    private calculateFirehoseCost;
+    private calculateAnalyticsCost;
+}

package/dist/action/pricing/calculators/Route53Calculator.d.ts

@@ -0,0 +1,18 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+export declare class Route53Calculator implements ResourceCostCalculator {
+    private readonly customMonthlyQueries?;
+    private readonly HOSTED_ZONE_PRICE;
+    private readonly BASIC_HEALTH_CHECK_PRICE;
+    private readonly HTTPS_HEALTH_CHECK_PRICE;
+    private readonly STANDARD_QUERY_PRICE_PER_MILLION;
+    private readonly LATENCY_QUERY_PRICE_PER_MILLION;
+    private readonly GEO_QUERY_PRICE_PER_MILLION;
+    private readonly DEFAULT_MONTHLY_QUERIES;
+    constructor(customMonthlyQueries?: number | undefined);
+    supports(resourceType: string): boolean;
+    calculateCost(resource: ResourceWithId, _region: string, _pricingClient: PricingClient): Promise<MonthlyCost>;
+    private calculateHostedZoneCost;
+    private calculateHealthCheckCost;
+    private calculateRecordSetCost;
+}

package/dist/action/pricing/calculators/TransitGatewayCalculator.d.ts

@@ -0,0 +1,16 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+export declare class TransitGatewayCalculator implements ResourceCostCalculator {
+    private readonly customAttachments?;
+    private readonly customMonthlyDataGB?;
+    private readonly HOURS_PER_MONTH;
+    private readonly DEFAULT_ATTACHMENTS;
+    private readonly DEFAULT_MONTHLY_DATA_GB;
+    private readonly FALLBACK_ATTACHMENT_PRICE;
+    private readonly FALLBACK_DATA_PRICE;
+    constructor(customAttachments?: number | undefined, customMonthlyDataGB?: number | undefined);
+    supports(resourceType: string): boolean;
+    calculateCost(resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+    private calculateAttachmentCost;
+    private calculateTransitGatewayCost;
+}

package/dist/action/reporter/index.d.ts

@@ -1,4 +1,5 @@
 export { Reporter } from './Reporter';
 export { SingleTemplateReporter } from './SingleTemplateReporter';
 export { GitHubActionReporter } from './GitHubActionReporter';
+export { ServiceBreakdown, getTrendIndicator, getPercentageChange, extractServiceName, groupCostsByService, calculateTotalCosts, } from './markdownUtils';
 export * from './types';

package/dist/action/reporter/markdownUtils.d.ts

@@ -0,0 +1,30 @@
+import { CostDelta } from '../pricing/types';
+/** Service breakdown entry for cost grouping */
+export interface ServiceBreakdown {
+    service: string;
+    totalCost: number;
+    resourceCount: number;
+}
+/**
+ * Get trend indicator emoji based on cost change direction
+ */
+export declare function getTrendIndicator(amount: number): string;
+/**
+ * Calculate percentage change between old and new amounts
+ */
+export declare function getPercentageChange(oldAmount: number, newAmount: number): string;
+/**
+ * Extract AWS service name from resource type (e.g., AWS::EC2::Instance -> EC2)
+ */
+export declare function extractServiceName(resourceType: string): string;
+/**
+ * Group costs by AWS service (e.g., EC2, S3, Lambda)
+ */
+export declare function groupCostsByService(costDelta: CostDelta): ServiceBreakdown[];
+/**
+ * Calculate total costs before and after changes
+ */
+export declare function calculateTotalCosts(costDelta: CostDelta): {
+    before: number;
+    after: number;
+};

package/dist/config/types.d.ts

@@ -127,6 +127,56 @@ export interface UsageAssumptionsConfig {
         /** Number of API calls per month (default: 10,000) */
         monthlyApiCalls?: number;
     };
+    /**
+     * Aurora Serverless usage assumptions for cost estimation.
+     *
+     * @see https://aws.amazon.com/rds/aurora/pricing/
+     */
+    auroraServerless?: {
+        /** Minimum ACU capacity (default: 0.5) */
+        minACU?: number;
+        /** Maximum ACU capacity (default: 16) */
+        maxACU?: number;
+        /** Storage size in GB (default: 100) */
+        storageGB?: number;
+    };
+    /**
+     * Transit Gateway usage assumptions for cost estimation.
+     *
+     * @see https://aws.amazon.com/transit-gateway/pricing/
+     */
+    transitGateway?: {
+        /** Number of VPC/VPN attachments (default: 3) */
+        attachments?: number;
+        /** Monthly data processed in GB (default: 1000) */
+        monthlyDataGB?: number;
+    };
+    /**
+     * Route 53 usage assumptions for cost estimation.
+     *
+     * @see https://aws.amazon.com/route53/pricing/
+     */
+    route53?: {
+        /** Monthly DNS queries (default: 1,000,000) */
+        monthlyQueries?: number;
+    };
+    /**
+     * Kinesis usage assumptions for cost estimation.
+     *
+     * @see https://aws.amazon.com/kinesis/pricing/
+     */
+    kinesis?: {
+        /** Number of shards for provisioned streams (default: 2) */
+        shardCount?: number;
+        /** Monthly data ingestion in GB for on-demand streams (default: 1000) */
+        ingestionGB?: number;
+        /** Monthly data retrieval in GB for on-demand streams (default: 2000) */
+        retrievalGB?: number;
+        /** Monthly data ingestion in GB for Firehose (default: 1000) */
+        firehoseGB?: number;
+        /** Number of Kinesis Processing Units for Analytics (default: 2) */
+        kpus?: number;
+    };
 }
 export interface SynthesisConfig {
     appPath?: string;

package/dist/config/types.js

@@ -12,4 +12,4 @@ class ConfigurationError extends Error {
     }
 }
 exports.ConfigurationError = ConfigurationError;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/config/types.ts"],"names":[],"mappings":";;;AA8MA,MAAa,kBAAmB,SAAQ,KAAK;IAGlC;IACA;IAHT,YACE,OAAe,EACR,UAAkB,EAClB,gBAA0B;QAEjC,KAAK,CAAC,OAAO,CAAC,CAAC;QAHR,eAAU,GAAV,UAAU,CAAQ;QAClB,qBAAgB,GAAhB,gBAAgB,CAAU;QAGjC,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;IACnC,CAAC;CACF;AATD,gDASC","sourcesContent":["export interface CostAnalyzerConfig {\n  thresholds?: ThresholdConfig;\n  usageAssumptions?: UsageAssumptionsConfig;\n  synthesis?: SynthesisConfig;\n  exclusions?: ExclusionsConfig;\n  cache?: CacheConfig;\n}\n\nexport interface ThresholdConfig {\n  default?: ThresholdLevels;\n  environments?: Record<string, ThresholdLevels>;\n}\n\nexport interface ThresholdLevels {\n  warning?: number;\n  error?: number;\n}\n\nexport interface UsageAssumptionsConfig {\n  s3?: {\n    storageGB?: number;\n    getRequests?: number;\n    putRequests?: number;\n  };\n  lambda?: {\n    invocationsPerMonth?: number;\n    averageDurationMs?: number;\n  };\n  /**\n   * DynamoDB usage assumptions for on-demand (pay-per-request) billing mode.\n   * These values are used to estimate monthly costs for DynamoDB tables\n   * configured with BillingMode: PAY_PER_REQUEST.\n   *\n   * For provisioned billing mode, costs are calculated based on the\n   * ReadCapacityUnits and WriteCapacityUnits specified in the template.\n   *\n   * @see https://aws.amazon.com/dynamodb/pricing/\n   */\n  dynamodb?: {\n    /** Number of read requests per month (default: 10,000,000) */\n    readRequestsPerMonth?: number;\n    /** Number of write requests per month (default: 1,000,000) */\n    writeRequestsPerMonth?: number;\n  };\n  natGateway?: {\n    dataProcessedGB?: number;\n  };\n  alb?: {\n    newConnectionsPerSecond?: number;\n    activeConnectionsPerMinute?: number;\n    processedBytesGB?: number;\n  };\n  nlb?: {\n    newConnectionsPerSecond?: number;\n    activeConnectionsPerMinute?: number;\n    processedBytesGB?: number;\n  };\n  cloudfront?: {\n    dataTransferGB?: number;\n    requests?: number;\n  };\n  apiGateway?: {\n    requestsPerMonth?: number;\n  };\n  vpcEndpoint?: {\n    dataProcessedGB?: number;\n  };\n  /**\n   * EFS (Elastic File System) usage assumptions for cost estimation.\n   * These values are used to estimate monthly costs for EFS file systems.\n   *\n   * @see https://aws.amazon.com/efs/pricing/\n   */\n  efs?: {\n    /** Total storage size in GB (default: 100) */\n    storageSizeGb?: number;\n    /** Percentage of storage in Infrequent Access class (default: 0, range: 0-100) */\n    infrequentAccessPercentage?: number;\n  };\n  /**\n   * SNS (Simple Notification Service) usage assumptions.\n   * These values are used to estimate monthly costs for SNS topics.\n   *\n   * @see https://aws.amazon.com/sns/pricing/\n   */\n  sns?: {\n    /** Number of publish requests per month (default: 1,000,000) */\n    monthlyPublishes?: number;\n    /** Number of HTTP/S deliveries per month (default: 1,000,000) */\n    httpDeliveries?: number;\n    /** Number of email deliveries per month (default: 0) */\n    emailDeliveries?: number;\n    /** Number of SMS deliveries per month (default: 0) */\n    smsDeliveries?: number;\n    /** Number of mobile push deliveries per month (default: 0) */\n    mobilePushDeliveries?: number;\n  };\n  /**\n   * SQS usage assumptions for cost estimation.\n   * Applies to both Standard and FIFO queues.\n   *\n   * @see https://aws.amazon.com/sqs/pricing/\n   */\n  sqs?: {\n    /** Number of requests per month (default: 1,000,000) */\n    monthlyRequests?: number;\n  };\n  /**\n   * Step Functions usage assumptions for cost estimation.\n   *\n   * Standard workflows are charged per state transition.\n   * Express workflows are charged per request and per GB-second of duration.\n   *\n   * @see https://aws.amazon.com/step-functions/pricing/\n   */\n  stepFunctions?: {\n    /** Number of workflow executions per month (default: 10,000) */\n    monthlyExecutions?: number;\n    /** Number of state transitions per execution (default: 10, for Standard workflows) */\n    stateTransitionsPerExecution?: number;\n    /** Average execution duration in milliseconds (default: 1000, for Express workflows) */\n    averageDurationMs?: number;\n  };\n  /**\n   * Secrets Manager usage assumptions for cost estimation.\n   *\n   * @see https://aws.amazon.com/secrets-manager/pricing/\n   */\n  secretsManager?: {\n    /** Number of API calls per month (default: 10,000) */\n    monthlyApiCalls?: number;\n  };\n  /**\n   * Aurora Serverless usage assumptions for cost estimation.\n   *\n   * @see https://aws.amazon.com/rds/aurora/pricing/\n   */\n  auroraServerless?: {\n    /** Minimum ACU capacity (default: 0.5) */\n    minACU?: number;\n    /** Maximum ACU capacity (default: 16) */\n    maxACU?: number;\n    /** Storage size in GB (default: 100) */\n    storageGB?: number;\n  };\n  /**\n   * Transit Gateway usage assumptions for cost estimation.\n   *\n   * @see https://aws.amazon.com/transit-gateway/pricing/\n   */\n  transitGateway?: {\n    /** Number of VPC/VPN attachments (default: 3) */\n    attachments?: number;\n    /** Monthly data processed in GB (default: 1000) */\n    monthlyDataGB?: number;\n  };\n  /**\n   * Route 53 usage assumptions for cost estimation.\n   *\n   * @see https://aws.amazon.com/route53/pricing/\n   */\n  route53?: {\n    /** Monthly DNS queries (default: 1,000,000) */\n    monthlyQueries?: number;\n  };\n  /**\n   * Kinesis usage assumptions for cost estimation.\n   *\n   * @see https://aws.amazon.com/kinesis/pricing/\n   */\n  kinesis?: {\n    /** Number of shards for provisioned streams (default: 2) */\n    shardCount?: number;\n    /** Monthly data ingestion in GB for on-demand streams (default: 1000) */\n    ingestionGB?: number;\n    /** Monthly data retrieval in GB for on-demand streams (default: 2000) */\n    retrievalGB?: number;\n    /** Monthly data ingestion in GB for Firehose (default: 1000) */\n    firehoseGB?: number;\n    /** Number of Kinesis Processing Units for Analytics (default: 2) */\n    kpus?: number;\n  };\n}\n\nexport interface SynthesisConfig {\n  appPath?: string;\n  outputPath?: string;\n  customCommand?: string;\n  context?: Record<string, string>;\n}\n\nexport interface ExclusionsConfig {\n  resourceTypes?: string[];\n}\n\nexport interface CacheConfig {\n  enabled?: boolean;\n  durationHours?: number;\n}\n\nexport interface ValidationResult {\n  valid: boolean;\n  errors: string[];\n  warnings: string[];\n}\n\nexport class ConfigurationError extends Error {\n  constructor(\n    message: string,\n    public configPath: string,\n    public validationErrors: string[],\n  ) {\n    super(message);\n    this.name = 'ConfigurationError';\n  }\n}\n"]}

package/dist/pricing/PricingService.js

@@ -22,6 +22,11 @@ const SNSCalculator_1 = require("./calculators/SNSCalculator");
 const SQSCalculator_1 = require("./calculators/SQSCalculator");
 const StepFunctionsCalculator_1 = require("./calculators/StepFunctionsCalculator");
 const VPCEndpointCalculator_1 = require("./calculators/VPCEndpointCalculator");
+const EKSCalculator_1 = require("./calculators/EKSCalculator");
+const AuroraServerlessCalculator_1 = require("./calculators/AuroraServerlessCalculator");
+const TransitGatewayCalculator_1 = require("./calculators/TransitGatewayCalculator");
+const Route53Calculator_1 = require("./calculators/Route53Calculator");
+const KinesisCalculator_1 = require("./calculators/KinesisCalculator");
 const PricingClient_1 = require("./PricingClient");
 class PricingService {
     calculators;
@@ -65,6 +70,11 @@ class PricingService {
             new SQSCalculator_1.SQSCalculator(config),
             new StepFunctionsCalculator_1.StepFunctionsCalculator(usageAssumptions?.stepFunctions?.monthlyExecutions, usageAssumptions?.stepFunctions?.stateTransitionsPerExecution, usageAssumptions?.stepFunctions?.averageDurationMs),
             new SecretsManagerCalculator_1.SecretsManagerCalculator(usageAssumptions?.secretsManager?.monthlyApiCalls),
+            new EKSCalculator_1.EKSCalculator(),
+            new AuroraServerlessCalculator_1.AuroraServerlessCalculator(usageAssumptions?.auroraServerless?.minACU, usageAssumptions?.auroraServerless?.maxACU, usageAssumptions?.auroraServerless?.storageGB),
+            new TransitGatewayCalculator_1.TransitGatewayCalculator(usageAssumptions?.transitGateway?.attachments, usageAssumptions?.transitGateway?.monthlyDataGB),
+            new Route53Calculator_1.Route53Calculator(usageAssumptions?.route53?.monthlyQueries),
+            new KinesisCalculator_1.KinesisCalculator(usageAssumptions?.kinesis?.shardCount, usageAssumptions?.kinesis?.ingestionGB, usageAssumptions?.kinesis?.retrievalGB, usageAssumptions?.kinesis?.firehoseGB, usageAssumptions?.kinesis?.kpus),
         ];
     }
     async getResourceCost(resource, region, templateResources) {
@@ -178,4 +188,4 @@ class PricingService {
     }
 }
 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 { AutoScalingGroupCalculator } from './calculators/AutoScalingGroupCalculator';\nimport { CloudFrontCalculator } from './calculators/CloudFrontCalculator';\nimport { DynamoDBCalculator } from './calculators/DynamoDBCalculator';\nimport { EC2Calculator } from './calculators/EC2Calculator';\nimport { ECSCalculator } from './calculators/ECSCalculator';\nimport { EFSCalculator } from './calculators/EFSCalculator';\nimport { ElastiCacheCalculator } from './calculators/ElastiCacheCalculator';\nimport { LambdaCalculator } from './calculators/LambdaCalculator';\nimport { LaunchTemplateCalculator } from './calculators/LaunchTemplateCalculator';\nimport { NatGatewayCalculator } from './calculators/NatGatewayCalculator';\nimport { NLBCalculator } from './calculators/NLBCalculator';\nimport { RDSCalculator } from './calculators/RDSCalculator';\nimport { S3Calculator } from './calculators/S3Calculator';\nimport { SecretsManagerCalculator } from './calculators/SecretsManagerCalculator';\nimport { SNSCalculator } from './calculators/SNSCalculator';\nimport { SQSCalculator } from './calculators/SQSCalculator';\nimport { StepFunctionsCalculator } from './calculators/StepFunctionsCalculator';\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, CostAnalyzerConfig } 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    \n    // Build config object for calculators that need it\n    const config: CostAnalyzerConfig | undefined = usageAssumptions ? { usageAssumptions } : undefined;\n    \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(config),\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      new AutoScalingGroupCalculator(),\n      new LaunchTemplateCalculator(),\n      new EFSCalculator(\n        usageAssumptions?.efs?.storageSizeGb,\n        usageAssumptions?.efs?.infrequentAccessPercentage,\n      ),\n      new SNSCalculator(\n        usageAssumptions?.sns?.monthlyPublishes,\n        usageAssumptions?.sns?.httpDeliveries,\n        usageAssumptions?.sns?.emailDeliveries,\n        usageAssumptions?.sns?.smsDeliveries,\n        usageAssumptions?.sns?.mobilePushDeliveries,\n      ),\n      new SQSCalculator(config),\n      new StepFunctionsCalculator(\n        usageAssumptions?.stepFunctions?.monthlyExecutions,\n        usageAssumptions?.stepFunctions?.stateTransitionsPerExecution,\n        usageAssumptions?.stepFunctions?.averageDurationMs,\n      ),\n      new SecretsManagerCalculator(\n        usageAssumptions?.secretsManager?.monthlyApiCalls,\n      ),\n    ];\n  }\n\n  async getResourceCost(resource: ResourceWithId, region: string, templateResources?: ResourceWithId[]): 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    // Find calculator using canCalculate if available, otherwise fall back to supports\n    const calculator = this.calculators.find(calc => {\n      if (calc.canCalculate) {\n        return calc.canCalculate(resource);\n      }\n      return calc.supports(resource.type);\n    });\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, templateResources);\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    // Build template resource context from all resources in the diff\n    const allResources: ResourceWithId[] = [\n      ...diff.added,\n      ...diff.removed,\n      ...diff.modified.map(r => ({\n        logicalId: r.logicalId,\n        type: r.type,\n        properties: r.newProperties,\n      })),\n    ];\n\n    const addedCosts = await Promise.all(\n      filteredAdded.map(async (resource) => {\n        const monthlyCost = await this.getResourceCost(resource, region, allResources);\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, allResources);\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, allResources);\n        const newMonthlyCost = await this.getResourceCost(newResource, region, allResources);\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"]}
+//# 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 { AutoScalingGroupCalculator } from './calculators/AutoScalingGroupCalculator';\nimport { CloudFrontCalculator } from './calculators/CloudFrontCalculator';\nimport { DynamoDBCalculator } from './calculators/DynamoDBCalculator';\nimport { EC2Calculator } from './calculators/EC2Calculator';\nimport { ECSCalculator } from './calculators/ECSCalculator';\nimport { EFSCalculator } from './calculators/EFSCalculator';\nimport { ElastiCacheCalculator } from './calculators/ElastiCacheCalculator';\nimport { LambdaCalculator } from './calculators/LambdaCalculator';\nimport { LaunchTemplateCalculator } from './calculators/LaunchTemplateCalculator';\nimport { NatGatewayCalculator } from './calculators/NatGatewayCalculator';\nimport { NLBCalculator } from './calculators/NLBCalculator';\nimport { RDSCalculator } from './calculators/RDSCalculator';\nimport { S3Calculator } from './calculators/S3Calculator';\nimport { SecretsManagerCalculator } from './calculators/SecretsManagerCalculator';\nimport { SNSCalculator } from './calculators/SNSCalculator';\nimport { SQSCalculator } from './calculators/SQSCalculator';\nimport { StepFunctionsCalculator } from './calculators/StepFunctionsCalculator';\nimport { VPCEndpointCalculator } from './calculators/VPCEndpointCalculator';\nimport { EKSCalculator } from './calculators/EKSCalculator';\nimport { AuroraServerlessCalculator } from './calculators/AuroraServerlessCalculator';\nimport { TransitGatewayCalculator } from './calculators/TransitGatewayCalculator';\nimport { Route53Calculator } from './calculators/Route53Calculator';\nimport { KinesisCalculator } from './calculators/KinesisCalculator';\nimport { PricingClient } from './PricingClient';\nimport {\n  PricingService as IPricingService,\n  MonthlyCost,\n  CostDelta,\n  ResourceCostCalculator,\n} from './types';\nimport { UsageAssumptionsConfig, CacheConfig, CostAnalyzerConfig } 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    \n    // Build config object for calculators that need it\n    const config: CostAnalyzerConfig | undefined = usageAssumptions ? { usageAssumptions } : undefined;\n    \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(config),\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      new AutoScalingGroupCalculator(),\n      new LaunchTemplateCalculator(),\n      new EFSCalculator(\n        usageAssumptions?.efs?.storageSizeGb,\n        usageAssumptions?.efs?.infrequentAccessPercentage,\n      ),\n      new SNSCalculator(\n        usageAssumptions?.sns?.monthlyPublishes,\n        usageAssumptions?.sns?.httpDeliveries,\n        usageAssumptions?.sns?.emailDeliveries,\n        usageAssumptions?.sns?.smsDeliveries,\n        usageAssumptions?.sns?.mobilePushDeliveries,\n      ),\n      new SQSCalculator(config),\n      new StepFunctionsCalculator(\n        usageAssumptions?.stepFunctions?.monthlyExecutions,\n        usageAssumptions?.stepFunctions?.stateTransitionsPerExecution,\n        usageAssumptions?.stepFunctions?.averageDurationMs,\n      ),\n      new SecretsManagerCalculator(\n        usageAssumptions?.secretsManager?.monthlyApiCalls,\n      ),\n      new EKSCalculator(),\n      new AuroraServerlessCalculator(\n        usageAssumptions?.auroraServerless?.minACU,\n        usageAssumptions?.auroraServerless?.maxACU,\n        usageAssumptions?.auroraServerless?.storageGB,\n      ),\n      new TransitGatewayCalculator(\n        usageAssumptions?.transitGateway?.attachments,\n        usageAssumptions?.transitGateway?.monthlyDataGB,\n      ),\n      new Route53Calculator(\n        usageAssumptions?.route53?.monthlyQueries,\n      ),\n      new KinesisCalculator(\n        usageAssumptions?.kinesis?.shardCount,\n        usageAssumptions?.kinesis?.ingestionGB,\n        usageAssumptions?.kinesis?.retrievalGB,\n        usageAssumptions?.kinesis?.firehoseGB,\n        usageAssumptions?.kinesis?.kpus,\n      ),\n    ];\n  }\n\n  async getResourceCost(resource: ResourceWithId, region: string, templateResources?: ResourceWithId[]): 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    // Find calculator using canCalculate if available, otherwise fall back to supports\n    const calculator = this.calculators.find(calc => {\n      if (calc.canCalculate) {\n        return calc.canCalculate(resource);\n      }\n      return calc.supports(resource.type);\n    });\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, templateResources);\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    // Build template resource context from all resources in the diff\n    const allResources: ResourceWithId[] = [\n      ...diff.added,\n      ...diff.removed,\n      ...diff.modified.map(r => ({\n        logicalId: r.logicalId,\n        type: r.type,\n        properties: r.newProperties,\n      })),\n    ];\n\n    const addedCosts = await Promise.all(\n      filteredAdded.map(async (resource) => {\n        const monthlyCost = await this.getResourceCost(resource, region, allResources);\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, allResources);\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, allResources);\n        const newMonthlyCost = await this.getResourceCost(newResource, region, allResources);\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/AuroraServerlessCalculator.d.ts

@@ -0,0 +1,20 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+export declare class AuroraServerlessCalculator implements ResourceCostCalculator {
+    private readonly customMinACU?;
+    private readonly customMaxACU?;
+    private readonly customStorageGB?;
+    private readonly HOURS_PER_MONTH;
+    private readonly DEFAULT_MIN_ACU;
+    private readonly DEFAULT_MAX_ACU;
+    private readonly DEFAULT_STORAGE_GB;
+    private readonly DEFAULT_MONTHLY_IO_REQUESTS;
+    private readonly FALLBACK_ACU_PRICE_V2;
+    private readonly FALLBACK_ACU_PRICE_V1;
+    private readonly STORAGE_PRICE_PER_GB;
+    private readonly IO_PRICE_PER_MILLION;
+    constructor(customMinACU?: number | undefined, customMaxACU?: number | undefined, customStorageGB?: number | undefined);
+    supports(resourceType: string): boolean;
+    canCalculate(resource: ResourceWithId): boolean;
+    calculateCost(resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+}

package/dist/pricing/calculators/AuroraServerlessCalculator.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuroraServerlessCalculator = void 0;
+const RegionMapper_1 = require("../RegionMapper");
+class AuroraServerlessCalculator {
+    customMinACU;
+    customMaxACU;
+    customStorageGB;
+    HOURS_PER_MONTH = 730;
+    DEFAULT_MIN_ACU = 0.5;
+    DEFAULT_MAX_ACU = 16;
+    DEFAULT_STORAGE_GB = 100;
+    DEFAULT_MONTHLY_IO_REQUESTS = 100_000_000;
+    FALLBACK_ACU_PRICE_V2 = 0.12;
+    FALLBACK_ACU_PRICE_V1 = 0.06;
+    STORAGE_PRICE_PER_GB = 0.10;
+    IO_PRICE_PER_MILLION = 0.20;
+    constructor(customMinACU, customMaxACU, customStorageGB) {
+        this.customMinACU = customMinACU;
+        this.customMaxACU = customMaxACU;
+        this.customStorageGB = customStorageGB;
+    }
+    supports(resourceType) {
+        return resourceType === 'AWS::RDS::DBCluster';
+    }
+    canCalculate(resource) {
+        const props = resource.properties || {};
+        return (props.EngineMode === 'serverless' ||
+            props.ServerlessV2ScalingConfiguration !== undefined);
+    }
+    async calculateCost(resource, region, pricingClient) {
+        try {
+            const props = resource.properties || {};
+            const scalingConfig = props.ServerlessV2ScalingConfiguration;
+            const isV2 = scalingConfig !== undefined;
+            const minACU = this.customMinACU
+                ?? scalingConfig?.MinCapacity
+                ?? this.DEFAULT_MIN_ACU;
+            const maxACU = this.customMaxACU
+                ?? scalingConfig?.MaxCapacity
+                ?? this.DEFAULT_MAX_ACU;
+            const avgACU = (minACU + maxACU) / 2;
+            const fallbackPrice = isV2 ? this.FALLBACK_ACU_PRICE_V2 : this.FALLBACK_ACU_PRICE_V1;
+            const acuPrice = await pricingClient.getPrice({
+                serviceCode: 'AmazonRDS',
+                region: (0, RegionMapper_1.normalizeRegion)(region),
+                filters: [
+                    { field: 'databaseEngine', value: 'Aurora' },
+                    { field: 'productFamily', value: 'ServerlessV2' },
+                ],
+            });
+            const rate = acuPrice ?? fallbackPrice;
+            const usedFallback = acuPrice === null;
+            const computeCost = avgACU * this.HOURS_PER_MONTH * rate;
+            const storageGB = this.customStorageGB ?? this.DEFAULT_STORAGE_GB;
+            const storageCost = storageGB * this.STORAGE_PRICE_PER_GB;
+            let ioCost = 0;
+            if (isV2) {
+                ioCost = (this.DEFAULT_MONTHLY_IO_REQUESTS / 1_000_000) * this.IO_PRICE_PER_MILLION;
+            }
+            const totalCost = computeCost + storageCost + ioCost;
+            const version = isV2 ? 'v2' : 'v1';
+            const assumptions = [
+                `Aurora Serverless ${version}: ${avgACU} avg ACUs × $${rate.toFixed(2)}/ACU-hour × ${this.HOURS_PER_MONTH}h = $${computeCost.toFixed(2)}/month`,
+                `Storage: ${storageGB} GB × $${this.STORAGE_PRICE_PER_GB}/GB = $${storageCost.toFixed(2)}/month`,
+            ];
+            if (isV2) {
+                assumptions.push(`I/O: ${this.DEFAULT_MONTHLY_IO_REQUESTS / 1_000_000}M requests × $${this.IO_PRICE_PER_MILLION}/M = $${ioCost.toFixed(2)}/month`);
+            }
+            if (usedFallback) {
+                assumptions.push(`Using fallback pricing (API data not available for region ${region})`);
+            }
+            assumptions.push(`ACU range: ${minACU}–${maxACU} (estimated average: ${avgACU})`);
+            return {
+                amount: totalCost,
+                currency: 'USD',
+                confidence: usedFallback ? 'medium' : 'medium',
+                assumptions,
+            };
+        }
+        catch (error) {
+            return {
+                amount: 0,
+                currency: 'USD',
+                confidence: 'unknown',
+                assumptions: [`Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`],
+            };
+        }
+    }
+}
+exports.AuroraServerlessCalculator = AuroraServerlessCalculator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AuroraServerlessCalculator.js","sourceRoot":"","sources":["../../../src/pricing/calculators/AuroraServerlessCalculator.ts"],"names":[],"mappings":"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","sourcesContent":["import { ResourceWithId } from '../../diff/types';\nimport { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';\nimport { normalizeRegion } from '../RegionMapper';\n\nexport class AuroraServerlessCalculator implements ResourceCostCalculator {\n  private readonly HOURS_PER_MONTH = 730;\n  private readonly DEFAULT_MIN_ACU = 0.5;\n  private readonly DEFAULT_MAX_ACU = 16;\n  private readonly DEFAULT_STORAGE_GB = 100;\n  private readonly DEFAULT_MONTHLY_IO_REQUESTS = 100_000_000;\n  private readonly FALLBACK_ACU_PRICE_V2 = 0.12;\n  private readonly FALLBACK_ACU_PRICE_V1 = 0.06;\n  private readonly STORAGE_PRICE_PER_GB = 0.10;\n  private readonly IO_PRICE_PER_MILLION = 0.20;\n\n  constructor(\n    private readonly customMinACU?: number,\n    private readonly customMaxACU?: number,\n    private readonly customStorageGB?: number,\n  ) {}\n\n  supports(resourceType: string): boolean {\n    return resourceType === 'AWS::RDS::DBCluster';\n  }\n\n  canCalculate(resource: ResourceWithId): boolean {\n    const props = resource.properties || {};\n    return (\n      (props.EngineMode as string) === 'serverless' ||\n      props.ServerlessV2ScalingConfiguration !== undefined\n    );\n  }\n\n  async calculateCost(\n    resource: ResourceWithId,\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    try {\n      const props = resource.properties || {};\n      const scalingConfig = props.ServerlessV2ScalingConfiguration as Record<string, unknown> | undefined;\n      const isV2 = scalingConfig !== undefined;\n\n      const minACU = this.customMinACU\n        ?? (scalingConfig?.MinCapacity as number | undefined)\n        ?? this.DEFAULT_MIN_ACU;\n      const maxACU = this.customMaxACU\n        ?? (scalingConfig?.MaxCapacity as number | undefined)\n        ?? this.DEFAULT_MAX_ACU;\n      const avgACU = (minACU + maxACU) / 2;\n\n      const fallbackPrice = isV2 ? this.FALLBACK_ACU_PRICE_V2 : this.FALLBACK_ACU_PRICE_V1;\n\n      const acuPrice = await pricingClient.getPrice({\n        serviceCode: 'AmazonRDS',\n        region: normalizeRegion(region),\n        filters: [\n          { field: 'databaseEngine', value: 'Aurora' },\n          { field: 'productFamily', value: 'ServerlessV2' },\n        ],\n      });\n\n      const rate = acuPrice ?? fallbackPrice;\n      const usedFallback = acuPrice === null;\n      const computeCost = avgACU * this.HOURS_PER_MONTH * rate;\n\n      const storageGB = this.customStorageGB ?? this.DEFAULT_STORAGE_GB;\n      const storageCost = storageGB * this.STORAGE_PRICE_PER_GB;\n\n      let ioCost = 0;\n      if (isV2) {\n        ioCost = (this.DEFAULT_MONTHLY_IO_REQUESTS / 1_000_000) * this.IO_PRICE_PER_MILLION;\n      }\n\n      const totalCost = computeCost + storageCost + ioCost;\n      const version = isV2 ? 'v2' : 'v1';\n\n      const assumptions = [\n        `Aurora Serverless ${version}: ${avgACU} avg ACUs × $${rate.toFixed(2)}/ACU-hour × ${this.HOURS_PER_MONTH}h = $${computeCost.toFixed(2)}/month`,\n        `Storage: ${storageGB} GB × $${this.STORAGE_PRICE_PER_GB}/GB = $${storageCost.toFixed(2)}/month`,\n      ];\n\n      if (isV2) {\n        assumptions.push(`I/O: ${this.DEFAULT_MONTHLY_IO_REQUESTS / 1_000_000}M requests × $${this.IO_PRICE_PER_MILLION}/M = $${ioCost.toFixed(2)}/month`);\n      }\n\n      if (usedFallback) {\n        assumptions.push(`Using fallback pricing (API data not available for region ${region})`);\n      }\n\n      assumptions.push(`ACU range: ${minACU}–${maxACU} (estimated average: ${avgACU})`);\n\n      return {\n        amount: totalCost,\n        currency: 'USD',\n        confidence: usedFallback ? 'medium' : 'medium',\n        assumptions,\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"]}

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

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

package/dist/pricing/calculators/EKSCalculator.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EKSCalculator = void 0;
+const RegionMapper_1 = require("../RegionMapper");
+class EKSCalculator {
+    HOURS_PER_MONTH = 730;
+    FALLBACK_CONTROL_PLANE_HOURLY = 0.10;
+    supports(resourceType) {
+        return resourceType === 'AWS::EKS::Cluster';
+    }
+    async calculateCost(_resource, region, pricingClient) {
+        try {
+            const hourlyRate = await pricingClient.getPrice({
+                serviceCode: 'AmazonEKS',
+                region: (0, RegionMapper_1.normalizeRegion)(region),
+                filters: [
+                    { field: 'productFamily', value: 'Compute' },
+                    { field: 'usagetype', value: 'AmazonEKS-Hours:perCluster' },
+                ],
+            });
+            const rate = hourlyRate ?? this.FALLBACK_CONTROL_PLANE_HOURLY;
+            const monthlyCost = rate * this.HOURS_PER_MONTH;
+            const usedFallback = hourlyRate === null;
+            return {
+                amount: monthlyCost,
+                currency: 'USD',
+                confidence: usedFallback ? 'medium' : 'high',
+                assumptions: [
+                    `EKS control plane: $${rate.toFixed(2)}/hour × ${this.HOURS_PER_MONTH} hours = $${monthlyCost.toFixed(2)}/month`,
+                    ...(usedFallback ? [`Using fallback pricing (API data not available for region ${region})`] : []),
+                    'Worker nodes (EC2/Fargate) are calculated separately',
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                amount: 0,
+                currency: 'USD',
+                confidence: 'unknown',
+                assumptions: [`Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`],
+            };
+        }
+    }
+}
+exports.EKSCalculator = EKSCalculator;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,27 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+export declare class KinesisCalculator implements ResourceCostCalculator {
+    private readonly customShardCount?;
+    private readonly customIngestionGB?;
+    private readonly customRetrievalGB?;
+    private readonly customFirehoseGB?;
+    private readonly customKPUs?;
+    private readonly HOURS_PER_MONTH;
+    private readonly DEFAULT_SHARD_COUNT;
+    private readonly FALLBACK_SHARD_PRICE;
+    private readonly DEFAULT_INGESTION_GB;
+    private readonly DEFAULT_RETRIEVAL_GB;
+    private readonly FALLBACK_INGESTION_PRICE;
+    private readonly FALLBACK_RETRIEVAL_PRICE;
+    private readonly DEFAULT_FIREHOSE_GB;
+    private readonly FALLBACK_FIREHOSE_PRICE;
+    private readonly DEFAULT_KPUS;
+    private readonly FALLBACK_KPU_PRICE;
+    constructor(customShardCount?: number | undefined, customIngestionGB?: number | undefined, customRetrievalGB?: number | undefined, customFirehoseGB?: number | undefined, customKPUs?: number | undefined);
+    supports(resourceType: string): boolean;
+    calculateCost(resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+    private calculateDataStreamCost;
+    private calculateOnDemandStreamCost;
+    private calculateFirehoseCost;
+    private calculateAnalyticsCost;
+}