ruby_reactor 0.3.0 → 0.3.1

data/lib/ruby_reactor/map/element_executor.rb

@@ -5,151 +5,137 @@ module RubyReactor
     class ElementExecutor
       extend Helpers
 
-      # rubocop:disable Metrics/MethodLength
       def self.perform(arguments)
         arguments = arguments.transform_keys(&:to_sym)
-        map_id = arguments[:map_id]
-        _element_id = arguments[:element_id]
-        index = arguments[:index]
-        serialized_inputs = arguments[:serialized_inputs]
-        reactor_class_info = arguments[:reactor_class_info]
-        strict_ordering = arguments[:strict_ordering]
-        parent_context_id = arguments[:parent_context_id]
-        parent_reactor_class_name = arguments[:parent_reactor_class_name]
-        step_name = arguments[:step_name]
-        batch_size = arguments[:batch_size]
-        # rubocop:enable Metrics/MethodLength
-        serialized_context = arguments[:serialized_context]
 
-        if serialized_context
-          context = ContextSerializer.deserialize(serialized_context)
+        context = hydrate_or_create_context(arguments)
+        storage = RubyReactor.configuration.storage_adapter
+        storage.store_map_element_context_id(arguments[:map_id], context.context_id,
+                                             arguments[:parent_reactor_class_name])
+
+        return if check_fail_fast?(arguments, storage)
+
+        executor = Executor.new(context.reactor_class, {}, context)
+        arguments[:serialized_context] ? executor.resume_execution : executor.execute
+
+        handle_result(executor.result, arguments, context, storage, executor)
+        finalize_execution(arguments, storage)
+      end
+
+      def self.load_parent_context(arguments, reactor_class_name, storage)
+        parent_context_data = storage.retrieve_context(arguments[:parent_context_id], reactor_class_name)
+        parent_reactor_class = Object.const_get(reactor_class_name)
+        parent_context = Context.new(
+          ContextSerializer.deserialize_value(parent_context_data["inputs"]),
+          parent_reactor_class
+        )
+        parent_context.context_id = arguments[:parent_context_id]
+        parent_context
+      end
+
+      # Legacy helpers resolved_next_element, build_serialized_inputs, queue_element_job
+      # are REMOVED as they are no longer used for self-queuing.
+
+      # Basic helper to build inputs for the CURRENT element (still needed for perform)
+      # Wait, perform uses `serialized_inputs` passed to it.
+      # We don't need `build_element_inputs` here?
+      # `perform` uses `params[:serialized_inputs]`.
+      # So we can remove input building helpers too?
+      # Let's check if they are used elsewhere.
+      # `resolve_reactor_class` is used in `perform`.
+      # `build_element_inputs` is likely in Helpers or mixed in?
+
+      # rubocop:disable Style/IdenticalConditionalBranches
+      def self.hydrate_or_create_context(arguments)
+        if arguments[:serialized_context]
+          context = ContextSerializer.deserialize(arguments[:serialized_context])
           context.map_metadata = arguments
-          reactor_class = context.reactor_class
 
-          # Ensure inputs are present (fallback to serialized_inputs if missing from context)
-          if context.inputs.empty? && serialized_inputs
-            context.inputs = ContextSerializer.deserialize_value(serialized_inputs)
+          if context.inputs.empty? && arguments[:serialized_inputs]
+            context.inputs = ContextSerializer.deserialize_value(arguments[:serialized_inputs])
           end
+          context
         else
-          # Deserialize inputs
-          inputs = ContextSerializer.deserialize_value(serialized_inputs)
-
-          # Resolve reactor class
-          reactor_class = resolve_reactor_class(reactor_class_info)
+          inputs = ContextSerializer.deserialize_value(arguments[:serialized_inputs])
+          reactor_class = resolve_reactor_class(arguments[:reactor_class_info])
 
-          # Create context
           context = Context.new(inputs, reactor_class)
