axn 0.1.0.pre.alpha.2.6 → 0.1.0.pre.alpha.2.6.1

data/lib/axn/factory.rb

@@ -22,6 +22,15 @@ module Axn
         after: nil,
         around: nil,
 
+        # Callbacks
+        on_success: nil,
+        on_failure: nil,
+        on_error: nil,
+        on_exception: nil,
+
+        # Strategies
+        use: [],
+
         &block
       )
         args = block.parameters.each_with_object(_hash_with_default_array) { |(type, field), hash| hash[type] << field }
@@ -82,6 +91,27 @@ module Axn
           axn.after(after) if after.present?
           axn.around(around) if around.present?
 
+          # Callbacks
+          axn.on_success(&on_success) if on_success.present?
+          axn.on_failure(&on_failure) if on_failure.present?
+          axn.on_error(&on_error) if on_error.present?
+          axn.on_exception(&on_exception) if on_exception.present?
+
+          # Strategies
+          Array(use).each do |strategy|
+            if strategy.is_a?(Array)
+              strategy_name, *config_args = strategy
+              if config_args.last.is_a?(Hash)
+                *other_args, config = config_args
+                axn.use(strategy_name, *other_args, **config)
+              else
+                axn.use(strategy_name, *config_args)
+              end
+            else
+              axn.use(strategy)
+            end
+          end
+
           # Default exposure
           axn.exposes(expose_return_as, allow_blank: true) if expose_return_as.present?
         end

data/lib/axn/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: axn
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre.alpha.2.6
+  version: 0.1.0.pre.alpha.2.6.1
 platform: ruby
 authors:
 - Kali Donovan
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-08-07 00:00:00.000000000 Z
+date: 2025-08-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -80,16 +80,22 @@ files:
 - lib/action/context.rb
 - lib/action/core.rb
 - lib/action/core/automatic_logging.rb
-- lib/action/core/context_facade.rb
+- lib/action/core/context/facade.rb
+- lib/action/core/context/facade_inspector.rb
+- lib/action/core/context/internal.rb
 - lib/action/core/contract.rb
 - lib/action/core/contract_for_subfields.rb
 - lib/action/core/contract_validation.rb
 - lib/action/core/event_handlers.rb
-- lib/action/core/handle_exceptions.rb
+- lib/action/core/flow.rb
+- lib/action/core/flow/callbacks.rb
+- lib/action/core/flow/exception_execution.rb
+- lib/action/core/flow/messages.rb
 - lib/action/core/hoist_errors.rb
 - lib/action/core/hooks.rb
 - lib/action/core/logging.rb
 - lib/action/core/timing.rb
+- lib/action/core/tracing.rb
 - lib/action/core/use_strategy.rb
 - lib/action/core/validation/fields.rb
 - lib/action/core/validation/subfields.rb
@@ -99,6 +105,7 @@ files:
 - lib/action/enqueueable.rb
 - lib/action/enqueueable/via_sidekiq.rb
 - lib/action/exceptions.rb
+- lib/action/result.rb
 - lib/action/strategies.rb
 - lib/action/strategies/transaction.rb
 - lib/axn.rb

data/lib/action/core/context_facade.rb

