pangea 0.0.45 → 0.0.46

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

@@ -1,295 +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 ElastiCache Parameter Group resources
-      class ElastiCacheParameterGroupAttributes < Dry::Struct
-        # Name of the parameter group
-        attribute :name, Resources::Types::String
-
-        # Description of the parameter group
-        attribute :description, Resources::Types::String.optional
-
-        # Cache parameter group family (e.g., "redis7.x", "memcached1.6")
-        attribute :family, Resources::Types::String.enum(
-          # Redis families
-          "redis2.6", "redis2.8", "redis3.2", "redis4.0", "redis5.0", "redis6.x", "redis7.x",
-          # Memcached families  
-          "memcached1.4", "memcached1.5", "memcached1.6"
-        )
-
-        # Parameters to apply to the parameter group
-        attribute :parameters, Resources::Types::Array.of(
-          Types::Hash.schema(
-            name: Types::String,
-            value: Types::String
-          )
-        ).default([].freeze)
-
-        # Tags to apply to the parameter group
-        attribute :tags, Resources::Types::AwsTags.default({})
-
-        # Custom validation
-        def self.new(attributes = {})
-          attrs = super(attributes)
-          
-          # Validate parameter group name format
-          unless attrs.name.match?(/\A[a-zA-Z0-9\-]+\z/)
-            raise Dry::Struct::Error, "Parameter group name must contain only letters, numbers, and hyphens"
-          end
-
-          # Validate name length
-          if attrs.name.length < 1 || attrs.name.length > 255
-            raise Dry::Struct::Error, "Parameter group name must be between 1 and 255 characters"
-          end
-
-          # Cannot start with a number or hyphen
-          if attrs.name.match?(/\A[\d\-]/)
-            raise Dry::Struct::Error, "Parameter group name cannot start with a number or hyphen"
-          end
-
-          # Cannot end with hyphen
-          if attrs.name.end_with?('-')
-            raise Dry::Struct::Error, "Parameter group name cannot end with a hyphen"
-          end
-
-          # Validate engine compatibility between family and parameters
-          engine_type = attrs.engine_type_from_family
-          attrs.parameters.each do |param|
-            unless attrs.parameter_valid_for_engine?(param[:name], engine_type)
-              raise Dry::Struct::Error, "Parameter '#{param[:name]}' is not valid for #{engine_type} engine"
-            end
-          end
-
-          # Default description if not provided
-          unless attrs.description
-            attrs = attrs.copy_with(description: "Custom parameter group for #{attrs.family}")
-          end
-
-          attrs
-        end
-
-        # Helper methods
-        def engine_type_from_family
-          family.start_with?('redis') ? 'redis' : 'memcached'
-        end
-
-        def is_redis_family?
-          family.start_with?('redis')
-        end
-
-        def is_memcached_family?
-          family.start_with?('memcached')
-        end
-
-        def family_version
-          family.sub(/^(redis|memcached)/, '')
-        end
-
-        def parameter_count
-          parameters.length
-        end
-
-        # Validate parameter compatibility with engine
-        def parameter_valid_for_engine?(param_name, engine_type)
-          case engine_type
-          when 'redis'
-            redis_parameters.include?(param_name)
-          when 'memcached'
-            memcached_parameters.include?(param_name)
-          else
-            false
-          end
-        end
-
-        # Common Redis parameters
-        def redis_parameters
-          [
-            'maxmemory-policy', 'timeout', 'tcp-keepalive', 'maxclients',
-            'reserved-memory', 'reserved-memory-percent', 'save',
-            'rdbchecksum', 'rdbcompression', 'repl-backlog-size',
-            'repl-backlog-ttl', 'repl-timeout', 'notify-keyspace-events',
-            'hash-max-ziplist-entries', 'hash-max-ziplist-value',
-            'list-max-ziplist-size', 'list-compress-depth',
-            'set-max-intset-entries', 'zset-max-ziplist-entries',
-            'zset-max-ziplist-value', 'slowlog-log-slower-than',
-            'slowlog-max-len', 'lua-time-limit', 'cluster-enabled',
-            'cluster-require-full-coverage', 'cluster-node-timeout'
-          ]
-        end
-
-        # Common Memcached parameters
-        def memcached_parameters
-          [
-            'binding_protocol', 'backlog_queue_limit', 'max_item_size',
-            'chunk_size_growth_factor', 'chunk_size', 'max_simultaneous_connections',
-            'minimum_allocated_slab', 'hash_algorithm'
-          ]
-        end
-
-        # Get parameters by type
-        def get_parameters_by_type(param_type)
-          case param_type
-          when :memory
-            parameters.select { |p| memory_related_parameters.include?(p[:name]) }
-          when :performance
-            parameters.select { |p| performance_related_parameters.include?(p[:name]) }
-          when :persistence
-            parameters.select { |p| persistence_related_parameters.include?(p[:name]) }
-          else
-            parameters
-          end
-        end
-
-        def memory_related_parameters
-          ['maxmemory-policy', 'reserved-memory', 'reserved-memory-percent', 'max_item_size']
-        end
-
-        def performance_related_parameters
-          ['maxclients', 'timeout', 'tcp-keepalive', 'slowlog-log-slower-than', 'chunk_size']
-        end
-
-        def persistence_related_parameters
-          ['save', 'rdbchecksum', 'rdbcompression']
-        end
-
-        # Validate parameter values
-        def validate_parameter_values
-          errors = []
-          
-          parameters.each do |param|
-            case param[:name]
-            when 'maxmemory-policy'
-              unless %w[volatile-lru allkeys-lru volatile-lfu allkeys-lfu volatile-random allkeys-random volatile-ttl noeviction].include?(param[:value])
-                errors << "Invalid maxmemory-policy value: #{param[:value]}"
-              end
-            when 'timeout'
-              unless param[:value].to_i >= 0
-                errors << "timeout must be >= 0"
-              end
-            when 'maxclients'
-              unless param[:value].to_i >= 1
-                errors << "maxclients must be >= 1"
-              end
-            end
-          end
-          
-          errors
-        end
-
-        # Check if this is a default parameter group
-        def is_default_group?
-          name.start_with?('default.')
-        end
-
-        # Cost implications (parameter groups themselves are free)
-        def has_cost_implications?
-          false
-        end
-
-        def estimated_monthly_cost
-          "$0.00/month (parameter groups are free)"
-        end
-      end
-
-      # Common ElastiCache parameter group configurations
-      module ElastiCacheParameterGroupConfigs
-        # Redis performance optimized configuration
-        def self.redis_performance(name, family: "redis7.x")
-          {
-            name: name,
-            family: family,
-            description: "Performance optimized Redis parameter group",
-            parameters: [
-              { name: "maxmemory-policy", value: "allkeys-lru" },
-              { name: "timeout", value: "300" },
-              { name: "tcp-keepalive", value: "60" },
-              { name: "reserved-memory-percent", value: "10" }
-            ]
-          }
-        end
-
-        # Redis persistence optimized configuration
-        def self.redis_persistence(name, family: "redis7.x")
-          {
-            name: name,
-            family: family,
-            description: "Persistence optimized Redis parameter group",
-            parameters: [
-              { name: "save", value: "900 1 300 10 60 10000" },
-              { name: "rdbcompression", value: "yes" },
-              { name: "rdbchecksum", value: "yes" },
-              { name: "maxmemory-policy", value: "allkeys-lru" }
-            ]
-          }
-        end
-
-        # Redis cluster mode configuration
-        def self.redis_cluster(name, family: "redis7.x")
-          {
-            name: name,
-            family: family,
-            description: "Redis cluster mode parameter group",
-            parameters: [
-              { name: "cluster-enabled", value: "yes" },
-              { name: "cluster-require-full-coverage", value: "no" },
-              { name: "cluster-node-timeout", value: "15000" },
-              { name: "maxmemory-policy", value: "allkeys-lru" }
-            ]
-          }
-        end
-
-        # Memcached performance configuration
-        def self.memcached_performance(name, family: "memcached1.6")
-          {
-            name: name,
-            family: family,
-            description: "Performance optimized Memcached parameter group",
-            parameters: [
-              { name: "max_item_size", value: "134217728" },  # 128MB
-              { name: "chunk_size_growth_factor", value: "1.25" },
-              { name: "max_simultaneous_connections", value: "65000" }
-            ]
-          }
-        end
-
-        # Redis memory optimized configuration
-        def self.redis_memory_optimized(name, family: "redis7.x")
-          {
-            name: name,
-            family: family,
-            description: "Memory optimized Redis parameter group",
-            parameters: [
-              { name: "maxmemory-policy", value: "volatile-lru" },
-              { name: "reserved-memory-percent", value: "25" },
-              { name: "hash-max-ziplist-entries", value: "1024" },
-              { name: "hash-max-ziplist-value", value: "64" },
-              { name: "list-max-ziplist-size", value: "-2" },
-              { name: "set-max-intset-entries", value: "512" }
-            ]
-          }
-        end
-      end
-    end
-      end
-    end
-  end
-end

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

