axn 0.1.0.pre.alpha.2.5.1.2 → 0.1.0.pre.alpha.2.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 42cc1a4a04b3e66593f20e8c705d21b18d0805b335ecc0f466aadbe66a4b34b1
-  data.tar.gz: 6e402f557bac045b01271a782a549264b52435a31ce4422b9023df3305cc378d
+  metadata.gz: d62aa4b98c8f159761234817e6b2ded26e0fcafa46d07685049d827281e92235
+  data.tar.gz: d3ffb46353e17db427393049767a6a03fbf3d5b30e94e4011a47397644364c32
 SHA512:
-  metadata.gz: 2dc07f5c6be221dc0d46961c8ea2810ed42a8b17d5bc195f4b695b782695f489259f6e9f6c4369b2e13e2b87f1a779db7fb71dbf8fd59b5712169512bac2c217
-  data.tar.gz: d772ed5b642945eaa6ed3c09d0161b26e7763ec692e481d70df893b88a9d1779018978806fb10459d84f8479eb2a5616a56e4c109723dc610227ec0e41998502
+  metadata.gz: 54a4ea06f021850cc1d4e1e9bf18a6ec20f495871f23efab20380cd2a8135c52df46099f03281944c4dbe4419c836a72309cfd719e769ae3fd7e48a2ad7683db
+  data.tar.gz: 474eea3af1b53ad4ae85096a2e39d4b141b01c8c4f239f710cd13de933046d92b7efc67333902c78ed29c882bda5ada0a44e9e2efeab05721681f5ded1633b41

data/.rubocop.yml

@@ -27,6 +27,12 @@ Style/TrailingCommaInArrayLiteral:
 Style/TrailingCommaInHashLiteral:
   EnforcedStyleForMultiline: comma
 
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Style/HashSyntax:
+  EnforcedShorthandSyntax: always
+
 Style/DoubleNegation:
   Enabled: false
 

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## Unreleased
+* N/A
+
+## 0.1.0-alpha.2.5.3
+* More aggressive logging of swallowed exceptions when not in production mode
+* Make automatic pre/post logging more digestible
+
+## 0.1.0-alpha.2.5.2
+* [BREAKING] Removing `EnqueueAllInBackground` + `EnqueueAllWorker` - better + simply solved at application level
+* [TEST] Expose spec helpers to consumers (add `require "axn/testing/spec_helpers"` to your `spec_helper.rb`)
+# [FEAT] Added ability to use custom Strategies (via e.g. `use :transaction`)
+
 ## 0.1.0-alpha.2.5.1.2
 * [BUGFIX] Subfield expectations: now support hashes with string keys (using with_indifferent_access)
 * [BUGFIX] Subfield expectations: Model reader fields now cache initial value (otherwise get fresh instance each call, cannot make in-memory changes)

data/docs/.vitepress/config.mjs

@@ -47,6 +47,13 @@ export default defineConfig({
           { text: 'Testing Actions', link: '/recipes/testing' },
         ]
       },
