pangea-aws 0.1.0

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

@@ -0,0 +1,138 @@
+# 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/resources/aws_cloudwatch_event_target/target_builders'
+require 'pangea/resource_registry'
+
+module Pangea
+  module Resources
+    module AWS
+      include CloudWatchEventTargetBuilders
+
+      # 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 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 },
+      #     retry_policy: { maximum_retry_attempts: 2, maximum_event_age_in_seconds: 3600 }
+      #   })
+      def aws_cloudwatch_event_target(name, attributes = {})
+        target_attrs = Types::CloudWatchEventTargetAttributes.new(attributes)
+
+        resource(:aws_cloudwatch_event_target, name) do
+          rule target_attrs.rule
+          arn target_attrs.arn
+          target_id target_attrs.target_id if target_attrs.target_id
+          event_bus_name target_attrs.event_bus_name if target_attrs.event_bus_name != 'default'
+          build_aws_cloudwatch_event_target_input_configuration(self, target_attrs)
+          role_arn target_attrs.role_arn if target_attrs.role_arn
+          build_aws_cloudwatch_event_target_target_configurations(self, target_attrs)
+          build_aws_cloudwatch_event_target_error_handling(self, target_attrs)
+        end
+
+        build_aws_cloudwatch_event_target_resource_reference(name, target_attrs)
+      end
+
+      private
+
+      def build_aws_cloudwatch_event_target_input_configuration(context, target_attrs)
+        if target_attrs.input
+          context.input target_attrs.input
+        elsif target_attrs.input_path
+          context.input_path target_attrs.input_path
+        elsif target_attrs.input_transformer
+          context.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
+      end
+
+      def build_aws_cloudwatch_event_target_target_configurations(context, target_attrs)
+        build_ecs_target(context, target_attrs.ecs_target) if target_attrs.ecs_target
+        build_batch_target(context, target_attrs.batch_target) if target_attrs.batch_target
+        build_kinesis_target(context, target_attrs.kinesis_target) if target_attrs.kinesis_target
+        build_sqs_target(context, target_attrs.sqs_target) if target_attrs.sqs_target
+        build_http_target(context, target_attrs.http_target) if target_attrs.http_target
+        build_run_command_targets(context, target_attrs.run_command_targets) if target_attrs.run_command_targets&.any?
+      end
+
+      def build_aws_cloudwatch_event_target_error_handling(context, target_attrs)
+        if target_attrs.retry_policy
+          context.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
+          context.dead_letter_config do
+            arn target_attrs.dead_letter_config.arn
+          end
+        end
+      end
+
+      def build_aws_cloudwatch_event_target_resource_reference(name, target_attrs)
+        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

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

