axn 0.1.0.pre.alpha.2.8.1 → 0.1.0.pre.alpha.3

data/lib/{action → axn}/core/flow/handlers/matcher.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require "action/core/flow/handlers/invoker"
+require "axn/core/flow/handlers/invoker"
 
-module Action
+module Axn
   module Core
     module Flow
       module Handlers
@@ -16,7 +16,7 @@ module Action
             result = matches?(exception:, action:)
             @invert ? !result : result
           rescue StandardError => e
-            Axn::Util.piping_error("determining if handler applies to exception", action:, exception: e)
+            Axn::Internal::Logging.piping_error("determining if handler applies to exception", action:, exception: e)
           end
 
           private
@@ -92,7 +92,7 @@ module Action
           def call(exception:, action:)
             matches?(exception:, action:)
           rescue StandardError => e
-            Axn::Util.piping_error("determining if handler applies to exception", action:, exception: e)
+            Axn::Internal::Logging.piping_error("determining if handler applies to exception", action:, exception: e)
           end
 
           def static? = @rules.empty?
@@ -103,7 +103,7 @@ module Action
             if_condition = binding.local_variable_get(:if)
             unless_condition = binding.local_variable_get(:unless)
 
-            raise Action::UnsupportedArgument, "providing both :if and :unless" if if_condition && unless_condition
+            raise Axn::UnsupportedArgument, "providing both :if and :unless" if if_condition && unless_condition
 
             new(Array(if_condition || unless_condition).compact, invert: !!unless_condition)
           end

data/lib/{action → axn}/core/flow/handlers/registry.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
-module Action
+module Axn
   module Core
     module Flow
       module Handlers
         # Small, immutable, copy-on-write registry keyed by event_type.
         # Stores arrays of entries (handlers/interceptors) in insertion order.
+        #
+        # NOTE: serves different need than user-mutable e.g. Axn::Async::Adapters
         class Registry
           def self.empty = new({})
 

data/lib/{action → axn}/core/flow/handlers/resolvers/base_resolver.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Action
+module Axn
   module Core
     module Flow
       module Handlers

data/lib/{action → axn}/core/flow/handlers/resolvers/callback_resolver.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require "action/core/flow/handlers/invoker"
+require "axn/core/flow/handlers/invoker"
 
-module Action
+module Axn
   module Core
     module Flow
       module Handlers

data/lib/{action → axn}/core/flow/handlers/resolvers/message_resolver.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require "action/core/flow/handlers/invoker"
+require "axn/core/flow/handlers/invoker"
 
-module Action
+module Axn
   module Core
     module Flow
       module Handlers
@@ -33,7 +33,7 @@ module Action
               message = resolved_message_body(descriptor)
               return nil unless message.present?
 
-              descriptor.prefix ? "#{descriptor.prefix}#{message}" : message
+              "#{resolved_prefix(descriptor)}#{message}"
             end
 
             def resolved_message_body(descriptor)
@@ -49,6 +49,15 @@ module Action
               end
             end
 
+            def resolved_prefix(descriptor)
+              return nil unless descriptor.prefix
+              return descriptor.prefix if descriptor.prefix.is_a?(String)
+
+              Invoker.call(action:, handler: descriptor.prefix, exception:, operation: "determining prefix callable")
+            rescue StandardError
+              nil
+            end
+
             def invoke_handler(handler) = handler ? Invoker.call(operation: "determining message callable", action:, handler:, exception:).presence : nil
             def fallback_message = event_type == :success ? DEFAULT_SUCCESS : DEFAULT_ERROR
           end

