axn 0.1.0.pre.alpha.2.5.3.1 → 0.1.0.pre.alpha.2.6.1

data/lib/action/core.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "action/context"
+
+require "action/strategies"
+require "action/core/hooks"
+require "action/core/logging"
+require "action/core/hoist_errors"
+require "action/core/flow"
+require "action/core/automatic_logging"
+require "action/core/use_strategy"
+require "action/core/tracing"
+
+# CONSIDER: make class names match file paths?
+require "action/core/validation/validators/model_validator"
+require "action/core/validation/validators/type_validator"
+require "action/core/validation/validators/validate_validator"
+
+require "action/core/contract_validation"
+require "action/core/contract"
+require "action/core/contract_for_subfields"
+require "action/core/timing"
+
+module Action
+  module Core
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+        include Core::Hooks
+        include Core::Logging
+        include Core::AutomaticLogging
+        include Core::Tracing
+        include Core::Timing
+
+        include Core::Flow
+
+        include Core::ContractValidation
+        include Core::Contract
+        include Core::ContractForSubfields
+
+        include Core::HoistErrors
+        include Core::UseStrategy
+      end
+    end
+
+    module ClassMethods
+      def call(**)
+        new(**).tap(&:_run).result
+      end
+
+      def call!(**)
+        result = call(**)
+        return result if result.ok?
+
+        raise result.exception || Action::Failure.new(result.error)
+      end
+    end
+
+    def initialize(**)
+      @__context = Action::Context.new(**)
+    end
+
+    # Main entry point for action execution
+    def _run
+      _with_tracing do
+        _with_logging do
+          _with_timing do
+            _with_exception_handling do # Exceptions stop here; outer wrappers access result status (and must not introduce another exception layer)
+              _with_contract do # Library internals -- any failures (e.g. contract violations) *should* fail the Action::Result
+                _with_hooks do # User hooks -- any failures here *should* fail the Action::Result
+                  call
+                end
+              end
+            end
+          end
+        end
+      end
+    ensure
+      _emit_metrics
+    end
+
+    # User-defined action logic - override this method in your action classes
+    def call; end
+
+    delegate :fail!, to: :@__context
+
+    private
+
+    def _emit_metrics
+      return unless Action.config.emit_metrics
+
+      Action.config.emit_metrics.call(
+        self.class.name || "AnonymousClass",
+        result,
+      )
+    rescue StandardError => e
+      Axn::Util.piping_error("running metrics hook", action: self, exception: e)
+    end
+  end
+end

data/lib/action/enqueueable/via_sidekiq.rb

@@ -18,9 +18,9 @@ module Action
             bang = args.size > 1 ? args.last : false
 
             if bang
-              self.class.call!(context)
+              self.class.call!(**context)
             else
-              self.class.call(context)
+              self.class.call(**context)
             end
           end
 

data/lib/action/enqueueable.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "enqueueable/via_sidekiq"
+require "action/enqueueable/via_sidekiq"
 
 module Action
   module Enqueueable

data/lib/action/{core/exceptions.rb → exceptions.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Action
-  # Raised internally when fail! is called -- triggers failure + rollback handling
+  # Raised internally when fail! is called
   class Failure < StandardError
     DEFAULT_MESSAGE = "Execution was halted"
 
@@ -17,24 +17,6 @@ module Action
     def inspect = "#<#{self.class.name} '#{message}'>"
   end
 
-  class StepsRequiredForInheritanceSupportError < StandardError
-    def message
-      <<~MSG
-        ** Inheritance support requires the following steps: **
-
-        Add this to your Gemfile:
-          gem "interactor", github: "kaspermeyer/interactor", branch: "fix-hook-inheritance"
-
-        Explanation:
-          Unfortunately the upstream interactor gem does not support inheritance of hooks, which is required for this feature.
-          This branch is a temporary fork that adds support for inheritance of hooks, but published gems cannot specify a branch dependency.
-          In the future we may inline the upstream Interactor gem entirely and remove this necessity, but while we're in alpha we're continuing
-          to use the upstream gem for stability (and there has been recent activity on the project, so they *may* be adding additional functionality
-          soon).
-      MSG
-    end
-  end
-
   class ContractViolation < StandardError
     class ReservedAttributeError < ContractViolation
       def initialize(name)

data/lib/action/result.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "action/core/context/facade"
+require "action/core/context/facade_inspector"
+
+module Action
+  # 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 :ok?, :exception, to: :context
+
+    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
+
+    # Outcome constants for action execution results
+    OUTCOMES = [
+      OUTCOME_SUCCESS = :success,
+      OUTCOME_FAILURE = :failure,
+      OUTCOME_EXCEPTION = :exception,
+    ].freeze
+
+    def outcome
+      return OUTCOME_EXCEPTION if exception
+      return OUTCOME_FAILURE if @context.failed?
+
+      OUTCOME_SUCCESS
+    end
+
+    # Elapsed time in milliseconds
+    def elapsed_time
+      @context.elapsed_time
+    end
+
+    private
+
+    def context_data_source = @context.exposed_data
+
+    def method_missing(method_name, ...) # rubocop:disable Style/MissingRespondToMissing (because we're not actually responding to anything additional)
+      if @context.__combined_data.key?(method_name.to_sym)
+        msg = <<~MSG
+          Method ##{method_name} is not available on Action::Result!
+
+          #{action_name} may be missing a line like:
+            exposes :#{method_name}
+        MSG
+
+        raise Action::ContractViolation::MethodNotAllowed, msg
+      end
+
+      super
+    end
+  end
+end

data/lib/axn/factory.rb

@@ -22,8 +22,15 @@ module Axn
         after: nil,
         around: nil,
 
-        # Allow dynamically assigning rollback method
-        rollback: 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 }
@@ -84,13 +91,24 @@ module Axn
           axn.after(after) if after.present?
           axn.around(around) if around.present?
 
