pangea-aws 0.1.0

data/lib/pangea/resources/aws_ecs_cluster/types.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+# Copyright 2025 The Pangea Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'dry-struct'
+require 'pangea/resources/types'
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        # Type-safe attributes for AWS ECS Cluster resources
+        class EcsClusterAttributes < Pangea::Resources::BaseAttributes
+          transform_keys(&:to_sym)
+          
+          # Cluster name (required)
+          attribute? :name, Pangea::Resources::Types::String.optional
+
+          # Capacity providers
+          attribute :capacity_providers, Pangea::Resources::Types::Array.of(Pangea::Resources::Types::String).default([].freeze)
+
+          # Container Insights
+          attribute? :container_insights_enabled, Pangea::Resources::Types::Bool.optional
+
+          # Settings
+          attribute? :setting, Pangea::Resources::Types::Array.of(
+            Pangea::Resources::Types::Hash.schema(
+              name: Pangea::Resources::Types::String.constrained(included_in: ["containerInsights"]),
+              value: Pangea::Resources::Types::String.constrained(included_in: ["enabled", "disabled"])
+            ).lax
+          ).default([].freeze)
+
+          # Configuration for execute command
+          attribute? :configuration, Pangea::Resources::Types::Hash.schema(
+            execute_command_configuration?: Pangea::Resources::Types::Hash.schema(
+              kms_key_id?: Pangea::Resources::Types::String.optional,
+              logging?: Pangea::Resources::Types::String.constrained(included_in: ["DEFAULT", "NONE", "OVERRIDE"]).optional,
+              log_configuration?: Pangea::Resources::Types::Hash.schema(
+                cloud_watch_encryption_enabled?: Pangea::Resources::Types::Bool.optional,
+                cloud_watch_log_group_name?: Pangea::Resources::Types::String.optional,
+                s3_bucket_name?: Pangea::Resources::Types::String.optional,
+                s3_bucket_encryption_enabled?: Pangea::Resources::Types::Bool.optional,
+                s3_key_prefix?: Pangea::Resources::Types::String.optional
+              ).lax.optional
+            ).optional
+          ).optional
+
+          # Service Connect defaults
+          attribute? :service_connect_defaults, Pangea::Resources::Types::Hash.schema(
+            namespace: Pangea::Resources::Types::String
+          ).lax.optional
+
+          # Tags
+          attribute :tags, Pangea::Resources::Types::AwsTags.default({}.freeze)
+
+        # Custom validation
+        def self.new(attributes = {})
+          attrs = super(attributes)
+          
+          # Validate capacity providers
+          valid_providers = %w[FARGATE FARGATE_SPOT]
+          attrs.capacity_providers.each do |provider|
+            unless valid_providers.include?(provider) || provider.start_with?("arn:aws:ecs:")
+              raise Dry::Struct::Error, "Invalid capacity provider: #{provider}. Must be FARGATE, FARGATE_SPOT, or an ARN"
+            end
+          end
+
+          # Validate container insights setting
+          if attrs.container_insights_enabled && attrs.setting.any?
+            existing_insights = attrs.setting.find { |s| s[:name] == "containerInsights" }
+            if existing_insights
+              expected_value = attrs.container_insights_enabled ? "enabled" : "disabled"
+              if existing_insights[:value] != expected_value
+                raise Dry::Struct::Error, "container_insights_enabled conflicts with setting value"
+              end
+            end
+          end
+
+          attrs
+        end
+
+        # Helper to check if using Fargate
+        def using_fargate?
+          capacity_providers.any? { |cp| cp.include?("FARGATE") }
+        end
+
+        # Helper to check if using EC2
+        def using_ec2?
+          capacity_providers.any? { |cp| !cp.include?("FARGATE") }
+        end
+
+        # Helper to check if Container Insights is enabled
+        def insights_enabled?
+          return container_insights_enabled if !container_insights_enabled.nil?
+          
+          insights_setting = setting.find { |s| s[:name] == "containerInsights" }
+          insights_setting ? insights_setting[:value] == "enabled" : false
+        end
+
+        # Helper to estimate monthly cost
+        def estimated_monthly_cost
+          # Base cost for Container Insights if enabled
+          insights_cost = insights_enabled? ? 5.0 : 0.0
+          
+          # ECS cluster itself is free, but add estimates for common resources
+          base_estimate = {
+            insights: insights_cost,
+            service_connect: service_connect_defaults ? 2.0 : 0.0
+          }
+          
+          base_estimate.values.sum
+        end
+
+        # Helper to generate a cluster ARN pattern
+          def arn_pattern(region = "*", account_id = "*")
+            "arn:aws:ecs:#{region}:#{account_id}:cluster/#{name}"
+          end
+        end
+
+        # Type for ECS cluster capacity provider strategy
+        unless const_defined?(:EcsCapacityProviderStrategy)
+        class EcsCapacityProviderStrategy < Pangea::Resources::BaseAttributes
+          transform_keys(&:to_sym)
+          
+          attribute? :capacity_provider, Pangea::Resources::Types::String.optional
+          attribute :weight, Pangea::Resources::Types::Integer.constrained(gteq: 0, lteq: 1000).default(1)
+          attribute :base, Pangea::Resources::Types::Integer.constrained(gteq: 0, lteq: 100000).default(0)
+          
+          # Validate strategy
+          def self.new(attributes = {})
+            attrs = super(attributes)
+            
+            # Validate that weight and base make sense together
+            if attrs.base > 0 && attrs.weight == 0
+              raise Dry::Struct::Error, "Cannot have base > 0 with weight = 0"
+            end
+            
+            attrs
+          end
+        end
+      end
+        end
+    end
+  end
+end

