ruby_reactor 0.8.3 → 0.8.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac772fc307621dcf2fba69d726aeb670a34201a0c06e17e1e9213b4779f4cd03
-  data.tar.gz: 5ed6d5e4251643fc16fafaf48ecde75aa31f95cc09f9b1fe9d0b879b190fa61b
+  metadata.gz: 325464f0f2b9ee374b1267a4c7243121c9b564814d425bfa5ecce59891979468
+  data.tar.gz: 996363b210d54be36ac7065532aac6c0349334b18d8d14816896debd4e8993c4
 SHA512:
-  metadata.gz: c61a1ec89ce310154e5bd9d2b09c3dc997e682a83d1bb5b18a87d47128f792133e27e7c8648db699cbfa5de8830522dad9bdfbb7b953addf89273fa3eb3042e0
-  data.tar.gz: b78511087cfccec3eb6912000c3d744fa0f1cabca1f87eed9a500d223eb2aa4e6d1e4219a85eb2c6774f54e14493179d3c86ba836e4012cf9a86ec3a553955c1
+  metadata.gz: 3fcbdbe30cce51beec8dd715c543c8db15140de630d94ec3ae01a7ba803d28cb88f44e0ce1ee97c232cbed34863d81b8c4d0ed979f44acf52a27cfbc07f31b04
+  data.tar.gz: 946f4082ec39691d47e35983b9466a128246159f0b191aca061d6c984e2340cabd09da8e111e92b4799ec97a8f4e9753826163e97df48424b3a1583abe40afbc

data/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.8.3"
+  ".": "0.8.4"
 }

data/.specify/feature.json

@@ -1,3 +1,3 @@
 {
-  "feature_directory": "specs/005-step-coordination-remediation"
+  "feature_directory": "specs/006-step-retry-declarations"
 }

data/CHANGELOG.md

@@ -204,6 +204,18 @@
 * Docs: a park keeps each level's lock without a second `:lock_acquired` only while the gap stays
   within the lock's `ttl`; a lapsed lock is acquired again.
 
