Merge pull request #51 from mattpolzin/feature/primary-resource-body-improvements

Feature/primary resource body improvements

JSONAPI.podspec

@@ -16,7 +16,7 @@ Pod::Spec.new do |spec|
   #
 
   spec.name         = "MP-JSONAPI"
-  spec.version      = "2.4.0"
+  spec.version      = "2.5.0"
   spec.summary      = "Swift Codable JSON API framework."
 
   # This description is used to generate tags and improve search results.

Package.resolved

@@ -6,8 +6,8 @@
         "repositoryURL": "https://github.com/mattpolzin/Poly.git",
         "state": {
           "branch": null,
-          "revision": "b24fd3b41bf3126d4c6dede3708135182172af60",
-          "version": "2.2.0"
+          "revision": "18cd995be5c28c4dfdc1464e54ee0efb03e215bf",
+          "version": "2.3.0"
         }
       }
     ]

Package.swift

@@ -18,7 +18,7 @@ let package = Package(
             targets: ["JSONAPITesting"])
     ],
     dependencies: [
-        .package(url: "https://github.com/mattpolzin/Poly.git", .upToNextMajor(from: "2.2.0")),
+        .package(url: "https://github.com/mattpolzin/Poly.git", .upToNextMajor(from: "2.3.0")),
     ],
     targets: [
         .target(

README.md

@@ -16,12 +16,13 @@ See the JSON API Spec here: https://jsonapi.org/format/
 - [Compound Example](https://colab.research.google.com/drive/1BdF0Kc7l2ixDfBZEL16FY6palweDszQU)
 - [Metadata Example](https://colab.research.google.com/drive/10dEESwiE9I3YoyfzVeOVwOKUTEgLT3qr)
 - [Custom Errors Example](https://colab.research.google.com/drive/1TIv6STzlHrkTf_-9Eu8sv8NoaxhZcFZH)
+- [PATCH Example](https://colab.research.google.com/drive/16KY-0BoLQKiSUh9G7nYmHzB8b2vhXA2U)
 
 ### Serverside
 - [GET Example](https://colab.research.google.com/drive/1krbhzSfz8mwkBTQQnKUZJLEtYsJKSfYX)
 - [POST Example](https://colab.research.google.com/drive/1z3n70LwRY7vLIgbsMghvnfHA67QiuqpQ)
 
-### Combined
+### Client+Server
 This library works well when used by both the server responsible for serialization and the client responsible for deserialization. Check out the [example](#example) further down in this README.
 
 ## Table of Contents
@@ -331,13 +332,11 @@ As of Swift 5.1, `Attributes` can be accessed via dynamic member keypath lookup
 let favoriteColor: String = person.favoriteColor
 ```
 
-🗒 `Attributes` can also be accessed via the older `subscript` operator as follows:
+:warning:  `Attributes` can also be accessed via the older `subscript` operator, but this is a deprecated feature that will be removed in the next major version:
 ```swift
 let favoriteColor: String = person[\.favoriteColor]
 ```
 
-In both cases you retain type-safety. It is best practice to pick an attribute access syntax and stick with it. At some point in the future the syntax deemed less desirable may be deprecated.
-
 #### `Transformer`
 
 Sometimes you need to use a type that does not encode or decode itself in the way you need to represent it as a serialized JSON object. For example, the Swift `Foundation` type `Date` can encode/decode itself to `Double` out of the box, but you might want to represent dates as ISO 8601 compliant `String`s instead. The Foundation library `JSONDecoder` has a setting to make this adjustment, but for the sake of an example, you could create a `Transformer`.

Sources/JSONAPI/Document/APIDescription.swift

@@ -7,58 +7,58 @@
 
 /// This is what the JSON API Spec calls the "JSON:API Object"
 public protocol APIDescriptionType: Codable, Equatable {
-	associatedtype Meta
+    associatedtype Meta
 }
 
 /// This is what the JSON API Spec calls the "JSON:API Object"
 public struct APIDescription<Meta: JSONAPI.Meta>: APIDescriptionType {
-	public let version: String
-	public let meta: Meta
+    public let version: String
+    public let meta: Meta
 
-	public init(version: String, meta: Meta) {
-		self.version = version
-		self.meta = meta
-	}
+    public init(version: String, meta: Meta) {
+        self.version = version
+        self.meta = meta
+    }
 }
 
 /// Can be used as `APIDescriptionType` for Documents that do not
 /// have any API Description (a.k.a. "JSON:API Object").
 public struct NoAPIDescription: APIDescriptionType, CustomStringConvertible {
-	public typealias Meta = NoMetadata
+    public typealias Meta = NoMetadata
 
-	public init() {}
+    public init() {}
 
-	public static var none: NoAPIDescription { return .init() }
+    public static var none: NoAPIDescription { return .init() }
 
-	public var description: String { return "No JSON:API Object" }
+    public var description: String { return "No JSON:API Object" }
 }
 
 extension APIDescription {
-	private enum CodingKeys: String, CodingKey {
-		case version
-		case meta
-	}
+    private enum CodingKeys: String, CodingKey {
+        case version
+        case meta
+    }
 
-	public init(from decoder: Decoder) throws {
-		let container = try decoder.container(keyedBy: CodingKeys.self)
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
 
-		// The spec says that if a version is not specified, it should be assumed to be at least 1.0
-		version = (try? container.decode(String.self, forKey: .version)) ?? "1.0"
+        // The spec says that if a version is not specified, it should be assumed to be at least 1.0
+        version = (try? container.decode(String.self, forKey: .version)) ?? "1.0"
 
-		if let metaVal = NoMetadata() as? Meta {
-			meta = metaVal
-		} else {
-			meta = try container.decode(Meta.self, forKey: .meta)
-		}
-	}
+        if let metaVal = NoMetadata() as? Meta {
+            meta = metaVal
+        } else {
+            meta = try container.decode(Meta.self, forKey: .meta)
+        }
+    }
 
-	public func encode(to encoder: Encoder) throws {
-		var container = encoder.container(keyedBy: CodingKeys.self)
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
 
-		try container.encode(version, forKey: .version)
+        try container.encode(version, forKey: .version)
 
-		if Meta.self != NoMetadata.self {
-			try container.encode(meta, forKey: .meta)
-		}
-	}
+        if Meta.self != NoMetadata.self {
+            try container.encode(meta, forKey: .meta)
+        }
+    }
 }

Sources/JSONAPI/Document/DocumentDecodingError.swift

@@ -0,0 +1,11 @@
+//
+//  DocumentDecodingErro.swift
+//  
+//
+//  Created by Mathew Polzin on 10/20/19.
+//
+
+public enum JSONAPIDocumentDecodingError: Swift.Error {
+    case foundErrorDocumentWhenExpectingSuccess
+    case foundSuccessDocumentWhenExpectingError
+}

Sources/JSONAPI/Document/Includes.swift

@@ -14,35 +14,35 @@ public typealias Include = EncodableJSONPoly
 ///
 /// If you have
 ///
-/// `let includes: Includes<Include2<Thing1, Thing2>> = ...`
+///     let includes: Includes<Include2<Thing1, Thing2>> = ...
 ///
 /// then you can access all `Thing1` included resources with
 ///
-/// `let includedThings = includes[Thing1.self]`
+///     let includedThings = includes[Thing1.self]
 public struct Includes<I: Include>: Encodable, Equatable {
-	public static var none: Includes { return .init(values: []) }
-	
-	let values: [I]
-	
-	public init(values: [I]) {
-		self.values = values
-	}
+    public static var none: Includes { return .init(values: []) }
 
-	public func encode(to encoder: Encoder) throws {
-		var container = encoder.unkeyedContainer()
+    public let values: [I]
 
-		guard I.self != NoIncludes.self else {
-			throw JSONAPIEncodingError.illegalEncoding("Attempting to encode Include0, which should be represented by the absense of an 'included' entry altogether.")
-		}
+    public init(values: [I]) {
+        self.values = values
+    }
 
-		for value in values {
-			try container.encode(value)
-		}
-	}
-	
-	public var count: Int {
-		return values.count
-	}
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.unkeyedContainer()
+
+        guard I.self != NoIncludes.self else {
+            throw JSONAPIEncodingError.illegalEncoding("Attempting to encode Include0, which should be represented by the absense of an 'included' entry altogether.")
+        }
+
+        for value in values {
+            try container.encode(value)
+        }
+    }
+
+    public var count: Int {
+        return values.count
+    }
 }
 
 extension Includes: Decodable where I: Decodable {
@@ -65,25 +65,25 @@ extension Includes: Decodable where I: Decodable {
 }
 
 extension Includes {
-	public func appending(_ other: Includes<I>) -> Includes {
-		return Includes(values: values + other.values)
-	}
+    public func appending(_ other: Includes<I>) -> Includes {
+        return Includes(values: values + other.values)
+    }
 }
 
 public func +<I: Include>(_ left: Includes<I>, _ right: Includes<I>) -> Includes<I> {
-	return left.appending(right)
+    return left.appending(right)
 }
 
 extension Includes: CustomStringConvertible {
-	public var description: String {
-		return "Includes(\(String(describing: values))"
-	}
+    public var description: String {
+        return "Includes(\(String(describing: values))"
+    }
 }
 
 extension Includes where I == NoIncludes {
-	public init() {
-		values = []
-	}
+    public init() {
+        values = []
+    }
 }
 
 // MARK: - 0 includes
@@ -93,73 +93,73 @@ public typealias NoIncludes = Include0
 // MARK: - 1 include
 public typealias Include1 = Poly1
 extension Includes where I: _Poly1 {
-	public subscript(_ lookup: I.A.Type) -> [I.A] {
-		return values.compactMap { $0.a }
-	}
+    public subscript(_ lookup: I.A.Type) -> [I.A] {
+        return values.compactMap { $0.a }
+    }
 }
 
 // MARK: - 2 includes
 public typealias Include2 = Poly2
 extension Includes where I: _Poly2 {
-	public subscript(_ lookup: I.B.Type) -> [I.B] {
-		return values.compactMap { $0.b }
-	}
+    public subscript(_ lookup: I.B.Type) -> [I.B] {
+        return values.compactMap { $0.b }
+    }
 }
 
 // MARK: - 3 includes
 public typealias Include3 = Poly3
 extension Includes where I: _Poly3 {
-	public subscript(_ lookup: I.C.Type) -> [I.C] {
-		return values.compactMap { $0.c }
-	}
+    public subscript(_ lookup: I.C.Type) -> [I.C] {
+        return values.compactMap { $0.c }
+    }
 }
 
 // MARK: - 4 includes
 public typealias Include4 = Poly4
 extension Includes where I: _Poly4 {
-	public subscript(_ lookup: I.D.Type) -> [I.D] {
-		return values.compactMap { $0.d }
-	}
+    public subscript(_ lookup: I.D.Type) -> [I.D] {
+        return values.compactMap { $0.d }
+    }
 }
 
 // MARK: - 5 includes
 public typealias Include5 = Poly5
 extension Includes where I: _Poly5 {
-	public subscript(_ lookup: I.E.Type) -> [I.E] {
-		return values.compactMap { $0.e }
-	}
+    public subscript(_ lookup: I.E.Type) -> [I.E] {
+        return values.compactMap { $0.e }
+    }
 }
 
 // MARK: - 6 includes
 public typealias Include6 = Poly6
 extension Includes where I: _Poly6 {
-	public subscript(_ lookup: I.F.Type) -> [I.F] {
-		return values.compactMap { $0.f }
-	}
+    public subscript(_ lookup: I.F.Type) -> [I.F] {
+        return values.compactMap { $0.f }
+    }
 }
 
 // MARK: - 7 includes
 public typealias Include7 = Poly7
 extension Includes where I: _Poly7 {
-	public subscript(_ lookup: I.G.Type) -> [I.G] {
-		return values.compactMap { $0.g }
-	}
+    public subscript(_ lookup: I.G.Type) -> [I.G] {
+        return values.compactMap { $0.g }
+    }
 }
 
 // MARK: - 8 includes
 public typealias Include8 = Poly8
 extension Includes where I: _Poly8 {
-	public subscript(_ lookup: I.H.Type) -> [I.H] {
-		return values.compactMap { $0.h }
-	}
+    public subscript(_ lookup: I.H.Type) -> [I.H] {
+        return values.compactMap { $0.h }
+    }
 }
 
 // MARK: - 9 includes
 public typealias Include9 = Poly9
 extension Includes where I: _Poly9 {
-	public subscript(_ lookup: I.I.Type) -> [I.I] {
-		return values.compactMap { $0.i }
-	}
+    public subscript(_ lookup: I.I.Type) -> [I.I] {
+        return values.compactMap { $0.i }
+    }
 }
 
 // MARK: - 10 includes

Sources/JSONAPI/Document/ResourceBody.swift

@@ -10,121 +10,123 @@
 /// array should be used for no results).
 public protocol OptionalEncodablePrimaryResource: Equatable, Encodable {}
 
-/// An `EncodablePrimaryResource` is a `PrimaryResource` that only supports encoding.
-/// This is actually more restrictave than `PrimaryResource`, which supports both encoding and
-/// decoding.
+/// An `EncodablePrimaryResource` is a `CodablePrimaryResource` that only supports encoding.
 public protocol EncodablePrimaryResource: OptionalEncodablePrimaryResource {}
 
 /// This protocol allows for `SingleResourceBody` to contain a `null`
 /// data object where `ManyResourceBody` cannot (because an empty
 /// array should be used for no results).
-public protocol OptionalPrimaryResource: OptionalEncodablePrimaryResource, Decodable {}
+public protocol OptionalCodablePrimaryResource: OptionalEncodablePrimaryResource, Decodable {}
 
-/// A `PrimaryResource` is a type that can be used in the body of a JSON API
+/// A `CodablePrimaryResource` is a type that can be used in the body of a JSON API
 /// document as the primary resource.
-public protocol PrimaryResource: EncodablePrimaryResource, OptionalPrimaryResource {}
+public protocol CodablePrimaryResource: EncodablePrimaryResource, OptionalCodablePrimaryResource {}
 
 extension Optional: OptionalEncodablePrimaryResource where Wrapped: EncodablePrimaryResource {}
 
-extension Optional: OptionalPrimaryResource where Wrapped: PrimaryResource {}
+extension Optional: OptionalCodablePrimaryResource where Wrapped: CodablePrimaryResource {}
 
 /// An `EncodableResourceBody` is a `ResourceBody` that only supports being
 /// encoded. It is actually weaker than `ResourceBody`, which supports both encoding
 /// and decoding.
-public protocol EncodableResourceBody: Equatable, Encodable {}
+public protocol EncodableResourceBody: Equatable, Encodable {
+    associatedtype PrimaryResource
+}
 
-/// A ResourceBody is a representation of the body of the JSON API Document.
+/// A `CodableResourceBody` is a representation of the body of the JSON:API Document.
 /// It can either be one resource (which can be specified as optional or not)
 /// or it can contain many resources (and array with zero or more entries).
-public protocol ResourceBody: Decodable, EncodableResourceBody {}
+public protocol CodableResourceBody: Decodable, EncodableResourceBody {}
 
 /// A `ResourceBody` that has the ability to take on more primary
 /// resources by appending another similarly typed `ResourceBody`.
-public protocol Appendable {
-	func appending(_ other: Self) -> Self
+public protocol ResourceBodyAppendable {
+    func appending(_ other: Self) -> Self
 }
 
-public func +<R: Appendable>(_ left: R, right: R) -> R {
-	return left.appending(right)
+public func +<R: ResourceBodyAppendable>(_ left: R, right: R) -> R {
+    return left.appending(right)
 }
 
 /// A type allowing for a document body containing 1 primary resource.
 /// If the `Entity` specialization is an `Optional` type, the body can contain
 /// 0 or 1 primary resources.
-public struct SingleResourceBody<Entity: JSONAPI.OptionalEncodablePrimaryResource>: EncodableResourceBody {
-	public let value: Entity
+public struct SingleResourceBody<PrimaryResource: JSONAPI.OptionalEncodablePrimaryResource>: EncodableResourceBody {
+    public let value: PrimaryResource
 
-	public init(resourceObject: Entity) {
-		self.value = resourceObject
-	}
+    public init(resourceObject: PrimaryResource) {
+        self.value = resourceObject
+    }
 }
 
 /// A type allowing for a document body containing 0 or more primary resources.
-public struct ManyResourceBody<Entity: JSONAPI.EncodablePrimaryResource>: EncodableResourceBody, Appendable {
-	public let values: [Entity]
+public struct ManyResourceBody<PrimaryResource: JSONAPI.EncodablePrimaryResource>: EncodableResourceBody, ResourceBodyAppendable {
+    public let values: [PrimaryResource]
 
-	public init(resourceObjects: [Entity]) {
-		values = resourceObjects
-	}
+    public init(resourceObjects: [PrimaryResource]) {
+        values = resourceObjects
+    }
 
-	public func appending(_ other: ManyResourceBody) -> ManyResourceBody {
-		return ManyResourceBody(resourceObjects: values + other.values)
-	}
+    public func appending(_ other: ManyResourceBody) -> ManyResourceBody {
+        return ManyResourceBody(resourceObjects: values + other.values)
+    }
 }
 
 /// Use NoResourceBody to indicate you expect a JSON API document to not
 /// contain a "data" top-level key.
-public struct NoResourceBody: ResourceBody {
-	public static var none: NoResourceBody { return NoResourceBody() }
+public struct NoResourceBody: CodableResourceBody {
+    public typealias PrimaryResource = Void
+
+    public static var none: NoResourceBody { return NoResourceBody() }
 }
 
 // MARK: Codable
 extension SingleResourceBody {
-	public func encode(to encoder: Encoder) throws {
-		var container = encoder.singleValueContainer()
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
 
         let anyNil: Any? = nil
-        let nilValue = anyNil as? Entity
+        let nilValue = anyNil as? PrimaryResource
         guard value != nilValue else {
             try container.encodeNil()
             return
         }
 
-		try container.encode(value)
-	}
+        try container.encode(value)
+    }
 }
 
-extension SingleResourceBody: Decodable, ResourceBody where Entity: OptionalPrimaryResource {
+extension SingleResourceBody: Decodable, CodableResourceBody where PrimaryResource: OptionalCodablePrimaryResource {
     public init(from decoder: Decoder) throws {
         let container = try decoder.singleValueContainer()
 
         let anyNil: Any? = nil
         if container.decodeNil(),
-            let val = anyNil as? Entity {
+            let val = anyNil as? PrimaryResource {
             value = val
             return
         }
 
-        value = try container.decode(Entity.self)
+        value = try container.decode(PrimaryResource.self)
     }
 }
 
 extension ManyResourceBody {
-	public func encode(to encoder: Encoder) throws {
-		var container = encoder.unkeyedContainer()
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.unkeyedContainer()
 
-		for value in values {
-			try container.encode(value)
-		}
-	}
+        for value in values {
+            try container.encode(value)
+        }
+    }
 }
 
-extension ManyResourceBody: Decodable, ResourceBody where Entity: PrimaryResource {
+extension ManyResourceBody: Decodable, CodableResourceBody where PrimaryResource: CodablePrimaryResource {
     public init(from decoder: Decoder) throws {
         var container = try decoder.unkeyedContainer()
-        var valueAggregator = [Entity]()
+        var valueAggregator = [PrimaryResource]()
         while !container.isAtEnd {
-            valueAggregator.append(try container.decode(Entity.self))
+            valueAggregator.append(try container.decode(PrimaryResource.self))
         }
         values = valueAggregator
     }
@@ -133,13 +135,13 @@ extension ManyResourceBody: Decodable, ResourceBody where Entity: PrimaryResourc
 // MARK: CustomStringConvertible
 
 extension SingleResourceBody: CustomStringConvertible {
-	public var description: String {
-		return "PrimaryResourceBody(\(String(describing: value)))"
-	}
+    public var description: String {
+        return "PrimaryResourceBody(\(String(describing: value)))"
+    }
 }
 
 extension ManyResourceBody: CustomStringConvertible {
-	public var description: String {
-		return "PrimaryResourceBody(\(String(describing: values)))"
-	}
+    public var description: String {
+        return "PrimaryResourceBody(\(String(describing: values)))"
+    }
 }

Sources/JSONAPI/EncodingError.swift

@@ -6,9 +6,9 @@
 //
 
 public enum JSONAPIEncodingError: Swift.Error {
-	case typeMismatch(expected: String, found: String)
-	case illegalEncoding(String)
-	case illegalDecoding(String)
-	case missingOrMalformedMetadata
-	case missingOrMalformedLinks
+    case typeMismatch(expected: String, found: String)
+    case illegalEncoding(String)
+    case illegalDecoding(String)
+    case missingOrMalformedMetadata
+    case missingOrMalformedLinks
 }

Sources/JSONAPI/Error/BasicJSONAPIError.swift

@@ -6,10 +6,12 @@
 //
 
 /// Most of the JSON:API Spec defined Error fields.
-public struct BasicJSONAPIErrorPayload<IdType: Codable & Equatable>: Codable, Equatable, ErrorDictType {
+public struct BasicJSONAPIErrorPayload<IdType: Codable & Equatable>: Codable, Equatable, ErrorDictType, CustomStringConvertible {
     /// a unique identifier for this particular occurrence of the problem
     public let id: IdType?
-//    public let links: Links? // we skip this for now to avoid adding complexity to using this basic type.
+
+    //    public let links: Links? // we skip this for now to avoid adding complexity to using this basic type.
+
     /// the HTTP status code applicable to this problem
     public let status: String?
     /// an application-specific error code
@@ -20,7 +22,8 @@ public struct BasicJSONAPIErrorPayload<IdType: Codable & Equatable>: Codable, Eq
     public let detail: String?
     /// an object containing references to the source of the error
     public let source: Source?
-//    public let meta: Meta? // we skip this for now to avoid adding complexity to using this basic type
+
+    //    public let meta: Meta? // we skip this for now to avoid adding complexity to using this basic type
 
     public init(id: IdType? = nil,
                 status: String? = nil,
@@ -61,6 +64,10 @@ public struct BasicJSONAPIErrorPayload<IdType: Codable & Equatable>: Codable, Eq
             ].compactMap { $0 }
         return Dictionary(uniqueKeysWithValues: keysAndValues)
     }
+
+    public var description: String {
+        return definedFields.map { "\($0.key): \($0.value)" }.sorted().joined(separator: ", ")
+    }
 }
 
 /// `BasicJSONAPIError` optionally decodes many possible fields

Sources/JSONAPI/Error/GenericJSONAPIError.swift

@@ -8,7 +8,7 @@
 /// `GenericJSONAPIError` can be used to specify whatever error
 /// payload you expect to need to parse in responses and handle any
 /// other payload structure as `.unknownError`.
-public enum GenericJSONAPIError<ErrorPayload: Codable & Equatable>: JSONAPIError {
+public enum GenericJSONAPIError<ErrorPayload: Codable & Equatable>: JSONAPIError, CustomStringConvertible {
     case unknownError
     case error(ErrorPayload)
 
@@ -35,6 +35,15 @@ public enum GenericJSONAPIError<ErrorPayload: Codable & Equatable>: JSONAPIError
     public static var unknown: Self {
         return .unknownError
     }
+
+    public var description: String {
+        switch self {
+        case .unknownError:
+            return "unknown error"
+        case .error(let payload):
+            return String(describing: payload)
+        }
+    }
 }
 
 public extension GenericJSONAPIError {

Sources/JSONAPI/Error/JSONAPIError.swift

@@ -6,7 +6,7 @@
 //
 
 public protocol JSONAPIError: Swift.Error, Equatable, Codable {
-	static var unknown: Self { get }
+    static var unknown: Self { get }
 }
 
 /// `UnknownJSONAPIError` can actually be used in any sitaution
@@ -16,18 +16,18 @@ public protocol JSONAPIError: Swift.Error, Equatable, Codable {
 /// information the server might be providing in the error payload,
 /// use `BasicJSONAPIError` instead.
 public enum UnknownJSONAPIError: JSONAPIError {
-	case unknownError
-	
-	public init(from decoder: Decoder) throws {
-		self = .unknown
-	}
+    case unknownError
 
-	public func encode(to encoder: Encoder) throws {
-		var container = encoder.singleValueContainer()
-		try container.encode("unknown")
-	}
-	
-	public static var unknown: Self {
-		return .unknownError
-	}
+    public init(from decoder: Decoder) throws {
+        self = .unknown
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+        try container.encode("unknown")
+    }
+
+    public static var unknown: Self {
+        return .unknownError
+    }
 }

Sources/JSONAPI/Meta/Links.swift

@@ -10,58 +10,58 @@ public protocol Links: Codable, Equatable {}
 
 /// Use NoLinks where no links should belong to a JSON API component
 public struct NoLinks: Links, CustomStringConvertible {
-	public static var none: NoLinks { return NoLinks() }
-	public init() {}
-
-	public var description: String { return "No Links" }
+    public static var none: NoLinks { return NoLinks() }
+    public init() {}
+    
+    public var description: String { return "No Links" }
 }
 
 public protocol JSONAPIURL: Codable, Equatable {}
 
 public struct Link<URL: JSONAPI.JSONAPIURL, Meta: JSONAPI.Meta>: Equatable, Codable {
-	public let url: URL
-	public let meta: Meta
-
-	public init(url: URL, meta: Meta) {
-		self.url = url
-		self.meta = meta
-	}
+    public let url: URL
+    public let meta: Meta
+    
+    public init(url: URL, meta: Meta) {
+        self.url = url
+        self.meta = meta
+    }
 }
 
 extension Link where Meta == NoMetadata {
-	public init(url: URL) {
-		self.init(url: url, meta: .none)
-	}
+    public init(url: URL) {
+        self.init(url: url, meta: .none)
+    }
 }
 
 public extension Link {
-	private enum CodingKeys: String, CodingKey {
-		case href
-		case meta
-	}
-
-	init(from decoder: Decoder) throws {
-		guard Meta.self == NoMetadata.self,
-			let noMeta = NoMetadata() as? Meta else {
-				let container = try decoder.container(keyedBy: CodingKeys.self)
-				meta = try container.decode(Meta.self, forKey: .meta)
-				url = try container.decode(URL.self, forKey: .href)
-				return
-		}
-		let container = try decoder.singleValueContainer()
-		url = try container.decode(URL.self)
-		meta = noMeta
-	}
-
-	func encode(to encoder: Encoder) throws {
-		guard Meta.self == NoMetadata.self else {
-			var container = encoder.container(keyedBy: CodingKeys.self)
-			try container.encode(url, forKey: .href)
-			try container.encode(meta, forKey: .meta)
-			return
-		}
-		var container = encoder.singleValueContainer()
-
-		try container.encode(url)
-	}
+    private enum CodingKeys: String, CodingKey {
+        case href
+        case meta
+    }
+    
+    init(from decoder: Decoder) throws {
+        guard Meta.self == NoMetadata.self,
+            let noMeta = NoMetadata() as? Meta else {
+                let container = try decoder.container(keyedBy: CodingKeys.self)
+                meta = try container.decode(Meta.self, forKey: .meta)
+                url = try container.decode(URL.self, forKey: .href)
+                return
+        }
+        let container = try decoder.singleValueContainer()
+        url = try container.decode(URL.self)
+        meta = noMeta
+    }
+    
+    func encode(to encoder: Encoder) throws {
+        guard Meta.self == NoMetadata.self else {
+            var container = encoder.container(keyedBy: CodingKeys.self)
+            try container.encode(url, forKey: .href)
+            try container.encode(meta, forKey: .meta)
+            return
+        }
+        var container = encoder.singleValueContainer()
+        
+        try container.encode(url)
+    }
 }

Sources/JSONAPI/Meta/Meta.swift

@@ -6,25 +6,25 @@
 //
 
 /// Conform a type to this protocol to indicate it can be encoded to or decoded from
-/// the meta data attached to a component of a JSON API document. Different meta data
+/// the meta data attached to a component of a JSON:API document. Different meta data
 /// can be stored all over the place: On the root document, on a resource object, on
 /// link objects, etc.
 ///
-/// JSON API Metadata is totally open ended. It can take whatever JSON-compliant structure
+/// JSON:API Metadata is totally open ended. It can take whatever JSON-compliant structure
 /// the server and client agree upon.
 public protocol Meta: Codable, Equatable {
 }
 
-// We make Optional a Meta if it wraps a Meta so that Metadata can be specified as
-// nullable.
+// We make Optional a Meta if it wraps a Meta so that
+// Metadata can be specified as nullable.
 extension Optional: Meta where Wrapped: Meta {}
 
 /// Use this type when you want to specify not to encode or decode any metadata
 /// for a type.
 public struct NoMetadata: Meta, CustomStringConvertible {
-	public static var none: NoMetadata { return NoMetadata() }
+    public static var none: NoMetadata { return NoMetadata() }
 
-	public init() { }
+    public init() { }
 
-	public var description: String { return "No Metadata" }
+    public var description: String { return "No Metadata" }
 }

Sources/JSONAPI/Resource/Attribute+Functor.swift

@@ -6,31 +6,31 @@
 //
 
 public extension TransformedAttribute {
-	/// Map an Attribute to a new wrapped type.
-	/// Note that the resulting Attribute will have no transformer, even if the
-	/// source Attribute has a transformer.
-	/// You are mapping the output of the source transform into
-	/// the RawValue of a new transformerless Attribute.
-	///
-	/// Generally, this is the most useful operation. The transformer gives you
-	/// control over the decoding of the Attribute, but once the Attribute exists,
-	/// mapping on it is most useful for creating computed Attribute properties.
-	func map<T: Codable>(_ transform: (Transformer.To) throws -> T) rethrows -> Attribute<T> {
-		return Attribute<T>(value: try transform(value))
-	}
+    /// Map an Attribute to a new wrapped type.
+    /// Note that the resulting Attribute will have no transformer, even if the
+    /// source Attribute has a transformer.
+    /// You are mapping the output of the source transform into
+    /// the RawValue of a new transformerless Attribute.
+    ///
+    /// Generally, this is the most useful operation. The transformer gives you
+    /// control over the decoding of the Attribute, but once the Attribute exists,
+    /// mapping on it is most useful for creating computed Attribute properties.
+    func map<T: Codable>(_ transform: (Transformer.To) throws -> T) rethrows -> Attribute<T> {
+        return Attribute<T>(value: try transform(value))
+    }
 }
 
 public extension Attribute {
-	/// Map an Attribute to a new wrapped type.
-	/// Note that the resulting Attribute will have no transformer, even if the
-	/// source Attribute has a transformer.
-	/// You are mapping the output of the source transform into
-	/// the RawValue of a new transformerless Attribute.
-	///
-	/// Generally, this is the most useful operation. The transformer gives you
-	/// control over the decoding of the Attribute, but once the Attribute exists,
-	/// mapping on it is most useful for creating computed Attribute properties.
-	func map<T: Codable>(_ transform: (ValueType) throws -> T) rethrows -> Attribute<T> {
-		return Attribute<T>(value: try transform(value))
-	}
+    /// Map an Attribute to a new wrapped type.
+    /// Note that the resulting Attribute will have no transformer, even if the
+    /// source Attribute has a transformer.
+    /// You are mapping the output of the source transform into
+    /// the RawValue of a new transformerless Attribute.
+    ///
+    /// Generally, this is the most useful operation. The transformer gives you
+    /// control over the decoding of the Attribute, but once the Attribute exists,
+    /// mapping on it is most useful for creating computed Attribute properties.
+    func map<T: Codable>(_ transform: (ValueType) throws -> T) rethrows -> Attribute<T> {
+        return Attribute<T>(value: try transform(value))
+    }
 }

Sources/JSONAPI/Resource/Attribute.swift

@@ -6,49 +6,49 @@
 //
 
 public protocol AttributeType: Codable {
-	associatedtype RawValue: Codable
-	associatedtype ValueType
+    associatedtype RawValue: Codable
+    associatedtype ValueType
 
-	var value: ValueType { get }
+    var value: ValueType { get }
 }
 
 // MARK: TransformedAttribute
 
 /// A TransformedAttribute takes a Codable type and attempts to turn it into another type.
 public struct TransformedAttribute<RawValue: Codable, Transformer: JSONAPI.Transformer>: AttributeType where Transformer.From == RawValue {
-	public let rawValue: RawValue
+    public let rawValue: RawValue
 
-	public let value: Transformer.To
+    public let value: Transformer.To
 
-	public init(rawValue: RawValue) throws {
-		self.rawValue = rawValue
-		value = try Transformer.transform(rawValue)
-	}
+    public init(rawValue: RawValue) throws {
+        self.rawValue = rawValue
+        value = try Transformer.transform(rawValue)
+    }
 }
 
 extension TransformedAttribute where Transformer == IdentityTransformer<RawValue> {
-	// If we are using the identity transform, we can skip the transform and guarantee no
-	// error is thrown.
-	public init(value: RawValue) {
-		rawValue = value
-		self.value = value
-	}
+    // If we are using the identity transform, we can skip the transform and guarantee no
+    // error is thrown.
+    public init(value: RawValue) {
+        rawValue = value
+        self.value = value
+    }
 }
 
 extension TransformedAttribute where Transformer: ReversibleTransformer {
-	/// Initialize a TransformedAttribute from its transformed value. The
-	/// RawValue, which is what gets encoded/decoded, is determined using
-	/// The Transformer's reverse function.
-	public init(transformedValue: Transformer.To) throws {
-		self.value = transformedValue
-		rawValue = try Transformer.reverse(value)
-	}
+    /// Initialize a TransformedAttribute from its transformed value. The
+    /// RawValue, which is what gets encoded/decoded, is determined using
+    /// The Transformer's reverse function.
+    public init(transformedValue: Transformer.To) throws {
+        self.value = transformedValue
+        rawValue = try Transformer.reverse(value)
+    }
 }
 
 extension TransformedAttribute: CustomStringConvertible {
-	public var description: String {
-		return "Attribute<\(String(describing: Transformer.From.self)) -> \(String(describing: Transformer.To.self))>(\(String(describing: value)))"
-	}
+    public var description: String {
+        return "Attribute<\(String(describing: Transformer.From.self)) -> \(String(describing: Transformer.To.self))>(\(String(describing: value)))"
+    }
 }
 
 extension TransformedAttribute: Equatable where Transformer.From: Equatable, Transformer.To: Equatable {}
@@ -63,85 +63,86 @@ public typealias ValidatedAttribute<RawValue: Codable, Validator: JSONAPI.Valida
 
 /// An Attribute simply represents a type that can be encoded and decoded.
 public struct Attribute<RawValue: Codable>: AttributeType {
-	let attribute: TransformedAttribute<RawValue, IdentityTransformer<RawValue>>
+    let attribute: TransformedAttribute<RawValue, IdentityTransformer<RawValue>>
 
-	public var value: RawValue {
-		return attribute.value
-	}
+    public var value: RawValue {
+        return attribute.value
+    }
 
-	public init(value: RawValue) {
-		attribute = .init(value: value)
-	}
+    public init(value: RawValue) {
+        attribute = .init(value: value)
+    }
 }
 
 extension Attribute: CustomStringConvertible {
-	public var description: String {
-		return "Attribute<\(String(describing: RawValue.self))>(\(String(describing: value)))"
-	}
+    public var description: String {
+        return "Attribute<\(String(describing: RawValue.self))>(\(String(describing: value)))"
+    }
 }
 
 extension Attribute: Equatable where RawValue: Equatable {}
 
 // MARK: - Codable
 extension TransformedAttribute {
-	public init(from decoder: Decoder) throws {
-		let container = try decoder.singleValueContainer()
-		
-		let rawVal: RawValue
-		
-		// A little trickery follows. If the value is nil, the
-		// container.decode(Value.self) will fail even if Value
-		// is Optional. However, we can check if decoding nil
-		// succeeds and then attempt to coerce nil to a Value
-		// type at which point we can store nil in `value`.
-		let anyNil: Any? = nil
-		if container.decodeNil(),
-			let val = anyNil as? Transformer.From {
-				rawVal = val
-		} else {
-			rawVal = try container.decode(Transformer.From.self)
-		}
-		
-		rawValue = rawVal
-		value = try Transformer.transform(rawVal)
-	}
-	
-	public func encode(to encoder: Encoder) throws {
-		var container = encoder.singleValueContainer()
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
 
-		try container.encode(rawValue)
-	}
+        let rawVal: RawValue
+
+        // A little trickery follows. If the value is nil, the
+        // container.decode(Value.self) will fail even if Value
+        // is Optional. However, we can check if decoding nil
+        // succeeds and then attempt to coerce nil to a Value
+        // type at which point we can store nil in `value`.
+        let anyNil: Any? = nil
+        if container.decodeNil(),
+            let val = anyNil as? Transformer.From {
+            rawVal = val
+        } else {
+            rawVal = try container.decode(Transformer.From.self)
+        }
+
+        rawValue = rawVal
+        value = try Transformer.transform(rawVal)
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+
+        try container.encode(rawValue)
+    }
 }
 
 extension Attribute {
-	public init(from decoder: Decoder) throws {
-		let container = try decoder.singleValueContainer()
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
 
-		// A little trickery follows. If the value is nil, the
-		// container.decode(Value.self) will fail even if Value
-		// is Optional. However, we can check if decoding nil
-		// succeeds and then attempt to coerce nil to a Value
-		// type at which point we can store nil in `value`.
-		let anyNil: Any? = nil
-		if container.decodeNil(),
-			let val = anyNil as? RawValue {
-			attribute = .init(value: val)
-		} else {
-			attribute = try container.decode(TransformedAttribute<RawValue, IdentityTransformer<RawValue>>.self)
-		}
-	}
+        // A little trickery follows. If the value is nil, the
+        // container.decode(Value.self) will fail even if Value
+        // is Optional. However, we can check if decoding nil
+        // succeeds and then attempt to coerce nil to a Value
+        // type at which point we can store nil in `value`.
+        let anyNil: Any? = nil
+        if container.decodeNil(),
+            let val = anyNil as? RawValue {
+            attribute = .init(value: val)
+        } else {
+            attribute = try container.decode(TransformedAttribute<RawValue, IdentityTransformer<RawValue>>.self)
+        }
+    }
 
-	public func encode(to encoder: Encoder) throws {
-		var container = encoder.singleValueContainer()
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
 
-		try container.encode(attribute)
-	}
+        try container.encode(attribute)
+    }
 }
 
 // MARK: Attribute decoding and encoding defaults
 
 extension AttributeType {
-	public static func defaultDecoding<Container: KeyedDecodingContainerProtocol>(from container: Container, forKey key: Container.Key) throws -> Self {
-		return try container.decode(Self.self, forKey: key)
-	}
+    public static func defaultDecoding<Container: KeyedDecodingContainerProtocol>(from container: Container,
+                                                                                  forKey key: Container.Key) throws -> Self {
+        return try container.decode(Self.self, forKey: key)
+    }
 }

Sources/JSONAPI/Resource/Id.swift

@@ -23,7 +23,7 @@ public protocol RawIdType: MaybeRawId, Hashable {}
 /// Conformances for `String` and `UUID`
 /// are given in the README for this library.
 public protocol CreatableRawIdType: RawIdType {
-	static func unique() -> Self
+    static func unique() -> Self
 }
 
 extension String: RawIdType {}
@@ -32,80 +32,80 @@ extension String: RawIdType {}
 /// have an Id (most likely because it was created by a client and the server will be responsible
 /// for assigning it an Id).
 public struct Unidentified: MaybeRawId, CustomStringConvertible {
-	public init() {}
-	
-	public var description: String { return "Unidentified" }
+    public init() {}
+
+    public var description: String { return "Unidentified" }
 }
 
 public protocol OptionalId: Codable {
-	associatedtype IdentifiableType: JSONAPI.JSONTyped
-	associatedtype RawType: MaybeRawId
+    associatedtype IdentifiableType: JSONAPI.JSONTyped
+    associatedtype RawType: MaybeRawId
 
-	var rawValue: RawType { get }
-	init(rawValue: RawType)
+    var rawValue: RawType { get }
+    init(rawValue: RawType)
 }
 
 public protocol IdType: OptionalId, CustomStringConvertible, Hashable where RawType: RawIdType {}
 
 extension Optional: MaybeRawId where Wrapped: Codable & Equatable {}
 extension Optional: OptionalId where Wrapped: IdType {
-	public typealias IdentifiableType = Wrapped.IdentifiableType
-	public typealias RawType = Wrapped.RawType?
+    public typealias IdentifiableType = Wrapped.IdentifiableType
+    public typealias RawType = Wrapped.RawType?
 
-	public var rawValue: Wrapped.RawType? {
-		guard case .some(let value) = self else {
-			return nil
-		}
-		return value.rawValue
-	}
+    public var rawValue: Wrapped.RawType? {
+        guard case .some(let value) = self else {
+            return nil
+        }
+        return value.rawValue
+    }
 
-	public init(rawValue: Wrapped.RawType?) {
-		self = rawValue.map { Wrapped(rawValue: $0) }
-	}
+    public init(rawValue: Wrapped.RawType?) {
+        self = rawValue.map { Wrapped(rawValue: $0) }
+    }
 }
 
 public extension IdType {
-	var description: String { return "Id(\(String(describing: rawValue)))" }
+    var description: String { return "Id(\(String(describing: rawValue)))" }
 }
 
 public protocol CreatableIdType: IdType {
-	init()
+    init()
 }
 
 /// An ResourceObject ID. These IDs can be encoded to or decoded from
 /// JSON API IDs.
 public struct Id<RawType: MaybeRawId, IdentifiableType: JSONAPI.JSONTyped>: Equatable, OptionalId {
 
-	public let rawValue: RawType
-	
-	public init(rawValue: RawType) {
-		self.rawValue = rawValue
-	}
+    public let rawValue: RawType
 
-	public init(from decoder: Decoder) throws {
-		let container = try decoder.singleValueContainer()
-		let rawValue = try container.decode(RawType.self)
-		self.init(rawValue: rawValue)
-	}
+    public init(rawValue: RawType) {
+        self.rawValue = rawValue
+    }
 
-	public func encode(to encoder: Encoder) throws {
-		var container = encoder.singleValueContainer()
-		try container.encode(rawValue)
-	}
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        let rawValue = try container.decode(RawType.self)
+        self.init(rawValue: rawValue)
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+        try container.encode(rawValue)
+    }
 }
 
 extension Id: Hashable, CustomStringConvertible, IdType where RawType: RawIdType {
-	public static func id(from rawValue: RawType) -> Id<RawType, IdentifiableType> {
-		return Id(rawValue: rawValue)
-	}
+    public static func id(from rawValue: RawType) -> Id<RawType, IdentifiableType> {
+        return Id(rawValue: rawValue)
+    }
 }
 
 extension Id: CreatableIdType where RawType: CreatableRawIdType {
-	public init() {
-		rawValue = .unique()
-	}
+    public init() {
+        rawValue = .unique()
+    }
 }
 
 extension Id where RawType == Unidentified {
-	public static var unidentified: Id { return .init(rawValue: Unidentified()) }
+    public static var unidentified: Id { return .init(rawValue: Unidentified()) }
 }

Sources/JSONAPI/Resource/Poly+PrimaryResource.swift

@@ -18,69 +18,147 @@ import Poly
 public typealias EncodableJSONPoly = Poly & EncodablePrimaryResource
 
 public typealias EncodablePolyWrapped = Encodable & Equatable
-public typealias PolyWrapped = EncodablePolyWrapped & Decodable
+public typealias CodablePolyWrapped = EncodablePolyWrapped & Decodable
 
-extension Poly0: PrimaryResource {
-	public init(from decoder: Decoder) throws {
-		throw JSONAPIEncodingError.illegalDecoding("Attempted to decode Poly0, which should represent a thing that is not expected to be found in a document.")
-	}
+extension Poly0: CodablePrimaryResource {
+    public init(from decoder: Decoder) throws {
+        throw JSONAPIEncodingError.illegalDecoding("Attempted to decode Poly0, which should represent a thing that is not expected to be found in a document.")
+    }
 
-	public func encode(to encoder: Encoder) throws {
-		throw JSONAPIEncodingError.illegalEncoding("Attempted to encode Poly0, which should represent a thing that is not expected to be found in a document.")
-	}
+    public func encode(to encoder: Encoder) throws {
+        throw JSONAPIEncodingError.illegalEncoding("Attempted to encode Poly0, which should represent a thing that is not expected to be found in a document.")
+    }
 }
 
 // MARK: - 1 type
-extension Poly1: EncodablePrimaryResource, OptionalEncodablePrimaryResource where A: EncodablePolyWrapped {}
+extension Poly1: EncodablePrimaryResource, OptionalEncodablePrimaryResource
+    where A: EncodablePolyWrapped {}
 
-extension Poly1: PrimaryResource, OptionalPrimaryResource where A: PolyWrapped {}
+extension Poly1: CodablePrimaryResource, OptionalCodablePrimaryResource
+    where A: CodablePolyWrapped {}
 
 // MARK: - 2 types
-extension Poly2: EncodablePrimaryResource, OptionalEncodablePrimaryResource where A: EncodablePolyWrapped, B: EncodablePolyWrapped {}
+extension Poly2: EncodablePrimaryResource, OptionalEncodablePrimaryResource
+    where A: EncodablePolyWrapped, B: EncodablePolyWrapped {}
 
-extension Poly2: PrimaryResource, OptionalPrimaryResource where A: PolyWrapped, B: PolyWrapped {}
+extension Poly2: CodablePrimaryResource, OptionalCodablePrimaryResource
+    where A: CodablePolyWrapped, B: CodablePolyWrapped {}
 
 // MARK: - 3 types
-extension Poly3: EncodablePrimaryResource, OptionalEncodablePrimaryResource where A: EncodablePolyWrapped, B: EncodablePolyWrapped, C: EncodablePolyWrapped {}
+extension Poly3: EncodablePrimaryResource, OptionalEncodablePrimaryResource
+    where A: EncodablePolyWrapped, B: EncodablePolyWrapped, C: EncodablePolyWrapped {}
 
-extension Poly3: PrimaryResource, OptionalPrimaryResource where A: PolyWrapped, B: PolyWrapped, C: PolyWrapped {}
+extension Poly3: CodablePrimaryResource, OptionalCodablePrimaryResource
+    where A: CodablePolyWrapped, B: CodablePolyWrapped, C: CodablePolyWrapped {}
 
 // MARK: - 4 types
-extension Poly4: EncodablePrimaryResource, OptionalEncodablePrimaryResource where A: EncodablePolyWrapped, B: EncodablePolyWrapped, C: EncodablePolyWrapped, D: EncodablePolyWrapped {}
+extension Poly4: EncodablePrimaryResource, OptionalEncodablePrimaryResource
+    where A: EncodablePolyWrapped, B: EncodablePolyWrapped, C: EncodablePolyWrapped, D: EncodablePolyWrapped {}
 
-extension Poly4: PrimaryResource, OptionalPrimaryResource where A: PolyWrapped, B: PolyWrapped, C: PolyWrapped, D: PolyWrapped {}
+extension Poly4: CodablePrimaryResource, OptionalCodablePrimaryResource
+    where A: CodablePolyWrapped, B: CodablePolyWrapped, C: CodablePolyWrapped, D: CodablePolyWrapped {}
 
 // MARK: - 5 types
-extension Poly5: EncodablePrimaryResource, OptionalEncodablePrimaryResource where A: EncodablePolyWrapped, B: EncodablePolyWrapped, C: EncodablePolyWrapped, D: EncodablePolyWrapped, E: EncodablePolyWrapped {}
+extension Poly5: EncodablePrimaryResource, OptionalEncodablePrimaryResource
+    where A: EncodablePolyWrapped, B: EncodablePolyWrapped, C: EncodablePolyWrapped, D: EncodablePolyWrapped, E: EncodablePolyWrapped {}
 
-extension Poly5: PrimaryResource, OptionalPrimaryResource where A: PolyWrapped, B: PolyWrapped, C: PolyWrapped, D: PolyWrapped, E: PolyWrapped {}
+extension Poly5: CodablePrimaryResource, OptionalCodablePrimaryResource
+    where A: CodablePolyWrapped, B: CodablePolyWrapped, C: CodablePolyWrapped, D: CodablePolyWrapped, E: CodablePolyWrapped {}
 
 // MARK: - 6 types
-extension Poly6: EncodablePrimaryResource, OptionalEncodablePrimaryResource where A: EncodablePolyWrapped, B: EncodablePolyWrapped, C: EncodablePolyWrapped, D: EncodablePolyWrapped, E: EncodablePolyWrapped, F: EncodablePolyWrapped {}
+extension Poly6: EncodablePrimaryResource, OptionalEncodablePrimaryResource
+    where A: EncodablePolyWrapped, B: EncodablePolyWrapped, C: EncodablePolyWrapped, D: EncodablePolyWrapped, E: EncodablePolyWrapped, F: EncodablePolyWrapped {}
 
-extension Poly6: PrimaryResource, OptionalPrimaryResource where A: PolyWrapped, B: PolyWrapped, C: PolyWrapped, D: PolyWrapped, E: PolyWrapped, F: PolyWrapped {}
+extension Poly6: CodablePrimaryResource, OptionalCodablePrimaryResource
+    where A: CodablePolyWrapped, B: CodablePolyWrapped, C: CodablePolyWrapped, D: CodablePolyWrapped, E: CodablePolyWrapped, F: CodablePolyWrapped {}
 
 // MARK: - 7 types
-extension Poly7: EncodablePrimaryResource, OptionalEncodablePrimaryResource where A: EncodablePolyWrapped, B: EncodablePolyWrapped, C: EncodablePolyWrapped, D: EncodablePolyWrapped, E: EncodablePolyWrapped, F: EncodablePolyWrapped, G: EncodablePolyWrapped {}
+extension Poly7: EncodablePrimaryResource, OptionalEncodablePrimaryResource
+    where
+        A: EncodablePolyWrapped,
+        B: EncodablePolyWrapped,
+        C: EncodablePolyWrapped,
+        D: EncodablePolyWrapped,
+        E: EncodablePolyWrapped,
+        F: EncodablePolyWrapped,
+        G: EncodablePolyWrapped {}
 
-extension Poly7: PrimaryResource, OptionalPrimaryResource where A: PolyWrapped, B: PolyWrapped, C: PolyWrapped, D: PolyWrapped, E: PolyWrapped, F: PolyWrapped, G: PolyWrapped {}
+extension Poly7: CodablePrimaryResource, OptionalCodablePrimaryResource
+    where A: CodablePolyWrapped, B: CodablePolyWrapped, C: CodablePolyWrapped, D: CodablePolyWrapped, E: CodablePolyWrapped, F: CodablePolyWrapped, G: CodablePolyWrapped {}
 
 // MARK: - 8 types
-extension Poly8: EncodablePrimaryResource, OptionalEncodablePrimaryResource where A: EncodablePolyWrapped, B: EncodablePolyWrapped, C: EncodablePolyWrapped, D: EncodablePolyWrapped, E: EncodablePolyWrapped, F: EncodablePolyWrapped, G: EncodablePolyWrapped, H: EncodablePolyWrapped {}
+extension Poly8: EncodablePrimaryResource, OptionalEncodablePrimaryResource
+    where
+        A: EncodablePolyWrapped,
+        B: EncodablePolyWrapped,
+        C: EncodablePolyWrapped,
+        D: EncodablePolyWrapped,
+        E: EncodablePolyWrapped,
+        F: EncodablePolyWrapped,
+        G: EncodablePolyWrapped,
+        H: EncodablePolyWrapped {}
 
-extension Poly8: PrimaryResource, OptionalPrimaryResource where A: PolyWrapped, B: PolyWrapped, C: PolyWrapped, D: PolyWrapped, E: PolyWrapped, F: PolyWrapped, G: PolyWrapped, H: PolyWrapped {}
+extension Poly8: CodablePrimaryResource, OptionalCodablePrimaryResource
+    where A: CodablePolyWrapped, B: CodablePolyWrapped, C: CodablePolyWrapped, D: CodablePolyWrapped, E: CodablePolyWrapped, F: CodablePolyWrapped, G: CodablePolyWrapped, H: CodablePolyWrapped {}
 
 // MARK: - 9 types
-extension Poly9: EncodablePrimaryResource, OptionalEncodablePrimaryResource where A: EncodablePolyWrapped, B: EncodablePolyWrapped, C: EncodablePolyWrapped, D: EncodablePolyWrapped, E: EncodablePolyWrapped, F: EncodablePolyWrapped, G: EncodablePolyWrapped, H: EncodablePolyWrapped, I: EncodablePolyWrapped {}
+extension Poly9: EncodablePrimaryResource, OptionalEncodablePrimaryResource
+    where
+        A: EncodablePolyWrapped,
+        B: EncodablePolyWrapped,
+        C: EncodablePolyWrapped,
+        D: EncodablePolyWrapped,
+        E: EncodablePolyWrapped,
+        F: EncodablePolyWrapped,
+        G: EncodablePolyWrapped,
+        H: EncodablePolyWrapped,
+        I: EncodablePolyWrapped {}
 
-extension Poly9: PrimaryResource, OptionalPrimaryResource where A: PolyWrapped, B: PolyWrapped, C: PolyWrapped, D: PolyWrapped, E: PolyWrapped, F: PolyWrapped, G: PolyWrapped, H: PolyWrapped, I: PolyWrapped {}
+extension Poly9: CodablePrimaryResource, OptionalCodablePrimaryResource
+    where A: CodablePolyWrapped, B: CodablePolyWrapped, C: CodablePolyWrapped, D: CodablePolyWrapped, E: CodablePolyWrapped, F: CodablePolyWrapped, G: CodablePolyWrapped, H: CodablePolyWrapped, I: CodablePolyWrapped {}
 
 // MARK: - 10 types
-extension Poly10: EncodablePrimaryResource, OptionalEncodablePrimaryResource where A: EncodablePolyWrapped, B: EncodablePolyWrapped, C: EncodablePolyWrapped, D: EncodablePolyWrapped, E: EncodablePolyWrapped, F: EncodablePolyWrapped, G: EncodablePolyWrapped, H: EncodablePolyWrapped, I: EncodablePolyWrapped, J: EncodablePolyWrapped {}
+extension Poly10: EncodablePrimaryResource, OptionalEncodablePrimaryResource
+    where
+        A: EncodablePolyWrapped,
+        B: EncodablePolyWrapped,
+        C: EncodablePolyWrapped,
+        D: EncodablePolyWrapped,
+        E: EncodablePolyWrapped,
+        F: EncodablePolyWrapped,
+        G: EncodablePolyWrapped,
+        H: EncodablePolyWrapped,
+        I: EncodablePolyWrapped,
+        J: EncodablePolyWrapped {}
 
-extension Poly10: PrimaryResource, OptionalPrimaryResource where A: PolyWrapped, B: PolyWrapped, C: PolyWrapped, D: PolyWrapped, E: PolyWrapped, F: PolyWrapped, G: PolyWrapped, H: PolyWrapped, I: PolyWrapped, J: PolyWrapped {}
+extension Poly10: CodablePrimaryResource, OptionalCodablePrimaryResource
+    where A: CodablePolyWrapped, B: CodablePolyWrapped, C: CodablePolyWrapped, D: CodablePolyWrapped, E: CodablePolyWrapped, F: CodablePolyWrapped, G: CodablePolyWrapped, H: CodablePolyWrapped, I: CodablePolyWrapped, J: CodablePolyWrapped {}
 
 // MARK: - 11 types
-extension Poly11: EncodablePrimaryResource, OptionalEncodablePrimaryResource where A: EncodablePolyWrapped, B: EncodablePolyWrapped, C: EncodablePolyWrapped, D: EncodablePolyWrapped, E: EncodablePolyWrapped, F: EncodablePolyWrapped, G: EncodablePolyWrapped, H: EncodablePolyWrapped, I: EncodablePolyWrapped, J: EncodablePolyWrapped, K: EncodablePolyWrapped {}
+extension Poly11: EncodablePrimaryResource, OptionalEncodablePrimaryResource
+    where
+        A: EncodablePolyWrapped,
+        B: EncodablePolyWrapped,
+        C: EncodablePolyWrapped,
+        D: EncodablePolyWrapped,
+        E: EncodablePolyWrapped,
+        F: EncodablePolyWrapped,
+        G: EncodablePolyWrapped,
+        H: EncodablePolyWrapped,
+        I: EncodablePolyWrapped,
+        J: EncodablePolyWrapped,
+        K: EncodablePolyWrapped {}
 
-extension Poly11: PrimaryResource, OptionalPrimaryResource where A: PolyWrapped, B: PolyWrapped, C: PolyWrapped, D: PolyWrapped, E: PolyWrapped, F: PolyWrapped, G: PolyWrapped, H: PolyWrapped, I: PolyWrapped, J: PolyWrapped, K: PolyWrapped {}
+extension Poly11: CodablePrimaryResource, OptionalCodablePrimaryResource
+    where
+        A: CodablePolyWrapped,
+        B: CodablePolyWrapped,
+        C: CodablePolyWrapped,
+        D: CodablePolyWrapped,
+        E: CodablePolyWrapped,
+        F: CodablePolyWrapped,
+        G: CodablePolyWrapped,
+        H: CodablePolyWrapped,
+        I: CodablePolyWrapped,
+        J: CodablePolyWrapped,
+        K: CodablePolyWrapped {}

Sources/JSONAPI/Resource/Relationship.swift

@@ -6,11 +6,11 @@
 //
 
 public protocol RelationshipType {
-	associatedtype LinksType
-	associatedtype MetaType
+    associatedtype LinksType
+    associatedtype MetaType
 
-	var links: LinksType { get }
-	var meta: MetaType { get }
+    var links: LinksType { get }
+    var meta: MetaType { get }
 }
 
 /// An ResourceObject relationship that can be encoded to or decoded from
@@ -19,46 +19,46 @@ public protocol RelationshipType {
 /// A convenient typealias might make your code much more legible: `One<ResourceObjectDescription>`
 public struct ToOneRelationship<Identifiable: JSONAPI.Identifiable, MetaType: JSONAPI.Meta, LinksType: JSONAPI.Links>: RelationshipType, Equatable {
 
-	public let id: Identifiable.Identifier
+    public let id: Identifiable.Identifier
 
-	public let meta: MetaType
-	public let links: LinksType
+    public let meta: MetaType
+    public let links: LinksType
 
-	public init(id: Identifiable.Identifier, meta: MetaType, links: LinksType) {
-		self.id = id
-		self.meta = meta
-		self.links = links
-	}
+    public init(id: Identifiable.Identifier, meta: MetaType, links: LinksType) {
+        self.id = id
+        self.meta = meta
+        self.links = links
+    }
 }
 
 extension ToOneRelationship where MetaType == NoMetadata, LinksType == NoLinks {
-	public init(id: Identifiable.Identifier) {
-		self.init(id: id, meta: .none, links: .none)
-	}
+    public init(id: Identifiable.Identifier) {
+        self.init(id: id, meta: .none, links: .none)
+    }
 }
 
 extension ToOneRelationship {
-	public init<T: ResourceObjectType>(resourceObject: T, meta: MetaType, links: LinksType) where T.Id == Identifiable.Identifier {
-		self.init(id: resourceObject.id, meta: meta, links: links)
-	}
+    public init<T: ResourceObjectType>(resourceObject: T, meta: MetaType, links: LinksType) where T.Id == Identifiable.Identifier {
+        self.init(id: resourceObject.id, meta: meta, links: links)
+    }
 }
 
 extension ToOneRelationship where MetaType == NoMetadata, LinksType == NoLinks {
-	public init<T: ResourceObjectType>(resourceObject: T) where T.Id == Identifiable.Identifier {
-		self.init(id: resourceObject.id, meta: .none, links: .none)
-	}
+    public init<T: ResourceObjectType>(resourceObject: T) where T.Id == Identifiable.Identifier {
+        self.init(id: resourceObject.id, meta: .none, links: .none)
+    }
 }
 
 extension ToOneRelationship where Identifiable: OptionalRelatable {
-	public init<T: ResourceObjectType>(resourceObject: T?, meta: MetaType, links: LinksType) where T.Id == Identifiable.Wrapped.Identifier {
-		self.init(id: resourceObject?.id, meta: meta, links: links)
-	}
+    public init<T: ResourceObjectType>(resourceObject: T?, meta: MetaType, links: LinksType) where T.Id == Identifiable.Wrapped.Identifier {
+        self.init(id: resourceObject?.id, meta: meta, links: links)
+    }
 }
 
 extension ToOneRelationship where Identifiable: OptionalRelatable, MetaType == NoMetadata, LinksType == NoLinks {
-	public init<T: ResourceObjectType>(resourceObject: T?) where T.Id == Identifiable.Wrapped.Identifier {
-		self.init(id: resourceObject?.id, meta: .none, links: .none)
-	}
+    public init<T: ResourceObjectType>(resourceObject: T?) where T.Id == Identifiable.Wrapped.Identifier {
+        self.init(id: resourceObject?.id, meta: .none, links: .none)
+    }
 }
 
 /// An ResourceObject relationship that can be encoded to or decoded from
@@ -67,57 +67,57 @@ extension ToOneRelationship where Identifiable: OptionalRelatable, MetaType == N
 /// A convenient typealias might make your code much more legible: `Many<ResourceObjectDescription>`
 public struct ToManyRelationship<Relatable: JSONAPI.Relatable, MetaType: JSONAPI.Meta, LinksType: JSONAPI.Links>: RelationshipType, Equatable {
 
-	public let ids: [Relatable.Identifier]
+    public let ids: [Relatable.Identifier]
 
-	public let meta: MetaType
-	public let links: LinksType
+    public let meta: MetaType
+    public let links: LinksType
 
-	public init(ids: [Relatable.Identifier], meta: MetaType, links: LinksType) {
-		self.ids = ids
-		self.meta = meta
-		self.links = links
-	}
+    public init(ids: [Relatable.Identifier], meta: MetaType, links: LinksType) {
+        self.ids = ids
+        self.meta = meta
+        self.links = links
+    }
 
-	public init<T: JSONAPI.Identifiable>(pointers: [ToOneRelationship<T, NoMetadata, NoLinks>], meta: MetaType, links: LinksType) where T.Identifier == Relatable.Identifier {
-		ids = pointers.map { $0.id }
-		self.meta = meta
-		self.links = links
-	}
+    public init<T: JSONAPI.Identifiable>(pointers: [ToOneRelationship<T, NoMetadata, NoLinks>], meta: MetaType, links: LinksType) where T.Identifier == Relatable.Identifier {
+        ids = pointers.map { $0.id }
+        self.meta = meta
+        self.links = links
+    }
 
-	public init<T: ResourceObjectType>(resourceObjects: [T], meta: MetaType, links: LinksType) where T.Id == Relatable.Identifier {
-		self.init(ids: resourceObjects.map { $0.id }, meta: meta, links: links)
-	}
+    public init<T: ResourceObjectType>(resourceObjects: [T], meta: MetaType, links: LinksType) where T.Id == Relatable.Identifier {
+        self.init(ids: resourceObjects.map { $0.id }, meta: meta, links: links)
+    }
 
-	private init(meta: MetaType, links: LinksType) {
-		self.init(ids: [], meta: meta, links: links)
-	}
+    private init(meta: MetaType, links: LinksType) {
+        self.init(ids: [], meta: meta, links: links)
+    }
 
-	public static func none(withMeta meta: MetaType, links: LinksType) -> ToManyRelationship {
-		return ToManyRelationship(meta: meta, links: links)
-	}
+    public static func none(withMeta meta: MetaType, links: LinksType) -> ToManyRelationship {
+        return ToManyRelationship(meta: meta, links: links)
+    }
 }
 
 extension ToManyRelationship where MetaType == NoMetadata, LinksType == NoLinks {
 
-	public init(ids: [Relatable.Identifier]) {
-		self.init(ids: ids, meta: .none, links: .none)
-	}
+    public init(ids: [Relatable.Identifier]) {
+        self.init(ids: ids, meta: .none, links: .none)
+    }
 
-	public init<T: JSONAPI.Identifiable>(pointers: [ToOneRelationship<T, NoMetadata, NoLinks>]) where T.Identifier == Relatable.Identifier {
-		self.init(pointers: pointers, meta: .none, links: .none)
-	}
+    public init<T: JSONAPI.Identifiable>(pointers: [ToOneRelationship<T, NoMetadata, NoLinks>]) where T.Identifier == Relatable.Identifier {
+        self.init(pointers: pointers, meta: .none, links: .none)
+    }
 
-	public static var none: ToManyRelationship {
-		return .none(withMeta: .none, links: .none)
-	}
+    public static var none: ToManyRelationship {
+        return .none(withMeta: .none, links: .none)
+    }
 
-	public init<T: ResourceObjectType>(resourceObjects: [T]) where T.Id == Relatable.Identifier {
-		self.init(resourceObjects: resourceObjects, meta: .none, links: .none)
-	}
+    public init<T: ResourceObjectType>(resourceObjects: [T]) where T.Id == Relatable.Identifier {
+        self.init(resourceObjects: resourceObjects, meta: .none, links: .none)
+    }
 }
 
 public protocol Identifiable: JSONTyped {
-	associatedtype Identifier: Equatable
+    associatedtype Identifier: Equatable
 }
 
 /// The Relatable protocol describes anything that
@@ -128,152 +128,152 @@ public protocol Relatable: Identifiable where Identifier: JSONAPI.IdType {
 /// OptionalRelatable just describes an Optional
 /// with a Reltable Wrapped type.
 public protocol OptionalRelatable: Identifiable where Identifier == Wrapped.Identifier? {
-	associatedtype Wrapped: JSONAPI.Relatable
+    associatedtype Wrapped: JSONAPI.Relatable
 }
 
 extension Optional: Identifiable, OptionalRelatable, JSONTyped where Wrapped: JSONAPI.Relatable {
-	public typealias Identifier = Wrapped.Identifier?
+    public typealias Identifier = Wrapped.Identifier?
 
-	public static var jsonType: String { return Wrapped.jsonType }
+    public static var jsonType: String { return Wrapped.jsonType }
 }
 
 // MARK: Codable
 private enum ResourceLinkageCodingKeys: String, CodingKey {
-	case data = "data"
-	case meta = "meta"
-	case links = "links"
+    case data = "data"
+    case meta = "meta"
+    case links = "links"
 }
 private enum ResourceIdentifierCodingKeys: String, CodingKey {
-	case id = "id"
-	case entityType = "type"
+    case id = "id"
+    case entityType = "type"
 }
 
 extension ToOneRelationship: Codable where Identifiable.Identifier: OptionalId {
-	public init(from decoder: Decoder) throws {
-		let container = try decoder.container(keyedBy: ResourceLinkageCodingKeys.self)
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: ResourceLinkageCodingKeys.self)
 
-		if let noMeta = NoMetadata() as? MetaType {
-			meta = noMeta
-		} else {
-			meta = try container.decode(MetaType.self, forKey: .meta)
-		}
+        if let noMeta = NoMetadata() as? MetaType {
+            meta = noMeta
+        } else {
+            meta = try container.decode(MetaType.self, forKey: .meta)
+        }
 
-		if let noLinks = NoLinks() as? LinksType {
-			links = noLinks
-		} else {
-			links = try container.decode(LinksType.self, forKey: .links)
-		}
+        if let noLinks = NoLinks() as? LinksType {
+            links = noLinks
+        } else {
+            links = try container.decode(LinksType.self, forKey: .links)
+        }
 
-		// A little trickery follows. If the id is nil, the
-		// container.decode(Identifier.self) will fail even if Identifier
-		// is Optional. However, we can check if decoding nil
-		// succeeds and then attempt to coerce nil to a Identifier
-		// type at which point we can store nil in `id`.
-		let anyNil: Any? = nil
-		if try container.decodeNil(forKey: .data),
-			let val = anyNil as? Identifiable.Identifier {
-			id = val
-			return
-		}
+        // A little trickery follows. If the id is nil, the
+        // container.decode(Identifier.self) will fail even if Identifier
+        // is Optional. However, we can check if decoding nil
+        // succeeds and then attempt to coerce nil to a Identifier
+        // type at which point we can store nil in `id`.
+        let anyNil: Any? = nil
+        if try container.decodeNil(forKey: .data),
+            let val = anyNil as? Identifiable.Identifier {
+            id = val
+            return
+        }
 
-		let identifier = try container.nestedContainer(keyedBy: ResourceIdentifierCodingKeys.self, forKey: .data)
-		
-		let type = try identifier.decode(String.self, forKey: .entityType)
-		
-		guard type == Identifiable.jsonType else {
-			throw JSONAPIEncodingError.typeMismatch(expected: Identifiable.jsonType, found: type)
-		}
-		
-		id = Identifiable.Identifier(rawValue: try identifier.decode(Identifiable.Identifier.RawType.self, forKey: .id))
-	}
-	
-	public func encode(to encoder: Encoder) throws {
-		var container = encoder.container(keyedBy: ResourceLinkageCodingKeys.self)
+        let identifier = try container.nestedContainer(keyedBy: ResourceIdentifierCodingKeys.self, forKey: .data)
 
-		if MetaType.self != NoMetadata.self {
-			try container.encode(meta, forKey: .meta)
-		}
+        let type = try identifier.decode(String.self, forKey: .entityType)
 
-		if LinksType.self != NoLinks.self {
-			try container.encode(links, forKey: .links)
-		}
+        guard type == Identifiable.jsonType else {
+            throw JSONAPIEncodingError.typeMismatch(expected: Identifiable.jsonType, found: type)
+        }
 
-		// If id is nil, instead of {id: , type: } we will just
-		// encode `null`
-		let anyNil: Any? = nil
-		let nilId = anyNil as? Identifiable.Identifier
-		guard id != nilId else {
-			try container.encodeNil(forKey: .data)
-			return
-		}
+        id = Identifiable.Identifier(rawValue: try identifier.decode(Identifiable.Identifier.RawType.self, forKey: .id))
+    }
 
-		var identifier = container.nestedContainer(keyedBy: ResourceIdentifierCodingKeys.self, forKey: .data)
-		
-		try identifier.encode(id.rawValue, forKey: .id)
-		try identifier.encode(Identifiable.jsonType, forKey: .entityType)
-	}
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: ResourceLinkageCodingKeys.self)
+
+        if MetaType.self != NoMetadata.self {
+            try container.encode(meta, forKey: .meta)
+        }
+
+        if LinksType.self != NoLinks.self {
+            try container.encode(links, forKey: .links)
+        }
+
+        // If id is nil, instead of {id: , type: } we will just
+        // encode `null`
+        let anyNil: Any? = nil
+        let nilId = anyNil as? Identifiable.Identifier
+        guard id != nilId else {
+            try container.encodeNil(forKey: .data)
+            return
+        }
+
+        var identifier = container.nestedContainer(keyedBy: ResourceIdentifierCodingKeys.self, forKey: .data)
+
+        try identifier.encode(id.rawValue, forKey: .id)
+        try identifier.encode(Identifiable.jsonType, forKey: .entityType)
+    }
 }
 
 extension ToManyRelationship: Codable {
-	public init(from decoder: Decoder) throws {
-		let container = try decoder.container(keyedBy: ResourceLinkageCodingKeys.self)
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: ResourceLinkageCodingKeys.self)
 
-		if let noMeta = NoMetadata() as? MetaType {
-			meta = noMeta
-		} else {
-			meta = try container.decode(MetaType.self, forKey: .meta)
-		}
+        if let noMeta = NoMetadata() as? MetaType {
+            meta = noMeta
+        } else {
+            meta = try container.decode(MetaType.self, forKey: .meta)
+        }
 
-		if let noLinks = NoLinks() as? LinksType {
-			links = noLinks
-		} else {
-			links = try container.decode(LinksType.self, forKey: .links)
-		}
+        if let noLinks = NoLinks() as? LinksType {
+            links = noLinks
+        } else {
+            links = try container.decode(LinksType.self, forKey: .links)
+        }
 
-		var identifiers = try container.nestedUnkeyedContainer(forKey: .data)
-		
-		var newIds = [Relatable.Identifier]()
-		while !identifiers.isAtEnd {
-			let identifier = try identifiers.nestedContainer(keyedBy: ResourceIdentifierCodingKeys.self)
-			
-			let type = try identifier.decode(String.self, forKey: .entityType)
-			
-			guard type == Relatable.jsonType else {
-				throw JSONAPIEncodingError.typeMismatch(expected: Relatable.jsonType, found: type)
-			}
-			
-			newIds.append(Relatable.Identifier(rawValue: try identifier.decode(Relatable.Identifier.RawType.self, forKey: .id)))
-		}
-		ids = newIds
-	}
-	
-	public func encode(to encoder: Encoder) throws {
-		var container = encoder.container(keyedBy: ResourceLinkageCodingKeys.self)
+        var identifiers = try container.nestedUnkeyedContainer(forKey: .data)
 
-		if MetaType.self != NoMetadata.self {
-			try container.encode(meta, forKey: .meta)
-		}
+        var newIds = [Relatable.Identifier]()
+        while !identifiers.isAtEnd {
+            let identifier = try identifiers.nestedContainer(keyedBy: ResourceIdentifierCodingKeys.self)
 
-		if LinksType.self != NoLinks.self {
-			try container.encode(links, forKey: .links)
-		}
+            let type = try identifier.decode(String.self, forKey: .entityType)
 
-		var identifiers = container.nestedUnkeyedContainer(forKey: .data)
-		
-		for id in ids {
-			var identifier = identifiers.nestedContainer(keyedBy: ResourceIdentifierCodingKeys.self)
-			
-			try identifier.encode(id.rawValue, forKey: .id)
-			try identifier.encode(Relatable.jsonType, forKey: .entityType)
-		}
-	}
+            guard type == Relatable.jsonType else {
+                throw JSONAPIEncodingError.typeMismatch(expected: Relatable.jsonType, found: type)
+            }
+
+            newIds.append(Relatable.Identifier(rawValue: try identifier.decode(Relatable.Identifier.RawType.self, forKey: .id)))
+        }
+        ids = newIds
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: ResourceLinkageCodingKeys.self)
+
+        if MetaType.self != NoMetadata.self {
+            try container.encode(meta, forKey: .meta)
+        }
+
+        if LinksType.self != NoLinks.self {
+            try container.encode(links, forKey: .links)
+        }
+
+        var identifiers = container.nestedUnkeyedContainer(forKey: .data)
+
+        for id in ids {
+            var identifier = identifiers.nestedContainer(keyedBy: ResourceIdentifierCodingKeys.self)
+
+            try identifier.encode(id.rawValue, forKey: .id)
+            try identifier.encode(Relatable.jsonType, forKey: .entityType)
+        }
+    }
 }
 
 // MARK: CustomStringDescribable
 extension ToOneRelationship: CustomStringConvertible {
-	public var description: String { return "Relationship(\(String(describing: id)))" }
+    public var description: String { return "Relationship(\(String(describing: id)))" }
 }
 
 extension ToManyRelationship: CustomStringConvertible {
-	public var description: String { return "Relationship([\(ids.map(String.init(describing:)).joined(separator: ", "))])" }
+    public var description: String { return "Relationship([\(ids.map(String.init(describing:)).joined(separator: ", "))])" }
 }