Throw error if @Group key is missing

Sources/FluentBenchmark/Tests/CodableTests.swift

@@ -17,7 +17,8 @@ extension FluentBenchmarker {
             _ = try JSONDecoder().decode(Question.self, from: .init(json.utf8))
             XCTFail("expected error")
         } catch DecodingError.typeMismatch(let type, let context) {
-            XCTAssertEqual(ObjectIdentifier(type), ObjectIdentifier(Project.self))
+            // This assertion's validity changes between Swift versions.
+            //XCTAssertEqual(ObjectIdentifier(type), ObjectIdentifier([String: Any].self), "\(type) != \([String: Any].self)")
             XCTAssertEqual(context.codingPath.map(\.stringValue), ["project"])
         }
     }

Sources/FluentKit/Model/Fields+Codable.swift

@@ -6,12 +6,13 @@ extension Fields {
             do {
                 let decoder = ContainerDecoder(container: container, key: .string(label))
                 try property.decode(from: decoder)
+            } catch let decodingError as DecodingError {
+                throw decodingError
             } catch {
-                throw DecodingError.typeMismatch(
-                    type(of: property).anyValueType,
+                throw DecodingError.dataCorrupted(
                     .init(
                         codingPath: [ModelCodingKey.string(label)],
-                        debugDescription: "Could not decode property",
+                        debugDescription: "Could not decode property: \(property)",
                         underlyingError: error
                     )
                 )
@@ -66,6 +67,27 @@ enum ModelCodingKey: CodingKey {
     }
 }
 
+extension ModelCodingKey: CustomStringConvertible {
+    var description: String {
+        switch self {
+        case .string(let string):
+            return string.description
+        case .int(let int):
+            return int.description
+        }
+    }
+}
+
+extension ModelCodingKey: CustomDebugStringConvertible {
+    var debugDescription: String {
+        switch self {
+        case .string(let string):
+            return string.debugDescription
+        case .int(let int):
+            return int.description
+        }
+    }
+}
 
 private struct ContainerDecoder: Decoder, SingleValueDecodingContainer {
     let container: KeyedDecodingContainer<ModelCodingKey>
@@ -80,7 +102,15 @@ private struct ContainerDecoder: Decoder, SingleValueDecodingContainer {
     }
 
     func container<Key>(keyedBy type: Key.Type) throws -> KeyedDecodingContainer<Key> where Key : CodingKey {
-        try self.container.nestedContainer(keyedBy: Key.self, forKey: self.key)
+        do {
+            return try self.container.nestedContainer(keyedBy: Key.self, forKey: self.key)
+        } catch DecodingError.typeMismatch(let mismatchedType, let context) {
+            throw DecodingError.typeMismatch(mismatchedType, .init(
+                codingPath: context.codingPath + [self.key],
+                debugDescription: "Could not decode key",
+                underlyingError: context.underlyingError
+            ))
+        }
     }
 
     func unkeyedContainer() throws -> UnkeyedDecodingContainer {

Sources/FluentKit/Properties/Group.swift

@@ -84,7 +84,7 @@ extension GroupProperty: AnyCodableProperty {
     }
 
     public func decode(from decoder: Decoder) throws {
-        self.value = try .init(from: decoder)
+        self.value = try Value(from: decoder)
     }
 }
 

Tests/FluentKitTests/FluentKitTests.swift

@@ -299,7 +299,14 @@ final class FluentKitTests: XCTestCase {
     // GitHub PR: https://github.com/vapor/fluent-kit/pull/209
     func testDecodeEnumProperty() throws {
         let json = """
-        {"name": "Squeeky", "type": "mouse"}
+        {
+            "name": "Squeeky",
+            "type": "mouse",
+            "foo": {
+                "bar": 42,
+                "baz": "hi"
+            }
+        }
         """
         do {
             let toy = try JSONDecoder().decode(Toy.self, from: Data(json.utf8))
@@ -450,8 +457,7 @@ final class FluentKitTests: XCTestCase {
             {"bar": "qux"}
             """.utf8))
             XCTFail("should not have passed")
-        } catch DecodingError.typeMismatch(let foo, let context) {
-            XCTAssert(foo is Bar.Type)
+        } catch DecodingError.dataCorrupted(let context) {
             XCTAssertEqual(context.codingPath.map(\.stringValue), ["bar"])
         }
     }
@@ -478,8 +484,7 @@ final class FluentKitTests: XCTestCase {
             {"bar": "qux"}
             """.utf8))
             XCTFail("should not have passed")
-        } catch DecodingError.typeMismatch(let foo, let context) {
-            XCTAssert(foo is Bar?.Type)
+        } catch DecodingError.dataCorrupted(let context) {
             XCTAssertEqual(context.codingPath.map(\.stringValue), ["bar"])
         }
     }
@@ -516,7 +521,6 @@ final class FluentKitTests: XCTestCase {
         XCTAssertEqual(foo.id, 1)
     }
 
-
     func testQueryBuilderFieldsFor() throws {
         let test = ArrayTestDatabase()
         let builder = User.query(on: test.db)
@@ -547,6 +551,19 @@ final class FluentKitTests: XCTestCase {
             }
         }
     }
+
+    func testGroupCodable() throws {
+        XCTAssertThrowsError(try JSONDecoder().decode(User.self, from: .init("""
+        {"name": "Tanner"}
+        """.utf8))) { error in
+            switch error as? DecodingError {
+            case .some(.keyNotFound(let key, _)):
+                XCTAssertEqual(key.description, "pet")
+            default:
+                XCTFail("Unexpected error: \(error)")
+            }
+        }
+    }
 }
 
 final class User: Model {