ruby_reactor 0.1.0

data/lib/ruby_reactor/template/element.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Template
+    class Element < Base
+      attr_reader :map_name, :path
+
+      def initialize(map_name, path = nil)
+        super()
+        @map_name = map_name
+        @path = path
+      end
+
+      def resolve(_context)
+        # Element resolution happens inside MapStep, not generic resolve
+        # But if called in wrong context, raise error
+        raise RubyReactor::Error::DependencyError, "element() can only be used within a map argument mapping"
+      end
+
+      def inspect
+        "element(:#{@map_name}#{", #{@path.inspect}" if @path})"
+      end
+    end
+  end
+end

data/lib/ruby_reactor/template/input.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Template
+    class Input < Base
+      attr_reader :name, :path
+
+      def initialize(name, path = nil)
+        super()
+        @name = name
+        @path = path
+      end
+
+      def resolve(context)
+        value = context.get_input(@name)
+        return nil if value.nil?
+
+        if @path
+          extract_path(value, @path)
+        else
+          value
+        end
+      end
+
+      def inspect
+        if @path
+          "input(:#{@name}, #{@path.inspect})"
+        else
+          "input(:#{@name})"
+        end
+      end
+
+      private
+
+      def extract_path(value, path)
+        if path.is_a?(Symbol) && value.respond_to?(:[])
+          value[path]
+        elsif path.is_a?(String)
+          path.split(".").reduce(value) { |v, key| v&.send(:[], key) }
+        elsif path.is_a?(Array)
+          path.reduce(value) { |v, key| v&.send(:[], key) }
+        elsif value.respond_to?(path)
+          value.send(path)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_reactor/template/result.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Template
+    class Result < Base
+      attr_reader :step_name, :path
+
+      def initialize(step_name, path = nil)
+        super()
+        @step_name = step_name
+        @path = path
+      end
+
+      def resolve(context)
+        value = context.get_result(@step_name)
+        return nil if value.nil?
+
+        if @path
+          extract_path(value, @path)
+        else
+          value
+        end
+      end
+
+      def inspect
+        if @path
+          "result(:#{@step_name}, #{@path.inspect})"
+        else
+          "result(:#{@step_name})"
+        end
+      end
+
+      private
+
+      def extract_path(value, path)
+        if path.is_a?(Symbol) && value.respond_to?(:[])
+          value[path]
+        elsif path.is_a?(String)
+          path.split(".").reduce(value) { |v, key| v&.send(:[], key) }
+        elsif path.is_a?(Array)
+          path.reduce(value) { |v, key| v&.send(:[], key) }
+        elsif value.respond_to?(path)
+          value.send(path)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_reactor/template/value.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Template
+    class Value < Base
+      attr_reader :value
+
+      def initialize(value)
+        super()
+        @value = value
+      end
+
+      def resolve(_context)
+        @value
+      end
+
+      def inspect
+        "value(#{@value.inspect})"
+      end
+    end
+  end
+end

data/lib/ruby_reactor/validation/base.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Validation
+    class Base
+      def self.call(data)
+        new.call(data)
+      end
+
+      def call(data)
+        raise NotImplementedError
+      end
+
+      protected
+
+      def success(value)
+        RubyReactor.Success(value)
+      end
+
+      def failure(errors)
+        error = RubyReactor::Error::InputValidationError.new(errors)
+        RubyReactor.Failure(error)
+      end
+    end
+  end
+end

