ruby_reactor 0.4.1 → 0.5.1

data/lib/ruby_reactor/rate_limit_registry.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  # Global registry of named rate limits, configured once via
+  # `RubyReactor.configure`. Lets multiple reactors share a single quota for an
+  # external service (e.g. all Stripe-calling reactors throttle against one
+  # `:stripe` bucket).
+  #
+  # @example
+  #   RubyReactor.configure do |config|
+  #     config.rate_limits.register(:stripe, limit: 3, period: :second)
+  #     config.rate_limits.register(:twilio, limits: { second: 10, minute: 100 })
+  #   end
+  #
+  #   class ChargeReactor < RubyReactor::Reactor
+  #     with_rate_limit(:stripe)
+  #   end
+  class RateLimitRegistry
+    # Raised when a reactor references a rate-limit name that was never
+    # registered. This is a configuration error, so it propagates out of
+    # `execute` rather than being swallowed into a step failure result.
+    class UnknownLimitError < StandardError; end
+
+    def initialize
+      @limits = {}
+    end
+
+    # Register a named rate limit. Same window args as the inline DSL form:
+    # a single window (`limit:` + `period:`) or layered windows (`limits:`).
+    def register(name, limit: nil, period: nil, limits: nil)
+      @limits[name.to_sym] = RubyReactor::RateLimit.normalize_specs(
+        limit: limit, period: period, limits: limits
+      )
+      self
+    end
+
+    # Return the normalized spec array for a registered name, or raise if the
+    # name was never registered (resolved lazily at execute time, so the error
+    # surfaces with a clear message instead of a nil dereference).
+    def fetch(name)
+      @limits.fetch(name.to_sym) do
+        raise UnknownLimitError, "Unknown rate limit #{name.inspect}. " \
+                                 "Register it with config.rate_limits.register(#{name.inspect}, ...)."
+      end
+    end
+
+    def registered?(name)
+      @limits.key?(name.to_sym)
+    end
+  end
+end

data/lib/ruby_reactor/reactor.rb

@@ -105,6 +105,7 @@ module RubyReactor
       if self.class.async? && !@context.inline_async_execution
         # For async reactors, queue a job for the whole reactor
         @context.status = :running
+        Executor.middlewares_for(self.class).on(:before_async_enqueue, @context)
         save_context
 
         serialized_context = ContextSerializer.serialize(@context)

data/lib/ruby_reactor/rspec/test_subject.rb

@@ -432,7 +432,6 @@ module RubyReactor
           worker_classes = [
             RubyReactor::SidekiqWorkers::Worker,
             RubyReactor::SidekiqWorkers::MapElementWorker,
-            RubyReactor::SidekiqWorkers::MapExecutionWorker,
             RubyReactor::SidekiqWorkers::MapCollectorWorker
           ]
 

data/lib/ruby_reactor/sidekiq_adapter.rb

@@ -41,8 +41,8 @@ module RubyReactor
 
     def self.perform_map_element_in(delay, map_id:, element_id:, index:, serialized_inputs:, reactor_class_info:,
                                     strict_ordering:, parent_context_id:, parent_reactor_class_name:, step_name:,
-                                    batch_size: nil, serialized_context: nil)
-      RubyReactor::SidekiqWorkers::MapElementWorker.perform_in(
+                                    batch_size: nil, serialized_context: nil, fail_fast: nil)
+      job_id = RubyReactor::SidekiqWorkers::MapElementWorker.perform_in(
         delay,
         {
           "map_id" => map_id,
@@ -55,9 +55,13 @@ module RubyReactor
           "parent_reactor_class_name" => parent_reactor_class_name,
           "step_name" => step_name,
           "batch_size" => batch_size,
-          "serialized_context" => serialized_context
+          "serialized_context" => serialized_context,
+          "fail_fast" => fail_fast
         }
       )
+      # Return an AsyncResult so RetryManager#handle_async_retry recognises the
+      # element was successfully requeued and yields a RetryQueuedResult.
+      RubyReactor::AsyncResult.new(job_id: job_id)
     end
     # rubocop:enable Metrics/ParameterLists
 
