pangea 0.0.45 → 0.0.47

data/lib/pangea/architectures/web_application_architecture/architecture.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # Copyright 2025 The Pangea Authors
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,38 +14,42 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-
 require_relative '../base'
 require_relative '../types'
 require_relative 'types'
+require_relative 'architecture/component_creation'
+require_relative 'architecture/resource_creation'
+require_relative 'architecture/fallback_resources'
+require_relative 'architecture/outputs'
+require_relative 'architecture/cost_estimation'
+require_relative 'architecture/helpers'
 require 'pangea/architecture_registry'
 
 module Pangea
   module Architectures
     module WebApplicationArchitecture
+      # Web application architecture builder
       class Architecture
+        include ComponentCreation
+        include ResourceCreation
+        include FallbackResources
+        include Outputs
+        include CostEstimation
+        include Helpers
+
         def self.build(name, attributes = {})
           new.build(name, attributes)
         end
 
         def build(name, attributes = {})
-          # 1. Validate input attributes
           arch_attrs = Types::Input.new(attributes)
-          
-          # 2. Merge with environment defaults
           defaults = Pangea::Architectures::Types.defaults_for_environment(arch_attrs.environment)
           merged_attrs = defaults.merge(arch_attrs.to_h)
-          
-          # 3. Create components using Pangea components
+
           components = create_components(name, merged_attrs)
-          
-          # 4. Create additional resources
           resources = create_resources(name, merged_attrs, components)
-          
-          # 5. Calculate outputs
           outputs = calculate_outputs(name, merged_attrs, components, resources)
-          
-          # 6. Return ArchitectureReference
+
           Pangea::Architectures::ArchitectureReference.new(
             type: 'web_application_architecture',
             name: name,
@@ -54,452 +59,11 @@ module Pangea
             outputs: outputs
           )
         end