-          context.parent_context_id = parent_context_id
+          context.parent_context_id = arguments[:parent_context_id]
           context.map_metadata = arguments
+          context
         end
+      end
+      # rubocop:enable Style/IdenticalConditionalBranches
 
-        storage = RubyReactor.configuration.storage_adapter
-        storage.store_map_element_context_id(map_id, context.context_id, parent_reactor_class_name)
-
-        # Fail Fast Check
-        if arguments[:fail_fast]
-          failed_context_id = storage.retrieve_map_failed_context_id(map_id, parent_reactor_class_name)
-          if failed_context_id
-            # Decrement counter as we are skipping execution
-            new_count = storage.decrement_map_counter(map_id, parent_reactor_class_name)
-            return unless new_count.zero?
+      def self.check_fail_fast?(arguments, storage)
+        return false unless arguments[:fail_fast]
 
-            # Trigger collection if we are the last one (skipped or otherwise)
-            RubyReactor.configuration.async_router.perform_map_collection_async(
-              parent_context_id: parent_context_id,
-              map_id: map_id,
-              parent_reactor_class_name: parent_reactor_class_name,
-              step_name: step_name,
-              strict_ordering: strict_ordering,
-              timeout: 3600
-            )
-            return
-          end
-        end
-
-        # Execute
-        executor = Executor.new(reactor_class, {}, context)
+        map_id = arguments[:map_id]
+        parent_reactor_class_name = arguments[:parent_reactor_class_name]
 
-        if serialized_context
-          executor.resume_execution
-        else
-          executor.execute
-        end
+        failed_context_id = storage.retrieve_map_failed_context_id(map_id, parent_reactor_class_name)
+        return false unless failed_context_id
 
-        result = executor.result
+        # Skip execution
+        finalize_execution(arguments, storage)
+        true
+      end
 
-        if result.is_a?(RetryQueuedResult)
-          trigger_next_batch_if_needed(arguments, index, batch_size)
-          return
-        end
+      def self.handle_result(result, arguments, context, storage, executor)
+        return if result.is_a?(RetryQueuedResult)
 
-        # Store result
+        map_id = arguments[:map_id]
+        index = arguments[:index]
+        parent_class = arguments[:parent_reactor_class_name] # Using short name for variable
 
         if result.success?
-          storage.store_map_result(map_id, index,
-                                   ContextSerializer.serialize_value(result.value),
-                                   parent_reactor_class_name,
-                                   strict_ordering: strict_ordering)
+          storage.store_map_result(map_id, index, ContextSerializer.serialize_value(result.value),
+                                   parent_class, strict_ordering: arguments[:strict_ordering])
         else
-          # Trigger Compensation Logic
           executor.undo_all
-
-          # Store error
-          storage.store_map_result(map_id, index, { _error: result.error }, parent_reactor_class_name,
-                                   strict_ordering: strict_ordering)
+          storage.store_map_result(map_id, index, { _error: result.error }, parent_class,
+                                   strict_ordering: arguments[:strict_ordering])
 
           if arguments[:fail_fast]
-            storage.store_map_failed_context_id(map_id, context.context_id, parent_reactor_class_name)
+            storage.store_map_failed_context_id(map_id, context.context_id, parent_class)
+            # FAST FAIL: Trigger Collector immediately to cancel/fail the map execution
+            RubyReactor.configuration.async_router.perform_map_collection_async(
+              parent_context_id: arguments[:parent_context_id],
+              map_id: map_id,
+              parent_reactor_class_name: parent_class,
+              step_name: arguments[:step_name],
+              strict_ordering: arguments[:strict_ordering],
+              timeout: 3600
+            )
           end
         end
+      end
 
-        # Decrement counter
-        new_count = storage.decrement_map_counter(map_id, parent_reactor_class_name)
+      def self.finalize_execution(arguments, storage)
+        map_id = arguments[:map_id]
+        parent_class = arguments[:parent_reactor_class_name]
 
