OpenAPI3 parameters and request bodies are actually OpenAPI3 compliant

Author: blake

lib/grape-swagger/openapi_3/doc_methods/parse_params.rb

@@ -52,13 +52,14 @@ def document_default_value(settings)
         end
 
         def document_type_and_format(settings, data_type)
+          @parsed_param[:schema] = {}
           if DataType.primitive?(data_type)
             data = DataType.mapping(data_type)
-            @parsed_param[:type], @parsed_param[:format] = data
+            @parsed_param[:schema][:type], @parsed_param[:schema][:format] = data
           else
-            @parsed_param[:type] = data_type
+            @parsed_param[:schema][:type] = data_type
           end
-          @parsed_param[:format] = settings[:format] if settings[:format].present?
+          @parsed_param[:schema][:format] = settings[:format] if settings[:format].present?
         end
 
         def document_array_param(value_type, definitions)

lib/grape-swagger/openapi_3/endpoint.rb

@@ -117,13 +117,15 @@ def method_object(route, options, path)
       method = {}
       method[:summary]     = summary_object(route)
       method[:description] = description_object(route)
-      method[:parameters]  = params_object(route, options, path)
+
+      parameters = params_object(route, options, path).partition { |p| p[:in] == 'body' || p[:in] == 'formData' }
+
+      method[:parameters]  = parameters.last
       method[:security]    = security_object(route)
       if %w[POST PUT PATCH].include?(route.request_method)
-        method[:requestBody] = response_body_object(route, options, path)
+        method[:requestBody] = response_body_object(route, path, parameters.first)
       end
 
-      # method[:consumes]    = consumes_object(route, options[:format])
       produces = produces_object(route, options[:produces] || options[:format])
 
       method[:responses]   = response_object(route, produces)
@@ -200,28 +202,17 @@ def params_object(route, options, path)
       parameters
     end
 
-    def response_body_object(route, options, path)
-      parameters = partition_params(route, options).map do |param, value|
-        value = { required: false }.merge(value) if value.is_a?(Hash)
-        _, value = default_type([[param, value]]).first if value == ''
-        if value[:type]
-          expose_params(value[:type])
-        elsif value[:documentation]
-          expose_params(value[:documentation][:type])
-        end
-
-        GrapeSwagger::DocMethods::ParseRequestBody.call(param, value, path, route, @definitions)
-      end.flatten
-
+    def response_body_object(_, _, parameters)
       parameters = {
         'content' => parameters.group_by { |p| p[:in] }.map do |_k, v|
+          properties = v.map { |value| [value[:name], value.except(:name, :in, :required, :schema).merge(value[:schema])] }.to_h
           required_values = v.select { |param| param[:required] }
           [
             'application/x-www-form-urlencoded',
             { 'schema' => {
               'type' => 'object',
               'required' => required_values.map { |required| required[:name] },
-              'properties' => v.map { |value| [value[:name], value.except(:name, :in, :required)] }.to_h
+              'properties' => properties
             } }
           ]
         end.to_h

spec/openapi_3/param_multi_type_spec.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'Params Multi Types' do
+  def app
+    Class.new(Grape::API) do
+      format :json
+
+      params do
+        if Grape::VERSION < '0.14'
+          requires :input, type: [String, Integer]
+        else
+          requires :input, types: [String, Integer]
+        end
+        requires :another_input, type: [String, Integer]
+      end
+      post :action do
+      end
+
+      add_swagger_documentation openapi_version: '3.0'
+    end
+  end
+
+  subject do
+    get '/swagger_doc/action'
+    expect(last_response.status).to eq 200
+    body = JSON.parse last_response.body
+    body['paths']['/action']['post']
+  end
+
+  it 'reads request body type correctly' do
+    expect(subject['requestBody']['content']).to eq('application/x-www-form-urlencoded' => {
+      'schema' => {
+        'properties' => { 'another_input' => { 'type' => 'string' }, 'input' => { 'type' => 'string' } },
+        'required' => %w[input another_input],
+        'type' => 'object'
+      }
+    })
+  end
+
+  describe 'header params' do
+    def app
+      Class.new(Grape::API) do
+        format :json
+
+        desc 'Some API', headers: { 'My-Header' => { required: true, description: 'Set this!' } }
+        params do
+          if Grape::VERSION < '0.14'
+            requires :input, type: [String, Integer]
+          else
+            requires :input, types: [String, Integer]
+          end
+          requires :another_input, type: [String, Integer]
+        end
+        post :action do
+        end
+
+        add_swagger_documentation openapi_version: '3.0'
+      end
+    end
+
+    it 'reads parameter type correctly' do
+      expect(subject['parameters']).to eq([{
+        'description' => 'Set this!',
+        'in' => 'header',
+        'name' => 'My-Header',
+        'required' => true,
+        'schema' => { 'type' => 'string' }
+      }])
+    end
+
+    it 'has consistent types' do
+      request_body_types = subject['requestBody']['content']['application/x-www-form-urlencoded']['schema']['properties'].values.map { |param| param['type'] }
+      expect(request_body_types).to eq(%w[string string])
+
+      request_body_types = subject['parameters'].map { |param| param['schema']['type'] }
+      expect(request_body_types).to eq(%w[string])
+    end
+  end
+end