axn 0.1.0.pre.alpha.2.8.1 → 0.1.0.pre.alpha.4

data/lib/action/attachable/steps.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module Action
-  module Attachable
-    module Steps
-      extend ActiveSupport::Concern
-
-      included do
-        class_attribute :_axn_steps, default: []
-      end
-
-      class_methods do
-        def steps(*steps)
-          Array(steps).compact.each do |step|
-            raise ArgumentError, "Step #{step} must include Action module" if step.is_a?(Class) && !step.included_modules.include?(Action) && !step < Action
-
-            step("Step #{_axn_steps.length + 1}", step)
-          end
-        end
-
-        def step(name, axn_klass = nil, error_prefix: nil, **kwargs, &block)
-          axn_klass = axn_for_attachment(
-            name:,
-            axn_klass:,
-            attachment_type: "Step",
-            superclass: Object, # NOTE: steps skip inheriting from the wrapping class (to avoid duplicate field expectations/exposures)
-            **kwargs,
-            &block
-          )
-
-          # Add the step to the list of steps
-          _axn_steps << axn_klass
-
-          # Set up error handling for steps without explicit labels
-          error_prefix ||= "#{name}: "
-          error from: axn_klass do |e|
-            "#{error_prefix}#{e.message}"
-          end
-        end
-      end
-
-      # Execute steps automatically when the action is called
-      def call
-        _axn_steps.each do |axn|
-          _merge_step_exposures!(axn.call!(**_merged_context_data))
-        end
-      end
-
-      private
-
-      def _merged_context_data
-        @__context.__combined_data
-      end
-
-      # Each step can expect the data exposed from the previous steps
-      def _merge_step_exposures!(step_result)
-        step_result.declared_fields.each do |field|
-          @__context.exposed_data[field] = step_result.public_send(field)
-        end
-      end
-    end
-  end
-end

data/lib/action/attachable/subactions.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module Action
-  module Attachable
-    module Subactions
-      extend ActiveSupport::Concern
-
-      included do
-        class_attribute :_axnable_methods, default: {}
-        class_attribute :_axns, default: {}
-      end
-
-      class_methods do
-        def axnable_method(name, axn_klass = nil, **action_kwargs, &block)
-          raise ArgumentError, "Unable to attach Axn -- '#{name}' is already taken" if respond_to?(name)
-
-          self._axnable_methods = _axnable_methods.merge(name => { axn_klass:, action_kwargs:, block: })
-
-          action_kwargs[:expose_return_as] ||= :value unless axn_klass
-          axn_klass = axn_for_attachment(name:, axn_klass:, **action_kwargs, &block)
-
-          define_singleton_method("#{name}_axn") do |**kwargs|
-            axn_klass.call(**kwargs)
-          end
-
-          define_singleton_method("#{name}!") do |**kwargs|
-            result = axn_klass.call!(**kwargs)
-            result.public_send(action_kwargs[:expose_return_as])
-          end
-        end
-
-        def axn(name, axn_klass = nil, **action_kwargs, &block)
-          raise ArgumentError, "Unable to attach Axn -- '#{name}' is already taken" if respond_to?(name)
-
-          self._axns = _axns.merge(name => { axn_klass:, action_kwargs:, block: })
-
-          axn_klass = axn_for_attachment(name:, axn_klass:, **action_kwargs, &block)
-
-          define_singleton_method(name) do |**kwargs|
-            axn_klass.call(**kwargs)
-          end
-
-          # TODO: do we also need an instance-level version that auto-creates the appropriate `error from:` to prefix with the name?
-
-          define_singleton_method("#{name}!") do |**kwargs|
-            axn_klass.call!(**kwargs)
-          end
-
-          self._axns = _axns.merge(name => axn_klass)
-        end
-
-        def inherited(subclass)
-          super
-
-          return unless subclass.name.present? # TODO: not sure why..
-
-          # Need to redefine the axnable methods on the subclass to ensure they properly reference the subclass's
-          # helper method definitions and not the superclass's.
-          _axnable_methods.each do |name, config|
-            subclass.axnable_method(name, config[:axn_klass], **config[:action_kwargs], &config[:block])
-          end
-
-          _axns.each do |name, config|
-            subclass.axn(name, config[:axn_klass], **config[:action_kwargs], &config[:block])
-          end
-        end
-      end
-    end
-  end
-end

data/lib/action/attachable.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require "action/attachable/base"
-require "action/attachable/steps"
-require "action/attachable/subactions"
-
-module Action
-  module Attachable
-    extend ActiveSupport::Concern
-
-    included do
-      include Base
-      include Steps
-      include Subactions
-    end
-  end
-end

