ruby_reactor 0.1.0 → 0.2.0

data/lib/ruby_reactor/executor/step_executor.rb

@@ -36,6 +36,9 @@ module RubyReactor
             # If a step returns Failure, we need to stop execution and return it
             return result if result.is_a?(RubyReactor::Failure)
 
+            # If a step returns InterruptResult, we need to stop execution and return it
+            return result if result.is_a?(RubyReactor::InterruptResult)
+
             # If result is nil, it means async was executed inline (test mode), continue
             next if result.nil?
           end
@@ -49,7 +52,13 @@ module RubyReactor
         # 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
+        if @dependency_graph.completed.include?(step_config.name)
+          return RubyReactor.Success(@context.get_result(step_config.name))
+        end
+
+        if step_config.interrupt?
+          handle_interrupt_step(step_config)
+        elsif step_config.async? && !@context.inline_async_execution
           handle_async_step(step_config)
         else
           execute_step_with_retry(step_config)
@@ -77,8 +86,10 @@ module RubyReactor
         # Update retry context
         @context.retry_context = other_executor.context.retry_context
 
-        # Clear current_step since we've completed it
-        @context.current_step = nil
+        # Update current_step:
+        # If the other executor has a current_step, it means it paused/interrupted there. We should adopt it.
+        # If it's nil, it means it completed successfully, so we clear our current_step (which was the async step).
+        @context.current_step = other_executor.context.current_step
 
         # Update our dependency graph to reflect completed steps
         other_executor.context.intermediate_results.each_key do |step_name|
@@ -91,7 +102,8 @@ module RubyReactor
         # 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 }
+          # Use string comparison for step names to avoid symbol/string mismatch issues
+          unless @compensation_manager.undo_stack.any? { |existing| existing[:step].name.to_s == item[:step].name.to_s }
             @compensation_manager.add_to_undo_stack(item)
           end
         end
@@ -248,6 +260,28 @@ module RubyReactor
         result.result
       end
 
+      def handle_interrupt_step(step_config)
+        # Check if we have a result for this step (resuming)
+        if @context.intermediate_results.key?(step_config.name)
+          # We are resuming
+          result = @context.get_result(step_config.name)
+          return RubyReactor.Success(result)
+        end
+
+        # We are pausing
+        correlation_id = nil
+        correlation_id = step_config.correlation_id_block.call(@context) if step_config.correlation_id_block
+
+        # Store current step as the one we are paused at
+        @context.current_step = step_config.name
+
+        RubyReactor::InterruptResult.new(
+          execution_id: @context.context_id,
+          correlation_id: correlation_id,
+          intermediate_results: @context.intermediate_results
+        )
+      end
+
       def configuration
         RubyReactor::Configuration.instance
       end

data/lib/ruby_reactor/executor.rb

@@ -40,24 +40,49 @@ module RubyReactor
       input_validator = InputValidator.new(@reactor_class, @context)
       input_validator.validate!
 
+      save_context
+
       graph_manager = GraphManager.new(@reactor_class, @dependency_graph, @context)
       graph_manager.build_and_validate!
+      graph_manager.mark_completed_steps_from_context
 
       @result = @step_executor.execute_all_steps
+      update_context_status(@result)
+      handle_interrupt(@result) if @result.is_a?(RubyReactor::InterruptResult)
+      @result
     rescue StandardError => e
       @result = @result_handler.handle_execution_error(e)
+      update_context_status(@result)
+      @result
+    ensure
+      save_context
     end
 
     def resume_execution
       prepare_for_resume
+      save_context
 
-      if @context.current_step
-        execute_current_step_and_continue
-      else
-        execute_remaining_steps
-      end
+      @result = if @context.current_step
+                  execute_current_step_and_continue
+                else
+                  execute_remaining_steps
+                end
+
+      update_context_status(@result)
+
+      handle_interrupt(@result) if @result.is_a?(RubyReactor::InterruptResult)
+
+      @result
     rescue StandardError => e
       handle_resume_error(e)
+      update_context_status(@result)
+      @result
+    ensure
+      save_context
+    end
+
+    def undo_all
+      @compensation_manager.rollback_completed_steps
     end
 
     def undo_stack
@@ -72,8 +97,45 @@ module RubyReactor
       @context.execution_trace
     end
 
+    def save_context
+      storage = RubyReactor::Configuration.instance.storage_adapter
+      reactor_class_name = @reactor_class.name || "AnonymousReactor-#{@reactor_class.object_id}"
+
+      # Serialize context
+      serialized_context = ContextSerializer.serialize(@context)
+      storage.store_context(@context.context_id, serialized_context, reactor_class_name)
+    end
+
     private
 