-
-        private
-
-        def create_components(name, attributes)
-          # Include the Components module to access component functions
-          extend Pangea::Components if defined?(Pangea::Components)
-          
-          components = {}
-
-          # 1. Network Foundation
-          components[:network] = create_network_component(name, attributes)
-          
-          # 2. Security Groups
-          components[:security_groups] = create_security_groups(name, attributes, components[:network])
-          
-          # 3. Load Balancer
-          components[:load_balancer] = create_load_balancer(name, attributes, components[:network], components[:security_groups])
-          
-          # 4. Auto Scaling Web Servers
-          components[:web_servers] = create_web_servers(name, attributes, components[:network], components[:security_groups], components[:load_balancer])
-          
-          # 5. Database (if enabled)
-          if attributes[:database_enabled] != false
-            components[:database] = create_database(name, attributes, components[:network], components[:security_groups])
-          end
-          
-          # 6. Monitoring & Logging
-          components[:monitoring] = create_monitoring(name, attributes, components)
-          
-          # 7. Optional components
-          if attributes[:enable_caching]
-            components[:cache] = create_cache_component(name, attributes, components[:network], components[:security_groups])
-          end
-          
-          if attributes[:enable_cdn]
-            components[:cdn] = create_cdn_component(name, attributes, components[:load_balancer])
-          end
-          
-          components
-        end
-
-        def create_network_component(name, attributes)
-          # This would use the secure_vpc component if available
-          if defined?(Pangea::Components) && respond_to?(:secure_vpc)
-            secure_vpc(:"#{name}_network", {
-              cidr_block: attributes[:vpc_cidr] || "10.0.0.0/16",
-              availability_zones: attributes[:availability_zones] || ["us-east-1a", "us-east-1b", "us-east-1c"],
-              enable_flow_logs: attributes[:environment] == 'production',
-              tags: architecture_tags(attributes)
-            })
-          else
-            # Fallback to direct resource creation
-            create_vpc_directly(name, attributes)
-          end
-        end
-
-        def create_security_groups(name, attributes, network)
-          if defined?(Pangea::Components) && respond_to?(:web_security_group)
-            web_security_group(:"#{name}_web_sg", {
-              vpc_ref: network.respond_to?(:vpc) ? network.vpc : network,
-              allowed_cidr_blocks: attributes[:allowed_cidr_blocks] || ["0.0.0.0/0"],
-              tags: architecture_tags(attributes)
-            })
-          else
-            create_security_groups_directly(name, attributes, network)
-          end
-        end
-
-        def create_load_balancer(name, attributes, network, security_groups)
-          if defined?(Pangea::Components) && respond_to?(:application_load_balancer)
-            subnets = network.respond_to?(:public_subnets) ? network.public_subnets : []
-            sg_refs = security_groups.respond_to?(:security_groups) ? security_groups.security_groups : [security_groups]
-            
-            application_load_balancer(:"#{name}_alb", {
-              subnet_refs: subnets,
-              security_group_refs: sg_refs,
-              enable_deletion_protection: attributes[:environment] == 'production',
-              certificate_arn: attributes[:ssl_certificate_arn],
-              tags: architecture_tags(attributes)
-            })
-          else
-            create_load_balancer_directly(name, attributes, network, security_groups)
-          end
-        end
-
-        def create_web_servers(name, attributes, network, security_groups, load_balancer)
-          if defined?(Pangea::Components) && respond_to?(:auto_scaling_web_servers)
-            subnets = network.respond_to?(:private_subnets) ? network.private_subnets : []
-            
-            auto_scaling_web_servers(:"#{name}_web", {
-              subnet_refs: subnets,
-              target_group_ref: load_balancer.respond_to?(:target_group) ? load_balancer.target_group : nil,
-              min_size: attributes[:auto_scaling][:min],
-              max_size: attributes[:auto_scaling][:max],
-              desired_capacity: attributes[:auto_scaling][:desired] || attributes[:auto_scaling][:min],
-              instance_type: attributes[:instance_type] || 't3.medium',
-              tags: architecture_tags(attributes)
-            })
-          else
-            create_web_servers_directly(name, attributes, network, security_groups, load_balancer)
-          end
-        end
-
-        def create_database(name, attributes, network, security_groups)
-          engine = attributes[:database_engine] || 'mysql'
-          
-          if defined?(Pangea::Components)
-            component_method = case engine
-                             when 'mysql'
-                               :mysql_database
-                             when 'postgresql'  
-                               :postgresql_database
-                             else
-                               :mysql_database
-                             end
-            
-            if respond_to?(component_method)
-              subnets = network.respond_to?(:private_subnets) ? network.private_subnets : []
-              vpc = network.respond_to?(:vpc) ? network.vpc : network
-              
-              send(component_method, :"#{name}_db", {
-                subnet_refs: subnets,
-                vpc_ref: vpc,
-                instance_class: attributes[:database_instance_class] || 'db.t3.micro',
-                allocated_storage: attributes[:database_allocated_storage] || 20,
-                storage_encrypted: attributes[:environment] == 'production',
-                backup_retention_days: attributes[:backup]&.[](:retention_days) || (attributes[:environment] == 'production' ? 7 : 1),
-                multi_az: attributes[:high_availability] && attributes[:environment] == 'production',
-                tags: architecture_tags(attributes)
-              })
-            else
-              create_database_directly(name, attributes, network, security_groups)
-            end
-          else
-            create_database_directly(name, attributes, network, security_groups)
-          end
-        end
-
-        def create_monitoring(name, attributes, components)
-          # Create CloudWatch resources and dashboards
-          monitoring_resources = {}
-          
-          # This could use monitoring components if available
-          if attributes[:monitoring][:enable_alerting]
-            monitoring_resources[:alarms] = create_cloudwatch_alarms(name, attributes, components)
-          end
-          
-          if attributes[:monitoring][:detailed_monitoring]
-            monitoring_resources[:dashboard] = create_cloudwatch_dashboard(name, attributes, components)
-          end
-          
-          monitoring_resources
-        end
-
-        def create_cache_component(name, attributes, network, security_groups)
-          if defined?(Pangea::Components) && respond_to?(:elasticache_redis)
-            subnets = network.respond_to?(:private_subnets) ? network.private_subnets : []
-            
-            elasticache_redis(:"#{name}_cache", {
-              subnet_refs: subnets,
-              node_type: 'cache.t3.micro',
-              num_cache_nodes: 1,
-              port: 6379,
-              tags: architecture_tags(attributes)
-            })
-          else
-            create_cache_directly(name, attributes, network, security_groups)
-          end
-        end
-
-        def create_cdn_component(name, attributes, load_balancer)
-          if defined?(Pangea::Components) && respond_to?(:cloudfront_distribution)
-            cloudfront_distribution(:"#{name}_cdn", {
-              origin_domain_name: load_balancer.respond_to?(:dns_name) ? load_balancer.dns_name : '',
-              price_class: 'PriceClass_100',
-              tags: architecture_tags(attributes)
-            })
-          else
-            create_cdn_directly(name, attributes, load_balancer)
-          end
-        end
-
-        def create_resources(name, attributes, components)
-          resources = {}
-          
-          # DNS Zone (if domain provided)
-          if attributes[:domain_name]
-            resources[:dns_zone] = create_dns_zone(name, attributes)
-          end
-          
-          # SSL Certificate (if domain provided)
-          if attributes[:domain_name] && !attributes[:ssl_certificate_arn]
-            resources[:ssl_certificate] = create_ssl_certificate(name, attributes)
-          end
-          
-          # S3 buckets for logs, assets, etc.
-          resources[:s3_buckets] = create_s3_buckets(name, attributes)
-          
-          resources
-        end
-
-        def calculate_outputs(name, attributes, components, resources)
-          outputs = {}
-          
-          # Primary application URL
-          if attributes[:domain_name]
-            outputs[:application_url] = "https://#{attributes[:domain_name]}"
-          elsif components[:load_balancer] && components[:load_balancer].respond_to?(:dns_name)
-            outputs[:application_url] = "https://#{components[:load_balancer].dns_name}"
-          end
-          
-          # Load balancer DNS name
-          if components[:load_balancer] && components[:load_balancer].respond_to?(:dns_name)
-            outputs[:load_balancer_dns] = components[:load_balancer].dns_name
-          end
-          
-          # Database endpoint
-          if components[:database] && components[:database].respond_to?(:endpoint)
-            outputs[:database_endpoint] = components[:database].endpoint
-          end
-          
-          # CDN domain (if enabled)
-          if components[:cdn] && components[:cdn].respond_to?(:domain_name)
-            outputs[:cdn_domain] = components[:cdn].domain_name
-          end
-          
-          # Monitoring dashboard URL
-          if components[:monitoring] && components[:monitoring][:dashboard]
-            outputs[:monitoring_dashboard_url] = components[:monitoring][:dashboard][:url]
-          end
-          
-          # Estimated monthly cost
-          outputs[:estimated_monthly_cost] = calculate_monthly_cost(components, resources)
-          
-          # Architecture capabilities
-          outputs[:capabilities] = {
-            high_availability: has_high_availability?(components),
-            auto_scaling: has_auto_scaling?(components),
-            caching: components.key?(:cache),
-            cdn: components.key?(:cdn),
-            ssl_termination: attributes[:ssl_certificate_arn] || resources[:ssl_certificate],
-            monitoring: components[:monitoring]&.any?,
-            backup: has_backup_strategy?(components)
-          }
-          
-          outputs
-        end
-
-        # Fallback resource creation methods (when components aren't available)
-        def create_vpc_directly(name, attributes)
-          # Direct resource creation using aws_vpc, aws_subnet, etc.
-          # This would be implemented if needed
-          {
-            vpc: { id: "#{name}-vpc-id" },
-            public_subnets: [],
-            private_subnets: []
-          }
-        end
-
-        def create_security_groups_directly(name, attributes, network)
-          # Direct security group creation
-          {
-            web_sg: { id: "#{name}-web-sg-id" },
-            db_sg: { id: "#{name}-db-sg-id" }
-          }
-        end
-
-        def create_load_balancer_directly(name, attributes, network, security_groups)
-          # Direct ALB creation
-          {
-            arn: "arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/app/#{name}/1234567890123456",
-            dns_name: "#{name}-alb-1234567890.us-east-1.elb.amazonaws.com",
-            target_group: { arn: "#{name}-tg-arn" }
-          }
-        end
-
-        def create_web_servers_directly(name, attributes, network, security_groups, load_balancer)
-          # Direct ASG creation
-          {
-            auto_scaling_group_name: "#{name}-asg",
-            launch_template_id: "#{name}-lt",
-            min_size: attributes[:auto_scaling][:min],
-            max_size: attributes[:auto_scaling][:max]
-          }
-        end
-
-        def create_database_directly(name, attributes, network, security_groups)
-          # Direct RDS creation
-          {
-            endpoint: "#{name}-db.cluster-xyz.us-east-1.rds.amazonaws.com",
-            port: 3306,
-            db_name: name.to_s.gsub('-', '_')
-          }
-        end
-
-        def create_cache_directly(name, attributes, network, security_groups)
-          # Direct ElastiCache creation
-          {
-            cache_cluster_id: "#{name}-cache",
-            redis_endpoint: "#{name}-cache.abc123.0001.use1.cache.amazonaws.com",
-            port: 6379
-          }
-        end
-
-        def create_cdn_directly(name, attributes, load_balancer)
-          # Direct CloudFront creation
-          {
-            distribution_id: "E1234567890123",
-            domain_name: "d1234567890123.cloudfront.net"
-          }
-        end
-
-        def create_dns_zone(name, attributes)
-          # DNS zone creation logic
-          {
-            zone_id: "Z1234567890123",
-            name_servers: ["ns-123.awsdns-12.com", "ns-456.awsdns-45.net"]
-          }
-        end
-
-        def create_ssl_certificate(name, attributes)
-          # ACM certificate creation logic
-          {
-            certificate_arn: "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012",
-            domain_name: attributes[:domain_name]
-          }
-        end
-
-        def create_s3_buckets(name, attributes)
-          # S3 bucket creation for logs, assets, etc.
-          {
-            logs_bucket: { name: "#{name}-logs-#{SecureRandom.hex(8)}" },
-            assets_bucket: { name: "#{name}-assets-#{SecureRandom.hex(8)}" }
-          }
-        end
-
-        def create_cloudwatch_alarms(name, attributes, components)
-          # CloudWatch alarms creation
-          {
-            high_cpu_alarm: "#{name}-high-cpu",
-            low_cpu_alarm: "#{name}-low-cpu",
-            target_response_time_alarm: "#{name}-response-time"
-          }
-        end
-
-        def create_cloudwatch_dashboard(name, attributes, components)
-          # CloudWatch dashboard creation
-          {
-            dashboard_name: "#{name}-dashboard",
-            url: "https://console.aws.amazon.com/cloudwatch/home#dashboards:name=#{name}-dashboard"
-          }
-        end
-
-        # Helper methods
-        def architecture_tags(attributes)
-          base_tags = {
-            Architecture: 'WebApplication',
-            Environment: attributes[:environment],
-            ManagedBy: 'Pangea'
-          }
-          
-          base_tags.merge(attributes[:tags] || {})
-        end
-
-        def calculate_monthly_cost(components, resources)
-          # Simplified cost calculation
-          cost = 0.0
-          
-          # Load balancer cost
-          cost += 22.0 if components[:load_balancer]
-          
-          # EC2 instances (estimated based on auto scaling)
-          if components[:web_servers] && components[:web_servers][:min_size]
-            instance_cost = estimate_instance_cost(components[:web_servers][:instance_type] || 't3.medium')
-            cost += instance_cost * components[:web_servers][:min_size]
-          end
-          
-          # Database cost
-          if components[:database]
-            cost += estimate_database_cost(components[:database][:instance_class] || 'db.t3.micro')
-          end
-          
-          # Cache cost
-          cost += 15.0 if components[:cache]
-          
-          # CDN cost (estimated)
-          cost += 10.0 if components[:cdn]
-          
-          cost.round(2)
-        end
-
-        def estimate_instance_cost(instance_type)
-          case instance_type
-          when /t3\.micro/ then 8.5
-          when /t3\.small/ then 17.0
-          when /t3\.medium/ then 34.0
-          when /t3\.large/ then 67.0
-          when /c5\.large/ then 72.0
-          else 50.0
-          end
-        end
-
-        def estimate_database_cost(instance_class)
-          case instance_class
-          when /db\.t3\.micro/ then 16.0
-          when /db\.t3\.small/ then 32.0
-          when /db\.r5\.large/ then 180.0
-          else 80.0
-          end
-        end
-
-        def has_high_availability?(components)
-          # Check if deployed across multiple AZs
-          network = components[:network]
-          return false unless network
-          
-          if network.respond_to?(:availability_zones)
-            network.availability_zones.size >= 2
-          else
-            true # Assume HA for fallback
-          end
-        end
-
-        def has_auto_scaling?(components)
-          components[:web_servers] && 
-          components[:web_servers][:auto_scaling_group_name] &&
-          components[:web_servers][:max_size] > components[:web_servers][:min_size]
-        end
-
-        def has_backup_strategy?(components)
-          database = components[:database]
-          return false unless database
-          
-          # Check if backup retention is configured
-          if database.respond_to?(:backup_retention_days)
-            database.backup_retention_days > 0
-          else
-            true # Assume backup for fallback
-          end
-        end
       end
     end
 
     # Architecture module for auto-registration
     module WebApplicationArchitectureModule
