grape 0.1.1 → 2.4.0

data/lib/grape/middleware/formatter.rb

@@ -1,106 +1,148 @@
-require 'grape/middleware/base'
-require 'multi_json'
+# frozen_string_literal: true
 
 module Grape
   module Middleware
     class Formatter < Base
-      CONTENT_TYPES = {
-        :xml => 'application/xml',
-        :json => 'application/json',
-        :atom => 'application/atom+xml',
-        :rss => 'application/rss+xml',
-        :txt => 'text/plain'
-      }
-      
-      def default_options
-        { 
-          :default_format => :txt,
-          :content_types => {}
-        }
-      end
-      
-      def content_types
-        CONTENT_TYPES.merge(options[:content_types])
-      end
-      
-      def mime_types
-        content_types.invert
-      end
-      
-      def headers
-        env.dup.inject({}){|h,(k,v)| h[k.downcase] = v; h}
-      end
-      
+      DEFAULT_OPTIONS = {
+        default_format: :txt
+      }.freeze
+
       def before
-        fmt = format_from_extension || format_from_header || options[:default_format]
-                
-        if content_types.key?(fmt)
-          env['api.format'] = fmt          
-        else
-          throw :error, :status => 406, :message => 'The requested format is not supported.'
-        end
+        negotiate_content_type
+        read_body_input
       end
-      
-      def format_from_extension
-        parts = request.path.split('.')
-        hit = parts.last.to_sym
-        
-        if parts.size <= 1
-          nil
+
+      def after
+        return unless @app_response
+
+        status, headers, bodies = *@app_response
+
+        if Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include?(status)
+          [status, headers, []]
         else
-          hit
+          build_formatted_response(status, headers, bodies)
         end
       end
-      
-      def format_from_header
-        mime_array.each do |t| 
-          if mime_types.key?(t)
-            return mime_types[t]
+
+      private
+
+      def build_formatted_response(status, headers, bodies)
+        headers = ensure_content_type(headers)
+
+        if bodies.is_a?(Grape::ServeStream::StreamResponse)
+          Grape::ServeStream::SendfileResponse.new([], status, headers) do |resp|
+            resp.body = bodies.stream
+          end
+        else
+          # Allow content-type to be explicitly overwritten
+          formatter = fetch_formatter(headers, options)
+          bodymap = ActiveSupport::Notifications.instrument('format_response.grape', formatter: formatter, env: env) do
+            bodies.collect { |body| formatter.call(body, env) }
           end
+          Rack::Response.new(bodymap, status, headers)
         end
-        nil
+      rescue Grape::Exceptions::InvalidFormatter => e
+        throw :error, status: 500, message: e.message, backtrace: e.backtrace, original_exception: e
+      end
+
+      def fetch_formatter(headers, options)
+        api_format = env.fetch(Grape::Env::API_FORMAT) { mime_types[headers[Rack::CONTENT_TYPE]] }
+        Grape::Formatter.formatter_for(api_format, options[:formatters])
       end
-      
-      def mime_array
-        accept = headers['accept']
-        if accept
-          accept.gsub(/\b/,'').
-            scan(/(\w+\/[\w+]+)(?:;[^,]*q=([0-9.]+)[^,]*)?/i).
-            sort_by{|a| -a[1].to_f}.
-            map{|a| a[0]}
+
+      # Set the content type header for the API format if it is not already present.
+      #
+      # @param headers [Hash]
+      # @return [Hash]
+      def ensure_content_type(headers)
+        if headers[Rack::CONTENT_TYPE]
+          headers
         else
-          []
+          headers.merge(Rack::CONTENT_TYPE => content_type_for(env[Grape::Env::API_FORMAT]))
         end
       end