+    def update_context_status(result)
+      return unless result
+
+      case result
+      when RubyReactor::AsyncResult
+        @context.status = :running
+      when RubyReactor::Success
+        @context.status = :completed
+      when RubyReactor::Failure
+        @context.status = :failed
+        @context.failure_reason = {
+          message: result.error.is_a?(Exception) ? result.error.message : result.error.to_s,
+          step_name: result.step_name,
+          inputs: result.inputs,
+          backtrace: result.backtrace,
+          reactor_name: result.reactor_name,
+          step_arguments: result.step_arguments,
+          exception_class: result.exception_class,
+          file_path: result.file_path,
+          line_number: result.line_number,
+          code_snippet: result.code_snippet,
+          validation_errors: result.validation_errors
+        }
+      when RubyReactor::InterruptResult
+        @context.status = :paused
+      end
+    end
+
     def prepare_for_resume
       # Build dependency graph and mark completed steps
       graph_manager = GraphManager.new(@reactor_class, @dependency_graph, @context)
@@ -85,6 +147,9 @@ module RubyReactor
       step_config = @reactor_class.steps[@context.current_step]
       return RubyReactor::Failure("Step '#{@context.current_step}' not found in reactor") unless step_config
 
+      # If current step is already in intermediate_results, skip directly to execute_all_steps
+      return @step_executor.execute_all_steps if @context.intermediate_results.key?(@context.current_step.to_sym)
+
       # Use execute_step (not execute_step_with_retry) so that async steps can be handled properly in inline mode
       result = @step_executor.execute_step(step_config)
 
@@ -93,7 +158,7 @@ module RubyReactor
         @result = @step_executor.execute_all_steps
       else
         case result
-        when RetryQueuedResult, RubyReactor::Failure, RubyReactor::AsyncResult
+        when RetryQueuedResult, RubyReactor::Failure, RubyReactor::AsyncResult, RubyReactor::InterruptResult
           # Step was requeued, failed, or handed off to async - return the result
           @result = result
         when RubyReactor::Success
@@ -110,14 +175,22 @@ module RubyReactor
     end
 
     def handle_resume_error(error)
-      # Only handle errors that haven't already triggered compensation
-      # StepFailureError means compensation already happened, just convert to Failure
-      @result = if error.is_a?(Error::StepFailureError)
-                  RubyReactor.Failure(error.message)
-                else
-                  @result_handler.handle_execution_error(error)
-                end
+      @result = @result_handler.handle_execution_error(error)
       @result
     end
+
+    def handle_interrupt(interrupt_result)
+      save_context
+
+      # Store correlation ID mapping if present
+      return unless interrupt_result.correlation_id
+
+      storage = RubyReactor::Configuration.instance.storage_adapter
+      storage.store_correlation_id(
+        interrupt_result.correlation_id,
+        @context.context_id,
+        @reactor_class.name
+      )
+    end
   end
 end

data/lib/ruby_reactor/interrupt_result.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  class InterruptResult
+    attr_reader :execution_id, :correlation_id, :status, :timeout_at, :intermediate_results, :error
+
+    def initialize(execution_id:, correlation_id: nil, timeout_at: nil, intermediate_results: {}, error: nil)
+      @execution_id = execution_id
+      @correlation_id = correlation_id
+      @status = :paused
+      @timeout_at = timeout_at
+      @intermediate_results = intermediate_results
+      @error = error
+    end
+
+    def paused?
+      true
+    end
+  end
+end

data/lib/ruby_reactor/map/collector.rb

@@ -5,7 +5,6 @@ module RubyReactor
     class Collector
       extend Helpers
 
-      # rubocop:disable Metrics/MethodLength
       def self.perform(arguments)
         arguments = arguments.transform_keys(&:to_sym)
         parent_context_id = arguments[:parent_context_id]
@@ -59,7 +58,6 @@ module RubyReactor
         # Resume execution
         resume_parent_execution(parent_context, step_name, final_result, storage)
       end
-      # rubocop:enable Metrics/MethodLength
     end
   end
 end

data/lib/ruby_reactor/map/element_executor.rb

@@ -34,9 +34,12 @@ module RubyReactor
 
           # Create context
           context = Context.new(inputs, reactor_class)
+          context.parent_context_id = parent_context_id
           context.map_metadata = arguments
         end
+
         storage = RubyReactor.configuration.storage_adapter
