pangea 0.0.45 → 0.0.46

data/lib/pangea/resources/event_driven_example.rb

@@ -1,288 +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.
-
-
-# Example usage of DynamoDB and EventBridge resources for event-driven architecture
-require 'pangea/resources/aws_resources'
-
-module Pangea
-  module Resources
-    module Examples
-      # Complete event-driven e-commerce architecture example
-      class EventDrivenEcommerce
-        include AWS
-
-        def self.create_infrastructure
-          # 1. Create DynamoDB tables for different domains
-          
-          # User data table
-          users_table = aws_dynamodb_table(:users, {
-            name: "users",
-            billing_mode: "PAY_PER_REQUEST",
-            attribute: [
-              { name: "user_id", type: "S" },
-              { name: "email", type: "S" }
-            ],
-            hash_key: "user_id",
-            global_secondary_index: [
-              {
-                name: "EmailIndex",
-                hash_key: "email",
-                projection_type: "ALL"
-              }
-            ],
-            stream_enabled: true,
-            stream_view_type: "NEW_AND_OLD_IMAGES"
-          })
-
-          # Orders table with complex indexing
-          orders_table = aws_dynamodb_table(:orders, {
-            name: "orders",
-            billing_mode: "PAY_PER_REQUEST",
-            attribute: [
-              { name: "order_id", type: "S" },
-              { name: "user_id", type: "S" },
-              { name: "order_date", type: "S" },
-              { name: "status", type: "S" }
-            ],
-            hash_key: "order_id",
-            global_secondary_index: [
-              {
-                name: "UserOrdersIndex",
-                hash_key: "user_id",
-                range_key: "order_date",
-                projection_type: "ALL"
-              },
-              {
-                name: "StatusIndex",
-                hash_key: "status",
-                range_key: "order_date",
-                projection_type: "KEYS_ONLY"
-              }
-            ],
-            stream_enabled: true,
-            stream_view_type: "NEW_AND_OLD_IMAGES"
-          })
-
-          # Global inventory table for multi-region access
-          inventory_global = aws_dynamodb_global_table(:inventory, {
-            name: "global-inventory",
-            billing_mode: "PAY_PER_REQUEST",
-            server_side_encryption: { enabled: true },
-            point_in_time_recovery: { enabled: true },
-            stream_enabled: true,
-            stream_view_type: "NEW_AND_OLD_IMAGES",
-            replica: [
-              { region_name: "us-east-1", table_class: "STANDARD" },
-              { region_name: "us-west-2", table_class: "STANDARD" },
-              { region_name: "eu-west-1", table_class: "STANDARD_INFREQUENT_ACCESS" }
-            ]
-          })
-
-          # 2. Create EventBridge buses for different domains
-          
-          # User service events
-          user_bus = aws_eventbridge_bus(:user_events, {
-            name: "user-service-events",
-            tags: {
-              Service: "user-service",
-              Domain: "UserManagement"
-            }
-          })
-
-          # Order processing events
-          order_bus = aws_eventbridge_bus(:order_events, {
-            name: "order-service-events",
-            kms_key_id: "alias/order-processing-encryption",
-            tags: {
-              Service: "order-service",
-              Domain: "OrderProcessing",
-              Encryption: "enabled"
-            }
-          })
-
-          # Inventory management events
-          inventory_bus = aws_eventbridge_bus(:inventory_events, {
-            name: "inventory-service-events",
-            tags: {
-              Service: "inventory-service",
-              Domain: "InventoryManagement"
-            }
-          })
-
-          # 3. Create EventBridge rules for event processing
-          
-          # User signup processing rule
-          user_signup_rule = aws_eventbridge_rule(:user_signup, {
-            name: "user-signup-processing",
-            event_bus_name: "user-service-events",
-            description: "Process new user signups",
-            event_pattern: JSON.generate({
-              source: ["user.service"],
-              "detail-type": ["User Created"],
-              detail: {
-                status: ["active"]
-              }
-            }),
-            state: "ENABLED"
-          })
-
-          # Order status change rule
-          order_status_rule = aws_eventbridge_rule(:order_status, {
-            name: "order-status-changes",
-            event_bus_name: "order-service-events",
-            description: "Track order status changes",
-            event_pattern: JSON.generate({
-              source: ["order.service"],
-              "detail-type": ["Order Status Changed"],
-              detail: {
-                newStatus: ["confirmed", "shipped", "delivered", "cancelled"]
-              }
-            })
-          })
-
-          # Inventory low stock alert rule
-          low_stock_rule = aws_eventbridge_rule(:low_stock, {
-            name: "inventory-low-stock",
-            event_bus_name: "inventory-service-events",
-            description: "Alert when inventory is low",
-            event_pattern: JSON.generate({
-              source: ["inventory.service"],
-              "detail-type": ["Stock Level Changed"],
-              detail: {
-                stockLevel: [{ numeric: ["<", 10] }]
-              }
-            })
-          })
-
-          # Scheduled daily reporting rule
-          daily_reports_rule = aws_eventbridge_rule(:daily_reports, {
-            name: "daily-business-reports",
-            description: "Generate daily business reports",
-            schedule_expression: "cron(0 6 * * ? *)",  # 6 AM daily
-            state: "ENABLED"
-          })
-
-          # 4. Create EventBridge targets for event processing
-          
-          # User signup email notification target
-          signup_email_target = aws_eventbridge_target(:signup_email, {
-            rule: "user-signup-processing",
-            event_bus_name: "user-service-events",
-            target_id: "send-welcome-email",
-            arn: "arn:aws:lambda:us-east-1:123456789012:function:SendWelcomeEmail",
-            input_transformer: {
-              input_paths: {
-                "userId" => "$.detail.userId",
-                "email" => "$.detail.email",
-                "name" => "$.detail.name"
-              },
-              input_template: JSON.generate({
-                user_id: "<userId>",
-                email_address: "<email>",
-                user_name: "<name>",
-                template: "welcome_email",
-                source: "user_signup_event"
-              })
-            }
-          })
-
-          # Order processing SQS target with DLQ
-          order_processing_target = aws_eventbridge_target(:order_processing, {
-            rule: "order-status-changes",
-            event_bus_name: "order-service-events",
-            target_id: "order-processing-queue",
-            arn: "arn:aws:sqs:us-east-1:123456789012:order-processing-queue",
-            retry_policy: {
-              maximum_retry_attempts: 3,
-              maximum_event_age_in_seconds: 1800  # 30 minutes
-            },
-            dead_letter_config: {
-              arn: "arn:aws:sqs:us-east-1:123456789012:failed-orders-dlq"
-            }
-          })
-
-          # Inventory alert SNS target
-          inventory_alert_target = aws_eventbridge_target(:inventory_alerts, {
-            rule: "inventory-low-stock",
-            event_bus_name: "inventory-service-events", 
-            target_id: "inventory-alert-topic",
-            arn: "arn:aws:sns:us-east-1:123456789012:inventory-alerts",
-            role_arn: "arn:aws:iam::123456789012:role/EventBridgeSNSRole"
-          })
-
-          # Daily report ECS task target
-          daily_report_target = aws_eventbridge_target(:daily_reports, {
-            rule: "daily-business-reports",
-            target_id: "daily-report-task",
-            arn: "arn:aws:ecs:us-east-1:123456789012:cluster/reporting-cluster",
-            role_arn: "arn:aws:iam::123456789012:role/EventBridgeECSRole",
-            ecs_parameters: {
-              task_definition_arn: "arn:aws:ecs:us-east-1:123456789012:task-definition/daily-reports:1",
-              launch_type: "FARGATE",
-              task_count: 1,
-              network_configuration: {
-                awsvpc_configuration: {
-                  subnets: ["subnet-12345678", "subnet-87654321"],
-                  security_groups: ["sg-reporting"],
-                  assign_public_ip: "DISABLED"
-                }
-              }
-            }
-          })
-
-          # Kinesis analytics target for real-time insights
-          analytics_target = aws_eventbridge_target(:analytics_stream, {
-            rule: "order-status-changes",
-            event_bus_name: "order-service-events",
-            target_id: "order-analytics-stream",
-            arn: "arn:aws:kinesis:us-east-1:123456789012:stream/order-analytics",
-            role_arn: "arn:aws:iam::123456789012:role/EventBridgeKinesisRole",
-            kinesis_parameters: {
-              partition_key_path: "$.detail.orderId"
-            }
-          })
-
-          # Return all created resources for reference
-          {
-            tables: {
-              users: users_table,
-              orders: orders_table,
-              inventory: inventory_global
-            },
-            buses: {
-              user_events: user_bus,
-              order_events: order_bus,
-              inventory_events: inventory_bus
-            },
-            rules: {
-              user_signup: user_signup_rule,
-              order_status: order_status_rule,
-              low_stock: low_stock_rule,
-              daily_reports: daily_reports_rule
-            },
-            targets: {
-              signup_email: signup_email_target,
-              order_processing: order_processing_target,
-              inventory_alerts: inventory_alert_target,
-              daily_reports: daily_report_target,
-              analytics: analytics_target
-            }
-          }
-        end
-      end
-    end
-  end
-end