@@ -78,23 +82,5 @@ module RubyReactor
     end
 
     # rubocop:enable Metrics/ParameterLists
-    # rubocop:disable Metrics/ParameterLists
-    def self.perform_map_execution_async(map_id:, serialized_inputs:, reactor_class_info:, strict_ordering:,
-                                         parent_context_id:, parent_reactor_class_name:, step_name:, fail_fast: nil)
-      # rubocop:enable Metrics/ParameterLists
-      job_id = RubyReactor::SidekiqWorkers::MapExecutionWorker.perform_async(
-        {
-          "map_id" => map_id,
-          "serialized_inputs" => serialized_inputs,
-          "reactor_class_info" => reactor_class_info,
-          "strict_ordering" => strict_ordering,
-          "parent_context_id" => parent_context_id,
-          "parent_reactor_class_name" => parent_reactor_class_name,
-          "step_name" => step_name,
-          "fail_fast" => fail_fast
-        }
-      )
-      RubyReactor::AsyncResult.new(job_id: job_id)
-    end
   end
 end

data/lib/ruby_reactor/sidekiq_workers/worker.rb

@@ -60,6 +60,10 @@ module RubyReactor
           # budget or appear as an error in dashboards. After the configured
           # cap is reached we escalate by marking the reactor as failed.
           handle_snooze(serialized_context, reactor_class_name, context, snooze_count, e)
+        rescue RubyReactor::RateLimitRegistry::UnknownLimitError => e
+          # Permanent configuration error — snoozing or retrying the same job
+          # will keep failing. Mark the context failed immediately.
+          escalate_snooze(context, snooze_count, e)
         end
       end
 

data/lib/ruby_reactor/step/map_step.rb

@@ -183,31 +183,35 @@ module RubyReactor
           )
         end
 
-        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].nil? || 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
+        def dispatch_async_map(map_id, arguments, context, _reactor_class_info, step_name)
+          # Every async map runs through the per-element Dispatcher path. When no
+          # batch_size is given we default to the full source size (one fan-out
+          # batch), so there is a single execution path: each element runs in its
+          # own worker, with the map counter/collector tracking completion. This
+          # lets elements with async steps or async retries hand off correctly
+          # instead of being forced to run synchronously in a single worker.
+          batch_size = arguments[:batch_size] || arguments[:source].size
+
+          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: 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].nil? || arguments[:fail_fast]
+          )
+          queue_collector(map_id, context, step_name, arguments[:strict_ordering])
+          "map:#{map_id}"
         end
 
         def prepare_async_execution(context, map_id, count)
           storage = RubyReactor.configuration.storage_adapter
+          middlewares = context.middlewares || Executor.middlewares_for(context.reactor_class)
+          middlewares.on(:before_async_enqueue, context)
           serialized_context = ContextSerializer.serialize(context)
           storage.store_context(context.context_id, serialized_context, context.reactor_class.name)
           storage.set_map_counter(map_id, count, context.reactor_class.name)
@@ -268,18 +272,6 @@ module RubyReactor
             strict_ordering: strict_ordering, timeout: 3600
           )
         end
-
-        def queue_single_worker(map_id:, arguments:, context:, reactor_class_info:, step_name:)
-          inputs = { source: arguments[:source], mappings: arguments[:argument_mappings] || {} }
-          serialized_inputs = ContextSerializer.serialize_value(inputs)
-
-          RubyReactor.configuration.async_router.perform_map_execution_async(
-            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, fail_fast: arguments[:fail_fast].nil? || arguments[:fail_fast]
-          )
-        end
       end
     end
   end

data/lib/ruby_reactor/validation/base.rb

@@ -19,7 +19,10 @@ module RubyReactor
 
       def failure(errors)
         error = RubyReactor::Error::InputValidationError.new(errors)
-        RubyReactor.Failure(error)
+        # Carry the structured field errors on the Failure itself so every
+        # validation failure shape (reactor inputs via `run`, step args, step
+        # output) exposes `validation_errors` uniformly.
+        RubyReactor.Failure(error, validation_errors: errors)
       end
     end
   end

