pangea 0.0.45 → 0.0.46

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

@@ -1,123 +0,0 @@
-# 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
-      # Type-safe attributes for AWS Load Balancer Listener Rule resources
-      class LoadBalancerListenerRuleAttributes < Dry::Struct
-        # The ARN of the listener to attach the rule to
-        attribute :listener_arn, Resources::Types::String
-        
-        # The priority for the rule (1-50000, lower numbers have higher priority)
-        attribute :priority, Resources::Types::Integer.constrained(gteq: 1, lteq: 50000)
-        
-        # Actions to take when the rule conditions are met
-        attribute :action, Resources::Types::Array.of(
-          Types::Hash.schema(
-            type: Types::ListenerActionType,
-            target_group_arn?: Types::String.optional,
-            forward?: Types::ListenerForwardAction.optional,
-            redirect?: Types::ListenerRedirectAction.optional,
-            fixed_response?: Types::ListenerFixedResponseAction.optional,
-            authenticate_cognito?: Types::ListenerAuthenticateCognitoAction.optional,
-            authenticate_oidc?: Types::ListenerAuthenticateOidcAction.optional,
-            order?: Types::Integer.constrained(gteq: 1, lteq: 50000).optional
-          )
-        ).constrained(min_size: 1)
-        
-        # Conditions that must be met for the rule to apply
-        attribute :condition, Resources::Types::Array.of(
-          Types::Hash.schema(
-            field?: Types::String.optional, # Legacy field name
-            values?: Types::Array.of(Types::String).optional, # Legacy values
-            host_header?: Types::ListenerConditionHostHeader.optional,
-            path_pattern?: Types::ListenerConditionPathPattern.optional,
-            http_method?: Types::ListenerConditionHttpMethod.optional,
-            query_string?: Types::ListenerConditionQueryString.optional,
-            http_header?: Types::ListenerConditionHttpHeader.optional,
-            source_ip?: Types::ListenerConditionSourceIp.optional
-          )
-        ).constrained(min_size: 1)
-        
-        # Tags to apply to the listener rule
-        attribute :tags, Resources::Types::AwsTags.default({})
-
-        # Custom validation for condition and action completeness
-        def self.new(attributes = {})
-          attrs = super(attributes)
-          
-          # Validate that each condition has proper configuration
-          attrs.condition.each_with_index do |condition, index|
-            condition_types = []
-            
-            # Check legacy condition format first
-            if condition[:field] && condition[:values]
-              condition_types << 'legacy'
-            end
-            
-            # Check modern condition types
-            condition_types << 'host-header' if condition[:host_header]
-            condition_types << 'path-pattern' if condition[:path_pattern]
-            condition_types << 'http-method' if condition[:http_method]
-            condition_types << 'query-string' if condition[:query_string]
-            condition_types << 'http-header' if condition[:http_header]
-            condition_types << 'source-ip' if condition[:source_ip]
-            
-            if condition_types.empty?
-              raise Dry::Struct::Error, "Condition #{index + 1} must specify at least one condition type"
-            elsif condition_types.length > 1
-              raise Dry::Struct::Error, "Condition #{index + 1} can only specify one condition type, found: #{condition_types.join(', ')}"
-            end
-          end
-          
-          # Validate actions
-          attrs.action.each_with_index do |action, index|
-            case action[:type]
-            when 'forward'
-              unless action[:target_group_arn] || action[:forward]
-                raise Dry::Struct::Error, "Forward action #{index + 1} requires either target_group_arn or forward configuration"
-              end
-            when 'redirect'
-              unless action[:redirect]
-                raise Dry::Struct::Error, "Redirect action #{index + 1} requires redirect configuration"
-              end
-            when 'fixed-response'
-              unless action[:fixed_response]
-                raise Dry::Struct::Error, "Fixed-response action #{index + 1} requires fixed_response configuration"
-              end
-            when 'authenticate-cognito'
-              unless action[:authenticate_cognito]
-                raise Dry::Struct::Error, "Authenticate-cognito action #{index + 1} requires authenticate_cognito configuration"
-              end
-            when 'authenticate-oidc'
-              unless action[:authenticate_oidc]
-                raise Dry::Struct::Error, "Authenticate-oidc action #{index + 1} requires authenticate_oidc configuration"
-              end
-            end
-          end
-
-          attrs
-        end
-      end
-    end
-      end
-    end
-  end
-end