@@ -1,286 +0,0 @@
-# AWS ElastiCache Subnet Group Implementation
-
-## Overview
-
-The `aws_elasticache_subnet_group` resource provides a type-safe interface for managing AWS ElastiCache Subnet Groups, which define VPC subnet placement for ElastiCache clusters with comprehensive validation and Multi-AZ support.
-
-## Architecture
-
-### Type System
-
-The implementation uses `ElastiCacheSubnetGroupAttributes` dry-struct for validation:
-
-```ruby
-class ElastiCacheSubnetGroupAttributes < Dry::Struct
-  attribute :name, Types::String
-  attribute? :description, Types::String.optional
-  attribute :subnet_ids, Types::Array.of(Types::String).constrained(min_size: 1)
-  attribute :tags, Types::AwsTags.default({})
-end
-```
-
-### Validation Strategy
-
-Comprehensive validation ensures AWS compatibility and best practices:
-
-#### Name Validation
-```ruby
-unless attrs.name.match?(/\A[a-z0-9\-]+\z/)
-  raise Dry::Struct::Error, "Subnet group name must contain only lowercase letters, numbers, and hyphens"
-end
-```
-
-#### Subnet ID Format Validation
-```ruby
-attrs.subnet_ids.each do |subnet_id|
-  unless subnet_id.match?(/\Asubnet-[a-f0-9]{8,17}\z/)
-    raise Dry::Struct::Error, "Invalid subnet ID format: #{subnet_id}"
-  end
-end
-```
-
-#### Multi-AZ Considerations
-```ruby
-def supports_multi_az?
-  subnet_count >= 2
-end
-
-def is_single_az?
-  subnet_count == 1
-end
-```
-
-## Key Features
-
-### 1. Subnet Group Naming
-
-Enforces AWS naming requirements:
-- Lowercase letters, numbers, and hyphens only
-- Cannot start or end with hyphen
-- 1-255 character length
-- Unique per region per account
-
-### 2. Subnet Validation
-
-Validates subnet configuration:
-- Minimum 1 subnet required
-- Maximum 20 subnets supported
-- Subnet ID format validation
-- All subnets must be in same VPC (enforced by AWS)
-
-### 3. Multi-AZ Assessment
-
-Automatic Multi-AZ capability detection:
-
-```ruby
-def supports_multi_az?
-  subnet_count >= 2
-end
-```
-
-Enables informed deployment decisions for high availability.
-
-### 4. Configuration Warnings
-
-Built-in configuration analysis:
-
-```ruby
-def validate_configuration
-  errors = []
-  
-  if is_single_az?
-    errors << "Single subnet limits cluster to single-AZ deployment"
-  end
-  
-  if subnet_count > 20
-    errors << "Maximum of 20 subnets supported per subnet group"
-  end
-  
-  errors
-end
-```
-
-## Implementation Patterns
-
-### 1. Resource Function Structure
-
-Follows Pangea's standard pattern with subnet-specific considerations:
-
-```ruby
-def aws_elasticache_subnet_group(name, attributes = {})
-  # 1. Validate attributes
-  subnet_group_attrs = ElastiCacheSubnetGroupAttributes.new(attributes)
-  
-  # 2. Generate terraform resource
-  resource(:aws_elasticache_subnet_group, name) do
-    name subnet_group_attrs.name
-    subnet_ids subnet_group_attrs.subnet_ids
-    description subnet_group_attrs.description if subnet_group_attrs.description
-  end
-  
-  # 3. Return ResourceReference
-  ResourceReference.new(...)
-end
-```
-
-### 2. Default Description Generation
-
-Automatic description generation when not provided:
-
-```ruby
-unless attrs.description
-  attrs = attrs.copy_with(description: "ElastiCache subnet group for #{attrs.name}")
-end
-```
-
-### 3. Cost Transparency
-
-Clear communication of cost implications:
-
-```ruby
-def has_cost_implications?
-  false
-end
-
-def estimated_monthly_cost
-  "$0.00/month (subnet groups are free)"
-end
-```
-
-## Configuration Helpers
-
-### Pre-defined Configurations
-
-`ElastiCacheSubnetGroupConfigs` module provides common patterns:
-
-```ruby
-module ElastiCacheSubnetGroupConfigs
-  def self.multi_az(name, subnet_ids, description: nil)
-    {
-      name: name,
-      subnet_ids: subnet_ids,
-      description: description || "Multi-AZ subnet group for #{name}"
-    }
-  end
-  
-  def self.private_subnets(name, private_subnet_ids)
-    {
-      name: "#{name}-private",
-      subnet_ids: private_subnet_ids,
-      description: "Private subnet group for #{name} ElastiCache clusters"
-    }
-  end
-end
-```
-
-## Resource Outputs
-
-Comprehensive outputs for integration with other resources:
-
-```ruby
-outputs: {
-  id: "${aws_elasticache_subnet_group.#{name}.id}",
-  name: "${aws_elasticache_subnet_group.#{name}.name}",
-  arn: "${aws_elasticache_subnet_group.#{name}.arn}",
-  vpc_id: "${aws_elasticache_subnet_group.#{name}.vpc_id}",
-  subnet_ids: "${aws_elasticache_subnet_group.#{name}.subnet_ids}"
-}
-```
-
-## Computed Properties
-
-Rich metadata for deployment decisions:
-
-```ruby
-computed_properties: {
-  subnet_count: subnet_group_attrs.subnet_count,
-  supports_multi_az: subnet_group_attrs.supports_multi_az?,
-  is_single_az: subnet_group_attrs.is_single_az?,
-  configuration_warnings: subnet_group_attrs.validate_configuration,
-  estimated_monthly_cost: subnet_group_attrs.estimated_monthly_cost
-}
-```
-
-## Integration Patterns
-
-### 1. VPC Integration
-
-Subnet groups bridge VPC subnets and ElastiCache clusters:
-
-```ruby
-# VPC subnet references
-subnet_ids = [
-  private_subnet_a.id,
-  private_subnet_b.id,
-  private_subnet_c.id
-]
-
-# Subnet group creation
-cache_subnets = aws_elasticache_subnet_group(:cache_subnets, {
-  name: "app-cache-subnets",
-  subnet_ids: subnet_ids
-})
-```
-
-### 2. ElastiCache Cluster Integration
-
-Direct integration with cluster resources:
-
-```ruby
-cache_cluster = aws_elasticache_cluster(:redis, {
-  cluster_id: "app-redis",
-  engine: "redis", 
-  node_type: "cache.r6g.large",
-  subnet_group_name: cache_subnets.name  # Reference subnet group
-})
-```
-
-### 3. Security Group Coordination
-
-Works with security groups for network access control:
-
-```ruby
-# Subnet group defines placement
-cache_subnets = aws_elasticache_subnet_group(:subnets, {...})
-
-# Security group defines access
-cache_sg = aws_security_group(:cache_sg, {...})
-
-# Both used in cluster
-cluster = aws_elasticache_cluster(:cluster, {
-  subnet_group_name: cache_subnets.name,
-  security_group_ids: [cache_sg.id]
-})
-```
-
-## Best Practices Encoded
-
-### 1. Security Guidance
-- Validates subnet configuration for private placement
-- Encourages private subnet usage through naming conventions
-
-### 2. High Availability Support
-- Multi-AZ detection and recommendations
-- Configuration warning system
-
-### 3. Naming Conventions
-- Enforces AWS naming requirements
-- Provides consistent naming patterns through helpers
-
-## AWS Service Integration
-
-### ElastiCache Service
-- Defines subnet placement for clusters
-- Enables VPC-based ElastiCache deployments
-- Supports both Redis and Memcached engines
-
-### VPC Service
-- Integrates with VPC subnets
-- Maintains VPC boundary constraints
-- Supports Multi-AZ subnet selection
-
-### IAM Integration
-- Subnet groups inherit VPC permissions
-- No additional IAM configuration required
-
-This implementation provides a foundation for secure, scalable ElastiCache deployments with proper subnet group management and comprehensive validation.

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