data/lib/ruby_reactor/validation/input_validator.rb

@@ -5,14 +5,16 @@ require "dry-validation"
 module RubyReactor
   module Validation
     class InputValidator < Base
-      attr_reader :schema
+      attr_reader :schema, :wrap_key
 
-      def initialize(schema)
+      def initialize(schema, wrap_key: nil)
         super()
         @schema = schema
+        @wrap_key = wrap_key
       end
 
       def call(data)
+        data = { @wrap_key => data } if @wrap_key
         result = schema.call(data)
 
         if result.success?

data/lib/ruby_reactor/validation/schema_builder.rb

@@ -12,6 +12,88 @@ module RubyReactor
       def self.build_contract_from_block(&block)
         Class.new(Dry::Validation::Contract, &block).new
       end
+
+      # Form 1 / 1b — a single named value with an optional type and predicates.
+      #
+      #   build_inline(:age, :integer, false, { gteq?: 18 })
+      #     => required(:age).filled(:integer, gteq?: 18)
+      #   build_inline(:user, User, false, {})
+      #     => required(:user).filled(type?: User)
+      #   build_inline(:bio, :string, true, { max_size?: 100 })
+      #     => optional(:bio).maybe(:string, max_size?: 100)
+      def self.build_inline(name, type, optional, predicates)
+        rules = [[name, type, optional, predicates]]
+        Dry::Schema.Params do
+          SchemaBuilder.apply_inline_rules(self, rules)
+        end
+      end
+
+      # Form 2 — the block receives the macro already bound to the name and
+      # optionality (`required(name)` / `optional(name)`). Because it is invoked
+      # as a block argument (not via instance_eval) the caller's `self` and
+      # lexical scope (class constants, helper methods) stay reachable.
+      def self.build_macro(name, optional, &block)
+        macro_method = optional ? :optional : :required
+        Dry::Schema.Params do
+          block.call(public_send(macro_method, name))
+        end
+      end
+
+      # Compose per-argument inline rules with an optional `validate_args`
+      # input (block or pre-built schema). Block/inline rules are applied first;
+      # a pre-built schema is merged last so its rules win.
+      def self.build_args(inline_rules, validate_input)
+        block = validate_input.is_a?(Proc) ? validate_input : nil
+        prebuilt = !validate_input.nil? && block.nil? ? schema_for(validate_input) : nil
+
+        composed = build_args_base(inline_rules, block)
+
+        if prebuilt && composed
+          composed.merge(prebuilt)
+        elsif prebuilt
+          prebuilt
+        else
+          composed
+        end
+      end
+
+      def self.build_args_base(inline_rules, block)
+        return Dry::Schema.Params(&block) if inline_rules.empty? && block
+        return nil if inline_rules.empty?
+
+        Dry::Schema.Params do
+          SchemaBuilder.apply_inline_rules(self, inline_rules)
+          instance_exec(&block) if block
+        end
+      end
+
+      # Apply a list of inline rules ([name, type, optional, predicates]) onto a
+      # dry-schema DSL context.
+      def self.apply_inline_rules(dsl, rules)
+        rules.each do |name, type, optional, predicates|
+          macro_method = optional ? :optional : :required
+          rule_method  = optional ? :maybe : :filled
+          positional   = type.is_a?(Symbol) ? [type] : []
+          kwargs       = type.is_a?(Module) ? { type?: type, **predicates } : predicates
+
+          macro = dsl.public_send(macro_method, name)
+          if kwargs.empty?
+            macro.public_send(rule_method, *positional)
+          else
+            macro.public_send(rule_method, *positional, **kwargs)
+          end
+        end
+      end
+
+      # Unwrap an InputValidator into its underlying dry-schema; pass dry-schemas
+      # through unchanged.
+      def self.schema_for(schema_or_validator)
+        if schema_or_validator.is_a?(RubyReactor::Validation::InputValidator)
+          schema_or_validator.schema
+        else
+          schema_or_validator
+        end
+      end
     end
   end
 end