-        # Trigger next batch if it's the last element of the current batch
-        trigger_next_batch_if_needed(arguments, index, batch_size)
+        new_count = storage.decrement_map_counter(map_id, parent_class)
+        trigger_next_batch_if_needed(arguments, arguments[:index], arguments[:batch_size])
 
         return unless new_count.zero?
 
-        # Trigger collection
         RubyReactor.configuration.async_router.perform_map_collection_async(
-          parent_context_id: parent_context_id,
+          parent_context_id: arguments[:parent_context_id],
           map_id: map_id,
-          parent_reactor_class_name: parent_reactor_class_name,
-          step_name: step_name,
-          strict_ordering: strict_ordering,
+          parent_reactor_class_name: parent_class,
+          step_name: arguments[:step_name],
+          strict_ordering: arguments[:strict_ordering],
           timeout: 3600
         )
       end
 
-      def self.load_parent_context(arguments, reactor_class_name, storage)
-        parent_context_data = storage.retrieve_context(arguments[:parent_context_id], reactor_class_name)
-        parent_reactor_class = Object.const_get(reactor_class_name)
-        parent_context = Context.new(
-          ContextSerializer.deserialize_value(parent_context_data["inputs"]),
-          parent_reactor_class
-        )
-        parent_context.context_id = arguments[:parent_context_id]
-        parent_context
-      end
-
-      # Legacy helpers resolved_next_element, build_serialized_inputs, queue_element_job
-      # are REMOVED as they are no longer used for self-queuing.
-
-      # Basic helper to build inputs for the CURRENT element (still needed for perform)
-      # Wait, perform uses `serialized_inputs` passed to it.
-      # We don't need `build_element_inputs` here?
-      # `perform` uses `params[:serialized_inputs]`.
-      # So we can remove input building helpers too?
-      # Let's check if they are used elsewhere.
-      # `resolve_reactor_class` is used in `perform`.
-      # `build_element_inputs` is likely in Helpers or mixed in?
-
       def self.trigger_next_batch_if_needed(arguments, index, batch_size)
         return unless batch_size && ((index + 1) % batch_size).zero?
 
         # Trigger Dispatcher for next batch
         next_batch_args = arguments.dup
+        # Ensure we don't carry over temporary execution flags if any
         next_batch_args[:continuation] = true
         RubyReactor::Map::Dispatcher.perform(next_batch_args)
       end

data/lib/ruby_reactor/map/execution.rb

@@ -31,6 +31,7 @@ module RubyReactor
       end
 
       def self.execute_all_elements(source:, mappings:, reactor_class:, parent_context:, storage_options:)
+        # rubocop:disable Metrics/BlockLength
         source.map.with_index do |element, index|
           if storage_options[:fail_fast]
             failed_context_id = storage_options[:storage].retrieve_map_failed_context_id(
@@ -71,12 +72,12 @@ module RubyReactor
 
           result
         end.compact
+        # rubocop:enable Metrics/BlockLength
       end
 
       def self.link_contexts(child_context, parent_context)
         child_context.parent_context = parent_context
         child_context.root_context = parent_context.root_context || parent_context
-        child_context.test_mode = parent_context.test_mode
         child_context.inline_async_execution = parent_context.inline_async_execution
       end
 

data/lib/ruby_reactor/map/helpers.rb

@@ -63,7 +63,8 @@ module RubyReactor
             final_result.error,
             step: step_name_sym,
             context: parent_context,
-            original_error: final_result.error.is_a?(Exception) ? final_result.error : nil
+            original_error: final_result.error.is_a?(Exception) ? final_result.error : nil,
+            exception_class: final_result.respond_to?(:exception_class) ? final_result.exception_class : nil
           )
 
           # Pass backtrace if available

data/lib/ruby_reactor/map/result_enumerator.rb

@@ -60,7 +60,7 @@ module RubyReactor
       end
 
       def [](index)