data/lib/action/configuration.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module Action
-  class Configuration
-    attr_accessor :wrap_with_trace, :emit_metrics
-    attr_writer :logger, :env, :on_exception, :additional_includes, :log_level
-
-    def log_level = @log_level ||= :info
-
-    def additional_includes = @additional_includes ||= []
-
-    def on_exception(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
-        @on_exception.call(e)
-      end
-    end
-
-    def logger
-      @logger ||= begin
-        Rails.logger
-      rescue NameError
-        Logger.new($stdout).tap do |l|
-          l.level = Logger::INFO
-        end
-      end
-    end
-
-    def env
-      @env ||= ENV["RACK_ENV"].presence || ENV["RAILS_ENV"].presence || "development"
-      ActiveSupport::StringInquirer.new(@env)
-    end
-  end
-
-  class << self
-    def config = @config ||= Configuration.new
-
-    def configure
-      self.config ||= Configuration.new
-      yield(config) if block_given?
-    end
-  end
-end

data/lib/action/core/automatic_logging.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-module Action
-  module Core
-    module AutomaticLogging
-      def self.included(base)
-        base.class_eval do
-          extend ClassMethods
-          include InstanceMethods
-
-          # Single class_attribute - nil means disabled, any level means enabled
-          class_attribute :auto_log_level, default: Action.config.log_level
-        end
-      end
-
-      module ClassMethods
-        def auto_log(level)
-          self.auto_log_level = level.presence
-        end
-      end
-
-      module InstanceMethods
-        private
-
-        def _with_logging
-          _log_before if self.class.auto_log_level
-          yield
-        ensure
-          _log_after if self.class.auto_log_level
-        end
-
-        def _log_before
-          level = self.class.auto_log_level
-          return unless level
-
-          self.class.public_send(
-            level,
-            [
-              "About to execute",
-              _log_context(:inbound),
-            ].compact.join(" with: "),
-            before: Action.config.env.production? ? nil : "\n------\n",
-          )
-        rescue StandardError => e
-          Axn::Util.piping_error("logging before hook", action: self, exception: e)
-        end
-
-        def _log_after
-          level = self.class.auto_log_level
-          return unless level
-
-          self.class.public_send(
-            level,
-            [
-              "Execution completed (with outcome: #{result.outcome}) in #{result.elapsed_time} milliseconds",
-              _log_context(:outbound),
-            ].compact.join(". Set: "),
-            after: Action.config.env.production? ? nil : "\n------\n",
-          )
-        rescue StandardError => e
-          Axn::Util.piping_error("logging after hook", action: self, exception: e)
-        end
-
-        def _log_context(direction)
-          data = context_for_logging(direction)
-          return unless data.present?
-
-          max_length = 150
-          suffix = "…<truncated>…"
-
-          _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
-    end
-  end
-end

data/lib/action/core/context/facade.rb

@@ -1,48 +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) do
-          _context_data_source[field]
-        end
-      end
-    end
-
-    attr_reader :declared_fields
-
-    def inspect = ContextFacadeInspector.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 action_name = @action.class.name.presence || "The action"
-
-    def _context_data_source = raise NotImplementedError
-
-    def _msg_resolver(event_type, exception:)
-      Action::Core::Flow::Handlers::Resolvers::MessageResolver.new(
-        action._messages_registry,
-        event_type,
-        action:,
-        exception:,
-      )
-    end
-  end
-end

data/lib/action/core/flow/handlers/invoker.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module Action
-  module Core
-    module Flow
-      module Handlers
-        # Shared block evaluation with consistent arity handling and error piping
-        module Invoker
-          extend self
-
-          def call(action:, handler:, exception: nil, operation: "executing handler")
-            return call_symbol_handler(action:, symbol: handler, exception:) if symbol?(handler)
-            return call_callable_handler(action:, callable: handler, exception:) if callable?(handler)
-
-            literal_value(handler)
-          rescue StandardError => e
-            Axn::Util.piping_error(operation, action:, exception: e)
-          end
-
-          # Shared introspection helpers
-          def accepts_exception_keyword?(callable_or_method)
-            return false unless callable_or_method.respond_to?(:parameters)
-
-            params = callable_or_method.parameters
-            params.any? { |type, name| %i[keyreq key].include?(type) && name == :exception } ||
-              params.any? { |type, _| type == :keyrest }
-          end
-
-          def accepts_positional_exception?(callable_or_method)
-            return false unless callable_or_method.respond_to?(:arity)
-
-            arity = callable_or_method.arity
-            arity == 1 || arity.negative?
-          end
-
-          private
-
-          def symbol?(value) = value.is_a?(Symbol)
-
-          def callable?(value) = value.respond_to?(:arity)
-
-          def call_symbol_handler(action:, symbol:, exception: nil)
-            unless action.respond_to?(symbol, true)
-              action.warn("Ignoring apparently-invalid symbol #{symbol.inspect} -- action does not respond to method")
-              return nil
-            end
-
-            method = action.method(symbol)
-            if exception && accepts_exception_keyword?(method)
-              action.send(symbol, exception:)
-            elsif exception && accepts_positional_exception?(method)
-              action.send(symbol, exception)
-            else
-              action.send(symbol)
-            end
-          end
-
-          def call_callable_handler(action:, callable:, exception: nil)
-            if exception && accepts_exception_keyword?(callable)
-              action.instance_exec(exception:, &callable)
-            elsif exception && accepts_positional_exception?(callable)
-              action.instance_exec(exception, &callable)
-            else
-              action.instance_exec(&callable)
-            end
-          end
-
-          def literal_value(value) = value
-        end
-      end
-    end
-  end
-end

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

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