data/lib/pangea/resources/helpers.rb

@@ -1,54 +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.
-
-
-module Pangea
-  module Resources
-    # Helper functions available in template context
-    module Helpers
-      # Create a terraform reference to another resource
-      # @param resource_type [Symbol] The resource type (e.g., :aws_vpc)
-      # @param resource_name [Symbol] The resource name
-      # @param attribute [Symbol] The attribute to reference (e.g., :id)
-      # @return [String] Terraform reference string
-      def ref(resource_type, resource_name, attribute)
-        "${#{resource_type}.#{resource_name}.#{attribute}}"
-      end
-      
-      # Create a data source reference
-      # @param data_type [Symbol] The data source type
-      # @param data_name [Symbol] The data source name  
-      # @param attribute [Symbol] The attribute to reference
-      # @return [String] Terraform data reference string
-      def data_ref(data_type, data_name, attribute)
-        "${data.#{data_type}.#{data_name}.#{attribute}}"
-      end
-      
-      # Create a variable reference
-      # @param var_name [Symbol] The variable name
-      # @return [String] Terraform variable reference string
-      def var(var_name)
-        "${var.#{var_name}}"
-      end
-      
-      # Create a local value reference
-      # @param local_name [Symbol] The local value name
-      # @return [String] Terraform local reference string
-      def local(local_name)
-        "${local.#{local_name}}"
-      end
-    end
-  end
-end