-        return nil if index < 0 || index >= count
+        return nil if index.negative? || index >= count
 
         results = @storage.retrieve_map_results_batch(
           @map_id,

data/lib/ruby_reactor/reactor.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module RubyReactor
+  # rubocop:disable Metrics/ClassLength
   class Reactor
     include RubyReactor::Dsl::Reactor
 
@@ -64,34 +65,71 @@ module RubyReactor
     def initialize(context = {})
       @context = context
       @result = :unexecuted
-      @undo_trace = []
-      @execution_trace = []
+
+      if @context.is_a?(Context)
+        @execution_trace = @context.execution_trace || []
+        @undo_trace = @execution_trace.select { |e| e[:type] == :undo }
+        @result = reconstruct_result
+      else
+        @undo_trace = []
+        @execution_trace = []
+      end
     end
 
+    # rubocop:disable Metrics/MethodLength
     def run(inputs = {})
-      if self.class.async?
-        # For async reactors, enqueue the job and return immediately
-        context = Context.new(inputs, self.class)
-        serialized_context = ContextSerializer.serialize(context)
-        configuration.async_router.perform_async(serialized_context)
+      # For all reactors, initialize context first to capture execution ID
+      @context = @context.is_a?(Context) ? @context : Context.new(inputs, self.class)
+
+      # Validate inputs
+      validation_result = self.class.validate_inputs(inputs)
+      if validation_result.failure?
+        @result = validation_result
+        @context.status = "failed"
+        @context.failure_reason = {
+          message: validation_result.error.message,
+          validation_errors: validation_result.error.field_errors
+        }
+        save_context
+        return validation_result
+      end
+
+      if self.class.async? && !@context.inline_async_execution
+        # For async reactors, queue a job for the whole reactor
+        @context.status = :running
+        save_context
+
+        serialized_context = ContextSerializer.serialize(@context)
+        @result = configuration.async_router.perform_async(serialized_context, self.class.name,
+                                                           intermediate_results: @context.intermediate_results)
+
+        # Even if it's an AsyncResult, it might have finished inline (e.g. Sidekiq::Testing.inline!)
+        # Check storage to see if it's already finished or paused (interrupted).
+        begin
+          reloaded = self.class.find(@context.context_id)
+          if reloaded.finished? || reloaded.context.status.to_s == "paused"
+            @context = reloaded.context
+            @result = reloaded.result
+            @execution_trace = reloaded.execution_trace
+            @undo_trace = reloaded.undo_trace
+            return @result
+          end
+        rescue StandardError
+          # Ignore if not found or other errors during reload check
+        end
+
       else
         # For sync reactors (potentially with async steps), execute normally
         context = @context.is_a?(Context) ? @context : nil
         executor = Executor.new(self.class, inputs, context)
         @result = executor.execute
-
         @context = executor.context
-
-        # Merge traces
-        @undo_trace = executor.undo_trace
         @execution_trace = executor.execution_trace
-
-        # If execution returned an AsyncResult (from step-level async), return it
-        return @result if @result.is_a?(RubyReactor::AsyncResult)
-
-        @result
+        @undo_trace = executor.undo_trace
       end
+      @result
     end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
     def continue(payload:, step_name:, idempotency_key: nil)
       _ = idempotency_key
@@ -178,6 +216,125 @@ module RubyReactor
       raise Error::DependencyError, "Dependency graph contains cycles"
     end
 
+    def reconstruct_result
+      case @context.status.to_s
+      when "completed" then reconstruct_success_result
+      when "failed" then reconstruct_failure_result
+      when "paused" then reconstruct_paused_result
+      else :unexecuted
+      end
+    end
+
+    def reconstruct_success_result
+      rs = self.class.respond_to?(:returns) ? self.class.returns : nil
+      val = if rs
+              @context.intermediate_results[rs.to_sym] || @context.intermediate_results[rs.to_s]
+            else
+              find_last_step_result
+            end
+      Success.new(val)
+    end
+
+    def find_last_step_result
+      last_run = @execution_trace.reverse.find { |e| e[:type] == :run || e["type"] == "run" }
+      return unless last_run
+
+      step_name = last_run[:step] || last_run["step"]
+      @context.intermediate_results[step_name.to_sym] || @context.intermediate_results[step_name.to_s]
+    end
+
+    def reconstruct_failure_result
+      reason = @context.failure_reason || {}
+      return reason if reason.is_a?(RubyReactor::Failure)
+
+      # Use string keys preferred, fallback to symbol
+      r = ->(k) { reason[k.to_s] || reason[k.to_sym] }
+
+      Failure.new(
+        r[:message],
+        step_name: r[:step_name],
+        inputs: r[:inputs] || {},
+        backtrace: r[:backtrace],
+        reactor_name: r[:reactor_name],
+        step_arguments: r[:step_arguments] || {},
+        exception_class: r[:exception_class],
+        file_path: r[:file_path],
+        line_number: r[:line_number],
+        code_snippet: r[:code_snippet],
+        validation_errors: r[:validation_errors],
+        retryable: r[:retryable],
+        invalid_payload: r[:invalid_payload]
+      )
+    end
+
+    def reconstruct_paused_result
+      InterruptResult.new(
+        execution_id: @context.context_id,
+        intermediate_results: @context.intermediate_results
+      )
+    end
+
+    def initialize_and_validate_run?(inputs)
+      # For all reactors, initialize context first to capture execution ID
+      @context = @context.is_a?(Context) ? @context : Context.new(inputs, self.class)
+
+      validation_result = self.class.validate_inputs(inputs)
+      if validation_result.failure?
+        handle_validation_failure(validation_result)
+        return false
+      end
+      true
+    end
+
+    def handle_validation_failure(result)
+      @result = result
+      @context.status = "failed"
+      @context.failure_reason = {
+        message: result.error.message,
+        validation_errors: result.error.field_errors
+      }
+      save_context
+    end
+
+    def perform_async_run
+      @context.status = :running
+      save_context
+
+      serialized_context = ContextSerializer.serialize(@context)
+      @result = configuration.async_router.perform_async(serialized_context, self.class.name,
+                                                         intermediate_results: @context.intermediate_results)
+
+      check_for_inline_completion
+    end
+
+    def check_for_inline_completion
+      # Even if it's an AsyncResult, it might have finished inline (e.g. Sidekiq::Testing.inline!)
+      # Check storage to see if it's already finished or paused (interrupted).
+      reloaded = self.class.find(@context.context_id)
+      if reloaded.finished? || reloaded.context.status.to_s == "paused"
+        update_state_from_reloaded(reloaded)
+        @result
+      end
+    rescue StandardError
+      # Ignore if not found or other errors during reload check
+    end
+
+    def update_state_from_reloaded(reloaded)
+      @context = reloaded.context
+      @result = reloaded.result
+      @execution_trace = reloaded.execution_trace
+      @undo_trace = reloaded.undo_trace
+    end
+
+    def perform_sync_run(inputs)
+      context = @context.is_a?(Context) ? @context : nil
+      executor = Executor.new(self.class, inputs, context)
+      @result = executor.execute
+      @context = executor.context
+      @execution_trace = executor.execution_trace
+      @undo_trace = executor.undo_trace
+    end
+
     def validate_continue_step!(step_name)
       return if step_name.to_s == @context.current_step.to_s
 
@@ -258,4 +415,5 @@ module RubyReactor
       storage.store_context(@context.context_id, serialized_context, reactor_class_name)
     end
   end
+  # rubocop:enable Metrics/ClassLength
 end

data/lib/ruby_reactor/rspec/helpers.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module RSpec
+    module Helpers
+      def test_reactor(reactor_class, inputs, context: {}, async: nil, process_jobs: true)
+        TestSubject.new(
+          reactor_class: reactor_class,
+          inputs: inputs,
+          context: context,
+          async: async,
+          process_jobs: process_jobs
+        )
+      end
+    end
+  end
+end