ruby_reactor 0.1.0

data/lib/ruby_reactor/dsl/reactor.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Dsl
+    module Reactor
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.instance_variable_set(:@inputs, {})
+        base.instance_variable_set(:@steps, {})
+        base.instance_variable_set(:@return_step, nil)
+        base.instance_variable_set(:@middlewares, [])
+        base.instance_variable_set(:@input_validations, {})
+        base.instance_variable_set(:@async, false)
+        base.instance_variable_set(:@retry_defaults, { max_attempts: 3, backoff: :exponential, base_delay: 1 })
+      end
+
+      module ClassMethods
+        include RubyReactor::Dsl::TemplateHelpers
+        include RubyReactor::Dsl::ValidationHelpers
+
+        def inputs
+          @inputs ||= {}
+        end
+
+        def steps
+          @steps ||= {}
+        end
+
+        def return_step
+          @return_step
+        end
+
+        def middlewares
+          @middlewares ||= []
+        end
+
+        def input_validations
+          @input_validations ||= {}
+        end
+
+        def async(async = true)
+          @async = async
+        end
+
+        def async?
+          @async ||= false
+        end
+
+        def retry_defaults(**kwargs)
+          if kwargs.empty?
+            @retry_defaults ||= { max_attempts: 1, backoff: :exponential, base_delay: 1 }
+          else
+            @retry_defaults = {
+              max_attempts: kwargs[:max_attempts] || 1,
+              backoff: kwargs[:backoff] || :exponential,
+              base_delay: kwargs[:base_delay] || 1
+            }
+          end
+        end
+
+        # rubocop:disable Metrics/ParameterLists
+        def input(name, transform: nil, description: nil, validate: nil, optional: false, redact: false,
+                  &validation_block)
+          # rubocop:enable Metrics/ParameterLists
+          inputs[name] = {
+            transform: transform,
+            description: description,
+            optional: optional,
+            redact: redact
+          }
+
+          # Handle validation
+          return unless validate || validation_block
+
+          validator = create_input_validator(validation_block || validate)
+          input_validations[name] = validator
+        end
+
+        def step(name, impl = nil, &block)
+          builder = RubyReactor::Dsl::StepBuilder.new(name, impl, self)
+
+          builder.instance_eval(&block) if block_given?
+
+          step_config = builder.build
+          steps[name] = step_config
+          step_config
+        end
+
+        def compose(name, composed_reactor_class = nil, &block)
+          builder = RubyReactor::Dsl::ComposeBuilder.new(name, composed_reactor_class, self, &block)
+
+          builder.instance_eval(&block) if block_given?
+
+          step_config = builder.build
+          steps[name] = step_config
+          step_config
+        end
+
+        def map(name, reactor_class = nil, &block)
+          builder = RubyReactor::Dsl::MapBuilder.new(name, reactor_class, self, &block)
+
+          builder.instance_eval(&block) if block_given?
+
+          step_config = builder.build
+          steps[name] = step_config
+          step_config
+        end
+
+        def returns(step_name)
+          @return_step = step_name
+        end
+
+        def middleware(middleware_class)
+          middlewares << middleware_class
+        end
+
+        def validate_inputs(inputs_hash)
+          errors = {}
+
+          input_validations.each do |input_name, validator|
+            # Skip validation if input is optional and not provided
+            next if inputs[input_name][:optional] && !inputs_hash.key?(input_name)
+
+            input_data = inputs_hash[input_name]
+            # Validate by wrapping the individual input in a hash with its name
+            result = validator.call({ input_name => input_data })
+
+            errors.merge!(result.error.field_errors) if result.failure? && result.error.respond_to?(:field_errors)
+          end
+
+          if errors.empty?
+            RubyReactor.Success(inputs_hash)
+          else
+            error = RubyReactor::Error::InputValidationError.new(errors)
+            RubyReactor.Failure(error)
+          end
+        end
+
+        # Entry point for running the reactor
+        def run(inputs = {})
+          reactor = new
+          reactor.run(inputs)
+        end
+
+        def call(inputs = {})
+          run(inputs)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_reactor/dsl/step_builder.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Dsl
+    class StepBuilder
+      include RubyReactor::Dsl::TemplateHelpers
+      include RubyReactor::Dsl::ValidationHelpers
+
+      attr_accessor :name, :impl, :arguments, :run_block, :compensate_block, :undo_block, :conditions, :guards,
+                    :dependencies, :args_validator, :output_validator, :retry_config
+
+      def initialize(name, impl = nil, reactor = nil)
+        @name = name
+        @impl = impl
+        @reactor = reactor
+        @arguments = {}
+        @run_block = nil
+        @compensate_block = nil
+        @undo_block = nil
+        @conditions = []
+        @guards = []
+        @dependencies = []
+        @args_validator = nil
+        @output_validator = nil
+        @async = false
+        @retry_config = {}
+      end
+
+      def argument(name, source, transform: nil)
+        @arguments[name] = {
+          source: source,
+          transform: transform
+        }
+      end
+
+      def run(&block)
+        @run_block = block
+      end
+
+      def compensate(&block)
+        @compensate_block = block
+      end
+
+      def undo(&block)
+        @undo_block = block
+      end
+
+      def where(&predicate)
+        @conditions << predicate
+      end
+
+      def guard(&guard_fn)
+        @guards << guard_fn
+      end
+
+      def wait_for(*step_names)
+        @dependencies.concat(step_names)
+      end
+
+      def validate_args(schema_or_validator = nil, &block)
+        if block_given?
+          @args_validator = build_input_validator(block)
+        elsif schema_or_validator
+          @args_validator = build_input_validator(schema_or_validator)
+        end
+      end
+
+      def validate_output(schema_or_validator = nil, &block)
+        if block_given?
+          @output_validator = build_input_validator(block)
+        elsif schema_or_validator
+          @output_validator = build_input_validator(schema_or_validator)
+        end
+      end
+
+      def async(async = true)
+        @async = async
+      end
+
+      def retries(max_attempts: 3, backoff: :exponential, base_delay: 1)
+        @retry_config = {
+          max_attempts: max_attempts,
+          backoff: backoff,
+          base_delay: base_delay
+        }
+      end
+
+      def build
+        step_config = {
+          name: @name,
+          impl: @impl,
+          arguments: @arguments,
+          run_block: @run_block,
+          compensate_block: @compensate_block,
+          undo_block: @undo_block,
+          conditions: @conditions,
+          guards: @guards,
+          dependencies: @dependencies,
+          args_validator: @args_validator,
+          output_validator: @output_validator,
+          async: @async,
+          retry_config: @retry_config.empty? ? (@reactor&.retry_defaults || {}) : @retry_config
+        }
+
+        RubyReactor::Dsl::StepConfig.new(step_config)
+      end
+
+      private
+
+      def build_input_validator(schema_or_block)
+        check_dry_validation_available!
+
+        schema = case schema_or_block
+                 when Proc
+                   build_validation_schema(&schema_or_block)
+                 else
+                   schema_or_block
+                 end
+
+        RubyReactor::Validation::InputValidator.new(schema)
+      end
+
+      def build_validation_schema(&block)
+        RubyReactor::Validation::SchemaBuilder.build_from_block(&block)
+      end
+
+      def check_dry_validation_available!
+        return if defined?(Dry::Schema)
+
+        raise LoadError,
+              "dry-validation gem is required for validation features. Add 'gem \"dry-validation\"' to your Gemfile."
+      end
+    end
+
+    class StepConfig
+      attr_reader :name, :impl, :arguments, :run_block, :compensate_block, :undo_block, :conditions, :guards,
+                  :dependencies, :args_validator, :output_validator, :async, :retry_config
+
+      def initialize(config)
+        @name = config[:name]
+        @impl = config[:impl]
+        @arguments = config[:arguments] || {}
+        @run_block = config[:run_block]
+        @compensate_block = config[:compensate_block]
+        @undo_block = config[:undo_block]
+        @conditions = config[:conditions] || []
+        @guards = config[:guards] || []
+        @dependencies = config[:dependencies] || []
+        @args_validator = config[:args_validator]
+        @output_validator = config[:output_validator]
+        @async = config[:async] || false
+        @retry_config = { max_attempts: 1 }.merge(config[:retry_config] || {})
+      end
+
+      def has_impl?
+        !@impl.nil?
+      end
+
+      def has_run_block?
+        !@run_block.nil?
+      end
+
+      def async?
+        @async
+      end
+
+      def retryable?
+        (retry_config[:max_attempts] || 0) > 1
+      end
+
+      def should_run?(context)
+        @conditions.all? { |condition| condition.call(context) } &&
+          @guards.all? { |guard| guard.call(context) }
+      end
+    end
+  end
+end