data/lib/axn/core/flow/handlers.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Axn
+  module Core
+    module Flow
+      module Handlers
+      end
+    end
+  end
+end
+
+require "axn/core/flow/handlers/base_descriptor"
+require "axn/core/flow/handlers/matcher"
+require "axn/core/flow/handlers/resolvers/base_resolver"
+require "axn/core/flow/handlers/descriptors/message_descriptor"
+require "axn/core/flow/handlers/descriptors/callback_descriptor"
+require "axn/core/flow/handlers/invoker"
+require "axn/core/flow/handlers/resolvers/callback_resolver"
+require "axn/core/flow/handlers/registry"
+require "axn/core/flow/handlers/resolvers/message_resolver"

data/lib/{action → axn}/core/flow/messages.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-require "action/core/flow/handlers"
+require "axn/core/flow/handlers"
 
-module Action
+module Axn
   module Core
     module Flow
       module Messages
         def self.included(base)
           base.class_eval do
-            class_attribute :_messages_registry, default: Action::Core::Flow::Handlers::Registry.empty
+            class_attribute :_messages_registry, default: Axn::Core::Flow::Handlers::Registry.empty
 
             extend ClassMethods
           end
@@ -21,19 +21,19 @@ module Action
           private
 
           def _add_message(kind, message:, **kwargs, &block)
-            raise Action::UnsupportedArgument, "calling #{kind} with both :if and :unless" if kwargs.key?(:if) && kwargs.key?(:unless)
-            raise Action::UnsupportedArgument, "Combining from: with if: or unless:" if kwargs.key?(:from) && (kwargs.key?(:if) || kwargs.key?(:unless))
+            raise Axn::UnsupportedArgument, "calling #{kind} with both :if and :unless" if kwargs.key?(:if) && kwargs.key?(:unless)
+            raise Axn::UnsupportedArgument, "Combining from: with if: or unless:" if kwargs.key?(:from) && (kwargs.key?(:if) || kwargs.key?(:unless))
             raise ArgumentError, "Provide either a message or a block, not both" if message && block_given?
             raise ArgumentError, "Provide a message, block, or prefix" unless message || block_given? || kwargs[:prefix]
             raise ArgumentError, "from: only applies to error messages" if kwargs.key?(:from) && kind != :error
 
             # If message is already a descriptor, use it directly
-            entry = if message.is_a?(Action::Core::Flow::Handlers::Descriptors::MessageDescriptor)
+            entry = if message.is_a?(Axn::Core::Flow::Handlers::Descriptors::MessageDescriptor)
                       raise ArgumentError, "Cannot pass additional configuration with prebuilt descriptor" if kwargs.any? || block_given?
 
                       message
                     else
