cdk-cost-analyzer 0.1.39 → 0.1.41

package/dist/pricing/calculators/KinesisCalculator.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KinesisCalculator = void 0;
+const RegionMapper_1 = require("../RegionMapper");
+class KinesisCalculator {
+    customShardCount;
+    customIngestionGB;
+    customRetrievalGB;
+    customFirehoseGB;
+    customKPUs;
+    HOURS_PER_MONTH = 730;
+    // Data Streams - Provisioned
+    DEFAULT_SHARD_COUNT = 2;
+    FALLBACK_SHARD_PRICE = 0.015;
+    // Data Streams - On-Demand
+    DEFAULT_INGESTION_GB = 1000;
+    DEFAULT_RETRIEVAL_GB = 2000;
+    FALLBACK_INGESTION_PRICE = 0.040;
+    FALLBACK_RETRIEVAL_PRICE = 0.015;
+    // Firehose
+    DEFAULT_FIREHOSE_GB = 1000;
+    FALLBACK_FIREHOSE_PRICE = 0.029;
+    // Analytics
+    DEFAULT_KPUS = 2;
+    FALLBACK_KPU_PRICE = 0.11;
+    constructor(customShardCount, customIngestionGB, customRetrievalGB, customFirehoseGB, customKPUs) {
+        this.customShardCount = customShardCount;
+        this.customIngestionGB = customIngestionGB;
+        this.customRetrievalGB = customRetrievalGB;
+        this.customFirehoseGB = customFirehoseGB;
+        this.customKPUs = customKPUs;
+    }
+    supports(resourceType) {
+        return (resourceType === 'AWS::Kinesis::Stream' ||
+            resourceType === 'AWS::KinesisFirehose::DeliveryStream' ||
+            resourceType === 'AWS::KinesisAnalyticsV2::Application');
+    }
+    async calculateCost(resource, region, pricingClient) {
+        try {
+            switch (resource.type) {
+                case 'AWS::Kinesis::Stream':
+                    return await this.calculateDataStreamCost(resource, region, pricingClient);
+                case 'AWS::KinesisFirehose::DeliveryStream':
+                    return this.calculateFirehoseCost();
+                case 'AWS::KinesisAnalyticsV2::Application':
+                    return this.calculateAnalyticsCost();
+                default:
+                    return {
+                        amount: 0,
+                        currency: 'USD',
+                        confidence: 'unknown',
+                        assumptions: [`Unsupported Kinesis resource type: ${resource.type}`],
+                    };
+            }
+        }
+        catch (error) {
+            return {
+                amount: 0,
+                currency: 'USD',
+                confidence: 'unknown',
+                assumptions: [`Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`],
+            };
+        }
+    }
+    async calculateDataStreamCost(resource, region, pricingClient) {
+        const props = resource.properties || {};
+        const streamModeDetails = props.StreamModeDetails;
+        const streamMode = streamModeDetails?.StreamMode || 'PROVISIONED';
+        if (streamMode === 'ON_DEMAND') {
+            return this.calculateOnDemandStreamCost();
+        }
+        const shardCount = this.customShardCount
+            ?? props.ShardCount
+            ?? this.DEFAULT_SHARD_COUNT;
+        const shardPrice = await pricingClient.getPrice({
+            serviceCode: 'AmazonKinesis',
+            region: (0, RegionMapper_1.normalizeRegion)(region),
+            filters: [
+                { field: 'productFamily', value: 'Kinesis Streams' },
+                { field: 'usagetype', value: 'shardHour-Provisioned' },
+            ],
+        });
+        const rate = shardPrice ?? this.FALLBACK_SHARD_PRICE;
+        const monthlyCost = shardCount * rate * this.HOURS_PER_MONTH;
+        return {
+            amount: monthlyCost,
+            currency: 'USD',
+            confidence: shardPrice !== null ? 'high' : 'medium',
+            assumptions: [
+                `Provisioned mode: ${shardCount} shards × $${rate.toFixed(4)}/shard-hour × ${this.HOURS_PER_MONTH}h = $${monthlyCost.toFixed(2)}/month`,
+                ...(shardPrice === null ? [`Using fallback pricing (API data not available for region ${region})`] : []),
+            ],
+        };
+    }
+    calculateOnDemandStreamCost() {
+        const ingestionGB = this.customIngestionGB ?? this.DEFAULT_INGESTION_GB;
+        const retrievalGB = this.customRetrievalGB ?? this.DEFAULT_RETRIEVAL_GB;
+        const ingestionCost = ingestionGB * this.FALLBACK_INGESTION_PRICE;
+        const retrievalCost = retrievalGB * this.FALLBACK_RETRIEVAL_PRICE;
+        const totalCost = ingestionCost + retrievalCost;
+        return {
+            amount: totalCost,
+            currency: 'USD',
+            confidence: 'medium',
+            assumptions: [
+                `On-demand mode`,
+                `Ingestion: ${ingestionGB} GB × $${this.FALLBACK_INGESTION_PRICE}/GB = $${ingestionCost.toFixed(2)}/month`,
+                `Retrieval: ${retrievalGB} GB × $${this.FALLBACK_RETRIEVAL_PRICE}/GB = $${retrievalCost.toFixed(2)}/month`,
+            ],
+        };
+    }
+    calculateFirehoseCost() {
+        const dataGB = this.customFirehoseGB ?? this.DEFAULT_FIREHOSE_GB;
+        const monthlyCost = dataGB * this.FALLBACK_FIREHOSE_PRICE;
+        return {
+            amount: monthlyCost,
+            currency: 'USD',
+            confidence: 'medium',
+            assumptions: [
+                `Firehose ingestion: ${dataGB} GB × $${this.FALLBACK_FIREHOSE_PRICE}/GB = $${monthlyCost.toFixed(2)}/month`,
+                'Does not include format conversion or VPC delivery costs',
+            ],
+        };
+    }
+    calculateAnalyticsCost() {
+        const kpus = this.customKPUs ?? this.DEFAULT_KPUS;
+        const monthlyCost = kpus * this.FALLBACK_KPU_PRICE * this.HOURS_PER_MONTH;
+        return {
+            amount: monthlyCost,
+            currency: 'USD',
+            confidence: 'medium',
+            assumptions: [
+                `Kinesis Analytics: ${kpus} KPUs × $${this.FALLBACK_KPU_PRICE}/KPU-hour × ${this.HOURS_PER_MONTH}h = $${monthlyCost.toFixed(2)}/month`,
+                '1 KPU = 1 vCPU + 4 GB memory',
+            ],
+        };
+    }
+}
+exports.KinesisCalculator = KinesisCalculator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"KinesisCalculator.js","sourceRoot":"","sources":["../../../src/pricing/calculators/KinesisCalculator.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 KinesisCalculator implements ResourceCostCalculator {\n  private readonly HOURS_PER_MONTH = 730;\n\n  // Data Streams - Provisioned\n  private readonly DEFAULT_SHARD_COUNT = 2;\n  private readonly FALLBACK_SHARD_PRICE = 0.015;\n\n  // Data Streams - On-Demand\n  private readonly DEFAULT_INGESTION_GB = 1000;\n  private readonly DEFAULT_RETRIEVAL_GB = 2000;\n  private readonly FALLBACK_INGESTION_PRICE = 0.040;\n  private readonly FALLBACK_RETRIEVAL_PRICE = 0.015;\n\n  // Firehose\n  private readonly DEFAULT_FIREHOSE_GB = 1000;\n  private readonly FALLBACK_FIREHOSE_PRICE = 0.029;\n\n  // Analytics\n  private readonly DEFAULT_KPUS = 2;\n  private readonly FALLBACK_KPU_PRICE = 0.11;\n\n  constructor(\n    private readonly customShardCount?: number,\n    private readonly customIngestionGB?: number,\n    private readonly customRetrievalGB?: number,\n    private readonly customFirehoseGB?: number,\n    private readonly customKPUs?: number,\n  ) {}\n\n  supports(resourceType: string): boolean {\n    return (\n      resourceType === 'AWS::Kinesis::Stream' ||\n      resourceType === 'AWS::KinesisFirehose::DeliveryStream' ||\n      resourceType === 'AWS::KinesisAnalyticsV2::Application'\n    );\n  }\n\n  async calculateCost(\n    resource: ResourceWithId,\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    try {\n      switch (resource.type) {\n        case 'AWS::Kinesis::Stream':\n          return await this.calculateDataStreamCost(resource, region, pricingClient);\n        case 'AWS::KinesisFirehose::DeliveryStream':\n          return this.calculateFirehoseCost();\n        case 'AWS::KinesisAnalyticsV2::Application':\n          return this.calculateAnalyticsCost();\n        default:\n          return {\n            amount: 0,\n            currency: 'USD',\n            confidence: 'unknown',\n            assumptions: [`Unsupported Kinesis resource type: ${resource.type}`],\n          };\n      }\n    } catch (error) {\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'unknown',\n        assumptions: [`Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`],\n      };\n    }\n  }\n\n  private async calculateDataStreamCost(\n    resource: ResourceWithId,\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    const props = resource.properties || {};\n    const streamModeDetails = props.StreamModeDetails as Record<string, unknown> | undefined;\n    const streamMode = (streamModeDetails?.StreamMode as string) || 'PROVISIONED';\n\n    if (streamMode === 'ON_DEMAND') {\n      return this.calculateOnDemandStreamCost();\n    }\n\n    const shardCount = this.customShardCount\n      ?? (props.ShardCount as number | undefined)\n      ?? this.DEFAULT_SHARD_COUNT;\n\n    const shardPrice = await pricingClient.getPrice({\n      serviceCode: 'AmazonKinesis',\n      region: normalizeRegion(region),\n      filters: [\n        { field: 'productFamily', value: 'Kinesis Streams' },\n        { field: 'usagetype', value: 'shardHour-Provisioned' },\n      ],\n    });\n\n    const rate = shardPrice ?? this.FALLBACK_SHARD_PRICE;\n    const monthlyCost = shardCount * rate * this.HOURS_PER_MONTH;\n\n    return {\n      amount: monthlyCost,\n      currency: 'USD',\n      confidence: shardPrice !== null ? 'high' : 'medium',\n      assumptions: [\n        `Provisioned mode: ${shardCount} shards × $${rate.toFixed(4)}/shard-hour × ${this.HOURS_PER_MONTH}h = $${monthlyCost.toFixed(2)}/month`,\n        ...(shardPrice === null ? [`Using fallback pricing (API data not available for region ${region})`] : []),\n      ],\n    };\n  }\n\n  private calculateOnDemandStreamCost(): MonthlyCost {\n    const ingestionGB = this.customIngestionGB ?? this.DEFAULT_INGESTION_GB;\n    const retrievalGB = this.customRetrievalGB ?? this.DEFAULT_RETRIEVAL_GB;\n\n    const ingestionCost = ingestionGB * this.FALLBACK_INGESTION_PRICE;\n    const retrievalCost = retrievalGB * this.FALLBACK_RETRIEVAL_PRICE;\n    const totalCost = ingestionCost + retrievalCost;\n\n    return {\n      amount: totalCost,\n      currency: 'USD',\n      confidence: 'medium',\n      assumptions: [\n        `On-demand mode`,\n        `Ingestion: ${ingestionGB} GB × $${this.FALLBACK_INGESTION_PRICE}/GB = $${ingestionCost.toFixed(2)}/month`,\n        `Retrieval: ${retrievalGB} GB × $${this.FALLBACK_RETRIEVAL_PRICE}/GB = $${retrievalCost.toFixed(2)}/month`,\n      ],\n    };\n  }\n\n  private calculateFirehoseCost(): MonthlyCost {\n    const dataGB = this.customFirehoseGB ?? this.DEFAULT_FIREHOSE_GB;\n    const monthlyCost = dataGB * this.FALLBACK_FIREHOSE_PRICE;\n\n    return {\n      amount: monthlyCost,\n      currency: 'USD',\n      confidence: 'medium',\n      assumptions: [\n        `Firehose ingestion: ${dataGB} GB × $${this.FALLBACK_FIREHOSE_PRICE}/GB = $${monthlyCost.toFixed(2)}/month`,\n        'Does not include format conversion or VPC delivery costs',\n      ],\n    };\n  }\n\n  private calculateAnalyticsCost(): MonthlyCost {\n    const kpus = this.customKPUs ?? this.DEFAULT_KPUS;\n    const monthlyCost = kpus * this.FALLBACK_KPU_PRICE * this.HOURS_PER_MONTH;\n\n    return {\n      amount: monthlyCost,\n      currency: 'USD',\n      confidence: 'medium',\n      assumptions: [\n        `Kinesis Analytics: ${kpus} KPUs × $${this.FALLBACK_KPU_PRICE}/KPU-hour × ${this.HOURS_PER_MONTH}h = $${monthlyCost.toFixed(2)}/month`,\n        '1 KPU = 1 vCPU + 4 GB memory',\n      ],\n    };\n  }\n}\n"]}