data/lib/ruby_reactor/version.rb

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

data/lib/ruby_reactor/web/coordination_serializer.rb

@@ -122,34 +122,28 @@ module RubyReactor
           end
 
           {
-            configured: {
-              limits: config[:limits].map do |window|
-                {
-                  name: window[:name],
-                  limit: window[:limit],
-                  period_seconds: window[:period_seconds]
-                }
-              end
-            },
+            configured: { limits: map_limits(config[:limits]) },
             key: key,
             state: windows
           }
         rescue StandardError => e
           {
-            configured: {
-              limits: config[:limits]&.map do |window|
-                {
-                  name: window[:name],
-                  limit: window[:limit],
-                  period_seconds: window[:period_seconds]
-                }
-              end
-            },
+            configured: { limits: map_limits(config[:limits]) },
             key: nil,
             key_error: e.message
           }
         end
 
+        def map_limits(limits)
+          Array(limits).map do |window|
+            {
+              name: window[:name],
+              limit: window[:limit],
+              period_seconds: window[:period_seconds]
+            }
+          end
+        end
+
         def build_period(config, inputs, adapter)
           key = resolve_key(config[:key_proc], inputs)
           every = config[:every]

data/teley/Dockerfile

@@ -0,0 +1,60 @@
+# Dockerfile for teley
+FROM node:24-slim
+
+WORKDIR /app
+
+# Install git and other build deps
+RUN apt-get update && apt-get install -y git && rm -rf /var/lib/apt/lists/*
+
+# Clone teley repo
+RUN git clone https://github.com/logaretm/teley.git .
+
+# Allow native builds for dependencies (like esbuild) via workspace config
+RUN echo "dangerouslyAllowAllBuilds: true" > pnpm-workspace.yaml
+
+# Patch workers/src/durable-object.ts to support default_token
+RUN node -e ' \
+  const fs = require("fs"); \
+  const file = "workers/src/durable-object.ts"; \
+  let content = fs.readFileSync(file, "utf8"); \
+  content = content.replace("const token = url.searchParams.get(\x27token\x27);", "const token = url.searchParams.get(\x27token\x27) || \x27default_token\x27;"); \
+  fs.writeFileSync(file, content, "utf8"); \
+'
+
+# Patch app/pages/live/[roomId].vue to support default_token fallback
+RUN node -e ' \
+  const fs = require("fs"); \
+  const file = "app/pages/live/[roomId].vue"; \
+  let content = fs.readFileSync(file, "utf8"); \
+  content = content.replace("const token = (route.query.token as string) || \x27\x27;", "const token = (route.query.token as string) || \x27default_token\x27;"); \
+  fs.writeFileSync(file, content, "utf8"); \
+'
+
+# Patch app/composables/useSession.ts to default to ruby_reactor_session and default_token
+RUN node -e ' \
+  const fs = require("fs"); \
+  const file = "app/composables/useSession.ts"; \
+  let content = fs.readFileSync(file, "utf8"); \
+  content = content.replace(/const initialize = async \(\): Promise<void> => {[\s\S]*?};/, "const initialize = async (): Promise<void> => {\n    if (initialized.value) return;\n    roomId.value = \x27ruby_reactor_session\x27;\n    receiveToken.value = \x27default_token\x27;\n    isNewSession.value = false;\n    initialized.value = true;\n  };"); \
+  fs.writeFileSync(file, content, "utf8"); \
+'
+
+
+# Enable corepack and install pnpm
+RUN corepack enable && corepack prepare pnpm@latest --activate
+
+# Install dependencies
+RUN pnpm install --frozen-lockfile
+
+# Build the Nuxt static files
+RUN pnpm build
+
+# Expose port
+EXPOSE 3000
+
+ENV HOST=0.0.0.0
+ENV PORT=3000
+
+# Start Cloudflare Pages local dev server via wrangler
+WORKDIR /app/workers
+CMD ["npx", "wrangler", "dev", "--ip", "0.0.0.0", "--port", "3000"]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_reactor
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.1
 platform: ruby
 authors:
 - Artur
@@ -133,12 +133,15 @@ files:
 - lib/ruby_reactor/map/collector.rb
 - lib/ruby_reactor/map/dispatcher.rb
 - lib/ruby_reactor/map/element_executor.rb
-- lib/ruby_reactor/map/execution.rb
 - lib/ruby_reactor/map/helpers.rb
 - lib/ruby_reactor/map/result_enumerator.rb
 - lib/ruby_reactor/max_retries_exhausted_failure.rb
+- lib/ruby_reactor/middleware.rb
+- lib/ruby_reactor/middleware_runner.rb
+- lib/ruby_reactor/open_telemetry.rb
 - lib/ruby_reactor/period.rb
 - lib/ruby_reactor/rate_limit.rb
+- lib/ruby_reactor/rate_limit_registry.rb
 - lib/ruby_reactor/reactor.rb
 - lib/ruby_reactor/registry.rb
 - lib/ruby_reactor/retry_context.rb
@@ -152,7 +155,6 @@ files:
 - lib/ruby_reactor/sidekiq_adapter.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
@@ -184,6 +186,7 @@ files:
 - llms-full.txt
 - llms.txt
 - sig/ruby_reactor.rbs
+- teley/Dockerfile
 homepage: https://github.com/arturictus/ruby_reactor
 licenses: []
 metadata:

data/lib/ruby_reactor/map/execution.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-module RubyReactor
-  module Map
-    class Execution
-      extend Helpers
-
-      def self.perform(arguments)
-        arguments = arguments.transform_keys(&:to_sym)
-        storage = RubyReactor.configuration.storage_adapter
-
-        parent_context = load_parent_context_from_storage(
-          arguments[:parent_context_id], arguments[:parent_reactor_class_name], storage
-        )
-        reactor_class = resolve_reactor_class(arguments[:reactor_class_info])
-        inputs = ContextSerializer.deserialize_value(arguments[:serialized_inputs])
-
-        results = execute_all_elements(
-          source: inputs[:source], mappings: inputs[:mappings],
-          reactor_class: reactor_class, parent_context: parent_context,
-          storage_options: {
-            map_id: arguments[:map_id], storage: storage,
-            parent_reactor_class_name: arguments[:parent_reactor_class_name],
-            strict_ordering: arguments[:strict_ordering],
-            fail_fast: arguments[:fail_fast]
-          }
-        )
-
-        finalize_execution(results, parent_context, arguments[:step_name], arguments[:parent_reactor_class_name],
-                           storage)
-      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(
-              storage_options[:map_id], storage_options[:parent_reactor_class_name]
-            )
-            next if failed_context_id
-          end
-          element_inputs = build_element_inputs(mappings, parent_context, element)
-
-          # 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)
-
-          if result.failure? && storage_options[:fail_fast]
-            storage_options[:storage].store_map_failed_context_id(
-              storage_options[:map_id], child_context.context_id, storage_options[:parent_reactor_class_name]
-            )
-          end
-
-          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.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(
-          options[:map_id], index, ContextSerializer.serialize_value(value), options[:parent_reactor_class_name],
-          strict_ordering: options[:strict_ordering]
-        )
-      end
-
-      def self.finalize_execution(results, parent_context, step_name, parent_reactor_class_name, storage)
-        step_config = Object.const_get(parent_reactor_class_name).steps[step_name.to_sym]
-        final_result = apply_collect_block(results, step_config)
-        resume_parent_execution(parent_context, step_name, final_result, storage)
-      end
-
-      private_class_method :execute_all_elements, :store_result, :finalize_execution
-    end
-  end
-end

data/lib/ruby_reactor/sidekiq_workers/map_execution_worker.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require "sidekiq"
-
-module RubyReactor
-  module SidekiqWorkers
-    class MapExecutionWorker
-      include ::Sidekiq::Worker
-
-      def perform(arguments)
-        RubyReactor::Map::Execution.perform(arguments)
-      end
-    end
-  end
-end