+      {
+        text: 'Strategies',
+        items: [
+          { text: 'Overview', link: '/strategies/index' },
+          { text: 'Transaction', link: '/strategies/transaction' },
+        ]
+      },
       {
         text: 'Additional Notes',
         items: [

data/docs/reference/configuration.md

@@ -36,6 +36,22 @@ For example, if you're using Honeybadger this could look something like:
   end
 ```
 
+**Note:** The `action:` and `context:` keyword arguments are *optional*—your proc can accept any combination of `e`, `action:`, and `context:`. Only the keyword arguments you explicitly declare will be passed to your handler. All of the following are valid:
+
+```ruby
+  # Only exception object
+  c.on_exception = proc { |e| ... }
+
+  # Exception and action
+  c.on_exception = proc { |e, action:| ... }
+
+  # Exception and context
+  c.on_exception = proc { |e, context:| ... }
+
+  # Exception, action, and context
+  c.on_exception = proc { |e, action:, context:| ... }
+```
+
 A couple notes:
 
   * `context` will contain the arguments passed to the `action`, _but_ any marked as sensitive (e.g. `expects :foo, sensitive: true`) will be filtered out in the logs.

data/docs/strategies/index.md

@@ -0,0 +1,272 @@
+# Strategies
+
+Strategies in Axn are reusable modules that provide common functionality and configuration patterns for your actions. They allow you to DRY up your code by encapsulating frequently used behaviors into named, configurable modules.
+
+## What are Strategies?
+
+Strategies are Ruby modules that can be included into your actions to add specific functionality. They're designed to be:
+
+- **Reusable**: Once defined, they can be used across multiple actions
+- **Configurable**: Many strategies support configuration options
+- **Composable**: You can use multiple strategies in a single action
+- **Discoverable**: Built-in strategies are automatically loaded, and custom ones can be registered
+
+## How to Use Strategies
+
+### Basic Usage
+
+To use a strategy in your action, call the `use` method with the strategy name:
+
+```ruby
+class CreateUser
+  include Action
+
+  use :transaction
+
+  expects :email, :name
+
+  def call
+    # This action will now run within a database transaction (including before/after hooks)
+    user = User.create!(email: email, name: name)
+    expose :user, user
+  end
+end
+```
+
+### Using Strategies with Configuration
+
+Some strategies support configuration options. These strategies have a `setup` method that accepts configuration and returns a configured module.  As an _imaginary_ example:
+
+```ruby
+class ProcessPayment
+  include Action
+
+  use :retry, max_attempts: 3, backoff: :exponential
+
+  expects :amount, :card_token
+
+  def call
+    # This action will retry up to 3 times with exponential backoff
+    result = PaymentProcessor.charge(amount, card_token)
+    expose :transaction_id, result.id
+  end
+end
+```
+
+## Built-in Strategies
+
+The list of built in strategies is available via `Action::Strategies.built_in`.
+
+## Registering Custom Strategies
+
+### Simple Strategies
+
+To create a custom strategy, define a module that extends `ActiveSupport::Concern`:
+
+```ruby
+module MyCustomStrategy
+  extend ActiveSupport::Concern
+
+  included do
+    # Add your strategy behavior here
+    # For example, add hooks, validations, or other functionality
+    before { log("Custom strategy before hook") }
+    after { log("Custom strategy after hook") }
+  end
+end
+```
+
+Then register it with the strategies system:
+
+```ruby
+Action::Strategies.register(:my_custom, MyCustomStrategy)
+```
+
+Now you can use it in your actions:
+
+```ruby
+class MyAction
+  include Action
+
+  use :my_custom
+
+  def call
+    # Your action implementation
+  end
+end
+```
+
+### Configurable Strategies
+
+For strategies that need configuration, implement a `setup` method that returns a configured module:
+
+```ruby
+module RetryStrategy
+  extend ActiveSupport::Concern
+
+  def self.setup(max_attempts: 3, backoff: :linear, &block)
+    Module.new do
+      extend ActiveSupport::Concern
+
+      included do
+        around do |hooked|
+          attempts = 0
+          begin
+            attempts += 1
+            hooked.call
+          rescue StandardError => e
+            if attempts < max_attempts
+              sleep(backoff_delay(attempts, backoff))
+              retry
+            else
+              raise e
+            end
+          end
+        end
+      end
+
+      private
+
+      def backoff_delay(attempt, type)
+        case type
+        when :linear
+          attempt * 0.1
+        when :exponential
+          0.1 * (2 ** (attempt - 1))
+        else
+          0.1
+        end
+      end
+    end
+  end
+end
+
+# Register the strategy
+Action::Strategies.register(:retry, RetryStrategy)
+```
+
+### Strategy Registration Best Practices
+
+1. **Register early**: Register custom strategies during application initialization
+2. **Use descriptive names**: Choose strategy names that clearly indicate their purpose
+3. **Handle configuration validation**: Validate configuration options in your `setup` method
+4. **Return proper modules**: Always return a module from the `setup` method
+5. **Document your strategies**: Include clear documentation for how to use your custom strategies
+
+### Example: Complete Custom Strategy
+
+Here's a complete example of a custom strategy that adds performance monitoring:
+
+```ruby
+module PerformanceMonitoringStrategy
+  extend ActiveSupport::Concern
+
+  def self.setup(threshold_ms: 1000, notify_slow: false, &block)
+    Module.new do
+      extend ActiveSupport::Concern
+
+      included do
+        around do |hooked|
+          start_time = Time.current
+          result = hooked.call
+          duration = ((Time.current - start_time) * 1000).round(2)
+
+          if duration > threshold_ms
+            log("Action took #{duration}ms (threshold: #{threshold_ms}ms)", level: :warn)
+            notify_slow_action(duration) if notify_slow
+          else
+            log("Action completed in #{duration}ms", level: :info)
+          end
+
+          result
+        end
+      end
+
+      private
+
+      def notify_slow_action(duration)
+        # In a real implementation, this might send to a monitoring service
+        # like New Relic, DataDog, or a custom alerting system
+        Rails.logger.warn("SLOW ACTION ALERT: #{self.class.name} took #{duration}ms")
+      end
+    end
+  end
+end
+
+# Register the strategy
+Action::Strategies.register(:performance_monitoring, PerformanceMonitoringStrategy)
+
+# Use it in an action
+class ExpensiveCalculation
+  include Action
+
+  use :performance_monitoring, threshold_ms: 500, notify_slow: true
+
+  expects :data
+
+  def call
+    # This action will be monitored for performance
+    result = perform_expensive_calculation(data)
+    expose :result, result
+  end
+
+  private
+
+  def perform_expensive_calculation(data)
+    # Simulate expensive operation
+    sleep(0.1)
+    data.map { |item| item * 2 }
+  end
+end
+```
+
+## Strategy Management
+
+### Viewing Available Strategies
+
+You can inspect all registered strategies:
+
+```ruby
+Action::Strategies.all
+# Returns a hash of strategy names to their modules
+```
+
+### Finding Specific Strategies
+
+To find a specific strategy by name:
+
+```ruby
+Action::Strategies.find(:transaction)
+# Returns the strategy module for the transaction strategy
+
+Action::Strategies.find(:nonexistent)
+# Raises Action::StrategyNotFound: Strategy 'nonexistent' not found
+```
+
+The `find` method is useful when you need to programmatically access a strategy module or verify that a strategy exists before using it.
+
+### Clearing Strategies
+
+To reset strategies to only built-in ones (useful in tests):
+
+```ruby
+Action::Strategies.clear!
+```
+
+### Strategy Errors
+
+The following errors may be raised when using strategies:
+
+- `Action::StrategyNotFound`: When trying to use a strategy that hasn't been registered
+- `Action::DuplicateStrategyError`: When trying to register a strategy with a name that's already taken
+- `ArgumentError`: When providing configuration to a strategy that doesn't support it
+
+## Best Practices
+
+1. **Keep strategies focused**: Each strategy should have a single, well-defined responsibility
+2. **Use meaningful names**: Strategy names should clearly indicate their purpose
+3. **Document configuration**: If your strategy accepts configuration, document all available options
+4. **Test your strategies**: Write tests for your custom strategies to ensure they work correctly
+5. **Consider composition**: Design strategies to work well together when used in combination
+
+

data/docs/strategies/transaction.md

@@ -0,0 +1,29 @@
+# Transaction Strategy
+
+The `transaction` strategy wraps your action execution in a database transaction:
+
+```ruby
+class TransferFunds
+  include Action
+
+  use :transaction
+
+  expects :from_account, :to_account, :amount
+
+  def call
+    from_account.withdraw!(amount)
+    to_account.deposit!(amount)
+    expose :transfer_id, SecureRandom.uuid
+  end
+end
+```
+
+**Important**: The transaction wraps the entire action execution, including:
+- `before` hooks
+- The main `call` method
+- `after` hooks
+- Success/failure callbacks (`on_success`, `on_failure`, etc.)
+
+This means that if any part of the action (including hooks or callbacks) raises an exception or calls `fail!`, the entire transaction will be rolled back.
+
+**Requirements**: Requires ActiveRecord to be available in your application.

data/docs/usage/using.md

@@ -55,33 +55,3 @@ Sidekiq integration is NOT YET TESTED/NOT YET USED IN OUR APP, and naming will V
     * enqueue will not retry even if fails
     * enqueue! will go through normal sidekiq retries on any failure (including user-facing `fail!`)
     * Note implicit GlobalID support (if not serializable, will get ArgumentError at callsite)
-
-
-### `.enqueue_all_in_background`
-
-In practice it's fairly common to need to enqueue a bunch of sidekiq jobs from a clock process.
-
-One approach is to define a class-level `.enqueue_all` method on your Action... but that ends up executing the enqueue_all logic directly from the clock process, which is undesirable.
-
-
-::: danger ALPHA
-We are actively testing this pattern -- not yet certain we'll keep it past beta.
-:::
-
-Therefore we've added an `.enqueue_all_in_background` method that will automatically call your `.enqueue_all` _from a background job_ rather than directly on the active process.
-
-```ruby
-class Foo
-  include Action
-
-  def self.enqueue_all
-    SomeModel.some_scope.find_each do |record|
-      enqueue(record:)
-    end
-  end
-
-  ...
-end
-
-Foo.enqueue_all # works, but `SomeModel.some_scope.find_each` is executed in the current context
-Foo.enqueue_all_in_background # same, but runs in the background (via Action::Enqueueable::EnqueueAllWorker)

data/docs/usage/writing.md

@@ -154,5 +154,5 @@ after hook
 
 A number of custom callback are available for you as well, if you want to take specific actions when a given Axn succeeds or fails. See the [Class Interface docs](/reference/class#callbacks) for details.
 
-## Debugging
-Remember you can [enable debug logging](/reference/configuration.html#global-debug-logging) to print log lines before and after each action is executed.
+## Strategies
+A number of [Strategies](/strategies/index), which are <abbr title="Don't Repeat Yourself">DRY</abbr>ed bits of commonly-used configuration, are available for your use as well.

data/lib/action/core/configuration.rb

@@ -2,7 +2,6 @@
 
 module Action
   class Configuration
-    include Action::Logging
     attr_accessor :top_level_around_hook
     attr_writer :logger, :env, :on_exception, :additional_includes, :default_log_level, :default_autolog_level
 
@@ -12,11 +11,21 @@ module Action
     def additional_includes = @additional_includes ||= []
 
     def on_exception(e, action:, context: {})
-      if @on_exception
-        # TODO: only pass action: or context: if requested (and update documentation)
-        @on_exception.call(e, action:, context:)
+      msg = "Handled exception (#{e.class.name}): #{e.message}"
+      msg = ("#" * 10) + " #{msg} " + ("#" * 10) unless Action.config.env.production?
+      action.log(msg)
+
+      return unless @on_exception
+
+      # Only pass the kwargs that the given block expects
+      kwargs = @on_exception.parameters.select { |type, _name| %i[key keyreq].include?(type) }.map(&:last)
+      kwarg_hash = {}
+      kwarg_hash[:action] = action if kwargs.include?(:action)
+      kwarg_hash[:context] = context if kwargs.include?(:context)
+      if kwarg_hash.any?
+        @on_exception.call(e, **kwarg_hash)
       else
-        log("[#{action.class.name.presence || "Anonymous Action"}] Exception raised: #{e.class.name} - #{e.message}")
+        @on_exception.call(e)
       end
     end
 

data/lib/action/core/context_facade.rb

@@ -75,8 +75,7 @@ module Action
         action.instance_exec(&msg)
       end
     rescue StandardError => e
-      action.warn("Ignoring #{e.class.name} while determining message callable: #{e.message}")
-      nil
+      Axn::Util.piping_error("determining message callable", action:, exception: e)
     end
   end
 

data/lib/action/core/event_handlers.rb

@@ -27,8 +27,7 @@ module Action
         action.instance_exec(exception, &@handler)
         true
       rescue StandardError => e
-        action.warn("Ignoring #{e.class.name} when evaluating handler: #{e.message}")
-        nil
+        Axn::Util.piping_error("executing handler", action:, exception: e)
       end
     end
 
@@ -54,8 +53,7 @@ module Action
           false
         end
       rescue StandardError => e
-        action.warn("Ignoring #{e.class.name} while determining matcher: #{e.message}")
-        false
+        Axn::Util.piping_error("determining if handler applies to exception", action:, exception: e)
       end
 
       private attr_reader :matcher

data/lib/action/core/{swallow_exceptions.rb → handle_exceptions.rb}

@@ -3,7 +3,7 @@
 require_relative "event_handlers"
 
 module Action
-  module SwallowExceptions
+  module HandleExceptions
     def self.included(base)
       base.class_eval do
         class_attribute :_success_msg, :_error_msg
@@ -56,7 +56,7 @@ module Action
         rescue StandardError => e
           # No action needed -- downstream #on_exception implementation should ideally log any internal failures, but
           # we don't want exception *handling* failures to cascade and overwrite the original exception.
-          warn("Ignoring #{e.class.name} in on_exception hook: #{e.message}")
+          Axn::Util.piping_error("executing on_exception hooks", action: self, exception: e)
         end
 
         class << base

data/lib/action/core/logging.rb

@@ -16,20 +16,20 @@ module Action
     module ClassMethods
       def default_log_level = Action.config.default_log_level
 
-      def log(message, level: default_log_level)
+      def log(message, level: default_log_level, before: nil, after: nil)
         msg = [_log_prefix, message].compact_blank.join(" ")
+        msg = [before, msg, after].compact_blank.join if before || after
 
         Action.config.logger.send(level, msg)
       end
 
       LEVELS.each do |level|
-        define_method(level) do |message|
-          log(message, level:)
+        define_method(level) do |message, before: nil, after: nil|
+          log(message, level:, before:, after:)
         end
       end
 
-      # TODO: this is ugly, we should be able to override in the config class...
-      def _log_prefix = name == "Action::Configuration" ? nil : "[#{name || "Anonymous Class"}]"
+      def _log_prefix = "[#{name.presence || "Anonymous Class"}]"
     end
   end
 end

data/lib/action/core/top_level_around_hook.rb

@@ -24,8 +24,9 @@ module Action
           self.class.default_autolog_level,
           [
             "About to execute",
-            context_for_logging(:inbound).presence&.inspect,
+            _log_context(:inbound),
           ].compact.join(" with: "),
+          before: Action.config.env.production? ? nil : "\n------\n",
         )
       end
 
@@ -36,21 +37,38 @@ module Action
           self.class.default_autolog_level,
           [
             "Execution completed (with outcome: #{outcome}) in #{elapsed_mils} milliseconds",
-            _log_after_data_peak,
+            _log_context(:outbound),
           ].compact.join(". Set: "),
+          after: Action.config.env.production? ? nil : "\n------\n",
         )
       end
 
-      def _log_after_data_peak
-        return unless (data = context_for_logging(:outbound)).present?
+      def _log_context(direction)
+        data = context_for_logging(direction)
+        return unless data.present?
 
-        max_length = 100
-        suffix = "...<truncated>...}"
+        max_length = 150
+        suffix = "…<truncated>…"
 
-        data.inspect.tap do |str|
+        _log_object(data).tap do |str|
           return str[0, max_length - suffix.length] + suffix if str.length > max_length
         end
       end
+
+      def _log_object(data)
+        case data
+        when Hash
+          # NOTE: slightly more manual in order to avoid quotes around ActiveRecord objects' <Class#id> formatting
+          "{#{data.map { |k, v| "#{k}: #{_log_object(v)}" }.join(", ")}}"
+        when Array
+          data.map { |v| _log_object(v) }
+        else
+          return data.to_unsafe_h if defined?(ActionController::Parameters) && data.is_a?(ActionController::Parameters)
+          return "<#{data.class.name}##{data.to_param.presence || "unpersisted"}>" if defined?(ActiveRecord::Base) && data.is_a?(ActiveRecord::Base)
+
+          data.inspect
+        end
+      end
     end
 
     module InstanceMethods

data/lib/action/core/use_strategy.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Action
+  module UseStrategy
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def use(strategy_name, **config, &block)
+        strategy = Action::Strategies.all[strategy_name.to_sym]
+        raise StrategyNotFound, "Strategy #{strategy_name} not found" if strategy.blank?
+        raise ArgumentError, "Strategy #{strategy_name} does not support config" if config.any? && !strategy.respond_to?(:setup)
+
+        # Allow dynamic setup of strategy (i.e. dynamically define module before returning)
+        if strategy.respond_to?(:setup)
+          configured = strategy.setup(**config, &block)
+          raise ArgumentError, "Strategy #{strategy_name} setup method must return a module" unless configured.is_a?(Module)
+
+          strategy = configured
+        else
+          raise ArgumentError, "Strategy #{strategy_name} does not support config (define #setup method)" if config.any?
+          raise ArgumentError, "Strategy #{strategy_name} does not support blocks (define #setup method)" if block_given?
+        end
+
+        include strategy
+      end
+    end
+  end
+end

data/lib/action/core/validation/validators/model_validator.rb

@@ -26,8 +26,7 @@ module Action
         msg = id.blank? ? "not found (given a blank ID)" : "not found for class #{klass.name} and ID #{id}"
         record.errors.add(attribute, msg)
       rescue StandardError => e
-        warn("Model validation on field '#{attribute}' raised #{e.class.name}: #{e.message}")
-
+        Axn::Util.piping_error("applying model validation on field '#{attribute}'", exception: e)
         record.errors.add(attribute, "error raised while trying to find a valid #{klass.name}")
       end
     end

data/lib/action/core/validation/validators/validate_validator.rb

@@ -9,7 +9,7 @@ module Action
         msg = begin
           options[:with].call(value)
         rescue StandardError => e
-          Action.config.logger.warn("Custom validation on field '#{attribute}' raised #{e.class.name}: #{e.message}")
+          Axn::Util.piping_error("applying custom validation on field '#{attribute}'", exception: e)
 
           "failed validation: #{e.message}"
         end

data/lib/action/enqueueable.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative "enqueueable/via_sidekiq"
-require_relative "enqueueable/enqueue_all_in_background"
 
 module Action
   module Enqueueable
@@ -9,7 +8,6 @@ module Action
 
     included do
       include ViaSidekiq
-      include EnqueueAllInBackground
     end
   end
 end

data/lib/action/strategies/transaction.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Action
+  class Strategies
+    module Transaction
+      extend ActiveSupport::Concern
+
+      included do
+        raise NotImplementedError, "Transaction strategy requires ActiveRecord" unless defined?(ActiveRecord)
+
+        around do |hooked|
+          ActiveRecord::Base.transaction do
+            hooked.call
+          end
+        end
+      end
+    end
+  end
+end

data/lib/action/strategies.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Action
+  class StrategyNotFound < StandardError; end
+  class DuplicateStrategyError < StandardError; end
+
+  class Strategies
+    # rubocop:disable Style/ClassVars
+    class << self
+      def built_in
+        return @@built_in if defined?(@@built_in)
+
+        strategy_files = Dir[File.join(__dir__, "strategies", "*.rb")]
+        strategy_files.each { |file| require file }
+
+        constants = Action::Strategies.constants.map { |const| Action::Strategies.const_get(const) }
+        mods = constants.select { |const| const.is_a?(Module) }
+
+        @@built_in = mods.to_h { |mod| [mod.name.split("::").last.downcase.to_sym, mod] }
+      end
+
+      def register(name, strategy)
+        all # ensure built_in is initialized
+        key = name.to_sym
+        raise DuplicateStrategyError, "Strategy #{name} already registered" if @@strategies.key?(key)
+
+        @@strategies[key] = strategy
+        @@strategies
+      end
+
+      def all
+        @@strategies ||= built_in.dup
+      end
+
+      def clear!
+        @@strategies = built_in.dup
+      end
+
+      def find(name)
+        raise StrategyNotFound, "Strategy name cannot be nil" if name.nil?
+        raise StrategyNotFound, "Strategy name cannot be empty" if name.to_s.strip.empty?
+
+        all[name.to_sym] or raise StrategyNotFound, "Strategy '#{name}' not found"
+      end
+    end
+    # rubocop:enable Style/ClassVars
+  end
+end

data/lib/axn/testing/spec_helpers.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "rspec"
+
+module Axn
+  module Testing
+    module SpecHelpers
+      def build_action(&block)
+        action = Class.new.send(:include, Action)
+        action.class_eval(&block) if block
+        action
+      end
+
+      def build_axn(**, &)
+        Axn::Factory.build(**, &)
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include Axn::Testing::SpecHelpers
+end

data/lib/axn/util.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Axn
+  module Util
+    def self.piping_error(desc, exception:, action: nil)
+      # Extract just filename/line number from backtrace
+      src = exception.backtrace.first.split.first.split("/").last.split(":")[0, 2].join(":")
+
+      message = if Action.config.env.production?
+                  "Ignoring exception raised while #{desc}: #{exception.class.name} - #{exception.message} (from #{src})"
+                else
+                  msg = "!! IGNORING EXCEPTION RAISED WHILE #{desc.upcase} !!\n\n" \
+                        "\t* Exception: #{exception.class.name}\n" \
+                        "\t* Message: #{exception.message}\n" \
+                        "\t* From: #{src}"
+                  "#{"⌵" * 30}\n\n#{msg}\n\n#{"^" * 30}"
+                end
+
+      (action || Action.config.logger).send(:warn, message)
+
+      nil
+    end
+  end
+end

data/lib/axn/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Axn
-  VERSION = "0.1.0-alpha.2.5.1.2"
+  VERSION = "0.1.0-alpha.2.5.3"
 end

data/lib/axn.rb

@@ -2,6 +2,7 @@
 
 module Axn; end
 require_relative "axn/version"
+require_relative "axn/util"
 
 require "interactor"
 require "active_support"
@@ -16,13 +17,15 @@ require_relative "action/core/configuration"
 require_relative "action/core/top_level_around_hook"
 require_relative "action/core/contract"
 require_relative "action/core/contract_for_subfields"
-require_relative "action/core/swallow_exceptions"
+require_relative "action/core/handle_exceptions"
 require_relative "action/core/hoist_errors"
+require_relative "action/core/use_strategy"
 
 require_relative "axn/factory"
 
 require_relative "action/attachable"
 require_relative "action/enqueueable"
+require_relative "action/strategies"
 
 def Axn(callable, **) # rubocop:disable Naming/MethodName
   return callable if callable.is_a?(Class) && callable < Action
@@ -42,12 +45,14 @@ module Action
       # can include those hook executions in any traces set from this hook.
       include TopLevelAroundHook
 
-      include SwallowExceptions
+      include HandleExceptions
       include Contract
       include ContractForSubfields
 
       include HoistErrors
 
+      include UseStrategy
+
       # --- Extensions ---
       include Attachable
       include Enqueueable
@@ -67,5 +72,3 @@ module Action
     end
   end
 end
-
-require "action/enqueueable/enqueue_all_worker"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: axn
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre.alpha.2.5.1.2
+  version: 0.1.0.pre.alpha.2.5.3
 platform: ruby
 authors:
 - Kali Donovan
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-06-26 00:00:00.000000000 Z
+date: 2025-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -81,6 +81,8 @@ files:
 - docs/reference/class.md
 - docs/reference/configuration.md
 - docs/reference/instance.md
+- docs/strategies/index.md
+- docs/strategies/transaction.md
 - docs/usage/setup.md
 - docs/usage/using.md
 - docs/usage/writing.md
@@ -94,21 +96,24 @@ files:
 - lib/action/core/contract_for_subfields.rb
 - lib/action/core/event_handlers.rb
 - lib/action/core/exceptions.rb
+- lib/action/core/handle_exceptions.rb
 - lib/action/core/hoist_errors.rb
 - lib/action/core/logging.rb
-- lib/action/core/swallow_exceptions.rb
 - lib/action/core/top_level_around_hook.rb
+- lib/action/core/use_strategy.rb
 - lib/action/core/validation/fields.rb
 - lib/action/core/validation/subfields.rb
 - lib/action/core/validation/validators/model_validator.rb
 - lib/action/core/validation/validators/type_validator.rb
 - lib/action/core/validation/validators/validate_validator.rb
 - lib/action/enqueueable.rb
-- lib/action/enqueueable/enqueue_all_in_background.rb
-- lib/action/enqueueable/enqueue_all_worker.rb
 - lib/action/enqueueable/via_sidekiq.rb
+- lib/action/strategies.rb
+- lib/action/strategies/transaction.rb
 - lib/axn.rb
 - lib/axn/factory.rb
+- lib/axn/testing/spec_helpers.rb
+- lib/axn/util.rb
 - lib/axn/version.rb
 - package.json
 - yarn.lock

data/lib/action/enqueueable/enqueue_all_in_background.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Action
-  module Enqueueable
-    module EnqueueAllInBackground
-      extend ActiveSupport::Concern
-
-      module ClassMethods
-        def enqueue_all_in_background
-          raise NotImplementedError, "#{name} must implement a .enqueue_all method in order to use .enqueue_all_in_background" unless respond_to?(:enqueue_all)
-
-          ::Action::Enqueueable::EnqueueAllWorker.enqueue(klass_name: name)
-        end
-      end
-    end
-  end
-end

data/lib/action/enqueueable/enqueue_all_worker.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-# NOTE: this is a standalone worker for enqueueing all instances of a class.
-# Unlike the other files in the folder, it is NOT included in the Action stack.
-
-# Note it uses Axn-native enqueueing, so will automatically support additional
-# backends as they are added (initially, just Sidekiq)
-
-module Action
-  module Enqueueable
-    class EnqueueAllWorker
-      include Action
-
-      expects :klass_name, type: String
-
-      def call
-        klass_name.constantize.enqueue_all
-      end
-    end
-  end
-end