data/lib/ruby_reactor/dsl/template_helpers.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Dsl
+    module TemplateHelpers
+      def input(name, path = nil)
+        RubyReactor::Template::Input.new(name, path)
+      end
+
+      def result(step_name, path = nil)
+        RubyReactor::Template::Result.new(step_name, path)
+      end
+
+      def value(val)
+        RubyReactor::Template::Value.new(val)
+      end
+
+      def element(map_name, path = nil)
+        RubyReactor::Template::Element.new(map_name, path)
+      end
+
+      # Make Success and Failure available in DSL contexts
+      # rubocop:disable Naming/MethodName
+      def Success(value = nil)
+        # rubocop:enable Naming/MethodName
+        RubyReactor.Success(value)
+      end
+
+      # rubocop:disable Naming/MethodName
+      def Failure(error)
+        # rubocop:enable Naming/MethodName
+        RubyReactor.Failure(error)
+      end
+    end
+  end
+end

data/lib/ruby_reactor/dsl/validation_helpers.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Dsl
+    module ValidationHelpers
+      # Validation helper methods
+      def build_validation_schema(&block)
+        check_dry_validation_available!
+        RubyReactor::Validation::SchemaBuilder.build_from_block(&block)
+      end
+
+      def create_input_validator(schema_or_block)
+        check_dry_validation_available!
+
+        schema = case schema_or_block
+                 when Proc
+                   build_validation_schema(&schema_or_block)
+                 else
+                   schema_or_block
+                 end
+
+        RubyReactor::Validation::InputValidator.new(schema)
+      end
+
+      private
+
+      def check_dry_validation_available!
+        return if defined?(Dry::Schema)
+
+        raise LoadError,
+              "dry-validation gem is required for validation features. Add 'gem \"dry-validation\"' to your Gemfile."
+      end
+    end
+  end
+end

