Add params validation and method wrapping logic

Adds the validation logic that integrates with dry-schema:
- validate_params instance method that validates input against the schema
- params method accepts either a schema class or block for defining validation rules
- Method wrapping via create_validator_for that prepends validation to wrapped methods
- Handles both positional hash and keyword argument calling styles
- Integration with PrependManager to apply validation before StepsMethodPrepender
- Returns Failure[:invalid_params, errors] when validation fails
- Adds dry-schema development dependency to Gemfile

Author: aaronmallen

Gemfile

@@ -22,6 +22,7 @@ end
 
 group :development, :test do
   gem "activerecord"
+  gem "dry-schema"
   gem "rom-sql"
   gem "sequel"
   gem "sqlite3"

lib/dry/operation/extensions/params.rb

@@ -18,25 +18,106 @@ module Extensions
       module Params
         def self.included(klass)
           klass.extend(ClassMethods)
+          klass.prepend(InstanceMethods)
+        end
+
+        # Instance methods for params validation
+        module InstanceMethods
+          include Dry::Monads::Result::Mixin
+
+          # Validates input against the params schema
+          #
+          # @param input [Hash] The input to validate
+          # @return [Dry::Monads::Result] Success with validated params or Failure with errors
+          # @api private
+          def validate_params(input)
+            schema = self.class._params_schema
+
+            return Success(input) unless schema
+
+            result = schema.call(input)
+
+            if result.success?
+              Success(result.to_h)
+            else
+              Failure[:invalid_params, result.errors.to_h]
+            end
+          end
         end
 
         # Class methods added to the operation class
         module ClassMethods
           # Define a params schema for validating operation inputs
           #
-          # The block is passed to `Dry::Schema.Params` to define the validation rules.
+          # Accepts either a schema class or a block for defining validation rules.
           #
+          # @param schema_class [Class, nil] A dry-schema class to use for validation
           # @yield Block for defining the schema using dry-schema DSL
           # @return [Dry::Schema::Params] The compiled schema
-          def params(&block)
-            @_params_schema = Dry::Schema.Params(&block)
+          #
+          # @example Using a block
+          #   params do
+          #     required(:name).filled(:string)
+          #   end
+          #
+          # @example Using a schema class
+          #   class UserSchema < Dry::Schema::Params
+          #     define do
+          #       required(:name).filled(:string)
+          #     end
+          #   end
+          #
+          #   params UserSchema
+          def params(schema_class = nil, &block)
+            @_params_schema = if schema_class
+              schema_class.is_a?(Class) ? schema_class.new : schema_class
+            elsif block
+              Dry::Schema.Params(&block)
+            else
+              raise ArgumentError, "params requires either a schema class or a block"
+            end
+            _apply_params_validation
           end
 
           # @api private
           def _params_schema
             @_params_schema
           end
 
+          # @api private
+          def _params_validated_methods
+            @_params_validated_methods ||= []
+          end
+
+          # @api private
+          def _apply_params_validation
+            methods_to_wrap = instance_variable_get(:@_prepend_manager)
+              &.instance_variable_get(:@methods_to_prepend) || []
+
+            methods_to_wrap.each do |method_name|
+              next if _params_validated_methods.include?(method_name)
+              next unless instance_methods.include?(method_name)
+
+              prepend(Params.create_validator_for(method_name))
+              _params_validated_methods << method_name
+            end
+          end
+
+          # @api private
+          def method_added(method_name)
+            if @_params_schema
+              methods_to_wrap = instance_variable_get(:@_prepend_manager)
+                &.instance_variable_get(:@methods_to_prepend) || []
+
+              if methods_to_wrap.include?(method_name) && !_params_validated_methods.include?(method_name)
+                prepend(Params.create_validator_for(method_name))
+                _params_validated_methods << method_name
+              end
+            end
+
+            super
+          end
+
           # @api private
           def inherited(subclass)
             super
@@ -45,6 +126,32 @@ def inherited(subclass)
             end
           end
         end
+
+        # @api private
+        # Creates a module that wraps a method to add params validation
+        def self.create_validator_for(method_name)
+          Module.new do
+            define_method(method_name) do |input = {}, *rest, **kwargs, &block|
+              use_kwargs = input.empty? && !kwargs.empty? && rest.empty?
+              actual_input = use_kwargs ? kwargs : input
+
+              validation_result = validate_params(actual_input)
+
+              case validation_result
+              when Dry::Monads::Success
+                validated_input = validation_result.value!
+
+                if use_kwargs
+                  super(**validated_input, &block)
+                else
+                  super(validated_input, *rest, **kwargs, &block)
+                end
+              when Dry::Monads::Failure
+                throw_failure(validation_result)
+              end
+            end
+          end
+        end
       end
     end
   end