ruby_reactor 0.1.0 → 0.3.0

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

data/lib/ruby_reactor/step/map_step.rb

@@ -28,6 +28,9 @@ module RubyReactor
           inputs = {}
 
           mappings.each do |mapped_input_name, source|
+            # Handle serialized template objects (Hashes from Sidekiq)
+            source = ContextSerializer.deserialize_value(source) if source.is_a?(Hash) && source["_type"]
+
             value = if source.is_a?(RubyReactor::Template::Element)
                       # Handle element reference
                       # For now assuming element() refers to the current map's element
@@ -88,6 +91,25 @@ module RubyReactor
 
           link_contexts(child_context, context)
 
+          map_id = "#{context.context_id}:#{context.current_step}"
+          storage = RubyReactor.configuration.storage_adapter
+          storage.store_map_element_context_id(map_id, child_context.context_id, context.reactor_class.name)
+
+          # Set map metadata for failure handling
+          child_context.map_metadata = {
+            map_id: map_id,
+            parent_reactor_class_name: context.reactor_class.name,
+            index: nil # Inline map execution doesn't track index in metadata currently, but could
+          }
+
+          # Store reference in composed_contexts so the UI knows where to find elements
+          context.composed_contexts[context.current_step] = {
+            name: context.current_step,
+            type: :map_ref,
+            map_id: map_id,
+            element_reactor_class: arguments[:mapped_reactor_class].name
+          }
+
           executor = RubyReactor::Executor.new(arguments[:mapped_reactor_class], {}, child_context)
           executor.execute
           executor.result
@@ -114,8 +136,11 @@ module RubyReactor
             RubyReactor::Success(results)
           else
             # New behavior: extract successful values only
-            successes = results.select(&:success?).map(&:value)
-            RubyReactor::Success(successes)
+            # New behavior: extract successful values only IF fail_fast is true behavior implies only values
+            # However, if fail_fast is false, we want to return results as is, or if logic dictates otherwise.
+            # wait, if fail_fast=false, we expect Result objects so we can check if success/failure.
+            # If we return only successes, we hide failures.
+            RubyReactor::Success(results)
           end
         end
 
@@ -134,24 +159,58 @@ module RubyReactor
         def run_async(arguments, context, step_name)
           map_id = "#{context.context_id}:#{step_name}"
           context.map_operations[step_name.to_s] = map_id
-          prepare_async_execution(context, map_id, arguments[:source].count)
+          prepare_async_execution(context, map_id, arguments[:source].size)
 
           reactor_class_info = build_reactor_class_info(arguments[:mapped_reactor_class], context, step_name)
 
-          job_id = if arguments[:batch_size]
-                     storage = RubyReactor.configuration.storage_adapter
-                     storage.set_last_queued_index(map_id, arguments[:batch_size] - 1, context.reactor_class.name)
-                     queue_fan_out(
-                       map_id: map_id, arguments: arguments, context: context,
-                       reactor_class_info: reactor_class_info, step_name: step_name,
-                       limit: arguments[:batch_size]
-                     )
-                   else
-                     queue_single_worker(map_id: map_id, arguments: arguments, context: context,
-                                         reactor_class_info: reactor_class_info, step_name: step_name)
-                   end
+          initialize_map_metadata(map_id, arguments, context, reactor_class_info)
+
+          job_id = dispatch_async_map(map_id, arguments, context, reactor_class_info, step_name)
+
+          # Store reference in composed_contexts so the UI knows where to find elements
+          context.composed_contexts[step_name.to_s] = {
+            name: step_name.to_s,
+            type: :map_ref,
+            map_id: map_id,
+            element_reactor_class: arguments[:mapped_reactor_class].name
+          }
+
+          RubyReactor::AsyncResult.new(
+            job_id: job_id,
+            intermediate_results: context.intermediate_results,
+            execution_id: context.context_id
+          )
+        end
+
+        def initialize_map_metadata(map_id, arguments, context, reactor_class_info)
+          storage = RubyReactor.configuration.storage_adapter
+          storage.initialize_map_operation(
+            map_id, arguments[:source].size, context.reactor_class.name,
+            strict_ordering: arguments[:strict_ordering], reactor_class_info: reactor_class_info
+          )
+        end
 
-          RubyReactor::AsyncResult.new(job_id: job_id, intermediate_results: context.intermediate_results)
+        def dispatch_async_map(map_id, arguments, context, reactor_class_info, step_name)
+          if arguments[:batch_size]
+            # Use new Dispatcher with Backpressure
+            RubyReactor::Map::Dispatcher.perform(
+              map_id: map_id,
+              parent_context_id: context.context_id,
+              parent_reactor_class_name: context.reactor_class.name,
+              source: arguments[:source],
+              batch_size: arguments[:batch_size],
+              step_name: step_name,
+              argument_mappings: arguments[:argument_mappings],
+              strict_ordering: arguments[:strict_ordering],
+              mapped_reactor_class: arguments[:mapped_reactor_class],
+              fail_fast: arguments[:fail_fast]
+            )
+            queue_collector(map_id, context, step_name, arguments[:strict_ordering])
+            "map:#{map_id}"
+          else
+            queue_single_worker(map_id: map_id, arguments: arguments, context: context,
+                                reactor_class_info: reactor_class_info, step_name: step_name)
+          end
         end
 
         def prepare_async_execution(context, map_id, count)
@@ -174,11 +233,11 @@ module RubyReactor
           # rubocop:enable Metrics/ParameterLists
           storage = RubyReactor.configuration.storage_adapter
           storage.initialize_map_operation(
-            map_id, arguments[:source].count, context.reactor_class.name,
+            map_id, arguments[:source].size, context.reactor_class.name,
             strict_ordering: arguments[:strict_ordering], reactor_class_info: reactor_class_info
           )
 
-          limit ||= arguments[:source].count
+          limit ||= arguments[:source].size
           first_job_id = nil
           arguments[:source].each_with_index do |element, index|
             break if index >= limit
@@ -225,7 +284,7 @@ module RubyReactor
             map_id: map_id, serialized_inputs: serialized_inputs,
             reactor_class_info: reactor_class_info, strict_ordering: arguments[:strict_ordering],
             parent_context_id: context.context_id, parent_reactor_class_name: context.reactor_class.name,
-            step_name: step_name.to_s
+            step_name: step_name.to_s, fail_fast: arguments[:fail_fast]
           )
         end
       end

data/lib/ruby_reactor/storage/adapter.rb

@@ -46,6 +46,38 @@ module RubyReactor
       def expire(key, seconds)
         raise NotImplementedError
       end
+
+      def store_correlation_id(correlation_id, context_id, reactor_class_name)
+        raise NotImplementedError
+      end
+
+      def retrieve_context_id_by_correlation_id(correlation_id, reactor_class_name)
+        raise NotImplementedError
+      end
+
+      def delete_correlation_id(correlation_id, reactor_class_name)
+        raise NotImplementedError
+      end
+
+      def delete_context(context_id, reactor_class_name)
+        raise NotImplementedError
+      end
+
+      def scan_reactors(pattern: "*", count: 50)
+        raise NotImplementedError
+      end
+
+      def find_context_by_id(context_id)
+        raise NotImplementedError
+      end
+
+      def store_map_element_context_id(map_id, context_id, reactor_class_name)
+        raise NotImplementedError
+      end
+
+      def retrieve_map_element_context_ids(map_id, reactor_class_name)
+        raise NotImplementedError
+      end
     end
   end
 end