pangea-aws 0.1.0

data/lib/pangea/resources/aws_dynamodb_global_table/types/instance_methods.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+# Copyright 2025 The Pangea Authors. Licensed under Apache 2.0.
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        # Instance methods for DynamoDbGlobalTableAttributes
+        module DynamoDbGlobalTableInstanceMethods
+          def is_pay_per_request?
+            billing_mode == "PAY_PER_REQUEST"
+          end
+
+          def is_provisioned?
+            billing_mode == "PROVISIONED"
+          end
+
+          def has_stream?
+            stream_enabled == true
+          end
+
+          def has_encryption?
+            !server_side_encryption.nil?
+          end
+
+          def has_pitr?
+            point_in_time_recovery && point_in_time_recovery[:enabled]
+          end
+
+          def region_count
+            replica.size
+          end
+
+          def regions
+            replica.map { |r| r[:region_name] }
+          end
+
+          def has_gsi?
+            replica.any? { |r| r[:global_secondary_index] && r[:global_secondary_index].any? }
+          end
+
+          def total_gsi_count
+            replica.sum { |r| (r[:global_secondary_index] || []).size }
+          end
+
+          def estimated_monthly_cost
+            cost_multiplier = region_count
+            base_cost = is_pay_per_request? ? "Variable per region" : "~$50"
+
+            "#{base_cost} x #{cost_multiplier} regions (#{total_gsi_count} total GSIs)"
+          end
+
+          def multi_region_strategy
+            case region_count
+            when 2
+              "Active-Active (2 regions)"
+            when 3
+              "Multi-region Active (3 regions)"
+            else
+              "Global Active-Active (#{region_count} regions)"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+# Copyright 2025 The Pangea Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'pangea/resources/types'
+require_relative 'types/instance_methods'
+require_relative 'types/configs'
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        # Type-safe attributes for AWS DynamoDB Global Table resources
+        class DynamoDbGlobalTableAttributes < Pangea::Resources::BaseAttributes
+          include DynamoDbGlobalTableInstanceMethods
+
+          # Global table name (required)
+          attribute? :name, Resources::Types::String.optional
+
+          # Billing mode
+          attribute :billing_mode, Resources::Types::String.constrained(included_in: ["PAY_PER_REQUEST", "PROVISIONED"]).default("PAY_PER_REQUEST")
+
+          # Replica configurations (required, must have at least 2 regions)
+          attribute? :replica, Resources::Types::Array.of(
+            Resources::Types::Hash.schema(
+              region_name: Resources::Types::String,
+              kms_key_id?: Resources::Types::String.optional,
+              point_in_time_recovery?: Resources::Types::Bool.optional,
+              table_class?: Resources::Types::String.constrained(included_in: ["STANDARD", "STANDARD_INFREQUENT_ACCESS"]).optional,
+              global_secondary_index?: Resources::Types::Array.of(
+                Resources::Types::Hash.schema(
+                  name: Resources::Types::String,
+                  read_capacity?: Resources::Types::Integer.optional.constrained(gteq: 1),
+                  write_capacity?: Resources::Types::Integer.optional.constrained(gteq: 1)
+                ).lax
+              ).optional,
+              tags?: Resources::Types::AwsTags.optional
+            )
+          ).constrained(min_size: 2)
+
+          # Stream specification
+          attribute? :stream_enabled, Resources::Types::Bool.optional
+          attribute? :stream_view_type, Resources::Types::String.constrained(included_in: ["KEYS_ONLY", "NEW_IMAGE", "OLD_IMAGE", "NEW_AND_OLD_IMAGES"]).optional
+
+          # Server-side encryption
+          attribute? :server_side_encryption, Resources::Types::Hash.schema(
+            enabled: Resources::Types::Bool.default(true),
+            kms_key_id?: Resources::Types::String.optional
+          ).lax.optional
+
+          # Time-based recovery
+          attribute? :point_in_time_recovery, Resources::Types::Hash.schema(
+            enabled: Resources::Types::Bool.default(false)
+          ).lax.optional
+
+          # Tags to apply to the global table
+          attribute :tags, Resources::Types::AwsTags.default({}.freeze)
+
+          # Custom validation
+          def self.new(attributes = {})
+            attrs = super(attributes)
+
+            # Validate minimum regions
+            if attrs.replica.size < 2
+              raise Dry::Struct::Error, "Global table requires at least 2 regions"
+            end
+
+            # Validate unique regions
+            regions = attrs.replica.map { |r| r[:region_name] }
+            if regions.uniq.size != regions.size
+              raise Dry::Struct::Error, "Global table cannot have duplicate regions"
+            end
+
+            # Validate stream configuration
+            if attrs.stream_enabled && !attrs.stream_view_type
+              raise Dry::Struct::Error, "stream_view_type is required when stream_enabled is true"
+            end
+
+            if attrs.stream_view_type && !attrs.stream_enabled
+              attrs = attrs.copy_with(stream_enabled: true)
+            end
+
+            # Validate billing mode consistency with replica GSI capacity
+            if attrs.billing_mode == "PROVISIONED"
+              attrs.replica.each do |replica|
+                next unless replica&.dig(:global_secondary_index)
+
+                replica&.dig(:global_secondary_index).each do |gsi|
+                  unless gsi[:read_capacity] && gsi[:write_capacity]
+                    raise Dry::Struct::Error, "GSI '#{gsi[:name]}' in region '#{replica&.dig(:region_name)}' requires capacity settings for PROVISIONED billing mode"
+                  end
+                end
+              end
+            elsif attrs.billing_mode == "PAY_PER_REQUEST"
+              attrs.replica.each do |replica|
+                next unless replica&.dig(:global_secondary_index)
+
+                replica&.dig(:global_secondary_index).each do |gsi|
+                  if gsi[:read_capacity] || gsi[:write_capacity]
+                    raise Dry::Struct::Error, "GSI '#{gsi[:name]}' in region '#{replica&.dig(:region_name)}' should not have capacity settings for PAY_PER_REQUEST billing mode"
+                  end
+                end
+              end
+            end
+
+            attrs
+          end
+        end
+      end
+
+      # DynamoDbGlobalTableConfigs is defined in types/configs.rb
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# RBS type definitions for AWS DynamoDB Global Table types
+
+module Pangea
+  module Resources
+    module AWS
+      class DynamoDbGlobalTableAttributes < Dry::Struct
+        attr_reader name: String
+        attr_reader billing_mode: String
+        attr_reader replica: Array[Hash[Symbol, untyped]]
+        attr_reader stream_enabled: bool?
+        attr_reader stream_view_type: String?
+        attr_reader server_side_encryption: Hash[Symbol, untyped]?
+        attr_reader point_in_time_recovery: Hash[Symbol, untyped]?
+        attr_reader tags: Hash[Symbol, String]
+        
+        def is_pay_per_request?: () -> bool
+        def is_provisioned?: () -> bool
+        def has_stream?: () -> bool
+        def has_encryption?: () -> bool
+        def has_pitr?: () -> bool
+        def region_count: () -> Integer
+        def regions: () -> Array[String]
+        def has_gsi?: () -> bool
+        def total_gsi_count: () -> Integer
+        def estimated_monthly_cost: () -> String
+        def multi_region_strategy: () -> String
+      end
+
+      module DynamoDbGlobalTableConfigs
+        def self.simple_global_table: (String, ?primary_region: String, ?secondary_region: String) -> Hash[Symbol, untyped]
+        def self.encrypted_global_table: (String, ?regions: Array[String]) -> Hash[Symbol, untyped]
+        def self.streaming_global_table: (String, ?regions: Array[String], ?stream_view_type: String) -> Hash[Symbol, untyped]
+        def self.high_performance_global_table: (String, ?regions: Array[String]) -> Hash[Symbol, untyped]
+        def self.global_table_with_gsi: (String, ?regions: Array[String], ?gsi_name: String) -> Hash[Symbol, untyped]
+        def self.disaster_recovery_global_table: (String, ?primary_region: String, ?dr_regions: Array[String]) -> Hash[Symbol, untyped]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# 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_dynamodb_kinesis_streaming_destination/types'
+require 'pangea/resource_registry'
+
+module Pangea
+  module Resources
+    module AWS
+      # Create an AWS DynamoDB Kinesis Streaming Destination with type-safe attributes
+      #
+      # DynamoDB Kinesis Data Streams for DynamoDB captures data modification events
+      # in a DynamoDB table and replicates them to a Kinesis data stream. This enables
+      # you to consume the stream and perform real-time analytics, feed data to other
+      # AWS services, or replicate data across Regions.
+      #
+      # @param name [Symbol] The resource name
+      # @param attributes [Hash] DynamoDB Kinesis streaming destination attributes
+      # @return [ResourceReference] Reference object with outputs and computed properties
+      def aws_dynamodb_kinesis_streaming_destination(name, attributes = {})
+        # Validate attributes using dry-struct
+        streaming_attrs = DynamoDBKinesisStreamingDestination::Types::DynamoDBKinesisStreamingDestinationAttributes.new(attributes)
+        
+        # Generate terraform resource block via terraform-synthesizer
+        resource(:aws_dynamodb_kinesis_streaming_destination, name) do
+          # Required attributes
+          stream_arn streaming_attrs.stream_arn
+          table_name streaming_attrs.table_name
+        end
+        
+        # Return resource reference with available outputs
+        ResourceReference.new(
+          type: 'aws_dynamodb_kinesis_streaming_destination',
+          name: name,
+          resource_attributes: streaming_attrs.to_h,
+          outputs: {
+            id: "${aws_dynamodb_kinesis_streaming_destination.#{name}.id}",
+            stream_arn: "${aws_dynamodb_kinesis_streaming_destination.#{name}.stream_arn}",
+            table_name: "${aws_dynamodb_kinesis_streaming_destination.#{name}.table_name}"
+          },
+          computed: {
+            stream_name: streaming_attrs.stream_name,
+            stream_region: streaming_attrs.stream_region,
+            stream_account_id: streaming_attrs.stream_account_id,
+            cross_region_streaming: streaming_attrs.cross_region_streaming?,
+            cross_account_streaming: streaming_attrs.cross_account_streaming?
+          }
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# 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'
+
+module Pangea
+  module Resources
+    module AWS
+      module DynamoDBKinesisStreamingDestination
+        # Common types for DynamoDB Kinesis Streaming Destination configurations
+        module Types
+          # Kinesis Stream ARN constraint
+          StreamArn = Resources::Types::String.constrained(
+            format: /\Aarn:aws:kinesis:[a-z0-9\-]*:[0-9]{12}:stream\/[a-zA-Z0-9_.-]+\z/
+          )
+
+          # DynamoDB Table name constraint
+          TableName = Resources::Types::String.constrained(
+            min_size: 3,
+            max_size: 255,
+            format: /\A[a-zA-Z0-9_.-]+\z/
+          )
+
+          # DynamoDB Kinesis Streaming Destination attributes with comprehensive validation
+          class DynamoDBKinesisStreamingDestinationAttributes < Pangea::Resources::BaseAttributes
+            transform_keys(&:to_sym)
+
+            # Required attributes
+            attribute? :stream_arn, StreamArn.optional
+            attribute? :table_name, TableName.optional
+
+            # Computed properties
+            def stream_name
+              stream_arn.split('/')[-1]
+            end
+
+            def stream_region
+              stream_arn.split(':')[3]
+            end
+
+            def stream_account_id
+              stream_arn.split(':')[4]
+            end
+
+            def cross_region_streaming?
+              false
+            end
+
+            def cross_account_streaming?
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_dynamodb_table/builders/config_builder.rb

@@ -0,0 +1,147 @@
+# 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
+    module AWS
+      module DynamoDBTable
+        # Builds DynamoDB table optional configuration blocks
+        module ConfigBuilder
+          module_function
+
+          def build_optional_features(context, attrs)
+            build_ttl(context, attrs)
+            build_stream(context, attrs)
+            build_pitr(context, attrs)
+            build_encryption(context, attrs)
+            build_table_settings(context, attrs)
+          end
+
+          def build_ttl(context, attrs)
+            return unless attrs.ttl
+
+            context.ttl do
+              context.attribute_name attrs.ttl&.dig(:attribute_name)
+              context.enabled attrs.ttl&.dig(:enabled)
+            end
+          end
+
+          def build_stream(context, attrs)
+            return unless attrs.stream_enabled
+
+            context.stream_enabled attrs.stream_enabled
+            context.stream_view_type attrs.stream_view_type
+          end
+
+          def build_pitr(context, attrs)
+            context.point_in_time_recovery do
+              context.enabled attrs.point_in_time_recovery_enabled
+            end
+          end
+
+          def build_encryption(context, attrs)
+            return unless attrs.server_side_encryption
+
+            sse = attrs.server_side_encryption
+            context.server_side_encryption do
+              context.enabled sse[:enabled]
+              context.kms_key_id sse[:kms_key_id] if sse[:kms_key_id]
+            end
+          end
+
+          def build_table_settings(context, attrs)
+            context.deletion_protection_enabled attrs.deletion_protection_enabled
+            context.table_class attrs.table_class
+          end
+
+          def build_restore_config(context, attrs)
+            if attrs.restore_source_name
+              context.restore_source_name attrs.restore_source_name
+            elsif attrs.restore_source_table_arn
+              context.restore_source_table_arn attrs.restore_source_table_arn
+              context.restore_to_time attrs.restore_to_time if attrs.restore_to_time
+              context.restore_date_time attrs.restore_date_time if attrs.restore_date_time
+            end
+          end
+
+          def build_import_config(context, attrs)
+            return unless attrs.import_table
+
+            import = attrs.import_table
+            context.import_table do
+              context.input_format import[:input_format]
+              build_s3_source(context, import[:s3_bucket_source])
+              build_format_options(context, import[:input_format_options])
+              context.input_compression_type import[:input_compression_type] if import[:input_compression_type]
+            end
+          end
+
+          def build_s3_source(context, source)
+            context.s3_bucket_source do
+              context.bucket source[:bucket]
+              context.bucket_owner source[:bucket_owner] if source[:bucket_owner]
+              context.key_prefix source[:key_prefix] if source[:key_prefix]
+            end
+          end
+
+          def build_format_options(context, options)
+            return unless options&.dig(:csv)
+
+            csv_opts = options[:csv]
+            context.input_format_options do
+              context.csv do
+                context.delimiter csv_opts[:delimiter] if csv_opts[:delimiter]
+                context.header_list csv_opts[:header_list] if csv_opts[:header_list]
+              end
+            end
+          end
+
+          def build_replicas(context, attrs)
+            attrs.replica.each do |replica_config|
+              context.replica do
+                context.region_name replica_config[:region_name]
+                context.kms_key_id replica_config[:kms_key_id] if replica_config[:kms_key_id]
+                context.point_in_time_recovery replica_config[:point_in_time_recovery] if replica_config[:point_in_time_recovery]
+                context.table_class replica_config[:table_class] if replica_config[:table_class]
+                build_replica_gsi(context, replica_config[:global_secondary_index])
+              end
+            end
+          end
+
+          def build_replica_gsi(context, gsi_list)
+            return unless gsi_list
+
+            gsi_list.each do |replica_gsi|
+              context.global_secondary_index do
+                context.name replica_gsi[:name]
+                context.read_capacity replica_gsi[:read_capacity] if replica_gsi[:read_capacity]
+                context.write_capacity replica_gsi[:write_capacity] if replica_gsi[:write_capacity]
+              end
+            end
+          end
+
+          def build_tags(context, attrs)
+            return unless attrs.tags.any?
+
+            context.tags do
+              attrs.tags.each { |key, value| context.public_send(key, value) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_dynamodb_table/builders/index_builder.rb

@@ -0,0 +1,62 @@
+# 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
+    module AWS
+      module DynamoDBTable
+        # Builds DynamoDB table index configuration blocks
+        module IndexBuilder
+          module_function
+
+          def build_indexes(context, attrs)
+            build_global_secondary_indexes(context, attrs)
+            build_local_secondary_indexes(context, attrs)
+          end
+
+          def build_global_secondary_indexes(context, attrs)
+            attrs.global_secondary_index.each do |gsi|
+              context.global_secondary_index do
+                context.name gsi[:name]
+                context.hash_key gsi[:hash_key]
+                context.range_key gsi[:range_key] if gsi[:range_key]
+
+                if attrs.is_provisioned?
+                  context.read_capacity gsi[:read_capacity]
+                  context.write_capacity gsi[:write_capacity]
+                end
+
+                context.projection_type gsi[:projection_type]
+                context.non_key_attributes gsi[:non_key_attributes] if gsi[:non_key_attributes]
+              end
+            end
+          end
+
+          def build_local_secondary_indexes(context, attrs)
+            attrs.local_secondary_index.each do |lsi|
+              context.local_secondary_index do
+                context.name lsi[:name]
+                context.range_key lsi[:range_key]
+                context.projection_type lsi[:projection_type]
+                context.non_key_attributes lsi[:non_key_attributes] if lsi[:non_key_attributes]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_dynamodb_table/builders/reference_builder.rb

@@ -0,0 +1,64 @@
+# 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
+    module AWS
+      module DynamoDBTable
+        # Builds resource references for DynamoDB tables
+        module ReferenceBuilder
+          TERRAFORM_OUTPUTS = %i[
+            id arn name billing_mode hash_key range_key
+            read_capacity write_capacity stream_arn stream_label
+            table_class tags_all
+          ].freeze
+
+          COMPUTED_PROPERTIES = %i[
+            is_pay_per_request? is_provisioned? has_range_key? has_gsi?
+            has_lsi? has_stream? has_ttl? has_encryption? has_pitr?
+            is_global_table? total_indexes estimated_monthly_cost
+          ].freeze
+
+          module_function
+
+          def build_reference(name, table_attrs)
+            ref = ResourceReference.new(
+              type: 'aws_dynamodb_table',
+              name: name,
+              resource_attributes: table_attrs.to_h,
+              outputs: build_outputs(name)
+            )
+
+            add_computed_properties(ref, table_attrs)
+            ref
+          end
+
+          def build_outputs(name)
+            TERRAFORM_OUTPUTS.each_with_object({}) do |output, hash|
+              hash[output] = "${aws_dynamodb_table.#{name}.#{output}}"
+            end
+          end
+
+          def add_computed_properties(ref, table_attrs)
+            COMPUTED_PROPERTIES.each do |prop|
+              ref.define_singleton_method(prop) { table_attrs.public_send(prop) }
+            end
+          end
+        end
+      end
+    end
+  end
+end