pangea 0.0.45 → 0.0.46

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

@@ -1,86 +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_api_gateway_api_key/types'
-require 'pangea/resource_registry'
-
-module Pangea
-  module Resources
-    module AWS
-      # Create an AWS API Gateway API Key with type-safe attributes
-      #
-      # @param name [Symbol] The resource name
-      # @param attributes [Hash] API Gateway API key attributes
-      # @return [ResourceReference] Reference object with outputs and computed properties
-      def aws_api_gateway_api_key(name, attributes = {})
-        # Validate attributes using dry-struct
-        api_key_attrs = Types::ApiGatewayApiKeyAttributes.new(attributes)
-        
-        # Generate terraform resource block via terraform-synthesizer
-        resource(:aws_api_gateway_api_key, name) do
-          name api_key_attrs.name
-          description api_key_attrs.description if api_key_attrs.description
-          enabled api_key_attrs.enabled
-          value api_key_attrs.value if api_key_attrs.value
-          
-          # Apply tags if present
-          if api_key_attrs.tags.any?
-            tags do
-              api_key_attrs.tags.each do |key, value|
-                public_send(key, value)
-              end
-            end
-          end
-        end
-        
-        # Return resource reference with available outputs
-        ResourceReference.new(
-          type: 'aws_api_gateway_api_key',
-          name: name,
-          resource_attributes: api_key_attrs.to_h,
-          outputs: {
-            id: "${aws_api_gateway_api_key.#{name}.id}",
-            arn: "${aws_api_gateway_api_key.#{name}.arn}",
-            name: "${aws_api_gateway_api_key.#{name}.name}",
-            description: "${aws_api_gateway_api_key.#{name}.description}",
-            enabled: "${aws_api_gateway_api_key.#{name}.enabled}",
-            value: "${aws_api_gateway_api_key.#{name}.value}",
-            created_date: "${aws_api_gateway_api_key.#{name}.created_date}",
-            last_updated_date: "${aws_api_gateway_api_key.#{name}.last_updated_date}",
-            tags_all: "${aws_api_gateway_api_key.#{name}.tags_all}"
-          },
-          computed_properties: {
-            active: api_key_attrs.active?,
-            disabled: api_key_attrs.disabled?,
-            custom_value: api_key_attrs.custom_value?,
-            auto_generated_value: api_key_attrs.auto_generated_value?,
-            security_level: api_key_attrs.security_level,
-            production_ready: api_key_attrs.production_ready?,
-            status: api_key_attrs.status,
-            key_type: api_key_attrs.key_type,
-            configuration_warnings: api_key_attrs.validate_configuration,
-            estimated_monthly_cost: api_key_attrs.estimated_monthly_cost
-          }
-        )
-      end
-    end
-  end
-end
-
-# Auto-register this module when it's loaded
-Pangea::ResourceRegistry.register(:aws, Pangea::Resources::AWS)

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

