chore: allow absent data in ToManyRelationship

Sources/JSONAPI/Resource/Relationship.swift

@@ -222,7 +222,7 @@ extension Optional: JSONAPIIdentifiable, OptionalRelatable, JSONTyped where Wrap
 }
 
 // MARK: Codable
-private enum ResourceLinkageCodingKeys: String, CodingKey {
+enum ResourceLinkageCodingKeys: String, CodingKey {
     case data = "data"
     case meta = "meta"
     case links = "links"
@@ -401,6 +401,16 @@ extension ToManyRelationship: Codable {
             links = try container.decode(LinksType.self, forKey: .links)
         }
 
+        let hasData = container.contains(.data)
+        var canHaveNoDataInRelationships: Bool = false
+        if let relatableType = Relatable.self as? ResourceObjectWithOptionalDataInRelationships.Type {
+            canHaveNoDataInRelationships = relatableType.canHaveNoDataInRelationships
+        }
+        guard hasData || !canHaveNoDataInRelationships else {
+            idsWithMeta = []
+            return
+        }
+
         var identifiers: UnkeyedDecodingContainer
         do {
             identifiers = try container.nestedUnkeyedContainer(forKey: .data)

Sources/JSONAPI/Resource/Resource Object/ResourceObject.swift

@@ -53,11 +53,25 @@ public protocol JSONTyped {
 
 /// A `ResourceObjectProxyDescription` is an `ResourceObjectDescription`
 /// without Codable conformance.
-public protocol ResourceObjectProxyDescription: JSONTyped {
+public protocol ResourceObjectProxyDescription: JSONTyped, ResourceObjectWithOptionalDataInRelationships {
     associatedtype Attributes: Equatable
     associatedtype Relationships: Equatable
 }
 
+/// A flagging protocol for `ResourceObjectProxyDescription` objects.
+/// Indicates an object with varying behavior when it's being decoded from resources and the `data` key is missing.
+public protocol ResourceObjectWithOptionalDataInRelationships {
+    /// A Boolean flag indicating that instances while decoding from relationships can be decoded without `data`
+    /// key and have only links and meta information.
+    ///
+    /// Default value: `false`.
+    static var canHaveNoDataInRelationships: Bool { get }
+}
+
+extension ResourceObjectWithOptionalDataInRelationships {
+    public static var canHaveNoDataInRelationships: Bool { false }
+}
+
 /// A `ResourceObjectDescription` describes a JSON API
 /// Resource Object. The Resource Object
 /// itself is encoded and decoded as an
@@ -244,6 +258,12 @@ public extension ResourceObject where EntityRawIdType: CreatableRawIdType {
     }
 }
 
+// Conformance to the protocol so we can access the `canHaveNoDataInRelationships` flag from
+// `ToManyRelationship` in type-erasured `Relatable`.
+extension ResourceObject: ResourceObjectWithOptionalDataInRelationships where Description: ResourceObjectWithOptionalDataInRelationships {
+    public static var canHaveNoDataInRelationships: Bool { Description.canHaveNoDataInRelationships }
+}
+
 // MARK: - Attribute Access
 public extension ResourceObjectProxy {
     // MARK: Dynaminc Member Keypath Lookup

Tests/JSONAPITests/Relationships/RelationshipTests.swift

@@ -6,7 +6,7 @@
 //
 
 import XCTest
-import JSONAPI
+@testable import JSONAPI
 
 class RelationshipTests: XCTestCase {
 
@@ -235,6 +235,37 @@ extension RelationshipTests {
 		test_DecodeEncodeEquality(type: ToManyWithMetaAndLinks.self,
 								  data: to_many_relationship_with_meta_and_links)
 	}
+
+  func test_ToManyRelationshipWithMetaNoDataOmittable() {
+    TestEntityType1.canHaveNoDataInRelationships = true
+
+    let relationship = decoded(type: ToManyWithMeta.self,
+                               data: to_many_relationship_with_meta_no_data)
+
+    XCTAssertEqual(relationship.ids, [])
+    XCTAssertEqual(relationship.meta.a, "hello")
+
+    TestEntityType1.canHaveNoDataInRelationships = false
+  }
+
+  func test_ToManyRelationshipWithMetaNoDataNotOmittable() {
+    TestEntityType1.canHaveNoDataInRelationships = false
+
+    do {
+        _ = try decodedThrows(type: ToManyWithMeta.self,
+                              data: to_many_relationship_with_meta_no_data)
+        XCTFail("Expected decoding to fail.")
+    } catch let error as DecodingError {
+      switch error {
+      case .keyNotFound(ResourceLinkageCodingKeys.data, _):
+        break
+      default:
+        XCTFail("Expected error to be DecodingError.keyNotFound(.data), but got \(error)")
+      }
+    } catch {
+      XCTFail("Expected to have DecodingError.keyNotFound(.data), but got \(error)")
+    }
+  }
 }
 
 // MARK: Nullable
@@ -277,12 +308,14 @@ extension RelationshipTests {
 
 // MARK: - Test types
 extension RelationshipTests {
-	enum TestEntityType1: ResourceObjectDescription {
+	enum TestEntityType1: ResourceObjectDescription, ResourceObjectWithOptionalDataInRelationships {
 		typealias Attributes = NoAttributes
 
 		typealias Relationships = NoRelationships
 
 		public static var jsonType: String { return "test_entity1" }
+
+    static var canHaveNoDataInRelationships: Bool = false
 	}
 
 	typealias TestEntity1 = BasicEntity<TestEntityType1>

Tests/JSONAPITests/Relationships/stubs/RelationshipStubs.swift

@@ -241,3 +241,11 @@ let to_many_relationship_type_mismatch = """
 	]
 }
 """.data(using: .utf8)!
+
+let to_many_relationship_with_meta_no_data = """
+{
+  "meta": {
+    "a": "hello"
+  }
+}
+""".data(using: .utf8)!

Tests/JSONAPITests/Test Helpers/EncodeDecode.swift

@@ -24,6 +24,10 @@ func decoded<T: Decodable>(type: T.Type, data: Data) -> T {
 	return try! testDecoder.decode(T.self, from: data)
 }
 
+func decodedThrows<T: Decodable>(type: T.Type, data: Data) throws -> T {
+  return try testDecoder.decode(T.self, from: data)
+}
+
 func encoded<T: Encodable>(value: T) -> Data {
 	return try! testEncoder.encode(value)
 }