@@ -1,209 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/parameter_filter"
-
-module Action
-  class ContextFacade
-    def initialize(action:, context:, declared_fields:, implicitly_allowed_fields: nil)
-      if self.class.name == "Action::ContextFacade" # rubocop:disable Style/ClassEqualityComparison
-        raise "Action::ContextFacade is an abstract class and should not be instantiated directly"
-      end
-
-      @context = context
-      @action = action
-      @declared_fields = declared_fields
-
-      (@declared_fields + Array(implicitly_allowed_fields)).each do |field|
-        singleton_class.define_method(field) { @context.public_send(field) }
-      end
-    end
-
-    attr_reader :declared_fields
-
-    def inspect = Inspector.new(facade: self, action:, context:).call
-
-    def fail!(...)
-      raise Action::ContractViolation::MethodNotAllowed, "Call fail! directly rather than on the context"
-    end
-
-    private
-
-    attr_reader :action, :context
-
-    def exposure_method_name = raise NotImplementedError
-
-    # Add nice error message for missing methods
-    def method_missing(method_name, ...) # rubocop:disable Style/MissingRespondToMissing (because we're not actually responding to anything additional)
-      if context.respond_to?(method_name)
-        msg = <<~MSG
-          Method ##{method_name} is not available on #{self.class.name}!
-
-          #{@action.class.name || "The action"} may be missing a line like:
-            #{exposure_method_name} :#{method_name}
-        MSG
-
-        raise Action::ContractViolation::MethodNotAllowed, msg
-      end
-
-      super
-    end
-
-    def determine_error_message(only_default: false)
-      return @context.error_from_user if @context.error_from_user.present?
-
-      # We need an exception for interceptors, and also in case the messages.error callable expects an argument
-      exception = @context.exception || Action::Failure.new
-
-      msg = action._error_msg
-
-      unless only_default
-        interceptor = action.class._error_interceptor_for(exception:, action:)
-        msg = interceptor.message if interceptor
-      end
-
-      stringified(msg, exception:).presence || "Something went wrong"
-    end
-
-    # Allow for callable OR string messages
-    def stringified(msg, exception: nil)
-      return msg.presence unless msg.respond_to?(:call)
-
-      # The error message callable can take the exception as an argument
-      if exception && msg.arity == 1
-        action.instance_exec(exception, &msg)
-      else
-        action.instance_exec(&msg)
-      end
-    rescue StandardError => e
-      Axn::Util.piping_error("determining message callable", action:, exception: e)
-    end
-  end
-
-  # Inbound / Internal ContextFacade
-  class InternalContext < ContextFacade
-    # So can be referenced from within e.g. rescues callables
-    def default_error
-      [@context.error_prefix, determine_error_message(only_default: true)].compact.join(" ").squeeze(" ")
-    end
-
-    private
-
-    def exposure_method_name = :expects
-  end
-
-  # Outbound / External ContextFacade
-  class Result < ContextFacade
-    # For ease of mocking return results in tests
-    class << self
-      def ok(msg = nil, **exposures)
-        exposes = exposures.keys.to_h { |key| [key, { allow_blank: true }] }
-
-        Axn::Factory.build(exposes:, messages: { success: msg }) do
-          exposures.each do |key, value|
-            expose(key, value)
-          end
-        end.call
-      end
-
-      def error(msg = nil, **exposures, &block)
-        exposes = exposures.keys.to_h { |key| [key, { allow_blank: true }] }
-        rescues = [-> { true }, msg]
-
-        Axn::Factory.build(exposes:, rescues:) do
-          exposures.each do |key, value|
-            expose(key, value)
-          end
-          block.call if block_given?
-          fail!
-        end.call
-      end
-    end
-
-    # Poke some holes for necessary internal control methods
-    delegate :each_pair, to: :context
-
-    # External interface
-    delegate :success?, :exception, to: :context
-    def ok? = success?
-
-    def error
-      return if ok?
-
-      [@context.error_prefix, determine_error_message].compact.join(" ").squeeze(" ")
-    end
-
-    def success
-      return unless ok?
-
-      stringified(action._success_msg).presence || "Action completed successfully"
-    end
-
-    def ok = success
-
-    def message = error || success
-
-    private
-
-    def exposure_method_name = :exposes
-  end
-
-  class Inspector
-    def initialize(action:, facade:, context:)
-      @action = action
-      @facade = facade
-      @context = context
-    end
-
-    def call
-      str = [status, visible_fields].compact_blank.join(" ")
-
-      "#<#{class_name} #{str}>"
-    end
-
-    private
-
-    attr_reader :action, :facade, :context
-
-    def status
-      return unless facade.is_a?(Action::Result)
-
-      return "[OK]" if context.success?
-      unless context.exception
-        return context.error_from_user.present? ? "[failed with '#{context.error_from_user}']" : "[failed]"
-      end
-
-      %([failed with #{context.exception.class.name}: '#{context.exception.message}'])
-    end
-
-    def visible_fields
-      declared_fields.map do |field|
-        value = facade.public_send(field)
-
-        "#{field}: #{format_for_inspect(field, value)}"
-      end.join(", ")
-    end
-
-    def class_name = facade.class.name
-    def declared_fields = facade.send(:declared_fields)
-
-    def format_for_inspect(field, value)
-      return value.inspect if value.nil?
-
-      # Initially based on https://github.com/rails/rails/blob/800976975253be2912d09a80757ee70a2bb1e984/activerecord/lib/active_record/attribute_methods.rb#L527
-      inspected_value = if value.is_a?(String) && value.length > 50
-                          "#{value[0, 50]}...".inspect
-                        elsif value.is_a?(Date) || value.is_a?(Time)
-                          %("#{value.to_fs(:inspect)}")
-                        elsif defined?(::ActiveRecord::Relation) && value.instance_of?(::ActiveRecord::Relation)
-                          # Avoid hydrating full AR relation (i.e. avoid loading records just to report an error)
-                          "#{value.name}::ActiveRecord_Relation"
-                        else
-                          value.inspect
-                        end
-
-      inspection_filter.filter_param(field, inspected_value)
-    end
-
-    def inspection_filter = action.send(:inspection_filter)
-  end
-end

data/lib/action/core/handle_exceptions.rb

@@ -1,143 +0,0 @@
-# frozen_string_literal: true
-
-# TODO: maybe namespace those under core?
-require "action/core/event_handlers"
-
-module Action
-  module Core
-    module HandleExceptions
-      def self.included(base)
-        base.class_eval do
-          class_attribute :_success_msg, :_error_msg
-          class_attribute :_custom_error_interceptors, default: []
-          class_attribute :_error_handlers, default: []
-          class_attribute :_exception_handlers, default: []
-          class_attribute :_failure_handlers, default: []
-          class_attribute :_success_handlers, default: []
-
-          include InstanceMethods
-          extend ClassMethods
-
-          def trigger_on_exception(exception)
-            interceptor = self.class._error_interceptor_for(exception:, action: self)
-            return if interceptor&.should_report_error == false
-
-            # Call any handlers registered on *this specific action* class
-            self.class._exception_handlers.each do |handler|
-              handler.execute_if_matches(exception:, action: self)
-            end
-
-            # Call any global handlers
-            Action.config.on_exception(exception,
-                                       action: self,
-                                       context: respond_to?(:context_for_logging) ? context_for_logging : @context.to_h)
-          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.
-            Axn::Util.piping_error("executing on_exception hooks", action: self, exception: e)
-          end
-
-          def trigger_on_success
-            # Call success handlers in child-first order (like after hooks)
-            self.class._success_handlers.each do |handler|
-              instance_exec(&handler)
-            rescue StandardError => e
-              # Log the error but continue with other handlers
-              Axn::Util.piping_error("executing on_success hook", action: self, exception: e)
-            end
-          end
-        end
-      end
-
-      module ClassMethods
-        def messages(success: nil, error: nil)
-          self._success_msg = success if success.present?
-          self._error_msg = error if error.present?
-
-          true
-        end
-
-        def error_from(matcher = nil, message = nil, **match_and_messages)
-          _register_error_interceptor(matcher, message, should_report_error: true, **match_and_messages)
-        end
-
-        def rescues(matcher = nil, message = nil, **match_and_messages)
-          _register_error_interceptor(matcher, message, should_report_error: false, **match_and_messages)
-        end
-
-        # ONLY raised exceptions (i.e. NOT fail!). Skipped if exception is rescued via .rescues.
-        def on_exception(matcher = -> { true }, &handler)
-          raise ArgumentError, "on_exception must be called with a block" unless block_given?
-
-          self._exception_handlers += [Action::EventHandlers::ConditionalHandler.new(matcher:, handler:)]
-        end
-
-        # ONLY raised on fail! (i.e. NOT unhandled exceptions).
-        def on_failure(matcher = -> { true }, &handler)
-          raise ArgumentError, "on_failure must be called with a block" unless block_given?
-
-          self._failure_handlers += [Action::EventHandlers::ConditionalHandler.new(matcher:, handler:)]
-        end
-
-        # Handles both fail! and unhandled exceptions... but is NOT affected by .rescues
-        def on_error(matcher = -> { true }, &handler)
-          raise ArgumentError, "on_error must be called with a block" unless block_given?
-
-          self._error_handlers += [Action::EventHandlers::ConditionalHandler.new(matcher:, handler:)]
-        end
-
-        # Executes when the action completes successfully (after all after hooks complete successfully)
-        # Runs in child-first order (child handlers before parent handlers)
-        def on_success(&handler)
-          raise ArgumentError, "on_success must be called with a block" unless block_given?
-
-          # Prepend like after hooks - child handlers run before parent handlers
-          self._success_handlers = [handler] + _success_handlers
-        end
-
-        def default_error = new.internal_context.default_error
-
-        # Private helpers
-
-        def _error_interceptor_for(exception:, action:)
-          Array(_custom_error_interceptors).detect do |int|
-            int.matches?(exception:, action:)
-          end
-        end
-
-        def _register_error_interceptor(matcher, message, should_report_error:, **match_and_messages)
-          method_name = should_report_error ? "error_from" : "rescues"
-          raise ArgumentError, "#{method_name} must be called with a key/value pair, or else keyword args" if [matcher, message].compact.size == 1
-
-          interceptors = { matcher => message }.compact.merge(match_and_messages).map do |(matcher, message)| # rubocop:disable Lint/ShadowingOuterLocalVariable
-            Action::EventHandlers::CustomErrorInterceptor.new(matcher:, message:, should_report_error:)
-          end
-
-          self._custom_error_interceptors += interceptors
-        end
-      end
-
-      module InstanceMethods
-        private
-
-        def fail!(message = nil)
-          @context.instance_variable_set("@failure", true)
-          @context.error_from_user = message if message.present?
-
-          raise Action::Failure, message
-        end
-
-        def try
-          yield
-        rescue Action::Failure => e
-          # NOTE: re-raising so we can still fail! from inside the block
-          raise e
-        rescue StandardError => e
-          trigger_on_exception(e)
-        end
-
-        delegate :default_error, to: :internal_context
-      end
-    end
-  end
-end