data/lib/ruby_reactor/validation/input_validator.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "dry-validation"
+
+module RubyReactor
+  module Validation
+    class InputValidator < Base
+      attr_reader :schema
+
+      def initialize(schema)
+        super()
+        @schema = schema
+      end
+
+      def call(data)
+        result = schema.call(data)
+
+        if result.success?
+          success(result.to_h)
+        else
+          failure(format_errors(result.errors))
+        end
+      end
+
+      private
+
+      def format_errors(errors)
+        formatted = {}
+        flatten_errors(errors.to_h, formatted, [])
+        formatted
+      end
+
+      def flatten_errors(errors_hash, formatted, path)
+        errors_hash.each do |key, messages|
+          current_path = path + [key]
+
+          case messages
+          when Array
+            # This is a leaf node with error messages
+            flat_key = if current_path.size == 1
+                         current_path.first.to_s
+                       else
+                         "#{current_path.first}#{current_path[1..].map { |k| "[#{k}]" }.join}"
+                       end
+            formatted[flat_key.to_sym] = messages.join(", ")
+          when Hash
+            # This is a nested structure, recurse
+            flatten_errors(messages, formatted, current_path)
+          else
+            # Single message
+            flat_key = if current_path.size == 1
+                         current_path.first.to_s
+                       else
+                         "#{current_path.first}#{current_path[1..].map { |k| "[#{k}]" }.join}"
+                       end
+            formatted[flat_key.to_sym] = messages.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_reactor/validation/schema_builder.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "dry-validation"
+
+module RubyReactor
+  module Validation
+    class SchemaBuilder
+      def self.build_from_block(&block)
+        Dry::Schema.Params(&block)
+      end
+
+      def self.build_contract_from_block(&block)
+        Class.new(Dry::Validation::Contract, &block).new
+      end
+    end
+  end
+end

data/lib/ruby_reactor/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  VERSION = "0.1.0"
+end

data/lib/ruby_reactor.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+
+# Load dry-validation if available (for validation features)
+begin
+  require "dry-validation"
+rescue LoadError
+  # dry-validation is optional, validation features won't be available
+end
+
+# Load sidekiq if available (for async features)
+begin
+  require "sidekiq"
+rescue LoadError
+  # sidekiq is optional, async features won't be available
+end
+
+loader = Zeitwerk::Loader.for_gem
+loader.setup
+
+module RubyReactor
+  # Success/Failure pattern for results
+  class Success
+    attr_reader :value
+
+    def initialize(value = nil)
+      @value = value
+    end
+
+    def success?
+      true
+    end
+
+    def failure?
+      false
+    end
+  end
+
+  class Failure
+    attr_reader :error, :retryable, :step_name, :inputs, :backtrace, :reactor_name, :step_arguments
+
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(error, retryable: nil, step_name: nil, inputs: {}, backtrace: nil, redact_inputs: [],
+                   reactor_name: nil, step_arguments: {})
+      # rubocop:enable Metrics/ParameterLists
+      @error = error
+      @retryable = if retryable.nil?
+                     error.respond_to?(:retryable?) ? error.retryable? : true
+                   else
+                     retryable
+                   end
+      @step_name = step_name
+      @reactor_name = reactor_name
+      @inputs = inputs
+      @step_arguments = step_arguments
+      @backtrace = backtrace || (error.respond_to?(:backtrace) ? error.backtrace : caller)
+      @redact_inputs = redact_inputs
+    end
+
+    def success?
+      false
+    end
+
+    def failure?
+      true
+    end
+
+    def retryable?
+      @retryable
+    end
+
+    def message
+      msg = []
+      header = "Error"
+      header += " in reactor '#{reactor_name}'" if reactor_name
+      header += " step '#{step_name}'" if step_name
+      header += ": #{error_message}"
+
+      msg << header
+
+      if inputs && !inputs.empty?
+        msg << "Inputs:"
+        inputs.each do |key, value|
+          val = @redact_inputs.include?(key) ? "[REDACTED]" : value.inspect
+          msg << "  #{key}: #{val}"
+        end
+      end
+
+      if step_arguments && !step_arguments.empty?
+        msg << "Step Arguments:"
+        step_arguments.each do |key, value|
+          # We might want to redact step arguments too if they come from redacted inputs
+          # For now, let's assume if the input key matches a redacted input key, it should be redacted
+          # But step arguments have different names.
+          # We can't easily track redaction for step arguments without more metadata.
+          # For now, let's just display them.
+          msg << "  #{key}: #{value.inspect}"
+        end
+      end
+
+      if backtrace
+        msg << "Backtrace:"
+        msg << backtrace.take(5).map { |line| "  #{line}" }.join("\n")
+      end
+
+      msg.join("\n")
+    end
+
+    def to_s
+      message
+    end
+
+    private
+
+    def error_message
+      @error.respond_to?(:message) ? @error.message : @error.to_s
+    end
+  end
+
+  # Async result for background job execution
+  class AsyncResult
+    attr_reader :job_id, :intermediate_results
+
+    def initialize(job_id:, intermediate_results: {})
+      @job_id = job_id
+      @intermediate_results = intermediate_results
+    end
+
+    def async?
+      true
+    end
+
+    def success?
+      false
+    end
+
+    def failure?
+      false
+    end
+  end
+
+  # Global helper methods
+  def self.Success(value = nil)
+    Success.new(value)
+  end
+
+  def self.Failure(error, **kwargs)
+    Failure.new(error, **kwargs)
+  end
+
+  def self.configure
+    yield(Configuration.instance) if block_given?
+  end
+
+  def self.configuration
+    Configuration.instance
+  end
+end

data/sig/ruby_reactor.rbs

@@ -0,0 +1,4 @@
+module RubyReactor
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,178 @@
+--- !ruby/object:Gem::Specification
+name: ruby_reactor
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Artur
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-12-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-validation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+description: Ruby Reactor implements the Saga pattern with compensation-based error
+  handling and DAG-based execution planning. It supports async execution via Sidekiq
+  and persistence via Redis.
+email:
+- 1930175+arturictus@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CODE_OF_CONDUCT.md
+- README.md
+- Rakefile
+- documentation/DAG.md
+- documentation/README.md
+- documentation/async_reactors.md
+- documentation/composition.md
+- documentation/core_concepts.md
+- documentation/data_pipelines.md
+- documentation/examples/inventory_management.md
+- documentation/examples/order_processing.md
+- documentation/examples/payment_processing.md
+- documentation/getting_started.md
+- documentation/retry_configuration.md
+- lib/ruby_reactor.rb
+- lib/ruby_reactor/async_router.rb
+- lib/ruby_reactor/configuration.rb
+- lib/ruby_reactor/context.rb
+- lib/ruby_reactor/context_serializer.rb
+- lib/ruby_reactor/dependency_graph.rb
+- lib/ruby_reactor/dsl/compose_builder.rb
+- lib/ruby_reactor/dsl/map_builder.rb
+- lib/ruby_reactor/dsl/reactor.rb
+- lib/ruby_reactor/dsl/step_builder.rb
+- lib/ruby_reactor/dsl/template_helpers.rb
+- lib/ruby_reactor/dsl/validation_helpers.rb
+- lib/ruby_reactor/error/base.rb
+- lib/ruby_reactor/error/compensation_error.rb
+- lib/ruby_reactor/error/context_too_large_error.rb
+- lib/ruby_reactor/error/dependency_error.rb
+- lib/ruby_reactor/error/deserialization_error.rb
+- lib/ruby_reactor/error/input_validation_error.rb
+- lib/ruby_reactor/error/schema_version_error.rb
+- lib/ruby_reactor/error/step_failure_error.rb
+- lib/ruby_reactor/error/undo_error.rb
+- lib/ruby_reactor/error/validation_error.rb
+- lib/ruby_reactor/executor.rb
+- lib/ruby_reactor/executor/compensation_manager.rb
+- lib/ruby_reactor/executor/graph_manager.rb
+- lib/ruby_reactor/executor/input_validator.rb
+- lib/ruby_reactor/executor/result_handler.rb
+- lib/ruby_reactor/executor/retry_manager.rb
+- lib/ruby_reactor/executor/step_executor.rb
+- lib/ruby_reactor/map/collector.rb
+- lib/ruby_reactor/map/element_executor.rb
+- lib/ruby_reactor/map/execution.rb
+- lib/ruby_reactor/map/helpers.rb
+- lib/ruby_reactor/max_retries_exhausted_failure.rb
+- lib/ruby_reactor/reactor.rb
+- lib/ruby_reactor/retry_context.rb
+- lib/ruby_reactor/retry_queued_result.rb
+- lib/ruby_reactor/sidekiq_workers/map_collector_worker.rb
+- lib/ruby_reactor/sidekiq_workers/map_element_worker.rb
+- lib/ruby_reactor/sidekiq_workers/map_execution_worker.rb
+- lib/ruby_reactor/sidekiq_workers/worker.rb
+- lib/ruby_reactor/step.rb
+- lib/ruby_reactor/step/compose_step.rb
+- lib/ruby_reactor/step/map_step.rb
+- lib/ruby_reactor/storage/adapter.rb
+- lib/ruby_reactor/storage/configuration.rb
+- lib/ruby_reactor/storage/redis_adapter.rb
+- lib/ruby_reactor/template/base.rb
+- lib/ruby_reactor/template/element.rb
+- lib/ruby_reactor/template/input.rb
+- lib/ruby_reactor/template/result.rb
+- lib/ruby_reactor/template/value.rb
+- lib/ruby_reactor/validation/base.rb
+- lib/ruby_reactor/validation/input_validator.rb
+- lib/ruby_reactor/validation/schema_builder.rb
+- lib/ruby_reactor/version.rb
+- sig/ruby_reactor.rbs
+homepage: https://github.com/arturictus/ruby_reactor
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+  rubygems_mfa_required: 'true'
+  homepage_uri: https://github.com/arturictus/ruby_reactor
+  source_code_uri: https://github.com/arturictus/ruby_reactor
+  changelog_uri: https://github.com/arturictus/ruby_reactor/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: A dynamic, concurrent, dependency-resolving saga orchestrator for Ruby.
+test_files: []