New content format

Sources/OpenAI/Public/Utilities/CodableUtilities.swift

@@ -0,0 +1,118 @@
+//
+//  CodableUtilities.swift
+//
+//
+//  Created by Federico Vitale on 09/11/23.
+//
+
+import Foundation
+
+
+/// Allows having dynamic keys in codables. 
+struct DynamicKey: CodingKey {
+    var stringValue: String
+    var intValue: Int?
+
+    init(stringValue: String) {
+        self.stringValue = stringValue
+    }
+
+    init?(intValue: Int) {
+        self.intValue = intValue
+        self.stringValue = "\(intValue)"
+    }
+}
+
+
+///  Allows to encode/decode ``Chat`` or ``Codable`` (T)
+///     ```swift
+///     struct Person: Codable, Equatable {
+///         let name: StringOrCodable<FullName>
+///
+///         struct FullName {
+///             firstName: String
+///             lastName: String
+///         }
+///     }
+///
+///     let person = Person(name: .string("John Doe"))
+///     let fullNamePerson = Person(name: .object(.init(firstName: "John", lastName: "Doe")))
+///     ```
+public enum StringOrCodable<T: Codable>: Equatable, Codable where T: Equatable {
+    case string(String)
+    case object(T)
+
+    enum CodingKeys: CodingKey {
+        case string
+        case object
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+
+        switch self {
+        case .string(let string):
+            try container.encode(string)
+        case .object(let object):
+            try container.encode(object)
+        }
+    }
+
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+
+        if let string = try? container.decode(String.self) {
+            self = .string(string)
+        } else if let object = try? container.decode(T.self) {
+            self = .object(object)
+        } else {
+            throw DecodingError.dataCorrupted(
+                DecodingError.Context(
+                    codingPath: decoder.codingPath,
+                    debugDescription: "Invalid data encountered when decoding StringOrCodable<T>"
+                )
+            )
+        }
+    }
+}
+
+/// Same as ``StringOrCodable`` but accepts 2 codable generics instead of String as first generic argument
+public enum AnyOf<T: Codable, U: Codable>: Equatable, Codable where T: Equatable, U: Equatable {
+    case objectA(T)
+    case objectB(U)
+
+    enum CodingKeys: CodingKey {
+        case objectA
+        case objectB
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+
+        switch self {
+        case .objectB(let value):
+            try container.encode(value)
+        case .objectA(let value):
+            try container.encode(value)
+        }
+    }
+
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+
+        if let valueT = try? container.decode(T.self) {
+            self = .objectA(valueT)
+        } else if let valueU = try? container.decode(U.self) {
+            self = .objectB(valueU)
+        } else {
+            throw DecodingError.dataCorrupted(
+                DecodingError.Context(
+                    codingPath: decoder.codingPath,
+                    debugDescription: "Invalid data encountered when decoding StringOrCodable<T>"
+                )
+            )
+        }
+    }
+}

Tests/OpenAITests/CodableUtilsTests.swift

@@ -0,0 +1,84 @@
+//
+//  File.swift
+//  
+//
+//  Created by Federico Vitale on 09/11/23.
+//
+
+import XCTest
+@testable import OpenAI
+
+fileprivate class TestUtils {
+    static func decode<T: Decodable & Equatable>(
+        _ jsonString: String,
+        _ expectedValue: T
+    ) throws {
+        let data = jsonString.data(using: .utf8)!
+        let decoded = try JSONDecoder().decode(T.self, from: data)
+
+        XCTAssertEqual(decoded, expectedValue)
+    }
+
+    static func encode<T: Encodable & Equatable>(
+        _ value: T,
+        _ expectedJson: String
+    ) throws {
+        let source = try jsonDataAsNSDictionary(JSONEncoder().encode(value))
+        let expected = try jsonDataAsNSDictionary(expectedJson.data(using: .utf8)!)
+
+        XCTAssertEqual(source, expected)
+    }
+
+    static func jsonDataAsNSDictionary(_ data: Data) throws -> NSDictionary {
+        return NSDictionary(dictionary: try JSONSerialization.jsonObject(with: data, options: []) as! [String: Any])
+    }
+}
+
+
+class CodableUtilsTests: XCTestCase {
+    func testStringOrCodable_String() throws {
+        struct Person: Codable, Equatable {
+            let name: StringOrCodable<FullName>
+
+            struct FullName: Codable, Equatable {
+                let firstName: String
+                let lastName: String
+            }
+        }
+
+        let jsonString = """
+        {
+            "name": "test"
+        }
+        """
+
+        let value = Person(name: .string("test"))
+
+        try TestUtils.encode(value, jsonString)
+        try TestUtils.decode(jsonString, value)
+    }
+
+    func testStringOrCodable_Object() throws {
+        struct Person: Codable, Equatable {
+            let name: StringOrCodable<FullName>
+
+            struct FullName: Codable, Equatable {
+                let firstName: String
+                let lastName: String
+            }
+        }
+
+        let jsonString = """
+        {
+            "name": { "firstName": "first", "lastName": "last" }
+        }
+        """
+
+        let value = Person(name: .object(.init(firstName: "first", lastName: "last")))
+
+        try TestUtils.encode(value, jsonString)
+        try TestUtils.decode(jsonString, value)
+    }
+}
+
+