ruby_reactor 0.1.0

data/lib/ruby_reactor/executor/input_validator.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  class Executor
+    class InputValidator
+      def initialize(reactor_class, context)
+        @reactor_class = reactor_class
+        @context = context
+      end
+
+      def validate!
+        check_required_inputs
+        validate_input_schemas
+      end
+
+      private
+
+      def check_required_inputs
+        @reactor_class.inputs.each do |input_name, input_config|
+          next if input_config[:optional] || @context.inputs.key?(input_name) || @context.inputs.key?(input_name.to_s)
+
+          raise Error::ValidationError.new(
+            "Required input '#{input_name}' is missing",
+            context: @context
+          )
+        end
+      end
+
+      def validate_input_schemas
+        return unless @reactor_class.respond_to?(:input_validations) && @reactor_class.input_validations.any?
+
+        validation_result = @reactor_class.validate_inputs(@context.inputs)
+        return unless validation_result.failure?
+
+        raise validation_result.error
+      end
+    end
+  end
+end

data/lib/ruby_reactor/executor/result_handler.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  class Executor
+    class ResultHandler
+      def initialize(context:, compensation_manager:, dependency_graph:)
+        @context = context
+        @compensation_manager = compensation_manager
+        @dependency_graph = dependency_graph
+        @step_results = {}
+      end
+
+      attr_reader :step_results
+
+      def handle_step_result(step_config, result, resolved_arguments)
+        case result
+        when RubyReactor::Success
+          validate_step_output(step_config, result.value, resolved_arguments)
+          @step_results[step_config.name] = result
+          @compensation_manager.add_to_undo_stack({ step: step_config, arguments: resolved_arguments, result: result })
+          @context.set_result(step_config.name, result.value)
+          @dependency_graph.complete_step(step_config.name)
+        when RubyReactor::MaxRetriesExhaustedFailure
+          # For MaxRetriesExhaustedFailure, use the original error to avoid double-wrapping the message
+          # The error message from MaxRetriesExhaustedFailure already includes "failed after N attempts"
+          @compensation_manager.handle_step_failure(step_config, result.original_error, resolved_arguments)
+          # Use the MaxRetriesExhaustedFailure error message for the final error
+          raise Error::StepFailureError.new(result.error, step: step_config.name, context: @context,
+                                                          step_arguments: resolved_arguments)
+        when RubyReactor::Failure
+          failure_result = @compensation_manager.handle_step_failure(step_config, result.error, resolved_arguments)
+          raise Error::StepFailureError.new(failure_result.error, step: step_config.name, context: @context,
+                                                                  step_arguments: resolved_arguments)
+        else
+          # Treat non-Success/Failure results as success with that value
+          validate_step_output(step_config, result, resolved_arguments)
+          success_result = RubyReactor.Success(result)
+          @step_results[step_config.name] = success_result
+          @compensation_manager.add_to_undo_stack({ step: step_config, arguments: resolved_arguments,
+                                                    result: success_result })
+          @context.set_result(step_config.name, result)
+          @dependency_graph.complete_step(step_config.name)
+        end
+      end
+
+      def handle_execution_error(error)
+        case error
+        when Error::StepFailureError
+          # Step failure has already been handled (compensation and rollback for the failed step)
+          # But we need to rollback all completed steps
+          @compensation_manager.rollback_completed_steps
+
+          redact_inputs = error.context.reactor_class.inputs.select { |_, config| config[:redact] }.keys
+
+          RubyReactor::Failure(
+            error.message,
+            step_name: error.step,
+            inputs: error.context.inputs,
+            redact_inputs: redact_inputs,
+            backtrace: error.backtrace,
+            reactor_name: error.context.reactor_class.name,
+            step_arguments: error.step_arguments
+          )
+        when Error::InputValidationError
+          # Preserve validation errors as-is for proper error handling
+          RubyReactor.Failure(error)
+        when Error::Base
+          # Other errors need rollback
+          @compensation_manager.rollback_completed_steps
+          RubyReactor.Failure("Execution error: #{error.message}")
+        else
+          # Unknown errors - don't rollback as they may not be reactor-related
+          RubyReactor.Failure("Execution failed: #{error.message}")
+        end
+      end
+
+      def final_result(reactor_class)
+        if reactor_class.return_step
+          result_value = @context.get_result(reactor_class.return_step)
+          RubyReactor.Success(result_value)
+        else
+          RubyReactor.Success(@context.intermediate_results)
+        end
+      end
+
+      private
+
+      def validate_step_output(step_config, value, resolved_arguments = {})
+        return unless step_config.output_validator
+
+        output_validation_result = step_config.output_validator.call(value)
+        return if output_validation_result.success?
+
+        raise Error::StepFailureError.new(
+          "Step '#{step_config.name}' output validation failed: #{output_validation_result.error.message}",
+          step: step_config.name,
+          context: @context,
+          step_arguments: resolved_arguments
+        )
+      end
+    end
+  end
+end