-      
-      def after
-        status, headers, bodies = *@app_response
-        bodymap = []
-        bodies.each do |body|
-          bodymap << case env['api.format']
-            when :json
-              encode_json(body)
-            when :txt
-              encode_txt(body)
+
+      def read_body_input
+        input = rack_request.body # reads RACK_INPUT
+        return if input.nil?
+        return unless read_body_input?
+
+        input.try(:rewind)
+        body = env[Grape::Env::API_REQUEST_INPUT] = input.read
+        begin
+          read_rack_input(body)
+        ensure
+          input.try(:rewind)
+        end
+      end
+
+      def read_rack_input(body)
+        return if body.empty?
+
+        media_type = rack_request.media_type
+        fmt = media_type ? mime_types[media_type] : options[:default_format]
+
+        throw :error, status: 415, message: "The provided content-type '#{media_type}' is not supported." unless content_type_for(fmt)
+        parser = Grape::Parser.parser_for fmt, options[:parsers]
+        if parser
+          begin
+            body = (env[Grape::Env::API_REQUEST_BODY] = parser.call(body, env))
+            if body.is_a?(Hash)
+              env[Rack::RACK_REQUEST_FORM_HASH] = if env.key?(Rack::RACK_REQUEST_FORM_HASH)
+                                                    env[Rack::RACK_REQUEST_FORM_HASH].merge(body)
+                                                  else
+                                                    body
+                                                  end
+              env[Rack::RACK_REQUEST_FORM_INPUT] = env[Rack::RACK_INPUT]
+            end
+          rescue Grape::Exceptions::Base => e
+            raise e
+          rescue StandardError => e
+            throw :error, status: 400, message: e.message, backtrace: e.backtrace, original_exception: e
           end
+        else
+          env[Grape::Env::API_REQUEST_BODY] = body
         end
-        headers['Content-Type'] = 'application/json'
-        Rack::Response.new(bodymap, status, headers).to_a
       end
-      
-      def encode_json(object)
-        if object.respond_to? :serializable_hash
-          MultiJson.encode(object.serializable_hash)
-        elsif object.respond_to? :to_json
-          object.to_json
+
+      # this middleware will not try to format the following content-types since Rack already handles them
+      # when calling Rack's `params` function
+      # - application/x-www-form-urlencoded
+      # - multipart/form-data
+      # - multipart/related
+      # - multipart/mixed
+      def read_body_input?
+        (rack_request.post? || rack_request.put? || rack_request.patch? || rack_request.delete?) &&
+          !(rack_request.form_data? && rack_request.content_type) &&
+          !rack_request.parseable_data? &&
+          (rack_request.content_length.to_i.positive? || rack_request.env['HTTP_TRANSFER_ENCODING'] == 'chunked')
+      end
+
+      def negotiate_content_type
+        fmt = format_from_extension || query_params['format'] || options[:format] || format_from_header || options[:default_format]
+        if content_type_for(fmt)
+          env[Grape::Env::API_FORMAT] = fmt.to_sym
         else
-          MultiJson.encode(object)
+          throw :error, status: 406, message: "The requested format '#{fmt}' is not supported."
         end
       end
-      
-      def encode_txt(object)
-        object.respond_to?(:to_txt) ? object.to_txt : object.to_s
+
+      def format_from_extension
+        request_path = rack_request.path.try(:scrub)
+        dot_pos = request_path.rindex('.')
+        return unless dot_pos
+
+        extension = request_path[dot_pos + 1..]
+        extension if content_type_for(extension)
+      end
+
+      def format_from_header
+        accept_header = env['HTTP_ACCEPT'].try(:scrub)
+        return if accept_header.blank?
+
+        media_type = Rack::Utils.best_q_match(accept_header, mime_types.keys)
+        mime_types[media_type] if media_type
       end
     end
   end
-end
+end

data/lib/grape/middleware/globals.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Grape
+  module Middleware
+    class Globals < Base
+      def before
+        request = Grape::Request.new(@env, build_params_with: @options[:build_params_with])
+        @env[Grape::Env::GRAPE_REQUEST] = request
+        @env[Grape::Env::GRAPE_REQUEST_HEADERS] = request.headers
+        @env[Grape::Env::GRAPE_REQUEST_PARAMS] = request.params if @env[Rack::RACK_INPUT]
+      end
+    end
+  end
+end

