hanami-controller 2.2.0.beta1 → 2.2.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97114bc3e9ab406fe26bc05b1022f79b9f1bcf1bcbf23b84cecffa6bdb306ec4
-  data.tar.gz: 8016185016dab18fda2fc40c028572240d000d09c2d1e37197430b46ab2a0e71
+  metadata.gz: c1d4e9b1af736129911e894a09fe5d61c1a56c50ac56ef31d4e2a2d6da27b4dc
+  data.tar.gz: 9cb8f020dcd2fe5b7e5880293058c85b8fa6b74d49982035dbffcf5c0234ff06
 SHA512:
-  metadata.gz: 44991c54305b783db097a835e63385ab09b8a62a8e90032a59eb8c456a72ffcd0169d155bf0070ed3409da75ff4748801e1aef71b353c1c5c25d6a92739a5d03
-  data.tar.gz: 1c0e08f6390616ac3f811b701cc2cd7d1365d64d182a0e6e73c506842acb248724126ef38b4582e7d028404fae13c16a6493eae720f931f0bc758682d5d5a26b
+  metadata.gz: 24b661dcdd3a9a75cb7842a12cd6fc8ad94a1aa814e0cb38cc89021583b9da5d5ae3d98a60fc43365b52ca537226e8a67c5bb572c9d6d884ad96a885e478e6f8
+  data.tar.gz: 9862fcb6a0f57e4dbaf5ceeb965df3c93d2b33e61da735b4ca906253dd7d3ff59dce188b545e939da23069ed8a984b80434200afebc575534ac4745a77dac976

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 Complete, fast and testable actions for Rack
 