data/lib/pangea/resources/aws_ecs_cluster_capacity_providers/resource.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+# Copyright 2025 The Pangea Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+require 'pangea/resources/base'
+require 'pangea/resources/reference'
+require 'pangea/resources/aws_ecs_cluster_capacity_providers/types'
+require 'pangea/resource_registry'
+
+module Pangea
+  module Resources
+    module AWS
+      # Create AWS ECS Cluster Capacity Providers association with type-safe attributes
+      #
+      # @param name [Symbol] The resource name
+      # @param attributes [Hash] ECS cluster capacity providers attributes
+      # @return [ResourceReference] Reference object with outputs and computed properties
+      def aws_ecs_cluster_capacity_providers(name, attributes = {})
+        # Validate attributes using dry-struct
+        providers_attrs = Types::EcsClusterCapacityProvidersAttributes.new(attributes)
+        
+        # Generate terraform resource block via terraform-synthesizer
+        resource(:aws_ecs_cluster_capacity_providers, name) do
+          # Cluster name
+          cluster_name providers_attrs.cluster_name
+          
+          # Capacity providers
+          capacity_providers providers_attrs.capacity_providers if providers_attrs.capacity_providers&.any?
+          
+          # Default capacity provider strategy
+          providers_attrs.default_capacity_provider_strategy.each do |strategy|
+            default_capacity_provider_strategy do
+              capacity_provider strategy.capacity_provider
+              weight strategy.weight
+              base strategy.base if strategy.base > 0
+            end
+          end
+        end
+        
+        # Return resource reference with available outputs
+        ResourceReference.new(
+          type: 'aws_ecs_cluster_capacity_providers',
+          name: name,
+          resource_attributes: providers_attrs.to_h,
+          outputs: {
+            id: "${aws_ecs_cluster_capacity_providers.#{name}.id}",
+            cluster_name: "${aws_ecs_cluster_capacity_providers.#{name}.cluster_name}"
+          },
+          computed_properties: {
+            using_fargate: providers_attrs.using_fargate?,
+            using_ec2: providers_attrs.using_ec2?,
+            using_custom_providers: providers_attrs.using_custom_providers?,
+            primary_capacity_provider: providers_attrs.primary_capacity_provider,
+            capacity_distribution: providers_attrs.capacity_distribution,
+            spot_prioritized: providers_attrs.spot_prioritized?,
+            estimated_spot_savings_percent: providers_attrs.estimated_spot_savings_percent,
+            provider_count: providers_attrs.capacity_providers.size,
+            has_default_strategy: providers_attrs.default_capacity_provider_strategy&.any?
+          }
+        )
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_ecs_cluster_capacity_providers/types.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+# Copyright 2025 The Pangea Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'pangea/resources/types'
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+      # Default capacity provider strategy
+      class EcsDefaultCapacityProviderStrategy < Pangea::Resources::BaseAttributes
+        attribute? :capacity_provider, Resources::Types::String.optional
+        attribute :weight, Resources::Types::Integer.constrained(gteq: 0, lteq: 1000).default(1)
+        attribute :base, Resources::Types::Integer.constrained(gteq: 0, lteq: 100000).default(0)
+        
+        # Validation
+        def self.new(attributes = {})
+          attrs = super(attributes)
+          
+          # Validate that base tasks don't exceed reasonable limits
+          if attrs.base > 0 && attrs.weight == 0
+            raise Dry::Struct::Error, "Cannot have base > 0 with weight = 0"
+          end
+          
+          attrs
+        end
+      end
+      
+      # Type-safe attributes for AWS ECS Cluster Capacity Providers
+      class EcsClusterCapacityProvidersAttributes < Pangea::Resources::BaseAttributes
+        # Cluster name (required)
+        attribute? :cluster_name, Resources::Types::String.optional
+        
+        # Capacity providers to associate with the cluster
+        attribute :capacity_providers, Resources::Types::Array.of(Resources::Types::String).default([].freeze)
+        
+        # Default capacity provider strategy
+        attribute :default_capacity_provider_strategy, Resources::Types::Array.of(EcsDefaultCapacityProviderStrategy).default([].freeze)
+        
+        # Custom validation
+        def self.new(attributes = {})
+          attrs = super(attributes)
+          
+          # Validate capacity provider names
+          valid_aws_providers = %w[FARGATE FARGATE_SPOT]
+          attrs.capacity_providers.each do |provider|
+            unless valid_aws_providers.include?(provider) || provider.start_with?("arn:aws:ecs:")
+              # Could be a custom capacity provider name
+              unless provider.match?(/^[\w\-]+$/)
+                raise Dry::Struct::Error, "Invalid capacity provider name format: #{provider}"
+              end
+            end
+          end
+          
+          # Validate default strategy references valid providers
+          if attrs.default_capacity_provider_strategy.any?
+            strategy_providers = attrs.default_capacity_provider_strategy.map(&:capacity_provider)
+            strategy_providers.each do |provider|
+              unless attrs.capacity_providers.include?(provider)
+                raise Dry::Struct::Error, "Default strategy references undefined capacity provider: #{provider}"
+              end
+            end
+            
+            # Validate total weight > 0
+            total_weight = attrs.default_capacity_provider_strategy.sum(&:weight)
+            if total_weight == 0 && attrs.default_capacity_provider_strategy.any? { |s| s.base == 0 }
+              raise Dry::Struct::Error, "Default capacity provider strategy must have at least one provider with weight > 0 or base > 0"
+            end
+            
+            # Validate only one provider can have base > 0 for a given base value
+            # Multiple providers can have different base values
+            base_counts = attrs.default_capacity_provider_strategy
+              .group_by(&:base)
+              .reject { |base, _| base == 0 }
+            
+            base_counts.each do |base, strategies|
+              if strategies.size > 1
+                raise Dry::Struct::Error, "Multiple providers cannot have the same base value (#{base})"
+              end
+            end
+          end
+          
+          attrs
+        end
+        
+        # Helper to check if using Fargate
+        def using_fargate?
+          capacity_providers.any? { |cp| cp.include?("FARGATE") }
+        end
+        
+        # Helper to check if using EC2
+        def using_ec2?
+          capacity_providers.any? { |cp| !cp.include?("FARGATE") && !cp.start_with?("arn:") }
+        end
+        
+        # Helper to check if using custom providers
+        def using_custom_providers?
+          capacity_providers.any? { |cp| !%w[FARGATE FARGATE_SPOT].include?(cp) }
+        end
+        
+        # Helper to get the primary capacity provider
+        def primary_capacity_provider
+          return nil if default_capacity_provider_strategy.empty?
+          
+          # Provider with highest base, or highest weight if no base
+          strategy_with_base = default_capacity_provider_strategy.max_by(&:base)
+          return strategy_with_base.capacity_provider if strategy_with_base.base > 0
+          
+          default_capacity_provider_strategy.max_by(&:weight).capacity_provider
+        end
+        
+        # Helper to calculate capacity distribution
+        def capacity_distribution
+          return {} if default_capacity_provider_strategy.empty?
+          
+          total_weight = default_capacity_provider_strategy.sum(&:weight)
+          return {} if total_weight == 0
+          
+          distribution = {}
+          default_capacity_provider_strategy.each do |strategy|
+            percentage = (strategy.weight.to_f / total_weight * 100).round(1)
+            distribution[strategy.capacity_provider] = {
+              percentage: percentage,
+              base: strategy.base
+            }
+          end
+          
+          distribution
+        end
+        
+        # Helper to check if Spot instances are prioritized
+        def spot_prioritized?
+          return false if default_capacity_provider_strategy.empty?
+          
+          spot_strategy = default_capacity_provider_strategy.find { |s| s.capacity_provider == "FARGATE_SPOT" }
+          regular_strategy = default_capacity_provider_strategy.find { |s| s.capacity_provider == "FARGATE" }
+          
+          return false unless spot_strategy && regular_strategy
+          
+          spot_strategy.weight > regular_strategy.weight
+        end
+        
+        # Helper to estimate cost savings from Spot usage
+        def estimated_spot_savings_percent
+          return 0.0 unless using_fargate?
+          
+          distribution = capacity_distribution
+          spot_percentage = distribution["FARGATE_SPOT"]&.dig(:percentage) || 0.0
+          
+          # Fargate Spot offers up to 70% discount
+          (spot_percentage * 0.7).round(1)
+        end
+      end
+    end
+      end
+    end
+  end

