Merge branch 'master' into master

Author: fenollp

README.md

@@ -21,7 +21,7 @@ Here's some projects that depend on _kin-openapi_:
   * [github.com/a-h/rest](https://github.com/a-h/rest) - "Generate OpenAPI 3.0 specifications from Go code without annotations or magic comments"
   * [github.com/Tufin/oasdiff](https://github.com/Tufin/oasdiff) - "A diff tool for OpenAPI Specification 3"
   * [github.com/danielgtaylor/apisprout](https://github.com/danielgtaylor/apisprout) - "Lightweight, blazing fast, cross-platform OpenAPI 3 mock server with validation"
-  * [github.com/deepmap/oapi-codegen](https://github.com/deepmap/oapi-codegen) - "Generate Go client and server boilerplate from OpenAPI 3 specifications"
+  * [github.com/oapi-codegen/oapi-codegen](https://github.com/oapi-codegen/oapi-codegen) - "Generate Go client and server boilerplate from OpenAPI 3 specifications"
   * [github.com/dunglas/vulcain](https://github.com/dunglas/vulcain) - "Use HTTP/2 Server Push to create fast and idiomatic client-driven REST APIs"
   * [github.com/danielgtaylor/restish](https://github.com/danielgtaylor/restish) - "...a CLI for interacting with REST-ish HTTP APIs with some nice features built-in"
   * [github.com/goadesign/goa](https://github.com/goadesign/goa) - "Design-based APIs and microservices in Go"

openapi2conv/openapi2_conv.go

@@ -568,6 +568,14 @@ func convertRefsInV3SchemaRef(from *openapi3.SchemaRef) *openapi3.SchemaRef {
 			to.Value.Items.Ref = ToV3Ref(to.Value.Items.Ref)
 		}
 		to.Value.AdditionalProperties = toV3AdditionalProperties(to.Value.AdditionalProperties)
+
+		if len(to.Value.AllOf) > 0 {
+			allOf := make(openapi3.SchemaRefs, len(to.Value.AllOf))
+			for i, schemaRef := range to.Value.AllOf {
+				allOf[i] = convertRefsInV3SchemaRef(schemaRef)
+			}
+			to.Value.AllOf = allOf
+		}
 	}
 	return &to
 }

openapi2conv/openapi2_conv_test.go

@@ -193,6 +193,87 @@ func TestConvOpenAPIV2ToV3WithNestedAdditionalPropertiesSchemaRef(t *testing.T)
 	require.Equal(t, "#/components/schemas/Foo", responseSchema.AdditionalProperties.Schema.Value.AdditionalProperties.Schema.Ref)
 }
 
+func TestConvOpenAPIV2ToV3WithAllOfInsideAdditionalProperties(t *testing.T) {
+	v2 := []byte(`
+{
+	"basePath": "/v2",
+    "host": "test.example.com",
+    "info": {
+        "title": "MyAPI",
+        "version": "0.1"
+    },
+    "paths": {
+        "/v1/objStatus": {
+            "get": {
+				"produces": [
+                    "application/json"
+                ],
+                "responses": {
+                    "200": {
+                        "schema": {
+							"type": "object",
+							"properties": {
+								"result": {
+									"type": "object",
+									"additionalProperties": {
+										"type": "object",
+										"allOf": [
+											{
+												"$ref": "#/definitions/ObjectInfo"
+											}
+										],
+										"additionalProperties": {
+											"allOf": [
+												{
+													"$ref": "#/definitions/ObjectInfo"
+												}
+											]
+										}
+									}
+								}
+							}
+						},
+                        "description": "Success"
+                    }
+                }
+            }
+        }
+    },
+    "definitions": {
+        "ObjectInfo": {
+            "type": "object",
+            "properties": {
+                "object_id": {
+                    "type": "string",
+                    "format": "uuid"
+                }
+            }
+        }
+    },
+	"schemes": [
+        "http"
+    ],
+    "swagger": "2.0"
+}
+`)
+
+	var doc2 openapi2.T
+	err := json.Unmarshal(v2, &doc2)
+	require.NoError(t, err)
+
+	doc3, err := ToV3(&doc2)
+	require.NoError(t, err)
+	err = doc3.Validate(context.Background())
+	require.NoError(t, err)
+
+	responseSchema := doc3.Paths.Value("/v1/objStatus").Get.Responses.Value("200").Value.Content.Get("application/json").Schema.Value
+	require.Equal(t, &openapi3.Types{"object"}, responseSchema.Type)
+	resultSchema := responseSchema.Properties["result"].Value
+	require.Equal(t, &openapi3.Types{"object"}, resultSchema.Type)
+	require.Equal(t, "#/components/schemas/ObjectInfo", resultSchema.AdditionalProperties.Schema.Value.AllOf[0].Ref)
+	require.Equal(t, "#/components/schemas/ObjectInfo", resultSchema.AdditionalProperties.Schema.Value.AdditionalProperties.Schema.Value.AllOf[0].Ref)
+}
+
 const exampleV2 = `
 {
 	"basePath": "/v2",

openapi3filter/req_resp_decoder.go

@@ -565,6 +565,12 @@ func (d *urlValuesDecoder) parseArray(raw []string, sm *openapi3.SerializationMe
 		}
 		value = append(value, item)
 	}
+	// If the array has only one element and that element is an empty string, it means no value exists, so return nil.
+	if len(value) == 1 {
+		if str, ok := value[0].(string); ok && str == "" {
+			return nil, nil
+		}
+	}
 	return value, nil
 }
 
@@ -1116,13 +1122,13 @@ func parseArray(raw []string, schemaRef *openapi3.SchemaRef) ([]any, error) {
 }
 
 // parsePrimitive returns a value that is created by parsing a source string to a primitive type
-// that is specified by a schema. The function returns nil when the source string is empty.
+// that is specified by a schema. The function returns nil when the source string is empty and the type is not "string".
 // The function panics when a schema has a non-primitive type.
 func parsePrimitive(raw string, schema *openapi3.SchemaRef) (v any, err error) {
-	if raw == "" {
-		return nil, nil
-	}
 	for _, typ := range schema.Value.Type.Slice() {
+		if raw == "" && typ != "string" {
+			return nil, nil
+		}
 		if v, err = parsePrimitiveCase(raw, schema, typ); err == nil {
 			return
 		}

openapi3filter/req_resp_decoder_test.go

@@ -671,13 +671,27 @@ func TestDecodeParameter(t *testing.T) {
 					want:  "foo",
 					found: true,
 				},
+				{
+					name:  "string empty",
+					param: &openapi3.Parameter{Name: "param", In: "query", Schema: stringSchema},
+					query: "param=",
+					want:  "",
+					found: true,
+				},
 				{
 					name:  "integer",
 					param: &openapi3.Parameter{Name: "param", In: "query", Schema: integerSchema},
 					query: "param=1",
 					want:  int64(1),
 					found: true,
 				},
+				{
+					name:  "integer empty",
+					param: &openapi3.Parameter{Name: "param", In: "query", Schema: integerSchema},
+					query: "param=",
+					want:  nil,
+					found: true,
+				},
 				{
 					name:  "integer invalid",
 					param: &openapi3.Parameter{Name: "param", In: "query", Schema: integerSchema},
@@ -692,6 +706,13 @@ func TestDecodeParameter(t *testing.T) {
 					want:  1.1,
 					found: true,
 				},
+				{
+					name:  "number empty",
+					param: &openapi3.Parameter{Name: "param", In: "query", Schema: numberSchema},
+					query: "param=",
+					want:  nil,
+					found: true,
+				},
 				{
 					name:  "number invalid",
 					param: &openapi3.Parameter{Name: "param", In: "query", Schema: numberSchema},
@@ -706,6 +727,13 @@ func TestDecodeParameter(t *testing.T) {
 					want:  true,
 					found: true,
 				},
+				{
+					name:  "boolean empty",
+					param: &openapi3.Parameter{Name: "param", In: "query", Schema: booleanSchema},
+					query: "param=",
+					want:  nil,
+					found: true,
+				},
 				{
 					name:  "boolean invalid",
 					param: &openapi3.Parameter{Name: "param", In: "query", Schema: booleanSchema},

openapi3filter/validate_response_test.go

@@ -42,8 +42,7 @@ func Test_validateResponseHeader(t *testing.T) {
 			},
 			isHeaderPresent: true,
 			headerVals:      []string{""},
-			wantErr:         true,
-			wantErrMsg:      `response header "X-Blab" doesn't match schema: Value is not nullable`,
+			wantErr:         false,
 		},
 		{
 			name: "test optional string header with single string value",