pangea-aws 0.1.0

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

@@ -0,0 +1,93 @@
+# 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_rds_cluster_parameter_group/types'
+require 'pangea/resource_registry'
+
+module Pangea
+  module Resources
+    module AWS
+      # Create an AWS RDS Cluster Parameter Group with type-safe attributes
+      #
+      # @param name [Symbol] The resource name
+      # @param attributes [Hash] RDS cluster parameter group attributes
+      # @return [ResourceReference] Reference object with outputs and computed properties
+      def aws_rds_cluster_parameter_group(name, attributes = {})
+        # Validate attributes using dry-struct
+        pg_attrs = Types::RdsClusterParameterGroupAttributes.new(attributes)
+        
+        # Generate terraform resource block via terraform-synthesizer
+        resource(:aws_rds_cluster_parameter_group, name) do
+          name pg_attrs.name if pg_attrs.name
+          name_prefix pg_attrs.name_prefix if pg_attrs.name_prefix
+          family pg_attrs.family
+          description pg_attrs.description
+          
+          # Parameters configuration
+          if pg_attrs.parameter&.any?
+            pg_attrs.parameter.each do |param|
+              parameter do
+                name param.name
+                value param.terraform_value
+                apply_method param.apply_method if param.apply_method != "pending-reboot"
+              end
+            end
+          end
+          
+          # Apply tags if present
+          if pg_attrs.tags&.any?
+            tags do
+              pg_attrs.tags.each do |key, value|
+                public_send(key, value)
+              end
+            end
+          end
+        end
+        
+        # Return resource reference with available outputs
+        ResourceReference.new(
+          type: 'aws_rds_cluster_parameter_group',
+          name: name,
+          resource_attributes: pg_attrs.to_h,
+          outputs: {
+            id: "${aws_rds_cluster_parameter_group.#{name}.id}",
+            arn: "${aws_rds_cluster_parameter_group.#{name}.arn}",
+            name: "${aws_rds_cluster_parameter_group.#{name}.name}",
+            family: "${aws_rds_cluster_parameter_group.#{name}.family}",
+            description: "${aws_rds_cluster_parameter_group.#{name}.description}",
+            tags: "${aws_rds_cluster_parameter_group.#{name}.tags}",
+            tags_all: "${aws_rds_cluster_parameter_group.#{name}.tags_all}"
+          },
+          computed_properties: {
+            engine_type: pg_attrs.engine_type,
+            engine_version: pg_attrs.engine_version,
+            is_mysql_family: pg_attrs.is_mysql_family?,
+            is_postgresql_family: pg_attrs.is_postgresql_family?,
+            parameter_count: pg_attrs.parameter.count,
+            parameter_names: pg_attrs.parameter_names,
+            has_immediate_parameters: pg_attrs.has_immediate_parameters?,
+            has_reboot_parameters: pg_attrs.has_reboot_parameters?,
+            immediate_parameter_count: pg_attrs.immediate_parameters.count,
+            reboot_parameter_count: pg_attrs.reboot_parameters.count,
+            configuration_summary: pg_attrs.configuration_summary
+          }
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+# Copyright 2025 The Pangea Authors. Licensed under Apache 2.0.
+
+require 'set'
+require 'pangea/resources/types'
+require_relative 'parameter'
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        # Type-safe attributes for AWS RDS Cluster Parameter Group resources
+        class RdsClusterParameterGroupAttributes < Pangea::Resources::BaseAttributes
+          AURORA_MYSQL_PARAMETERS = Set.new(%w[
+            innodb_buffer_pool_size max_connections slow_query_log long_query_time innodb_lock_wait_timeout
+            interactive_timeout wait_timeout max_allowed_packet innodb_flush_log_at_trx_commit innodb_file_per_table
+            general_log binlog_format innodb_autoinc_lock_mode character_set_server collation_server time_zone
+            sql_mode innodb_log_buffer_size read_buffer_size sort_buffer_size join_buffer_size tmp_table_size
+            max_heap_table_size thread_cache_size table_open_cache innodb_thread_concurrency innodb_read_io_threads
+            innodb_write_io_threads
+          ]).freeze
+
+          AURORA_POSTGRESQL_PARAMETERS = Set.new(%w[
+            shared_buffers max_connections work_mem maintenance_work_mem effective_cache_size random_page_cost
+            seq_page_cost log_statement log_min_duration_statement log_connections log_disconnections log_lock_waits
+            log_temp_files checkpoint_timeout checkpoint_completion_target wal_buffers default_statistics_target
+            effective_io_concurrency max_wal_size min_wal_size autovacuum autovacuum_max_workers autovacuum_naptime
+            autovacuum_vacuum_threshold autovacuum_analyze_threshold timezone log_timezone datestyle lc_messages
+            lc_monetary lc_numeric lc_time statement_timeout idle_in_transaction_session_timeout
+          ]).freeze
+
+          attribute? :name, Resources::Types::String.optional
+          attribute? :name_prefix, Resources::Types::String.optional
+          attribute? :family, Resources::Types::String.constrained(included_in: ['aurora-mysql5.7', 'aurora-mysql8.0',
+            'aurora-postgresql10', 'aurora-postgresql11', 'aurora-postgresql12',
+            'aurora-postgresql13', 'aurora-postgresql14', 'aurora-postgresql15'])
+          attribute? :description, Resources::Types::String.optional
+          attribute :parameter, Resources::Types::Array.of(DbParameter).default([].freeze)
+          attribute :tags, Resources::Types::AwsTags.default({}.freeze)
+
+          def self.new(attributes = {})
+            attrs = super(attributes)
+            raise Dry::Struct::Error, "Cannot specify both 'name' and 'name_prefix'" if attrs.name && attrs.name_prefix
+
+            parameter_names = attrs.parameter.map(&:name)
+            duplicates = parameter_names.select { |n| parameter_names.count(n) > 1 }.uniq
+            raise Dry::Struct::Error, "Duplicate parameter names found: #{duplicates.join(', ')}" if duplicates.any?
+
+            invalid_params = validate_parameters_for_family(attrs.family, attrs.parameter)
+            raise Dry::Struct::Error, "Invalid parameters for family '#{attrs.family}': #{invalid_params.join(', ')}" if invalid_params.any?
+
+            attrs
+          end
+
+          def self.validate_parameters_for_family(family, parameters)
+            parameters.each_with_object([]) do |param, invalid|
+              valid_params = family.start_with?('aurora-mysql') ? AURORA_MYSQL_PARAMETERS : AURORA_POSTGRESQL_PARAMETERS
+              invalid << param.name unless valid_params.include?(param.name)
+            end
+          end
+
+          def engine_type
+            return 'mysql' if family.start_with?('aurora-mysql')
+            return 'postgresql' if family.start_with?('aurora-postgresql')
+
+            'unknown'
+          end
+
+          def engine_version
+            case family
+            when 'aurora-mysql5.7' then '5.7'
+            when 'aurora-mysql8.0' then '8.0'
+            when /^aurora-postgresql(\d+)/ then ::Regexp.last_match(1)
+            else 'unknown'
+            end
+          end
+
+          def is_mysql_family? = family.start_with?('aurora-mysql')
+          def is_postgresql_family? = family.start_with?('aurora-postgresql')
+          def immediate_parameters = parameter.select(&:requires_immediate_application?)
+          def reboot_parameters = parameter.select(&:requires_reboot?)
+          def has_immediate_parameters? = immediate_parameters.any?
+          def has_reboot_parameters? = reboot_parameters.any?
+          def get_parameter(name) = parameter.find { |p| p.name == name }
+          def has_parameter?(name) = !get_parameter(name).nil?
+          def parameter_names = parameter.map(&:name)
+
+          def configuration_summary
+            summary = ["Engine: #{engine_type}", "Version: #{engine_version}", "Parameters: #{parameter.count}"]
+            summary << "Immediate changes: #{immediate_parameters.count}" if has_immediate_parameters?
+            summary << "Reboot required: #{reboot_parameters.count}" if has_reboot_parameters?
+            summary.join('; ')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_rds_cluster_parameter_group/types/configs.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+# Copyright 2025 The Pangea Authors. Licensed under Apache 2.0.
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        # Common RDS Cluster Parameter Group configurations
+        module RdsClusterParameterGroupConfigs
+          def self.aurora_mysql_performance(family: 'aurora-mysql8.0')
+            {
+              family: family,
+              description: 'Aurora MySQL performance optimized parameter group',
+              parameter: [
+                { name: 'innodb_buffer_pool_size', value: '{DBInstanceClassMemory*3/4}', apply_method: 'pending-reboot' },
+                { name: 'max_connections', value: 1000, apply_method: 'immediate' },
+                { name: 'slow_query_log', value: 1, apply_method: 'immediate' },
+                { name: 'long_query_time', value: 0.5, apply_method: 'immediate' },
+                { name: 'innodb_lock_wait_timeout', value: 120, apply_method: 'immediate' },
+                { name: 'wait_timeout', value: 28_800, apply_method: 'immediate' },
+                { name: 'interactive_timeout', value: 28_800, apply_method: 'immediate' }
+              ],
+              tags: { Purpose: 'performance', Engine: 'aurora-mysql' }
+            }
+          end
+
+          def self.aurora_postgresql_performance(family: 'aurora-postgresql14')
+            {
+              family: family,
+              description: 'Aurora PostgreSQL performance optimized parameter group',
+              parameter: [
+                { name: 'shared_buffers', value: '{DBInstanceClassMemory/4}', apply_method: 'pending-reboot' },
+                { name: 'max_connections', value: 1000, apply_method: 'pending-reboot' },
+                { name: 'work_mem', value: '64MB', apply_method: 'immediate' },
+                { name: 'maintenance_work_mem', value: '2GB', apply_method: 'immediate' },
+                { name: 'effective_cache_size', value: '{DBInstanceClassMemory*3/4}', apply_method: 'immediate' },
+                { name: 'random_page_cost', value: 1.1, apply_method: 'immediate' },
+                { name: 'checkpoint_completion_target', value: 0.9, apply_method: 'immediate' }
+              ],
+              tags: { Purpose: 'performance', Engine: 'aurora-postgresql' }
+            }
+          end
+
+          def self.development_logging(family:, engine_type:)
+            parameters = if engine_type == 'mysql'
+                           [
+                             { name: 'slow_query_log', value: 1, apply_method: 'immediate' },
+                             { name: 'long_query_time', value: 0.1, apply_method: 'immediate' },
+                             { name: 'general_log', value: 1, apply_method: 'immediate' }
+                           ]
+                         else
+                           [
+                             { name: 'log_statement', value: 'all', apply_method: 'immediate' },
+                             { name: 'log_min_duration_statement', value: 100, apply_method: 'immediate' },
+                             { name: 'log_connections', value: 1, apply_method: 'immediate' },
+                             { name: 'log_disconnections', value: 1, apply_method: 'immediate' }
+                           ]
+                         end
+
+            { family: family, description: 'Development parameter group with extensive logging', parameter: parameters, tags: { Environment: 'development', Purpose: 'debugging' } }
+          end
+
+          def self.security_hardened(family:, engine_type:)
+            parameters = if engine_type == 'mysql'
+                           [
+                             { name: 'sql_mode', value: 'STRICT_TRANS_TABLES,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION', apply_method: 'immediate' },
+                             { name: 'innodb_lock_wait_timeout', value: 50, apply_method: 'immediate' }
+                           ]
+                         else
+                           [
+                             { name: 'statement_timeout', value: 300_000, apply_method: 'immediate' },
+                             { name: 'idle_in_transaction_session_timeout', value: 600_000, apply_method: 'immediate' }
+                           ]
+                         end
+
+            { family: family, description: 'Security hardened parameter group', parameter: parameters, tags: { Purpose: 'security', Compliance: 'hardened' } }
+          end
+
+          def self.high_connections(family:, engine_type:)
+            parameters = if engine_type == 'mysql'
+                           [
+                             { name: 'max_connections', value: 5000, apply_method: 'immediate' },
+                             { name: 'thread_cache_size', value: 256, apply_method: 'immediate' },
+                             { name: 'table_open_cache', value: 4000, apply_method: 'immediate' },
+                             { name: 'innodb_thread_concurrency', value: 0, apply_method: 'immediate' }
+                           ]
+                         else
+                           [
+                             { name: 'max_connections', value: 5000, apply_method: 'pending-reboot' },
+                             { name: 'shared_buffers', value: '{DBInstanceClassMemory/3}', apply_method: 'pending-reboot' },
+                             { name: 'work_mem', value: '32MB', apply_method: 'immediate' }
+                           ]
+                         end
+
+            { family: family, description: 'High connection count optimization', parameter: parameters, tags: { Purpose: 'high-connections', Workload: 'connection-heavy' } }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_rds_cluster_parameter_group/types/parameter.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# Copyright 2025 The Pangea Authors. Licensed under Apache 2.0.
+
+require 'pangea/resources/types'
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        # Database parameter configuration — skip if already defined by aws_db_parameter_group
+        unless const_defined?(:DbParameter)
+          unless const_defined?(:DbParameter)
+          class DbParameter < Pangea::Resources::BaseAttributes
+            attribute? :name, Resources::Types::String.optional
+            attribute? :value, Resources::Types::String | Resources::Types::Integer | Resources::Types::Float | Resources::Types::Bool.optional
+            attribute :apply_method, Resources::Types::String.constrained(included_in: ['immediate', 'pending-reboot']).default('pending-reboot')
+
+            def self.new(attributes = {})
+              attrs = super(attributes)
+
+              if attrs.value.is_a?(TrueClass) || attrs.value.is_a?(FalseClass)
+                attrs = attrs.copy(value: attrs.value ? '1' : '0')
+              elsif attrs.value.is_a?(Numeric)
+                attrs = attrs.copy(value: attrs.value.to_s)
+              end
+
+              attrs
+            end
+
+            def terraform_value = value.to_s
+            def requires_immediate_application? = apply_method == 'immediate'
+            def requires_reboot? = apply_method == 'pending-reboot'
+          end
+        end
+      end
+    end
+  end
+end
+          end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Copyright 2025 The Pangea Authors. Licensed under Apache 2.0.
+
+require 'pangea/resources/types'
+require_relative 'types/parameter'
+require_relative 'types/attributes'
+require_relative 'types/configs'
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        # DbParameter is defined in types/parameter.rb
+        # RdsClusterParameterGroupAttributes is defined in types/attributes.rb
+        # RdsClusterParameterGroupConfigs is defined in types/configs.rb
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_rds_cluster_parameter_group/types.rbs

@@ -0,0 +1,65 @@
+module Pangea
+  module Resources
+    module AWS
+      class DbParameter < Dry::Struct
+        attribute :name, Types::String
+        attribute :value, Types::String | Types::Integer | Types::Float | Types::Bool
+        attribute :apply_method, Types::String
+
+        def self.new: (Hash[Symbol, untyped] attributes) -> DbParameter
+
+        def name: () -> String
+        def value: () -> (String | Integer | Float | bool)
+        def apply_method: () -> String
+        def terraform_value: () -> String
+        def requires_immediate_application?: () -> bool
+        def requires_reboot?: () -> bool
+      end
+
+      class RdsClusterParameterGroupAttributes < Dry::Struct
+        attribute :name, Types::String?
+        attribute :name_prefix, Types::String?  
+        attribute :family, Types::String
+        attribute :description, Types::String
+        attribute :parameter, Types::Array[DbParameter]
+        attribute :tags, Types::AwsTags
+
+        def self.new: (Hash[Symbol, untyped] attributes) -> RdsClusterParameterGroupAttributes
+        def self.validate_parameters_for_family: (String family, Array[DbParameter] parameters) -> Array[String]
+
+        def name: () -> String?
+        def name_prefix: () -> String?
+        def family: () -> String
+        def description: () -> String
+        def parameter: () -> Array[DbParameter]
+        def tags: () -> Hash[Symbol, String]
+
+        def engine_type: () -> String
+        def engine_version: () -> String
+        def is_mysql_family?: () -> bool
+        def is_postgresql_family?: () -> bool
+        def immediate_parameters: () -> Array[DbParameter]
+        def reboot_parameters: () -> Array[DbParameter]
+        def has_immediate_parameters?: () -> bool
+        def has_reboot_parameters?: () -> bool
+        def get_parameter: (String name) -> DbParameter?
+        def has_parameter?: (String name) -> bool
+        def parameter_names: () -> Array[String]
+        def configuration_summary: () -> String
+
+        AURORA_MYSQL_PARAMETERS: Set[String]
+        AURORA_POSTGRESQL_PARAMETERS: Set[String]
+      end
+
+      module RdsClusterParameterGroupConfigs
+        def self.aurora_mysql_performance: (?family: String) -> Hash[Symbol, untyped]
+        def self.aurora_postgresql_performance: (?family: String) -> Hash[Symbol, untyped]
+        def self.development_logging: (family: String, engine_type: String) -> Hash[Symbol, untyped]
+        def self.security_hardened: (family: String, engine_type: String) -> Hash[Symbol, untyped]
+        def self.high_connections: (family: String, engine_type: String) -> Hash[Symbol, untyped]
+      end
+
+      def aws_rds_cluster_parameter_group: (Symbol name, Hash[Symbol, untyped] attributes) -> ResourceReference
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+# 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_rds_global_cluster/types'
+require 'pangea/resource_registry'
+
+module Pangea
+  module Resources
+    module AWS
+      # Create an AWS RDS Global Cluster with type-safe attributes
+      #
+      # @param name [Symbol] The resource name
+      # @param attributes [Hash] RDS global cluster attributes
+      # @return [ResourceReference] Reference object with outputs and computed properties
+      def aws_rds_global_cluster(name, attributes = {})
+        # Validate attributes using dry-struct
+        global_attrs = Types::RdsGlobalClusterAttributes.new(attributes)
+        
+        # Generate terraform resource block via terraform-synthesizer
+        resource(:aws_rds_global_cluster, name) do
+          global_cluster_identifier global_attrs.global_cluster_identifier if global_attrs.global_cluster_identifier
+          engine global_attrs.engine
+          engine_version global_attrs.engine_version if global_attrs.engine_version
+          engine_lifecycle_support global_attrs.engine_lifecycle_support if global_attrs.engine_lifecycle_support
+          
+          # Database configuration (only for new global clusters)
+          unless global_attrs.source_db_cluster_identifier
+            database_name global_attrs.database_name if global_attrs.database_name
+            master_username global_attrs.master_username if global_attrs.master_username
+            master_password global_attrs.master_password if global_attrs.master_password
+            manage_master_user_password global_attrs.manage_master_user_password if global_attrs.manage_master_user_password
+            master_user_secret_kms_key_id global_attrs.master_user_secret_kms_key_id if global_attrs.master_user_secret_kms_key_id
+          end
+          
+          # Source cluster (for migration from existing cluster)
+          source_db_cluster_identifier global_attrs.source_db_cluster_identifier if global_attrs.source_db_cluster_identifier
+          
+          # Storage configuration
+          storage_encrypted global_attrs.storage_encrypted
+          kms_key_id global_attrs.kms_key_id if global_attrs.kms_key_id
+          
+          # Backup configuration
+          if global_attrs.backup_configuration
+            backup_configuration do
+              backup_retention_period global_attrs.backup_configuration.backup_retention_period
+              preferred_backup_window global_attrs.backup_configuration.preferred_backup_window if global_attrs.backup_configuration.preferred_backup_window
+              copy_tags_to_snapshot global_attrs.backup_configuration.copy_tags_to_snapshot
+            end
+          end
+          
+          # Force destroy configuration
+          force_destroy global_attrs.force_destroy if global_attrs.force_destroy
+          
+          # Apply tags if present
+          if global_attrs.tags&.any?
+            tags do
+              global_attrs.tags.each do |key, value|
+                public_send(key, value)
+              end
+            end
+          end
+        end
+        
+        # Return resource reference with available outputs
+        ResourceReference.new(
+          type: 'aws_rds_global_cluster',
+          name: name,
+          resource_attributes: global_attrs.to_h,
+          outputs: {
+            id: "${aws_rds_global_cluster.#{name}.id}",
+            arn: "${aws_rds_global_cluster.#{name}.arn}",
+            global_cluster_identifier: "${aws_rds_global_cluster.#{name}.global_cluster_identifier}",
+            global_cluster_resource_id: "${aws_rds_global_cluster.#{name}.global_cluster_resource_id}",
+            engine: "${aws_rds_global_cluster.#{name}.engine}",
+            engine_version_actual: "${aws_rds_global_cluster.#{name}.engine_version_actual}",
+            database_name: "${aws_rds_global_cluster.#{name}.database_name}",
+            master_username: "${aws_rds_global_cluster.#{name}.master_username}",
+            master_user_secret: "${aws_rds_global_cluster.#{name}.master_user_secret}",
+            storage_encrypted: "${aws_rds_global_cluster.#{name}.storage_encrypted}",
+            kms_key_id: "${aws_rds_global_cluster.#{name}.kms_key_id}",
+            global_cluster_members: "${aws_rds_global_cluster.#{name}.global_cluster_members}",
+            tags: "${aws_rds_global_cluster.#{name}.tags}",
+            tags_all: "${aws_rds_global_cluster.#{name}.tags_all}"
+          },
+          computed_properties: {
+            engine_family: global_attrs.engine_family,
+            engine_major_version: global_attrs.engine_major_version,
+            is_mysql: global_attrs.is_mysql?,
+            is_postgresql: global_attrs.is_postgresql?,
+            uses_managed_password: global_attrs.uses_managed_password?,
+            created_from_source: global_attrs.created_from_source?,
+            is_encrypted: global_attrs.is_encrypted?,
+            allows_force_destroy: global_attrs.allows_force_destroy?,
+            has_backup_configuration: global_attrs.has_backup_configuration?,
+            effective_backup_retention_period: global_attrs.effective_backup_retention_period,
+            effective_backup_window: global_attrs.effective_backup_window,
+            supported_regions: global_attrs.supported_regions,
+            configuration_summary: global_attrs.configuration_summary,
+            estimated_monthly_cost: global_attrs.estimated_monthly_cost
+          }
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# Copyright 2025 The Pangea Authors. Licensed under Apache 2.0.
+
+require_relative 'backup_config'
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        class RdsGlobalClusterAttributes < Pangea::Resources::BaseAttributes
+          attribute? :global_cluster_identifier, Resources::Types::String.optional
+          attribute? :engine, Resources::Types::String.constrained(included_in: ['aurora', 'aurora-mysql', 'aurora-postgresql']).optional
+          attribute? :engine_version, Resources::Types::String.optional
+          attribute? :database_name, Resources::Types::String.optional
+          attribute? :master_username, Resources::Types::String.optional
+          attribute? :master_password, Resources::Types::String.optional
+          attribute :manage_master_user_password, Resources::Types::Bool.default(true)
+          attribute? :master_user_secret_kms_key_id, Resources::Types::String.optional
+          attribute :storage_encrypted, Resources::Types::Bool.default(true)
+          attribute? :kms_key_id, Resources::Types::String.optional
+          attribute :force_destroy, Resources::Types::Bool.default(false)
+          attribute? :source_db_cluster_identifier, Resources::Types::String.optional
+          attribute? :engine_lifecycle_support, Resources::Types::String.constrained(included_in: ['open-source-rds-extended-support', 'open-source-rds-extended-support-disabled']).optional
+          attribute? :backup_configuration, GlobalClusterBackupConfiguration.optional
+          attribute :tags, Resources::Types::AwsTags.default({}.freeze)
+
+          def self.new(attributes = {})
+            attrs = super(attributes)
+            raise Dry::Struct::Error, "Cannot specify both 'master_password' and 'manage_master_user_password'" if attrs.master_password && attrs.manage_master_user_password
+            if attrs.source_db_cluster_identifier
+              raise Dry::Struct::Error, 'database_name, master_username, and master_password are inherited from source cluster' if attrs.database_name || attrs.master_username || attrs.master_password
+            else
+              raise Dry::Struct::Error, 'master_username is required when not using source_db_cluster_identifier' unless attrs.master_username
+            end
+            raise Dry::Struct::Error, "Invalid engine version '#{attrs.engine_version}' for engine '#{attrs.engine}'" if attrs.engine_version && !valid_engine_version?(attrs.engine, attrs.engine_version)
+            attrs
+          end
+
+          def self.valid_engine_version?(engine, version)
+            case engine
+            when 'aurora', 'aurora-mysql' then version.match?(/^(5\.7|8\.0)\.mysql_aurora\.\d+\.\d+\.\d+$/)
+            when 'aurora-postgresql' then version.match?(/^\d{1,2}\.\d+$/)
+            else false
+            end
+          end
+
+          def engine_family = engine.include?('postgresql') ? 'postgresql' : 'mysql'
+          def is_mysql? = engine.include?('mysql') || engine == 'aurora'
+          def is_postgresql? = engine.include?('postgresql')
+          def uses_managed_password? = manage_master_user_password
+          def created_from_source? = !source_db_cluster_identifier.nil?
+          def is_encrypted? = storage_encrypted
+          def allows_force_destroy? = force_destroy
+          def has_backup_configuration? = !backup_configuration.nil?
+          def effective_backup_retention_period = backup_configuration&.backup_retention_period || 7
+          def effective_backup_window = backup_configuration&.preferred_backup_window || '03:00-04:00'
+
+          def engine_major_version
+            case engine
+            when 'aurora', 'aurora-mysql' then engine_version&.match(/^(\d+\.\d+)/)&.[](1) || '8.0'
+            when 'aurora-postgresql' then engine_version&.match(/^(\d{1,2})/)&.[](1) || '14'
+            else 'unknown'
+            end
+          end
+
+          SUPPORTED_REGIONS = %w[us-east-1 us-east-2 us-west-1 us-west-2 ca-central-1 eu-west-1 eu-west-2 eu-west-3 eu-central-1 eu-north-1 ap-northeast-1 ap-northeast-2 ap-southeast-1 ap-southeast-2 ap-south-1 sa-east-1].freeze
+          def supported_regions = SUPPORTED_REGIONS
+          def supports_region?(region) = SUPPORTED_REGIONS.include?(region)
+
+          def estimated_monthly_cost
+            base_cost = engine_family == 'postgresql' ? '~$120-600/month per region' : '~$100-500/month per region'
+            "#{base_cost} + cross-region data transfer costs"
+          end
+
+          def configuration_summary
+            summary = ["Engine: #{engine_family}", 'Regions: Global (multi-region)', "Encryption: #{is_encrypted? ? 'enabled' : 'disabled'}"]
+            summary << "Source: #{source_db_cluster_identifier}" if created_from_source?
+            summary << "Backup: #{effective_backup_retention_period} days" if has_backup_configuration?
+            summary.join('; ')
+          end
+
+          def recommended_secondary_regions(primary_region)
+            { 'us-east-1' => %w[us-west-2 eu-west-1], 'us-west-2' => %w[us-east-1 eu-west-1], 'eu-west-1' => %w[us-east-1 ap-northeast-1], 'ap-northeast-1' => %w[us-west-2 eu-west-1] }[primary_region] || %w[us-east-1 us-west-2 eu-west-1].reject { |r| r == primary_region }
+          end
+        end
+      end
+    end
+  end
+end