+## [0.8.4](https://github.com/arturictus/ruby_reactor/compare/v0.8.3...v0.8.4) (2026-09-26)
+
+
+### ⚠ BREAKING CHANGES
+
+* `retry_defaults` on a reactor raises RubyReactor::Error::DeprecatedDslError. Migration: move the values onto each step that should retry (`retries max_attempts: 3, backoff: :exponential, base_delay: 2` inside the step block, or on the step class once supported). A step without `retries` runs once. `max_attempts: 0` is not valid: use `max_attempts: 1` (or omit `retries`) for a step that must never retry.
+
+### Features
+
+* implement step-scoped retry declarations ([#61](https://github.com/arturictus/ruby_reactor/issues/61)) ([75d9c4e](https://github.com/arturictus/ruby_reactor/commit/75d9c4edca1a6ec53183d56c9c6261e792c98cc2))
+* Inputs protection ([#63](https://github.com/arturictus/ruby_reactor/issues/63)) ([faf90e8](https://github.com/arturictus/ruby_reactor/commit/faf90e8dbfff87f6492af863b90e8247c84bd673))
+
 ## [0.8.3](https://github.com/arturictus/ruby_reactor/compare/v0.8.2...v0.8.3) (2026-09-25)
 
 

data/CLAUDE.md

@@ -1,5 +1,5 @@
 <!-- SPECKIT START -->
 For additional context about technologies to be used, project structure,
 shell commands, and other important information, read the current plan
-at specs/005-step-coordination-remediation/plan.md
+at specs/006-step-retry-declarations/plan.md
 <!-- SPECKIT END -->

data/README.md

@@ -21,7 +21,7 @@ The key value is **Reliability**: if any part of your workflow fails, Ruby React
 - **Background Execution**: Hand a whole reactor, or everything after a declared step, to a background job via Sidekiq or ActiveJob (so any ActiveJob-compatible queue — Resque, Solid Queue, GoodJob, etc. — works too).
 - **Async Steps & Reactors**: `async_step` and `async_reactor` dispatch independent units of work while the reactor keeps running; steps that read their result wait for it.
 - **Map & Parallel Execution**: Iterate over collections in parallel with the `map` step, distributing work across multiple workers.
-- **Retries**: Configurable retry logic for failed steps, with exponential backoff.
+- **Retries**: per-step retry policies (declared on the step class or step block) with exponential, linear, or fixed backoff.
 - **Compensation**: Automatic rollback of completed steps when a failure occurs.
 - **Interrupts**: Pause and resume workflows to wait for external events (webhooks, user approvals).
 - **Input Validation**: Integrated with `dry-validation` for robust input checking.
@@ -247,14 +247,16 @@ One-line helpers end a step immediately from any call depth: `success!(value)`,
 class ReserveInventoryStep < RubyReactor::Step
   # The step's input contract: enforced before `run` on every execution path.
   input :order, :hash
+  # The step's retry policy: applies in every reactor that uses this step.
+  retries max_attempts: 3
 
   def run
-    reservation_id = InventoryService.reserve(inputs[:order][:items])
+    reservation_id = InventoryService.reserve(inputs.order[:items])
     Success(reservation_id: reservation_id)
   end
 
   def compensate
-    InventoryService.release_partial(inputs[:order][:items])
+    InventoryService.release_partial(inputs.order[:items])
     Success()
   end
 
@@ -327,7 +329,7 @@ require 'ruby_reactor'
 
 class ValidateEmailStep < RubyReactor::Step
   def run
-    email = inputs[:email]
+    email = inputs.email
     email&.include?('@') ? Success(email.strip) : Failure("Email must contain @")
   end
 end
@@ -336,14 +338,14 @@ class CreateUserStep < RubyReactor::Step
   def run
     Success(
       id: rand(10000),
-      email: inputs[:email],
-      password_hash: inputs[:password_hash],
+      email: inputs.email,
+      password_hash: inputs.password_hash,
       created_at: Time.now
     )
   end
 
   def compensate
-    Notify.to(inputs[:email])
+    Notify.to(inputs.email)
     Success()
   end
 end
@@ -358,9 +360,9 @@ class UserRegistrationReactor < RubyReactor::Reactor
 
   step :hash_password do
     argument :password, input(:password)
-    run do |args, _context|
+    run do |inputs, _context|
       require 'digest'
-      Success(Digest::SHA256.hexdigest(args[:password]))
+      Success(Digest::SHA256.hexdigest(inputs.password))
     end
   end
 
@@ -373,13 +375,13 @@ class UserRegistrationReactor < RubyReactor::Reactor
     argument :email, result(:validate_email)
     wait_for :create_user
 
-    run do |args, _context|
-      Email.send!(args[:email], "verify your email")
+    run do |inputs, _context|
+      Email.send!(inputs.email, "verify your email")
       Success()
     end
 
-    compensate do |_error, args, _context|
-      Email.send("support@acme.com", "Email verification for #{args[:email]} couldn't be sent")
+    compensate do |_error, inputs, _context|
+      Email.send("support@acme.com", "Email verification for #{inputs.email} couldn't be sent")
       Success()
     end
   end
@@ -443,12 +445,12 @@ class CreateUserReactor < RubyReactor::Reactor
   input :params
 
   step :validate_inputs do
-    run { |args| validate(args[:params]) }
+    run { |inputs| validate(inputs.params) }
   end
 
   step :create_user do
     argument :params, result(:validate_inputs)
-    run { |args| User.create(args[:params]) }
+    run { |inputs| User.create(inputs.params) }
   end
 
   # :create_user is the LAST step to run in the calling process.
@@ -457,13 +459,13 @@ class CreateUserReactor < RubyReactor::Reactor
 
   step :open_account do
     argument :user, result(:create_user)
-    run { |args| Bank.open_account(args[:user]) }
+    run { |inputs| Bank.open_account(inputs.user) }
   end
 
   step :report_new_user do
     argument :user, result(:create_user)
     wait_for :open_account
-    run { |args| Analytics.track(args[:user]) }
+    run { |inputs| Analytics.track(inputs.user) }
   end
 end
 
@@ -514,19 +516,19 @@ class SignupReactor < RubyReactor::Reactor
 
   async_step :send_email do
     argument :to, input(:email)
-    run { |args| Mailer.welcome(args[:to]).deliver_now; Success(:sent) }
+    run { |inputs| Mailer.welcome(inputs.to).deliver_now; Success(:sent) }
   end
 
   # Does NOT wait — it has no dependency on :send_email.
   step :record_signup do
     argument :email, input(:email)
-    run { |args| Success(Signup.create!(email: args[:email])) }
+    run { |inputs| Success(Signup.create!(email: inputs.email)) }
   end
 
   # DOES wait, because it reads the result.
   step :confirm_delivery do
     argument :delivery, result(:send_email)
-    run { |args| Success("confirmed") }
+    run { |inputs| Success("confirmed") }
   end
 end
 ```
@@ -564,8 +566,8 @@ class SignupReactor < RubyReactor::Reactor
 
   step :verify do
     argument :account, result(:provision_account)   # waits for the child
-    run do |args|
-      args[:account].success? ? Success(args[:account].value) : Failure(args[:account].error)
+    run do |inputs|
+      inputs.account.success? ? Success(inputs.account.value) : Failure(inputs.account.error)
     end
   end
 end
@@ -667,7 +669,7 @@ Pause execution to wait for external events like webhooks or user approvals.
 ```ruby
 class ApprovalReactor < RubyReactor::Reactor
   step :submit_request do
-    run { |args| RequestService.submit(args) }
+    run { |inputs| RequestService.submit(inputs.to_h) }
   end
 
   interrupt :wait_for_manager do
@@ -678,8 +680,8 @@ class ApprovalReactor < RubyReactor::Reactor
 
   step :process_decision do
     argument :decision, result(:wait_for_manager)
-    run do |args| 
-      args[:decision] == 'approved' ? Success() : Failure("Rejected")
+    run do |inputs| 
+      inputs.decision == 'approved' ? Success() : Failure("Rejected")
     end
   end
 end
@@ -716,7 +718,7 @@ class RefundOrderReactor < RubyReactor::Reactor
 
   step :refund do
     argument :order_id, input(:order_id)
-    run { |args| PaymentGateway.refund(args[:order_id]) }
+    run { |inputs| PaymentGateway.refund(inputs.order_id) }
   end
 end
 
@@ -745,7 +747,7 @@ class GeocodeReactor < RubyReactor::Reactor
 
   step :geocode do
     argument :address, input(:address)
-    run { |args| Geocoder.lookup(args[:address]) }
+    run { |inputs| Geocoder.lookup(inputs.address) }
   end
 end
 
@@ -759,7 +761,7 @@ class MonthlyBillingReactor < RubyReactor::Reactor
 
   step :build do
     argument :org_id, input(:org_id)
-    run { |args| Billing.generate(args[:org_id]) }
+    run { |inputs| Billing.generate(inputs.org_id) }
   end
 end
 
@@ -775,7 +777,7 @@ class ChargeReactor < RubyReactor::Reactor
 
   step :charge do
     argument :account_id, input(:account_id)
-    run { |args| Stripe.charge(args[:account_id]) }
+    run { |inputs| Stripe.charge(inputs.account_id) }
   end
 end
 
@@ -792,7 +794,7 @@ class OrderedTransactionReactor < RubyReactor::Reactor
 
   step :apply do
     argument :transaction, input(:transaction)
-    run { |args| Ledger.apply(args[:transaction]) }
+    run { |inputs| Ledger.apply(inputs.transaction) }
   end
 end
 
@@ -816,7 +818,7 @@ class ChargeReactor < RubyReactor::Reactor
 
   step :charge do
     argument :account_id, input(:account_id)
-    run { |args| Stripe.charge(args[:account_id]) }
+    run { |inputs| Stripe.charge(inputs.account_id) }
   end
 end
 ```
@@ -841,9 +843,9 @@ A step's `run` block can also return `Halt(reason: "...")` to stop the reactor c
 ```ruby
 step :ensure_active do
   argument :user, result(:fetch_user)
-  run do |args, _ctx|
-    next Halt(reason: "user_opted_out") if args[:user].opted_out?
-    Success(args[:user])
+  run do |inputs, _ctx|
+    next Halt(reason: "user_opted_out") if inputs.user.opted_out?
+    Success(inputs.user)
   end
 end
 ```
@@ -853,9 +855,9 @@ To skip a *single* step while the reactor continues — the step did nothing, bu
 ```ruby
 step :maybe_sync do
   argument :user, result(:fetch_user)
-  run do |args, _ctx|
-    next Skipped(args[:user]) if args[:user].already_synced?
-    Success(sync!(args[:user]))
+  run do |inputs, _ctx|
+    next Skipped(inputs.user) if inputs.user.already_synced?
+    Success(sync!(inputs.user))
   end
 end
 ```
@@ -879,7 +881,7 @@ class DataProcessingReactor < RubyReactor::Reactor
 
     step :transform do
       argument :item, input(:item)
-      run { |args| transform_item(args[:item]) }
+      run { |inputs| transform_item(inputs.item) }
     end
 
     returns :transform
@@ -913,7 +915,7 @@ map :archive_old_users do
 
   step :archive do
     argument :user, input(:user)
-    run { |args| args[:user].archive! }
+    run { |inputs| inputs.user.archive! }
   end
   
   returns :archive
@@ -921,9 +923,9 @@ end
 
 step :summary do
   argument :results, result(:archive_old_users)
-  run do |args|
-    puts "Archived: #{args[:results].successes.count}"
-    puts "Failed: #{args[:results].failures.count}"
+  run do |inputs|
+    puts "Archived: #{inputs.results.successes.count}"
+    puts "Failed: #{inputs.results.failures.count}"
     Success()
   end
 end
@@ -1005,12 +1007,12 @@ class ValidatedUserReactor < RubyReactor::Reactor
     argument :age, input(:age)
     argument :bio, input(:bio)
 
-    run do |args, context|
+    run do |inputs, context|
       profile = {
-        name: args[:name],
-        email: args[:email],
-        age: args[:age],
-        bio: args[:bio] || "No bio provided",
+        name: inputs.name,
+        email: inputs.email,
+        age: inputs.age,
+        bio: inputs.bio || "No bio provided",
         created_at: Time.now
       }
       Success(profile)
@@ -1124,7 +1126,7 @@ step :charge do
   argument :amount,   input(:amount)
   argument :currency, input(:currency)
 
-  run { |args, _| charge!(args) }
+  run { |inputs, _| charge!(inputs) }
 end
 ```
 
@@ -1201,9 +1203,9 @@ class OrderProcessingReactor < RubyReactor::Reactor
   step :validate_user do
     argument :user_id, input(:user_id)
 
-    run do |args, context|
+    run do |inputs, context|
       # Check if user exists and has permission to purchase
-      user = find_user(args[:user_id])
+      user = find_user(inputs.user_id)
       user ? Success(user) : Failure("User not found")
     end
   end
@@ -1211,8 +1213,8 @@ class OrderProcessingReactor < RubyReactor::Reactor
   step :validate_products do
     argument :product_ids, input(:product_ids)
 
-    run do |args, context|
-      products = args[:product_ids].map { |id| find_product(id) }
+    run do |inputs, context|
+      products = inputs.product_ids.map { |id| find_product(id) }
       if products.all?
         Success(products)
       else
@@ -1224,8 +1226,8 @@ class OrderProcessingReactor < RubyReactor::Reactor
   step :calculate_total do
     argument :products, result(:validate_products)
 
-    run do |args, context|
-      total = args[:products].sum { |p| p[:price] }
+    run do |inputs, context|
+      total = inputs.products.sum { |p| p[:price] }
       Success(total)
     end
   end
@@ -1233,8 +1235,8 @@ class OrderProcessingReactor < RubyReactor::Reactor
   step :check_inventory do
     argument :products, result(:validate_products)
 
-    run do |args, context|
-      available = args[:products].all? { |p| p[:stock] > 0 }
+    run do |inputs, context|
+      available = inputs.products.all? { |p| p[:stock] > 0 }
       available ? Success(true) : Failure("Out of stock")
     end
   end
@@ -1243,15 +1245,15 @@ class OrderProcessingReactor < RubyReactor::Reactor
     argument :user, result(:validate_user)
     argument :total, result(:calculate_total)
 
-    run do |args, context|
+    run do |inputs, context|
       # Process payment logic here
-      payment_id = process_payment(args[:user][:id], args[:total])
+      payment_id = process_payment(inputs.user[:id], inputs.total)
       Success(payment_id)
     end
 
-    undo do |error, args, context|
+    undo do |error, inputs, context|
       # Refund payment on failure
-      refund_payment(args[:payment_id])
+      refund_payment(inputs.payment_id)
       Success()
     end
   end
@@ -1261,14 +1263,14 @@ class OrderProcessingReactor < RubyReactor::Reactor
     argument :products, result(:validate_products)
     argument :payment_id, result(:process_payment)
 
-    run do |args, context|
-      order = create_order_record(args[:user], args[:products], args[:payment_id])
+    run do |inputs, context|
+      order = create_order_record(inputs.user, inputs.products, inputs.payment_id)
       Success(order)
     end
 
-    undo do |error, args, context|
+    undo do |error, inputs, context|
       # Cancel order and update inventory
-      cancel_order(args[:order][:id])
+      cancel_order(inputs.order[:id])
       Success()
     end
   end
@@ -1276,14 +1278,14 @@ class OrderProcessingReactor < RubyReactor::Reactor
   step :update_inventory do
     argument :products, result(:validate_products)
 
-    run do |args, context|
-      args[:products].each { |p| decrement_stock(p[:id]) }
+    run do |inputs, context|
+      inputs.products.each { |p| decrement_stock(p[:id]) }
       Success(true)
     end
 
-    undo do |error, args, context|
+    undo do |error, inputs, context|
       # Restock products
-      args[:products].each { |p| increment_stock(p[:id]) }
+      inputs.products.each { |p| increment_stock(p[:id]) }
       Success()
     end
   end
@@ -1292,8 +1294,8 @@ class OrderProcessingReactor < RubyReactor::Reactor
     argument :user, result(:validate_user)
     argument :order, result(:create_order)
 
-    run do |args, context|
-      send_email(args[:user][:email], "Order confirmed", order_details(args[:order]))
+    run do |inputs, context|
+      send_email(inputs.user[:email], "Order confirmed", order_details(inputs.order))
       Success(true)
     end
   end
@@ -1316,9 +1318,9 @@ class TransactionReactor < RubyReactor::Reactor
     argument :from_account, input(:from_account)
     argument :to_account, input(:to_account)
 
-    run do |args, context|
-      from = find_account(args[:from_account])
-      to = find_account(args[:to_account])
+    run do |inputs, context|
+      from = find_account(inputs.from_account)
+      to = find_account(inputs.to_account)
 
       if from && to && from != to
         Success({from: from, to: to})
@@ -1332,9 +1334,9 @@ class TransactionReactor < RubyReactor::Reactor
     argument :accounts, result(:validate_accounts)
     argument :amount, input(:amount)
 
-    run do |args, context|
-      if args[:accounts][:from][:balance] >= args[:amount]
-        Success(args[:accounts])
+    run do |inputs, context|
+      if inputs.accounts[:from][:balance] >= inputs.amount
+        Success(inputs.accounts)
       else
         Failure("Insufficient funds")
       end
@@ -1345,14 +1347,14 @@ class TransactionReactor < RubyReactor::Reactor
     argument :accounts, result(:check_balance)
     argument :amount, input(:amount)
 
-    run do |args, context|
-      debit(args[:accounts][:from][:id], args[:amount])
-      Success(args[:accounts])
+    run do |inputs, context|
+      debit(inputs.accounts[:from][:id], inputs.amount)
+      Success(inputs.accounts)
     end
 
-    undo do |error, args, context|
+    undo do |error, inputs, context|
       # Credit the amount back
-      credit(args[:accounts][:from][:id], args[:amount])
+      credit(inputs.accounts[:from][:id], inputs.amount)
       Success()
     end
   end
@@ -1361,14 +1363,14 @@ class TransactionReactor < RubyReactor::Reactor
     argument :accounts, result(:debit_account)
     argument :amount, input(:amount)
 
-    run do |args, context|
-      credit(args[:accounts][:to][:id], args[:amount])
+    run do |inputs, context|
+      credit(inputs.accounts[:to][:id], inputs.amount)
       Success({transaction_id: generate_transaction_id()})
     end
 
-    undo do |error, args, context|
+    undo do |error, inputs, context|
       # Debit the amount back from recipient
-      debit(args[:accounts][:to][:id], args[:amount])
+      debit(inputs.accounts[:to][:id], inputs.amount)
       Success()
     end
   end
@@ -1377,9 +1379,9 @@ class TransactionReactor < RubyReactor::Reactor
     argument :accounts, result(:validate_accounts)
     wait_for :credit_account, :debit_account
 
-    run do |args, context|
-      Notify.to(args[:accounts][:from])
-      Notify.to(args[:accounts][:to])
+    run do |inputs, context|
+      Notify.to(inputs.accounts[:from])
+      Notify.to(inputs.accounts[:to])
     end
      
   end
@@ -1430,8 +1432,8 @@ class SchemaValidatedReactor < RubyReactor::Reactor
   step :process_user do
     argument :user, input(:user)
 
-    run do |args, context|
-      Success(args[:user])
+    run do |inputs, context|
+      Success(inputs.user)
     end
   end
 
@@ -1483,7 +1485,7 @@ Discover how to build complex, modular workflows by composing reactors within ot
 Master the `map` feature for processing collections. Learn about parallel execution, batch processing for large datasets, and error handling strategies like fail-fast vs. partial result collection.
 
 ### [Retry Configuration](documentation/retry_configuration.md)
-Configure robust retry policies for your steps. This guide details the available backoff strategies (exponential, linear, fixed), how to configure retries at the reactor or step level, and how background retries work without blocking workers.
+Configure robust retry policies for your steps. This guide details the available backoff strategies (exponential, linear, fixed), how to declare retries on a step class or inline step, and how background retries work without blocking workers.
 
 ### [Interrupts](documentation/interrupts.md)
 Learn how to pause and resume reactors to handle long-running processes, manual approvals, and asynchronous callbacks. Patterns for correlation IDs, timeouts, and payload validation.

data/lib/ruby_reactor/dsl/async_reactor_builder.rb

@@ -10,6 +10,7 @@ module RubyReactor
     # ordering nonce.
     class AsyncReactorBuilder
       include RubyReactor::Dsl::TemplateHelpers
+      include RubyReactor::Dsl::Retryable
 
       attr_accessor :name, :child_reactor_class, :argument_mappings
 
@@ -18,17 +19,13 @@ module RubyReactor
         @child_reactor_class = child_reactor_class
         @reactor = reactor
         @argument_mappings = {}
-        @retry_config = {}
+        @retry_config = nil
       end
 
       def argument(child_input_name, source)
         @argument_mappings[child_input_name] = source
       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
         RubyReactor::Dsl::StepConfig.new(
           async_dispatch: :reactor,
@@ -49,7 +46,7 @@ module RubyReactor
           dependencies: dependencies_from_mappings,
           args_validator: nil,
           output_validator: nil,
-          retry_config: @retry_config.empty? ? (@reactor&.retry_defaults || {}) : @retry_config
+          retry_config: @retry_config
         )
       end
 

data/lib/ruby_reactor/dsl/compose_builder.rb

@@ -4,6 +4,7 @@ module RubyReactor
   module Dsl
     class ComposeBuilder
       include RubyReactor::Dsl::TemplateHelpers
+      include RubyReactor::Dsl::Retryable
 
       attr_accessor :name, :composed_reactor_class, :argument_mappings
 
@@ -20,7 +21,7 @@ module RubyReactor
         end
         @reactor = reactor
         @argument_mappings = {}
-        @retry_config = {}
+        @retry_config = nil
       end
 
       def argument(composed_input_name, source)
@@ -44,14 +45,6 @@ module RubyReactor
         )
       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
         warn_if_child_has_ordered_lock!
         dependencies = extract_dependencies_from_mappings
@@ -71,7 +64,7 @@ module RubyReactor
           dependencies: dependencies,
           args_validator: nil,
           output_validator: nil,
-          retry_config: @retry_config.empty? ? (@reactor&.retry_defaults || {}) : @retry_config
+          retry_config: @retry_config
         }
 
         RubyReactor::Dsl::StepConfig.new(step_config)

data/lib/ruby_reactor/dsl/reactor.rb

@@ -11,7 +11,6 @@ module RubyReactor
         base.instance_variable_set(:@middlewares, [])
         base.instance_variable_set(:@input_validations, {})
         base.instance_variable_set(:@background_handoff, nil)
-        base.instance_variable_set(:@retry_defaults, { max_attempts: 3, backoff: :exponential, base_delay: 1 })
       end
 
       module ClassMethods
@@ -55,16 +54,14 @@ module RubyReactor
                 "inputs inside the worker."
         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
+        # Reactor-wide retry defaults are gone: the builders snapshotted them at
+        # `step` time, so they silently applied only to steps declared AFTER
+        # the `retry_defaults` line. A step's retry policy now lives on the step.
+        def retry_defaults(*, **)
+          raise RubyReactor::Error::DeprecatedDslError,
+                "`retry_defaults` has been removed from #{name || "this reactor"}: reactor-wide defaults " \
+                "silently applied only to steps declared after them. Declare `retries` on each step class " \
+                "(or step block) that should retry; a step with no `retries` runs once."
         end
 
         # rubocop:disable Metrics/ParameterLists