data/lib/pangea/resources/aws_lb_listener_rule/types.rbs

@@ -1,20 +0,0 @@
-# Type definitions for AWS Load Balancer Listener Rule resources
-
-module Pangea
-  module Resources
-    module AWS
-      class LoadBalancerListenerRuleAttributes < Dry::Struct
-        attribute :listener_arn, String
-        attribute :priority, Integer
-        attribute :action, Array[Hash[Symbol, untyped]]
-        attribute :condition, Array[Hash[Symbol, untyped]]
-        attribute :tags, Hash[Symbol, String]
-        
-        def self.new: (Hash[Symbol, untyped] attributes) -> LoadBalancerListenerRuleAttributes
-      end
-      
-      # Load balancer listener rule function signature
-      def aws_lb_listener_rule: (Symbol name, Hash[Symbol, untyped] attributes) -> ResourceReference
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-# 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_relative 'types'
-
-module Pangea
-  module Resources
-    module AWS
-      # Manages aws lb ssl negotiation policy resources.
-      #
-      # @param name [Symbol] The resource name
-      # @param attributes [Hash] Resource attributes
-      # @return [ResourceReference] Reference object with outputs and computed properties
-      def aws_lb_ssl_negotiation_policy(name, attributes = {})
-        # Validate attributes using dry-struct
-        attrs = Types::AwsLbSslNegotiationPolicyAttributes.new(attributes)
-        
-        # Generate terraform resource block via terraform-synthesizer
-        resource(:aws_lb_ssl_negotiation_policy, name) do
-          # TODO: Implement specific resource attributes
-          
-          # Apply tags if present
-          if attrs.tags.any?
-            tags do
-              attrs.tags.each do |key, value|
-                public_send(key, value)
-              end
-            end
-          end
-        end
-        
-        # Return resource reference with available outputs
-        ResourceReference.new(
-          type: 'aws_lb_ssl_negotiation_policy',
-          name: name,
-          resource_attributes: attrs.to_h,
-          outputs: {
-            id: "${aws_lb_ssl_negotiation_policy.#{name}.id}"
-            # TODO: Add specific output attributes
-          },
-          computed_properties: {
-            # TODO: Add computed properties
-          }
-        )
-      end
-    end
-  end
-end
-
-
-# Auto-register this module when it's loaded
-Pangea::ResourceRegistry.register(:aws, Pangea::Resources::AWS)

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

@@ -1,46 +0,0 @@
-# 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
-      # Type-safe attributes for AwsLbSslNegotiationPolicy resources
-      # Manages aws lb ssl negotiation policy resources.
-      class AwsLbSslNegotiationPolicyAttributes < Dry::Struct
-        # TODO: Define specific attributes for aws_lb_ssl_negotiation_policy
-        
-        # Tags to apply to the resource
-        attribute :tags, Resources::Types::AwsTags.default({})
-
-        # Custom validation
-        def self.new(attributes = {})
-          attrs = super(attributes)
-          
-          # TODO: Add custom validation logic
-          
-          attrs
-        end
-        
-        # TODO: Add computed properties specific to aws_lb_ssl_negotiation_policy
-      end
-    end
-      end
-    end
-  end
-end

data/lib/pangea/resources/aws_lb_target_group/CLAUDE.md