data/lib/grape/middleware/stack.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Grape
+  module Middleware
+    # Class to handle the stack of middlewares based on ActionDispatch::MiddlewareStack
+    # It allows to insert and insert after
+    class Stack
+      extend Forwardable
+      class Middleware
+        attr_reader :args, :block, :klass
+
+        def initialize(klass, args, block)
+          @klass = klass
+          @args = args
+          @block = block
+        end
+
+        def name
+          klass.name
+        end
+
+        def ==(other)
+          case other
+          when Middleware
+            klass == other.klass
+          when Class
+            klass == other || (name.nil? && klass.superclass == other)
+          end
+        end
+
+        def inspect
+          klass.to_s
+        end
+
+        def build(builder)
+          # we need to force the ruby2_keywords_hash for middlewares that initialize contains keywords
+          # like ActionDispatch::RequestId since middleware arguments are serialized
+          # https://rubyapi.org/3.4/o/hash#method-c-ruby2_keywords_hash
+          args[-1] = Hash.ruby2_keywords_hash(args[-1]) if args.last.is_a?(Hash) && Hash.respond_to?(:ruby2_keywords_hash)
+          builder.use(klass, *args, &block)
+        end
+      end
+
+      include Enumerable
+
+      attr_accessor :middlewares, :others
+
+      def_delegators :middlewares, :each, :size, :last, :[]
+
+      def initialize
+        @middlewares = []
+        @others = []
+      end
+
+      def insert(index, klass, *args, &block)
+        index = assert_index(index, :before)
+        middlewares.insert(index, self.class::Middleware.new(klass, args, block))
+      end
+
+      alias insert_before insert
+
+      def insert_after(index, *args, &block)
+        index = assert_index(index, :after)
+        insert(index + 1, *args, &block)
+      end
+
+      def use(klass, *args, &block)
+        middleware = self.class::Middleware.new(klass, args, block)
+        middlewares.push(middleware)
+      end
+
+      def merge_with(middleware_specs)
+        middleware_specs.each do |operation, klass, *args|
+          if args.last.is_a?(Proc)
+            last_proc = args.pop
+            public_send(operation, klass, *args, &last_proc)
+          else
+            public_send(operation, klass, *args)
+          end
+        end
+      end
+
+      # @return [Rack::Builder] the builder object with our middlewares applied
+      def build
+        Rack::Builder.new.tap do |builder|
+          others.shift(others.size).each { |m| merge_with(m) }
+          middlewares.each do |m|
+            m.build(builder)
+          end
+        end
+      end
+
+      # @description Add middlewares with :use operation to the stack. Store others with :insert_* operation for later
+      # @param [Array] other_specs An array of middleware specifications (e.g. [[:use, klass], [:insert_before, *args]])
+      def concat(other_specs)
+        use, not_use = other_specs.partition { |o| o.first == :use }
+        others << not_use
+        merge_with(use)
+      end
+
+      protected
+
+      def assert_index(index, where)
+        i = index.is_a?(Integer) ? index : middlewares.index(index)
+        i || raise("No such middleware to insert #{where}: #{index.inspect}")
+      end
+    end
+  end
+end

data/lib/grape/middleware/versioner/accept_version_header.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Grape
+  module Middleware
+    module Versioner
+      # This middleware sets various version related rack environment variables
+      # based on the HTTP Accept-Version header
+      #
+      # Example: For request header
+      #    Accept-Version: v1
+      #
+      # The following rack env variables are set:
+      #
+      #    env['api.version']  => 'v1'
+      #
+      # If version does not match this route, then a 406 is raised with
+      # X-Cascade header to alert Grape::Router to attempt the next matched
+      # route.
+      class AcceptVersionHeader < Base
+        def before
+          potential_version = env['HTTP_ACCEPT_VERSION'].try(:scrub)
+          not_acceptable!('Accept-Version header must be set.') if strict? && potential_version.blank?
+
+          return if potential_version.blank?
+
+          not_acceptable!('The requested version is not supported.') unless potential_version_match?(potential_version)
+          env[Grape::Env::API_VERSION] = potential_version
+        end
+
+        private
+
+        def not_acceptable!(message)
+          throw :error, status: 406, headers: error_headers, message: message
+        end
+      end
+    end
+  end
+end