data/lib/pangea/resources/reference.rb

@@ -1,280 +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 'dry-struct'
-require 'pangea/resources/types'
-
-module Pangea
-  module Resources
-    # Resource reference object returned by resource functions
-    # Provides access to resource attributes, outputs, and computed properties
-    class ResourceReference < Dry::Struct
-      
-      attribute :type, Types::String           # aws_vpc, aws_subnet, etc.
-      attribute :name, Types::Symbol           # Resource name
-      attribute :resource_attributes, Types::Hash       # Original attributes passed to function
-      attribute :outputs, Types::Hash.default({}.freeze)  # Available outputs for this resource type
-      
-      # Generate terraform reference for any attribute
-      def ref(attribute_name)
-        "${#{type}.#{name}.#{attribute_name}}"
-      end
-      
-      # Alias for ref - more natural syntax
-      def [](attribute_name)
-        ref(attribute_name)
-      end
-      
-      # Access to common outputs with friendly names
-      def id
-        ref(:id)
-      end
-      
-      def arn
-        ref(:arn)
-      end
-      
-      # Resource-specific computed properties
-      def computed_attributes
-        @computed_attributes ||= case type
-        when 'aws_vpc'
-          VpcComputedAttributes.new(self)
-        when 'aws_subnet'
-          SubnetComputedAttributes.new(self)
-        when 'aws_instance'
-          InstanceComputedAttributes.new(self)
-        else
-          BaseComputedAttributes.new(self)
-        end
-      end
-      
-      # Method delegation to computed attributes
-      def method_missing(method_name, *args, &block)
-        if computed_attributes.respond_to?(method_name)
-          computed_attributes.public_send(method_name, *args, &block)
-        else
-          super
-        end
-      end
-      
-      def respond_to_missing?(method_name, include_private = false)
-        computed_attributes.respond_to?(method_name, include_private) || super
-      end
-      
-      # Convert to hash for terraform-synthesizer integration
-      def to_h
-        {
-          type: type,
-          name: name,
-          attributes: resource_attributes,  # Use 'attributes' as key for compatibility
-          outputs: outputs
-        }
-      end
-    end
-    
-    # Base computed attributes - common to all resources
-    class BaseComputedAttributes
-      attr_reader :resource_ref
-      
-      def initialize(resource_ref)
-        @resource_ref = resource_ref
-      end
-      
-      # Common terraform attributes available on all resources
-      def id
-        resource_ref.ref(:id)
-      end
-      
-      def terraform_resource_name
-        "#{resource_ref.type}.#{resource_ref.name}"
-      end
-      
-      def tags
-        resource_ref.resource_attributes[:tags] || {}
-      end
-    end
-    
-    # VPC-specific computed attributes
-    class VpcComputedAttributes < BaseComputedAttributes
-      # VPC-specific terraform outputs
-      def cidr_block
-        resource_ref.ref(:cidr_block)
-      end
-      
-      def default_security_group_id
-        resource_ref.ref(:default_security_group_id)
-      end
-      
-      def default_route_table_id
-        resource_ref.ref(:default_route_table_id)
-      end
-      
-      def default_network_acl_id
-        resource_ref.ref(:default_network_acl_id)
-      end
-      
-      def dhcp_options_id
-        resource_ref.ref(:dhcp_options_id)
-      end
-      
-      def main_route_table_id
-        resource_ref.ref(:main_route_table_id)
-      end
-      
-      def owner_id
-        resource_ref.ref(:owner_id)
-      end
-      
-      # Computed helper methods
-      def is_private_cidr?
-        cidr = resource_ref.resource_attributes[:cidr_block]
-        return false unless cidr
-        
-        ip_parts = cidr.split('/')[0].split('.').map(&:to_i)
-        
-        # 10.0.0.0/8
-        return true if ip_parts[0] == 10
-        
-        # 172.16.0.0/12
-        return true if ip_parts[0] == 172 && (16..31).include?(ip_parts[1])
-        
-        # 192.168.0.0/16
-        return true if ip_parts[0] == 192 && ip_parts[1] == 168
-        
-        false
-      end
-      
-      def estimated_subnet_capacity
-        cidr_parts = resource_ref.resource_attributes[:cidr_block].split('/')
-        vpc_size = cidr_parts[1].to_i
-        
-        # Estimate how many /24 subnets can fit
-        case vpc_size
-        when 16 then 256
-        when 17 then 128
-        when 18 then 64
-        when 19 then 32
-        when 20 then 16
-        when 21 then 8
-        when 22 then 4
-        when 23 then 2
-        when 24 then 1
-        else 0
-        end
-      end
-    end
-    
-    # Subnet-specific computed attributes
-    class SubnetComputedAttributes < BaseComputedAttributes
-      def availability_zone
-        resource_ref.ref(:availability_zone)
-      end
-      
-      def availability_zone_id
-        resource_ref.ref(:availability_zone_id)
-      end
-      
-      def cidr_block
-        resource_ref.ref(:cidr_block)
-      end
-      
-      def vpc_id
-        resource_ref.ref(:vpc_id)
-      end
-      
-      def is_public?
-        resource_ref.resource_attributes[:map_public_ip_on_launch] == true
-      end
-      
-      def is_private?
-        !is_public?
-      end
-      
-      def subnet_type
-        is_public? ? 'public' : 'private'
-      end
-      
-      # Calculate approximate IP capacity
-      def ip_capacity
-        cidr_parts = resource_ref.resource_attributes[:cidr_block].split('/')
-        subnet_size = cidr_parts[1].to_i
-        
-        # AWS reserves 5 IPs per subnet
-        total_ips = 2**(32 - subnet_size)
-        total_ips - 5
-      end
-    end
-    
-    # EC2 Instance-specific computed attributes
-    class InstanceComputedAttributes < BaseComputedAttributes
-      def public_ip
-        resource_ref.ref(:public_ip)
-      end
-      
-      def private_ip
-        resource_ref.ref(:private_ip)
-      end
-      
-      def public_dns
-        resource_ref.ref(:public_dns)
-      end
-      
-      def private_dns
-        resource_ref.ref(:private_dns)
-      end
-      
-      def instance_state
-        resource_ref.ref(:instance_state)
-      end
-      
-      def subnet_id
-        resource_ref.ref(:subnet_id)
-      end
-      
-      def vpc_security_group_ids
-        resource_ref.ref(:vpc_security_group_ids)
-      end
-      
-      def instance_type
-        resource_ref.resource_attributes[:instance_type]
-      end
-      
-      def ami
-        resource_ref.resource_attributes[:ami]
-      end
-      
-      # Helper methods
-      def will_have_public_ip?
-        # If explicitly set to false, respect that
-        return false if resource_ref.resource_attributes[:associate_public_ip_address] == false
-        
-        # Otherwise, true if explicitly set to true or in a public subnet
-        resource_ref.resource_attributes[:associate_public_ip_address] == true ||
-          resource_ref.resource_attributes[:subnet_id]&.include?('public')
-      end
-      
-      def compute_family
-        instance_type = resource_ref.resource_attributes[:instance_type]
-        instance_type.split('.').first if instance_type
-      end
-      
-      def compute_size
-        instance_type = resource_ref.resource_attributes[:instance_type]
-        instance_type.split('.').last if instance_type
-      end
-    end
-  end
-end