@@ -0,0 +1,97 @@
+# 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
+      # Helper methods for building CloudWatch Event Target configurations
+      module CloudWatchEventTargetBuilders
+        private
+
+        def build_ecs_target(context, ecs_config)
+          context.ecs_target do
+            task_definition_arn ecs_config[:task_definition_arn]
+            task_count ecs_config[:task_count] if ecs_config[:task_count]
+            launch_type ecs_config[:launch_type] if ecs_config[:launch_type]
+            platform_version ecs_config[:platform_version] if ecs_config[:platform_version]
+            group ecs_config[:group] if ecs_config[:group]
+            build_network_configuration(self, ecs_config[:network_configuration]) if ecs_config[:network_configuration]
+            build_placement_constraints(self, ecs_config[:placement_constraints]) if ecs_config[:placement_constraints]
+          end
+        end
+
+        def build_network_configuration(context, network_config)
+          context.network_configuration do
+            if network_config[:awsvpc_configuration]
+              awsvpc_configuration do
+                subnets network_config[:awsvpc_configuration][:subnets]
+                security_groups network_config[:awsvpc_configuration][:security_groups] if network_config[:awsvpc_configuration][:security_groups]
+                assign_public_ip network_config[:awsvpc_configuration][:assign_public_ip] if network_config[:awsvpc_configuration][:assign_public_ip]
+              end
+            end
+          end
+        end
+
+        def build_placement_constraints(context, constraints)
+          constraints.each do |constraint|
+            context.placement_constraint do
+              type constraint[:type]
+              expression constraint[:expression] if constraint[:expression]
+            end
+          end
+        end
+
+        def build_batch_target(context, batch_config)
+          context.batch_target do
+            job_definition batch_config[:job_definition]
+            job_name batch_config[:job_name]
+            array_size batch_config[:array_size] if batch_config[:array_size]
+            job_attempts batch_config[:job_attempts] if batch_config[:job_attempts]
+          end
+        end
+
+        def build_kinesis_target(context, kinesis_config)
+          context.kinesis_target do
+            partition_key_path kinesis_config[:partition_key_path] if kinesis_config[:partition_key_path]
+          end
+        end
+
+        def build_sqs_target(context, sqs_config)
+          context.sqs_target do
+            message_group_id sqs_config[:message_group_id] if sqs_config[:message_group_id]
+          end
+        end
+
+        def build_http_target(context, http_config)
+          context.http_target do
+            endpoint http_config[:endpoint] if http_config[:endpoint]
+            header_parameters http_config[:header_parameters] if http_config[:header_parameters]
+            query_string_parameters http_config[:query_string_parameters] if http_config[:query_string_parameters]
+            path_parameter_values http_config[:path_parameter_values] if http_config[:path_parameter_values]
+          end
+        end
+
+        def build_run_command_targets(context, run_command_targets)
+          run_command_targets.each do |run_command|
+            context.run_command_targets do
+              key run_command[:key]
+              values run_command[:values]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+# Copyright 2025 The Pangea Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'dry-struct'
+require 'pangea/resources/types'
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        # Dead letter configuration for CloudWatch Event targets
+        unless const_defined?(:DeadLetterConfig)
+        class DeadLetterConfig < Pangea::Resources::BaseAttributes
+          transform_keys(&:to_sym)
+
+          attribute? :arn, Resources::Types::String.optional
+
+          def to_h
+            { arn: arn }
+          end
+        end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+# Copyright 2025 The Pangea Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'dry-struct'
+require 'pangea/resources/types'
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        # Input transformer configuration for CloudWatch Event targets
+        unless const_defined?(:InputTransformer)
+        class InputTransformer < Pangea::Resources::BaseAttributes
+          transform_keys(&:to_sym)
+
+          attribute :input_paths_map, Resources::Types::Hash.default({}.freeze)
+          attribute? :input_template, Resources::Types::String.optional
+
+          def to_h
+            {
+              input_paths_map: input_paths_map,
+              input_template: input_template
+            }.compact
+          end
+        end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+# Copyright 2025 The Pangea Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'dry-struct'
+require 'pangea/resources/types'
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        # Retry policy configuration for CloudWatch Event targets
+        unless const_defined?(:RetryPolicy)
+        class RetryPolicy < Pangea::Resources::BaseAttributes
+          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
+      end
+    end
+        end
+  end
+end

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

