Add OAS 3.2.0 defaultMapping field to Discriminator Object

Author: mattpolzin

Sources/OpenAPIKit/Discriminator.swift

@@ -11,18 +11,44 @@ extension OpenAPI {
     /// OpenAPI Spec "Discriminator Object"
     ///
     /// See [OpenAPI Discriminator Object](https://spec.openapis.org/oas/v3.2.0.html#discriminator-object).
-    public struct Discriminator: Equatable, Sendable {
+    public struct Discriminator: HasConditionalWarnings, Sendable {
         public let propertyName: String
         public let mapping: OrderedDictionary<String, String>?
+        public let defaultMapping: String?
+
+        public let conditionalWarnings: [(any Condition, OpenAPI.Warning)]
 
         public init(propertyName: String,
-                    mapping: OrderedDictionary<String, String>? = nil) {
+                    mapping: OrderedDictionary<String, String>? = nil,
+                    defaultMapping: String? = nil) {
             self.propertyName = propertyName
             self.mapping = mapping
+            self.defaultMapping = defaultMapping
+
+            self.conditionalWarnings = [
+                nonNilVersionWarning(fieldName: "defaultMapping", value: defaultMapping, minimumVersion: .v3_2_0)
+            ].compactMap { $0 }
         }
     }
 }
 
+extension OpenAPI.Discriminator: Equatable {
+    public static func == (lhs: Self, rhs: Self) -> Bool {
+        lhs.propertyName == rhs.propertyName
+        && lhs.mapping == rhs.mapping
+        && lhs.defaultMapping == rhs.defaultMapping
+    }
+}
+
+fileprivate func nonNilVersionWarning<Subject>(fieldName: String, value: Subject?, minimumVersion: OpenAPI.Document.Version) -> (any Condition, OpenAPI.Warning)? {
+    value.map { _ in
+        OpenAPI.Document.ConditionalWarnings.version(
+            lessThan: minimumVersion,
+            doesNotSupport: "The Discriminator \(fieldName) field"
+        )
+    }
+}
+
 // MARK: - Codable
 
 extension OpenAPI.Discriminator: Encodable {
@@ -31,6 +57,7 @@ extension OpenAPI.Discriminator: Encodable {
 
         try container.encode(propertyName, forKey: .propertyName)
         try container.encodeIfPresent(mapping, forKey: .mapping)
+        try container.encodeIfPresent(defaultMapping, forKey: .defaultMapping)
     }
 }
 
@@ -40,13 +67,19 @@ extension OpenAPI.Discriminator: Decodable {
 
         propertyName = try container.decode(String.self, forKey: .propertyName)
         mapping = try container.decodeIfPresent(OrderedDictionary<String, String>.self, forKey: .mapping)
+        defaultMapping = try container.decodeIfPresent(String.self, forKey: .defaultMapping)
+
+        conditionalWarnings = [
+            nonNilVersionWarning(fieldName: "defaultMapping", value: defaultMapping, minimumVersion: .v3_2_0)
+        ].compactMap { $0 }
     }
 }
 
 extension OpenAPI.Discriminator {
     private enum CodingKeys: String, CodingKey {
         case propertyName
         case mapping
+        case defaultMapping
     }
 }
 

Tests/OpenAPIKitTests/DiscriminatorTests.swift

@@ -14,11 +14,21 @@ final class DiscriminatorTests: XCTestCase {
         let t1 = OpenAPI.Discriminator(propertyName: "hello world")
         XCTAssertEqual(t1.propertyName, "hello world")
         XCTAssertNil(t1.mapping)
+        XCTAssertEqual(t1.conditionalWarnings.count, 0)
 
         let t2 = OpenAPI.Discriminator(propertyName: "hello world",
                                        mapping: ["hello": "world"])
         XCTAssertEqual(t2.propertyName, "hello world")
         XCTAssertEqual(t2.mapping, ["hello": "world"])
+        XCTAssertEqual(t2.conditionalWarnings.count, 0)
+
+        let t3 = OpenAPI.Discriminator(propertyName: "hello world",
+                                       mapping: ["hello": "world"],
+                                       defaultMapping: "world")
+        XCTAssertEqual(t3.propertyName, "hello world")
+        XCTAssertEqual(t3.mapping, ["hello": "world"])
+        XCTAssertEqual(t3.defaultMapping, "world")
+        XCTAssertEqual(t3.conditionalWarnings.count, 1)
     }
 }
 
@@ -85,4 +95,35 @@ extension DiscriminatorTests {
         XCTAssertEqual(discriminator, OpenAPI.Discriminator(propertyName: "hello",
                                                             mapping: [ "hello": "world"]))
     }
+
+    func test_withDefaultMapping_encode() {
+        let discriminator = OpenAPI.Discriminator(propertyName: "hello",
+                                                  defaultMapping: "world")
+        let encodedDiscriminator = try! orderUnstableTestStringFromEncoding(of: discriminator)
+
+        assertJSONEquivalent(
+            encodedDiscriminator,
+            """
+            {
+              "defaultMapping" : "world",
+              "propertyName" : "hello"
+            }
+            """
+        )
+    }
+
+    func test_withDefaultMapping_decode() {
+        let discriminatorData =
+        """
+        {
+            "defaultMapping" : "world",
+            "propertyName": "hello",
+        }
+        """.data(using: .utf8)!
+
+        let discriminator = try! orderUnstableDecode(OpenAPI.Discriminator.self, from: discriminatorData)
+
+        XCTAssertEqual(discriminator, OpenAPI.Discriminator(propertyName: "hello",
+                                                            defaultMapping: "world"))
+    }
 }