@@ -1,247 +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 API Gateway API Key resources
-      class ApiGatewayApiKeyAttributes < Dry::Struct
-        # Name for the API key
-        attribute :name, Resources::Types::String
-
-        # Description of the API key
-        attribute :description, Resources::Types::String.optional
-
-        # Whether the API key is enabled
-        attribute :enabled, Resources::Types::Bool.default(true)
-
-        # API key value (if provided, otherwise auto-generated)
-        attribute :value, Resources::Types::String.optional
-
-        # Tags to apply to the API key
-        attribute :tags, Resources::Types::AwsTags.default({})
-
-        # Custom validation
-        def self.new(attributes = {})
-          attrs = super(attributes)
-          
-          # Validate name format
-          unless attrs.name.match?(/\A[a-zA-Z0-9\-_]{1,128}\z/)
-            raise Dry::Struct::Error, "API key name must be 1-128 characters and contain only alphanumeric, hyphens, and underscores"
-          end
-
-          # Validate API key value format if provided
-          if attrs.value
-            unless attrs.value.match?(/\A[a-zA-Z0-9]{20,128}\z/)
-              raise Dry::Struct::Error, "API key value must be 20-128 characters and contain only alphanumeric characters"
-            end
-          end
-
-          # Set default description if not provided
-          unless attrs.description
-            status = attrs.enabled ? "Active" : "Disabled"
-            attrs = attrs.copy_with(description: "#{status} API key for #{attrs.name}")
-          end
-
-          attrs
-        end
-
-        # Helper methods
-        def active?
-          enabled
-        end
-
-        def disabled?
-          !enabled
-        end
-
-        def custom_value?
-          !value.nil?
-        end
-
-        def auto_generated_value?
-          value.nil?
-        end
-
-        def estimated_monthly_cost
-          "$0.00 (no additional charge for API keys)"
-        end
-
-        def validate_configuration
-          warnings = []
-          
-          if disabled?
-            warnings << "API key is disabled - remember to enable for production use"
-          end
-          
-          if name.length < 3
-            warnings << "Very short API key name - consider more descriptive naming"
-          end
-          
-          if custom_value? && value.length < 32
-            warnings << "Short custom API key value - consider longer keys for better security"
-          end
-          
-          unless description&.include?(name) || description&.include?('purpose')
-            warnings << "API key description should include purpose or context"
-          end
-          
-          warnings
-        end
-
-        # Get security assessment
-        def security_level
-          return 'low' if disabled?
-          
-          if custom_value?
-            case value.length
-            when 20..31
-              'medium'
-            when 32..63
-              'high'
-            else
-              'very_high'
-            end
-          else
-            'high' # AWS-generated keys are secure
-          end
-        end
-
-        # Check if suitable for production
-        def production_ready?
-          enabled && name.length >= 5
-        end
-
-        # Get key status
-        def status
-          enabled ? 'active' : 'disabled'
-        end
-
-        # Get key type
-        def key_type
-          custom_value? ? 'custom' : 'auto_generated'
-        end
-      end
-
-      # Common API Gateway API key configurations
-      module ApiGatewayApiKeyConfigs
-        # Standard API key for application
-        def self.application_api_key(app_name, environment = 'production')
-          {
-            name: "#{app_name.downcase.gsub(/[^a-z0-9]/, '-')}-#{environment}-api-key",
-            description: "#{environment.capitalize} API key for #{app_name}",
-            enabled: true,
-            tags: {
-              Application: app_name,
-              Environment: environment,
-              Purpose: 'API Access Control'
-            }
-          }
-        end
-
-        # Development API key with descriptive naming
-        def self.development_api_key(project_name, developer_name = nil)
-          key_name = developer_name ? 
-            "#{project_name.downcase.gsub(/[^a-z0-9]/, '-')}-#{developer_name.downcase.gsub(/[^a-z0-9]/, '-')}-dev" :
-            "#{project_name.downcase.gsub(/[^a-z0-9]/, '-')}-dev-api-key"
-          
-          {
-            name: key_name,
-            description: "Development API key for #{project_name}#{developer_name ? " (#{developer_name})" : ''}",
-            enabled: true,
-            tags: {
-              Environment: 'development',
-              Project: project_name,
-              Developer: developer_name,
-              Purpose: 'Development and Testing'
-            }.compact
-          }
-        end
-
-        # Corporate partner API key
-        def self.partner_api_key(partner_name, access_level = 'standard')
-          {
-            name: "#{partner_name.downcase.gsub(/[^a-z0-9]/, '-')}-partner-api-key",
-            description: "#{access_level.capitalize} access API key for partner #{partner_name}",
-            enabled: true,
-            tags: {
-              Partner: partner_name,
-              AccessLevel: access_level,
-              Purpose: 'Partner API Access',
-              KeyType: 'external_partner'
-            }
-          }
-        end
-
-        # Service-to-service API key
-        def self.service_api_key(service_name, target_service, environment = 'production')
-          {
-            name: "#{service_name.downcase.gsub(/[^a-z0-9]/, '-')}-to-#{target_service.downcase.gsub(/[^a-z0-9]/, '-')}-key",
-            description: "#{environment.capitalize} service key for #{service_name} to access #{target_service}",
-            enabled: true,
-            tags: {
-              SourceService: service_name,
-              TargetService: target_service,
-              Environment: environment,
-              Purpose: 'Service-to-Service Communication',
-              KeyType: 'internal_service'
-            }
-          }
-        end
-
-        # Mobile application API key
-        def self.mobile_app_api_key(app_name, platform, version = nil)
-          key_name = version ? 
-            "#{app_name.downcase.gsub(/[^a-z0-9]/, '-')}-#{platform.downcase}-v#{version.gsub('.', '-')}" :
-            "#{app_name.downcase.gsub(/[^a-z0-9]/, '-')}-#{platform.downcase}-mobile"
-          
-          {
-            name: key_name,
-            description: "#{platform} mobile API key for #{app_name}#{version ? " v#{version}" : ''}",
-            enabled: true,
-            tags: {
-              Application: app_name,
-              Platform: platform,
-              Version: version,
-              Purpose: 'Mobile Application Access',
-              KeyType: 'mobile_client'
-            }.compact
-          }
-        end
-
-        # Temporary/limited API key
-        def self.temporary_api_key(purpose, expiry_context, enabled = false)
-          {
-            name: "temp-#{purpose.downcase.gsub(/[^a-z0-9]/, '-')}-api-key",
-            description: "Temporary API key for #{purpose} (#{expiry_context})",
-            enabled: enabled,
-            tags: {
-              Purpose: purpose,
-              KeyType: 'temporary',
-              ExpiryContext: expiry_context,
-              AutoManaged: 'true'
-            }
-          }
-        end
-      end
-    end
-      end
-    end
-  end
-end

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

@@ -1,270 +0,0 @@
-# AWS API Gateway Deployment Implementation
-
-## Overview
-
-The `aws_api_gateway_deployment` resource implements type-safe creation of API deployments in API Gateway. Deployments make your API configuration available for invocation and can optionally create or update stages.
-
-## Implementation Details
-
-### Type System
-
-The implementation uses `dry-struct` for runtime validation with the following key validations:
-
-1. **Stage Name Validation**: 
-   - Alphanumeric and underscores only
-   - Blocks reserved names like 'test'
-
-2. **Canary Settings Validation**:
-   - Traffic percentage between 0.0 and 100.0
-   - Optional stage variable overrides for canary
-
-3. **Stage Variable Validation**:
-   - Variable names must be alphanumeric with underscores
-   - Values are always strings
-
-### Deployment Concepts
-
-API Gateway deployments work as snapshots:
-
-1. **Deployment**: Immutable snapshot of API configuration
-2. **Stage**: Mutable pointer to a deployment
-3. **Stage Variables**: Runtime configuration for stages
-
-### Deployment Triggers
-
-The resource supports triggers for automatic redeployment:
-
-- Method configuration changes
-- Integration changes
-- Model updates
-- Authorizer modifications
-- Manual timestamp triggers
-
-### Computed Properties
-
-The type class provides helper properties:
-
-- `creates_stage?`: Whether deployment creates a stage
-- `has_canary?`: Whether canary deployment is configured
-- `canary_percentage`: Percentage of canary traffic
-- `has_stage_variables?`: Whether stage variables exist
-
-## Design Patterns
-
-### Environment-Based Deployments
-
-Different stages for different environments:
-
-```
-dev -> Development deployment
-staging -> Staging deployment  
-prod -> Production deployment
-```
-
-### Version-Based Deployments
-
-Stages representing API versions:
-
-```
-v1 -> Version 1.0 deployment
-v2 -> Version 2.0 deployment
-```
-
-### Canary Deployments
-
-Gradual rollout strategies:
-
-```
-prod (90%) -> Current version
-prod canary (10%) -> New version testing
-```
-
-## Integration Patterns
-
-### With Lambda Aliases
-
-Stage variables control Lambda aliases:
-
-```ruby
-variables: {
-  "lambdaAlias" => "prod"  # Routes to prod alias
-}
-```
-
-### With Feature Flags
-
-Stage variables as feature toggles:
-
-```ruby
-variables: {
-  "enableNewFeature" => "true",
-  "debugMode" => "false"
-}
-```
-
-### With Backend Endpoints
-
-Stage-specific backend configuration:
-
-```ruby
-variables: {
-  "backendUrl" => "https://prod.backend.com"
-}
-```
-
-## Deployment Strategies
-
-### Blue-Green Deployments
-
-1. Deploy to "green" stage
-2. Test green environment
-3. Switch traffic from "blue" to "green"
-4. Keep blue as rollback option
-
-### Canary Deployments
-
-1. Deploy with small canary percentage
-2. Monitor canary metrics
-3. Gradually increase canary traffic
-4. Promote canary to 100% or rollback
-
-### Rolling Deployments
-
-1. Deploy to dev stage
-2. Promote to staging
-3. Final deployment to production
-4. Each stage validates before next
-
-## Performance Considerations
-
-1. **Deployment Time**: Deployments can take 30-60 seconds
-2. **Stage Caching**: Stages can cache responses
-3. **Canary Overhead**: Slight latency for traffic routing
-4. **Stage Variables**: No performance impact
-
-## Common Patterns
-
-### Multi-Environment Setup
-
-Standard dev/staging/prod pattern:
-
-```ruby
-# Each environment has different configuration
-dev: debug logging, no caching
-staging: info logging, test caching
-prod: error logging, full caching
-```
-
-### API Versioning
-
-Version-specific stages:
-
-```ruby
-/v1/* -> v1 stage
-/v2/* -> v2 stage
-```
-
-### Regional Deployments
-
-Region-specific configurations:
-
-```ruby
-us-east-1: US endpoints
-eu-west-1: EU endpoints
-ap-southeast-1: APAC endpoints
-```
-
-## Monitoring and Debugging
-
-1. **Deployment History**: Track all deployments
-2. **Stage Metrics**: Monitor per-stage performance
-3. **Canary Metrics**: Separate canary monitoring
-4. **Stage Logs**: Stage-specific CloudWatch logs
-
-## Error Handling
-
-Common deployment errors:
-
-1. **Validation Errors**: Invalid API configuration
-2. **Permission Errors**: Missing IAM permissions
-3. **Resource Limits**: Too many deployments
-4. **Stage Conflicts**: Stage already exists
-
-## Best Practices
-
-1. **Immutable Deployments**: Never modify deployments
-2. **Descriptive Names**: Clear deployment descriptions
-3. **Stage Variables**: Use for environment config
-4. **Canary Testing**: Start with low percentages
-5. **Trigger Management**: Automate redeployments
-
-## Security Considerations
-
-1. **Stage Isolation**: Each stage has separate config
-2. **Variable Security**: Don't store secrets in variables
-3. **Access Control**: Stage-specific IAM policies
-4. **Audit Trail**: Track deployment history
-
-## Cost Optimization
-
-1. **Stage Consolidation**: Minimize number of stages
-2. **Cache Configuration**: Enable caching per stage
-3. **Canary Duration**: Short canary periods
-4. **Deployment Frequency**: Batch changes
-
-## Testing Strategies
-
-1. **Stage Testing**: Test each stage independently
-2. **Canary Validation**: Monitor canary metrics
-3. **Rollback Testing**: Verify rollback procedures
-4. **Variable Testing**: Test all variable combinations
-
-## Common Use Cases
-
-### Feature Rollout
-
-Use canary deployments for gradual feature release:
-
-```ruby
-5% -> Early adopters
-25% -> Expanded testing
-50% -> Half rollout
-100% -> Full release
-```
-
-### A/B Testing
-
-Different stages for different experiences:
-
-```ruby
-stage_a: Original experience
-stage_b: New experience
-```
-
-### Maintenance Mode
-
-Stage variables for maintenance:
-
-```ruby
-variables: {
-  "maintenanceMode" => "true",
-  "maintenanceMessage" => "Scheduled maintenance"
-}
-```
-
-## Integration with CI/CD
-
-1. **Automated Deployments**: Trigger from CI/CD
-2. **Environment Promotion**: Automated stage promotion
-3. **Rollback Automation**: Automated failure recovery
-4. **Deployment Validation**: Post-deployment tests
-
-## Future Enhancements
-
-Potential improvements:
-
-1. **Deployment Templates**: Pre-configured patterns
-2. **Automatic Rollback**: Based on error rates
-3. **Stage Cloning**: Copy stage configurations
-4. **Deployment Scheduling**: Time-based deployments
-5. **Multi-Region Sync**: Coordinated deployments