data/lib/ruby_reactor/executor/retry_manager.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  class Executor
+    class RetryManager
+      def initialize(context)
+        @context = context
+      end
+
+      def execute_with_retry(step_config, reactor_class)
+        loop do
+          prepare_retry_attempt(step_config)
+          result = yield
+          handled_result = handle_retry_result(step_config, reactor_class, result)
+          return handled_result if handled_result
+        end
+      end
+
+      private
+
+      def can_retry_step?(step_config)
+        step_config.retryable? && @context.retry_context.can_retry_step?(step_config.name,
+                                                                         step_config.retry_config[:max_attempts])
+      end
+
+      def calculate_backoff_delay(step_config, _error, reactor_class)
+        attempt_number = @context.retry_context.attempts_for_step(step_config.name)
+        backoff_strategy = step_config.retry_config[:backoff] || reactor_class.retry_defaults[:backoff]
+        base_delay = step_config.retry_config[:base_delay] || reactor_class.retry_defaults[:base_delay]
+
+        delay = RetryContext.calculate_backoff_delay(attempt_number, backoff_strategy, base_delay)
+        @context.retry_context.next_retry_at = Time.now + delay
+        delay
+      end
+
+      def requeue_job_for_step_retry(step_config, error, reactor_class)
+        delay = calculate_backoff_delay(step_config, error, reactor_class)
+
+        # Serialize context and requeue the job
+        # Use root context if available to ensure we serialize the full tree
+        context_to_serialize = @context.root_context || @context
+        reactor_class_name = context_to_serialize.reactor_class.name
+
+        serialized_context = ContextSerializer.serialize(context_to_serialize)
+
+        if @context.map_metadata
+          map_args = @context.map_metadata.transform_keys(&:to_sym)
+          configuration.async_router.perform_map_element_in(
+            delay,
+            map_id: map_args[:map_id],
+            element_id: map_args[:element_id],
+            index: map_args[:index],
+            serialized_inputs: map_args[:serialized_inputs],
+            reactor_class_info: map_args[:reactor_class_info],
+            strict_ordering: map_args[:strict_ordering],
+            parent_context_id: map_args[:parent_context_id],
+            parent_reactor_class_name: map_args[:parent_reactor_class_name],
+            step_name: map_args[:step_name],
+            batch_size: map_args[:batch_size],
+            serialized_context: serialized_context
+          )
+        else
+          configuration.async_router.perform_in(delay, serialized_context, reactor_class_name)
+        end
+      end
+
+      def clear_retry_state
+        @context.retry_context.current_step = nil
+        @context.retry_context.failure_reason = nil
+        @context.retry_context.next_retry_at = nil
+      end
+
+      def prepare_retry_attempt(step_config)
+        @context.retry_context.current_step = step_config.name
+        @context.retry_context.increment_attempt_for_step(step_config.name)
+      end
+
+      def handle_retry_result(step_config, reactor_class, result)
+        case result
+        when RubyReactor::Success
+          clear_retry_state
+          result
+        when RubyReactor::Failure
+          handle_failure_result(step_config, reactor_class, result)
+        when RetryQueuedResult, RubyReactor::AsyncResult
+          # Pass through async results
+          result
+        else
+          clear_retry_state
+          RubyReactor::Failure("Step '#{step_config.name}' returned unexpected result: #{result.inspect}")
+        end
+      end
+
+      def handle_failure_result(step_config, reactor_class, result)
+        if can_retry_step?(step_config) && result.retryable?
+          handle_retryable_failure(step_config, reactor_class, result)
+        else
+          handle_non_retryable_failure(step_config, result, reactor_class)
+        end
+      end
+
+      def handle_retryable_failure(step_config, reactor_class, result)
+        # Check if we should requeue (async retry)
+        is_async = reactor_class.async? || step_config.async? ||
+                   @context.root_context&.reactor_class&.async? ||
+                   @context.inline_async_execution
+
+        if is_async && !@context.test_mode
+          handle_async_retry(step_config, reactor_class, result)
+        else
+          handle_sync_retry(step_config, reactor_class, result)
+        end
+      end
+
+      def handle_async_retry(step_config, reactor_class, result)
+        requeue_job_for_step_retry(step_config, result.error, reactor_class)
+        RetryQueuedResult.new(
+          step_config.name,
+          @context.retry_context.attempts_for_step(step_config.name),
+          @context.retry_context.next_retry_at
+        )
+      end
+
+      def handle_sync_retry(step_config, reactor_class, result)
+        delay = calculate_backoff_delay(step_config, result.error, reactor_class)
+        sleep(delay)
+        nil # continue loop
+      end
+
+      def handle_non_retryable_failure(step_config, result, reactor_class)
+        clear_retry_state
+        current_attempts = @context.retry_context.attempts_for_step(step_config.name)
+        error_message = result.error.respond_to?(:message) ? result.error.message : result.error.to_s
+        MaxRetriesExhaustedFailure.new(
+          "Step '#{step_config.name}' failed after #{current_attempts} attempts: #{error_message}",
+          step: step_config.name,
+          attempts: current_attempts,
+          original_error: result.error,
+          inputs: result.respond_to?(:inputs) ? result.inputs : {},
+          backtrace: result.respond_to?(:backtrace) ? result.backtrace : nil,
+          redact_inputs: if result.respond_to?(:instance_variable_get)
+                           result.instance_variable_get(:@redact_inputs)
+                         else
+                           []
+                         end,
+          reactor_name: reactor_class.name,
+          step_arguments: result.respond_to?(:step_arguments) ? result.step_arguments : {}
+        )
+      end
+
+      def configuration
+        RubyReactor::Configuration.instance
+      end
+    end
+  end
+end

