Add vendor extensions support to Content

Author: mattpolzin

README.md

@@ -135,6 +135,7 @@ This library *is* opinionated about a few defaults when you use the Swift types,
 - [x] example
 - [ ] examples
 - [x] encoding
+- [x] specification extensions (`vendorExtensions`)
 
 ### Encoding Object (`OpenAPI.Content.Encoding`)
 - [x] contentType

Sources/OpenAPIKit/Content.swift

@@ -16,18 +16,27 @@ extension OpenAPI {
         case form = "application/x-www-form-urlencoded"
     }
 
-    public struct Content: Codable, Equatable {
+    public struct Content: Equatable {
         public let schema: Either<JSONReference<Components, JSONSchema>, JSONSchema>
         public let example: AnyCodable?
         //        public let examples:
         public let encoding: [String: Encoding]?
 
+        /// Dictionary of vendor extensions.
+        ///
+        /// These should be of the form:
+        /// `[ "x-extensionKey": <anything>]`
+        /// where the values are anything codable.
+        public let vendorExtensions: [String: AnyCodable]
+
         public init(schema: Either<JSONReference<Components, JSONSchema>, JSONSchema>,
                     example: AnyCodable? = nil,
-                    encoding: [String: Encoding]? = nil) {
+                    encoding: [String: Encoding]? = nil,
+                    vendorExtensions: [String: AnyCodable] = [:]) {
             self.schema = schema
             self.example = example
             self.encoding = encoding
+            self.vendorExtensions = vendorExtensions
         }
     }
 }
@@ -53,3 +62,93 @@ extension OpenAPI.Content {
         }
     }
 }
+
+// MARK: - Codable
+
+extension OpenAPI.Content: Encodable {
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+
+        try container.encode(schema, forKey: .schema)
+
+        if example != nil {
+            try container.encode(example, forKey: .example)
+        }
+
+        if encoding != nil {
+            try container.encode(encoding, forKey: .encoding)
+        }
+
+        if vendorExtensions != [:] {
+            for (key, value) in vendorExtensions {
+                let xKey = key.starts(with: "x-") ? key : "x-\(key)"
+                try container.encode(value, forKey: .extended(xKey))
+            }
+        }
+    }
+}
+
+extension OpenAPI.Content: Decodable {
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+
+        schema = try container.decode(Either<JSONReference<OpenAPI.Components, JSONSchema>, JSONSchema>.self, forKey: .schema)
+        example = try container.decodeIfPresent(AnyCodable.self, forKey: .example)
+        encoding = try container.decodeIfPresent([String: Encoding].self, forKey: .encoding)
+
+        let decodedAny = (try AnyCodable(from: decoder)).value as? [String: Any]
+
+        vendorExtensions = decodedAny?.filter {
+            guard let key = CodingKeys(stringValue: $0.key) else { return false }
+
+            return !CodingKeys.allBuiltinCases.contains(key)
+        }.mapValues(AnyCodable.init) ?? [:]
+    }
+}
+
+extension OpenAPI.Content {
+    private enum CodingKeys: CodingKey, Equatable {
+        case schema
+        case example
+        case encoding
+        case extended(String)
+
+        init?(stringValue: String) {
+            switch stringValue {
+            case "schema":
+                self = .schema
+            case "example":
+                self = .example
+            case "encoding":
+                self = .encoding
+            default:
+                self = .extended(stringValue)
+            }
+        }
+
+        init?(intValue: Int) {
+            return nil
+        }
+
+        var stringValue: String {
+            switch self {
+            case .schema:
+                return "schema"
+            case .example:
+                return "example"
+            case .encoding:
+                return "encoding"
+            case .extended(let key):
+                return key
+            }
+        }
+
+        var intValue: Int? {
+            return nil
+        }
+
+        static var allBuiltinCases: [CodingKeys] {
+            return [.schema, .example, .encoding]
+        }
+    }
+}

Tests/OpenAPIKitTests/ContentTests.swift

@@ -8,6 +8,7 @@
 import Foundation
 import XCTest
 import OpenAPIKit
+import AnyCodable
 
 final class ContentTests: XCTestCase {
     func test_init() {
@@ -114,6 +115,86 @@ extension ContentTests {
 
         XCTAssertEqual(content, OpenAPI.Content(schema: .init(.string(required: false))))
     }
+
+    func test_exampleAndSchemaContent_encode() {
+        // TODO: write test
+    }
+
+    func test_exampleAndSchemaContent_decode() {
+        // TODO: write test
+    }
+
+    func test_encodingAndSchema_encode() {
+        // TODO: write test
+    }
+
+    func test_encodingAndSchema_decode() {
+        // TODO: write test
+    }
+
+    func test_vendorExtensions_encode() {
+        let content = OpenAPI.Content(schema: .init(.string),
+                                      vendorExtensions: [ "x-hello": [ "world": 123 ] ])
+
+        let encodedContent = try! testStringFromEncoding(of: content)
+
+        XCTAssertEqual(encodedContent,
+"""
+{
+  "schema" : {
+    "type" : "string"
+  },
+  "x-hello" : {
+    "world" : 123
+  }
+}
+"""
+        )
+    }
+
+    func test_vendorExtensions_encode_fixKey() {
+        let content = OpenAPI.Content(schema: .init(.string),
+                                      vendorExtensions: [ "hello": [ "world": 123 ] ])
+
+        let encodedContent = try! testStringFromEncoding(of: content)
+
+        XCTAssertEqual(encodedContent,
+"""
+{
+  "schema" : {
+    "type" : "string"
+  },
+  "x-hello" : {
+    "world" : 123
+  }
+}
+"""
+        )
+    }
+
+    func test_vendorExtensions_decode() {
+        let contentData =
+"""
+{
+  "schema" : {
+    "type" : "string"
+  },
+  "x-hello" : {
+    "world" : 123
+  }
+}
+""".data(using: .utf8)!
+        let content = try! testDecoder.decode(OpenAPI.Content.self, from: contentData)
+
+        let contentToMatch = OpenAPI.Content(schema: .init(.string(required: false)),
+                                             vendorExtensions: ["x-hello": AnyCodable(["world": 123])])
+
+        // needs to be broken down due to difficulties with equality comparing of AnyCodable
+        // created from code with a semantically equivalent AnyCodable from Data.
+        XCTAssertEqual(content.schema, contentToMatch.schema)
+        XCTAssertEqual(content.vendorExtensions.keys, contentToMatch.vendorExtensions.keys)
+        XCTAssertEqual(content.vendorExtensions["x-hello"]?.value as? [String: Int], contentToMatch.vendorExtensions["x-hello"]?.value as? [String: Int]?)
+    }
 }
 
 // MARK: Content.Encoding