@@ -1,271 +0,0 @@
-# AWS Load Balancer Target Group Resource Implementation
-
-## Overview
-
-The `aws_lb_target_group` resource creates an AWS Target Group for use with Application Load Balancers (ALB), Network Load Balancers (NLB), or Gateway Load Balancers (GWLB). Target groups route requests to registered targets (EC2 instances, IP addresses, Lambda functions, or other ALBs) based on the protocol and port specified.
-
-## Type Safety Implementation
-
-### Attributes Structure
-
-```ruby
-class TargetGroupAttributes < Dry::Struct
-  # Required attributes
-  attribute :port, Port                              # 0-65535
-  attribute :protocol, String.enum(HTTP, HTTPS, TCP, TLS, UDP, TCP_UDP, GENEVE)
-  attribute :vpc_id, String                           # VPC ID
-  
-  # Optional attributes
-  attribute :name, String.optional
-  attribute :name_prefix, String.optional
-  attribute :target_type, AlbTargetType               # instance, ip, lambda, alb
-  attribute :deregistration_delay, Integer            # 0-3600 seconds
-  attribute :slow_start, Integer                      # 0-900 seconds
-  
-  # Nested configurations
-  attribute :health_check, TargetGroupHealthCheck.optional
-  attribute :stickiness, TargetGroupStickiness.optional
-end
-
-class TargetGroupHealthCheck < Dry::Struct
-  attribute :enabled, Bool
-  attribute :interval, Integer                        # 5-300 seconds
-  attribute :path, String                            # HTTP/HTTPS only
-  attribute :port, String                            # traffic-port or specific
-  attribute :protocol, HealthCheckProtocol
-  attribute :timeout, Integer                        # Must be < interval
-  attribute :healthy_threshold, Integer              # 2-10
-  attribute :unhealthy_threshold, Integer            # 2-10
-  attribute :matcher, String                         # HTTP status codes
-end
-```
-
-### Key Design Decisions
-
-1. **Protocol-Specific Validation**:
-   - GENEVE protocol requires port 6081
-   - HTTP/HTTPS support health check paths and stickiness
-   - TCP/TLS/UDP for Network Load Balancers
-   - Protocol version only valid for HTTP/HTTPS
-
-2. **Name vs Name Prefix**:
-   - Mutually exclusive options
-   - `name`: Fixed target group name
-   - `name_prefix`: AWS generates unique name
-
-3. **Health Check Configuration**:
-   - Timeout must be less than interval
-   - Path only valid for HTTP/HTTPS protocols
-   - Matcher (status codes) only for HTTP/HTTPS
-
-4. **Stickiness Support**:
-   - Only available for ALB (HTTP/HTTPS)
-   - Two types: lb_cookie and app_cookie
-   - app_cookie requires cookie_name
-
-5. **Computed Properties**:
-   - `supports_stickiness?`: True for HTTP/HTTPS
-   - `supports_health_check_path?`: True for HTTP/HTTPS
-   - `is_network_load_balancer?`: True for TCP/TLS/UDP
-
-## Resource Function Pattern
-
-The `aws_lb_target_group` function handles protocol-specific configurations:
-
-```ruby
-def aws_lb_target_group(name, attributes = {})
-  # 1. Validate attributes with dry-struct
-  tg_attrs = Types::TargetGroupAttributes.new(attributes)
-  
-  # 2. Generate Terraform resource via synthesizer
-  resource(:aws_lb_target_group, name) do
-    # Basic configuration
-    port tg_attrs.port
-    protocol tg_attrs.protocol
-    vpc_id tg_attrs.vpc_id
-    
-    # Conditional health check block
-    if tg_attrs.health_check
-      health_check do
-        # Only include path for HTTP/HTTPS
-        path hc.path if tg_attrs.supports_health_check_path?
-        # ... other health check settings
-      end
-    end
-    
-    # Conditional stickiness (only for ALB)
-    if tg_attrs.stickiness && tg_attrs.supports_stickiness?
-      stickiness do
-        # Stickiness configuration
-      end
-    end
-  end
-  
-  # 3. Return ResourceReference with outputs and computed properties
-  ResourceReference.new(
-    type: 'aws_lb_target_group',
-    name: name,
-    outputs: { id, arn, arn_suffix, name, port, protocol },
-    computed_properties: { supports_stickiness, is_network_load_balancer }
-  )
-end
-```
-
-## Integration with Terraform Synthesizer
-
-The resource handles protocol-specific features:
-
-```ruby
-resource(:aws_lb_target_group, name) do
-  port 80
-  protocol "HTTP"
-  vpc_id vpc_id
-  target_type "instance"
-  
-  # ALB-specific health check
-  health_check do
-    enabled true
-    interval 30
-    path "/health"        # Only for HTTP/HTTPS
-    port "traffic-port"
-    protocol "HTTP"
-    timeout 5
-    healthy_threshold 2
-    unhealthy_threshold 3
-    matcher "200-299"     # Only for HTTP/HTTPS
-  end
-  
-  # ALB-specific stickiness
-  stickiness do
-    enabled true
-    type "lb_cookie"
-    duration 86400
-  end
-  
-  tags do
-    Name "web-target-group"
-    Environment "production"
-  end
-end
-```
-
-## Common Usage Patterns
-
-### 1. HTTP Target Group for ALB
-```ruby
-tg = aws_lb_target_group(:web, {
-  port: 80,
-  protocol: "HTTP",
-  vpc_id: vpc.id,
-  health_check: {
-    enabled: true,
-    path: "/health",
-    interval: 30,
-    timeout: 5,
-    healthy_threshold: 2,
-    unhealthy_threshold: 3,
-    matcher: "200,301"
-  },
-  stickiness: {
-    enabled: true,
-    type: "lb_cookie",
-    duration: 3600
-  }
-})
-```
-
-### 2. TCP Target Group for NLB
-```ruby
-tg = aws_lb_target_group(:tcp_app, {
-  port: 3306,
-  protocol: "TCP",
-  vpc_id: vpc.id,
-  target_type: "instance",
-  deregistration_delay: 60,
-  health_check: {
-    enabled: true,
-    protocol: "TCP",
-    interval: 10,
-    timeout: 5,
-    healthy_threshold: 2,
-    unhealthy_threshold: 2
-  }
-})
-```
-
-### 3. Lambda Target Group
-```ruby
-tg = aws_lb_target_group(:lambda, {
-  port: 443,
-  protocol: "HTTPS",
-  vpc_id: vpc.id,
-  target_type: "lambda",
-  health_check: {
-    enabled: false  # Lambda health checks work differently
-  }
-})
-```
-
-### 4. IP-based Target Group for Containers
-```ruby
-tg = aws_lb_target_group(:container, {
-  port: 8080,
-  protocol: "HTTP",
-  vpc_id: vpc.id,
-  target_type: "ip",
-  slow_start: 30,  # Gradual traffic increase
-  deregistration_delay: 30,
-  health_check: {
-    path: "/api/health",
-    interval: 15,
-    timeout: 10,
-    healthy_threshold: 2,
-    unhealthy_threshold: 3
-  }
-})
-```
-
-## Testing Considerations
-
-1. **Type Validation**:
-   - Test protocol-specific constraints
-   - Test name/name_prefix mutual exclusivity
-   - Test health check timeout < interval
-   - Test port range validation
-
-2. **Protocol-Specific Features**:
-   - Verify stickiness only for HTTP/HTTPS
-   - Verify health check path only for HTTP/HTTPS
-   - Test GENEVE port requirement
-
-3. **Nested Structure Generation**:
-   - Test health check block generation
-   - Test stickiness block inclusion
-   - Test conditional attribute inclusion
-
-4. **Edge Cases**:
-   - Empty health check configuration
-   - Invalid protocol/feature combinations
-   - Target type specific validations
-
-## Future Enhancements
-
-1. **Enhanced Validation**:
-   - Cross-validate target type with protocol
-   - Validate health check protocol compatibility
-   - VPC ID format validation
-
-2. **Additional Features**:
-   - Connection termination settings
-   - Advanced routing configuration
-   - Target group weight support
-
-3. **Computed Properties**:
-   - Estimated target capacity
-   - Protocol-specific recommendations
-   - Health check timing analysis
-
-4. **Helper Methods**:
-   - Target registration helpers
-   - Health check template generators
-   - Blue/green deployment support

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