data/lib/ruby_reactor/executor/step_executor.rb

@@ -0,0 +1,319 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  class Executor
+    class StepExecutor
+      def initialize(context:, dependency_graph:, reactor_class:, managers:)
+        @context = context
+        @dependency_graph = dependency_graph
+        @reactor_class = reactor_class
+        @retry_manager = managers[:retry_manager]
+        @result_handler = managers[:result_handler]
+        @compensation_manager = managers[:compensation_manager]
+      end
+
+      def execute_all_steps
+        until @dependency_graph.all_completed?
+          ready_steps = @dependency_graph.ready_steps
+
+          if ready_steps.empty?
+            raise Error::DependencyError.new(
+              "No ready steps available but execution not complete",
+              context: @context
+            )
+          end
+
+          # Execute steps sequentially
+          ready_steps.each do |step_config|
+            result = execute_step(step_config)
+
+            # If step execution was handed off to async, return the async result
+            return result if result.is_a?(RubyReactor::AsyncResult)
+
+            # If a step returns RetryQueuedResult, we need to stop and return it
+            return result if result.is_a?(RetryQueuedResult)
+
+            # If a step returns Failure, we need to stop execution and return it
+            return result if result.is_a?(RubyReactor::Failure)
+
+            # If result is nil, it means async was executed inline (test mode), continue
+            next if result.nil?
+          end
+        end
+
+        # Return the final result
+        @result_handler.final_result(@reactor_class)
+      end
+
+      def execute_step(step_config)
+        # If we're already in inline async execution mode (inside Worker),
+        # treat async steps as sync to avoid infinite recursion
+
+        if step_config.async? && !@context.inline_async_execution
+          handle_async_step(step_config)
+        else
+          execute_step_with_retry(step_config)
+        end
+      end
+
+      def merge_executor_state(other_executor)
+        # Merge the state from the async-executed executor back into ours
+        # We need to update our context IN PLACE, not replace the reference,
+        # because the Executor also holds a reference to the same context object
+
+        # Update intermediate results
+        other_executor.context.intermediate_results.each do |step_name, value|
+          @context.set_result(step_name, value)
+        end
+
+        # Append execution trace from the async execution
+        # The Worker's execution will have ALL steps including ones we already executed,
+        # but we only want to add the NEW entries (from current_step onwards)
+        current_trace_length = @context.execution_trace.length
+        new_trace_entries = other_executor.context.execution_trace[current_trace_length..] || []
+
+        @context.execution_trace.concat(new_trace_entries)
+
+        # Update retry context
+        @context.retry_context = other_executor.context.retry_context
+
+        # Clear current_step since we've completed it
+        @context.current_step = nil
+
+        # Update our dependency graph to reflect completed steps
+        other_executor.context.intermediate_results.each_key do |step_name|
+          @dependency_graph.complete_step(step_name)
+        end
+
+        # Also mark the current_step as completed if it exists (for failed steps that don't have results)
+        @dependency_graph.complete_step(other_executor.context.current_step) if other_executor.context.current_step
+
+        # Merge any undo stack items
+        other_executor.undo_stack.each do |item|
+          # Avoid duplicates by checking if this step is already in the undo stack
+          unless @compensation_manager.undo_stack.any? { |existing| existing[:step].name == item[:step].name }
+            @compensation_manager.add_to_undo_stack(item)
+          end
+        end
+
+        # Merge undo trace from the other executor
+        other_executor.undo_trace.each do |trace_entry|
+          @compensation_manager.undo_trace << trace_entry
+        end
+      end
+
+      def execute_step_with_retry(step_config)
+        result = @retry_manager.execute_with_retry(step_config, @reactor_class) do
+          safe_execute_step_sync(step_config)
+        end
+
+        unless result.is_a?(RetryQueuedResult) || result.is_a?(RubyReactor::AsyncResult)
+          resolved_arguments = resolve_arguments(step_config)
+          @result_handler.handle_step_result(step_config, result, resolved_arguments)
+        end
+
+        result
+      end
+
+      def safe_execute_step_sync(step_config)
+        resolved_arguments = {}
+        execute_step_sync_without_result_handling(step_config) do |args|
+          resolved_arguments = args
+        end
+      rescue StandardError => e
+        # Identify redacted inputs
+        redact_inputs = @reactor_class.inputs.select { |_, config| config[:redact] }.keys
+
+        RubyReactor::Failure(
+          e,
+          step_name: step_config.name,
+          inputs: @context.inputs,
+          redact_inputs: redact_inputs,
+          reactor_name: @reactor_class.name,
+          step_arguments: resolved_arguments
+        )
+      end
+
+      def execute_step_sync(step_config)
+        @context.with_step(step_config.name) do
+          # Check conditions and guards
+          unless step_config.should_run?(@context)
+            @dependency_graph.complete_step(step_config.name)
+            return RubyReactor.Success(nil)
+          end
+
+          # Resolve arguments
+          resolved_arguments = resolve_arguments(step_config)
+
+          # Validate arguments if validator is defined
+          validate_step_arguments(step_config, resolved_arguments)
+
+          # Execute the step
+          result = run_step_implementation(step_config, resolved_arguments)
+
+          # Handle the result
+          @result_handler.handle_step_result(step_config, result, resolved_arguments)
+        end
+      end
+
+      # Execute step without handling the result (used during retries)
+      def execute_step_sync_without_result_handling(step_config)
+        @context.with_step(step_config.name) do
+          # Check conditions and guards
+          unless step_config.should_run?(@context)
+            @dependency_graph.complete_step(step_config.name)
+            return RubyReactor.Success(nil)
+          end
+
+          # Resolve arguments
+          resolved_arguments = resolve_arguments(step_config)
+
+          yield resolved_arguments if block_given?
+
+          # Validate arguments if validator is defined
+          validate_step_arguments(step_config, resolved_arguments)
+
+          # Execute the step
+          run_step_implementation(step_config, resolved_arguments)
+        end
+      end
+
+      private
+
+      def handle_async_step(step_config)
+        # Step-level async: hand off execution to worker
+
+        @context.current_step = step_config.name
+        @context.undo_stack = @compensation_manager.undo_stack
+
+        # Use root context if available to ensure we serialize the full tree
+        context_to_serialize = @context.root_context || @context
+        reactor_class_name = context_to_serialize.reactor_class.name
+
+        serialized_context = ContextSerializer.serialize(context_to_serialize)
+
+        result = configuration.async_router.perform_async(
+          serialized_context,
+          reactor_class_name,
+          intermediate_results: @context.intermediate_results
+        )
+
+        # Handle different result types from async router
+        case result
+        when RubyReactor::AsyncResult
+          # Production behavior: return async result to caller
+
+          result
+        when Executor
+          handle_inline_executor_result(result)
+        else
+          # Unexpected result type, treat as error
+          raise Error::ValidationError.new(
+            "Unexpected result type from async router: #{result.class}",
+            context: @context
+          )
+        end
+      end
+
+      def handle_inline_executor_result(result)
+        # Worker executed inline and returned an executor.
+        # This happens when running in test mode or when perform_async returns an executor.
+        # We need to merge the state back into our current executor.
+        #
+        # If we are a child reactor, the worker executed the root reactor, so the result
+        # will be a Root executor. We handle this mismatch below by finding our
+        # corresponding child context within the root result.
+        if @context.root_context && (result.context.reactor_class != @reactor_class)
+          # We are a child, and result is root.
+          # We need to find ourselves in the root result using context_id.
+          matching_context = find_context_by_id(result.context, @context.context_id)
+
+          if matching_context
+            # Replace the result's context with the matching child context
+            # so merge_executor_state works correctly
+            result.instance_variable_set(:@context, matching_context)
+          else
+            # Fallback: if we can't find it (shouldn't happen), we might be in trouble.
+            # But let's try to proceed, maybe it's not nested?
+            # For now, raise an error to be explicit
+            raise Error::ValidationError.new(
+              "Could not find child context with ID #{@context.context_id} in root result",
+              context: @context
+            )
+          end
+        end
+
+        merge_executor_state(result)
+
+        result.result
+      end
+
+      def configuration
+        RubyReactor::Configuration.instance
+      end
+
+      def validate_step_arguments(step_config, resolved_arguments)
+        return unless step_config.args_validator
+
+        validation_result = step_config.args_validator.call(resolved_arguments)
+        return if validation_result.success?
+
+        raise Error::StepFailureError.new(
+          "Step '#{step_config.name}' argument validation failed: #{validation_result.error.message}",
+          step: step_config.name,
+          context: @context
+        )
+      end
+
+      def resolve_arguments(step_config)
+        resolved = {}
+
+        step_config.arguments.each do |arg_name, arg_config|
+          source = arg_config[:source]
+          transform = arg_config[:transform]
+
+          value = source.resolve(@context)
+          value = transform.call(value) if transform
+
+          resolved[arg_name] = value
+        end
+
+        resolved
+      end
+
+      def run_step_implementation(step_config, arguments)
+        @context.execution_trace << { type: :run, step: step_config.name, timestamp: Time.now, arguments: arguments }
+        if step_config.has_run_block?
+          # Execute inline block
+          # If no arguments are defined for the step, pass the reactor inputs as arguments
+          args_to_pass = arguments.empty? ? @context.inputs : arguments
+          step_config.run_block.call(args_to_pass, @context)
+        elsif step_config.has_impl?
+          # Execute step class
+          step_config.impl.run(arguments, @context)
+        else
+          raise Error::ValidationError.new(
+            "Step '#{step_config.name}' has no implementation",
+            step: step_config.name,
+            context: @context
+          )
+        end
+      end
+
+      def find_context_by_id(root_context, target_id)
+        return root_context if root_context.context_id == target_id
+
+        # Search in composed contexts
+        root_context.composed_contexts.each_value do |composed_data|
+          # composed_data is a hash with :context key
+          next unless composed_data.is_a?(Hash) && composed_data[:context].is_a?(RubyReactor::Context)
+
+          found = find_context_by_id(composed_data[:context], target_id)
+          return found if found
+        end
+
+        nil
+      end
+    end
+  end
+end