data/lib/ruby_reactor/error/base.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Error
+    class Base < StandardError
+      attr_reader :step, :context, :original_error
+
+      def initialize(message, step: nil, context: nil, original_error: nil)
+        super(message)
+        @step = step
+        @context = context
+        @original_error = original_error
+      end
+    end
+  end
+end

data/lib/ruby_reactor/error/compensation_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Error
+    class CompensationError < Base
+    end
+  end
+end

data/lib/ruby_reactor/error/context_too_large_error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Error
+    class ContextTooLargeError < Base
+      def initialize(message)
+        super("Context size exceeds limits: #{message}")
+      end
+    end
+  end
+end

data/lib/ruby_reactor/error/dependency_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Error
+    class DependencyError < Base
+    end
+  end
+end

data/lib/ruby_reactor/error/deserialization_error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Error
+    class DeserializationError < Base
+      def initialize(message)
+        super("Context deserialization failed: #{message}")
+      end
+    end
+  end
+end

data/lib/ruby_reactor/error/input_validation_error.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Error
+    class InputValidationError < Base
+      attr_reader :field_errors
+
+      def initialize(field_errors)
+        @field_errors = field_errors
+        @message = build_message
+        super(@message)
+      end
+
+      def build_message
+        return "Input validation failed" if field_errors.empty?
+
+        error_messages = field_errors.map do |field, errors|
+          "#{field} #{errors}"
+        end
+
+        "Input validation failed: #{error_messages.join(", ")}"
+      end
+
+      def to_s
+        @message || build_message
+      end
+    end
+  end
+end

data/lib/ruby_reactor/error/schema_version_error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Error
+    class SchemaVersionError < Base
+      def initialize(message)
+        super("Schema version mismatch: #{message}")
+      end
+    end
+  end
+end