@@ -1,159 +0,0 @@
-# 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_lb_target_group/types'
-require 'pangea/resource_registry'
-
-module Pangea
-  module Resources
-    module AWS
-      # Create an AWS Load Balancer Target Group with type-safe attributes
-      #
-      # @param name [Symbol] The resource name
-      # @param attributes [Hash] Target Group attributes
-      # @option attributes [Integer] :port The port for targets (required)
-      # @option attributes [String] :protocol The protocol (HTTP, HTTPS, TCP, etc.) (required)
-      # @option attributes [String] :vpc_id The VPC ID (required)
-      # @option attributes [String] :target_type Target type (instance, ip, lambda, alb)
-      # @option attributes [Hash] :health_check Health check configuration
-      # @option attributes [Hash] :stickiness Session stickiness configuration
-      # @option attributes [Hash] :tags Resource tags
-      # @return [ResourceReference] Reference object with outputs and computed properties
-      #
-      # @example Basic HTTP target group
-      #   tg = aws_lb_target_group(:web, {
-      #     port: 80,
-      #     protocol: "HTTP",
-      #     vpc_id: vpc.id,
-      #     health_check: {
-      #       enabled: true,
-      #       path: "/health",
-      #       healthy_threshold: 2,
-      #       unhealthy_threshold: 3
-      #     },
-      #     tags: { Name: "web-target-group" }
-      #   })
-      #
-      # @example Target group with stickiness
-      #   tg = aws_lb_target_group(:app, {
-      #     port: 443,
-      #     protocol: "HTTPS",
-      #     vpc_id: vpc.id,
-      #     target_type: "ip",
-      #     stickiness: {
-      #       enabled: true,
-      #       type: "lb_cookie",
-      #       duration: 86400
-      #     }
-      #   })
-      def aws_lb_target_group(name, attributes = {})
-        # Validate attributes using dry-struct
-        tg_attrs = Types::Types::TargetGroupAttributes.new(attributes)
-        
-        # Generate terraform resource block via terraform-synthesizer
-        resource(:aws_lb_target_group, name) do
-          # Name or name_prefix
-          if tg_attrs.name
-            __send__(:name, tg_attrs.name)
-          elsif tg_attrs.name_prefix
-            name_prefix tg_attrs.name_prefix
-          end
-          
-          # Required attributes
-          port tg_attrs.port
-          protocol tg_attrs.protocol
-          vpc_id tg_attrs.vpc_id
-          
-          # Optional attributes
-          target_type tg_attrs.target_type if tg_attrs.target_type != 'instance'
-          deregistration_delay tg_attrs.deregistration_delay if tg_attrs.deregistration_delay != 300
-          slow_start tg_attrs.slow_start if tg_attrs.slow_start > 0
-          proxy_protocol_v2 tg_attrs.proxy_protocol_v2 if tg_attrs.proxy_protocol_v2
-          preserve_client_ip tg_attrs.preserve_client_ip unless tg_attrs.preserve_client_ip.nil?
-          ip_address_type tg_attrs.ip_address_type if tg_attrs.ip_address_type != 'ipv4'
-          protocol_version tg_attrs.protocol_version if tg_attrs.protocol_version
-          
-          # Health check configuration
-          if tg_attrs.health_check
-            health_check do
-              hc = tg_attrs.health_check
-              enabled hc.enabled
-              interval hc.interval
-              path hc.path if tg_attrs.supports_health_check_path?
-              port hc.port
-              protocol hc.protocol
-              timeout hc.timeout
-              healthy_threshold hc.healthy_threshold
-              unhealthy_threshold hc.unhealthy_threshold
-              matcher hc.matcher if tg_attrs.supports_health_check_path?
-            end
-          end
-          
-          # Stickiness configuration
-          if tg_attrs.stickiness && tg_attrs.supports_stickiness?
-            stickiness do
-              s = tg_attrs.stickiness
-              enabled s.enabled
-              type s.type
-              duration s.duration if s.type == 'lb_cookie'
-              cookie_name s.cookie_name if s.cookie_name
-            end
-          end
-          
-          # Apply tags if present
-          if tg_attrs.tags.any?
-            tags do
-              tg_attrs.tags.each do |key, value|
-                public_send(key, value)
-              end
-            end
-          end
-        end
-        
-        # Return resource reference with available outputs and computed properties
-        ref = ResourceReference.new(
-          type: 'aws_lb_target_group',
-          name: name,
-          resource_attributes: tg_attrs.to_h,
-          outputs: {
-            id: "${aws_lb_target_group.#{name}.id}",
-            arn: "${aws_lb_target_group.#{name}.arn}",
-            arn_suffix: "${aws_lb_target_group.#{name}.arn_suffix}",
-            name: "${aws_lb_target_group.#{name}.name}",
-            port: "${aws_lb_target_group.#{name}.port}",
-            protocol: "${aws_lb_target_group.#{name}.protocol}",
-            vpc_id: "${aws_lb_target_group.#{name}.vpc_id}",
-            target_type: "${aws_lb_target_group.#{name}.target_type}",
-            health_check: "${aws_lb_target_group.#{name}.health_check}",
-            stickiness: "${aws_lb_target_group.#{name}.stickiness}"
-          }
-        )
-        
-        # Add computed properties via method delegation
-        ref.define_singleton_method(:supports_stickiness?) { tg_attrs.supports_stickiness? }
-        ref.define_singleton_method(:supports_health_check_path?) { tg_attrs.supports_health_check_path? }
-        ref.define_singleton_method(:is_network_load_balancer?) { tg_attrs.is_network_load_balancer? }
-        
-        ref
-      end
-    end
-  end
-end
-
-# Auto-register this module when it's loaded
-Pangea::ResourceRegistry.register(:aws, Pangea::Resources::AWS)