interactor-validation 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8a2389fc324f275ef082e2d5b24174f8c753c88a5adc3d4ed6499670b6a1da11
+  data.tar.gz: dc45f25929ca97a2a49dc4663e885dff8780d1dc54d4d11bb8555e39fd00c11f
+SHA512:
+  metadata.gz: dfc83bceb6887d5b45338a0801ba61e9e978bbbd319fa5b43d754bc50cc18f863fda7d841e1dd8a749292bc9ffb998bb476df57b0e76091075723fc157281d2f
+  data.tar.gz: f0ab78c0e9f364da7c343fd5799d020c8dd4e3139c7b859c95ae8f7d10470c24a6b1e519516b27b0eff06627549075bb8b1d1e125afde15f2cea2b88e91459d3

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-11-16
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Wilson Anciro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,241 @@
+# Interactor::Validation
+
+Add Rails-style parameter validation to your [Interactor](https://github.com/collectiveidea/interactor) service objects with simple, declarative syntax.
+
+## Installation
+
+```ruby
+gem "interactor-validation"
+```
+
+## Quick Start
+
+```ruby
+class CreateUser
+  include Interactor
+  include Interactor::Validation
+
+  params :email, :username, :age
+
+  validates :email, presence: true, format: { with: URI::MailTo::EMAIL_REGEXP }
+  validates :username, presence: true, length: { minimum: 3, maximum: 20 }
+  validates :age, numericality: { greater_than: 0, less_than: 150 }
+
+  def call
+    user = User.create!(email: email, username: username, age: age)
+    context.user = user
+  end
+end
+
+# Success
+result = CreateUser.call(email: "dev@example.com", username: "developer", age: 25)
+result.success? # => true
+result.user     # => #<User...>
+
+# Failure - automatic validation
+result = CreateUser.call(email: "", username: "ab", age: -5)
+result.failure? # => true
+result.errors   # => [
+                #      { code: "EMAIL_IS_REQUIRED" },
+                #      { code: "USERNAME_BELOW_MIN_LENGTH_3" },
+                #      { code: "AGE_MUST_BE_GREATER_THAN_0" }
+                #    ]
+```
+
+## Features
+
+### Parameter Declaration
+
+Use `params` to declare expected parameters - they're automatically delegated to context:
+
+```ruby
+params :user_id, :action
+
+def call
+  # Access directly instead of context.user_id
+  user = User.find(user_id)
+  user.perform(action)
+end
+```
+
+### Validation Rules
+
+All validations run **before** your `call` method. If validation fails, the interactor stops and returns structured errors.
+
+**Presence**
+```ruby
+validates :name, presence: true
+# Error: { code: "NAME_IS_REQUIRED" }
+```
+
+**Format (Regex)**
+```ruby
+validates :email, format: { with: /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i }
+# Error: { code: "EMAIL_INVALID_FORMAT" }
+```
+
+**Length**
+```ruby
+validates :password, length: { minimum: 8, maximum: 128 }
+validates :code, length: { is: 6 }
+# Errors: { code: "PASSWORD_BELOW_MIN_LENGTH_8" }
+#         { code: "CODE_INVALID_LENGTH_6" }
+```
+
+**Inclusion**
+```ruby
+validates :status, inclusion: { in: %w[active pending inactive] }
+# Error: { code: "STATUS_NOT_IN_LIST" }
+```
+
+**Numericality**
+```ruby
+validates :price, numericality: { greater_than_or_equal_to: 0 }
+validates :quantity, numericality: { greater_than: 0, less_than_or_equal_to: 100 }
+# Errors: { code: "PRICE_MUST_BE_GREATER_THAN_OR_EQUAL_TO_0" }
+```
+
+### Error Formats
+
+The gem supports two error formatting modes:
+
+#### Code Mode (Default)
+
+Returns structured error codes ideal for APIs and i18n:
+
+```ruby
+result.errors # => [
+              #      { code: "EMAIL_IS_REQUIRED" },
+              #      { code: "USERNAME_BELOW_MIN_LENGTH_3" }
+              #    ]
+```
+
+#### Default Mode
+
+Returns ActiveModel-style errors with human-readable messages:
+
+```ruby
+Interactor::Validation.configure do |config|
+  config.error_mode = :default
+end
+
+result.errors # => [
+              #      { attribute: :email, type: :blank, message: "Email can't be blank" },
+              #      { attribute: :username, type: :too_short, message: "Username is too short (minimum is 3 characters)" }
+              #    ]
+```
+
+## Configuration
+
+### Global Configuration
+
+Configure validation behavior for all interactors:
+
+```ruby
+# config/initializers/interactor_validation.rb
+Interactor::Validation.configure do |config|
+  # Error format mode: :code (default) or :default
+  config.error_mode = :code
+
+  # Stop validation at first error (default: false)
+  config.halt_on_first_error = false
+end
+```
+
+### Per-Interactor Configuration
+
+Override global settings for specific interactors:
+
+```ruby
+class CreateUser
+  include Interactor
+  include Interactor::Validation
+
+  configure_validation do |config|
+    config.error_mode = :default
+    config.halt_on_first_error = true
+  end
+
+  validates :username, presence: true
+  validates :email, presence: true
+end
+```
+
+### Custom Error Messages
+
+Provide custom error messages for any validation:
+
+```ruby
+# With :code mode
+configure_validation do |config|
+  config.error_mode = :code
+end
+
+validates :username, presence: { message: "CUSTOM_REQUIRED_ERROR" }
+validates :email, format: { with: /@/, message: "CUSTOM_FORMAT_ERROR" }
+# => { code: "USERNAME_CUSTOM_REQUIRED_ERROR" }
+# => { code: "EMAIL_CUSTOM_FORMAT_ERROR" }
+
+# With :default mode
+configure_validation do |config|
+  config.error_mode = :default
+end
+
+validates :bio, length: { maximum: 500, message: "is too long (max 500 chars)" }
+# => { attribute: :bio, type: :too_long, message: "is too long (max 500 chars)" }
+```
+
+### Advanced Usage
+
+#### Halt on First Error
+
+Improve performance by stopping validation at the first failure:
+
+```ruby
+configure_validation do |config|
+  config.halt_on_first_error = true  # Stop at first error
+end
+
+validates :field1, presence: true
+validates :field2, presence: true  # Won't run if field1 fails
+validates :field3, presence: true  # Won't run if field1 or field2 fails
+```
+
+#### Integration with ActiveModel Validations
+
+Use ActiveModel's custom validation callbacks:
+
+```ruby
+class CreateUser
+  include Interactor
+  include Interactor::Validation
+
+  params :user_data
+
+  validate :check_user_data_structure
+  validates :username, presence: true
+
+  def check_user_data_structure
+    errors.add(:user_data, "must be a Hash") unless user_data.is_a?(Hash)
+  end
+end
+```
+
+## Development
+
+```bash
+bin/setup              # Install dependencies
+bundle exec rspec      # Run tests
+bundle exec rubocop    # Lint code
+bin/console            # Interactive console
+```
+
+## Requirements
+
+- Ruby >= 3.2.0
+- Interactor ~> 3.0
+- ActiveModel >= 6.0
+
+## License
+
+MIT License - see [LICENSE.txt](LICENSE.txt)

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/interactor/validation/configuration.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Interactor
+  module Validation
+    # Configuration class for interactor validation behavior
+    class Configuration
+      attr_accessor :halt_on_first_error
+      attr_reader :error_mode
+
+      # Available error modes:
+      # - :default - Uses ActiveModel-style human-readable messages
+      # - :code - Returns structured error codes (e.g., USERNAME_IS_REQUIRED) [DEFAULT]
+      def initialize
+        @error_mode = :code
+        @halt_on_first_error = false
+      end
+
+      def error_mode=(mode)
+        raise ArgumentError, "Invalid error_mode: #{mode}. Must be :default or :code" unless %i[default code].include?(mode)
+
+        @error_mode = mode
+      end
+    end
+
+    class << self
+      attr_writer :configuration
+
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def configure
+        yield(configuration)
+      end
+
+      def reset_configuration!
+        @configuration = Configuration.new
+      end
+    end
+  end
+end

data/lib/interactor/validation/params.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Interactor
+  module Validation
+    module Params
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_declared_params, instance_writer: false, default: []
+      end
+
+      class_methods do
+        # Declares parameters that will be delegated from context
+        # and registered for validation
+        #
+        # @param param_names [Array<Symbol>] the parameter names to declare
+        # @example
+        #   params :username, :password
+        def params(*param_names)
+          param_names.each do |param_name|
+            # Ensure we're working with a copy to avoid modifying parent's array
+            current_params = _declared_params.dup
+            self._declared_params = current_params + [param_name] unless current_params.include?(param_name)
+
+            # Delegate to context for easy access
+            delegate param_name, to: :context
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interactor/validation/validates.rb

@@ -0,0 +1,311 @@
+# frozen_string_literal: true
+
+module Interactor
+  module Validation
+    module Validates
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_param_validations, instance_writer: false, default: {}
+      end
+
+      def self.included(base)
+        super
+        # Include ActiveModel::Validations first, then prepend our override
+        base.include ActiveModel::Validations unless base.included_modules.include?(ActiveModel::Validations)
+        base.singleton_class.prepend(ClassMethodsOverride)
+      end
+
+      module ClassMethodsOverride
+        # Override ActiveModel's validates to handle our simple validation rules
+        # Falls back to ActiveModel's validates for complex cases
+        def validates(param_name, **rules)
+          # If no keyword arguments, delegate to ActiveModel's validates
+          return super(param_name) if rules.empty?
+
+          # Merge validation rules for the same param, ensuring we don't modify parent's hash
+          current_validations = _param_validations.dup
+          existing_rules = current_validations[param_name] || {}
+          self._param_validations = current_validations.merge(param_name => existing_rules.merge(rules))
+        end
+      end
+
+      private
+
+      # Validates all declared parameters before execution
+      def validate_params!
+        # Trigger ActiveModel validations first (validate callbacks)
+        # This runs any custom validations defined with validate :method_name
+        # NOTE: valid? must be called BEFORE adding our custom errors
+        # because it clears the errors object
+        valid?
+
+        # Run our custom param validations after ActiveModel validations
+        self.class._param_validations.each do |param_name, rules|
+          # Safe param access - returns nil if not present in context
+          value = context.respond_to?(param_name) ? context.public_send(param_name) : nil
+          validate_param(param_name, value, rules)
+
+          # Halt on first error if configured
+          break if current_config.halt_on_first_error && errors.any?
+        end
+
+        return if errors.empty?
+
+        context.fail!(errors: formatted_errors)
+      end
+
+      # Get the current configuration (instance config overrides global config)
+      def current_config
+        self.class.validation_config || Interactor::Validation.configuration
+      end
+
+      # Validates a single parameter with the given rules
+      def validate_param(param_name, value, rules)
+        validate_presence(param_name, value, rules)
+        validate_format(param_name, value, rules)
+        validate_length(param_name, value, rules)
+        validate_inclusion(param_name, value, rules)
+        validate_numericality(param_name, value, rules)
+      end
+
+      def validate_presence(param_name, value, rules)
+        return unless rules[:presence]
+        return if value.present?
+
+        message = extract_message(rules[:presence], :blank)
+        add_error(param_name, message, :blank)
+      end
+
+      def validate_format(param_name, value, rules)
+        return unless rules[:format] && value.present?
+
+        format_options = rules[:format]
+        pattern = format_options.is_a?(Hash) ? format_options[:with] : format_options
+        return if value.to_s.match?(pattern)
+
+        message = extract_message(format_options, :invalid)
+        add_error(param_name, message, :invalid)
+      end
+
+      def validate_length(param_name, value, rules)
+        return unless rules[:length] && value.present?
+
+        length_rules = rules[:length]
+        length = value.to_s.length
+
+        if length_rules[:maximum] && length > length_rules[:maximum]
+          message = extract_message(length_rules, :too_long, count: length_rules[:maximum])
+          add_error(param_name, message, :too_long, count: length_rules[:maximum])
+        end
+
+        if length_rules[:minimum] && length < length_rules[:minimum]
+          message = extract_message(length_rules, :too_short, count: length_rules[:minimum])
+          add_error(param_name, message, :too_short, count: length_rules[:minimum])
+        end
+
+        return unless length_rules[:is] && length != length_rules[:is]
+
+        message = extract_message(length_rules, :wrong_length, count: length_rules[:is])
+        add_error(param_name, message, :wrong_length, count: length_rules[:is])
+      end
+
+      def validate_inclusion(param_name, value, rules)
+        return unless rules[:inclusion] && value.present?
+
+        inclusion_options = rules[:inclusion]
+        allowed_values = inclusion_options.is_a?(Hash) ? inclusion_options[:in] : inclusion_options
+        return if allowed_values.include?(value)
+
+        message = extract_message(inclusion_options, :inclusion)
+        add_error(param_name, message, :inclusion)
+      end
+
+      def validate_numericality(param_name, value, rules)
+        return unless rules[:numericality] && value.present?
+
+        numeric_rules = rules[:numericality].is_a?(Hash) ? rules[:numericality] : {}
+
+        unless numeric?(value)
+          message = extract_message(numeric_rules, :not_a_number)
+          add_error(param_name, message, :not_a_number)
+          return
+        end
+
+        numeric_value = coerce_to_numeric(value)
+        validate_numeric_constraints(param_name, numeric_value, numeric_rules)
+      end
+
+      def numeric?(value)
+        value.is_a?(Numeric) || value.to_s.match?(/\A-?\d+(\.\d+)?\z/)
+      end
+
+      def coerce_to_numeric(value)
+        value.is_a?(Numeric) ? value : value.to_s.to_f
+      end
+
+      def validate_numeric_constraints(param_name, value, rules)
+        if rules[:greater_than] && value <= rules[:greater_than]
+          message = extract_message(rules, :greater_than, count: rules[:greater_than])
+          add_error(param_name, message, :greater_than, count: rules[:greater_than])
+        end
+
+        if rules[:greater_than_or_equal_to] && value < rules[:greater_than_or_equal_to]
+          message = extract_message(rules, :greater_than_or_equal_to, count: rules[:greater_than_or_equal_to])
+          add_error(param_name, message, :greater_than_or_equal_to, count: rules[:greater_than_or_equal_to])
+        end
+
+        if rules[:less_than] && value >= rules[:less_than]
+          message = extract_message(rules, :less_than, count: rules[:less_than])
+          add_error(param_name, message, :less_than, count: rules[:less_than])
+        end
+
+        if rules[:less_than_or_equal_to] && value > rules[:less_than_or_equal_to]
+          message = extract_message(rules, :less_than_or_equal_to, count: rules[:less_than_or_equal_to])
+          add_error(param_name, message, :less_than_or_equal_to, count: rules[:less_than_or_equal_to])
+        end
+
+        return unless rules[:equal_to] && value != rules[:equal_to]
+
+        message = extract_message(rules, :equal_to, count: rules[:equal_to])
+        add_error(param_name, message, :equal_to, count: rules[:equal_to])
+      end
+
+      # Extract custom message from validation options
+      # @param options [Hash, Boolean] validation options
+      # @param error_type [Symbol] the type of error
+      # @param interpolations [Hash] values to interpolate into message
+      # @return [String, nil] custom message if provided
+      def extract_message(options, _error_type, **_interpolations)
+        return nil unless options.is_a?(Hash)
+
+        options[:message]
+      end
+
+      # Add an error with proper formatting based on error mode
+      # @param param_name [Symbol] the parameter name
+      # @param custom_message [String, nil] custom error message if provided
+      # @param error_type [Symbol] the type of validation error
+      # @param interpolations [Hash] values to interpolate into the message
+      def add_error(param_name, custom_message, error_type, **interpolations)
+        if current_config.error_mode == :code
+          # Code mode: use custom message or generate code
+          code_message = custom_message || error_code_for(error_type, **interpolations)
+          errors.add(param_name, code_message)
+        elsif custom_message
+          # Default mode: use ActiveModel's error messages
+          errors.add(param_name, custom_message)
+        else
+          errors.add(param_name, error_type, **interpolations)
+        end
+      end
+
+      # Generate error code for :code mode
+      # @param error_type [Symbol] the type of validation error
+      # @param interpolations [Hash] values to interpolate into the code
+      # @return [String] the error code
+      def error_code_for(error_type, **interpolations)
+        case error_type
+        when :blank
+          "IS_REQUIRED"
+        when :invalid
+          "INVALID_FORMAT"
+        when :too_long
+          "EXCEEDS_MAX_LENGTH_#{interpolations[:count]}"
+        when :too_short
+          "BELOW_MIN_LENGTH_#{interpolations[:count]}"
+        when :wrong_length
+          "MUST_BE_LENGTH_#{interpolations[:count]}"
+        when :inclusion
+          "NOT_IN_ALLOWED_VALUES"
+        when :not_a_number
+          "MUST_BE_A_NUMBER"
+        when :greater_than
+          "MUST_BE_GREATER_THAN_#{interpolations[:count]}"
+        when :greater_than_or_equal_to
+          "MUST_BE_AT_LEAST_#{interpolations[:count]}"
+        when :less_than
+          "MUST_BE_LESS_THAN_#{interpolations[:count]}"
+        when :less_than_or_equal_to
+          "MUST_BE_AT_MOST_#{interpolations[:count]}"
+        when :equal_to
+          "MUST_BE_EQUAL_TO_#{interpolations[:count]}"
+        else
+          error_type.to_s.upcase
+        end
+      end
+
+      # Formats errors into the expected structure
+      def formatted_errors
+        if current_config.error_mode == :code
+          # Code mode: return structured error codes
+          errors.map do |error|
+            param_name = error.attribute.to_s.upcase
+            message = error.message
+
+            { code: "#{param_name}_#{message}" }
+          end
+        else
+          # Default mode: return ActiveModel-style errors
+          errors.map do |error|
+            # Build a human-readable message manually to avoid anonymous class issues
+            message = build_error_message(error)
+            {
+              attribute: error.attribute,
+              type: error.type,
+              message: message
+            }
+          end
+        end
+      end
+
+      # Build a human-readable error message
+      # @param error [ActiveModel::Error] the error object
+      # @return [String] the formatted message
+      def build_error_message(error)
+        # Try to use ActiveModel's message first
+        error.message if error.respond_to?(:message)
+      rescue ArgumentError
+        # Fallback for anonymous classes or other issues
+        attribute_name = error.attribute.to_s.humanize
+        error_message = error.options[:message] || default_message_for_type(error.type, error.options)
+        "#{attribute_name} #{error_message}"
+      end
+
+      # Get default message for error type
+      # @param type [Symbol] the error type
+      # @param options [Hash] error options with interpolations
+      # @return [String] the default message
+      def default_message_for_type(type, options = {})
+        case type
+        when :blank
+          "can't be blank"
+        when :invalid
+          "is invalid"
+        when :too_long
+          "is too long (maximum is #{options[:count]} characters)"
+        when :too_short
+          "is too short (minimum is #{options[:count]} characters)"
+        when :wrong_length
+          "is the wrong length (should be #{options[:count]} characters)"
+        when :inclusion
+          "is not included in the list"
+        when :not_a_number
+          "is not a number"
+        when :greater_than
+          "must be greater than #{options[:count]}"
+        when :greater_than_or_equal_to
+          "must be greater than or equal to #{options[:count]}"
+        when :less_than
+          "must be less than #{options[:count]}"
+        when :less_than_or_equal_to
+          "must be less than or equal to #{options[:count]}"
+        when :equal_to
+          "must be equal to #{options[:count]}"
+        else
+          "is invalid"
+        end
+      end
+    end
+  end
+end

data/lib/interactor/validation/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Interactor
+  module Validation
+    VERSION = "0.1.1"
+  end
+end

data/lib/interactor/validation.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "interactor"
+require "active_support/concern"
+require "active_model"
+
+require_relative "validation/version"
+require_relative "validation/configuration"
+require_relative "validation/params"
+require_relative "validation/validates"
+
+module Interactor
+  module Validation
+    class Error < StandardError; end
+
+    extend ActiveSupport::Concern
+
+    included do
+      include Params
+      include Validates
+
+      # Instance-level configuration (can override global config)
+      class_attribute :validation_config, instance_writer: false, default: nil
+    end
+
+    class_methods do
+      # Configure validation behavior for this interactor class
+      # @example
+      #   configure_validation do |config|
+      #     config.error_mode = :code
+      #   end
+      def configure_validation
+        self.validation_config ||= Configuration.new
+        yield(validation_config)
+      end
+    end
+
+    def self.included(base)
+      super
+      # Set up the validation hook after all modules are included
+      # Use class_eval to ensure we're in the right context
+      base.class_eval do
+        before :validate_params! if respond_to?(:before)
+
+        # Set up inherited hook to ensure child classes also get the before hook
+        def self.inherited(subclass)
+          super
+          subclass.before :validate_params! if subclass.respond_to?(:before)
+        end
+      end
+    end
+  end
+end

data/sig/interactor/validation.rbs

@@ -0,0 +1,6 @@
+module Interactor
+  module Validation
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification
+name: interactor-validation
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Wilson Anciro
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: interactor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: fuubar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+description: Adds Rails-style parameter declaration and validation to Interactor contexts
+  with support for presence, format, length, inclusion, and numericality validations.
+email:
+- konekred@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/interactor/validation.rb
+- lib/interactor/validation/configuration.rb
+- lib/interactor/validation/params.rb
+- lib/interactor/validation/validates.rb
+- lib/interactor/validation/version.rb
+- sig/interactor/validation.rbs
+homepage: https://github.com/zyxzen/interactor-validation
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/zyxzen/interactor-validation
+  source_code_uri: https://github.com/zyxzen/interactor-validation
+  changelog_uri: https://github.com/zyxzen/interactor-validation/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Parameter declaration and validation for Interactor gem
+test_files: []