-                      Action::Core::Flow::Handlers::Descriptors::MessageDescriptor.build(
+                      Axn::Core::Flow::Handlers::Descriptors::MessageDescriptor.build(
                         handler: block_given? ? block : message,
                         **kwargs,
                       )

data/lib/{action → axn}/core/flow.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require "action/core/flow/messages"
-require "action/core/flow/callbacks"
-require "action/core/flow/exception_execution"
+require "axn/core/flow/messages"
+require "axn/core/flow/callbacks"
+require "axn/core/flow/exception_execution"
 
-module Action
+module Axn
   module Core
     module Flow
       def self.included(base)

data/lib/{action → axn}/core/hooks.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Action
+module Axn
   module Core
     module Hooks
       def self.included(base)
@@ -68,10 +68,15 @@ module Action
       private
 
       def _with_hooks
-        _run_around_hooks do
-          _run_before_hooks
-          yield
-          _run_after_hooks
+        # Outer is needed in the unlikely case done! is called in around hooks
+        __respecting_early_completion do
+          _run_around_hooks do
+            __respecting_early_completion do
+              _run_before_hooks
+              yield
+              _run_after_hooks
+            end
+          end
         end
       end
 
@@ -118,6 +123,12 @@ module Action
       def _run_hook(hook, *)
         hook.is_a?(Symbol) ? send(hook, *) : instance_exec(*, &hook)
       end
+
+      def __respecting_early_completion
+        yield
+      rescue Axn::Internal::EarlyCompletion => e
+        @__context.__record_early_completion(e.message)
+      end
     end
   end
 end

data/lib/{action → axn}/core/logging.rb

@@ -2,7 +2,7 @@
 
 require "active_support/core_ext/module/delegation"
 
-module Action
+module Axn
   module Core
     module Logging
       LEVELS = %i[debug info warn error fatal].freeze
@@ -15,13 +15,13 @@ module Action
       end
 
       module ClassMethods
-        def log_level = Action.config.log_level
+        def log_level = Axn.config.log_level
 
         def log(message, level: 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)
+          Axn.config.logger.send(level, msg)
         end
 
         LEVELS.each do |level|

data/lib/{action → axn}/core/nesting_tracking.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Action
+module Axn
   module Core
     module NestingTracking
       def self.included(base)

data/lib/axn/core/profiling.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "axn/core/flow/handlers/invoker"
+
+module Axn
+  module Core
+    module Profiling
+      def self.included(base)
+        base.class_eval do
+          class_attribute :_profiling_enabled, default: false
+          class_attribute :_profiling_condition, default: nil
+          class_attribute :_profiling_sample_rate, default: 0.1
+          class_attribute :_profiling_output_dir, default: nil
+
+          extend ClassMethods
+        end
+      end
+
+      module ClassMethods
+        # Enable profiling for this action class
+        #
+        # @param if [Proc, Symbol, #call, nil] Optional condition to determine when to profile
+        # @param sample_rate [Float] Sampling rate (0.0 to 1.0, default: 0.1)
+        # @param output_dir [String, Pathname] Output directory for profile files (default: Rails.root/tmp/profiles or tmp/profiles)
+        # @return [void]
+        def profile(if: nil, sample_rate: 0.1, output_dir: nil)
+          self._profiling_enabled = true
+          self._profiling_condition = binding.local_variable_get(:if)
+          self._profiling_sample_rate = sample_rate
+          self._profiling_output_dir = output_dir || _default_profiling_output_dir
+        end
+
+        private
+
+        def _default_profiling_output_dir
+          if defined?(Rails) && Rails.respond_to?(:root)
+            Rails.root.join("tmp", "profiles")
+          else
+            Pathname.new("tmp/profiles")
+          end
+        end
+      end
+
+      private
+
+      def _with_profiling(&)
+        # Check if this specific action should be profiled
+        return yield unless _should_profile?
+
+        _profile_with_vernier(&)
+      end
+
+      def _profile_with_vernier(&)
+        _ensure_vernier_available!
+
+        class_name = self.class.name.presence || "AnonymousAction"
+        profile_name = "axn_#{class_name}_#{Time.now.to_i}"
+
+        # Ensure output directory exists (only once per instance)
+        _ensure_output_directory_exists
+
+        # Build output file path
+        output_dir = self.class._profiling_output_dir || _default_profiling_output_dir
+        output_file = File.join(output_dir, "#{profile_name}.json")
+
+        # Configure Vernier with our settings
+        collector_options = {
+          out: output_file,
+          allocation_sample_rate: (self.class._profiling_sample_rate * 1000).to_i,
+        }
+
+        Vernier.profile(**collector_options, &)
+      end
+
+      def _ensure_output_directory_exists
+        return if @_profiling_directory_created
+
+        output_dir = self.class._profiling_output_dir || _default_profiling_output_dir
+        FileUtils.mkdir_p(output_dir)
+        @_profiling_directory_created = true
+      end
+
+      def _should_profile?
+        # Fast path: check if action has profiling enabled
+        return false unless self.class._profiling_enabled
+
+        # Fast path: no condition means always profile
+        return true unless self.class._profiling_condition
+
+        # Slow path: evaluate condition (only when needed)
+        Axn::Core::Flow::Handlers::Invoker.call(
+          action: self,
+          handler: self.class._profiling_condition,
+          operation: "determining if profiling should run",
+        )
+      end
+
+      def _ensure_vernier_available!
+        return if defined?(Vernier) && Vernier.is_a?(Module)
+
+        begin
+          require "vernier"
+        rescue LoadError
+          raise LoadError, <<~ERROR
+            Vernier profiler is not available. To use profiling, add 'vernier' to your Gemfile:
+
+              gem 'vernier', '~> 0.1'
+
+            Then run: bundle install
+          ERROR
+        end
+      end
+
+      def _default_profiling_output_dir
+        if defined?(Rails) && Rails.respond_to?(:root)
+          Rails.root.join("tmp", "profiles")
+        else
+          Pathname.new("tmp/profiles")
+        end
+      end
+    end
+  end
+end

data/lib/{action → axn}/core/timing.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Action
+module Axn
   module Core
     module Timing
       def self.included(base)

data/lib/axn/core/tracing.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Axn
+  module Core
+    module Tracing
+      private
+
+      def _with_tracing(&)
+        return yield unless Axn.config.wrap_with_trace
+
+        Axn.config.wrap_with_trace.call(self.class.name || "AnonymousClass", &)
+      rescue StandardError => e
+        Axn::Internal::Logging.piping_error("running trace hook", action: self, exception: e)
+      end
+    end
+  end
+end

data/lib/axn/core/use_strategy.rb

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

data/lib/{action → axn}/core/validation/fields.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Action
+module Axn
   module Validation
     class Fields
       include ActiveModel::Validations
@@ -20,9 +20,25 @@ module Action
         @context.public_send(attr)
       end
 
+      def method_missing(method_name, ...)
+        # Delegate method calls to the action instance to support symbol-based validations
+        # like inclusion: { in: :valid_channels_for_number }
+        action = _action_for_validation
+        return super unless action && action.respond_to?(method_name, true) # rubocop:disable Style/SafeNavigation
+
+        action.send(method_name, ...)
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        action = _action_for_validation
+        return super unless action
+
+        action.respond_to?(method_name, include_private) || super
+      end
+
       def self.validate!(validations:, context:, exception_klass:)
         validator = Class.new(self) do
-          def self.name = "Action::Validation::Fields::OneOff"
+          def self.name = "Axn::Validation::Fields::OneOff"
 
           validations.each do |field, field_validations|
             field_validations.each do |key, value|
@@ -35,6 +51,14 @@ module Action
 
         raise exception_klass, validator.errors
       end
+
+      private
+
+      def _action_for_validation
+        return unless @context.respond_to?(:action, true)
+
+        @context.send(:action)
+      end
     end
   end
 end

data/lib/{action → axn}/core/validation/subfields.rb

@@ -2,7 +2,7 @@
 
 require "active_support/core_ext/hash/indifferent_access"
 
-module Action
+module Axn
   module Validation
     class Subfields
       include ActiveModel::Validations
@@ -17,24 +17,26 @@ module Action
       end
 
       def read_attribute_for_validation(attr)
-        self.class.extract(attr, @source)
+        # Only use action's reader methods for model fields that need special resolution
+        # For all other fields, use the unified FieldResolvers system
+        if @action && @validations&.key?(:model) && @action.respond_to?(attr)
+          @action.public_send(attr)
+        else
+          Axn::Core::FieldResolvers.resolve(type: :extract, field: attr, provided_data: @source)
+        end
       end
 
-      def self.extract(attr, source)
-        return source.public_send(attr) if source.respond_to?(attr)
-        raise "Unclear how to extract #{attr} from #{source.inspect}" unless source.respond_to?(:dig)
-
-        base = source.respond_to?(:with_indifferent_access) ? source.with_indifferent_access : source
-        base.dig(*attr.to_s.split("."))
-      end
-
-      def self.validate!(field:, validations:, source:, exception_klass:)
+      def self.validate!(field:, validations:, source:, exception_klass:, action: nil)
         validator = Class.new(self) do
-          def self.name = "Action::Validation::Subfields::OneOff"
+          def self.name = "Axn::Validation::Subfields::OneOff"
 
           validates field, **validations
         end.new(source)
 
+        # Set the action context for model field resolution
+        validator.instance_variable_set(:@action, action)
+        validator.instance_variable_set(:@validations, validations)
+
         return if validator.valid?
 
         raise exception_klass, validator.errors

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+module Axn
+  module Validators
+    class ModelValidator < ActiveModel::EachValidator
+      # Syntactic sugar: model: User -> model: { klass: User }
+      def self.apply_syntactic_sugar(value, fields)
+        (value.is_a?(Hash) ? value.dup : { klass: value }).tap do |options|
+          # Set default klass based on field name if not provided
+          options[:klass] = nil if options[:klass] == true
+          options[:klass] ||= fields.first.to_s.classify
+
+          # Constantize string klass names
+          options[:klass] = options[:klass].constantize if options[:klass].is_a?(String)
+
+          # Set default finder if not provided
+          options[:finder] ||= :find
+        end
+      end
+
+      def check_validity!
+        return unless options[:klass].nil?
+
+        raise ArgumentError, "must supply :klass"
+      end
+
+      def validate_each(record, attribute, value)
+        # The value is already resolved by the facade, just validate the type
+        type_validator = TypeValidator.new(attributes: [attribute], **options)
+        type_validator.validate_each(record, attribute, value)
+      end
+    end
+  end
+end

data/lib/axn/core/validation/validators/type_validator.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+module Axn
+  module Validators
+    class TypeValidator < ActiveModel::EachValidator
+      def self.apply_syntactic_sugar(value, _fields)
+        return value if value.is_a?(Hash)
+
+        { klass: value }
+      end
+
+      def check_validity!
+        raise ArgumentError, "must supply :klass" if options[:klass].nil?
+      end
+
+      # NOTE: we override the default validate method to allow for custom allow_blank logic
+      # (e.g. type: Hash should fail if given false or "", but by default EachValidator would skip)
+      def validate(record)
+        attributes.each do |attribute|
+          value = record.read_attribute_for_validation(attribute)
+          validate_each(record, attribute, value)
+        end
+      end
+
+      def validate_each(record, attribute, value)
+        # Custom allow_blank logic: only skip validation for nil, not other blank values
+        return if value.nil? && (options[:allow_nil] || options[:allow_blank])
+
+        # Check if any of the types are valid
+        valid = types.any? do |type|
+          valid_type?(type:, value:, allow_blank: options[:allow_blank])
+        end
+
+        record.errors.add attribute, (options[:message] || msg) unless valid
+      end
+
+      private
+
+      def types = Array(options[:klass])
+      def msg = types.size == 1 ? "is not a #{types.first}" : "is not one of #{types.join(", ")}"
+
+      def valid_type?(type:, value:, allow_blank:)
+        # NOTE: allow mocks to pass type validation by default (much easier testing ergonomics)
+        return true if Axn.config.env.test? && value.class.name&.start_with?("RSpec::Mocks::")
+
+        case type
+        when :boolean
+          boolean_type?(value)
+        when :uuid
+          uuid_type?(value, allow_blank:)
+        when :params
+          params_type?(value)
+        else
+          class_type?(type, value)
+        end
+      end
+
+      def boolean_type?(value)
+        [true, false].include?(value)
+      end
+
+      def uuid_type?(value, allow_blank: false)
+        return false unless value.is_a?(String)
+        return true if value.blank? && allow_blank
+
+        value.match?(/\A[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}\z/i)
+      end
+
+      def params_type?(value)
+        value.is_a?(Hash) || (defined?(ActionController::Parameters) && value.is_a?(ActionController::Parameters))
+      end
+
+      def class_type?(type, value)
+        value.is_a?(type)
+      end
+    end
+  end
+end