data/lib/pangea/resources/aws_ecs_service/dsl_builders.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+# Copyright 2025 The Pangea Authors. Licensed under Apache 2.0.
+
+module Pangea
+  module Resources
+    module AWS
+      # DSL methods for building ECS service resource blocks
+      # Extended into the resource block context to provide builder methods
+      module EcsServiceConnectDsl
+        def build_core_config(attrs)
+          name attrs.name
+          cluster attrs.cluster
+          task_definition attrs.task_definition
+        end
+
+        def build_scheduling_config(attrs)
+          desired_count attrs.desired_count unless attrs.scheduling_strategy == "DAEMON"
+          scheduling_strategy attrs.scheduling_strategy if attrs.scheduling_strategy != "REPLICA"
+        end
+
+        def build_launch_config(attrs)
+          return unless attrs.launch_type
+
+          launch_type attrs.launch_type
+          platform_version attrs.platform_version if attrs.launch_type == "FARGATE"
+        end
+
+        def build_capacity_provider_strategy(attrs)
+          attrs.capacity_provider_strategy.each do |strategy|
+            capacity_provider_strategy do
+              capacity_provider strategy.capacity_provider
+              weight strategy.weight
+              base strategy.base if strategy.base > 0
+            end
+          end
+        end
+
+        def build_load_balancers(attrs)
+          attrs.load_balancer.each do |lb|
+            load_balancer do
+              target_group_arn lb.target_group_arn
+              container_name lb.container_name
+              container_port lb.container_port
+            end
+          end
+        end
+
+        def build_network_config(attrs)
+          return unless attrs.network_configuration
+
+          network_configuration do
+            subnets attrs.network_configuration.subnets
+            security_groups attrs.network_configuration.security_groups if attrs.network_configuration.security_groups
+            assign_public_ip attrs.network_configuration.assign_public_ip
+          end
+        end
+
+        def build_service_registries(attrs)
+          attrs.service_registries.each do |registry|
+            service_registries do
+              registry_arn registry.registry_arn
+              port registry.port if registry.port
+              container_port registry.container_port if registry.container_port
+              container_name registry.container_name if registry.container_name
+            end
+          end
+        end
+
+        def build_deployment_config(attrs)
+          deployment_configuration do
+            deployment_circuit_breaker do
+              enable attrs.deployment_configuration.deployment_circuit_breaker[:enable]
+              rollback attrs.deployment_configuration.deployment_circuit_breaker[:rollback]
+            end
+            maximum_percent attrs.deployment_configuration.maximum_percent
+            minimum_healthy_percent attrs.deployment_configuration.minimum_healthy_percent
+          end
+
+          deployment_controller do
+            type attrs.deployment_controller[:type]
+          end
+        end
+
+        def build_placement_config(attrs)
+          attrs.placement_constraints.each do |constraint|
+            placement_constraints do
+              type constraint.type
+              expression constraint.expression if constraint.expression
+            end
+          end
+
+          attrs.placement_strategy.each do |strategy|
+            placement_strategy do
+              type strategy.type
+              field strategy.field if strategy.field
+            end
+          end
+        end
+
+        def build_additional_config(attrs)
+          health_check_grace_period_seconds attrs.health_check_grace_period_seconds if attrs.health_check_grace_period_seconds
+          enable_ecs_managed_tags attrs.enable_ecs_managed_tags
+          enable_execute_command attrs.enable_execute_command
+          propagate_tags attrs.propagate_tags if attrs.propagate_tags != "NONE"
+        end
+
+        def build_service_connect_config(attrs)
+          config = attrs.service_connect_configuration
+          return unless config
+
+          service_connect_configuration do
+            enabled config[:enabled]
+            namespace config[:namespace] if config[:namespace]
+
+            build_service_connect_services(config[:services]) if config[:services]
+            build_service_connect_log_config(config[:log_configuration]) if config[:log_configuration]
+          end
+        end
+
+        def build_lifecycle_config(attrs)
+          wait_for_steady_state attrs.wait_for_steady_state
+          force_new_deployment attrs.force_new_deployment
+        end
+
+        def build_tags(attrs)
+          return unless attrs.tags.any?
+
+          tags do
+            attrs.tags.each { |key, value| public_send(key, value) }
+          end
+        end
+
+        # Service Connect nested block builders
+        def build_service_connect_services(services)
+          services.each { |svc| build_service_connect_service(svc) }
+        end
+
+        def build_service_connect_service(svc)
+          service do
+            port_name svc[:port_name]
+            discovery_name svc[:discovery_name] if svc[:discovery_name]
+            ingress_port_override svc[:ingress_port_override] if svc[:ingress_port_override]
+
+            build_client_aliases(svc[:client_aliases]) if svc[:client_aliases]
+            build_timeout_config(svc[:timeout]) if svc[:timeout]
+            build_tls_config(svc[:tls]) if svc[:tls]
+          end
+        end
+
+        def build_client_aliases(aliases)
+          aliases.each do |alias_config|
+            client_alias do
+              port alias_config[:port]
+              dns_name alias_config[:dns_name] if alias_config[:dns_name]
+            end
+          end
+        end
+
+        def build_timeout_config(timeout_config)
+          timeout do
+            idle_timeout_seconds timeout_config[:idle_timeout_seconds] if timeout_config[:idle_timeout_seconds]
+            per_request_timeout_seconds timeout_config[:per_request_timeout_seconds] if timeout_config[:per_request_timeout_seconds]
+          end
+        end
+
+        def build_tls_config(tls_config)
+          tls do
+            issuer_certificate_authority do
+              aws_pca_authority_arn tls_config[:issuer_certificate_authority][:aws_pca_authority_arn]
+            end
+            kms_key tls_config[:kms_key] if tls_config[:kms_key]
+            role_arn tls_config[:role_arn] if tls_config[:role_arn]
+          end
+        end
+
+        def build_service_connect_log_config(log_config)
+          log_configuration do
+            log_driver log_config[:log_driver]
+            options log_config[:options] if log_config[:options]
+
+            log_config[:secret_options]&.each do |secret|
+              secret_option do
+                name secret[:name]
+                value_from secret[:value_from]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_ecs_service/reference_builder.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# Copyright 2025 The Pangea Authors. Licensed under Apache 2.0.
+
+require 'pangea/resources/reference'
+
+module Pangea
+  module Resources
+    module AWS
+      module EcsServiceReferenceBuilder
+        OUTPUTS = %i[
+          id name cluster iam_role desired_count launch_type
+          platform_version task_definition load_balancers
+          service_registries tags_all
+        ].freeze
+
+        # Build a ResourceReference for an ECS service
+        # @param name [Symbol] The resource name
+        # @param service_attrs [EcsServiceAttributes] The validated attributes
+        # @return [ResourceReference] Reference with outputs and computed properties
+        def self.build(name, service_attrs)
+          ref = ResourceReference.new(
+            type: 'aws_ecs_service',
+            name: name,
+            resource_attributes: service_attrs.to_h,
+            outputs: build_outputs(name)
+          )
+
+          define_computed_properties(ref, service_attrs)
+          ref
+        end
+
+        # Build output interpolations for all standard outputs
+        def self.build_outputs(name)
+          OUTPUTS.each_with_object({}) do |output, hash|
+            hash[output] = "${aws_ecs_service.#{name}.#{output}}"
+          end
+        end
+
+        # Define computed property methods on the reference
+        def self.define_computed_properties(ref, attrs)
+          ref.define_singleton_method(:using_fargate?) { attrs.using_fargate? }
+          ref.define_singleton_method(:load_balanced?) { attrs.load_balanced? }
+          ref.define_singleton_method(:service_discovery_enabled?) { attrs.service_discovery_enabled? }
+          ref.define_singleton_method(:service_connect_enabled?) { attrs.service_connect_enabled? }
+          ref.define_singleton_method(:estimated_monthly_cost) { attrs.estimated_monthly_cost }
+          ref.define_singleton_method(:deployment_safe?) { attrs.deployment_safe? }
+          ref.define_singleton_method(:is_daemon_service?) { attrs.scheduling_strategy == "DAEMON" }
+        end
+      end
+    end
+  end
+end