+## v2.2.0.rc1 - 2024-10-29
+
+## v2.2.0.beta2 - 2024-09-25
+
+### Added
+
+- [Tim Riley, Krzysztof Piotrowski] Add support for using full dry-validation contracts for action param validation, via `Hanami::Action.contract` (#453, #454)
+
 ## v2.2.0.beta1 - 2024-07-16
 
 ### Changed

data/hanami-controller.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = ">= 3.1"
 
   spec.add_dependency "rack", "~> 2.0"
-  spec.add_dependency "hanami-utils", "~> 2.2.beta"
+  spec.add_dependency "hanami-utils", "~> 2.2.rc"
   spec.add_dependency "dry-configurable", "~> 1.0", "< 2"
   spec.add_dependency "dry-core", "~> 1.0"
   spec.add_dependency "zeitwerk", "~> 2.6"

data/lib/hanami/action/csrf_protection.rb

@@ -131,14 +131,14 @@ module Hanami
         return false unless verify_csrf_token?(req, res)
 
         missing_csrf_token?(req, res) ||
-          !::Rack::Utils.secure_compare(req.session[CSRF_TOKEN], req.params[CSRF_TOKEN])
+          !::Rack::Utils.secure_compare(req.session[CSRF_TOKEN], req.params.raw[CSRF_TOKEN.to_s])
       end
 
       # Verify the CSRF token was passed in params.
       #
       # @api private
       def missing_csrf_token?(req, *)
-        Hanami::Utils::Blank.blank?(req.params[CSRF_TOKEN])
+        Hanami::Utils::Blank.blank?(req.params.raw[CSRF_TOKEN.to_s])
       end
 
       # Generates a random CSRF Token

data/lib/hanami/action/params.rb

@@ -1,9 +1,21 @@
 # frozen_string_literal: true
 
-require "hanami/validations/form"
+require "rack/request"
+require "hanami/utils/hash"
 
 module Hanami
   class Action
+    # Provides access to params included in a Rack request.
+    #
+    # Offers useful access to params via methods like {#[]}, {#get} and {#to_h}.
+    #
+    # These params are available via {Request#params}.
+    #
+    # This class is used by default when {Hanami::Action::Validatable} is not included, or when no
+    # {Validatable::ClassMethods#params params} validation schema is defined.
+    #
+    # @see Hanami::Action::Request#params
+
     # A set of params requested by the client
     #
     # It's able to extract the relevant params from a Rack env of from an Hash.
@@ -14,8 +26,23 @@ module Hanami
     #   * Default: it returns the given hash as it is. It's useful for testing purposes.
     #
     # @since 0.1.0
-    class Params < BaseParams
-      include Hanami::Validations::Form
+    class Params
+      # Permits all params and returns them as symbolized keys. Stands in for a
+      # `Dry::Validation::Contract` when neither {Action.params} nor {Action.contract} are called.
+      #
+      # @see {Params#initialize}
+      #
+      # @since 2.2.0
+      # @api private
+      class DefaultContract
+        def self.call(attrs) = Result.new(attrs)
+
+        class Result
+          def initialize(attrs) = @attrs = Utils::Hash.deep_symbolize(attrs)
+          def to_h = @attrs
+          def errors = {}
+        end
+      end
 
       # Params errors
       #
@@ -107,46 +134,57 @@ module Hanami
         end
       end
 
-      # This is a Hanami::Validations extension point
+      # Defines validations for the params, using the `params` schema of a dry-validation contract.
+      #
+      # @param block [Proc] the schema definition
       #
+      # @see https://dry-rb.org/gems/dry-validation/
+      #
+      # @api public
       # @since 0.7.0
-      # @api private
-      def self._base_rules
-        lambda do
-          optional(:_csrf_token).filled(:str?)
+      def self.params(&block)
+        unless defined?(Dry::Validation::Contract)
+          message = %(To use `.params`, please add the "hanami-validations" gem to your Gemfile)
+          raise NoMethodError, message
         end
+
+        @_contract = Class.new(Dry::Validation::Contract) { params(&block || -> {}) }.new
+      end
+
+      class << self
+        # @api private
+        # @since 2.2.0
+        attr_reader :_contract
       end
 
-      # Define params validations
+      # @attr_reader env [Hash] the Rack env
       #
-      # @param blk [Proc] the validations definitions
+      # @since 0.7.0
+      # @api private
+      attr_reader :env
+
+      # @attr_reader raw [Hash] the raw params from the request
       #
       # @since 0.7.0
+      # @api private
+      attr_reader :raw
+
+      # Returns structured error messages
       #
-      # @see https://guides.hanamirb.org/validations/overview
+      # @return [Hash]
       #
-      # @example
-      #   class Signup < Hanami::Action
-      #     MEGABYTE = 1024 ** 2
-      #
-      #     params do
-      #       required(:first_name).filled(:str?)
-      #       required(:last_name).filled(:str?)
-      #       required(:email).filled?(:str?, format?: /\A.+@.+\z/)
-      #       required(:password).filled(:str?).confirmation
-      #       required(:terms_of_service).filled(:bool?)
-      #       required(:age).filled(:int?, included_in?: 18..99)
-      #       optional(:avatar).filled(size?: 1..(MEGABYTE * 3))
-      #     end
+      # @since 0.7.0
       #
-      #     def handle(req, *)
-      #       halt 400 unless req.params.valid?
-      #       # ...
-      #     end
-      #   end
-      def self.params(&blk)
-        validations(&blk || -> {})
-      end
+      # @example
+      #   params.errors
+      #     # => {
+      #            :email=>["is missing", "is in invalid format"],
+      #            :name=>["is missing"],
+      #            :tos=>["is missing"],
+      #            :age=>["is missing"],
+      #            :address=>["is missing"]
+      #          }
+      attr_reader :errors
 
       # Initialize the params and freeze them.
       #
@@ -156,40 +194,75 @@ module Hanami
       #
       # @since 0.1.0
       # @api private
-      def initialize(env)
+      def initialize(env:, contract: nil)
         @env = env
-        super(_extract_params)
-        validation = validate
+        @raw = _extract_params
+
+        # Fall back to the default contract here, rather than in the `._contract` method itself.
+        # This allows `._contract` to return nil when there is no user-defined contract, which is
+        # important for the backwards compatibility behavior in `Validatable::ClassMethods#params`.
+        contract ||= self.class._contract || DefaultContract
+        validation = contract.call(raw)
+
         @params = validation.to_h
-        @errors = Errors.new(validation.messages)
+        @errors = Errors.new(validation.errors.to_h)
+
         freeze
       end
 
-      # Returns raw params from Rack env
+      # Returns the value for the given params key.
       #
-      # @return [Hash]
+      # @param key [Symbol] the key
+      #
+      # @return [Object,nil] the associated value, if found
       #
-      # @since 0.3.2
-      def raw
-        @input
+      # @since 0.7.0
+      # @api public
+      def [](key)
+        @params[key]
       end
 
-      # Returns structured error messages
+      # Returns an value associated with the given params key.
       #
-      # @return [Hash]
+      # You can access nested attributes by listing all the keys in the path. This uses the same key
+      # path semantics as `Hash#dig`.
       #
-      # @since 0.7.0
+      # @param keys [Array<Symbol,Integer>] the key
+      #
+      # @return [Object,NilClass] return the associated value, if found
       #
       # @example
-      #   params.errors
-      #     # => {
-      #            :email=>["is missing", "is in invalid format"],
-      #            :name=>["is missing"],
-      #            :tos=>["is missing"],
-      #            :age=>["is missing"],
-      #            :address=>["is missing"]
-      #          }
-      attr_reader :errors
+      #   require "hanami/controller"
+      #
+      #   module Deliveries
+      #     class Create < Hanami::Action
+      #       def handle(req, *)
+      #         req.params.get(:customer_name)     # => "Luca"
+      #         req.params.get(:uknown)            # => nil
+      #
+      #         req.params.get(:address, :city)    # => "Rome"
+      #         req.params.get(:address, :unknown) # => nil
+      #
+      #         req.params.get(:tags, 0)           # => "foo"
+      #         req.params.get(:tags, 1)           # => "bar"
+      #         req.params.get(:tags, 999)         # => nil
+      #
+      #         req.params.get(nil)                # => nil
+      #       end
+      #     end
+      #   end
+      #
+      # @since 0.7.0
+      # @api public
+      def get(*keys)
+        @params.dig(*keys)
+      end
+
+      # This is for compatibility with Hanami::Helpers::FormHelper::Values
+      #
+      # @api private
+      # @since 0.8.0
+      alias_method :dig, :get
 
       # Returns flat collection of full error messages
       #
@@ -234,6 +307,21 @@ module Hanami
         errors.empty?
       end
 
+      # Iterates over the params.
+      #
+      # Calls the given block with each param key-value pair; returns the full hash of params.
+      #
+      # @yieldparam key [Symbol]
+      # @yieldparam value [Object]
+      #
+      # @return [to_h]
+      #
+      # @since 0.7.1
+      # @api public
+      def each(&blk)
+        to_h.each(&blk)
+      end
+
       # Serialize validated params to Hash
       #
       # @return [::Hash]
@@ -252,6 +340,36 @@ module Hanami
       def deconstruct_keys(*)
         to_hash
       end
+
+      private
+
+      # @since 0.7.0
+      # @api private
+      def _extract_params
+        result = {}
+
+        if env.key?(Action::RACK_INPUT)
+          result.merge! ::Rack::Request.new(env).params
+          result.merge! _router_params
+        else
+          result.merge! _router_params(env)
+          env[Action::REQUEST_METHOD] ||= Action::DEFAULT_REQUEST_METHOD
+        end
+
+        result
+      end
+
+      # @since 0.7.0
+      # @api private
+      def _router_params(fallback = {})
+        env.fetch(ROUTER_PARAMS) do
+          if session = fallback.delete(Action::RACK_SESSION)
+            fallback[Action::RACK_SESSION] = Utils::Hash.deep_symbolize(session)
+          end
+
+          fallback
+        end
+      end
     end
   end
 end

data/lib/hanami/action/request.rb

@@ -18,10 +18,7 @@ module Hanami
     class Request < ::Rack::Request
       # Returns the request's params.
       #
-      # For an action with {Validatable} included, this will be a {Params} instance, otherwise a
-      # {BaseParams}.
-      #
-      # @return [BaseParams,Params]
+      # @return [Params]
       #
       # @since 2.0.0
       # @api public

data/lib/hanami/action/validatable.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "params"
-
 module Hanami
   class Action
     # Support for validating params when calling actions.
@@ -28,34 +26,32 @@ module Hanami
       # @since 0.1.0
       # @api private
       module ClassMethods
-        # Whitelist valid parameters to be passed to Hanami::Action#call.
-        #
-        # This feature isn't mandatory, but higly recommended for security
-        # reasons.
+        # Defines a validation schema for the params passed to {Hanami::Action#call}.
         #
-        # Because params come into your application from untrusted sources, it's
-        # a good practice to filter only the wanted keys that serve for your
-        # specific use case.
+        # This feature isn't mandatory, but is highly recommended for secure handling of params:
+        # because params come from an untrusted source, it's good practice to filter these to only
+        # the keys and types required for your action's use case.
         #
-        # Once whitelisted, the params are available as an Hash with symbols
-        # as keys.
+        # The given block is evaluated inside a `params` schema of a `Dry::Validation::Contract`
+        # class. This constrains the validation to simple structure and type rules only. If you want
+        # to use all the features of dry-validation contracts, use {#contract} instead.
         #
-        # It accepts an anonymous block where all the params can be listed.
-        # It internally creates an inner class which inherits from
-        # Hanami::Action::Params.
+        # The resulting contract becomes part of a dedicated params class for the action, inheriting
+        # from {Hanami::Action::Params}.
         #
-        # Alternatively, it accepts an concrete class that should inherit from
-        # Hanami::Action::Params.
+        # Instead of defining the params validation schema inline, you can alternatively provide a
+        # concrete params class, which should inherit from {Hanami::Action::Params}.
         #
         # @param klass [Class,nil] a Hanami::Action::Params subclass
-        # @param blk [Proc] a block which defines the whitelisted params
+        # @param block [Proc] the params schema definition
         #
         # @return void
         #
+        # @see #contract
         # @see Hanami::Action::Params
-        # @see https://guides.hanamirb.org//validations/overview
+        # @see https://dry-rb.org/gems/dry-validation/
         #
-        # @example Anonymous Block
+        # @example Inline definition
         #   require "hanami/controller"
         #
         #   class Signup < Hanami::Action
@@ -78,9 +74,11 @@ module Hanami
         #   require "hanami/controller"
         #
         #   class SignupParams < Hanami::Action::Params
-        #     required(:first_name)
-        #     required(:last_name)
-        #     required(:email)
+        #     params do
+        #       required(:first_name)
+        #       required(:last_name)
+        #       required(:email)
+        #     end
         #   end
         #
         #   class Signup < Hanami::Action
@@ -95,15 +93,106 @@ module Hanami
         #     end
         #   end
         #
+        # @api public
         # @since 0.3.0
+        def params(klass = nil, &block)
+          contract_class =
+            if klass.nil?
+              Class.new(Dry::Validation::Contract) { params(&block) }
+            elsif klass < Params
+              # Handle subclasses of Hanami::Action::Params.
+              klass._contract.class
+            else
+              klass
+            end
+
+          config.contract_class = contract_class
+        end
+
+        # Defines a validation contract for the params passed to {Hanami::Action#call}.
+        #
+        # This feature isn't mandatory, but is highly recommended for secure handling of params:
+        # because params come from an untrusted source, it's good practice to filter these to only
+        # the keys and types required for your action's use case.
+        #
+        # The given block is evaluated inside a `Dry::Validation::Contract` class. This allows you
+        # to use all features of dry-validation contracts
+        #
+        # The resulting contract becomes part of a dedicated params class for the action, inheriting
+        # from {Hanami::Action::Params}.
+        #
+        # Instead of defining the params validation contract inline, you can alternatively provide a
+        # concrete params class, which should inherit from {Hanami::Action::Params}.
+        #
+        # @param klass [Class,nil] a Hanami::Action::Params subclass
+        # @param block [Proc] the params schema definition
+        #
+        # @return void
+        #
+        # @see #params
+        # @see Hanami::Action::Params
+        # @see https://dry-rb.org/gems/dry-validation/
+        #
+        # @example Inline definition
+        #   require "hanami/controller"
+        #
+        #   class Signup < Hanami::Action
+        #     contract do
+        #       params do
+        #         required(:first_name)
+        #         required(:last_name)
+        #         required(:email)
+        #       end
+        #
+        #       rule(:email) do
+        #         # custom rule logic here
+        #       end
+        #     end
+        #
+        #     def handle(req, *)
+        #       puts req.params.class            # => Signup::Params
+        #       puts req.params.class.superclass # => Hanami::Action::Params
+        #
+        #       puts req.params[:first_name]     # => "Luca"
+        #       puts req.params[:admin]          # => nil
+        #     end
+        #   end
+        #
+        # @example Concrete class
+        #   require "hanami/controller"
+        #
+        #   class SignupParams < Hanami::Action::Params
+        #     contract do
+        #       params do
+        #         required(:first_name)
+        #         required(:last_name)
+        #         required(:email)
+        #       end
+        #
+        #       rule(:email) do
+        #         # custom rule logic here
+        #       end
+        #     end
+        #   end
+        #
+        #   class Signup < Hanami::Action
+        #     params SignupParams
+        #
+        #     def handle(req, *)
+        #       puts req.params.class            # => SignupParams
+        #       puts req.params.class.superclass # => Hanami::Action::Params
+        #
+        #       req.params[:first_name]          # => "Luca"
+        #       req.params[:admin]               # => nil
+        #     end
+        #   end
+        #
         # @api public
-        def params(klass = nil, &blk)
-          if klass.nil?
-            klass = const_set(PARAMS_CLASS_NAME, Class.new(Params))
-            klass.class_eval { params(&blk) }
-          end
+        # @since 2.2.0
+        def contract(klass = nil, &block)
+          contract_class = klass || Class.new(Dry::Validation::Contract, &block)
 
-          @params_class = klass
+          config.contract_class = contract_class
         end
       end
     end

data/lib/hanami/action.rb

@@ -39,7 +39,7 @@ module Hanami
         loader.ignore(
           "#{root}/hanami-controller.rb",
           "#{root}/hanami/controller/version.rb",
-          "#{root}/hanami/action/{constants,errors,params,validatable}.rb"
+          "#{root}/hanami/action/{constants,errors,validatable}.rb"
         )
         loader.inflector.inflect("csrf_protection" => "CSRFProtection")
       end
@@ -72,6 +72,7 @@ module Hanami
     setting :public_directory, default: Config::DEFAULT_PUBLIC_DIRECTORY
     setting :before_callbacks, default: Utils::Callbacks::Chain.new, mutable: true
     setting :after_callbacks, default: Utils::Callbacks::Chain.new, mutable: true
+    setting :contract_class
 
     # @!scope class
 
@@ -105,37 +106,30 @@ module Hanami
           include Validatable if defined?(Validatable)
         end
       end
-
-      if instance_variable_defined?(:@params_class)
-        subclass.instance_variable_set(:@params_class, @params_class)
-      end
     end
 
-    # Returns the class which defines the params
-    #
-    # Returns the class which has been provided to define the
-    # params. By default this will be Hanami::Action::Params.
+    # Placeholder for the `.params` method. Raises an error when the hanami-validations gem is not
+    # installed.
     #
-    # @return [Class] A params class (when whitelisted) or
-    #   Hanami::Action::Params
+    # @raise [NoMethodError]
     #
-    # @api private
-    # @since 0.7.0
-    def self.params_class
-      @params_class || BaseParams
+    # @api public
+    # @since 2.0.0
+    def self.params(_klass = nil)
+      message = %(To use `.params`, please add the "hanami-validations" gem to your Gemfile)
+      raise NoMethodError, message
     end
 
-    # Placeholder implementation for params class method
-    #
-    # Raises a developer friendly error to include `hanami/validations`.
+    # Placeholder for the `.contract` method. Raises an error when the hanami-validations gem is not
+    # installed.
     #
     # @raise [NoMethodError]
     #
     # @api public
-    # @since 2.0.0
-    def self.params(_klass = nil)
-      raise NoMethodError,
-            "To use `params`, please add 'hanami/validations' gem to your Gemfile"
+    # @since 2.2.0
+    def self.contract
+      message = %(To use `.contract`, please add the "hanami-validations" gem to your Gemfile)
+      raise NoMethodError, message
     end
 
     # @overload self.append_before(*callbacks, &block)
@@ -287,12 +281,21 @@ module Hanami
       config.handle_exception(...)
     end
 
+    # @since 2.0.0
+    # @api private
+    private attr_reader :config
+
+    # @since 2.2.0
+    # @api private
+    private attr_reader :contract
+
     # Returns a new action
     #
     # @since 2.0.0
     # @api public
-    def initialize(config: self.class.config)
+    def initialize(config: self.class.config, contract: nil)
       @config = config
+      @contract = contract || config.contract_class&.new # TODO: tests showing this overridden by a dep
       freeze
     end
 
@@ -305,7 +308,7 @@ module Hanami
       response = nil
 
       halted = catch :halt do
-        params   = self.class.params_class.new(env)
+        params = Params.new(env: env, contract: contract)
         request  = build_request(
           env: env,
           params: params,
@@ -401,10 +404,6 @@ module Hanami
 
     private
 
-    # @since 2.0.0
-    # @api private
-    attr_reader :config
-
     # @since 2.0.0
     # @api private
     def enforce_accepted_mime_types(request)

data/lib/hanami/controller/version.rb

@@ -8,6 +8,6 @@ module Hanami
     #
     # @since 0.1.0
     # @api public
-    VERSION = "2.2.0.beta1"
+    VERSION = "2.2.0.rc1"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hanami-controller
 version: !ruby/object:Gem::Version
-  version: 2.2.0.beta1
+  version: 2.2.0.rc1
 platform: ruby
 authors:
 - Luca Guidi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-16 00:00:00.000000000 Z
+date: 2024-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.2.beta
+        version: 2.2.rc
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.2.beta
+        version: 2.2.rc
 - !ruby/object:Gem::Dependency
   name: dry-configurable
   requirement: !ruby/object:Gem::Requirement
@@ -175,7 +175,6 @@ files:
 - hanami-controller.gemspec
 - lib/hanami-controller.rb
 - lib/hanami/action.rb
-- lib/hanami/action/base_params.rb
 - lib/hanami/action/cache.rb
 - lib/hanami/action/cache/cache_control.rb
 - lib/hanami/action/cache/conditional_get.rb
@@ -222,7 +221,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: Complete, fast and testable actions for Rack and Hanami

data/lib/hanami/action/base_params.rb

@@ -1,170 +0,0 @@
-# frozen_string_literal: true
-
-require "rack/request"
-require "hanami/utils/hash"
-
-module Hanami
-  class Action
-    # Provides access to params included in a Rack request.
-    #
-    # Offers useful access to params via methods like {#[]}, {#get} and {#to_h}.
-    #
-    # These params are available via {Request#params}.
-    #
-    # This class is used by default when {Hanami::Action::Validatable} is not included, or when no
-    # {Validatable::ClassMethods#params params} validation schema is defined.
-    #
-    # @see Hanami::Action::Request#params
-    #
-    # @api private
-    # @since 0.7.0
-    class BaseParams
-      # @attr_reader env [Hash] the Rack env
-      #
-      # @since 0.7.0
-      # @api private
-      attr_reader :env
-
-      # @attr_reader raw [Hash] the raw params from the request
-      #
-      # @since 0.7.0
-      # @api private
-      attr_reader :raw
-
-      # Returns a new frozen params object for the Rack env.
-      #
-      # @param env [Hash] a Rack env or an hash of params.
-      #
-      # @since 0.7.0
-      # @api private
-      def initialize(env)
-        @env    = env
-        @raw    = _extract_params
-        @params = Utils::Hash.deep_symbolize(@raw)
-        freeze
-      end
-
-      # Returns the value for the given params key.
-      #
-      # @param key [Symbol] the key
-      #
-      # @return [Object,nil] the associated value, if found
-      #
-      # @since 0.7.0
-      # @api public
-      def [](key)
-        @params[key]
-      end
-
-      # Returns an value associated with the given params key.
-      #
-      # You can access nested attributes by listing all the keys in the path. This uses the same key
-      # path semantics as `Hash#dig`.
-      #
-      # @param keys [Array<Symbol,Integer>] the key
-      #
-      # @return [Object,NilClass] return the associated value, if found
-      #
-      # @example
-      #   require "hanami/controller"
-      #
-      #   module Deliveries
-      #     class Create < Hanami::Action
-      #       def handle(req, *)
-      #         req.params.get(:customer_name)     # => "Luca"
-      #         req.params.get(:uknown)            # => nil
-      #
-      #         req.params.get(:address, :city)    # => "Rome"
-      #         req.params.get(:address, :unknown) # => nil
-      #
-      #         req.params.get(:tags, 0)           # => "foo"
-      #         req.params.get(:tags, 1)           # => "bar"
-      #         req.params.get(:tags, 999)         # => nil
-      #
-      #         req.params.get(nil)                # => nil
-      #       end
-      #     end
-      #   end
-      #
-      # @since 0.7.0
-      # @api public
-      def get(*keys)
-        @params.dig(*keys)
-      end
-
-      # This is for compatibility with Hanami::Helpers::FormHelper::Values
-      #
-      # @api private
-      # @since 0.8.0
-      alias_method :dig, :get
-
-      # Returns true at all times, providing a common interface with {Params}.
-      #
-      # @return [TrueClass] always returns true
-      #
-      # @see Hanami::Action::Params#valid?
-      #
-      # @api public
-      # @since 0.7.0
-      def valid?
-        true
-      end
-
-      # Returns a hash of the parsed request params.
-      #
-      # @return [Hash]
-      #
-      # @since 0.7.0
-      # @api public
-      def to_h
-        @params
-      end
-      alias_method :to_hash, :to_h
-
-      # Iterates over the params.
-      #
-      # Calls the given block with each param key-value pair; returns the full hash of params.
-      #
-      # @yieldparam key [Symbol]
-      # @yieldparam value [Object]
-      #
-      # @return [to_h]
-      #
-      # @since 0.7.1
-      # @api public
-      def each(&blk)
-        to_h.each(&blk)
-      end
-
-      private
-
-      # @since 0.7.0
-      # @api private
-      def _extract_params
-        result = {}
-
-        if env.key?(Action::RACK_INPUT)
-          result.merge! ::Rack::Request.new(env).params
-          result.merge! _router_params
-        else
-          result.merge! _router_params(env)
-          env[Action::REQUEST_METHOD] ||= Action::DEFAULT_REQUEST_METHOD
-        end
-
-        result
-      end
-
-      # @since 0.7.0
-      # @api private
-      def _router_params(fallback = {})
-        env.fetch(ROUTER_PARAMS) do
-          if session = fallback.delete(Action::RACK_SESSION)
-            fallback[Action::RACK_SESSION] = Utils::Hash.deep_symbolize(session)
-          end
-
-          fallback
-        end
-      end
-    end
-  end
-end