data/lib/action/core/logging.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/module/delegation"
-
-module Action
-  module Core
-    module Logging
-      LEVELS = %i[debug info warn error fatal].freeze
-
-      def self.included(base)
-        base.class_eval do
-          extend ClassMethods
-          delegate :log, *LEVELS, to: :class
-        end
-      end
-
-      module ClassMethods
-        def log_level = Action.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)
-        end
-
-        LEVELS.each do |level|
-          define_method(level) do |message, before: nil, after: nil|
-            log(message, level:, before:, after:)
-          end
-        end
-
-        def _log_prefix = "[#{name.presence || "Anonymous Class"}]"
-      end
-    end
-  end
-end

data/lib/action/core/tracing.rb

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

data/lib/action/core/use_strategy.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module Action
-  module Core
-    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
-end

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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require "active_model"
-
-module Action
-  module Validators
-    class ModelValidator < ActiveModel::EachValidator
-      def self.model_for(field:, klass: nil)
-        return klass if defined?(ActiveRecord::Base) && klass.is_a?(ActiveRecord::Base)
-
-        field.to_s.delete_suffix("_id").classify.constantize
-      end
-
-      def self.instance_for(field:, klass:, id:)
-        klass = model_for(field:, klass:)
-        return unless klass.respond_to?(:find_by)
-
-        klass.find_by(id:)
-      end
-
-      def validate_each(record, attribute, id)
-        klass = self.class.model_for(field: attribute, klass: options[:with])
-        instance = self.class.instance_for(field: attribute, klass:, id:)
-        return if instance.present?
-
-        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
-        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
-  end
-end

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

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require "active_model"
-
-module Action
-  module Validators
-    class TypeValidator < ActiveModel::EachValidator
-      def validate_each(record, attribute, value)
-        # NOTE: the last one (:value) might be my fault from the make-it-a-hash fallback in #parse_field_configs
-        types = options[:in].presence || Array(options[:with]).presence || Array(options[:value]).presence
-
-        return if value.blank? && !types.include?(:boolean) # Handled with a separate default presence validator
-
-        msg = types.size == 1 ? "is not a #{types.first}" : "is not one of #{types.join(", ")}"
-        record.errors.add attribute, (options[:message] || msg) unless types.any? do |type|
-          if type == :boolean
-            [true, false].include?(value)
-          elsif type == :uuid
-            value.is_a?(String) && 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)
-          else
-            # NOTE: allow mocks to pass type validation by default (much easier testing ergonomics)
-            next true if Action.config.env.test? && value.class.name&.start_with?("RSpec::Mocks::")
-
-            value.is_a?(type)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/action/enqueueable/via_sidekiq.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-module Action
-  module Enqueueable
-    module ViaSidekiq
-      def self.included(base)
-        base.class_eval do
-          begin
-            require "sidekiq"
-            include Sidekiq::Job
-          rescue LoadError
-            puts "Sidekiq not available -- skipping Enqueueable"
-            return
-          end
-
-          define_method(:perform) do |*args|
-            context = self.class._params_from_global_id(args.first)
-            bang = args.size > 1 ? args.last : false
-
-            if bang
-              self.class.call!(**context)
-            else
-              self.class.call(**context)
-            end
-          end
-
-          def self.enqueue(context = {})
-            perform_async(_process_context_to_sidekiq_args(context))
-          end
-
-          def self.enqueue!(context = {})
-            perform_async(_process_context_to_sidekiq_args(context), true)
-          end
-
-          def self.queue_options(opts)
-            opts = opts.transform_keys(&:to_s)
-            self.sidekiq_options_hash = get_sidekiq_options.merge(opts)
-          end
-
-          private
-
-          def self._process_context_to_sidekiq_args(context)
-            client = Sidekiq::Client.new
-
-            _params_to_global_id(context).tap do |args|
-              if client.send(:json_unsafe?, args).present?
-                raise ArgumentError,
-                      "Cannot pass non-JSON-serializable objects to Sidekiq. Make sure all expected arguments are serializable (or respond to to_global_id)."
-              end
-            end
-          end
-
-          def self._params_to_global_id(context)
-            context.stringify_keys.each_with_object({}) do |(key, value), hash|
-              if value.respond_to?(:to_global_id)
-                hash["#{key}_as_global_id"] = value.to_global_id.to_s
-              else
-                hash[key] = value
-              end
-            end
-          end
-
-          def self._params_from_global_id(params)
-            params.each_with_object({}) do |(key, value), hash|
-              if key.end_with?("_as_global_id")
-                hash[key.delete_suffix("_as_global_id")] = GlobalID::Locator.locate(value)
-              else
-                hash[key] = value
-              end
-            end.symbolize_keys
-          end
-        end
-      end
-    end
-  end
-end

data/lib/action/enqueueable.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require "action/enqueueable/via_sidekiq"
-
-module Action
-  module Enqueueable
-    extend ActiveSupport::Concern
-
-    included do
-      include ViaSidekiq
-    end
-  end
-end