data/lib/grape/middleware/versioner/base.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Grape
+  module Middleware
+    module Versioner
+      class Base < Grape::Middleware::Base
+        DEFAULT_OPTIONS = {
+          pattern: /.*/i.freeze,
+          version_options: {
+            strict: false,
+            cascade: true,
+            parameter: 'apiver'
+          }.freeze
+        }.freeze
+
+        def self.inherited(klass)
+          super
+          Versioner.register(klass)
+        end
+
+        def versions
+          options[:versions]
+        end
+
+        def prefix
+          options[:prefix]
+        end
+
+        def mount_path
+          options[:mount_path]
+        end
+
+        def pattern
+          options[:pattern]
+        end
+
+        def version_options
+          options[:version_options]
+        end
+
+        def strict?
+          version_options[:strict]
+        end
+
+        # By default those errors contain an `X-Cascade` header set to `pass`, which allows nesting and stacking
+        # of routes (see Grape::Router) for more information). To prevent
+        # this behavior, and not add the `X-Cascade` header, one can set the `:cascade` option to `false`.
+        def cascade?
+          version_options[:cascade]
+        end
+
+        def parameter_key
+          version_options[:parameter]
+        end
+
+        def vendor
+          version_options[:vendor]
+        end
+
+        def error_headers
+          cascade? ? { 'X-Cascade' => 'pass' } : {}
+        end
+
+        def potential_version_match?(potential_version)
+          versions.blank? || versions.any? { |v| v.to_s == potential_version }
+        end
+
+        def version_not_found!
+          throw :error, status: 404, message: '404 API Version Not Found', headers: { 'X-Cascade' => 'pass' }
+        end
+      end
+    end
+  end
+end

