pangea 0.0.45 → 0.0.46

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

@@ -1,226 +0,0 @@
-# frozen_string_literal: true
-# Copyright 2025 The Pangea Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-require 'pangea/resources/base'
-require 'pangea/resources/reference'
-require 'pangea/resources/aws_cloudwatch_event_target/types'
-require 'pangea/resource_registry'
-
-module Pangea
-  module Resources
-    module AWS
-      # Create an AWS CloudWatch Event Target with type-safe attributes
-      #
-      # @param name [Symbol] The resource name
-      # @param attributes [Hash] CloudWatch Event Target attributes
-      # @option attributes [String] :rule The name of the rule
-      # @option attributes [String] :arn ARN of the target resource
-      # @option attributes [String] :target_id Unique target ID
-      # @option attributes [String] :event_bus_name Event bus name (default: "default")
-      # @option attributes [String] :input JSON text to pass to target
-      # @option attributes [String] :input_path JSONPath to extract from event
-      # @option attributes [Hash] :input_transformer Input transformation configuration
-      # @option attributes [String] :role_arn IAM role for the target
-      # @option attributes [Hash] :ecs_target ECS task configuration
-      # @option attributes [Hash] :batch_target Batch job configuration
-      # @option attributes [Hash] :retry_policy Retry policy configuration
-      # @option attributes [Hash] :dead_letter_config Dead letter queue configuration
-      # @return [ResourceReference] Reference object with outputs and computed properties
-      #
-      # @example Lambda function target
-      #   lambda_target = aws_cloudwatch_event_target(:lambda_processor, {
-      #     rule: event_rule.name,
-      #     arn: processor_lambda.arn
-      #   })
-      #
-      # @example SNS topic with input transformation
-      #   sns_target = aws_cloudwatch_event_target(:notification, {
-      #     rule: alert_rule.name,
-      #     arn: notification_topic.arn,
-      #     input_transformer: {
-      #       input_paths_map: {
-      #         instance: "$.detail.instance",
-      #         status: "$.detail.status"
-      #       },
-      #       input_template: '"Instance <instance> is now <status>"'
-      #     }
-      #   })
-      #
-      # @example ECS task target with retry policy
-      #   ecs_target = aws_cloudwatch_event_target(:ecs_task, {
-      #     rule: scheduled_rule.name,
-      #     arn: ecs_cluster.arn,
-      #     role_arn: ecs_events_role.arn,
-      #     ecs_target: {
-      #       task_definition_arn: task_definition.arn,
-      #       task_count: 1,
-      #       launch_type: "FARGATE",
-      #       network_configuration: {
-      #         awsvpc_configuration: {
-      #           subnets: subnet_ids,
-      #           security_groups: [security_group.id],
-      #           assign_public_ip: "ENABLED"
-      #         }
-      #       }
-      #     },
-      #     retry_policy: {
-      #       maximum_retry_attempts: 2,
-      #       maximum_event_age_in_seconds: 3600
-      #     }
-      #   })
-      def aws_cloudwatch_event_target(name, attributes = {})
-        # Validate attributes using dry-struct
-        target_attrs = Types::Types::CloudWatchEventTargetAttributes.new(attributes)
-        
-        # Generate terraform resource block via terraform-synthesizer
-        resource(:aws_cloudwatch_event_target, name) do
-          rule target_attrs.rule
-          arn target_attrs.arn
-          
-          # Optional target ID
-          target_id target_attrs.target_id if target_attrs.target_id
-          
-          # Event bus name if not default
-          event_bus_name target_attrs.event_bus_name if target_attrs.event_bus_name != 'default'
-          
-          # Input configuration (mutually exclusive)
-          if target_attrs.input
-            input target_attrs.input
-          elsif target_attrs.input_path
-            input_path target_attrs.input_path
-          elsif target_attrs.input_transformer
-            input_transformer do
-              input_paths_map target_attrs.input_transformer.input_paths_map if target_attrs.input_transformer.input_paths_map.any?
-              input_template target_attrs.input_transformer.input_template
-            end
-          end
-          
-          # IAM role if required
-          role_arn target_attrs.role_arn if target_attrs.role_arn
-          
-          # Target-specific configurations
-          if target_attrs.ecs_target
-            ecs_target do
-              task_definition_arn target_attrs.ecs_target[:task_definition_arn]
-              task_count target_attrs.ecs_target[:task_count] if target_attrs.ecs_target[:task_count]
-              launch_type target_attrs.ecs_target[:launch_type] if target_attrs.ecs_target[:launch_type]
-              platform_version target_attrs.ecs_target[:platform_version] if target_attrs.ecs_target[:platform_version]
-              group target_attrs.ecs_target[:group] if target_attrs.ecs_target[:group]
-              
-              if target_attrs.ecs_target[:network_configuration]
-                network_configuration do
-                  if target_attrs.ecs_target[:network_configuration][:awsvpc_configuration]
-                    awsvpc_configuration do
-                      subnets target_attrs.ecs_target[:network_configuration][:awsvpc_configuration][:subnets]
-                      security_groups target_attrs.ecs_target[:network_configuration][:awsvpc_configuration][:security_groups] if target_attrs.ecs_target[:network_configuration][:awsvpc_configuration][:security_groups]
-                      assign_public_ip target_attrs.ecs_target[:network_configuration][:awsvpc_configuration][:assign_public_ip] if target_attrs.ecs_target[:network_configuration][:awsvpc_configuration][:assign_public_ip]
-                    end
-                  end
-                end
-              end
-              
-              if target_attrs.ecs_target[:placement_constraints]
-                target_attrs.ecs_target[:placement_constraints].each do |constraint|
-                  placement_constraint do
-                    type constraint[:type]
-                    expression constraint[:expression] if constraint[:expression]
-                  end
-                end
-              end
-            end
-          end
-          
-          if target_attrs.batch_target
-            batch_target do
-              job_definition target_attrs.batch_target[:job_definition]
-              job_name target_attrs.batch_target[:job_name]
-              array_size target_attrs.batch_target[:array_size] if target_attrs.batch_target[:array_size]
-              job_attempts target_attrs.batch_target[:job_attempts] if target_attrs.batch_target[:job_attempts]
-            end
-          end
-          
-          if target_attrs.kinesis_target
-            kinesis_target do
-              partition_key_path target_attrs.kinesis_target[:partition_key_path] if target_attrs.kinesis_target[:partition_key_path]
-            end
-          end
-          
-          if target_attrs.sqs_target
-            sqs_target do
-              message_group_id target_attrs.sqs_target[:message_group_id] if target_attrs.sqs_target[:message_group_id]
-            end
-          end
-          
-          if target_attrs.http_target
-            http_target do
-              endpoint target_attrs.http_target[:endpoint] if target_attrs.http_target[:endpoint]
-              header_parameters target_attrs.http_target[:header_parameters] if target_attrs.http_target[:header_parameters]
-              query_string_parameters target_attrs.http_target[:query_string_parameters] if target_attrs.http_target[:query_string_parameters]
-              path_parameter_values target_attrs.http_target[:path_parameter_values] if target_attrs.http_target[:path_parameter_values]
-            end
-          end
-          
-          # Run command targets
-          if target_attrs.run_command_targets.any?
-            target_attrs.run_command_targets.each do |run_command|
-              run_command_targets do
-                key run_command[:key]
-                values run_command[:values]
-              end
-            end
-          end
-          
-          # Error handling
-          if target_attrs.retry_policy
-            retry_policy do
-              maximum_retry_attempts target_attrs.retry_policy.maximum_retry_attempts if target_attrs.retry_policy.maximum_retry_attempts
-              maximum_event_age_in_seconds target_attrs.retry_policy.maximum_event_age_in_seconds if target_attrs.retry_policy.maximum_event_age_in_seconds
-            end
-          end
-          
-          if target_attrs.dead_letter_config
-            dead_letter_config do
-              arn target_attrs.dead_letter_config.arn
-            end
-          end
-        end
-        
-        # Return resource reference with available outputs
-        ResourceReference.new(
-          type: 'aws_cloudwatch_event_target',
-          name: name,
-          resource_attributes: target_attrs.to_h,
-          outputs: {
-            id: "${aws_cloudwatch_event_target.#{name}.id}",
-            arn: "${aws_cloudwatch_event_target.#{name}.arn}",
-            rule: "${aws_cloudwatch_event_target.#{name}.rule}",
-            target_id: "${aws_cloudwatch_event_target.#{name}.target_id}"
-          },
-          computed_properties: {
-            target_service: target_attrs.target_service,
-            requires_role: target_attrs.requires_role?,
-            has_input_transformation: target_attrs.has_input_transformation?,
-            has_retry_policy: target_attrs.has_retry_policy?,
-            has_dead_letter_queue: target_attrs.has_dead_letter_queue?
-          }
-        )
-      end
-    end
-  end
-end
-
-# Auto-register this module when it's loaded
-Pangea::ResourceRegistry.register(:aws, Pangea::Resources::AWS)

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

