pangea-aws 0.1.0

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

@@ -0,0 +1,66 @@
+# 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_docdb_subnet_group/types'
+require 'pangea/resource_registry'
+
+module Pangea
+  module Resources
+    module AWS
+      # Provides a DocumentDB subnet group resource.
+      #
+      # @param name [Symbol] The resource name
+      # @param attributes [Hash] Resource attributes
+      # @return [ResourceReference] Reference object with outputs and computed properties
+      def aws_docdb_subnet_group(name, attributes = {})
+        # Validate attributes using dry-struct
+        attrs = Types::DocdbSubnetGroupAttributes.new(attributes)
+        
+        # Generate terraform resource block via terraform-synthesizer
+        resource(:aws_docdb_subnet_group, name) do
+          name attrs.name if attrs.name
+          description attrs.description if attrs.description
+          subnet_ids attrs.subnet_ids if attrs.subnet_ids
+          
+          # Apply tags if present
+          if attrs.tags&.any?
+            tags do
+              attrs.tags.each do |key, value|
+                public_send(key, value)
+              end
+            end
+          end
+        end
+        
+        # Return resource reference with available outputs
+        ResourceReference.new(
+          type: 'aws_docdb_subnet_group',
+          name: name,
+          resource_attributes: attrs.to_h,
+          outputs: {
+            id: "${aws_docdb_subnet_group.#{name}.id}",
+            arn: "${aws_docdb_subnet_group.#{name}.arn}"
+          },
+          computed_properties: {
+            # Computed properties from type definitions
+          }
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# 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'
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+      # Type-safe attributes for AwsDocdbSubnetGroup resources
+      # Provides a DocumentDB subnet group resource.
+      class DocdbSubnetGroupAttributes < Pangea::Resources::BaseAttributes
+        attribute? :name, Resources::Types::String.optional
+        attribute? :description, Resources::Types::String.optional
+        attribute :subnet_ids, Resources::Types::Array.of(Resources::Types::String).default([].freeze)
+        
+        # Tags to apply to the resource
+        attribute :tags, Resources::Types::AwsTags.default({}.freeze)
+
+        # Custom validation
+        def self.new(attributes = {})
+          attrs = super(attributes)
+          
+          
+          
+          
+          attrs
+        end
+        
+        # TODO: Add computed properties specific to aws_docdb_subnet_group
+
+      end
+    end
+      end
+    end
+  end

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

@@ -0,0 +1,180 @@
+# 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'
+
+module Pangea
+  module Resources
+    module AWS
+      # Type-safe resource function for AWS DRS Launch Configuration Template
+      #
+      # @param name [Symbol] The resource name
+      # @param attributes [Hash] Resource attributes following AWS provider schema
+      # @return [Pangea::Resources::Reference] Resource reference for chaining
+      # 
+      # @see https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/drs_launch_configuration_template
+      #
+      # @example Production launch configuration template
+      #   aws_drs_launch_configuration_template(:production_launch, {
+      #     copy_private_ip: false,
+      #     copy_tags: true,
+      #     launch_disposition: "STARTED",
+      #     licensing: {
+      #       os_byol: false
+      #     },
+      #     target_instance_type_right_sizing_method: "BASIC",
+      #     post_launch_enabled: true,
+      #     post_launch_actions: {
+      #       deployment: "TEST_AND_CUTOVER",
+      #       s3_log_bucket: log_bucket.bucket,
+      #       s3_output_key_prefix: "drs-launch-logs/",
+      #       cloud_watch_log_group_name: log_group.name,
+      #       ssm_documents: [
+      #         {
+      #           action_name: "configure-application",
+      #           ssm_document_name: "ConfigureApplication",
+      #           timeout_seconds: 1800,
+      #           must_succeed_for_cutover: true,
+      #           parameters: {
+      #             "EnvironmentType" => "production"
+      #           }
+      #         }
+      #       ]
+      #     },
+      #     tags: {
+      #       "Template" => "production-launch",
+      #       "Purpose" => "disaster-recovery"
+      #     }
+      #   })
+      def aws_drs_launch_configuration_template(name, attributes)
+        transformed = Base.transform_attributes(attributes, {
+          copy_private_ip: {
+            description: "Whether to copy private IP address",
+            type: :boolean,
+            default: false
+          },
+          copy_tags: {
+            description: "Whether to copy tags from source",
+            type: :boolean,
+            default: true
+          },
+          launch_disposition: {
+            description: "Launch disposition (STOPPED or STARTED)",
+            type: :string,
+            default: "STOPPED",
+            enum: ["STOPPED", "STARTED"]
+          },
+          licensing: {
+            description: "Licensing configuration",
+            type: :hash,
+            properties: {
+              os_byol: {
+                description: "Whether to use BYOL licensing",
+                type: :boolean,
+                default: true
+              }
+            }
+          },
+          target_instance_type_right_sizing_method: {
+            description: "Right-sizing method for target instances",
+            type: :string,
+            default: "BASIC",
+            enum: ["BASIC", "IN_AWS"]
+          },
+          post_launch_enabled: {
+            description: "Whether post-launch actions are enabled",
+            type: :boolean,
+            default: false
+          },
+          post_launch_actions: {
+            description: "Configuration for post-launch actions",
+            type: :hash,
+            properties: {
+              deployment: {
+                description: "Deployment type",
+                type: :string,
+                enum: ["TEST_AND_CUTOVER", "CUTOVER_ONLY", "TEST_ONLY"]
+              },
+              s3_log_bucket: {
+                description: "S3 bucket for post-launch action logs",
+                type: :string
+              },
+              s3_output_key_prefix: {
+                description: "S3 key prefix for logs",
+                type: :string
+              },
+              cloud_watch_log_group_name: {
+                description: "CloudWatch log group name",
+                type: :string
+              },
+              ssm_documents: {
+                description: "List of SSM documents to execute",
+                type: :array,
+                items: {
+                  type: :hash,
+                  properties: {
+                    action_name: {
+                      description: "Name of the action",
+                      type: :string,
+                      required: true
+                    },
+                    ssm_document_name: {
+                      description: "Name of SSM document",
+                      type: :string,
+                      required: true
+                    },
+                    timeout_seconds: {
+                      description: "Timeout for the action",
+                      type: :integer
+                    },
+                    must_succeed_for_cutover: {
+                      description: "Whether action must succeed for cutover",
+                      type: :boolean,
+                      default: false
+                    },
+                    parameters: {
+                      description: "Parameters for the SSM document",
+                      type: :map
+                    }
+                  }
+                }
+              }
+            }
+          },
+          tags: {
+            description: "Resource tags",
+            type: :map
+          }
+        })
+
+        resource_block = resource(:aws_drs_launch_configuration_template, name, transformed)
+        
+        Reference.new(
+          type: :aws_drs_launch_configuration_template,
+          name: name,
+          attributes: {
+            arn: "#{resource_block}.arn",
+            id: "#{resource_block}.id",
+            template_id: "#{resource_block}.template_id",
+            tags_all: "#{resource_block}.tags_all"
+          },
+          resource: resource_block
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,153 @@
+# 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'
+
+module Pangea
+  module Resources
+    module AWS
+      # Type-safe resource function for AWS DRS Replication Configuration Template
+      #
+      # @param name [Symbol] The resource name
+      # @param attributes [Hash] Resource attributes following AWS provider schema
+      # @return [Pangea::Resources::Reference] Resource reference for chaining
+      # 
+      # @see https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/drs_replication_configuration_template
+      #
+      # @example Standard replication template for production workloads
+      #   aws_drs_replication_configuration_template(:production_template, {
+      #     associate_default_security_group: false,
+      #     bandwidth_throttling: 50,
+      #     create_public_ip: false,
+      #     data_plane_routing: "PRIVATE_IP",
+      #     default_large_staging_disk_type: "GP3",
+      #     ebs_encryption: "DEFAULT",
+      #     replication_server_instance_type: "m5.large",
+      #     replication_servers_security_groups_ids: [
+      #       security_group.id
+      #     ],
+      #     staging_area_subnet_id: private_subnet.id,
+      #     staging_area_tags: {
+      #       "Purpose" => "DRS-Staging",
+      #       "Environment" => "production"
+      #     },
+      #     use_dedicated_replication_server: false,
+      #     tags: {
+      #       "Template" => "production-replication",
+      #       "CostCenter" => "infrastructure"
+      #     }
+      #   })
+      #
+      # @example High-performance replication template
+      #   aws_drs_replication_configuration_template(:high_performance, {
+      #     associate_default_security_group: false,
+      #     bandwidth_throttling: 0,
+      #     create_public_ip: false,
+      #     data_plane_routing: "PRIVATE_IP",
+      #     default_large_staging_disk_type: "GP3",
+      #     ebs_encryption: "CUSTOMER_MANAGED_CMK",
+      #     ebs_encryption_key_arn: kms_key.arn,
+      #     replication_server_instance_type: "c5.xlarge",
+      #     replication_servers_security_groups_ids: [dr_security_group.id],
+      #     staging_area_subnet_id: dr_subnet.id,
+      #     use_dedicated_replication_server: true
+      #   })
+      def aws_drs_replication_configuration_template(name, attributes)
+        transformed = Base.transform_attributes(attributes, {
+          associate_default_security_group: {
+            description: "Whether to associate default security group",
+            type: :boolean,
+            default: true
+          },
+          bandwidth_throttling: {
+            description: "Bandwidth throttling for replication (Mbps, 0 = unlimited)",
+            type: :integer,
+            default: 0
+          },
+          create_public_ip: {
+            description: "Whether to create public IP for replication servers",
+            type: :boolean,
+            default: false
+          },
+          data_plane_routing: {
+            description: "Data plane routing (PUBLIC_IP or PRIVATE_IP)",
+            type: :string,
+            default: "PRIVATE_IP",
+            enum: ["PUBLIC_IP", "PRIVATE_IP"]
+          },
+          default_large_staging_disk_type: {
+            description: "Default large staging disk type",
+            type: :string,
+            default: "GP2",
+            enum: ["GP2", "GP3", "ST1"]
+          },
+          ebs_encryption: {
+            description: "EBS encryption type",
+            type: :string,
+            default: "DEFAULT",
+            enum: ["DEFAULT", "CUSTOMER_MANAGED_CMK", "NONE"]
+          },
+          ebs_encryption_key_arn: {
+            description: "ARN of EBS encryption key (required if ebs_encryption is CUSTOMER_MANAGED_CMK)",
+            type: :string
+          },
+          replication_server_instance_type: {
+            description: "Instance type for replication servers",
+            type: :string,
+            default: "m5.large"
+          },
+          replication_servers_security_groups_ids: {
+            description: "Security group IDs for replication servers",
+            type: :array
+          },
+          staging_area_subnet_id: {
+            description: "Subnet ID for staging area",
+            type: :string,
+            required: true
+          },
+          staging_area_tags: {
+            description: "Tags for staging area resources",
+            type: :map
+          },
+          use_dedicated_replication_server: {
+            description: "Whether to use dedicated replication server",
+            type: :boolean,
+            default: false
+          },
+          tags: {
+            description: "Resource tags",
+            type: :map
+          }
+        })
+
+        resource_block = resource(:aws_drs_replication_configuration_template, name, transformed)
+        
+        Reference.new(
+          type: :aws_drs_replication_configuration_template,
+          name: name,
+          attributes: {
+            arn: "#{resource_block}.arn",
+            id: "#{resource_block}.id",
+            template_id: "#{resource_block}.template_id",
+            tags_all: "#{resource_block}.tags_all"
+          },
+          resource: resource_block
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+# 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_global_table/types'
+require 'pangea/resource_registry'
+
+module Pangea
+  module Resources
+    module AWS
+      # Create an AWS DynamoDB Global Table with type-safe attributes
+      #
+      # @param name [Symbol] The resource name
+      # @param attributes [Hash] DynamoDB global table attributes
+      # @return [ResourceReference] Reference object with outputs and computed properties
+      def aws_dynamodb_global_table(name, attributes = {})
+        # Validate attributes using dry-struct
+        global_table_attrs = Types::DynamoDbGlobalTableAttributes.new(attributes)
+        
+        # Generate terraform resource block via terraform-synthesizer
+        resource(:aws_dynamodb_global_table, name) do
+          global_table_name global_table_attrs.name
+          billing_mode global_table_attrs.billing_mode
+
+          # Replica configurations
+          global_table_attrs.replica.each do |replica_config|
+            replica do
+              region_name replica_config[:region_name]
+              kms_key_id replica_config[:kms_key_id] if replica_config[:kms_key_id]
+              point_in_time_recovery replica_config[:point_in_time_recovery] if replica_config[:point_in_time_recovery]
+              table_class replica_config[:table_class] if replica_config[:table_class]
+              
+              # Global Secondary Index configurations per replica
+              if replica_config[:global_secondary_index]
+                replica_config[:global_secondary_index].each do |gsi|
+                  global_secondary_index do
+                    name gsi[:name]
+                    read_capacity gsi[:read_capacity] if gsi[:read_capacity]
+                    write_capacity gsi[:write_capacity] if gsi[:write_capacity]
+                  end
+                end
+              end
+
+              # Replica-specific tags
+              if replica_config[:tags] && replica_config[:tags].any?
+                tags do
+                  replica_config[:tags].each do |key, value|
+                    public_send(key, value)
+                  end
+                end
+              end
+            end
+          end
+
+          # Stream configuration
+          if global_table_attrs.stream_enabled
+            stream_enabled global_table_attrs.stream_enabled
+            stream_view_type global_table_attrs.stream_view_type
+          end
+
+          # Server-side encryption
+          if global_table_attrs.server_side_encryption
+            server_side_encryption do
+              enabled global_table_attrs.server_side_encryption&.dig(:enabled)
+              kms_key_id global_table_attrs.server_side_encryption&.dig(:kms_key_id) if global_table_attrs.server_side_encryption&.dig(:kms_key_id)
+            end
+          end
+
+          # Point-in-time recovery
+          if global_table_attrs.point_in_time_recovery
+            point_in_time_recovery do
+              enabled global_table_attrs.point_in_time_recovery&.dig(:enabled)
+            end
+          end
+
+          # Apply global tags if present
+          if global_table_attrs.tags&.any?
+            tags do
+              global_table_attrs.tags.each do |key, value|
+                public_send(key, value)
+              end
+            end
+          end
+        end
+        
+        # Return resource reference with available outputs
+        ResourceReference.new(
+          type: 'aws_dynamodb_global_table',
+          name: name,
+          resource_attributes: global_table_attrs.to_h,
+          outputs: {
+            id: "${aws_dynamodb_global_table.#{name}.id}",
+            arn: "${aws_dynamodb_global_table.#{name}.arn}",
+            global_table_name: "${aws_dynamodb_global_table.#{name}.global_table_name}",
+            billing_mode: "${aws_dynamodb_global_table.#{name}.billing_mode}",
+            stream_arn: "${aws_dynamodb_global_table.#{name}.stream_arn}",
+            stream_label: "${aws_dynamodb_global_table.#{name}.stream_label}",
+            tags_all: "${aws_dynamodb_global_table.#{name}.tags_all}"
+          },
+          computed_properties: {
+            is_pay_per_request: global_table_attrs.is_pay_per_request?,
+            is_provisioned: global_table_attrs.is_provisioned?,
+            has_stream: global_table_attrs.has_stream?,
+            has_encryption: global_table_attrs.has_encryption?,
+            has_pitr: global_table_attrs.has_pitr?,
+            region_count: global_table_attrs.region_count,
+            regions: global_table_attrs.regions,
+            has_gsi: global_table_attrs.has_gsi?,
+            total_gsi_count: global_table_attrs.total_gsi_count,
+            estimated_monthly_cost: global_table_attrs.estimated_monthly_cost,
+            multi_region_strategy: global_table_attrs.multi_region_strategy
+          }
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+# Copyright 2025 The Pangea Authors. Licensed under Apache 2.0.
+
+module Pangea
+  module Resources
+    module AWS
+      # Common DynamoDB Global Table configurations
+      module DynamoDbGlobalTableConfigs
+        # Simple global table across two regions
+        def self.simple_global_table(name, primary_region: "us-east-1", secondary_region: "us-west-2")
+          {
+            name: name,
+            billing_mode: "PAY_PER_REQUEST",
+            replica: [
+              { region_name: primary_region },
+              { region_name: secondary_region }
+            ]
+          }
+        end
+
+        # Global table with encryption
+        def self.encrypted_global_table(name, regions: ["us-east-1", "us-west-2", "eu-west-1"])
+          {
+            name: name,
+            billing_mode: "PAY_PER_REQUEST",
+            server_side_encryption: { enabled: true },
+            point_in_time_recovery: { enabled: true },
+            replica: regions.map { |region| { region_name: region } }
+          }
+        end
+
+        # Global table with streams
+        def self.streaming_global_table(name, regions: ["us-east-1", "us-west-2"],
+                                        stream_view_type: "NEW_AND_OLD_IMAGES")
+          {
+            name: name,
+            billing_mode: "PAY_PER_REQUEST",
+            stream_enabled: true,
+            stream_view_type: stream_view_type,
+            replica: regions.map { |region| { region_name: region } }
+          }
+        end
+
+        # High-performance global table with provisioned throughput
+        def self.high_performance_global_table(name, regions: ["us-east-1", "us-west-2", "eu-west-1"])
+          {
+            name: name,
+            billing_mode: "PROVISIONED",
+            server_side_encryption: { enabled: true },
+            point_in_time_recovery: { enabled: true },
+            replica: regions.map do |region|
+              {
+                region_name: region,
+                point_in_time_recovery: true,
+                table_class: "STANDARD"
+              }
+            end
+          }
+        end
+
+        # Global table with regional GSI configurations
+        def self.global_table_with_gsi(name, regions: ["us-east-1", "us-west-2"], gsi_name: "GSI1")
+          {
+            name: name,
+            billing_mode: "PAY_PER_REQUEST",
+            replica: regions.map do |region|
+              {
+                region_name: region,
+                global_secondary_index: [
+                  {
+                    name: gsi_name
+                  }
+                ]
+              }
+            end
+          }
+        end
+
+        # Multi-region disaster recovery setup
+        def self.disaster_recovery_global_table(name,
+                                               primary_region: "us-east-1",
+                                               dr_regions: ["us-west-2", "eu-west-1"])
+          all_regions = [primary_region] + dr_regions
+
+          {
+            name: name,
+            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: all_regions.map do |region|
+              {
+                region_name: region,
+                point_in_time_recovery: true,
+                table_class: region == primary_region ? "STANDARD" : "STANDARD_INFREQUENT_ACCESS"
+              }
+            end
+          }
+        end
+      end
+    end
+  end
+end