data/lib/grape/middleware/versioner/header.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Grape
+  module Middleware
+    module Versioner
+      # This middleware sets various version related rack environment variables
+      # based on the HTTP Accept header with the pattern:
+      # application/vnd.:vendor-:version+:format
+      #
+      # Example: For request header
+      #    Accept: application/vnd.mycompany.a-cool-resource-v1+json
+      #
+      # The following rack env variables are set:
+      #
+      #    env['api.type']    => 'application'
+      #    env['api.subtype'] => 'vnd.mycompany.a-cool-resource-v1+json'
+      #    env['api.vendor]   => 'mycompany.a-cool-resource'
+      #    env['api.version]  => 'v1'
+      #    env['api.format]   => 'json'
+      #
+      # If version does not match this route, then a 406 is raised with
+      # X-Cascade header to alert Grape::Router to attempt the next matched
+      # route.
+      class Header < Base
+        def before
+          match_best_quality_media_type! do |media_type|
+            env.update(
+              Grape::Env::API_TYPE => media_type.type,
+              Grape::Env::API_SUBTYPE => media_type.subtype,
+              Grape::Env::API_VENDOR => media_type.vendor,
+              Grape::Env::API_VERSION => media_type.version,
+              Grape::Env::API_FORMAT => media_type.format
+            )
+          end
+        end
+
+        private
+
+        def match_best_quality_media_type!
+          return unless vendor
+
+          strict_header_checks!
+          media_type = Grape::Util::MediaType.best_quality(accept_header, available_media_types)
+          if media_type
+            yield media_type
+          else
+            fail!
+          end
+        end
+
+        def accept_header
+          env['HTTP_ACCEPT']
+        end
+
+        def strict_header_checks!
+          return unless strict?
+
+          accept_header_check!
+          version_and_vendor_check!
+        end
+
+        def accept_header_check!
+          return if accept_header.present?
+
+          invalid_accept_header!('Accept header must be set.')
+        end
+
+        def version_and_vendor_check!
+          return if versions.blank? || version_and_vendor?
+
+          invalid_accept_header!('API vendor or version not found.')
+        end
+
+        def q_values_mime_types
+          @q_values_mime_types ||= Rack::Utils.q_values(accept_header).map(&:first)
+        end
+
+        def version_and_vendor?
+          q_values_mime_types.any? { |mime_type| Grape::Util::MediaType.match?(mime_type) }
+        end
+
+        def invalid_accept_header!(message)
+          raise Grape::Exceptions::InvalidAcceptHeader.new(message, error_headers)
+        end
+
+        def invalid_version_header!(message)
+          raise Grape::Exceptions::InvalidVersionHeader.new(message, error_headers)
+        end
+
+        def fail!
+          return if env[Grape::Env::GRAPE_ALLOWED_METHODS].present?
+
+          media_types = q_values_mime_types.map { |mime_type| Grape::Util::MediaType.parse(mime_type) }
+          vendor_not_found!(media_types) || version_not_found!(media_types)
+        end
+
+        def vendor_not_found!(media_types)
+          return unless media_types.all? { |media_type| media_type&.vendor && media_type.vendor != vendor }
+
+          invalid_accept_header!('API vendor not found.')
+        end
+
+        def version_not_found!(media_types)
+          return unless media_types.all? { |media_type| media_type&.version && versions&.exclude?(media_type.version) }
+
+          invalid_version_header!('API version not found.')
+        end
+
+        def available_media_types
+          [].tap do |available_media_types|
+            base_media_type = "application/vnd.#{vendor}"
+            content_types.each_key do |extension|
+              versions&.reverse_each do |version|
+                available_media_types << "#{base_media_type}-#{version}+#{extension}"
+                available_media_types << "#{base_media_type}-#{version}"
+              end
+              available_media_types << "#{base_media_type}+#{extension}"
+            end
+
+            available_media_types << base_media_type
+            available_media_types.concat(content_types.values.flatten)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape/middleware/versioner/param.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Grape
+  module Middleware
+    module Versioner
+      # This middleware sets various version related rack environment variables
+      # based on the request parameters and removes that parameter from the
+      # request parameters for subsequent middleware and API.
+      # If the version substring does not match any potential initialized
+      # versions, a 404 error is thrown.
+      # If the version substring is not passed the version (highest mounted)
+      # version will be used.
+      #
+      # Example: For a uri path
+      #   /resource?apiver=v1
+      #
+      # The following rack env variables are set and path is rewritten to
+      # '/resource':
+      #
+      #   env['api.version'] => 'v1'
+      class Param < Base
+        def before
+          potential_version = query_params[parameter_key]
+          return if potential_version.blank?
+
+          version_not_found! unless potential_version_match?(potential_version)
+          env[Grape::Env::API_VERSION] = env[Rack::RACK_REQUEST_QUERY_HASH].delete(parameter_key)
+        end
+      end
+    end
+  end
+end

data/lib/grape/middleware/versioner/path.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Grape
+  module Middleware
+    module Versioner
+      # This middleware sets various version related rack environment variables
+      # based on the uri path and removes the version substring from the uri
+      # path. If the version substring does not match any potential initialized
+      # versions, a 404 error is thrown.
+      #
+      # Example: For a uri path
+      #   /v1/resource
+      #
+      # The following rack env variables are set and path is rewritten to
+      # '/resource':
+      #
+      #   env['api.version'] => 'v1'
+      #
+      class Path < Base
+        def before
+          path_info = Grape::Router.normalize_path(env[Rack::PATH_INFO])
+          return if path_info == '/'
+
+          [mount_path, Grape::Router.normalize_path(prefix)].each do |path|
+            path_info.delete_prefix!(path) if path.present? && path != '/' && path_info.start_with?(path)
+          end
+
+          slash_position = path_info.index('/', 1) # omit the first one
+          return unless slash_position
+
+          potential_version = path_info[1..slash_position - 1]
+          return unless potential_version.match?(pattern)
+
+          version_not_found! unless potential_version_match?(potential_version)
+          env[Grape::Env::API_VERSION] = potential_version
+        end
+      end
+    end
+  end
+end