cdk-cost-analyzer 0.1.29 → 0.1.31

package/.cdk-cost-analyzer-cache/metadata.json

@@ -2,35 +2,35 @@
   "entries": {
     "AmazonS3:US East (N. Virginia):storageClass:General Purpose|volumeType:Standard": {
       "price": 0.023,
-      "timestamp": 1770930014058
+      "timestamp": 1770971189885
     },
     "AmazonDynamoDB:US East (N. Virginia):group:DDB-ReadUnits|productFamily:Amazon DynamoDB PayPerRequest Throughput": {
       "price": 0.023,
-      "timestamp": 1770930014064
+      "timestamp": 1770971189892
     },
     "AmazonDynamoDB:US East (N. Virginia):group:DDB-WriteUnits|productFamily:Amazon DynamoDB PayPerRequest Throughput": {
       "price": 0.023,
-      "timestamp": 1770930014064
+      "timestamp": 1770971189892
     },
     "AmazonEC2:US East (N. Virginia):capacitystatus:Used|instanceType:t3.micro|operatingSystem:Linux|preInstalledSw:NA|tenancy:Shared": {
       "price": 0.023,
-      "timestamp": 1770930014073
+      "timestamp": 1770971189901
     },
     "AWSLambda:US East (N. Virginia):group:AWS-Lambda-Requests": {
       "price": 0.023,
-      "timestamp": 1770930014082
+      "timestamp": 1770971189906
     },
     "AWSLambda:US East (N. Virginia):group:AWS-Lambda-Duration": {
       "price": 0.023,
-      "timestamp": 1770930014082
+      "timestamp": 1770971189906
     },
     "AmazonS3:EU (Frankfurt):storageClass:General Purpose|volumeType:Standard": {
       "price": 0.023,
-      "timestamp": 1770930021336
+      "timestamp": 1770971197326
     },
     "AmazonS3:invalid-region-123:storageClass:General Purpose|volumeType:Standard": {
       "price": 0.023,
-      "timestamp": 1770930021376
+      "timestamp": 1770971197371
     }
   }
 }

package/dist/config/types.d.ts

