pangea-aws 0.1.0

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

@@ -0,0 +1,60 @@
+# 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
+    module AWS
+      module Types
+        # SES Domain Identity resource attributes
+        class SesDomainIdentityAttributes < Pangea::Resources::BaseAttributes
+          transform_keys(&:to_sym)
+
+          attribute? :domain, Resources::Types::DomainName.optional
+
+          # Custom validation
+          def self.new(attributes)
+            attrs = attributes.is_a?(::Hash) ? attributes : {}
+
+            # Validate domain is not a wildcard domain for SES
+            if attrs[:domain]&.start_with?('*.')
+              raise Dry::Struct::Error, "SES domain identity cannot be a wildcard domain: #{attrs[:domain]}"
+            end
+
+            super(attrs)
+          end
+
+          # Check if this is a subdomain
+          def is_subdomain?
+            domain.count('.') > 1
+          end
+
+          # Get parent domain
+          def parent_domain
+            return nil unless is_subdomain?
+            domain.split('.', 2)[1]
+          end
+
+          # Get domain parts for validation records
+          def domain_parts
+            domain.split('.')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# 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_ses_email_identity/types'
+require 'pangea/resource_registry'
+
+module Pangea
+  module Resources
+    module AWS
+      # Create an AWS SES Email Identity for email sending
+      #
+      # @param name [Symbol] The resource name
+      # @param attributes [Hash] Email identity attributes
+      # @option attributes [String] :email The email address to verify
+      # @return [ResourceReference] Reference object with outputs
+      def aws_ses_email_identity(name, attributes = {})
+        # Validate attributes using dry-struct
+        identity_attrs = Types::SesEmailIdentityAttributes.new(attributes)
+        
+        # Generate terraform resource block
+        resource(:aws_ses_email_identity, name) do
+          email identity_attrs.email
+        end
+        
+        # Return resource reference with outputs
+        ResourceReference.new(
+          type: 'aws_ses_email_identity',
+          name: name,
+          resource_attributes: identity_attrs.to_h,
+          outputs: {
+            email: "${aws_ses_email_identity.#{name}.email}",
+            arn: "${aws_ses_email_identity.#{name}.arn}"
+          }
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# 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
+    module AWS
+      module Types
+        # SES Email Identity resource attributes
+        class SesEmailIdentityAttributes < Pangea::Resources::BaseAttributes
+          transform_keys(&:to_sym)
+
+          attribute? :email, Resources::Types::EmailAddress.optional
+
+          # Custom validation for email format
+          def self.new(attributes)
+            attrs = attributes.is_a?(::Hash) ? attributes : {}
+
+            # Additional email validation beyond basic format
+            if attrs[:email]
+              email = attrs[:email].downcase
+              
+              # Check for common invalid patterns
+              if email.include?('..')
+                raise Dry::Struct::Error, "Email address cannot contain consecutive dots: #{attrs[:email]}"
+              end
+              
+              if email.start_with?('.') || email.end_with?('.')
+                raise Dry::Struct::Error, "Email address cannot start or end with a dot: #{attrs[:email]}"
+              end
+              
+              # Update with normalized email
+              attrs[:email] = email
+            end
+
+            super(attrs)
+          end
+
+          # Get the domain part of the email
+          def domain_part
+            email.split('@')[1]
+          end
+
+          # Get the local part of the email  
+          def local_part
+            email.split('@')[0]
+          end
+
+          # Check if email uses a common provider
+          def common_provider?
+            common_domains = %w[gmail.com yahoo.com hotmail.com outlook.com]
+            common_domains.include?(domain_part.downcase)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# 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_relative 'types'
+
+module Pangea
+  module Resources
+    module AWS
+      # AWS Step Functions Activity implementation
+      # Provides type-safe function for creating activities
+      def aws_sfn_activity(name, attributes = {})
+        # Validate attributes using dry-struct
+        validated_attrs = Types::SfnActivityAttributes.new(attributes)
+        
+        # Create reference that will be returned
+        ref = ResourceReference.new(
+          type: 'aws_sfn_activity',
+          name: name,
+          resource_attributes: validated_attrs.to_h,
+          outputs: {
+            id: "${aws_sfn_activity.#{name}.id}",
+            arn: "${aws_sfn_activity.#{name}.arn}",
+            name: "${aws_sfn_activity.#{name}.name}",
+            creation_date: "${aws_sfn_activity.#{name}.creation_date}",
+            tags_all: "${aws_sfn_activity.#{name}.tags_all}"
+          }
+        )
+        
+        # Synthesize the Terraform resource
+        resource :aws_sfn_activity, name do
+          name validated_attrs.name
+          
+          # Tags
+          if validated_attrs.tags
+            tags validated_attrs.tags
+          end
+        end
+        
+        # Return the reference
+        ref
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+# 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
+    module AWS
+      module Types
+        # AWS Step Functions Activity attributes with validation
+        class SfnActivityAttributes < Pangea::Resources::BaseAttributes
+          transform_keys(&:to_sym)
+          
+          # Core attributes
+          attribute? :name, Resources::Types::String.optional
+          
+          # Optional attributes
+          attribute? :tags, Resources::Types::Hash.optional
+          
+          # Custom validation
+          def self.new(attributes)
+            attrs = attributes.is_a?(::Hash) ? attributes : {}
+            
+            # Validate activity name format
+            if attrs[:name]
+              validate_activity_name(attrs[:name])
+            end
+            
+            super(attrs)
+          end
+          
+          def self.validate_activity_name(name)
+            # Activity names must be 1-80 characters
+            if name.length < 1 || name.length > 80
+              raise Dry::Struct::Error, "Activity name must be between 1 and 80 characters"
+            end
+            
+            # Must contain only alphanumeric, hyphens, and underscores
+            unless name.match?(/^[a-zA-Z0-9\-_]+$/)
+              raise Dry::Struct::Error, "Activity name can only contain letters, numbers, hyphens, and underscores"
+            end
+            
+            # Cannot start or end with hyphen
+            if name.start_with?('-') || name.end_with?('-')
+              raise Dry::Struct::Error, "Activity name cannot start or end with a hyphen"
+            end
+            
+            true
+          end
+          
+          # Computed properties
+          def is_valid_name?
+            return false unless name
+            
+            begin
+              self.class.validate_activity_name(name)
+              true
+            rescue Dry::Struct::Error
+              false
+            end
+          end
+          
+          def estimated_arn(region, account_id)
+            "arn:aws:states:#{region}:#{account_id}:activity:#{name}"
+          end
+          
+          # Activity naming patterns
+          def self.activity_name_patterns
+            {
+              data_processing: "data-processing-activity",
+              file_processing: "file-processing-activity", 
+              image_processing: "image-processing-activity",
+              email_sending: "email-sending-activity",
+              report_generation: "report-generation-activity",
+              data_validation: "data-validation-activity",
+              backup_task: "backup-task-activity",
+              cleanup_task: "cleanup-task-activity",
+              monitoring_check: "monitoring-check-activity",
+              health_check: "health-check-activity",
+              batch_job: "batch-job-activity",
+              etl_process: "etl-process-activity",
+              ml_training: "ml-training-activity",
+              ml_inference: "ml-inference-activity",
+              api_integration: "api-integration-activity"
+            }
+          end
+          
+          # Common activity configurations
+          def self.data_processing_activity(name_suffix = "")
+            suffix = name_suffix.empty? ? "" : "-#{name_suffix}"
+            "data-processing-activity#{suffix}"
+          end
+          
+          def self.worker_activity(worker_type, environment = nil)
+            base_name = "#{worker_type}-worker-activity"
+            environment ? "#{base_name}-#{environment}" : base_name
+          end
+          
+          def self.batch_activity(batch_type)
+            "#{batch_type}-batch-activity"
+          end
+          
+          def self.integration_activity(service_name, action)
+            "#{service_name}-#{action}-activity"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# 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_relative 'types'
+
+module Pangea
+  module Resources
+    module AWS
+      # AWS Step Functions State Machine implementation
+      # Provides type-safe function for creating state machines
+      def aws_sfn_state_machine(name, attributes = {})
+        # Validate attributes using dry-struct
+        validated_attrs = Types::SfnStateMachineAttributes.new(attributes)
+        
+        # Create reference that will be returned
+        ref = ResourceReference.new(
+          type: 'aws_sfn_state_machine',
+          name: name,
+          resource_attributes: validated_attrs.to_h,
+          outputs: {
+            id: "${aws_sfn_state_machine.#{name}.id}",
+            arn: "${aws_sfn_state_machine.#{name}.arn}",
+            name: "${aws_sfn_state_machine.#{name}.name}",
+            creation_date: "${aws_sfn_state_machine.#{name}.creation_date}",
+            status: "${aws_sfn_state_machine.#{name}.status}",
+            tags_all: "${aws_sfn_state_machine.#{name}.tags_all}"
+          }
+        )
+        
+        # Synthesize the Terraform resource
+        resource :aws_sfn_state_machine, name do
+          name validated_attrs.name
+          definition validated_attrs.definition
+          role_arn validated_attrs.role_arn
+          type validated_attrs.type if validated_attrs.type
+          
+          # Optional logging configuration
+          if validated_attrs.logging_configuration
+            logging_configuration do
+              level validated_attrs.logging_configuration&.dig(:level) if validated_attrs.logging_configuration&.dig(:level)
+              include_execution_data validated_attrs.logging_configuration&.dig(:include_execution_data) if validated_attrs.logging_configuration.key?(:include_execution_data)
+              
+              if validated_attrs.logging_configuration&.dig(:destinations)
+                validated_attrs.logging_configuration&.dig(:destinations).each do |destination|
+                  destination do
+                    if destination[:cloud_watch_logs_log_group]
+                      cloud_watch_logs_log_group do
+                        log_group_arn destination[:cloud_watch_logs_log_group][:log_group_arn]
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+          
+          # Optional tracing configuration
+          if validated_attrs.tracing_configuration
+            tracing_configuration do
+              enabled validated_attrs.tracing_configuration&.dig(:enabled) if validated_attrs.tracing_configuration.key?(:enabled)
+            end
+          end
+          
+          # Tags
+          if validated_attrs.tags
+            tags validated_attrs.tags
+          end
+        end
+        
+        # Return the reference
+        ref
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_sfn_state_machine/types/attributes.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# Copyright 2025 The Pangea Authors. Licensed under Apache 2.0.
+
+require 'dry-struct'
+require 'pangea/resources/types'
+require 'json'
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        # AWS Step Functions State Machine attributes with validation
+        class SfnStateMachineAttributes < Pangea::Resources::BaseAttributes
+          transform_keys(&:to_sym)
+
+          # Core attributes
+          attribute? :name, Resources::Types::String.optional
+          attribute? :definition, Resources::Types::String.optional
+          attribute? :role_arn, Resources::Types::String.optional
+
+          # Optional attributes
+          attribute :type, Resources::Types::String.optional.default("STANDARD")
+          attribute? :logging_configuration, Resources::Types::Hash.optional
+          attribute? :tracing_configuration, Resources::Types::Hash.optional
+          attribute? :tags, Resources::Types::Hash.optional
+
+          # Custom validation
+          def self.new(attributes)
+            attrs = attributes.is_a?(::Hash) ? attributes : {}
+            SfnValidators.validate_type(attrs)
+            SfnValidators.validate_definition(attrs)
+            SfnValidators.validate_logging(attrs)
+            SfnValidators.validate_tracing(attrs)
+            super(attrs)
+          end
+
+          # Computed properties
+          def is_express_type? = type == "EXPRESS"
+          def is_standard_type? = type == "STANDARD"
+          def has_logging? = !logging_configuration.nil? && logging_configuration&.dig(:level) != "OFF"
+          def has_tracing? = !tracing_configuration.nil? && tracing_configuration&.dig(:enabled) == true
+          def parsed_definition = @parsed_definition ||= ::JSON.parse(definition)
+          def start_state = parsed_definition["StartAt"]
+          def states = parsed_definition["States"] || {}
+          def state_count = states.size
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_sfn_state_machine/types/builders.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+# Copyright 2025 The Pangea Authors. Licensed under Apache 2.0.
+
+require 'json'
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        class SfnStateMachineAttributes < Pangea::Resources::BaseAttributes          # Common state machine pattern builders
+          module Builders
+            extend self
+
+            def simple_task_definition(task_arn, next_state = nil)
+              state = { "Type" => "Task", "Resource" => task_arn }
+              state[next_state ? "Next" : "End"] = next_state || true
+              ::JSON.pretty_generate({
+                "Comment" => "Simple task state machine",
+                "StartAt" => "Task",
+                "States" => { "Task" => state }
+              })
+            end
+
+            def sequential_tasks_definition(tasks)
+              states = {}
+              tasks.each_with_index do |(name, resource), index|
+                state = { "Type" => "Task", "Resource" => resource }
+                if index < tasks.size - 1
+                  state["Next"] = tasks[index + 1][0]
+                else
+                  state["End"] = true
+                end
+                states[name] = state
+              end
+              ::JSON.pretty_generate({
+                "Comment" => "Sequential tasks state machine",
+                "StartAt" => tasks.first[0],
+                "States" => states
+              })
+            end
+
+            def parallel_tasks_definition(branches)
+              parallel_branches = branches.map do |_branch_name, tasks|
+                {
+                  "StartAt" => tasks.first[0],
+                  "States" => tasks.each_with_object({}) do |(name, resource), states|
+                    states[name] = { "Type" => "Task", "Resource" => resource, "End" => true }
+                  end
+                }
+              end
+              ::JSON.pretty_generate({
+                "Comment" => "Parallel tasks state machine",
+                "StartAt" => "Parallel",
+                "States" => {
+                  "Parallel" => { "Type" => "Parallel", "Branches" => parallel_branches, "End" => true }
+                }
+              })
+            end
+
+            def choice_definition(choices, default_state)
+              choice_rules = choices.map do |condition, next_state|
+                { "Variable" => condition[:variable], condition[:operator] => condition[:value], "Next" => next_state }
+              end
+              ::JSON.pretty_generate({
+                "Comment" => "Choice state machine",
+                "StartAt" => "Choice",
+                "States" => { "Choice" => { "Type" => "Choice", "Choices" => choice_rules, "Default" => default_state } }
+              })
+            end
+
+            def cloudwatch_logging(log_group_arn, level = "ERROR", include_execution_data = false)
+              {
+                level: level,
+                include_execution_data: include_execution_data,
+                destinations: [{ cloud_watch_logs_log_group: { log_group_arn: log_group_arn } }]
+              }
+            end
+
+            def enable_xray_tracing = { enabled: true }
+            def disable_tracing = { enabled: false }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_sfn_state_machine/types/validators.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+# Copyright 2025 The Pangea Authors. Licensed under Apache 2.0.
+
+require 'json'
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        module SfnValidators
+          extend self
+
+          def validate_type(attrs)
+            return unless attrs[:type] && !%w[STANDARD EXPRESS].include?(attrs[:type])
+            raise Dry::Struct::Error, "State machine type must be 'STANDARD' or 'EXPRESS'"
+          end
+
+          def validate_definition(attrs)
+            return unless attrs[:definition]
+            parsed = ::JSON.parse(attrs[:definition])
+            validate_asl_definition(parsed)
+          rescue ::JSON::ParserError => e
+            raise Dry::Struct::Error, "Definition must be valid JSON: #{e.message}"
+          end
+
+          def validate_logging(attrs)
+            return unless attrs[:logging_configuration]
+            validate_logging_configuration(attrs[:logging_configuration])
+          end
+
+          def validate_tracing(attrs)
+            return unless attrs[:tracing_configuration]
+            validate_tracing_configuration(attrs[:tracing_configuration])
+          end
+
+          def validate_asl_definition(definition)
+            raise "Definition must be a JSON object" unless definition.is_a?(::Hash)
+            raise "Definition must include 'StartAt' field" unless definition["StartAt"]
+            raise "Definition must include 'States' field" unless definition["States"]
+            raise "'States' must be an object" unless definition["States"].is_a?(::Hash)
+            raise "'StartAt' must reference an existing state" unless definition["States"][definition["StartAt"]]
+            definition["States"].each { |name, state| validate_state_definition(name, state) }
+          end
+
+          def validate_state_definition(state_name, state_def)
+            raise "State '#{state_name}' must be an object" unless state_def.is_a?(::Hash)
+            raise "State '#{state_name}' must have a 'Type' field" unless state_def["Type"]
+            valid_types = %w[Task Pass Fail Succeed Choice Wait Parallel Map]
+            type = state_def["Type"]
+            raise "Invalid type '#{type}' for '#{state_name}'" unless valid_types.include?(type)
+            validate_state_type_requirements(state_name, type, state_def)
+          end
+
+          def validate_state_type_requirements(state_name, type, state_def)
+            case type
+            when "Task"
+              raise "Task '#{state_name}' must have 'Resource'" unless state_def["Resource"]
+            when "Choice"
+              raise "Choice '#{state_name}' must have 'Choices' array" unless state_def["Choices"]&.is_a?(Array)
+            when "Wait"
+              wait_fields = %w[Seconds SecondsPath Timestamp TimestampPath]
+              raise "Wait '#{state_name}' must have timing field" unless wait_fields.any? { |f| state_def[f] }
+            when "Parallel"
+              raise "Parallel '#{state_name}' must have 'Branches' array" unless state_def["Branches"]&.is_a?(Array)
+            end
+          end
+
+          def validate_logging_configuration(config)
+            raise "Logging configuration must be a hash" unless config.is_a?(::Hash)
+            if config[:level] && !%w[ALL ERROR FATAL OFF].include?(config[:level])
+              raise "Logging level must be one of: ALL, ERROR, FATAL, OFF"
+            end
+            if config[:destinations] && !config[:destinations].is_a?(Array)
+              raise "Logging destinations must be an array"
+            end
+          end
+
+          def validate_tracing_configuration(config)
+            raise "Tracing configuration must be a hash" unless config.is_a?(::Hash)
+          end
+        end
+      end
+    end
+  end
+end