-      # Architecture function that can be used in templates
       def web_application_architecture(name, attributes = {})
         WebApplicationArchitecture::Architecture.build(name, attributes)
       end
@@ -508,4 +72,4 @@ module Pangea
 end
 
 # Auto-register this architecture module when it's loaded
-Pangea::ArchitectureRegistry.register_architecture(Pangea::Architectures::WebApplicationArchitectureModule)
+Pangea::ArchitectureRegistry.register_architecture(Pangea::Architectures::WebApplicationArchitectureModule)

data/lib/pangea/architectures/web_application_architecture/types/cost_estimation.rb

@@ -0,0 +1,88 @@
+# 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.
+
+module Pangea
+  module Architectures
+    module WebApplicationArchitecture
+      module Types
+        # Cost estimation helpers for web application architecture
+        module CostEstimation
+          INSTANCE_COSTS = {
+            /t3\.micro/ => 8.5,
+            /t3\.small/ => 17.0,
+            /t3\.medium/ => 34.0,
+            /t3\.large/ => 67.0,
+            /c5\.large/ => 72.0
+          }.freeze
+
+          DATABASE_COSTS = {
+            /db\.t3\.micro/ => 16.0,
+            /db\.t3\.small/ => 32.0,
+            /db\.r5\.large/ => 180.0
+          }.freeze
+
+          ALB_BASE_COST = 22.0
+          CACHING_COST = 15.0
+          CDN_COST = 10.0
+          STORAGE_COST = 5.0
+          DEFAULT_INSTANCE_COST = 50.0
+          DEFAULT_DATABASE_COST = 80.0
+
+          module_function
+
+          def estimate_monthly_cost(attributes)
+            cost = ALB_BASE_COST
+
+            cost += compute_instance_cost(attributes)
+            cost += compute_database_cost(attributes)
+            cost += CACHING_COST if attributes[:enable_caching]
+            cost += CDN_COST if attributes[:enable_cdn]
+            cost += STORAGE_COST
+
+            apply_environment_multiplier(cost, attributes[:environment]).round(2)
+          end
+
+          def compute_instance_cost(attributes)
+            instance_cost = find_cost(attributes[:instance_type], INSTANCE_COSTS, DEFAULT_INSTANCE_COST)
+            instance_cost * attributes[:auto_scaling][:min]
+          end
+
+          def compute_database_cost(attributes)
+            return 0.0 unless attributes[:database_enabled]
+
+            db_cost = find_cost(attributes[:database_instance_class], DATABASE_COSTS, DEFAULT_DATABASE_COST)
+            db_cost += db_cost * 0.5 if attributes[:high_availability]
+            db_cost
+          end
+
+          def find_cost(type, cost_map, default)
+            cost_map.each do |pattern, cost|
+              return cost if type.match?(pattern)
+            end
+            default
+          end
+
+          def apply_environment_multiplier(cost, environment)
+            case environment
+            when 'production' then cost * 1.2
+            when 'staging' then cost * 1.1
+            else cost
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/architectures/web_application_architecture/types/defaults.rb