+        storage.store_map_element_context_id(map_id, context.context_id, parent_reactor_class_name)
 
         # Execute
         executor = Executor.new(reactor_class, {}, context)

data/lib/ruby_reactor/map/execution.rb

@@ -32,7 +32,27 @@ module RubyReactor
       def self.execute_all_elements(source:, mappings:, reactor_class:, parent_context:, storage_options:)
         source.map.with_index do |element, index|
           element_inputs = build_element_inputs(mappings, parent_context, element)
-          result = reactor_class.run(element_inputs)
+
+          # Manually create and link context to ensure parent_context_id is set
+          child_context = RubyReactor::Context.new(element_inputs, reactor_class)
+          link_contexts(child_context, parent_context)
+
+          # Ensure we store the element context linkage
+          storage_options[:storage].store_map_element_context_id(
+            storage_options[:map_id], child_context.context_id, storage_options[:parent_reactor_class_name]
+          )
+
+          # Set map metadata for failure handling
+          metadata = {
+            map_id: storage_options[:map_id],
+            parent_reactor_class_name: storage_options[:parent_reactor_class_name],
+            index: index
+          }
+          child_context.map_metadata = metadata
+
+          executor = RubyReactor::Executor.new(reactor_class, {}, child_context)
+          executor.execute
+          result = executor.result
 
           store_result(result, index, storage_options)
 
@@ -40,6 +60,13 @@ module RubyReactor
         end
       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