-          # Rollback
-          if rollback.present?
-            raise ArgumentError, "[Axn::Factory] Rollback must be a callable" unless rollback.respond_to?(:call) && rollback.respond_to?(:arity)
-            raise ArgumentError, "[Axn::Factory] Rollback must be a callable with no arguments" unless rollback.arity.zero?
-
-            axn.define_method(:rollback) do
-              instance_exec(&rollback)
+          # 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
 

data/lib/axn/version.rb

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

data/lib/axn.rb

@@ -1,31 +1,19 @@
 # frozen_string_literal: true
 
-module Axn; end
-require_relative "axn/version"
-require_relative "axn/util"
-
-require "interactor"
 require "active_support"
 
-require_relative "action/core/validation/validators/model_validator"
-require_relative "action/core/validation/validators/type_validator"
-require_relative "action/core/validation/validators/validate_validator"
+module Axn; end
+require "axn/version"
+require "axn/util"
+require "axn/factory"
 
-require_relative "action/core/exceptions"
-require_relative "action/core/logging"
-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/handle_exceptions"
-require_relative "action/core/hoist_errors"
-require_relative "action/core/use_strategy"
+require "action/configuration"
+require "action/exceptions"
 
-require_relative "axn/factory"
+require "action/core"
 
-require_relative "action/attachable"
-require_relative "action/enqueueable"
-require_relative "action/strategies"
+require "action/attachable"
+require "action/enqueueable"
 
 def Axn(callable, **) # rubocop:disable Naming/MethodName
   return callable if callable.is_a?(Class) && callable < Action
@@ -36,22 +24,7 @@ end
 module Action
   def self.included(base)
     base.class_eval do
-      include Interactor
-
-      # Include first so other modules can assume `log` is available
-      include Logging
-
-      # NOTE: include before any others that set hooks (like contract validation), so we
-      # can include those hook executions in any traces set from this hook.
-      include TopLevelAroundHook
-
-      include HandleExceptions
-      include Contract
-      include ContractForSubfields
-
-      include HoistErrors
-
-      include UseStrategy
+      include Core
 
       # --- Extensions ---
       include Attachable
@@ -59,16 +32,6 @@ module Action
 
       # Allow additional automatic includes to be configured
       Array(Action.config.additional_includes).each { |mod| include mod }
-
-      # ----
-
-      # ALPHA: Everything below here is to support inheritance
-
-      base.define_singleton_method(:inherited) do |base_klass|
-        return super(base_klass) if Interactor::Hooks::ClassMethods.private_method_defined?(:ancestor_hooks)
-
-        raise StepsRequiredForInheritanceSupportError
-      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: axn
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre.alpha.2.5.3.1
+  version: 0.1.0.pre.alpha.2.6.1
 platform: ruby
 authors:
 - Kali Donovan
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-07-30 00:00:00.000000000 Z
+date: 2025-08-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -38,20 +38,6 @@ dependencies:
     - - ">"
       - !ruby/object:Gem::Version
         version: '7.0'
-- !ruby/object:Gem::Dependency
-  name: interactor
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 3.1.2
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 3.1.2
 description: Pattern for writing callable service objects with contract validation
   and error swallowing
 email:
@@ -90,16 +76,26 @@ files:
 - lib/action/attachable/base.rb
 - lib/action/attachable/steps.rb
 - lib/action/attachable/subactions.rb
-- lib/action/core/configuration.rb
-- lib/action/core/context_facade.rb
+- lib/action/configuration.rb
+- 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_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/exceptions.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/top_level_around_hook.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
@@ -108,6 +104,8 @@ files:
 - lib/action/core/validation/validators/validate_validator.rb
 - 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 :called!, :rollback!, :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