@@ -0,0 +1,90 @@
+# 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.
+
+module Pangea
+  module Architectures
+    module WebApplicationArchitecture
+      module Types
+        # Environment-specific defaults and input coercion
+        module Defaults
+          ENVIRONMENT_CONFIGS = {
+            'development' => {
+              instance_type: 't3.micro',
+              auto_scaling: { min: 1, max: 2, desired: 1 },
+              database_instance_class: 'db.t3.micro',
+              enable_caching: false,
+              enable_cdn: false,
+              high_availability: false
+            },
+            'staging' => {
+              instance_type: 't3.small',
+              auto_scaling: { min: 1, max: 4, desired: 2 },
+              database_instance_class: 'db.t3.small',
+              enable_caching: true,
+              enable_cdn: false,
+              high_availability: true
+            },
+            'production' => {
+              instance_type: 't3.medium',
+              auto_scaling: { min: 2, max: 10, desired: 3 },
+              database_instance_class: 'db.r5.large',
+              enable_caching: true,
+              enable_cdn: true,
+              high_availability: true
+            }
+          }.freeze
+
+          module_function
+
+          def compute_defaults_for_environment(environment)
+            base_defaults = Pangea::Architectures::Types.defaults_for_environment(environment)
+            web_app_defaults = ENVIRONMENT_CONFIGS.fetch(environment.to_s, {})
+
+            base_defaults.merge(web_app_defaults)
+          end
+
+          def coerce_input(raw_attributes)
+            # Apply environment-specific defaults
+            if raw_attributes[:environment]
+              defaults = compute_defaults_for_environment(raw_attributes[:environment])
+              raw_attributes = defaults.merge(raw_attributes)
+            end
+
+            # Coerce types
+            coerced = {}
+
+            # Handle tags coercion
+            coerced[:tags] = Pangea::Architectures::Types.coerce_tags(raw_attributes[:tags])
+
+            # Handle auto scaling config coercion
+            if raw_attributes[:auto_scaling]
+              coerced[:auto_scaling] = Pangea::Architectures::Types.coerce_auto_scaling_config(
+                raw_attributes[:auto_scaling]
+              )
+            end
+
+            # Merge coerced values
+            final_attributes = raw_attributes.merge(coerced)
+
+            # Validate the final configuration
+            Validation.validate_web_application_config(final_attributes)
+
+            Input.new(final_attributes)
+          end
+        end
+      end
+    end
+  end
+end