@@ -0,0 +1,80 @@
+# 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 Types
+        # Module for detecting AWS service type from ARN
+        module TargetServiceDetection
+          # Service patterns mapped to service symbols
+          SERVICE_PATTERNS = {
+            /^arn:aws[a-z\-]*:lambda:/ => :lambda,
+            /^arn:aws[a-z\-]*:sns:/ => :sns,
+            /^arn:aws[a-z\-]*:sqs:/ => :sqs,
+            /^arn:aws[a-z\-]*:kinesis:/ => :kinesis,
+            /^arn:aws[a-z\-]*:firehose:/ => :firehose,
+            /^arn:aws[a-z\-]*:logs:/ => :cloudwatch_logs,
+            /^arn:aws[a-z\-]*:events:/ => :event_bus,
+            /^arn:aws[a-z\-]*:states:/ => :step_functions,
+            /^arn:aws[a-z\-]*:codebuild:/ => :codebuild,
+            /^arn:aws[a-z\-]*:codepipeline:/ => :codepipeline,
+            /^arn:aws[a-z\-]*:ecs:/ => :ecs,
+            /^arn:aws[a-z\-]*:batch:/ => :batch,
+            /^arn:aws[a-z\-]*:glue:/ => :glue,
+            /^arn:aws[a-z\-]*:redshift:/ => :redshift,
+            /^arn:aws[a-z\-]*:sagemaker:/ => :sagemaker
+          }.freeze
+
+          # Services that typically require an IAM role
+          ROLE_REQUIRED_SERVICES = %i[
+            ecs batch kinesis firehose step_functions codebuild codepipeline
+          ].freeze
+
+          # Detect target service from ARN
+          def target_service
+            return :unknown unless arn
+
+            SERVICE_PATTERNS.each do |pattern, service|
+              return service if arn.match?(pattern)
+            end
+
+            :unknown
+          end
+
+          # Check if this target service typically requires a role
+          def requires_role?
+            ROLE_REQUIRED_SERVICES.include?(target_service)
+          end
+
+          # Check if input transformation is configured
+          def has_input_transformation?
+            !input_transformer.nil?
+          end
+
+          # Check if retry policy is configured
+          def has_retry_policy?
+            !retry_policy.nil?
+          end
+
+          # Check if dead letter queue is configured
+          def has_dead_letter_queue?
+            !dead_letter_config.nil?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_cloudwatch_event_target/types/validators.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.
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        # Validation helpers for CloudWatch Event Target attributes
+        module CloudWatchEventTargetValidators
+          # Validate ARN format
+          def self.validate_arn(arn)
+            return unless arn
+            return if arn.match?(/^arn:aws[a-z\-]*:/) || arn.match?(/^\$\{/)
+
+            raise Dry::Struct::Error, 'arn must be a valid AWS ARN'
+          end
+
+          # Validate input options are mutually exclusive
+          def self.validate_input_options(attrs)
+            input_options = %i[input input_path input_transformer].count { |opt| attrs[opt] }
+            return unless 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
+          def self.validate_role_arn(role_arn)
+            return unless role_arn && !role_arn.empty?
+            return if role_arn.match?(/^arn:aws[a-z\-]*:iam::\d{12}:role\//) ||
+                      role_arn.match?(/^\$\{/)
+
+            raise Dry::Struct::Error, 'role_arn must be a valid IAM role ARN'
+          end
+
+          # Validate ECS target configuration
+          def self.validate_ecs_target(ecs_target)
+            return unless ecs_target
+            return if ecs_target[:task_definition_arn]
+
+            raise Dry::Struct::Error, 'ecs_target requires task_definition_arn'
+          end
+
+          # Validate Batch target configuration
+          def self.validate_batch_target(batch_target)
+            return unless batch_target
+            return if batch_target[:job_definition] && batch_target[:job_name]
+
+            raise Dry::Struct::Error, 'batch_target requires job_definition and job_name'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_cloudwatch_event_target/types.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.
+
+require 'dry-struct'
+require 'pangea/resources/types'
+require 'json'
+
+require_relative 'types/input_transformer'
+require_relative 'types/retry_policy'
+require_relative 'types/dead_letter_config'
+require_relative 'types/target_service_detection'
+require_relative 'types/validators'
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        # CloudWatch Event Target resource attributes with validation
+        class CloudWatchEventTargetAttributes < Pangea::Resources::BaseAttributes
+          include TargetServiceDetection
+
+          transform_keys(&:to_sym)
+
+          # Required attributes
+          attribute? :rule, Resources::Types::String.optional
+          attribute? :arn, Resources::Types::String.optional
+          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 : {}
+
+            CloudWatchEventTargetValidators.validate_arn(attrs[:arn])
+            CloudWatchEventTargetValidators.validate_input_options(attrs)
+            CloudWatchEventTargetValidators.validate_role_arn(attrs[:role_arn])
+            CloudWatchEventTargetValidators.validate_ecs_target(attrs[:ecs_target])
+            CloudWatchEventTargetValidators.validate_batch_target(attrs[:batch_target])
+
+            # Convert nested structures to appropriate types
+            attrs = convert_nested_structures(attrs)
+
+            super(attrs)
+          end
+
+          def self.convert_nested_structures(attrs)
+            attrs = attrs.dup
+
+            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
+
+            attrs
+          end
+
+          def to_h
+            build_required_hash
+              .merge(build_optional_hash)
+              .merge(build_target_config_hash)
+              .merge(build_error_handling_hash)
+              .compact
+          end
+
+          private
+
+          def build_required_hash
+            {
+              rule: rule,
+              arn: arn,
+              event_bus_name: event_bus_name
+            }
+          end
+
+          def build_optional_hash
+            hash = {}
+            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
+            hash
+          end
+
+          def build_target_config_hash
+            hash = {}
+            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
+            hash
+          end
+
+          def build_error_handling_hash
+            hash = {}
+            hash[:retry_policy] = retry_policy.to_h if retry_policy
+            hash[:dead_letter_config] = dead_letter_config.to_h if dead_letter_config
+            hash
+          end
+        end
+      end
+    end
+  end
+end