Support nested values in OpenAPIObjectContainer

Author: rboyce

Sources/OpenAPIRuntime/Base/OpenAPIValue.swift

@@ -143,6 +143,18 @@ public struct OpenAPIValueContainer: Codable, Equatable, Hashable, Sendable {
             try container.encode(value.map(OpenAPIValueContainer.init(validatedValue:)))
         case let value as [String: OpenAPIValueContainer?]:
             try container.encode(value.mapValues(OpenAPIValueContainer.init(validatedValue:)))
+        case let value as [Sendable?]:
+            try container.encode(
+                value.map {
+                    try OpenAPIValueContainer.init(unvalidatedValue: $0)
+                }
+            )
+        case let value as [String: Sendable?]:
+            try container.encode(
+                value.mapValues {
+                    try OpenAPIValueContainer.init(unvalidatedValue: $0)
+                }
+            )
         default:
             throw EncodingError.invalidValue(
                 value,

Tests/OpenAPIRuntimeTests/Conversion/Test_CodableExtensions.swift

@@ -288,4 +288,92 @@ final class Test_CodableExtensions: Test_Runtime {
             )
         }
     }
+
+    func testEncodeNested_true() throws {
+
+        struct Foo: Encodable {
+            var bar: String
+            var dict: OpenAPIObjectContainer = .init()
+        }
+
+        do {
+            let value = Foo(
+                bar: "hi",
+                dict: try .init(unvalidatedValue: [
+                    "baz": "bar",
+                    "number": 1,
+                    "nestedArray": [
+                        1,
+                        [
+                            "k": "v"
+                        ],
+                    ],
+                    "nestedDict": [
+                        "nested": 2
+                    ],
+                ])
+            )
+            let data = try testEncoder.encode(value)
+            XCTAssertEqual(
+                String(decoding: data, as: UTF8.self),
+                #"""
+                {
+                  "bar" : "hi",
+                  "dict" : {
+                    "baz" : "bar",
+                    "nestedArray" : [
+                      1,
+                      {
+                        "k" : "v"
+                      }
+                    ],
+                    "nestedDict" : {
+                      "nested" : 2
+                    },
+                    "number" : 1
+                  }
+                }
+                """#
+            )
+        }
+    }
+
+    func testDecodeEncodeRoundTripNested_true() throws {
+
+        struct Foo: Codable {
+            var bar: String
+            var dict: OpenAPIObjectContainer = .init()
+        }
+
+        do {
+            let data = Data(
+                #"""
+                {
+                  "bar" : "hi",
+                  "dict" : {
+                    "baz" : "bar",
+                    "nestedArray" : [
+                      1,
+                      {
+                        "k" : "v"
+                      }
+                    ],
+                    "nestedDict" : {
+                      "nested" : 2
+                    },
+                    "number" : 1
+                  }
+                }
+                """#
+                .utf8
+            )
+            let decoded = try testDecoder.decode(Foo.self, from: data)
+            let nestedDict = try XCTUnwrap(decoded.dict.value["nestedDict"] as? [String: Any?])
+            let nestedValue = try XCTUnwrap(nestedDict["nested"] as? Int)
+            XCTAssertEqual(nestedValue, 2)
+
+            let encodedData = try testEncoder.encode(decoded)
+            XCTAssertEqual(encodedData, data)
+        }
+    }
 }