@@ -1,231 +0,0 @@
-# frozen_string_literal: true
-# Copyright 2025 The Pangea Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-require 'dry-struct'
-require 'pangea/resources/types'
-require 'json'
-
-module Pangea
-  module Resources
-    module AWS
-      module Types
-        # Input transformer configuration
-        class InputTransformer < Dry::Struct
-          transform_keys(&:to_sym)
-          
-          attribute :input_paths_map, Resources::Types::Hash.default({}.freeze)
-          attribute :input_template, Resources::Types::String
-          
-          def to_h
-            {
-              input_paths_map: input_paths_map,
-              input_template: input_template
-            }.compact
-          end
-        end
-        
-        # Retry policy configuration
-        class RetryPolicy < Dry::Struct
-          transform_keys(&:to_sym)
-          
-          attribute :maximum_event_age_in_seconds, Resources::Types::Integer.optional.default(nil)
-          attribute :maximum_retry_attempts, Resources::Types::Integer.optional.default(nil)
-          
-          def to_h
-            hash = {}
-            hash[:maximum_event_age_in_seconds] = maximum_event_age_in_seconds if maximum_event_age_in_seconds
-            hash[:maximum_retry_attempts] = maximum_retry_attempts if maximum_retry_attempts
-            hash.compact
-          end
-        end
-        
-        # Dead letter config
-        class DeadLetterConfig < Dry::Struct
-          transform_keys(&:to_sym)
-          
-          attribute :arn, Resources::Types::String
-          
-          def to_h
-            { arn: arn }
-          end
-        end
-        
-        # CloudWatch Event Target resource attributes with validation
-        class CloudWatchEventTargetAttributes < Dry::Struct
-          transform_keys(&:to_sym)
-          
-          # Required attributes
-          attribute :rule, Resources::Types::String
-          attribute :arn, Resources::Types::String
-          attribute :target_id, Resources::Types::String.optional.default(nil)
-          
-          # Optional attributes
-          attribute :event_bus_name, Resources::Types::String.default('default')
-          attribute :input, Resources::Types::String.optional.default(nil)
-          attribute :input_path, Resources::Types::String.optional.default(nil)
-          attribute :input_transformer, InputTransformer.optional.default(nil)
-          attribute :role_arn, Resources::Types::String.optional.default(nil)
-          
-          # Target-specific configurations
-          attribute :ecs_target, Resources::Types::Hash.optional.default(nil)
-          attribute :batch_target, Resources::Types::Hash.optional.default(nil)
-          attribute :kinesis_target, Resources::Types::Hash.optional.default(nil)
-          attribute :sqs_target, Resources::Types::Hash.optional.default(nil)
-          attribute :http_target, Resources::Types::Hash.optional.default(nil)
-          attribute :run_command_targets, Resources::Types::Array.of(Resources::Types::Hash).default([].freeze)
-          attribute :redshift_target, Resources::Types::Hash.optional.default(nil)
-          attribute :sage_maker_pipeline_target, Resources::Types::Hash.optional.default(nil)
-          
-          # Error handling
-          attribute :retry_policy, RetryPolicy.optional.default(nil)
-          attribute :dead_letter_config, DeadLetterConfig.optional.default(nil)
-          
-          # Validate target configuration
-          def self.new(attributes)
-            attrs = attributes.is_a?(Hash) ? attributes : {}
-            
-            # Validate ARN format
-            if attrs[:arn] && !attrs[:arn].match?(/^arn:aws[a-z\-]*:/) && !attrs[:arn].match?(/^\$\{/)
-              raise Dry::Struct::Error, "arn must be a valid AWS ARN"
-            end
-            
-            # Validate input options are mutually exclusive
-            input_options = [:input, :input_path, :input_transformer].count { |opt| attrs[opt] }
-            if input_options > 1
-              raise Dry::Struct::Error, "Can only specify one of: input, input_path, or input_transformer"
-            end
-            
-            # Validate role_arn format if provided
-            if attrs[:role_arn] && !attrs[:role_arn].empty?
-              unless attrs[:role_arn].match?(/^arn:aws[a-z\-]*:iam::\d{12}:role\//) ||
-                     attrs[:role_arn].match?(/^\$\{/)
-                raise Dry::Struct::Error, "role_arn must be a valid IAM role ARN"
-              end
-            end
-            
-            # Convert nested structures to appropriate types
-            if attrs[:input_transformer] && !attrs[:input_transformer].is_a?(InputTransformer)
-              attrs[:input_transformer] = InputTransformer.new(attrs[:input_transformer])
-            end
-            
-            if attrs[:retry_policy] && !attrs[:retry_policy].is_a?(RetryPolicy)
-              attrs[:retry_policy] = RetryPolicy.new(attrs[:retry_policy])
-            end
-            
-            if attrs[:dead_letter_config] && !attrs[:dead_letter_config].is_a?(DeadLetterConfig)
-              attrs[:dead_letter_config] = DeadLetterConfig.new(attrs[:dead_letter_config])
-            end
-            
-            # Validate target-specific configurations
-            if attrs[:ecs_target]
-              validate_ecs_target(attrs[:ecs_target])
-            end
-            
-            if attrs[:batch_target]
-              validate_batch_target(attrs[:batch_target])
-            end
-            
-            super(attrs)
-          end
-          
-          def self.validate_ecs_target(ecs_target)
-            unless ecs_target[:task_definition_arn]
-              raise Dry::Struct::Error, "ecs_target requires task_definition_arn"
-            end
-          end
-          
-          def self.validate_batch_target(batch_target)
-            unless batch_target[:job_definition] && batch_target[:job_name]
-              raise Dry::Struct::Error, "batch_target requires job_definition and job_name"
-            end
-          end
-          
-          # Computed properties
-          def target_service
-            return :unknown unless arn
-            
-            case arn
-            when /^arn:aws[a-z\-]*:lambda:/ then :lambda
-            when /^arn:aws[a-z\-]*:sns:/ then :sns
-            when /^arn:aws[a-z\-]*:sqs:/ then :sqs
-            when /^arn:aws[a-z\-]*:kinesis:/ then :kinesis
-            when /^arn:aws[a-z\-]*:firehose:/ then :firehose
-            when /^arn:aws[a-z\-]*:logs:/ then :cloudwatch_logs
-            when /^arn:aws[a-z\-]*:events:/ then :event_bus
-            when /^arn:aws[a-z\-]*:states:/ then :step_functions
-            when /^arn:aws[a-z\-]*:codebuild:/ then :codebuild
-            when /^arn:aws[a-z\-]*:codepipeline:/ then :codepipeline
-            when /^arn:aws[a-z\-]*:ecs:/ then :ecs
-            when /^arn:aws[a-z\-]*:batch:/ then :batch
-            when /^arn:aws[a-z\-]*:glue:/ then :glue
-            when /^arn:aws[a-z\-]*:redshift:/ then :redshift
-            when /^arn:aws[a-z\-]*:sagemaker:/ then :sagemaker
-            else :unknown
-            end
-          end
-          
-          def requires_role?
-            # Services that typically require a role
-            [:ecs, :batch, :kinesis, :firehose, :step_functions, :codebuild, :codepipeline].include?(target_service)
-          end
-          
-          def has_input_transformation?
-            !input_transformer.nil?
-          end
-          
-          def has_retry_policy?
-            !retry_policy.nil?
-          end
-          
-          def has_dead_letter_queue?
-            !dead_letter_config.nil?
-          end
-          
-          def to_h
-            hash = {
-              rule: rule,
-              arn: arn,
-              event_bus_name: event_bus_name
-            }
-            
-            # Optional attributes
-            hash[:target_id] = target_id if target_id
-            hash[:input] = input if input
-            hash[:input_path] = input_path if input_path
-            hash[:input_transformer] = input_transformer.to_h if input_transformer
-            hash[:role_arn] = role_arn if role_arn
-            
-            # Target-specific configurations
-            hash[:ecs_target] = ecs_target if ecs_target
-            hash[:batch_target] = batch_target if batch_target
-            hash[:kinesis_target] = kinesis_target if kinesis_target
-            hash[:sqs_target] = sqs_target if sqs_target
-            hash[:http_target] = http_target if http_target
-            hash[:run_command_targets] = run_command_targets if run_command_targets.any?
-            hash[:redshift_target] = redshift_target if redshift_target
-            hash[:sage_maker_pipeline_target] = sage_maker_pipeline_target if sage_maker_pipeline_target
-            
-            # Error handling
-            hash[:retry_policy] = retry_policy.to_h if retry_policy
-            hash[:dead_letter_config] = dead_letter_config.to_h if dead_letter_config
-            
-            hash.compact
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-# Copyright 2025 The Pangea Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-require 'pangea/resources/base'
-require 'pangea/resources/reference'
-
-module Pangea
-  module Resources
-    module AWS
-      # Type-safe resource function for AWS CloudWatch Insight Rule
-      #
-      # @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/cloudwatch_insight_rule
-      #
-      # @example Application performance insight rule
-      #   aws_cloudwatch_insight_rule(:app_performance, {
-      #     name: "ApplicationPerformanceInsights",
-      #     rule_definition: jsonencode({
-      #       "Rules": [
-      #         {
-      #           "RuleName": "ApplicationLatency",
-      #           "RuleState": "ENABLED",
-      #           "Schema": "AWS/ApplicationELB",
-      #           "Fields": {
-      #             "TargetResponseTime": "TargetResponseTime"
-      #           }
-      #         }
-      #       ]
-      #     }),
-      #     rule_state: "ENABLED"
-      #   })
-      #
-      # @example Custom metric insight rule
-      #   aws_cloudwatch_insight_rule(:custom_insights, {
-      #     name: "CustomMetricInsights",
-      #     rule_definition: rule_definition_ref.json,
-      #     rule_state: "ENABLED",
-      #     tags: {
-      #       Environment: "production",
-      #       Team: "platform"
-      #     }
-      #   })
-      def aws_cloudwatch_insight_rule(name, attributes)
-        transformed = Base.transform_attributes(attributes, {
-          name: {
-            description: "Name of the insight rule",
-            type: :string,
-            required: true
-          },
-          rule_definition: {
-            description: "JSON definition of the insight rule",
-            type: :string,
-            required: true
-          },
-          rule_state: {
-            description: "State of the insight rule (ENABLED or DISABLED)",
-            type: :string,
-            default: "ENABLED"
-          },
-          tags: {
-            description: "Resource tags",
-            type: :map
-          }
-        })
-
-        resource_block = resource(:aws_cloudwatch_insight_rule, name, transformed)
-        
-        Reference.new(
-          type: :aws_cloudwatch_insight_rule,
-          name: name,
-          attributes: {
-            arn: "#{resource_block}.arn",
-            id: "#{resource_block}.id",
-            name: "#{resource_block}.name",
-            tags_all: "#{resource_block}.tags_all"
-          },
-          resource: resource_block
-        )
-      end
-    end
-  end
-end
-
-# Auto-register this module when it's loaded
-Pangea::ResourceRegistry.register(:aws, Pangea::Resources::AWS)

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

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-# Copyright 2025 The Pangea Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-require 'pangea/resources/base'
-require 'pangea/resources/reference'
-
-module Pangea
-  module Resources
-    module AWS
-      # Type-safe resource function for AWS CloudWatch Log Data Protection Policy
-      #
-      # @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/cloudwatch_log_data_protection_policy
-      #
-      # @example PII detection and redaction policy
-      #   aws_cloudwatch_log_data_protection_policy(:pii_protection, {
-      #     log_group_name: log_group.name,
-      #     policy_document: jsonencode({
-      #       "Name": "PIIDetectionPolicy",
-      #       "Description": "Detect and redact PII data",
-      #       "Version": "2021-06-01",
-      #       "Statement": [
-      #         {
-      #           "Sid": "DetectPII",
-      #           "DataIdentifier": [
-      #             "arn:aws:dataprotection::aws:data-identifier/EmailAddress",
-      #             "arn:aws:dataprotection::aws:data-identifier/CreditCardNumber"
-      #           ],
-      #           "Operation": {
-      #             "Audit": {
-      #               "FindingsDestination": {
-      #                 "CloudWatchLogs": {
-      #                   "LogGroup": audit_log_group.name
-      #                 }
-      #               }
-      #             },
-      #             "Deidentify": {
-      #               "MaskConfig": {}
-      #             }
-      #           }
-      #         }
-      #       ]
-      #     })
-      #   })
-      #
-      # @example Custom data identifier protection
-      #   aws_cloudwatch_log_data_protection_policy(:custom_protection, {
-      #     log_group_name: "/aws/apigateway/access-logs",
-      #     policy_document: protection_policy_ref.json
-      #   })
-      def aws_cloudwatch_log_data_protection_policy(name, attributes)
-        transformed = Base.transform_attributes(attributes, {
-          log_group_name: {
-            description: "Name of the log group to apply policy to",
-            type: :string,
-            required: true
-          },
-          policy_document: {
-            description: "JSON policy document defining data protection rules",
-            type: :string,
-            required: true
-          }
-        })
-
-        resource_block = resource(:aws_cloudwatch_log_data_protection_policy, name, transformed)
-        
-        Reference.new(
-          type: :aws_cloudwatch_log_data_protection_policy,
-          name: name,
-          attributes: {
-            id: "#{resource_block}.id",
-            log_group_name: "#{resource_block}.log_group_name",
-            policy_document: "#{resource_block}.policy_document"
-          },
-          resource: resource_block
-        )
-      end
-    end
-  end
-end
-
-# Auto-register this module when it's loaded
-Pangea::ResourceRegistry.register(:aws, Pangea::Resources::AWS)