package/dist/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/pricing/calculators/Route53Calculator.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Route53Calculator = void 0;
+class Route53Calculator {
+    customMonthlyQueries;
+    HOSTED_ZONE_PRICE = 0.50;
+    BASIC_HEALTH_CHECK_PRICE = 0.50;
+    HTTPS_HEALTH_CHECK_PRICE = 1.00;
+    STANDARD_QUERY_PRICE_PER_MILLION = 0.40;
+    LATENCY_QUERY_PRICE_PER_MILLION = 0.60;
+    GEO_QUERY_PRICE_PER_MILLION = 0.70;
+    DEFAULT_MONTHLY_QUERIES = 1_000_000;
+    constructor(customMonthlyQueries) {
+        this.customMonthlyQueries = customMonthlyQueries;
+    }
+    supports(resourceType) {
+        return (resourceType === 'AWS::Route53::HostedZone' ||
+            resourceType === 'AWS::Route53::HealthCheck' ||
+            resourceType === 'AWS::Route53::RecordSet');
+    }
+    async calculateCost(resource, _region, _pricingClient) {
+        switch (resource.type) {
+            case 'AWS::Route53::HostedZone':
+                return this.calculateHostedZoneCost();
+            case 'AWS::Route53::HealthCheck':
+                return this.calculateHealthCheckCost(resource);
+            case 'AWS::Route53::RecordSet':
+                return this.calculateRecordSetCost(resource);
+            default:
+                return {
+                    amount: 0,
+                    currency: 'USD',
+                    confidence: 'unknown',
+                    assumptions: [`Unsupported Route 53 resource type: ${resource.type}`],
+                };
+        }
+    }
+    calculateHostedZoneCost() {
+        return {
+            amount: this.HOSTED_ZONE_PRICE,
+            currency: 'USD',
+            confidence: 'high',
+            assumptions: [
+                `Hosted zone: $${this.HOSTED_ZONE_PRICE.toFixed(2)}/month`,
+                'DNS query costs are calculated on RecordSet resources',
+            ],
+        };
+    }
+    calculateHealthCheckCost(resource) {
+        const props = resource.properties || {};
+        const healthCheckConfig = props.HealthCheckConfig;
+        const checkType = healthCheckConfig?.Type || 'HTTP';
+        const isAdvanced = ['HTTPS', 'HTTP_STR_MATCH', 'HTTPS_STR_MATCH'].includes(checkType);
+        const price = isAdvanced ? this.HTTPS_HEALTH_CHECK_PRICE : this.BASIC_HEALTH_CHECK_PRICE;
+        return {
+            amount: price,
+            currency: 'USD',
+            confidence: 'high',
+            assumptions: [
+                `Health check (${checkType}): $${price.toFixed(2)}/month`,
+            ],
+        };
+    }
+    calculateRecordSetCost(resource) {
+        const props = resource.properties || {};
+        // Alias records to AWS resources are free
+        if (props.AliasTarget) {
+            return {
+                amount: 0,
+                currency: 'USD',
+                confidence: 'high',
+                assumptions: ['Alias record to AWS resource: no query charges'],
+            };
+        }
+        const queries = this.customMonthlyQueries ?? this.DEFAULT_MONTHLY_QUERIES;
+        const queriesInMillions = queries / 1_000_000;
+        let pricePerMillion = this.STANDARD_QUERY_PRICE_PER_MILLION;
+        let routingType = 'standard';
+        if (props.Region) {
+            pricePerMillion = this.LATENCY_QUERY_PRICE_PER_MILLION;
+            routingType = 'latency-based';
+        }
+        else if (props.GeoLocation) {
+            pricePerMillion = this.GEO_QUERY_PRICE_PER_MILLION;
+            routingType = 'geolocation';
+        }
+        const monthlyCost = queriesInMillions * pricePerMillion;
+        return {
+            amount: monthlyCost,
+            currency: 'USD',
+            confidence: 'medium',
+            assumptions: [
+                `DNS queries (${routingType}): ${queriesInMillions}M × $${pricePerMillion.toFixed(2)}/M = $${monthlyCost.toFixed(2)}/month`,
+            ],
+        };
+    }
+}
+exports.Route53Calculator = Route53Calculator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Route53Calculator.js","sourceRoot":"","sources":["../../../src/pricing/calculators/Route53Calculator.ts"],"names":[],"mappings":"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","sourcesContent":["import { ResourceWithId } from '../../diff/types';\nimport { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';\n\nexport class Route53Calculator implements ResourceCostCalculator {\n  private readonly HOSTED_ZONE_PRICE = 0.50;\n  private readonly BASIC_HEALTH_CHECK_PRICE = 0.50;\n  private readonly HTTPS_HEALTH_CHECK_PRICE = 1.00;\n  private readonly STANDARD_QUERY_PRICE_PER_MILLION = 0.40;\n  private readonly LATENCY_QUERY_PRICE_PER_MILLION = 0.60;\n  private readonly GEO_QUERY_PRICE_PER_MILLION = 0.70;\n  private readonly DEFAULT_MONTHLY_QUERIES = 1_000_000;\n\n  constructor(\n    private readonly customMonthlyQueries?: number,\n  ) {}\n\n  supports(resourceType: string): boolean {\n    return (\n      resourceType === 'AWS::Route53::HostedZone' ||\n      resourceType === 'AWS::Route53::HealthCheck' ||\n      resourceType === 'AWS::Route53::RecordSet'\n    );\n  }\n\n  async calculateCost(\n    resource: ResourceWithId,\n    _region: string,\n    _pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    switch (resource.type) {\n      case 'AWS::Route53::HostedZone':\n        return this.calculateHostedZoneCost();\n      case 'AWS::Route53::HealthCheck':\n        return this.calculateHealthCheckCost(resource);\n      case 'AWS::Route53::RecordSet':\n        return this.calculateRecordSetCost(resource);\n      default:\n        return {\n          amount: 0,\n          currency: 'USD',\n          confidence: 'unknown',\n          assumptions: [`Unsupported Route 53 resource type: ${resource.type}`],\n        };\n    }\n  }\n\n  private calculateHostedZoneCost(): MonthlyCost {\n    return {\n      amount: this.HOSTED_ZONE_PRICE,\n      currency: 'USD',\n      confidence: 'high',\n      assumptions: [\n        `Hosted zone: $${this.HOSTED_ZONE_PRICE.toFixed(2)}/month`,\n        'DNS query costs are calculated on RecordSet resources',\n      ],\n    };\n  }\n\n  private calculateHealthCheckCost(resource: ResourceWithId): MonthlyCost {\n    const props = resource.properties || {};\n    const healthCheckConfig = props.HealthCheckConfig as Record<string, unknown> | undefined;\n    const checkType = (healthCheckConfig?.Type as string) || 'HTTP';\n\n    const isAdvanced = ['HTTPS', 'HTTP_STR_MATCH', 'HTTPS_STR_MATCH'].includes(checkType);\n    const price = isAdvanced ? this.HTTPS_HEALTH_CHECK_PRICE : this.BASIC_HEALTH_CHECK_PRICE;\n\n    return {\n      amount: price,\n      currency: 'USD',\n      confidence: 'high',\n      assumptions: [\n        `Health check (${checkType}): $${price.toFixed(2)}/month`,\n      ],\n    };\n  }\n\n  private calculateRecordSetCost(resource: ResourceWithId): MonthlyCost {\n    const props = resource.properties || {};\n\n    // Alias records to AWS resources are free\n    if (props.AliasTarget) {\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'high',\n        assumptions: ['Alias record to AWS resource: no query charges'],\n      };\n    }\n\n    const queries = this.customMonthlyQueries ?? this.DEFAULT_MONTHLY_QUERIES;\n    const queriesInMillions = queries / 1_000_000;\n\n    let pricePerMillion = this.STANDARD_QUERY_PRICE_PER_MILLION;\n    let routingType = 'standard';\n\n    if (props.Region) {\n      pricePerMillion = this.LATENCY_QUERY_PRICE_PER_MILLION;\n      routingType = 'latency-based';\n    } else if (props.GeoLocation) {\n      pricePerMillion = this.GEO_QUERY_PRICE_PER_MILLION;\n      routingType = 'geolocation';\n    }\n\n    const monthlyCost = queriesInMillions * pricePerMillion;\n\n    return {\n      amount: monthlyCost,\n      currency: 'USD',\n      confidence: 'medium',\n      assumptions: [\n        `DNS queries (${routingType}): ${queriesInMillions}M × $${pricePerMillion.toFixed(2)}/M = $${monthlyCost.toFixed(2)}/month`,\n      ],\n    };\n  }\n}\n"]}

package/dist/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/pricing/calculators/TransitGatewayCalculator.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransitGatewayCalculator = void 0;
+const RegionMapper_1 = require("../RegionMapper");
+class TransitGatewayCalculator {
+    customAttachments;
+    customMonthlyDataGB;
+    HOURS_PER_MONTH = 730;
+    DEFAULT_ATTACHMENTS = 3;
+    DEFAULT_MONTHLY_DATA_GB = 1000;
+    FALLBACK_ATTACHMENT_PRICE = 0.05;
+    FALLBACK_DATA_PRICE = 0.02;
+    constructor(customAttachments, customMonthlyDataGB) {
+        this.customAttachments = customAttachments;
+        this.customMonthlyDataGB = customMonthlyDataGB;
+    }
+    supports(resourceType) {
+        return (resourceType === 'AWS::EC2::TransitGateway' ||
+            resourceType === 'AWS::EC2::TransitGatewayAttachment');
+    }
+    async calculateCost(resource, region, pricingClient) {
+        try {
+            if (resource.type === 'AWS::EC2::TransitGatewayAttachment') {
+                return await this.calculateAttachmentCost(region, pricingClient);
+            }
+            return await this.calculateTransitGatewayCost(region, pricingClient);
+        }
+        catch (error) {
+            return {
+                amount: 0,
+                currency: 'USD',
+                confidence: 'unknown',
+                assumptions: [`Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`],
+            };
+        }
+    }
+    async calculateAttachmentCost(region, pricingClient) {
+        const hourlyRate = await pricingClient.getPrice({
+            serviceCode: 'AmazonVPC',
+            region: (0, RegionMapper_1.normalizeRegion)(region),
+            filters: [
+                { field: 'productFamily', value: 'TransitGateway' },
+                { field: 'operation', value: 'TransitGatewayVPCAttachment' },
+            ],
+        });
+        const rate = hourlyRate ?? this.FALLBACK_ATTACHMENT_PRICE;
+        const monthlyCost = rate * this.HOURS_PER_MONTH;
+        return {
+            amount: monthlyCost,
+            currency: 'USD',
+            confidence: hourlyRate !== null ? 'high' : 'medium',
+            assumptions: [
+                `Transit Gateway attachment: $${rate.toFixed(4)}/hour × ${this.HOURS_PER_MONTH}h = $${monthlyCost.toFixed(2)}/month`,
+                ...(hourlyRate === null ? [`Using fallback pricing (API data not available for region ${region})`] : []),
+                'Data processing costs are calculated on the Transit Gateway resource',
+            ],
+        };
+    }
+    async calculateTransitGatewayCost(region, pricingClient) {
+        const hourlyRate = await pricingClient.getPrice({
+            serviceCode: 'AmazonVPC',
+            region: (0, RegionMapper_1.normalizeRegion)(region),
+            filters: [
+                { field: 'productFamily', value: 'TransitGateway' },
+                { field: 'operation', value: 'TransitGatewayVPCAttachment' },
+            ],
+        });
+        const dataRate = await pricingClient.getPrice({
+            serviceCode: 'AmazonVPC',
+            region: (0, RegionMapper_1.normalizeRegion)(region),
+            filters: [
+                { field: 'productFamily', value: 'TransitGateway' },
+                { field: 'operation', value: 'TransitGatewayData' },
+            ],
+        });
+        const attachmentRate = hourlyRate ?? this.FALLBACK_ATTACHMENT_PRICE;
+        const dataProcessingRate = dataRate ?? this.FALLBACK_DATA_PRICE;
+        const usedFallback = hourlyRate === null || dataRate === null;
+        const attachments = this.customAttachments ?? this.DEFAULT_ATTACHMENTS;
+        const monthlyDataGB = this.customMonthlyDataGB ?? this.DEFAULT_MONTHLY_DATA_GB;
+        const attachmentCost = attachments * attachmentRate * this.HOURS_PER_MONTH;
+        const dataProcessingCost = monthlyDataGB * dataProcessingRate;
+        const totalCost = attachmentCost + dataProcessingCost;
+        return {
+            amount: totalCost,
+            currency: 'USD',
+            confidence: 'medium',
+            assumptions: [
+                `${attachments} attachments × $${attachmentRate.toFixed(4)}/hour × ${this.HOURS_PER_MONTH}h = $${attachmentCost.toFixed(2)}/month`,
+                `Data processing: ${monthlyDataGB} GB × $${dataProcessingRate.toFixed(4)}/GB = $${dataProcessingCost.toFixed(2)}/month`,
+                ...(usedFallback ? [`Using fallback pricing (API data not available for region ${region})`] : []),
+            ],
+        };
+    }
+}
+exports.TransitGatewayCalculator = TransitGatewayCalculator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TransitGatewayCalculator.js","sourceRoot":"","sources":["../../../src/pricing/calculators/TransitGatewayCalculator.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 TransitGatewayCalculator implements ResourceCostCalculator {\n  private readonly HOURS_PER_MONTH = 730;\n  private readonly DEFAULT_ATTACHMENTS = 3;\n  private readonly DEFAULT_MONTHLY_DATA_GB = 1000;\n  private readonly FALLBACK_ATTACHMENT_PRICE = 0.05;\n  private readonly FALLBACK_DATA_PRICE = 0.02;\n\n  constructor(\n    private readonly customAttachments?: number,\n    private readonly customMonthlyDataGB?: number,\n  ) {}\n\n  supports(resourceType: string): boolean {\n    return (\n      resourceType === 'AWS::EC2::TransitGateway' ||\n      resourceType === 'AWS::EC2::TransitGatewayAttachment'\n    );\n  }\n\n  async calculateCost(\n    resource: ResourceWithId,\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    try {\n      if (resource.type === 'AWS::EC2::TransitGatewayAttachment') {\n        return await this.calculateAttachmentCost(region, pricingClient);\n      }\n      return await this.calculateTransitGatewayCost(region, pricingClient);\n    } catch (error) {\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'unknown',\n        assumptions: [`Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`],\n      };\n    }\n  }\n\n  private async calculateAttachmentCost(\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    const hourlyRate = await pricingClient.getPrice({\n      serviceCode: 'AmazonVPC',\n      region: normalizeRegion(region),\n      filters: [\n        { field: 'productFamily', value: 'TransitGateway' },\n        { field: 'operation', value: 'TransitGatewayVPCAttachment' },\n      ],\n    });\n\n    const rate = hourlyRate ?? this.FALLBACK_ATTACHMENT_PRICE;\n    const monthlyCost = rate * this.HOURS_PER_MONTH;\n\n    return {\n      amount: monthlyCost,\n      currency: 'USD',\n      confidence: hourlyRate !== null ? 'high' : 'medium',\n      assumptions: [\n        `Transit Gateway attachment: $${rate.toFixed(4)}/hour × ${this.HOURS_PER_MONTH}h = $${monthlyCost.toFixed(2)}/month`,\n        ...(hourlyRate === null ? [`Using fallback pricing (API data not available for region ${region})`] : []),\n        'Data processing costs are calculated on the Transit Gateway resource',\n      ],\n    };\n  }\n\n  private async calculateTransitGatewayCost(\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    const hourlyRate = await pricingClient.getPrice({\n      serviceCode: 'AmazonVPC',\n      region: normalizeRegion(region),\n      filters: [\n        { field: 'productFamily', value: 'TransitGateway' },\n        { field: 'operation', value: 'TransitGatewayVPCAttachment' },\n      ],\n    });\n\n    const dataRate = await pricingClient.getPrice({\n      serviceCode: 'AmazonVPC',\n      region: normalizeRegion(region),\n      filters: [\n        { field: 'productFamily', value: 'TransitGateway' },\n        { field: 'operation', value: 'TransitGatewayData' },\n      ],\n    });\n\n    const attachmentRate = hourlyRate ?? this.FALLBACK_ATTACHMENT_PRICE;\n    const dataProcessingRate = dataRate ?? this.FALLBACK_DATA_PRICE;\n    const usedFallback = hourlyRate === null || dataRate === null;\n\n    const attachments = this.customAttachments ?? this.DEFAULT_ATTACHMENTS;\n    const monthlyDataGB = this.customMonthlyDataGB ?? this.DEFAULT_MONTHLY_DATA_GB;\n\n    const attachmentCost = attachments * attachmentRate * this.HOURS_PER_MONTH;\n    const dataProcessingCost = monthlyDataGB * dataProcessingRate;\n    const totalCost = attachmentCost + dataProcessingCost;\n\n    return {\n      amount: totalCost,\n      currency: 'USD',\n      confidence: 'medium',\n      assumptions: [\n        `${attachments} attachments × $${attachmentRate.toFixed(4)}/hour × ${this.HOURS_PER_MONTH}h = $${attachmentCost.toFixed(2)}/month`,\n        `Data processing: ${monthlyDataGB} GB × $${dataProcessingRate.toFixed(4)}/GB = $${dataProcessingCost.toFixed(2)}/month`,\n        ...(usedFallback ? [`Using fallback pricing (API data not available for region ${region})`] : []),\n      ],\n    };\n  }\n}\n"]}

package/dist/releasetag.txt

@@ -1 +1 @@
-v0.1.39
+v0.1.41