@@ -1,79 +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_elasticache_subnet_group/types'
-require 'pangea/resource_registry'
-
-module Pangea
-  module Resources
-    module AWS
-      # Create an AWS ElastiCache Subnet Group with type-safe attributes
-      #
-      # @param name [Symbol] The resource name
-      # @param attributes [Hash] ElastiCache subnet group attributes
-      # @return [ResourceReference] Reference object with outputs and computed properties
-      def aws_elasticache_subnet_group(name, attributes = {})
-        # Validate attributes using dry-struct
-        subnet_group_attrs = Types::ElastiCacheSubnetGroupAttributes.new(attributes)
-        
-        # Generate terraform resource block via terraform-synthesizer
-        resource(:aws_elasticache_subnet_group, name) do
-          name subnet_group_attrs.name
-          subnet_ids subnet_group_attrs.subnet_ids
-          description subnet_group_attrs.description if subnet_group_attrs.description
-          
-          # Apply tags if present
-          if subnet_group_attrs.tags.any?
-            tags do
-              subnet_group_attrs.tags.each do |key, value|
-                public_send(key, value)
-              end
-            end
-          end
-        end
-        
-        # Return resource reference with available outputs
-        ResourceReference.new(
-          type: 'aws_elasticache_subnet_group',
-          name: name,
-          resource_attributes: subnet_group_attrs.to_h,
-          outputs: {
-            id: "${aws_elasticache_subnet_group.#{name}.id}",
-            name: "${aws_elasticache_subnet_group.#{name}.name}",
-            arn: "${aws_elasticache_subnet_group.#{name}.arn}",
-            description: "${aws_elasticache_subnet_group.#{name}.description}",
-            subnet_ids: "${aws_elasticache_subnet_group.#{name}.subnet_ids}",
-            vpc_id: "${aws_elasticache_subnet_group.#{name}.vpc_id}",
-            tags_all: "${aws_elasticache_subnet_group.#{name}.tags_all}"
-          },
-          computed_properties: {
-            subnet_count: subnet_group_attrs.subnet_count,
-            supports_multi_az: subnet_group_attrs.supports_multi_az?,
-            is_single_az: subnet_group_attrs.is_single_az?,
-            configuration_warnings: subnet_group_attrs.validate_configuration,
-            has_cost_implications: subnet_group_attrs.has_cost_implications?,
-            estimated_monthly_cost: subnet_group_attrs.estimated_monthly_cost
-          }
-        )
-      end
-    end
-  end
-end
-
-# Auto-register this module when it's loaded
-Pangea::ResourceRegistry.register(:aws, Pangea::Resources::AWS)