+
       def self.store_result(result, index, options)
         value = result.success? ? result.value : { _error: result.error }
         options[:storage].store_map_result(

data/lib/ruby_reactor/map/helpers.rb

@@ -7,7 +7,11 @@ module RubyReactor
       # Resolves the reactor class from reactor_class_info
       def resolve_reactor_class(info)
         if info["type"] == "class"
-          Object.const_get(info["name"])
+          begin
+            Object.const_get(info["name"])
+          rescue NameError
+            RubyReactor::Registry.find(info["name"])
+          end
         elsif info["type"] == "inline"
           parent_class = Object.const_get(info["parent"])
           step_config = parent_class.steps[info["step"].to_sym]
@@ -49,12 +53,46 @@ module RubyReactor
 
       # Resumes parent reactor execution after map completion
       def resume_parent_execution(parent_context, step_name, final_result, storage)
-        value = final_result.success? ? final_result.value : final_result
-        parent_context.set_result(step_name.to_sym, value)
-        parent_context.current_step = nil
-
         executor = RubyReactor::Executor.new(parent_context.reactor_class, {}, parent_context)
-        executor.resume_execution
+
+        if final_result.failure?
+          step_name_sym = step_name.to_sym
+          parent_context.current_step = step_name_sym
+
+          error = RubyReactor::Error::StepFailureError.new(
+            final_result.error,
+            step: step_name_sym,
+            context: parent_context,
+            original_error: final_result.error.is_a?(Exception) ? final_result.error : nil
+          )
+
+          # Pass backtrace if available
+          if final_result.respond_to?(:backtrace) && final_result.backtrace
+            error.set_backtrace(final_result.backtrace)
+          elsif final_result.error.respond_to?(:backtrace)
+            error.set_backtrace(final_result.error.backtrace)
+          end
+
+          failure_response = executor.result_handler.handle_execution_error(error)
+          # Manually update context status since we're not running executor loop
+          executor.send(:update_context_status, failure_response)
+        else
+          parent_context.set_result(step_name.to_sym, final_result.value)
+
+          # Manually update execution trace to reflect completion
+          # This is necessary because resume_execution continues from the NEXT step
+          # and the async step (which returned AsyncResult) needs to be marked as done with actual value
+          parent_context.execution_trace << {
+            type: :result,
+            step: step_name_sym,
+            timestamp: Time.now,
+            value: final_result.value,
+            status: :success
+          }
+
+          parent_context.current_step = nil
+          executor.resume_execution
+        end
 
         storage.store_context(
           parent_context.context_id,

data/lib/ruby_reactor/reactor.rb

@@ -6,6 +6,61 @@ module RubyReactor
 
     attr_reader :context, :result, :undo_trace, :execution_trace
 
+    def self.find(id)
+      reactor_class_name = name
+      serialized_context = configuration.storage_adapter.retrieve_context(id, reactor_class_name)
+      raise Error::ValidationError, "Context '#{id}' not found" unless serialized_context
+
+      context = Context.deserialize_from_retry(serialized_context)
+      new(context)
+    end
+
+    def self.find_by_correlation_id(correlation_id)
+      reactor_class_name = name
+      context_id = configuration.storage_adapter.retrieve_context_id_by_correlation_id(
+        correlation_id,
+        reactor_class_name
+      )
+      raise Error::ValidationError, "Correlation ID '#{correlation_id}' not found" unless context_id
+
+      find(context_id)
+    end
+
+    def self.continue(id:, payload:, step_name:, idempotency_key: nil)
+      reactor = find(id)
+      result = reactor.continue(payload: payload, step_name: step_name, idempotency_key: idempotency_key)
+
+      if result.is_a?(RubyReactor::Failure) && result.respond_to?(:invalid_payload?) && result.invalid_payload?
+        # Raise exception to match expected behavior (strict mode for class method)
+        # We do NOT cancel the reactor, allowing the user to retry with valid payload
+        raise Error::InputValidationError, result.error
+      end
+
+      result
+    end
+
+    def self.continue_by_correlation_id(correlation_id:, payload:, step_name:, idempotency_key: nil)
+      reactor = find_by_correlation_id(correlation_id)
+      # We delegate to the class-level continue method to ensure auto-compensation logic applies
+      # by using the context ID found by find_by_correlation_id
+      continue(id: reactor.context.context_id, payload: payload, step_name: step_name, idempotency_key: idempotency_key)
+    end
+
+    def self.cancel(id:, reason:)
+      reactor = find(id)
+      reactor.cancel(reason)
+    end
+
+    def self.undo(id)
+      reactor = find(id)
+      reactor.undo
+      cancel(id: id, reason: "Undo triggered")
+    end
+
+    def self.configuration
+      RubyReactor::Configuration.instance
+    end
+
     def initialize(context = {})
       @context = context
       @result = :unexecuted
@@ -21,11 +76,13 @@ module RubyReactor
         configuration.async_router.perform_async(serialized_context)
       else
         # For sync reactors (potentially with async steps), execute normally
-        executor = Executor.new(self.class, inputs)
+        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
 
@@ -36,6 +93,55 @@ module RubyReactor
       end
     end
 
+    def continue(payload:, step_name:, idempotency_key: nil)
+      _ = idempotency_key
+
+      unless @context.current_step
+        raise Error::ValidationError, "Cannot resume: context does not have a current step (was it interrupted?)"
+      end
+
+      if @context.cancelled
+        raise Error::ValidationError,
+              "Cannot resume: reactor has been cancelled (Reason: #{@context.cancellation_reason})"
+      end
+
+      validate_continue_step!(step_name)
+
+      if (failure = validate_continue_payload(payload, step_name))
+        return failure
+      end
+
+      target_step = step_name
+      @context.set_result(target_step, payload)
+
+      # Resume execution
+      executor = Executor.new(self.class, {}, @context)
+      @result = executor.resume_execution
+
+      @context = executor.context
+      @undo_trace = executor.undo_trace
+      @execution_trace = executor.execution_trace
+
+      @result
+    rescue Error::InputValidationError => e
+      # This might catch other validations, but here we specifically want payload validation.
+      # The block above handles payload validation explicitly.
+      RubyReactor::Failure(e.message, invalid_payload: true)
+    end
+
+    def undo
+      executor = Executor.new(self.class, {}, @context)
+      executor.undo_all
+      executor.save_context
+    end
+
+    def cancel(reason)
+      @context.cancelled = true
+      @context.cancellation_reason = reason
+      @context.status = "cancelled"
+      save_context
+    end
+
     def validate!
       # Validate reactor configuration
       validate_steps!
@@ -71,5 +177,85 @@ module RubyReactor
 
       raise Error::DependencyError, "Dependency graph contains cycles"
     end
+
+    def validate_continue_step!(step_name)
+      return if step_name.to_s == @context.current_step.to_s
+
+      # Build graph to check if step is ready
+      graph_manager = Executor::GraphManager.new(self.class, DependencyGraph.new, @context)
+      graph_manager.build_and_validate!
+      graph_manager.mark_completed_steps_from_context
+      ready_steps = graph_manager.dependency_graph.ready_steps.map(&:name).map(&:to_s)
+
+      return if ready_steps.include?(step_name.to_s)
+
+      raise Error::ValidationError,
+            "Cannot resume: expected step '#{@context.current_step}' " \
+            "or ready steps #{ready_steps} but got '#{step_name}'"
+    end
+
+    def validate_continue_payload(payload, step_name)
+      step_config = self.class.steps[step_name.to_sym]
+      return unless step_config&.validation_schema
+
+      validation = step_config.validation_schema.call(payload)
+
+      return unless validation.failure?
+
+      # Track attempts
+      step_key = step_name.to_sym
+      @context.private_data[:interrupt_attempts] ||= {}
+      @context.private_data[:interrupt_attempts][step_key] ||= 0
+      @context.private_data[:interrupt_attempts][step_key] += 1
+
+      save_context # Persist the attempt count
+
+      current_attempts = @context.private_data[:interrupt_attempts][step_key]
+      max_attempts = step_config.max_attempts
+
+      if max_attempts != :infinity && current_attempts >= max_attempts
+        # Max attempts reached - Fail and Compensate
+        undo
+
+        # Instead of cancelling, we mark as failed so it shows up as failed in UI
+        @context.status = "failed"
+        @context.failure_reason = {
+          message: "Validation failed after #{max_attempts} attempts",
+          step_name: step_name,
+          errors: validation.errors.to_h,
+          payload: payload,
+          step_arguments: payload,
+          attempts: current_attempts,
+          validation_errors: validation.errors.to_h
+        }
+
+        save_context
+
+        return RubyReactor::Failure(
+          "Validation failed after #{max_attempts} attempts",
+          step_name: step_name,
+          step_arguments: payload,
+          validation_errors: validation.errors.to_h
+        )
+      end
+
+      failure = RubyReactor::Failure(validation.errors.to_h)
+      # We need a way to mark this failure as a validation failure
+      # For now, we rely on the error object inside Failure or just return Failure
+      # The PRD requires `result.invalid_payload?` to be true.
+      # Since we don't have that method on Failure yet, we might need to enhance Failure
+      # OR wrap it. For now, let's assume Failure wraps the error and we can check it.
+      # We'll use a specific error type to identify it.
+      failure.instance_variable_set(:@type, :input_validation)
+      def failure.invalid_payload? = true
+      failure
+    end
+
+    def save_context
+      storage = configuration.storage_adapter
+      reactor_class_name = self.class.name || "AnonymousReactor-#{self.class.object_id}"
+      serialized_context = ContextSerializer.serialize(@context)
+      storage.store_context(@context.context_id, serialized_context, reactor_class_name)
+    end
   end
 end

data/lib/ruby_reactor/registry.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "concurrent"
+
+module RubyReactor
+  # Registry for dynamically created reactor classes (e.g. from inline map/compose)
+  # This avoids polluting the global constant namespace with runtime-generated constants.
+  class Registry
+    @reactors = Concurrent::Map.new
+
+    class << self
+      def register(name, klass)
+        @reactors[name] = klass
+      end
+
+      def find(name)
+        @reactors[name]
+      end
+
+      def clear!
+        @reactors.clear
+      end
+    end
+  end
+end

data/lib/ruby_reactor/sidekiq_workers/worker.rb

@@ -37,8 +37,8 @@ module RubyReactor
 
         # Resume execution from the failed step
         executor = Executor.new(context.reactor_class, {}, context)
-        executor.compensation_manager.undo_stack.concat(context.undo_stack)
         executor.resume_execution
+        executor.save_context
 
         # Return the executor (which now has the result stored in it)
         executor

data/lib/ruby_reactor/step/compose_step.rb

@@ -29,12 +29,28 @@ module RubyReactor
         handle_execution_result(result)
       end
 
-      def self.compensate(_reason, _arguments, _context)
-        # TODO: Implement proper compensation for composed reactors
-        # This requires tracking the execution state of the composed reactor
-        # and being able to trigger compensation on its completed steps.
-        # For now, we assume the composed reactor handles its own compensation
-        # or that compensation is not needed for composed steps.
+      def self.compensate(_reason, arguments, context)
+        step_name = context.current_step
+        composed_data = context.composed_contexts[step_name]
+        return RubyReactor.Success() unless composed_data && composed_data[:context]
+
+        child_context = composed_data[:context]
+        executor = RubyReactor::Executor.new(arguments[:composed_reactor_class], {}, child_context)
+        executor.undo_all
+        executor.save_context
+
+        RubyReactor.Success()
+      end
+
+      def self.undo(_result, arguments, context)
+        step_name = context.current_step
+        composed_data = context.composed_contexts[step_name]
+        return RubyReactor.Success() unless composed_data && composed_data[:context]
+
+        child_context = composed_data[:context]
+        executor = RubyReactor::Executor.new(arguments[:composed_reactor_class], {}, child_context)
+        executor.undo_all
+        executor.save_context
 
         RubyReactor.Success()
       end