data/lib/pangea/resources/templates/resource_template.rb.erb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module Pangea
-  module Resources
-    module AWS<%= service_name %>
-      # <%= description %>
-      #
-      # @example Basic usage
-      #   aws_<%= service_lower %>_<%= resource_lower %>(:<%= example_name %>,
-      #     <%= example_attributes %>
-      #   )
-      #
-      # @param name [Symbol] Resource identifier
-      # @param attributes [Hash] Resource configuration
-      # @return [ResourceReference] Reference to the created resource
-      def aws_<%= service_lower %>_<%= resource_lower %>(name, attributes = {})
-        validate_name!(name)
-        
-        # Use centralized types
-        attrs = Types::AWS<%= service_name %><%= resource_name %>.new(
-          apply_defaults(attributes)
-        )
-        
-        # Validate business rules
-        validate_<%= resource_lower %>_attributes(attrs)
-        
-        # Create resource
-        resource(:"aws_<%= service_lower %>_<%= resource_lower %>", name) do
-          attrs.to_h.each do |key, value|
-            case key
-            when :tags
-              tags value.merge(default_tags)
-            else
-              send(key, value)
-            end
-          end
-        end
-        
-        # Return typed reference
-        ResourceReference.new(
-          "aws_<%= service_lower %>_<%= resource_lower %>",
-          name,
-          attrs,
-          outputs: %i[id arn tags] + <%= resource_outputs %>
-        )
-      end
-      
-      private
-      
-      def validate_<%= resource_lower %>_attributes(attrs)
-        # Resource-specific validation
-        <%= validations %>
-      end
-    end
-  end
-end