Support url form encoded bodies (apple#53)

### Motivation

[Issue 182](apple/swift-openapi-generator#182)
Supporting runtime update for [add URL form encoder &
decoder](apple/swift-openapi-generator#283)

### Modifications

Add converter methods for Codable <--> URLEncodedForm.

**Note:** Trying to encode a primitive collection (e.g. an array of
`String`) form a Codable type fails because the URIEncoder rejects
nested object types. I didn't make any changes to the Encoder here, as I
think there may be a larger discussion needed about how to approach
this. It would be beneficial to support this, as there may be a form
which contains multiple values for the same key.

Decoding an exploded key from to a Codable type containing an array
works already, but I've not included the test in this PR, as that should
be included in the above.

### Result

Converter methods for URLEncodedForms are now available for use in
generated content.

### Test Plan

Update tests for encoders and decoders.

---------

Co-authored-by: benfrearson <[email protected]>
Co-authored-by: bfrearson <>
Co-authored-by: Honza Dvorsky <[email protected]>

Author: 3 people

Sources/OpenAPIRuntime/Conversion/Converter+Client.swift

@@ -168,6 +168,34 @@ extension Converter {
         )
     }
 
+    //    | client | set | request body | urlEncodedForm | codable | optional | setOptionalRequestBodyAsURLEncodedForm |
+    public func setOptionalRequestBodyAsURLEncodedForm<T: Encodable>(
+        _ value: T,
+        headerFields: inout [HeaderField],
+        contentType: String
+    ) throws -> Data? {
+        try setOptionalRequestBody(
+            value,
+            headerFields: &headerFields,
+            contentType: contentType,
+            convert: convertBodyCodableToURLFormData
+        )
+    }
+
+    //    | client | set | request body | urlEncodedForm | codable | required | setRequiredRequestBodyAsURLEncodedForm |
+    public func setRequiredRequestBodyAsURLEncodedForm<T: Encodable>(
+        _ value: T,
+        headerFields: inout [HeaderField],
+        contentType: String
+    ) throws -> Data {
+        try setRequiredRequestBody(
+            value,
+            headerFields: &headerFields,
+            contentType: contentType,
+            convert: convertBodyCodableToURLFormData
+        )
+    }
+
     //    | client | get | response body | string | required | getResponseBodyAsString |
     public func getResponseBodyAsString<T: Decodable, C>(
         _ type: T.Type,

Sources/OpenAPIRuntime/Conversion/Converter+Server.swift

@@ -273,6 +273,34 @@ extension Converter {
         )
     }
 
+    //    | server | get | request body | URLEncodedForm | codable | optional | getOptionalRequestBodyAsURLEncodedForm |
+    func getOptionalRequestBodyAsURLEncodedForm<T: Decodable, C>(
+        _ type: T.Type,
+        from data: Data?,
+        transforming transform: (T) -> C
+    ) throws -> C? {
+        try getOptionalRequestBody(
+            type,
+            from: data,
+            transforming: transform,
+            convert: convertURLEncodedFormToCodable
+        )
+    }
+
+    //    | server | get | request body | URLEncodedForm | codable | required | getRequiredRequestBodyAsURLEncodedForm |
+    public func getRequiredRequestBodyAsURLEncodedForm<T: Decodable, C>(
+        _ type: T.Type,
+        from data: Data?,
+        transforming transform: (T) -> C
+    ) throws -> C {
+        try getRequiredRequestBody(
+            type,
+            from: data,
+            transforming: transform,
+            convert: convertURLEncodedFormToCodable
+        )
+    }
+
     //    | server | set | response body | string | required | setResponseBodyAsString |
     public func setResponseBodyAsString<T: Encodable>(
         _ value: T,

Sources/OpenAPIRuntime/Conversion/CurrencyExtensions.swift

@@ -177,12 +177,43 @@ extension Converter {
         try decoder.decode(T.self, from: data)
     }
 
+    func convertURLEncodedFormToCodable<T: Decodable>(
+        _ data: Data
+    ) throws -> T {
+        let decoder = URIDecoder(
+            configuration: .init(
+                style: .form,
+                explode: true,
+                spaceEscapingCharacter: .plus,
+                dateTranscoder: configuration.dateTranscoder
+            )
+        )
+        let uriString = String(decoding: data, as: UTF8.self)
+        return try decoder.decode(T.self, from: uriString)
+    }
+
     func convertBodyCodableToJSON<T: Encodable>(
         _ value: T
     ) throws -> Data {
         try encoder.encode(value)
     }
 
+    func convertBodyCodableToURLFormData<T: Encodable>(
+        _ value: T
+    ) throws -> Data {
+        let encoder = URIEncoder(
+            configuration: .init(
+                style: .form,
+                explode: true,
+                spaceEscapingCharacter: .plus,
+                dateTranscoder: configuration.dateTranscoder
+            )
+        )
+        let encodedString = try encoder.encode(value, forKey: "")
+        let data = Data(encodedString.utf8)
+        return data
+    }
+
     func convertHeaderFieldCodableToJSON<T: Encodable>(
         _ value: T
     ) throws -> String {

Tests/OpenAPIRuntimeTests/Conversion/Test_Converter+Client.swift

@@ -234,6 +234,46 @@ final class Test_ClientConverterExtensions: Test_Runtime {
         )
     }
 
+    //    | client | set | request body | urlEncodedForm | codable | optional | setRequiredRequestBodyAsURLEncodedForm |
+    func test_setOptionalRequestBodyAsURLEncodedForm_codable() throws {
+        var headerFields: [HeaderField] = []
+        let body = try converter.setOptionalRequestBodyAsURLEncodedForm(
+            testStructDetailed,
+            headerFields: &headerFields,
+            contentType: "application/x-www-form-urlencoded"
+        )
+
+        guard let body else {
+            XCTFail("Expected body should not be nil")
+            return
+        }
+
+        XCTAssertEqualStringifiedData(body, testStructURLFormString)
+        XCTAssertEqual(
+            headerFields,
+            [
+                .init(name: "content-type", value: "application/x-www-form-urlencoded")
+            ]
+        )
+    }
+
+    //    | client | set | request body | urlEncodedForm | codable | required | setRequiredRequestBodyAsURLEncodedForm |
+    func test_setRequiredRequestBodyAsURLEncodedForm_codable() throws {
+        var headerFields: [HeaderField] = []
+        let body = try converter.setRequiredRequestBodyAsURLEncodedForm(
+            testStructDetailed,
+            headerFields: &headerFields,
+            contentType: "application/x-www-form-urlencoded"
+        )
+        XCTAssertEqualStringifiedData(body, testStructURLFormString)
+        XCTAssertEqual(
+            headerFields,
+            [
+                .init(name: "content-type", value: "application/x-www-form-urlencoded")
+            ]
+        )
+    }
+
     //    | client | set | request body | binary | optional | setOptionalRequestBodyAsBinary |
     func test_setOptionalRequestBodyAsBinary_data() throws {
         var headerFields: [HeaderField] = []
@@ -308,3 +348,18 @@ final class Test_ClientConverterExtensions: Test_Runtime {
         XCTAssertEqual(value, testStringData)
     }
 }
+
+public func XCTAssertEqualStringifiedData(
+    _ expression1: @autoclosure () throws -> Data,
+    _ expression2: @autoclosure () throws -> String,
+    _ message: @autoclosure () -> String = "",
+    file: StaticString = #filePath,
+    line: UInt = #line
+) {
+    do {
+        let actualString = String(decoding: try expression1(), as: UTF8.self)
+        XCTAssertEqual(actualString, try expression2(), file: file, line: line)
+    } catch {
+        XCTFail(error.localizedDescription, file: file, line: line)
+    }
+}

Tests/OpenAPIRuntimeTests/Conversion/Test_Converter+Server.swift

@@ -339,6 +339,26 @@ final class Test_ServerConverterExtensions: Test_Runtime {
         XCTAssertEqual(body, testStruct)
     }
 
+    //    | server | get | request body | urlEncodedForm | optional | getOptionalRequestBodyAsURLEncodedForm |
+    func test_getOptionalRequestBodyAsURLEncodedForm_codable() throws {
+        let body: TestPetDetailed? = try converter.getOptionalRequestBodyAsURLEncodedForm(
+            TestPetDetailed.self,
+            from: testStructURLFormData,
+            transforming: { $0 }
+        )
+        XCTAssertEqual(body, testStructDetailed)
+    }
+
+    //    | server | get | request body | urlEncodedForm | required | getRequiredRequestBodyAsURLEncodedForm |
+    func test_getRequiredRequestBodyAsURLEncodedForm_codable() throws {
+        let body: TestPetDetailed = try converter.getRequiredRequestBodyAsURLEncodedForm(
+            TestPetDetailed.self,
+            from: testStructURLFormData,
+            transforming: { $0 }
+        )
+        XCTAssertEqual(body, testStructDetailed)
+    }
+
     //    | server | get | request body | binary | optional | getOptionalRequestBodyAsBinary |
     func test_getOptionalRequestBodyAsBinary_data() throws {
         let body: Data? = try converter.getOptionalRequestBodyAsBinary(

Tests/OpenAPIRuntimeTests/Test_Runtime.swift

@@ -86,6 +86,10 @@ class Test_Runtime: XCTestCase {
         .init(name: "Fluffz")
     }
 
+    var testStructDetailed: TestPetDetailed {
+        .init(name: "Rover!", type: "Golden Retriever", age: "3")
+    }
+
     var testStructString: String {
         #"{"name":"Fluffz"}"#
     }
@@ -98,6 +102,10 @@ class Test_Runtime: XCTestCase {
         """#
     }
 
+    var testStructURLFormString: String {
+        "age=3&name=Rover%21&type=Golden+Retriever"
+    }
+
     var testEnum: TestHabitat {
         .water
     }
@@ -114,6 +122,10 @@ class Test_Runtime: XCTestCase {
         Data(testStructPrettyString.utf8)
     }
 
+    var testStructURLFormData: Data {
+        Data(testStructURLFormString.utf8)
+    }
+
     func _testPrettyEncoded<Value: Encodable>(_ value: Value, expectedJSON: String) throws {
         let encoder = JSONEncoder()
         encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
@@ -140,6 +152,12 @@ struct TestPet: Codable, Equatable {
     var name: String
 }
 
+struct TestPetDetailed: Codable, Equatable {
+    var name: String
+    var type: String
+    var age: String
+}
+
 enum TestHabitat: String, Codable, Equatable {
     case water
     case land