Merge pull request #11 from daangn/feature/elon/add-resilient-decoding

feat: Add ResilientDecodingErrorReporter

Author: ElonPark

.github/workflows/ci.yml

@@ -19,7 +19,7 @@ jobs:
     runs-on: macos-15
     strategy:
       matrix:
-        xcode: ['16.1']
+        xcode: ['16.4']
         config: ['debug', 'release']
 
     steps:

README.md

@@ -120,10 +120,10 @@ extension User: Codable {
 
 ### PolymorphicCodable
 
-`PolymorphicCodable` provides functionality to easily decode polymorphic types from JSON. It includes several interfaces like `PolymorphicIdentifiable`, `PolymorphicCodableStrategy`, and property wrappers like `PolymorphicValue` and `PolymorphicArrayValue`.
+`PolymorphicCodable` provides functionality to easily decode polymorphic types from JSON. This functionality provides Swift implementation for the OpenAPI Specification's `oneOf` pattern, allowing type-safe handling of multiple possible schemas. It includes several interfaces like `PolymorphicIdentifiable`, `PolymorphicCodableStrategy`, and property wrappers like `PolymorphicValue` and `PolymorphicArrayValue`.
 
 **Parameters:**
-- `identifierCodingKey`: Specifies the JSON key used to determine the type of object being decoded. Defaults to "type" if not specified, allowing you to omit this parameter when using the default value.
+- `identifierCodingKey`: Specifies the JSON key used to determine the type of object being decoded. This parameter corresponds to the `discriminator.propertyName` in OpenAPI Specification's oneOf definition. Defaults to "type" if not specified, allowing you to omit this parameter when using the default value.
 - `fallbackType`: Defines a default type to use when the identifier in the JSON doesn't match any of the registered types, preventing decoding failures for unknown types. If this parameter is omitted and an unknown type identifier is encountered during decoding, a decoding error will be thrown.
 
 The following example demonstrates how to decode dynamic JSON content where the type of object is determined at runtime:
@@ -277,3 +277,4 @@ This project is licensed under the MIT. See LICENSE for details.
 - PolymorphicCodable was inspired by [Encode and decode polymorphic types in Swift](https://nilcoalescing.com/blog/BringingPolymorphismToCodable/).
 - AnyCodable was adapted from [Flight-School/AnyCodable](https://github.com/Flight-School/AnyCodable).
 - BetterCodable was adapted from [marksands/BetterCodable](https://github.com/marksands/BetterCodable).
+- ResilientDecodingErrorReporter was adapted from [airbnb/ResilientDecoding](https://github.com/airbnb/ResilientDecoding).

Sources/KarrotCodableKit/BetterCodable/DataValue/DataValue.swift

@@ -25,14 +25,33 @@ public protocol DataValueCodableStrategy {
 public struct DataValue<Coder: DataValueCodableStrategy> {
   public var wrappedValue: Coder.DataType
 
+  public let outcome: ResilientDecodingOutcome
+
   public init(wrappedValue: Coder.DataType) {
     self.wrappedValue = wrappedValue
+    self.outcome = .decodedSuccessfully
+  }
+
+  init(wrappedValue: Coder.DataType, outcome: ResilientDecodingOutcome) {
+    self.wrappedValue = wrappedValue
+    self.outcome = outcome
   }
+
+  #if DEBUG
+  public var projectedValue: ResilientProjectedValue { ResilientProjectedValue(outcome: outcome) }
+  #endif
 }
 
 extension DataValue: Decodable {
   public init(from decoder: Decoder) throws {
-    self.wrappedValue = try Coder.decode(String(from: decoder))
+    do {
+      let stringValue = try String(from: decoder)
+      self.wrappedValue = try Coder.decode(stringValue)
+      self.outcome = .decodedSuccessfully
+    } catch {
+      decoder.reportError(error)
+      throw error
+    }
   }
 }
 
@@ -42,6 +61,16 @@ extension DataValue: Encodable {
   }
 }
 
-extension DataValue: Equatable where Coder.DataType: Equatable {}
-extension DataValue: Hashable where Coder.DataType: Hashable {}
+extension DataValue: Equatable where Coder.DataType: Equatable {
+  public static func == (lhs: Self, rhs: Self) -> Bool {
+    lhs.wrappedValue == rhs.wrappedValue
+  }
+}
+
+extension DataValue: Hashable where Coder.DataType: Hashable {
+  public func hash(into hasher: inout Hasher) {
+    hasher.combine(wrappedValue)
+  }
+}
+
 extension DataValue: Sendable where Coder.DataType: Sendable {}

Sources/KarrotCodableKit/BetterCodable/DateValue/DateValue.swift

@@ -25,15 +25,33 @@ public protocol DateValueCodableStrategy {
 public struct DateValue<Formatter: DateValueCodableStrategy> {
   public var wrappedValue: Date
 
+  public let outcome: ResilientDecodingOutcome
+
   public init(wrappedValue: Date) {
     self.wrappedValue = wrappedValue
+    self.outcome = .decodedSuccessfully
   }
+
+  init(wrappedValue: Date, outcome: ResilientDecodingOutcome) {
+    self.wrappedValue = wrappedValue
+    self.outcome = outcome
+  }
+
+  #if DEBUG
+  public var projectedValue: ResilientProjectedValue { ResilientProjectedValue(outcome: outcome) }
+  #endif
 }
 
 extension DateValue: Decodable where Formatter.RawValue: Decodable {
   public init(from decoder: Decoder) throws {
-    let value = try Formatter.RawValue(from: decoder)
-    self.wrappedValue = try Formatter.decode(value)
+    do {
+      let value = try Formatter.RawValue(from: decoder)
+      self.wrappedValue = try Formatter.decode(value)
+      self.outcome = .decodedSuccessfully
+    } catch {
+      decoder.reportError(error)
+      throw error
+    }
   }
 }
 
@@ -45,7 +63,7 @@ extension DateValue: Encodable where Formatter.RawValue: Encodable {
 }
 
 extension DateValue: Equatable {
-  public static func == (lhs: DateValue<Formatter>, rhs: DateValue<Formatter>) -> Bool {
+  public static func == (lhs: Self, rhs: Self) -> Bool {
     lhs.wrappedValue == rhs.wrappedValue
   }
 }

Sources/KarrotCodableKit/BetterCodable/DateValue/OptionalDateValue.swift

@@ -26,19 +26,39 @@ public protocol OptionalDateValueCodableStrategy {
 public struct OptionalDateValue<Formatter: OptionalDateValueCodableStrategy> {
   public var wrappedValue: Date?
 
+  public let outcome: ResilientDecodingOutcome
+
   public init(wrappedValue: Date?) {
     self.wrappedValue = wrappedValue
+    self.outcome = .decodedSuccessfully
   }
+
+  init(wrappedValue: Date?, outcome: ResilientDecodingOutcome) {
+    self.wrappedValue = wrappedValue
+    self.outcome = outcome
+  }
+
+  #if DEBUG
+  public var projectedValue: ResilientProjectedValue { ResilientProjectedValue(outcome: outcome) }
+  #endif
 }
 
 extension OptionalDateValue: Decodable where Formatter.RawValue: Decodable {
   public init(from decoder: Decoder) throws {
     do {
       let value = try Formatter.RawValue(from: decoder)
-      self.wrappedValue = try Formatter.decode(value)
+      do {
+        self.wrappedValue = try Formatter.decode(value)
+        self.outcome = .decodedSuccessfully
+      } catch {
+        decoder.reportError(error)
+        throw error
+      }
     } catch DecodingError.valueNotFound(let rawType, _) where rawType == Formatter.RawValue.self {
       self.wrappedValue = nil
+      self.outcome = .valueWasNil
     } catch {
+      decoder.reportError(error)
       throw error
     }
   }
@@ -52,7 +72,7 @@ extension OptionalDateValue: Encodable where Formatter.RawValue: Encodable {
 }
 
 extension OptionalDateValue: Equatable {
-  public static func == (lhs: OptionalDateValue<Formatter>, rhs: OptionalDateValue<Formatter>) -> Bool {
+  public static func == (lhs: Self, rhs: Self) -> Bool {
     lhs.wrappedValue == rhs.wrappedValue
   }
 }