data/lib/ruby_reactor/error/step_failure_error.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Error
+    class StepFailureError < Base
+      attr_reader :step_arguments
+
+      def initialize(message, step: nil, context: nil, original_error: nil, step_arguments: {})
+        super(message, step: step, context: context, original_error: original_error)
+        @step_arguments = step_arguments
+      end
+
+      def retryable?
+        true
+      end
+    end
+  end
+end

data/lib/ruby_reactor/error/undo_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Error
+    class UndoError < Base
+    end
+  end
+end

data/lib/ruby_reactor/error/validation_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Error
+    class ValidationError < Base
+    end
+  end
+end

data/lib/ruby_reactor/executor/compensation_manager.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  class Executor
+    class CompensationManager
+      def initialize(context)
+        @context = context
+        @undo_stack = []
+        @undo_trace = []
+      end
+
+      attr_reader :undo_stack, :undo_trace
+
+      def add_to_undo_stack(step_info)
+        @undo_stack << step_info
+      end
+
+      def handle_step_failure(step_config, error, arguments)
+        # Try compensation
+        compensation_result = compensate_step(step_config, error, arguments)
+        case compensation_result
+        when RubyReactor::Success
+          # Compensation succeeded, continue with rollback
+          rollback_completed_steps
+          RubyReactor.Failure("Step '#{step_config.name}' failed: #{error}")
+        when RubyReactor::Failure
+          # Compensation failed, this is more serious
+          rollback_completed_steps
+          raise Error::CompensationError.new(
+            "Compensation for step '#{step_config.name}' failed: #{compensation_result.error}",
+            step: step_config.name,
+            context: @context,
+            original_error: error
+          )
+        end
+      end
+
+      def rollback_completed_steps
+        @undo_stack.reverse_each do |step_info|
+          result = undo_step(step_info[:step], step_info[:result], step_info[:arguments])
+          @undo_trace << { type: :undo, step: step_info[:step].name, result: result,
+                           arguments: step_info[:arguments] }
+        end
+        @undo_stack.clear
+      end
+
+      private
+
+      def compensate_step(step_config, error, arguments)
+        if step_config.compensate_block
+          @context.execution_trace << { type: :compensate, step: step_config.name, timestamp: Time.now, error: error,
+                                        arguments: arguments }
+          @undo_trace << { type: :compensation, step: step_config.name, error: error, arguments: arguments }
+          step_config.compensate_block.call(error, arguments, @context)
+        elsif step_config.has_impl?
+          @context.execution_trace << { type: :compensate, step: step_config.name, timestamp: Time.now, error: error,
+                                        arguments: arguments }
+          @undo_trace << { type: :compensation, step: step_config.name, error: error, arguments: arguments }
+          step_config.impl.compensate(error, arguments, @context)
+        else
+          RubyReactor.Success() # Default compensation
+        end
+      end
+
+      def undo_step(step_config, result, arguments)
+        @context.execution_trace << { type: :undo, step: step_config.name, timestamp: Time.now, result: result.value,
+                                      arguments: arguments }
+        if step_config.undo_block
+          step_config.undo_block.call(result.value, arguments, @context)
+        elsif step_config.has_impl?
+          step_config.impl.undo(result.value, arguments, @context)
+        end
+      rescue StandardError
+        # Log undo failure but don't halt the rollback process
+        # In a real implementation, this would use a logger
+      end
+    end
+  end
+end

data/lib/ruby_reactor/executor/graph_manager.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  class Executor
+    class GraphManager
+      def initialize(reactor_class, dependency_graph, context)
+        @reactor_class = reactor_class
+        @dependency_graph = dependency_graph
+        @context = context
+      end
+
+      def build_and_validate!
+        build_dependency_graph
+        validate_graph!
+      end
+
+      def mark_completed_steps_from_context
+        @context.intermediate_results.each_key do |step_name|
+          @dependency_graph.complete_step(step_name)
+        end
+      end
+
+      private
+
+      def build_dependency_graph
+        @reactor_class.steps.each_value do |step_config|
+          @dependency_graph.add_step(step_config)
+        end
+      end
+
+      def validate_graph!
+        return unless @dependency_graph.has_cycles?
+
+        raise Error::DependencyError.new(
+          "Dependency graph contains cycles",
+          context: @context
+        )
+      end
+    end
+  end
+end