@@ -62,6 +62,40 @@ export interface UsageAssumptionsConfig {
     vpcEndpoint?: {
         dataProcessedGB?: number;
     };
+    /**
+     * SNS (Simple Notification Service) usage assumptions.
+     * These values are used to estimate monthly costs for SNS topics.
+     *
+     * @see https://aws.amazon.com/sns/pricing/
+     */
+    sns?: {
+        /** Number of publish requests per month (default: 1,000,000) */
+        monthlyPublishes?: number;
+        /** Number of HTTP/S deliveries per month (default: 1,000,000) */
+        httpDeliveries?: number;
+        /** Number of email deliveries per month (default: 0) */
+        emailDeliveries?: number;
+        /** Number of SMS deliveries per month (default: 0) */
+        smsDeliveries?: number;
+        /** Number of mobile push deliveries per month (default: 0) */
+        mobilePushDeliveries?: number;
+    };
+    /**
+     * Step Functions usage assumptions for cost estimation.
+     *
+     * Standard workflows are charged per state transition.
+     * Express workflows are charged per request and per GB-second of duration.
+     *
+     * @see https://aws.amazon.com/step-functions/pricing/
+     */
+    stepFunctions?: {
+        /** Number of workflow executions per month (default: 10,000) */
+        monthlyExecutions?: number;
+        /** Number of state transitions per execution (default: 10, for Standard workflows) */
+        stateTransitionsPerExecution?: number;
+        /** Average execution duration in milliseconds (default: 1000, for Express workflows) */
+        averageDurationMs?: 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,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

package/dist/pricing/PricingService.js

@@ -16,6 +16,8 @@ const NatGatewayCalculator_1 = require("./calculators/NatGatewayCalculator");
 const NLBCalculator_1 = require("./calculators/NLBCalculator");
 const RDSCalculator_1 = require("./calculators/RDSCalculator");
 const S3Calculator_1 = require("./calculators/S3Calculator");
+const SNSCalculator_1 = require("./calculators/SNSCalculator");
+const StepFunctionsCalculator_1 = require("./calculators/StepFunctionsCalculator");
 const VPCEndpointCalculator_1 = require("./calculators/VPCEndpointCalculator");
 const PricingClient_1 = require("./PricingClient");
 class PricingService {
@@ -55,6 +57,8 @@ class PricingService {
             new ElastiCacheCalculator_1.ElastiCacheCalculator(),
             new AutoScalingGroupCalculator_1.AutoScalingGroupCalculator(),
             new LaunchTemplateCalculator_1.LaunchTemplateCalculator(),
+            new SNSCalculator_1.SNSCalculator(usageAssumptions?.sns?.monthlyPublishes, usageAssumptions?.sns?.httpDeliveries, usageAssumptions?.sns?.emailDeliveries, usageAssumptions?.sns?.smsDeliveries, usageAssumptions?.sns?.mobilePushDeliveries),
+            new StepFunctionsCalculator_1.StepFunctionsCalculator(usageAssumptions?.stepFunctions?.monthlyExecutions, usageAssumptions?.stepFunctions?.stateTransitionsPerExecution, usageAssumptions?.stepFunctions?.averageDurationMs),
         ];
     }
     async getResourceCost(resource, region, templateResources) {
@@ -168,4 +172,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 { 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 { 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    ];\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 { 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 { SNSCalculator } from './calculators/SNSCalculator';\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 SNSCalculator(\n        usageAssumptions?.sns?.monthlyPublishes,\n        usageAssumptions?.sns?.httpDeliveries,\n        usageAssumptions?.sns?.emailDeliveries,\n        usageAssumptions?.sns?.smsDeliveries,\n        usageAssumptions?.sns?.mobilePushDeliveries,\n      ),\n      new StepFunctionsCalculator(\n        usageAssumptions?.stepFunctions?.monthlyExecutions,\n        usageAssumptions?.stepFunctions?.stateTransitionsPerExecution,\n        usageAssumptions?.stepFunctions?.averageDurationMs,\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/SNSCalculator.d.ts

@@ -0,0 +1,54 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+/**
+ * Cost breakdown for SNS pricing components
+ */
+export interface SNSCostBreakdown {
+    publishCost: number;
+    httpDeliveryCost: number;
+    emailDeliveryCost: number;
+    smsDeliveryCost: number;
+    mobilePushDeliveryCost: number;
+    totalCost: number;
+}
+/**
+ * Calculator for AWS::SNS::Topic resources.
+ *
+ * SNS Pricing Model (as of 2024):
+ * - Publishes: $0.50 per million requests (first 1M free)
+ * - HTTP/S deliveries: $0.60 per million
+ * - Email deliveries: $2.00 per 100,000
+ * - SMS: Varies by country (using US rate as default)
+ * - Mobile push: $0.50 per million
+ *
+ * @see https://aws.amazon.com/sns/pricing/
+ */
+export declare class SNSCalculator implements ResourceCostCalculator {
+    private readonly customMonthlyPublishes?;
+    private readonly customHttpDeliveries?;
+    private readonly customEmailDeliveries?;
+    private readonly customSmsDeliveries?;
+    private readonly customMobilePushDeliveries?;
+    private readonly DEFAULT_MONTHLY_PUBLISHES;
+    private readonly DEFAULT_HTTP_DELIVERIES;
+    private readonly DEFAULT_EMAIL_DELIVERIES;
+    private readonly DEFAULT_SMS_DELIVERIES;
+    private readonly DEFAULT_MOBILE_PUSH_DELIVERIES;
+    private readonly FALLBACK_PUBLISH_PRICE_PER_MILLION;
+    private readonly FALLBACK_HTTP_DELIVERY_PRICE_PER_MILLION;
+    private readonly FALLBACK_EMAIL_DELIVERY_PRICE_PER_100K;
+    private readonly FALLBACK_SMS_PRICE_PER_MESSAGE;
+    private readonly FALLBACK_MOBILE_PUSH_PRICE_PER_MILLION;
+    private readonly FREE_TIER_PUBLISHES;
+    constructor(customMonthlyPublishes?: number | undefined, customHttpDeliveries?: number | undefined, customEmailDeliveries?: number | undefined, customSmsDeliveries?: number | undefined, customMobilePushDeliveries?: number | undefined);
+    supports(resourceType: string): boolean;
+    calculateCost(resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+    private getPublishPrice;
+    private getHttpDeliveryPrice;
+    private getEmailDeliveryPrice;
+    private getSmsPrice;
+    private getMobilePushPrice;
+    private calculateCostBreakdown;
+    private buildAssumptions;
+    private hasCustomAssumptions;
+}

package/dist/pricing/calculators/SNSCalculator.js

@@ -0,0 +1,308 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SNSCalculator = void 0;
+const RegionMapper_1 = require("../RegionMapper");
+const Logger_1 = require("../../utils/Logger");
+/**
+ * Calculator for AWS::SNS::Topic resources.
+ *
+ * SNS Pricing Model (as of 2024):
+ * - Publishes: $0.50 per million requests (first 1M free)
+ * - HTTP/S deliveries: $0.60 per million
+ * - Email deliveries: $2.00 per 100,000
+ * - SMS: Varies by country (using US rate as default)
+ * - Mobile push: $0.50 per million
+ *
+ * @see https://aws.amazon.com/sns/pricing/
+ */
+class SNSCalculator {
+    customMonthlyPublishes;
+    customHttpDeliveries;
+    customEmailDeliveries;
+    customSmsDeliveries;
+    customMobilePushDeliveries;
+    // Default usage assumptions
+    DEFAULT_MONTHLY_PUBLISHES = 1_000_000;
+    DEFAULT_HTTP_DELIVERIES = 1_000_000;
+    DEFAULT_EMAIL_DELIVERIES = 0;
+    DEFAULT_SMS_DELIVERIES = 0;
+    DEFAULT_MOBILE_PUSH_DELIVERIES = 0;
+    // Fallback pricing rates (AWS SNS us-east-1 pricing as of 2024)
+    FALLBACK_PUBLISH_PRICE_PER_MILLION = 0.50;
+    FALLBACK_HTTP_DELIVERY_PRICE_PER_MILLION = 0.60;
+    FALLBACK_EMAIL_DELIVERY_PRICE_PER_100K = 2.00;
+    FALLBACK_SMS_PRICE_PER_MESSAGE = 0.00645; // US rate
+    FALLBACK_MOBILE_PUSH_PRICE_PER_MILLION = 0.50;
+    // Free tier thresholds
+    FREE_TIER_PUBLISHES = 1_000_000;
+    constructor(customMonthlyPublishes, customHttpDeliveries, customEmailDeliveries, customSmsDeliveries, customMobilePushDeliveries) {
+        this.customMonthlyPublishes = customMonthlyPublishes;
+        this.customHttpDeliveries = customHttpDeliveries;
+        this.customEmailDeliveries = customEmailDeliveries;
+        this.customSmsDeliveries = customSmsDeliveries;
+        this.customMobilePushDeliveries = customMobilePushDeliveries;
+    }
+    supports(resourceType) {
+        return resourceType === 'AWS::SNS::Topic';
+    }
+    async calculateCost(resource, region, pricingClient) {
+        const monthlyPublishes = this.customMonthlyPublishes ?? this.DEFAULT_MONTHLY_PUBLISHES;
+        const httpDeliveries = this.customHttpDeliveries ?? this.DEFAULT_HTTP_DELIVERIES;
+        const emailDeliveries = this.customEmailDeliveries ?? this.DEFAULT_EMAIL_DELIVERIES;
+        const smsDeliveries = this.customSmsDeliveries ?? this.DEFAULT_SMS_DELIVERIES;
+        const mobilePushDeliveries = this.customMobilePushDeliveries ?? this.DEFAULT_MOBILE_PUSH_DELIVERIES;
+        Logger_1.Logger.debug('SNS pricing calculation started', {
+            region,
+            logicalId: resource.logicalId,
+            monthlyPublishes,
+            httpDeliveries,
+            emailDeliveries,
+            smsDeliveries,
+            mobilePushDeliveries,
+        });
+        try {
+            const regionPrefix = (0, RegionMapper_1.getRegionPrefix)(region);
+            const normalizedRegion = (0, RegionMapper_1.normalizeRegion)(region);
+            // Fetch pricing data from AWS Pricing API
+            const publishPrice = await this.getPublishPrice(pricingClient, normalizedRegion, regionPrefix);
+            const httpDeliveryPrice = await this.getHttpDeliveryPrice(pricingClient, normalizedRegion, regionPrefix);
+            const emailDeliveryPrice = await this.getEmailDeliveryPrice(pricingClient, normalizedRegion, regionPrefix);
+            const smsPrice = await this.getSmsPrice(pricingClient, normalizedRegion, regionPrefix);
+            const mobilePushPrice = await this.getMobilePushPrice(pricingClient, normalizedRegion, regionPrefix);
+            const hasCustomAssumptions = this.hasCustomAssumptions();
+            const allPricesAvailable = publishPrice !== null &&
+                httpDeliveryPrice !== null &&
+                emailDeliveryPrice !== null &&
+                smsPrice !== null &&
+                mobilePushPrice !== null;
+            // Calculate costs using API prices or fallbacks
+            const costBreakdown = this.calculateCostBreakdown(monthlyPublishes, httpDeliveries, emailDeliveries, smsDeliveries, mobilePushDeliveries, publishPrice, httpDeliveryPrice, emailDeliveryPrice, smsPrice, mobilePushPrice);
+            Logger_1.Logger.debug('SNS cost calculated', {
+                costBreakdown,
+                allPricesAvailable,
+            });
+            const assumptions = this.buildAssumptions(monthlyPublishes, httpDeliveries, emailDeliveries, smsDeliveries, mobilePushDeliveries, costBreakdown, allPricesAvailable, publishPrice, httpDeliveryPrice, emailDeliveryPrice, smsPrice, mobilePushPrice);
+            // Determine confidence level
+            let confidence;
+            if (!allPricesAvailable && !hasCustomAssumptions) {
+                confidence = 'unknown';
+            }
+            else if (!allPricesAvailable && hasCustomAssumptions) {
+                confidence = 'low';
+            }
+            else {
+                confidence = 'medium';
+            }
+            // If all prices are unavailable and no custom assumptions, return zero cost
+            if (!allPricesAvailable && !hasCustomAssumptions) {
+                return {
+                    amount: 0,
+                    currency: 'USD',
+                    confidence: 'unknown',
+                    assumptions: [
+                        `Pricing data not available for SNS in region ${region}`,
+                        ...assumptions,
+                    ],
+                };
+            }
+            return {
+                amount: costBreakdown.totalCost,
+                currency: 'USD',
+                confidence,
+                assumptions,
+            };
+        }
+        catch (error) {
+            Logger_1.Logger.debug('SNS pricing calculation failed', {
+                error: error instanceof Error ? error.message : String(error),
+                region,
+            });
+            // If user provided custom assumptions, use fallback pricing
+            if (this.hasCustomAssumptions()) {
+                const costBreakdown = this.calculateCostBreakdown(monthlyPublishes, httpDeliveries, emailDeliveries, smsDeliveries, mobilePushDeliveries, null, null, null, null, null);
+                return {
+                    amount: costBreakdown.totalCost,
+                    currency: 'USD',
+                    confidence: 'low',
+                    assumptions: [
+                        'Using fallback pricing (API error)',
+                        `Assumes ${monthlyPublishes.toLocaleString()} publishes per month`,
+                        `Assumes ${httpDeliveries.toLocaleString()} HTTP/S deliveries per month`,
+                    ],
+                };
+            }
+            return {
+                amount: 0,
+                currency: 'USD',
+                confidence: 'unknown',
+                assumptions: [`Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`],
+            };
+        }
+    }
+    async getPublishPrice(pricingClient, normalizedRegion, regionPrefix) {
+        const usageType = regionPrefix ? `${regionPrefix}-PublishRequests` : 'PublishRequests';
+        return pricingClient.getPrice({
+            serviceCode: 'AmazonSNS',
+            region: normalizedRegion,
+            filters: [
+                { field: 'productFamily', value: 'Notification' },
+                { field: 'usagetype', value: usageType },
+            ],
+        });
+    }
+    async getHttpDeliveryPrice(pricingClient, normalizedRegion, regionPrefix) {
+        const usageType = regionPrefix ? `${regionPrefix}-DeliveryAttempts-HTTP` : 'DeliveryAttempts-HTTP';
+        return pricingClient.getPrice({
+            serviceCode: 'AmazonSNS',
+            region: normalizedRegion,
+            filters: [
+                { field: 'productFamily', value: 'Notification' },
+                { field: 'usagetype', value: usageType },
+            ],
+        });
+    }
+    async getEmailDeliveryPrice(pricingClient, normalizedRegion, regionPrefix) {
+        const usageType = regionPrefix ? `${regionPrefix}-DeliveryAttempts-EMAIL` : 'DeliveryAttempts-EMAIL';
+        return pricingClient.getPrice({
+            serviceCode: 'AmazonSNS',
+            region: normalizedRegion,
+            filters: [
+                { field: 'productFamily', value: 'Notification' },
+                { field: 'usagetype', value: usageType },
+            ],
+        });
+    }
+    async getSmsPrice(pricingClient, normalizedRegion, regionPrefix) {
+        const usageType = regionPrefix ? `${regionPrefix}-DeliveryAttempts-SMS` : 'DeliveryAttempts-SMS';
+        return pricingClient.getPrice({
+            serviceCode: 'AmazonSNS',
+            region: normalizedRegion,
+            filters: [
+                { field: 'productFamily', value: 'SMS' },
+                { field: 'usagetype', value: usageType },
+            ],
+        });
+    }
+    async getMobilePushPrice(pricingClient, normalizedRegion, regionPrefix) {
+        const usageType = regionPrefix ? `${regionPrefix}-DeliveryAttempts-APNS` : 'DeliveryAttempts-APNS';
+        return pricingClient.getPrice({
+            serviceCode: 'AmazonSNS',
+            region: normalizedRegion,
+            filters: [
+                { field: 'productFamily', value: 'Mobile Push Notification' },
+                { field: 'usagetype', value: usageType },
+            ],
+        });
+    }
+    calculateCostBreakdown(monthlyPublishes, httpDeliveries, emailDeliveries, smsDeliveries, mobilePushDeliveries, publishPrice, httpDeliveryPrice, emailDeliveryPrice, smsPrice, mobilePushPrice) {
+        // Use API prices if available, otherwise fallback
+        const effectivePublishPrice = publishPrice ?? this.FALLBACK_PUBLISH_PRICE_PER_MILLION;
+        const effectiveHttpDeliveryPrice = httpDeliveryPrice ?? this.FALLBACK_HTTP_DELIVERY_PRICE_PER_MILLION;
+        const effectiveEmailDeliveryPrice = emailDeliveryPrice ?? this.FALLBACK_EMAIL_DELIVERY_PRICE_PER_100K;
+        const effectiveSmsPrice = smsPrice ?? this.FALLBACK_SMS_PRICE_PER_MESSAGE;
+        const effectiveMobilePushPrice = mobilePushPrice ?? this.FALLBACK_MOBILE_PUSH_PRICE_PER_MILLION;
+        // Calculate publish cost (first 1M free)
+        const billablePublishes = Math.max(0, monthlyPublishes - this.FREE_TIER_PUBLISHES);
+        const publishCost = (billablePublishes / 1_000_000) * effectivePublishPrice;
+        // HTTP/S delivery cost: $X per million
+        const httpDeliveryCost = (httpDeliveries / 1_000_000) * effectiveHttpDeliveryPrice;
+        // Email delivery cost: $X per 100,000
+        const emailDeliveryCost = (emailDeliveries / 100_000) * effectiveEmailDeliveryPrice;
+        // SMS delivery cost: $X per message (varies by country, using US rate)
+        const smsDeliveryCost = smsDeliveries * effectiveSmsPrice;
+        // Mobile push delivery cost: $X per million
+        const mobilePushDeliveryCost = (mobilePushDeliveries / 1_000_000) * effectiveMobilePushPrice;
+        const totalCost = publishCost + httpDeliveryCost + emailDeliveryCost + smsDeliveryCost + mobilePushDeliveryCost;
+        return {
+            publishCost,
+            httpDeliveryCost,
+            emailDeliveryCost,
+            smsDeliveryCost,
+            mobilePushDeliveryCost,
+            totalCost,
+        };
+    }
+    buildAssumptions(monthlyPublishes, httpDeliveries, emailDeliveries, smsDeliveries, mobilePushDeliveries, costBreakdown, allPricesAvailable, publishPrice, httpDeliveryPrice, emailDeliveryPrice, smsPrice, mobilePushPrice) {
+        const assumptions = [];
+        // Add usage assumptions
+        assumptions.push(`Assumes ${monthlyPublishes.toLocaleString()} publishes per month`);
+        assumptions.push(`Assumes ${httpDeliveries.toLocaleString()} HTTP/S deliveries per month`);
+        if (emailDeliveries > 0) {
+            assumptions.push(`Assumes ${emailDeliveries.toLocaleString()} email deliveries per month`);
+        }
+        if (smsDeliveries > 0) {
+            assumptions.push(`Assumes ${smsDeliveries.toLocaleString()} SMS deliveries per month (using US rate)`);
+        }
+        if (mobilePushDeliveries > 0) {
+            assumptions.push(`Assumes ${mobilePushDeliveries.toLocaleString()} mobile push deliveries per month`);
+        }
+        // Add free tier information
+        if (monthlyPublishes <= this.FREE_TIER_PUBLISHES) {
+            assumptions.push(`First ${this.FREE_TIER_PUBLISHES.toLocaleString()} publishes are free`);
+        }
+        else {
+            const billablePublishes = monthlyPublishes - this.FREE_TIER_PUBLISHES;
+            assumptions.push(`${this.FREE_TIER_PUBLISHES.toLocaleString()} free tier publishes applied, ${billablePublishes.toLocaleString()} billable`);
+        }
+        // Add cost breakdown
+        if (costBreakdown.publishCost > 0) {
+            assumptions.push(`Publish cost: $${costBreakdown.publishCost.toFixed(2)}`);
+        }
+        if (costBreakdown.httpDeliveryCost > 0) {
+            assumptions.push(`HTTP/S delivery cost: $${costBreakdown.httpDeliveryCost.toFixed(2)}`);
+        }
+        if (costBreakdown.emailDeliveryCost > 0) {
+            assumptions.push(`Email delivery cost: $${costBreakdown.emailDeliveryCost.toFixed(2)}`);
+        }
+        if (costBreakdown.smsDeliveryCost > 0) {
+            assumptions.push(`SMS delivery cost: $${costBreakdown.smsDeliveryCost.toFixed(2)}`);
+        }
+        if (costBreakdown.mobilePushDeliveryCost > 0) {
+            assumptions.push(`Mobile push delivery cost: $${costBreakdown.mobilePushDeliveryCost.toFixed(2)}`);
+        }
+        // Add fallback pricing notes
+        if (!allPricesAvailable) {
+            if (publishPrice === null) {
+                assumptions.push('Using fallback publish pricing (API unavailable)');
+            }
+            if (httpDeliveryPrice === null) {
+                assumptions.push('Using fallback HTTP delivery pricing (API unavailable)');
+            }
+            if (emailDeliveryPrice === null && emailDeliveries > 0) {
+                assumptions.push('Using fallback email delivery pricing (API unavailable)');
+            }
+            if (smsPrice === null && smsDeliveries > 0) {
+                assumptions.push('Using fallback SMS pricing (API unavailable)');
+            }
+            if (mobilePushPrice === null && mobilePushDeliveries > 0) {
+                assumptions.push('Using fallback mobile push pricing (API unavailable)');
+            }
+        }
+        // Add custom assumption notes
+        if (this.customMonthlyPublishes !== undefined) {
+            assumptions.push('Using custom publish count from configuration');
+        }
+        if (this.customHttpDeliveries !== undefined) {
+            assumptions.push('Using custom HTTP delivery count from configuration');
+        }
+        if (this.customEmailDeliveries !== undefined) {
+            assumptions.push('Using custom email delivery count from configuration');
+        }
+        if (this.customSmsDeliveries !== undefined) {
+            assumptions.push('Using custom SMS delivery count from configuration');
+        }
+        if (this.customMobilePushDeliveries !== undefined) {
+            assumptions.push('Using custom mobile push delivery count from configuration');
+        }
+        return assumptions;
+    }
+    hasCustomAssumptions() {
+        return (this.customMonthlyPublishes !== undefined ||
+            this.customHttpDeliveries !== undefined ||
+            this.customEmailDeliveries !== undefined ||
+            this.customSmsDeliveries !== undefined ||
+            this.customMobilePushDeliveries !== undefined);
+    }
+}
+exports.SNSCalculator = SNSCalculator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SNSCalculator.js","sourceRoot":"","sources":["../../../src/pricing/calculators/SNSCalculator.ts"],"names":[],"mappings":";;;AAEA,kDAAmE;AACnE,+CAA4C;AAc5C;;;;;;;;;;;GAWG;AACH,MAAa,aAAa;IAmBL;IACA;IACA;IACA;IACA;IAtBnB,4BAA4B;IACX,yBAAyB,GAAG,SAAS,CAAC;IACtC,uBAAuB,GAAG,SAAS,CAAC;IACpC,wBAAwB,GAAG,CAAC,CAAC;IAC7B,sBAAsB,GAAG,CAAC,CAAC;IAC3B,8BAA8B,GAAG,CAAC,CAAC;IAEpD,gEAAgE;IAC/C,kCAAkC,GAAG,IAAI,CAAC;IAC1C,wCAAwC,GAAG,IAAI,CAAC;IAChD,sCAAsC,GAAG,IAAI,CAAC;IAC9C,8BAA8B,GAAG,OAAO,CAAC,CAAC,UAAU;IACpD,sCAAsC,GAAG,IAAI,CAAC;IAE/D,uBAAuB;IACN,mBAAmB,GAAG,SAAS,CAAC;IAEjD,YACmB,sBAA+B,EAC/B,oBAA6B,EAC7B,qBAA8B,EAC9B,mBAA4B,EAC5B,0BAAmC;QAJnC,2BAAsB,GAAtB,sBAAsB,CAAS;QAC/B,yBAAoB,GAApB,oBAAoB,CAAS;QAC7B,0BAAqB,GAArB,qBAAqB,CAAS;QAC9B,wBAAmB,GAAnB,mBAAmB,CAAS;QAC5B,+BAA0B,GAA1B,0BAA0B,CAAS;IACnD,CAAC;IAEJ,QAAQ,CAAC,YAAoB;QAC3B,OAAO,YAAY,KAAK,iBAAiB,CAAC;IAC5C,CAAC;IAED,KAAK,CAAC,aAAa,CACjB,QAAwB,EACxB,MAAc,EACd,aAA4B;QAE5B,MAAM,gBAAgB,GAAG,IAAI,CAAC,sBAAsB,IAAI,IAAI,CAAC,yBAAyB,CAAC;QACvF,MAAM,cAAc,GAAG,IAAI,CAAC,oBAAoB,IAAI,IAAI,CAAC,uBAAuB,CAAC;QACjF,MAAM,eAAe,GAAG,IAAI,CAAC,qBAAqB,IAAI,IAAI,CAAC,wBAAwB,CAAC;QACpF,MAAM,aAAa,GAAG,IAAI,CAAC,mBAAmB,IAAI,IAAI,CAAC,sBAAsB,CAAC;QAC9E,MAAM,oBAAoB,GAAG,IAAI,CAAC,0BAA0B,IAAI,IAAI,CAAC,8BAA8B,CAAC;QAEpG,eAAM,CAAC,KAAK,CAAC,iCAAiC,EAAE;YAC9C,MAAM;YACN,SAAS,EAAE,QAAQ,CAAC,SAAS;YAC7B,gBAAgB;YAChB,cAAc;YACd,eAAe;YACf,aAAa;YACb,oBAAoB;SACrB,CAAC,CAAC;QAEH,IAAI,CAAC;YACH,MAAM,YAAY,GAAG,IAAA,8BAAe,EAAC,MAAM,CAAC,CAAC;YAC7C,MAAM,gBAAgB,GAAG,IAAA,8BAAe,EAAC,MAAM,CAAC,CAAC;YAEjD,0CAA0C;YAC1C,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,aAAa,EAAE,gBAAgB,EAAE,YAAY,CAAC,CAAC;YAC/F,MAAM,iBAAiB,GAAG,MAAM,IAAI,CAAC,oBAAoB,CAAC,aAAa,EAAE,gBAAgB,EAAE,YAAY,CAAC,CAAC;YACzG,MAAM,kBAAkB,GAAG,MAAM,IAAI,CAAC,qBAAqB,CAAC,aAAa,EAAE,gBAAgB,EAAE,YAAY,CAAC,CAAC;YAC3G,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,gBAAgB,EAAE,YAAY,CAAC,CAAC;YACvF,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,aAAa,EAAE,gBAAgB,EAAE,YAAY,CAAC,CAAC;YAErG,MAAM,oBAAoB,GAAG,IAAI,CAAC,oBAAoB,EAAE,CAAC;YACzD,MAAM,kBAAkB,GAAG,YAAY,KAAK,IAAI;gBAC9C,iBAAiB,KAAK,IAAI;gBAC1B,kBAAkB,KAAK,IAAI;gBAC3B,QAAQ,KAAK,IAAI;gBACjB,eAAe,KAAK,IAAI,CAAC;YAE3B,gDAAgD;YAChD,MAAM,aAAa,GAAG,IAAI,CAAC,sBAAsB,CAC/C,gBAAgB,EAChB,cAAc,EACd,eAAe,EACf,aAAa,EACb,oBAAoB,EACpB,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EAClB,QAAQ,EACR,eAAe,CAChB,CAAC;YAEF,eAAM,CAAC,KAAK,CAAC,qBAAqB,EAAE;gBAClC,aAAa;gBACb,kBAAkB;aACnB,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,IAAI,CAAC,gBAAgB,CACvC,gBAAgB,EAChB,cAAc,EACd,eAAe,EACf,aAAa,EACb,oBAAoB,EACpB,aAAa,EACb,kBAAkB,EAClB,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EAClB,QAAQ,EACR,eAAe,CAChB,CAAC;YAEF,6BAA6B;YAC7B,IAAI,UAAiD,CAAC;YACtD,IAAI,CAAC,kBAAkB,IAAI,CAAC,oBAAoB,EAAE,CAAC;gBACjD,UAAU,GAAG,SAAS,CAAC;YACzB,CAAC;iBAAM,IAAI,CAAC,kBAAkB,IAAI,oBAAoB,EAAE,CAAC;gBACvD,UAAU,GAAG,KAAK,CAAC;YACrB,CAAC;iBAAM,CAAC;gBACN,UAAU,GAAG,QAAQ,CAAC;YACxB,CAAC;YAED,4EAA4E;YAC5E,IAAI,CAAC,kBAAkB,IAAI,CAAC,oBAAoB,EAAE,CAAC;gBACjD,OAAO;oBACL,MAAM,EAAE,CAAC;oBACT,QAAQ,EAAE,KAAK;oBACf,UAAU,EAAE,SAAS;oBACrB,WAAW,EAAE;wBACX,gDAAgD,MAAM,EAAE;wBACxD,GAAG,WAAW;qBACf;iBACF,CAAC;YACJ,CAAC;YAED,OAAO;gBACL,MAAM,EAAE,aAAa,CAAC,SAAS;gBAC/B,QAAQ,EAAE,KAAK;gBACf,UAAU;gBACV,WAAW;aACZ,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,eAAM,CAAC,KAAK,CAAC,gCAAgC,EAAE;gBAC7C,KAAK,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;gBAC7D,MAAM;aACP,CAAC,CAAC;YAEH,4DAA4D;YAC5D,IAAI,IAAI,CAAC,oBAAoB,EAAE,EAAE,CAAC;gBAChC,MAAM,aAAa,GAAG,IAAI,CAAC,sBAAsB,CAC/C,gBAAgB,EAChB,cAAc,EACd,eAAe,EACf,aAAa,EACb,oBAAoB,EACpB,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,CACL,CAAC;gBAEF,OAAO;oBACL,MAAM,EAAE,aAAa,CAAC,SAAS;oBAC/B,QAAQ,EAAE,KAAK;oBACf,UAAU,EAAE,KAAK;oBACjB,WAAW,EAAE;wBACX,oCAAoC;wBACpC,WAAW,gBAAgB,CAAC,cAAc,EAAE,sBAAsB;wBAClE,WAAW,cAAc,CAAC,cAAc,EAAE,8BAA8B;qBACzE;iBACF,CAAC;YACJ,CAAC;YAED,OAAO;gBACL,MAAM,EAAE,CAAC;gBACT,QAAQ,EAAE,KAAK;gBACf,UAAU,EAAE,SAAS;gBACrB,WAAW,EAAE,CAAC,4BAA4B,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;aACpG,CAAC;QACJ,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,eAAe,CAC3B,aAA4B,EAC5B,gBAAwB,EACxB,YAAoB;QAEpB,MAAM,SAAS,GAAG,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,kBAAkB,CAAC,CAAC,CAAC,iBAAiB,CAAC;QACvF,OAAO,aAAa,CAAC,QAAQ,CAAC;YAC5B,WAAW,EAAE,WAAW;YACxB,MAAM,EAAE,gBAAgB;YACxB,OAAO,EAAE;gBACP,EAAE,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE,cAAc,EAAE;gBACjD,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,EAAE;aACzC;SACF,CAAC,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,oBAAoB,CAChC,aAA4B,EAC5B,gBAAwB,EACxB,YAAoB;QAEpB,MAAM,SAAS,GAAG,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,wBAAwB,CAAC,CAAC,CAAC,uBAAuB,CAAC;QACnG,OAAO,aAAa,CAAC,QAAQ,CAAC;YAC5B,WAAW,EAAE,WAAW;YACxB,MAAM,EAAE,gBAAgB;YACxB,OAAO,EAAE;gBACP,EAAE,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE,cAAc,EAAE;gBACjD,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,EAAE;aACzC;SACF,CAAC,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,qBAAqB,CACjC,aAA4B,EAC5B,gBAAwB,EACxB,YAAoB;QAEpB,MAAM,SAAS,GAAG,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,yBAAyB,CAAC,CAAC,CAAC,wBAAwB,CAAC;QACrG,OAAO,aAAa,CAAC,QAAQ,CAAC;YAC5B,WAAW,EAAE,WAAW;YACxB,MAAM,EAAE,gBAAgB;YACxB,OAAO,EAAE;gBACP,EAAE,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE,cAAc,EAAE;gBACjD,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,EAAE;aACzC;SACF,CAAC,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,WAAW,CACvB,aAA4B,EAC5B,gBAAwB,EACxB,YAAoB;QAEpB,MAAM,SAAS,GAAG,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,uBAAuB,CAAC,CAAC,CAAC,sBAAsB,CAAC;QACjG,OAAO,aAAa,CAAC,QAAQ,CAAC;YAC5B,WAAW,EAAE,WAAW;YACxB,MAAM,EAAE,gBAAgB;YACxB,OAAO,EAAE;gBACP,EAAE,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE,KAAK,EAAE;gBACxC,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,EAAE;aACzC;SACF,CAAC,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,kBAAkB,CAC9B,aAA4B,EAC5B,gBAAwB,EACxB,YAAoB;QAEpB,MAAM,SAAS,GAAG,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,wBAAwB,CAAC,CAAC,CAAC,uBAAuB,CAAC;QACnG,OAAO,aAAa,CAAC,QAAQ,CAAC;YAC5B,WAAW,EAAE,WAAW;YACxB,MAAM,EAAE,gBAAgB;YACxB,OAAO,EAAE;gBACP,EAAE,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE,0BAA0B,EAAE;gBAC7D,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,EAAE;aACzC;SACF,CAAC,CAAC;IACL,CAAC;IAEO,sBAAsB,CAC5B,gBAAwB,EACxB,cAAsB,EACtB,eAAuB,EACvB,aAAqB,EACrB,oBAA4B,EAC5B,YAA2B,EAC3B,iBAAgC,EAChC,kBAAiC,EACjC,QAAuB,EACvB,eAA8B;QAE9B,kDAAkD;QAClD,MAAM,qBAAqB,GAAG,YAAY,IAAI,IAAI,CAAC,kCAAkC,CAAC;QACtF,MAAM,0BAA0B,GAAG,iBAAiB,IAAI,IAAI,CAAC,wCAAwC,CAAC;QACtG,MAAM,2BAA2B,GAAG,kBAAkB,IAAI,IAAI,CAAC,sCAAsC,CAAC;QACtG,MAAM,iBAAiB,GAAG,QAAQ,IAAI,IAAI,CAAC,8BAA8B,CAAC;QAC1E,MAAM,wBAAwB,GAAG,eAAe,IAAI,IAAI,CAAC,sCAAsC,CAAC;QAEhG,yCAAyC;QACzC,MAAM,iBAAiB,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,gBAAgB,GAAG,IAAI,CAAC,mBAAmB,CAAC,CAAC;QACnF,MAAM,WAAW,GAAG,CAAC,iBAAiB,GAAG,SAAS,CAAC,GAAG,qBAAqB,CAAC;QAE5E,uCAAuC;QACvC,MAAM,gBAAgB,GAAG,CAAC,cAAc,GAAG,SAAS,CAAC,GAAG,0BAA0B,CAAC;QAEnF,sCAAsC;QACtC,MAAM,iBAAiB,GAAG,CAAC,eAAe,GAAG,OAAO,CAAC,GAAG,2BAA2B,CAAC;QAEpF,uEAAuE;QACvE,MAAM,eAAe,GAAG,aAAa,GAAG,iBAAiB,CAAC;QAE1D,4CAA4C;QAC5C,MAAM,sBAAsB,GAAG,CAAC,oBAAoB,GAAG,SAAS,CAAC,GAAG,wBAAwB,CAAC;QAE7F,MAAM,SAAS,GAAG,WAAW,GAAG,gBAAgB,GAAG,iBAAiB,GAAG,eAAe,GAAG,sBAAsB,CAAC;QAEhH,OAAO;YACL,WAAW;YACX,gBAAgB;YAChB,iBAAiB;YACjB,eAAe;YACf,sBAAsB;YACtB,SAAS;SACV,CAAC;IACJ,CAAC;IAEO,gBAAgB,CACtB,gBAAwB,EACxB,cAAsB,EACtB,eAAuB,EACvB,aAAqB,EACrB,oBAA4B,EAC5B,aAA+B,EAC/B,kBAA2B,EAC3B,YAA2B,EAC3B,iBAAgC,EAChC,kBAAiC,EACjC,QAAuB,EACvB,eAA8B;QAE9B,MAAM,WAAW,GAAa,EAAE,CAAC;QAEjC,wBAAwB;QACxB,WAAW,CAAC,IAAI,CAAC,WAAW,gBAAgB,CAAC,cAAc,EAAE,sBAAsB,CAAC,CAAC;QACrF,WAAW,CAAC,IAAI,CAAC,WAAW,cAAc,CAAC,cAAc,EAAE,8BAA8B,CAAC,CAAC;QAE3F,IAAI,eAAe,GAAG,CAAC,EAAE,CAAC;YACxB,WAAW,CAAC,IAAI,CAAC,WAAW,eAAe,CAAC,cAAc,EAAE,6BAA6B,CAAC,CAAC;QAC7F,CAAC;QACD,IAAI,aAAa,GAAG,CAAC,EAAE,CAAC;YACtB,WAAW,CAAC,IAAI,CAAC,WAAW,aAAa,CAAC,cAAc,EAAE,2CAA2C,CAAC,CAAC;QACzG,CAAC;QACD,IAAI,oBAAoB,GAAG,CAAC,EAAE,CAAC;YAC7B,WAAW,CAAC,IAAI,CAAC,WAAW,oBAAoB,CAAC,cAAc,EAAE,mCAAmC,CAAC,CAAC;QACxG,CAAC;QAED,4BAA4B;QAC5B,IAAI,gBAAgB,IAAI,IAAI,CAAC,mBAAmB,EAAE,CAAC;YACjD,WAAW,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,mBAAmB,CAAC,cAAc,EAAE,qBAAqB,CAAC,CAAC;QAC5F,CAAC;aAAM,CAAC;YACN,MAAM,iBAAiB,GAAG,gBAAgB,GAAG,IAAI,CAAC,mBAAmB,CAAC;YACtE,WAAW,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,mBAAmB,CAAC,cAAc,EAAE,iCAAiC,iBAAiB,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC;QAC/I,CAAC;QAED,qBAAqB;QACrB,IAAI,aAAa,CAAC,WAAW,GAAG,CAAC,EAAE,CAAC;YAClC,WAAW,CAAC,IAAI,CAAC,kBAAkB,aAAa,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAC7E,CAAC;QACD,IAAI,aAAa,CAAC,gBAAgB,GAAG,CAAC,EAAE,CAAC;YACvC,WAAW,CAAC,IAAI,CAAC,0BAA0B,aAAa,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAC1F,CAAC;QACD,IAAI,aAAa,CAAC,iBAAiB,GAAG,CAAC,EAAE,CAAC;YACxC,WAAW,CAAC,IAAI,CAAC,yBAAyB,aAAa,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAC1F,CAAC;QACD,IAAI,aAAa,CAAC,eAAe,GAAG,CAAC,EAAE,CAAC;YACtC,WAAW,CAAC,IAAI,CAAC,uBAAuB,aAAa,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QACtF,CAAC;QACD,IAAI,aAAa,CAAC,sBAAsB,GAAG,CAAC,EAAE,CAAC;YAC7C,WAAW,CAAC,IAAI,CAAC,+BAA+B,aAAa,CAAC,sBAAsB,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QACrG,CAAC;QAED,6BAA6B;QAC7B,IAAI,CAAC,kBAAkB,EAAE,CAAC;YACxB,IAAI,YAAY,KAAK,IAAI,EAAE,CAAC;gBAC1B,WAAW,CAAC,IAAI,CAAC,kDAAkD,CAAC,CAAC;YACvE,CAAC;YACD,IAAI,iBAAiB,KAAK,IAAI,EAAE,CAAC;gBAC/B,WAAW,CAAC,IAAI,CAAC,wDAAwD,CAAC,CAAC;YAC7E,CAAC;YACD,IAAI,kBAAkB,KAAK,IAAI,IAAI,eAAe,GAAG,CAAC,EAAE,CAAC;gBACvD,WAAW,CAAC,IAAI,CAAC,yDAAyD,CAAC,CAAC;YAC9E,CAAC;YACD,IAAI,QAAQ,KAAK,IAAI,IAAI,aAAa,GAAG,CAAC,EAAE,CAAC;gBAC3C,WAAW,CAAC,IAAI,CAAC,8CAA8C,CAAC,CAAC;YACnE,CAAC;YACD,IAAI,eAAe,KAAK,IAAI,IAAI,oBAAoB,GAAG,CAAC,EAAE,CAAC;gBACzD,WAAW,CAAC,IAAI,CAAC,sDAAsD,CAAC,CAAC;YAC3E,CAAC;QACH,CAAC;QAED,8BAA8B;QAC9B,IAAI,IAAI,CAAC,sBAAsB,KAAK,SAAS,EAAE,CAAC;YAC9C,WAAW,CAAC,IAAI,CAAC,+CAA+C,CAAC,CAAC;QACpE,CAAC;QACD,IAAI,IAAI,CAAC,oBAAoB,KAAK,SAAS,EAAE,CAAC;YAC5C,WAAW,CAAC,IAAI,CAAC,qDAAqD,CAAC,CAAC;QAC1E,CAAC;QACD,IAAI,IAAI,CAAC,qBAAqB,KAAK,SAAS,EAAE,CAAC;YAC7C,WAAW,CAAC,IAAI,CAAC,sDAAsD,CAAC,CAAC;QAC3E,CAAC;QACD,IAAI,IAAI,CAAC,mBAAmB,KAAK,SAAS,EAAE,CAAC;YAC3C,WAAW,CAAC,IAAI,CAAC,oDAAoD,CAAC,CAAC;QACzE,CAAC;QACD,IAAI,IAAI,CAAC,0BAA0B,KAAK,SAAS,EAAE,CAAC;YAClD,WAAW,CAAC,IAAI,CAAC,4DAA4D,CAAC,CAAC;QACjF,CAAC;QAED,OAAO,WAAW,CAAC;IACrB,CAAC;IAEO,oBAAoB;QAC1B,OAAO,CACL,IAAI,CAAC,sBAAsB,KAAK,SAAS;YACzC,IAAI,CAAC,oBAAoB,KAAK,SAAS;YACvC,IAAI,CAAC,qBAAqB,KAAK,SAAS;YACxC,IAAI,CAAC,mBAAmB,KAAK,SAAS;YACtC,IAAI,CAAC,0BAA0B,KAAK,SAAS,CAC9C,CAAC;IACJ,CAAC;CACF;AApZD,sCAoZC","sourcesContent":["import { ResourceWithId } from '../../diff/types';\nimport { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';\nimport { normalizeRegion, getRegionPrefix } from '../RegionMapper';\nimport { Logger } from '../../utils/Logger';\n\n/**\n * Cost breakdown for SNS pricing components\n */\nexport interface SNSCostBreakdown {\n  publishCost: number;\n  httpDeliveryCost: number;\n  emailDeliveryCost: number;\n  smsDeliveryCost: number;\n  mobilePushDeliveryCost: number;\n  totalCost: number;\n}\n\n/**\n * Calculator for AWS::SNS::Topic resources.\n *\n * SNS Pricing Model (as of 2024):\n * - Publishes: $0.50 per million requests (first 1M free)\n * - HTTP/S deliveries: $0.60 per million\n * - Email deliveries: $2.00 per 100,000\n * - SMS: Varies by country (using US rate as default)\n * - Mobile push: $0.50 per million\n *\n * @see https://aws.amazon.com/sns/pricing/\n */\nexport class SNSCalculator implements ResourceCostCalculator {\n  // Default usage assumptions\n  private readonly DEFAULT_MONTHLY_PUBLISHES = 1_000_000;\n  private readonly DEFAULT_HTTP_DELIVERIES = 1_000_000;\n  private readonly DEFAULT_EMAIL_DELIVERIES = 0;\n  private readonly DEFAULT_SMS_DELIVERIES = 0;\n  private readonly DEFAULT_MOBILE_PUSH_DELIVERIES = 0;\n\n  // Fallback pricing rates (AWS SNS us-east-1 pricing as of 2024)\n  private readonly FALLBACK_PUBLISH_PRICE_PER_MILLION = 0.50;\n  private readonly FALLBACK_HTTP_DELIVERY_PRICE_PER_MILLION = 0.60;\n  private readonly FALLBACK_EMAIL_DELIVERY_PRICE_PER_100K = 2.00;\n  private readonly FALLBACK_SMS_PRICE_PER_MESSAGE = 0.00645; // US rate\n  private readonly FALLBACK_MOBILE_PUSH_PRICE_PER_MILLION = 0.50;\n\n  // Free tier thresholds\n  private readonly FREE_TIER_PUBLISHES = 1_000_000;\n\n  constructor(\n    private readonly customMonthlyPublishes?: number,\n    private readonly customHttpDeliveries?: number,\n    private readonly customEmailDeliveries?: number,\n    private readonly customSmsDeliveries?: number,\n    private readonly customMobilePushDeliveries?: number,\n  ) {}\n\n  supports(resourceType: string): boolean {\n    return resourceType === 'AWS::SNS::Topic';\n  }\n\n  async calculateCost(\n    resource: ResourceWithId,\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    const monthlyPublishes = this.customMonthlyPublishes ?? this.DEFAULT_MONTHLY_PUBLISHES;\n    const httpDeliveries = this.customHttpDeliveries ?? this.DEFAULT_HTTP_DELIVERIES;\n    const emailDeliveries = this.customEmailDeliveries ?? this.DEFAULT_EMAIL_DELIVERIES;\n    const smsDeliveries = this.customSmsDeliveries ?? this.DEFAULT_SMS_DELIVERIES;\n    const mobilePushDeliveries = this.customMobilePushDeliveries ?? this.DEFAULT_MOBILE_PUSH_DELIVERIES;\n\n    Logger.debug('SNS pricing calculation started', {\n      region,\n      logicalId: resource.logicalId,\n      monthlyPublishes,\n      httpDeliveries,\n      emailDeliveries,\n      smsDeliveries,\n      mobilePushDeliveries,\n    });\n\n    try {\n      const regionPrefix = getRegionPrefix(region);\n      const normalizedRegion = normalizeRegion(region);\n\n      // Fetch pricing data from AWS Pricing API\n      const publishPrice = await this.getPublishPrice(pricingClient, normalizedRegion, regionPrefix);\n      const httpDeliveryPrice = await this.getHttpDeliveryPrice(pricingClient, normalizedRegion, regionPrefix);\n      const emailDeliveryPrice = await this.getEmailDeliveryPrice(pricingClient, normalizedRegion, regionPrefix);\n      const smsPrice = await this.getSmsPrice(pricingClient, normalizedRegion, regionPrefix);\n      const mobilePushPrice = await this.getMobilePushPrice(pricingClient, normalizedRegion, regionPrefix);\n\n      const hasCustomAssumptions = this.hasCustomAssumptions();\n      const allPricesAvailable = publishPrice !== null &&\n        httpDeliveryPrice !== null &&\n        emailDeliveryPrice !== null &&\n        smsPrice !== null &&\n        mobilePushPrice !== null;\n\n      // Calculate costs using API prices or fallbacks\n      const costBreakdown = this.calculateCostBreakdown(\n        monthlyPublishes,\n        httpDeliveries,\n        emailDeliveries,\n        smsDeliveries,\n        mobilePushDeliveries,\n        publishPrice,\n        httpDeliveryPrice,\n        emailDeliveryPrice,\n        smsPrice,\n        mobilePushPrice,\n      );\n\n      Logger.debug('SNS cost calculated', {\n        costBreakdown,\n        allPricesAvailable,\n      });\n\n      const assumptions = this.buildAssumptions(\n        monthlyPublishes,\n        httpDeliveries,\n        emailDeliveries,\n        smsDeliveries,\n        mobilePushDeliveries,\n        costBreakdown,\n        allPricesAvailable,\n        publishPrice,\n        httpDeliveryPrice,\n        emailDeliveryPrice,\n        smsPrice,\n        mobilePushPrice,\n      );\n\n      // Determine confidence level\n      let confidence: 'high' | 'medium' | 'low' | 'unknown';\n      if (!allPricesAvailable && !hasCustomAssumptions) {\n        confidence = 'unknown';\n      } else if (!allPricesAvailable && hasCustomAssumptions) {\n        confidence = 'low';\n      } else {\n        confidence = 'medium';\n      }\n\n      // If all prices are unavailable and no custom assumptions, return zero cost\n      if (!allPricesAvailable && !hasCustomAssumptions) {\n        return {\n          amount: 0,\n          currency: 'USD',\n          confidence: 'unknown',\n          assumptions: [\n            `Pricing data not available for SNS in region ${region}`,\n            ...assumptions,\n          ],\n        };\n      }\n\n      return {\n        amount: costBreakdown.totalCost,\n        currency: 'USD',\n        confidence,\n        assumptions,\n      };\n    } catch (error) {\n      Logger.debug('SNS pricing calculation failed', {\n        error: error instanceof Error ? error.message : String(error),\n        region,\n      });\n\n      // If user provided custom assumptions, use fallback pricing\n      if (this.hasCustomAssumptions()) {\n        const costBreakdown = this.calculateCostBreakdown(\n          monthlyPublishes,\n          httpDeliveries,\n          emailDeliveries,\n          smsDeliveries,\n          mobilePushDeliveries,\n          null,\n          null,\n          null,\n          null,\n          null,\n        );\n\n        return {\n          amount: costBreakdown.totalCost,\n          currency: 'USD',\n          confidence: 'low',\n          assumptions: [\n            'Using fallback pricing (API error)',\n            `Assumes ${monthlyPublishes.toLocaleString()} publishes per month`,\n            `Assumes ${httpDeliveries.toLocaleString()} HTTP/S deliveries per month`,\n          ],\n        };\n      }\n\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 getPublishPrice(\n    pricingClient: PricingClient,\n    normalizedRegion: string,\n    regionPrefix: string,\n  ): Promise<number | null> {\n    const usageType = regionPrefix ? `${regionPrefix}-PublishRequests` : 'PublishRequests';\n    return pricingClient.getPrice({\n      serviceCode: 'AmazonSNS',\n      region: normalizedRegion,\n      filters: [\n        { field: 'productFamily', value: 'Notification' },\n        { field: 'usagetype', value: usageType },\n      ],\n    });\n  }\n\n  private async getHttpDeliveryPrice(\n    pricingClient: PricingClient,\n    normalizedRegion: string,\n    regionPrefix: string,\n  ): Promise<number | null> {\n    const usageType = regionPrefix ? `${regionPrefix}-DeliveryAttempts-HTTP` : 'DeliveryAttempts-HTTP';\n    return pricingClient.getPrice({\n      serviceCode: 'AmazonSNS',\n      region: normalizedRegion,\n      filters: [\n        { field: 'productFamily', value: 'Notification' },\n        { field: 'usagetype', value: usageType },\n      ],\n    });\n  }\n\n  private async getEmailDeliveryPrice(\n    pricingClient: PricingClient,\n    normalizedRegion: string,\n    regionPrefix: string,\n  ): Promise<number | null> {\n    const usageType = regionPrefix ? `${regionPrefix}-DeliveryAttempts-EMAIL` : 'DeliveryAttempts-EMAIL';\n    return pricingClient.getPrice({\n      serviceCode: 'AmazonSNS',\n      region: normalizedRegion,\n      filters: [\n        { field: 'productFamily', value: 'Notification' },\n        { field: 'usagetype', value: usageType },\n      ],\n    });\n  }\n\n  private async getSmsPrice(\n    pricingClient: PricingClient,\n    normalizedRegion: string,\n    regionPrefix: string,\n  ): Promise<number | null> {\n    const usageType = regionPrefix ? `${regionPrefix}-DeliveryAttempts-SMS` : 'DeliveryAttempts-SMS';\n    return pricingClient.getPrice({\n      serviceCode: 'AmazonSNS',\n      region: normalizedRegion,\n      filters: [\n        { field: 'productFamily', value: 'SMS' },\n        { field: 'usagetype', value: usageType },\n      ],\n    });\n  }\n\n  private async getMobilePushPrice(\n    pricingClient: PricingClient,\n    normalizedRegion: string,\n    regionPrefix: string,\n  ): Promise<number | null> {\n    const usageType = regionPrefix ? `${regionPrefix}-DeliveryAttempts-APNS` : 'DeliveryAttempts-APNS';\n    return pricingClient.getPrice({\n      serviceCode: 'AmazonSNS',\n      region: normalizedRegion,\n      filters: [\n        { field: 'productFamily', value: 'Mobile Push Notification' },\n        { field: 'usagetype', value: usageType },\n      ],\n    });\n  }\n\n  private calculateCostBreakdown(\n    monthlyPublishes: number,\n    httpDeliveries: number,\n    emailDeliveries: number,\n    smsDeliveries: number,\n    mobilePushDeliveries: number,\n    publishPrice: number | null,\n    httpDeliveryPrice: number | null,\n    emailDeliveryPrice: number | null,\n    smsPrice: number | null,\n    mobilePushPrice: number | null,\n  ): SNSCostBreakdown {\n    // Use API prices if available, otherwise fallback\n    const effectivePublishPrice = publishPrice ?? this.FALLBACK_PUBLISH_PRICE_PER_MILLION;\n    const effectiveHttpDeliveryPrice = httpDeliveryPrice ?? this.FALLBACK_HTTP_DELIVERY_PRICE_PER_MILLION;\n    const effectiveEmailDeliveryPrice = emailDeliveryPrice ?? this.FALLBACK_EMAIL_DELIVERY_PRICE_PER_100K;\n    const effectiveSmsPrice = smsPrice ?? this.FALLBACK_SMS_PRICE_PER_MESSAGE;\n    const effectiveMobilePushPrice = mobilePushPrice ?? this.FALLBACK_MOBILE_PUSH_PRICE_PER_MILLION;\n\n    // Calculate publish cost (first 1M free)\n    const billablePublishes = Math.max(0, monthlyPublishes - this.FREE_TIER_PUBLISHES);\n    const publishCost = (billablePublishes / 1_000_000) * effectivePublishPrice;\n\n    // HTTP/S delivery cost: $X per million\n    const httpDeliveryCost = (httpDeliveries / 1_000_000) * effectiveHttpDeliveryPrice;\n\n    // Email delivery cost: $X per 100,000\n    const emailDeliveryCost = (emailDeliveries / 100_000) * effectiveEmailDeliveryPrice;\n\n    // SMS delivery cost: $X per message (varies by country, using US rate)\n    const smsDeliveryCost = smsDeliveries * effectiveSmsPrice;\n\n    // Mobile push delivery cost: $X per million\n    const mobilePushDeliveryCost = (mobilePushDeliveries / 1_000_000) * effectiveMobilePushPrice;\n\n    const totalCost = publishCost + httpDeliveryCost + emailDeliveryCost + smsDeliveryCost + mobilePushDeliveryCost;\n\n    return {\n      publishCost,\n      httpDeliveryCost,\n      emailDeliveryCost,\n      smsDeliveryCost,\n      mobilePushDeliveryCost,\n      totalCost,\n    };\n  }\n\n  private buildAssumptions(\n    monthlyPublishes: number,\n    httpDeliveries: number,\n    emailDeliveries: number,\n    smsDeliveries: number,\n    mobilePushDeliveries: number,\n    costBreakdown: SNSCostBreakdown,\n    allPricesAvailable: boolean,\n    publishPrice: number | null,\n    httpDeliveryPrice: number | null,\n    emailDeliveryPrice: number | null,\n    smsPrice: number | null,\n    mobilePushPrice: number | null,\n  ): string[] {\n    const assumptions: string[] = [];\n\n    // Add usage assumptions\n    assumptions.push(`Assumes ${monthlyPublishes.toLocaleString()} publishes per month`);\n    assumptions.push(`Assumes ${httpDeliveries.toLocaleString()} HTTP/S deliveries per month`);\n\n    if (emailDeliveries > 0) {\n      assumptions.push(`Assumes ${emailDeliveries.toLocaleString()} email deliveries per month`);\n    }\n    if (smsDeliveries > 0) {\n      assumptions.push(`Assumes ${smsDeliveries.toLocaleString()} SMS deliveries per month (using US rate)`);\n    }\n    if (mobilePushDeliveries > 0) {\n      assumptions.push(`Assumes ${mobilePushDeliveries.toLocaleString()} mobile push deliveries per month`);\n    }\n\n    // Add free tier information\n    if (monthlyPublishes <= this.FREE_TIER_PUBLISHES) {\n      assumptions.push(`First ${this.FREE_TIER_PUBLISHES.toLocaleString()} publishes are free`);\n    } else {\n      const billablePublishes = monthlyPublishes - this.FREE_TIER_PUBLISHES;\n      assumptions.push(`${this.FREE_TIER_PUBLISHES.toLocaleString()} free tier publishes applied, ${billablePublishes.toLocaleString()} billable`);\n    }\n\n    // Add cost breakdown\n    if (costBreakdown.publishCost > 0) {\n      assumptions.push(`Publish cost: $${costBreakdown.publishCost.toFixed(2)}`);\n    }\n    if (costBreakdown.httpDeliveryCost > 0) {\n      assumptions.push(`HTTP/S delivery cost: $${costBreakdown.httpDeliveryCost.toFixed(2)}`);\n    }\n    if (costBreakdown.emailDeliveryCost > 0) {\n      assumptions.push(`Email delivery cost: $${costBreakdown.emailDeliveryCost.toFixed(2)}`);\n    }\n    if (costBreakdown.smsDeliveryCost > 0) {\n      assumptions.push(`SMS delivery cost: $${costBreakdown.smsDeliveryCost.toFixed(2)}`);\n    }\n    if (costBreakdown.mobilePushDeliveryCost > 0) {\n      assumptions.push(`Mobile push delivery cost: $${costBreakdown.mobilePushDeliveryCost.toFixed(2)}`);\n    }\n\n    // Add fallback pricing notes\n    if (!allPricesAvailable) {\n      if (publishPrice === null) {\n        assumptions.push('Using fallback publish pricing (API unavailable)');\n      }\n      if (httpDeliveryPrice === null) {\n        assumptions.push('Using fallback HTTP delivery pricing (API unavailable)');\n      }\n      if (emailDeliveryPrice === null && emailDeliveries > 0) {\n        assumptions.push('Using fallback email delivery pricing (API unavailable)');\n      }\n      if (smsPrice === null && smsDeliveries > 0) {\n        assumptions.push('Using fallback SMS pricing (API unavailable)');\n      }\n      if (mobilePushPrice === null && mobilePushDeliveries > 0) {\n        assumptions.push('Using fallback mobile push pricing (API unavailable)');\n      }\n    }\n\n    // Add custom assumption notes\n    if (this.customMonthlyPublishes !== undefined) {\n      assumptions.push('Using custom publish count from configuration');\n    }\n    if (this.customHttpDeliveries !== undefined) {\n      assumptions.push('Using custom HTTP delivery count from configuration');\n    }\n    if (this.customEmailDeliveries !== undefined) {\n      assumptions.push('Using custom email delivery count from configuration');\n    }\n    if (this.customSmsDeliveries !== undefined) {\n      assumptions.push('Using custom SMS delivery count from configuration');\n    }\n    if (this.customMobilePushDeliveries !== undefined) {\n      assumptions.push('Using custom mobile push delivery count from configuration');\n    }\n\n    return assumptions;\n  }\n\n  private hasCustomAssumptions(): boolean {\n    return (\n      this.customMonthlyPublishes !== undefined ||\n      this.customHttpDeliveries !== undefined ||\n      this.customEmailDeliveries !== undefined ||\n      this.customSmsDeliveries !== undefined ||\n      this.customMobilePushDeliveries !== undefined\n    );\n  }\n}\n"]}

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

@@ -0,0 +1,23 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+export type StepFunctionsWorkflowType = 'STANDARD' | 'EXPRESS';
+export declare class StepFunctionsCalculator implements ResourceCostCalculator {
+    private readonly customMonthlyExecutions?;
+    private readonly customStateTransitionsPerExecution?;
+    private readonly customAverageDurationMs?;
+    private readonly DEFAULT_MONTHLY_EXECUTIONS;
+    private readonly DEFAULT_STATE_TRANSITIONS_PER_EXECUTION;
+    private readonly DEFAULT_AVERAGE_DURATION_MS;
+    private readonly FALLBACK_STANDARD_STATE_TRANSITION_PRICE;
+    private readonly FALLBACK_EXPRESS_REQUEST_PRICE;
+    private readonly FALLBACK_EXPRESS_DURATION_PRICE;
+    constructor(customMonthlyExecutions?: number | undefined, customStateTransitionsPerExecution?: number | undefined, customAverageDurationMs?: number | undefined);
+    supports(resourceType: string): boolean;
+    calculateCost(resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+    private getWorkflowType;
+    private calculateStandardWorkflowCost;
+    private calculateExpressWorkflowCost;
+    private buildStandardAssumptions;
+    private buildExpressAssumptions;
+    private hasCustomAssumptions;
+}

package/dist/pricing/calculators/StepFunctionsCalculator.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StepFunctionsCalculator = void 0;
+const RegionMapper_1 = require("../RegionMapper");
+class StepFunctionsCalculator {
+    customMonthlyExecutions;
+    customStateTransitionsPerExecution;
+    customAverageDurationMs;
+    // Default usage assumptions
+    DEFAULT_MONTHLY_EXECUTIONS = 10000;
+    DEFAULT_STATE_TRANSITIONS_PER_EXECUTION = 10;
+    DEFAULT_AVERAGE_DURATION_MS = 1000;
+    // Fallback pricing rates (AWS Step Functions us-east-1 pricing as of 2024)
+    // Used when API pricing is unavailable but user provided usage assumptions
+    FALLBACK_STANDARD_STATE_TRANSITION_PRICE = 0.025 / 1000; // $0.025 per 1,000 state transitions
+    FALLBACK_EXPRESS_REQUEST_PRICE = 1.0 / 1000000; // $1.00 per million requests
+    FALLBACK_EXPRESS_DURATION_PRICE = 0.00001667; // Per GB-second
+    constructor(customMonthlyExecutions, customStateTransitionsPerExecution, customAverageDurationMs) {
+        this.customMonthlyExecutions = customMonthlyExecutions;
+        this.customStateTransitionsPerExecution = customStateTransitionsPerExecution;
+        this.customAverageDurationMs = customAverageDurationMs;
+    }
+    supports(resourceType) {
+        return resourceType === 'AWS::StepFunctions::StateMachine';
+    }
+    async calculateCost(resource, region, pricingClient) {
+        const workflowType = this.getWorkflowType(resource);
+        if (workflowType === 'EXPRESS') {
+            return this.calculateExpressWorkflowCost(resource, region, pricingClient);
+        }
+        return this.calculateStandardWorkflowCost(resource, region, pricingClient);
+    }
+    getWorkflowType(resource) {
+        const typeProperty = resource.properties.Type;
+        if (typeProperty === 'EXPRESS') {
+            return 'EXPRESS';
+        }
+        return 'STANDARD';
+    }
+    async calculateStandardWorkflowCost(_resource, region, pricingClient) {
+        const monthlyExecutions = this.customMonthlyExecutions ?? this.DEFAULT_MONTHLY_EXECUTIONS;
+        const stateTransitionsPerExecution = this.customStateTransitionsPerExecution ?? this.DEFAULT_STATE_TRANSITIONS_PER_EXECUTION;
+        const totalStateTransitions = monthlyExecutions * stateTransitionsPerExecution;
+        try {
+            const regionPrefix = (0, RegionMapper_1.getRegionPrefix)(region);
+            const usageType = regionPrefix
+                ? `${regionPrefix}-StateTransition`
+                : 'StateTransition';
+            const stateTransitionPrice = await pricingClient.getPrice({
+                serviceCode: 'AWSStepFunctions',
+                region: (0, RegionMapper_1.normalizeRegion)(region),
+                filters: [
+                    { field: 'productFamily', value: 'AWS Step Functions' },
+                    { field: 'usagetype', value: usageType },
+                ],
+            });
+            const assumptions = this.buildStandardAssumptions(monthlyExecutions, stateTransitionsPerExecution, totalStateTransitions);
+            if (stateTransitionPrice === null) {
+                const hasCustomAssumptions = this.hasCustomAssumptions();
+                if (hasCustomAssumptions) {
+                    const monthlyCost = totalStateTransitions * this.FALLBACK_STANDARD_STATE_TRANSITION_PRICE;
+                    return {
+                        amount: monthlyCost,
+                        currency: 'USD',
+                        confidence: 'low',
+                        assumptions: [
+                            'Using fallback state transition pricing (API unavailable)',
+                            ...assumptions,
+                        ],
+                    };
+                }
+                return {
+                    amount: 0,
+                    currency: 'USD',
+                    confidence: 'unknown',
+                    assumptions: [
+                        `Pricing data not available for Step Functions Standard workflow in region ${region}`,
+                        ...assumptions,
+                    ],
+                };
+            }
+            const monthlyCost = totalStateTransitions * stateTransitionPrice;
+            return {
+                amount: monthlyCost,
+                currency: 'USD',
+                confidence: 'medium',
+                assumptions,
+            };
+        }
+        catch (error) {
+            const assumptions = [
+                `Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`,
+                ...this.buildStandardAssumptions(monthlyExecutions, stateTransitionsPerExecution, totalStateTransitions),
+            ];
+            const hasCustomAssumptions = this.hasCustomAssumptions();
+            if (hasCustomAssumptions) {
+                const monthlyCost = totalStateTransitions * this.FALLBACK_STANDARD_STATE_TRANSITION_PRICE;
+                return {
+                    amount: monthlyCost,
+                    currency: 'USD',
+                    confidence: 'low',
+                    assumptions: [
+                        'Using fallback pricing (API error)',
+                        ...assumptions.slice(1),
+                    ],
+                };
+            }
+            return {
+                amount: 0,
+                currency: 'USD',
+                confidence: 'unknown',
+                assumptions,
+            };
+        }
+    }
+    async calculateExpressWorkflowCost(_resource, region, pricingClient) {
+        const monthlyExecutions = this.customMonthlyExecutions ?? this.DEFAULT_MONTHLY_EXECUTIONS;
+        const averageDurationMs = this.customAverageDurationMs ?? this.DEFAULT_AVERAGE_DURATION_MS;
+        // Express workflows are billed based on: requests + duration (GB-seconds)
+        // Assume 64MB memory per execution (typical Step Functions memory allocation)
+        const memoryMB = 64;
+        const durationSeconds = averageDurationMs / 1000;
+        const gbSeconds = (memoryMB / 1024) * durationSeconds * monthlyExecutions;
+        try {
+            const regionPrefix = (0, RegionMapper_1.getRegionPrefix)(region);
+            const requestUsageType = regionPrefix
+                ? `${regionPrefix}-ExpressRequest`
+                : 'ExpressRequest';
+            const durationUsageType = regionPrefix
+                ? `${regionPrefix}-ExpressDuration`
+                : 'ExpressDuration';
+            const requestPrice = await pricingClient.getPrice({
+                serviceCode: 'AWSStepFunctions',
+                region: (0, RegionMapper_1.normalizeRegion)(region),
+                filters: [
+                    { field: 'productFamily', value: 'AWS Step Functions' },
+                    { field: 'usagetype', value: requestUsageType },
+                ],
+            });
+            const durationPrice = await pricingClient.getPrice({
+                serviceCode: 'AWSStepFunctions',
+                region: (0, RegionMapper_1.normalizeRegion)(region),
+                filters: [
+                    { field: 'productFamily', value: 'AWS Step Functions' },
+                    { field: 'usagetype', value: durationUsageType },
+                ],
+            });
+            const assumptions = this.buildExpressAssumptions(monthlyExecutions, averageDurationMs, gbSeconds);
+            if (requestPrice === null || durationPrice === null) {
+                const hasCustomAssumptions = this.hasCustomAssumptions();
+                if (hasCustomAssumptions) {
+                    const effectiveRequestPrice = requestPrice ?? this.FALLBACK_EXPRESS_REQUEST_PRICE;
+                    const effectiveDurationPrice = durationPrice ?? this.FALLBACK_EXPRESS_DURATION_PRICE;
+                    const requestCost = monthlyExecutions * effectiveRequestPrice;
+                    const durationCost = gbSeconds * effectiveDurationPrice;
+                    const monthlyCost = requestCost + durationCost;
+                    return {
+                        amount: monthlyCost,
+                        currency: 'USD',
+                        confidence: 'low',
+                        assumptions: [
+                            requestPrice === null ? 'Using fallback request pricing (API unavailable)' : '',
+                            durationPrice === null ? 'Using fallback duration pricing (API unavailable)' : '',
+                            ...assumptions,
+                        ].filter(a => a !== ''),
+                    };
+                }
+                return {
+                    amount: 0,
+                    currency: 'USD',
+                    confidence: 'unknown',
+                    assumptions: [
+                        `Pricing data not available for Step Functions Express workflow in region ${region}`,
+                        ...assumptions,
+                    ],
+                };
+            }
+            const requestCost = monthlyExecutions * requestPrice;
+            const durationCost = gbSeconds * durationPrice;
+            const monthlyCost = requestCost + durationCost;
+            return {
+                amount: monthlyCost,
+                currency: 'USD',
+                confidence: 'medium',
+                assumptions,
+            };
+        }
+        catch (error) {
+            const assumptions = [
+                `Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`,
+                ...this.buildExpressAssumptions(monthlyExecutions, averageDurationMs, gbSeconds),
+            ];
+            const hasCustomAssumptions = this.hasCustomAssumptions();
+            if (hasCustomAssumptions) {
+                const requestCost = monthlyExecutions * this.FALLBACK_EXPRESS_REQUEST_PRICE;
+                const durationCost = gbSeconds * this.FALLBACK_EXPRESS_DURATION_PRICE;
+                const monthlyCost = requestCost + durationCost;
+                return {
+                    amount: monthlyCost,
+                    currency: 'USD',
+                    confidence: 'low',
+                    assumptions: [
+                        'Using fallback pricing (API error)',
+                        ...assumptions.slice(1),
+                    ],
+                };
+            }
+            return {
+                amount: 0,
+                currency: 'USD',
+                confidence: 'unknown',
+                assumptions,
+            };
+        }
+    }
+    buildStandardAssumptions(monthlyExecutions, stateTransitionsPerExecution, totalStateTransitions) {
+        const assumptions = [
+            `Assumes ${monthlyExecutions.toLocaleString()} executions per month`,
+            `Assumes ${stateTransitionsPerExecution} state transitions per execution`,
+            `Total estimated state transitions: ${totalStateTransitions.toLocaleString()}`,
+            'STANDARD workflow type',
+            'Pricing: $0.025 per 1,000 state transitions',
+        ];
+        if (this.customMonthlyExecutions !== undefined) {
+            assumptions.push('Using custom monthly executions from configuration');
+        }
+        if (this.customStateTransitionsPerExecution !== undefined) {
+            assumptions.push('Using custom state transitions per execution from configuration');
+        }
+        return assumptions;
+    }
+    buildExpressAssumptions(monthlyExecutions, averageDurationMs, gbSeconds) {
+        const assumptions = [
+            `Assumes ${monthlyExecutions.toLocaleString()} executions per month`,
+            `Assumes ${averageDurationMs}ms average execution duration`,
+            `Total estimated GB-seconds: ${gbSeconds.toFixed(2)}`,
+            'EXPRESS workflow type',
+            'Pricing: $1.00 per million requests + $0.00001667 per GB-second',
+            'Assumes 64MB memory allocation per execution',
+        ];
+        if (this.customMonthlyExecutions !== undefined) {
+            assumptions.push('Using custom monthly executions from configuration');
+        }
+        if (this.customAverageDurationMs !== undefined) {
+            assumptions.push('Using custom average duration from configuration');
+        }
+        return assumptions;
+    }
+    hasCustomAssumptions() {
+        return this.customMonthlyExecutions !== undefined ||
+            this.customStateTransitionsPerExecution !== undefined ||
+            this.customAverageDurationMs !== undefined;
+    }
+}
+exports.StepFunctionsCalculator = StepFunctionsCalculator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"StepFunctionsCalculator.js","sourceRoot":"","sources":["../../../src/pricing/calculators/StepFunctionsCalculator.ts"],"names":[],"mappings":"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","sourcesContent":["import { ResourceWithId } from '../../diff/types';\nimport { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';\nimport { normalizeRegion, getRegionPrefix } from '../RegionMapper';\n\nexport type StepFunctionsWorkflowType = 'STANDARD' | 'EXPRESS';\n\nexport class StepFunctionsCalculator implements ResourceCostCalculator {\n  // Default usage assumptions\n  private readonly DEFAULT_MONTHLY_EXECUTIONS = 10000;\n  private readonly DEFAULT_STATE_TRANSITIONS_PER_EXECUTION = 10;\n  private readonly DEFAULT_AVERAGE_DURATION_MS = 1000;\n\n  // Fallback pricing rates (AWS Step Functions us-east-1 pricing as of 2024)\n  // Used when API pricing is unavailable but user provided usage assumptions\n  private readonly FALLBACK_STANDARD_STATE_TRANSITION_PRICE = 0.025 / 1000; // $0.025 per 1,000 state transitions\n  private readonly FALLBACK_EXPRESS_REQUEST_PRICE = 1.0 / 1000000; // $1.00 per million requests\n  private readonly FALLBACK_EXPRESS_DURATION_PRICE = 0.00001667; // Per GB-second\n\n  constructor(\n    private readonly customMonthlyExecutions?: number,\n    private readonly customStateTransitionsPerExecution?: number,\n    private readonly customAverageDurationMs?: number,\n  ) {}\n\n  supports(resourceType: string): boolean {\n    return resourceType === 'AWS::StepFunctions::StateMachine';\n  }\n\n  async calculateCost(\n    resource: ResourceWithId,\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    const workflowType = this.getWorkflowType(resource);\n    \n    if (workflowType === 'EXPRESS') {\n      return this.calculateExpressWorkflowCost(resource, region, pricingClient);\n    }\n    \n    return this.calculateStandardWorkflowCost(resource, region, pricingClient);\n  }\n\n  private getWorkflowType(resource: ResourceWithId): StepFunctionsWorkflowType {\n    const typeProperty = resource.properties.Type as string | undefined;\n    if (typeProperty === 'EXPRESS') {\n      return 'EXPRESS';\n    }\n    return 'STANDARD';\n  }\n\n  private async calculateStandardWorkflowCost(\n    _resource: ResourceWithId,\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    const monthlyExecutions = this.customMonthlyExecutions ?? this.DEFAULT_MONTHLY_EXECUTIONS;\n    const stateTransitionsPerExecution = this.customStateTransitionsPerExecution ?? this.DEFAULT_STATE_TRANSITIONS_PER_EXECUTION;\n    const totalStateTransitions = monthlyExecutions * stateTransitionsPerExecution;\n\n    try {\n      const regionPrefix = getRegionPrefix(region);\n      const usageType = regionPrefix \n        ? `${regionPrefix}-StateTransition` \n        : 'StateTransition';\n\n      const stateTransitionPrice = await pricingClient.getPrice({\n        serviceCode: 'AWSStepFunctions',\n        region: normalizeRegion(region),\n        filters: [\n          { field: 'productFamily', value: 'AWS Step Functions' },\n          { field: 'usagetype', value: usageType },\n        ],\n      });\n\n      const assumptions = this.buildStandardAssumptions(monthlyExecutions, stateTransitionsPerExecution, totalStateTransitions);\n\n      if (stateTransitionPrice === null) {\n        const hasCustomAssumptions = this.hasCustomAssumptions();\n        \n        if (hasCustomAssumptions) {\n          const monthlyCost = totalStateTransitions * this.FALLBACK_STANDARD_STATE_TRANSITION_PRICE;\n          return {\n            amount: monthlyCost,\n            currency: 'USD',\n            confidence: 'low',\n            assumptions: [\n              'Using fallback state transition pricing (API unavailable)',\n              ...assumptions,\n            ],\n          };\n        }\n\n        return {\n          amount: 0,\n          currency: 'USD',\n          confidence: 'unknown',\n          assumptions: [\n            `Pricing data not available for Step Functions Standard workflow in region ${region}`,\n            ...assumptions,\n          ],\n        };\n      }\n\n      const monthlyCost = totalStateTransitions * stateTransitionPrice;\n\n      return {\n        amount: monthlyCost,\n        currency: 'USD',\n        confidence: 'medium',\n        assumptions,\n      };\n    } catch (error) {\n      const assumptions = [\n        `Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`,\n        ...this.buildStandardAssumptions(monthlyExecutions, stateTransitionsPerExecution, totalStateTransitions),\n      ];\n\n      const hasCustomAssumptions = this.hasCustomAssumptions();\n      \n      if (hasCustomAssumptions) {\n        const monthlyCost = totalStateTransitions * this.FALLBACK_STANDARD_STATE_TRANSITION_PRICE;\n        return {\n          amount: monthlyCost,\n          currency: 'USD',\n          confidence: 'low',\n          assumptions: [\n            'Using fallback pricing (API error)',\n            ...assumptions.slice(1),\n          ],\n        };\n      }\n\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'unknown',\n        assumptions,\n      };\n    }\n  }\n\n  private async calculateExpressWorkflowCost(\n    _resource: ResourceWithId,\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    const monthlyExecutions = this.customMonthlyExecutions ?? this.DEFAULT_MONTHLY_EXECUTIONS;\n    const averageDurationMs = this.customAverageDurationMs ?? this.DEFAULT_AVERAGE_DURATION_MS;\n    \n    // Express workflows are billed based on: requests + duration (GB-seconds)\n    // Assume 64MB memory per execution (typical Step Functions memory allocation)\n    const memoryMB = 64;\n    const durationSeconds = averageDurationMs / 1000;\n    const gbSeconds = (memoryMB / 1024) * durationSeconds * monthlyExecutions;\n\n    try {\n      const regionPrefix = getRegionPrefix(region);\n      const requestUsageType = regionPrefix \n        ? `${regionPrefix}-ExpressRequest` \n        : 'ExpressRequest';\n      const durationUsageType = regionPrefix \n        ? `${regionPrefix}-ExpressDuration` \n        : 'ExpressDuration';\n\n      const requestPrice = await pricingClient.getPrice({\n        serviceCode: 'AWSStepFunctions',\n        region: normalizeRegion(region),\n        filters: [\n          { field: 'productFamily', value: 'AWS Step Functions' },\n          { field: 'usagetype', value: requestUsageType },\n        ],\n      });\n\n      const durationPrice = await pricingClient.getPrice({\n        serviceCode: 'AWSStepFunctions',\n        region: normalizeRegion(region),\n        filters: [\n          { field: 'productFamily', value: 'AWS Step Functions' },\n          { field: 'usagetype', value: durationUsageType },\n        ],\n      });\n\n      const assumptions = this.buildExpressAssumptions(monthlyExecutions, averageDurationMs, gbSeconds);\n\n      if (requestPrice === null || durationPrice === null) {\n        const hasCustomAssumptions = this.hasCustomAssumptions();\n        \n        if (hasCustomAssumptions) {\n          const effectiveRequestPrice = requestPrice ?? this.FALLBACK_EXPRESS_REQUEST_PRICE;\n          const effectiveDurationPrice = durationPrice ?? this.FALLBACK_EXPRESS_DURATION_PRICE;\n          \n          const requestCost = monthlyExecutions * effectiveRequestPrice;\n          const durationCost = gbSeconds * effectiveDurationPrice;\n          const monthlyCost = requestCost + durationCost;\n\n          return {\n            amount: monthlyCost,\n            currency: 'USD',\n            confidence: 'low',\n            assumptions: [\n              requestPrice === null ? 'Using fallback request pricing (API unavailable)' : '',\n              durationPrice === null ? 'Using fallback duration pricing (API unavailable)' : '',\n              ...assumptions,\n            ].filter(a => a !== ''),\n          };\n        }\n\n        return {\n          amount: 0,\n          currency: 'USD',\n          confidence: 'unknown',\n          assumptions: [\n            `Pricing data not available for Step Functions Express workflow in region ${region}`,\n            ...assumptions,\n          ],\n        };\n      }\n\n      const requestCost = monthlyExecutions * requestPrice;\n      const durationCost = gbSeconds * durationPrice;\n      const monthlyCost = requestCost + durationCost;\n\n      return {\n        amount: monthlyCost,\n        currency: 'USD',\n        confidence: 'medium',\n        assumptions,\n      };\n    } catch (error) {\n      const assumptions = [\n        `Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`,\n        ...this.buildExpressAssumptions(monthlyExecutions, averageDurationMs, gbSeconds),\n      ];\n\n      const hasCustomAssumptions = this.hasCustomAssumptions();\n      \n      if (hasCustomAssumptions) {\n        const requestCost = monthlyExecutions * this.FALLBACK_EXPRESS_REQUEST_PRICE;\n        const durationCost = gbSeconds * this.FALLBACK_EXPRESS_DURATION_PRICE;\n        const monthlyCost = requestCost + durationCost;\n\n        return {\n          amount: monthlyCost,\n          currency: 'USD',\n          confidence: 'low',\n          assumptions: [\n            'Using fallback pricing (API error)',\n            ...assumptions.slice(1),\n          ],\n        };\n      }\n\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'unknown',\n        assumptions,\n      };\n    }\n  }\n\n  private buildStandardAssumptions(\n    monthlyExecutions: number,\n    stateTransitionsPerExecution: number,\n    totalStateTransitions: number,\n  ): string[] {\n    const assumptions = [\n      `Assumes ${monthlyExecutions.toLocaleString()} executions per month`,\n      `Assumes ${stateTransitionsPerExecution} state transitions per execution`,\n      `Total estimated state transitions: ${totalStateTransitions.toLocaleString()}`,\n      'STANDARD workflow type',\n      'Pricing: $0.025 per 1,000 state transitions',\n    ];\n\n    if (this.customMonthlyExecutions !== undefined) {\n      assumptions.push('Using custom monthly executions from configuration');\n    }\n    if (this.customStateTransitionsPerExecution !== undefined) {\n      assumptions.push('Using custom state transitions per execution from configuration');\n    }\n\n    return assumptions;\n  }\n\n  private buildExpressAssumptions(\n    monthlyExecutions: number,\n    averageDurationMs: number,\n    gbSeconds: number,\n  ): string[] {\n    const assumptions = [\n      `Assumes ${monthlyExecutions.toLocaleString()} executions per month`,\n      `Assumes ${averageDurationMs}ms average execution duration`,\n      `Total estimated GB-seconds: ${gbSeconds.toFixed(2)}`,\n      'EXPRESS workflow type',\n      'Pricing: $1.00 per million requests + $0.00001667 per GB-second',\n      'Assumes 64MB memory allocation per execution',\n    ];\n\n    if (this.customMonthlyExecutions !== undefined) {\n      assumptions.push('Using custom monthly executions from configuration');\n    }\n    if (this.customAverageDurationMs !== undefined) {\n      assumptions.push('Using custom average duration from configuration');\n    }\n\n    return assumptions;\n  }\n\n  private hasCustomAssumptions(): boolean {\n    return this.customMonthlyExecutions !== undefined ||\n           this.customStateTransitionsPerExecution !== undefined ||\n           this.customAverageDurationMs !== undefined;\n  }\n}\n"]}

package/dist/pricing/index.d.ts

@@ -7,5 +7,7 @@ export { LambdaCalculator } from './calculators/LambdaCalculator';
 export { RDSCalculator } from './calculators/RDSCalculator';
 export { CloudFrontCalculator } from './calculators/CloudFrontCalculator';
 export { ElastiCacheCalculator } from './calculators/ElastiCacheCalculator';
+export { SNSCalculator, SNSCostBreakdown } from './calculators/SNSCalculator';
 export { LaunchTemplateCalculator, LaunchTemplateConfig, EbsVolumeConfig, } from './calculators/LaunchTemplateCalculator';
+export { StepFunctionsCalculator, StepFunctionsWorkflowType, } from './calculators/StepFunctionsCalculator';
 export * from './types';

package/dist/pricing/index.js

@@ -14,7 +14,7 @@ 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.LaunchTemplateCalculator = exports.ElastiCacheCalculator = exports.CloudFrontCalculator = exports.RDSCalculator = exports.LambdaCalculator = exports.S3Calculator = exports.EC2Calculator = exports.CacheManager = exports.PricingClient = exports.PricingService = void 0;
+exports.StepFunctionsCalculator = exports.LaunchTemplateCalculator = exports.SNSCalculator = 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");
@@ -33,7 +33,11 @@ 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; } });
+var SNSCalculator_1 = require("./calculators/SNSCalculator");
+Object.defineProperty(exports, "SNSCalculator", { enumerable: true, get: function () { return SNSCalculator_1.SNSCalculator; } });
 var LaunchTemplateCalculator_1 = require("./calculators/LaunchTemplateCalculator");
 Object.defineProperty(exports, "LaunchTemplateCalculator", { enumerable: true, get: function () { return LaunchTemplateCalculator_1.LaunchTemplateCalculator; } });
+var StepFunctionsCalculator_1 = require("./calculators/StepFunctionsCalculator");
+Object.defineProperty(exports, "StepFunctionsCalculator", { enumerable: true, get: function () { return StepFunctionsCalculator_1.StepFunctionsCalculator; } });
 __exportStar(require("./types"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJpY2luZy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLG1EQUFrRDtBQUF6QyxnSEFBQSxjQUFjLE9BQUE7QUFDdkIsaURBQWdEO0FBQXZDLDhHQUFBLGFBQWEsT0FBQTtBQUN0QiwrQ0FBOEM7QUFBckMsNEdBQUEsWUFBWSxPQUFBO0FBQ3JCLDZEQUE0RDtBQUFuRCw4R0FBQSxhQUFhLE9BQUE7QUFDdEIsMkRBQTBEO0FBQWpELDRHQUFBLFlBQVksT0FBQTtBQUNyQixtRUFBa0U7QUFBekQsb0hBQUEsZ0JBQWdCLE9BQUE7QUFDekIsNkRBQTREO0FBQW5ELDhHQUFBLGFBQWEsT0FBQTtBQUN0QiwyRUFBMEU7QUFBakUsNEhBQUEsb0JBQW9CLE9BQUE7QUFDN0IsNkVBQTRFO0FBQW5FLDhIQUFBLHFCQUFxQixPQUFBO0FBQzlCLG1GQUlnRDtBQUg5QyxvSUFBQSx3QkFBd0IsT0FBQTtBQUkxQiwwQ0FBd0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBQcmljaW5nU2VydmljZSB9IGZyb20gJy4vUHJpY2luZ1NlcnZpY2UnO1xuZXhwb3J0IHsgUHJpY2luZ0NsaWVudCB9IGZyb20gJy4vUHJpY2luZ0NsaWVudCc7XG5leHBvcnQgeyBDYWNoZU1hbmFnZXIgfSBmcm9tICcuL0NhY2hlTWFuYWdlcic7XG5leHBvcnQgeyBFQzJDYWxjdWxhdG9yIH0gZnJvbSAnLi9jYWxjdWxhdG9ycy9FQzJDYWxjdWxhdG9yJztcbmV4cG9ydCB7IFMzQ2FsY3VsYXRvciB9IGZyb20gJy4vY2FsY3VsYXRvcnMvUzNDYWxjdWxhdG9yJztcbmV4cG9ydCB7IExhbWJkYUNhbGN1bGF0b3IgfSBmcm9tICcuL2NhbGN1bGF0b3JzL0xhbWJkYUNhbGN1bGF0b3InO1xuZXhwb3J0IHsgUkRTQ2FsY3VsYXRvciB9IGZyb20gJy4vY2FsY3VsYXRvcnMvUkRTQ2FsY3VsYXRvcic7XG5leHBvcnQgeyBDbG91ZEZyb250Q2FsY3VsYXRvciB9IGZyb20gJy4vY2FsY3VsYXRvcnMvQ2xvdWRGcm9udENhbGN1bGF0b3InO1xuZXhwb3J0IHsgRWxhc3RpQ2FjaGVDYWxjdWxhdG9yIH0gZnJvbSAnLi9jYWxjdWxhdG9ycy9FbGFzdGlDYWNoZUNhbGN1bGF0b3InO1xuZXhwb3J0IHtcbiAgTGF1bmNoVGVtcGxhdGVDYWxjdWxhdG9yLFxuICBMYXVuY2hUZW1wbGF0ZUNvbmZpZyxcbiAgRWJzVm9sdW1lQ29uZmlnLFxufSBmcm9tICcuL2NhbGN1bGF0b3JzL0xhdW5jaFRlbXBsYXRlQ2FsY3VsYXRvcic7XG5leHBvcnQgKiBmcm9tICcuL3R5cGVzJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/dist/releasetag.txt

@@ -1 +1 @@
-v0.1.29
+v0.1.31

package/docs/CALCULATORS.md

@@ -583,6 +583,135 @@ Total: $1.03/month
 - WebSocket connections billed per minute
 - Message size up to 128 KB
 
+### AWS::SNS::Topic
+
+**Description:** Simple Notification Service for pub/sub messaging
+
+**Cost Components:**
+- Publish requests: Per million requests (first 1M free)
+- HTTP/S deliveries: Per million deliveries
+- Email deliveries: Per 100,000 deliveries
+- SMS deliveries: Per message (varies by country)
+- Mobile push deliveries: Per million deliveries
+
+**Default Assumptions:**
+- 1 million publish requests per month
+- 1 million HTTP/S deliveries per month
+- 0 email deliveries per month
+- 0 SMS deliveries per month
+- 0 mobile push deliveries per month
+
+**Configuration:**
+```yaml
+usageAssumptions:
+  sns:
+    monthlyPublishes: 1000000
+    httpDeliveries: 1000000
+    emailDeliveries: 0
+    smsDeliveries: 0
+    mobilePushDeliveries: 0
+```
+
+**Example:**
+```
+Publish requests: 2M publishes - 1M free = 1M × $0.50/1M = $0.50
+HTTP/S deliveries: 1M × $0.60/1M = $0.60
+Total: $1.10/month
+```
+
+**Example with multiple delivery types:**
+```yaml
+usageAssumptions:
+  sns:
+    monthlyPublishes: 5000000
+    httpDeliveries: 2000000
+    emailDeliveries: 100000
+    smsDeliveries: 10000
+    mobilePushDeliveries: 500000
+```
+
+```
+Publish requests: 5M - 1M free = 4M × $0.50/1M = $2.00
+HTTP/S deliveries: 2M × $0.60/1M = $1.20
+Email deliveries: 100K × $2.00/100K = $2.00
+SMS deliveries: 10K × $0.00645 = $64.50 (US rate)
+Mobile push: 500K × $0.50/1M = $0.25
+Total: $69.95/month
+```
+
+**Notes:**
+- First 1 million publish requests free per month
+- SMS pricing varies significantly by destination country
+- US SMS rate used as fallback ($0.00645/message)
+- Mobile push includes APNS (iOS), GCM/FCM (Android), ADM (Amazon)
+- Data transfer costs not included
+- SNS FIFO topics may have different pricing
+- Large message payloads (>64KB) count as multiple requests
+
+### AWS::StepFunctions::StateMachine
+
+**Description:** AWS Step Functions state machine for serverless workflow orchestration
+
+**Workflow Types:**
+
+Step Functions supports two workflow types with different pricing models:
+
+| Workflow Type | Best For | Pricing Model |
+|---------------|----------|---------------|
+| STANDARD | Long-running, durable workflows | Per state transition |
+| EXPRESS | High-volume, short-duration workflows | Per request + duration |
+
+**Cost Components:**
+
+**Standard Workflows:**
+- State transitions: $0.025 per 1,000 state transitions
+
+**Express Workflows:**
+- Requests: $1.00 per million requests
+- Duration: $0.00001667 per GB-second
+
+**Default Assumptions:**
+- 10,000 workflow executions per month
+- 10 state transitions per execution (Standard workflows)
+- 1,000ms average execution duration (Express workflows)
+- 64MB memory allocation per execution (Express workflows)
+
+**Configuration:**
+```yaml
+usageAssumptions:
+  stepFunctions:
+    monthlyExecutions: 10000        # Executions per month
+    stateTransitionsPerExecution: 10 # State transitions per execution (Standard)
+    averageDurationMs: 1000          # Average duration in ms (Express)
+```
+
+**Example (Standard Workflow):**
+```
+Executions: 10,000
+State transitions per execution: 10
+Total transitions: 100,000
+Cost: 100,000 × ($0.025 / 1,000) = $2.50/month
+```
+
+**Example (Express Workflow):**
+```
+Executions: 10,000
+Request cost: 10,000 × ($1.00 / 1,000,000) = $0.01
+Duration: 64MB memory × 1 second × 10,000 = 625 GB-seconds
+Duration cost: 625 × $0.00001667 = $0.01
+Total: $0.02/month
+```
+
+**Notes:**
+- Workflow type detected from `Type` property in CloudFormation template
+- Defaults to STANDARD if Type property is not specified
+- Standard workflows are billed per state transition (includes retries)
+- Express workflows are billed per request and per GB-second of duration
+- Express workflows have a maximum duration of 5 minutes
+- Standard workflows can run for up to 1 year
+- First 4,000 state transitions per month are free tier eligible (Standard)
+- Activity polling and callbacks may incur additional charges
+
 ## Container Resources
 
 ### AWS::ECS::Service
@@ -695,7 +824,20 @@ usageAssumptions:
     websocket:
       messagesPerMonth: 5000000
       connectionMinutes: 500000
-  
+
+  # Messaging
+  sns:
+    monthlyPublishes: 5000000
+    httpDeliveries: 2000000
+    emailDeliveries: 100000
+    smsDeliveries: 10000
+    mobilePushDeliveries: 500000
+
+  stepFunctions:
+    monthlyExecutions: 50000           # Executions per month
+    stateTransitionsPerExecution: 15   # State transitions per execution (Standard)
+    averageDurationMs: 2000            # Average duration in ms (Express)
+
   # Containers
   ecs:
     fargate:
@@ -722,6 +864,11 @@ const result = await analyzeCosts({
       invocationsPerMonth: 5000000,
       averageDurationMs: 500,
     },
+    stepFunctions: {
+      monthlyExecutions: 50000,
+      stateTransitionsPerExecution: 15,
+      averageDurationMs: 2000,
+    },
   },
 });
 ```

package/package.json

@@ -57,7 +57,7 @@
     "jest": "^30.2.0",
     "jest-junit": "^16",
     "lint-staged": "^15.0.0",
-    "projen": "^0.99.11",
+    "projen": "^0.99.12",
     "ts-jest": "^29.4.6",
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3"
@@ -83,7 +83,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.29",
+  "version": "0.1.31",
   "bugs": {
     "url": "https://github.com/buildinginthecloud/cdk-cost-analyzer/issues"
   },