update swift tools version in package file, add some property wrappers, add some tests for wrappers. its all broken but worth holding onto for now.

JSONAPI.playground/Pages/Full Client & Server Example.xcplaygroundpage/Contents.swift

@@ -4,66 +4,65 @@ import Poly
 
 // MARK: - Preamble (setup)
 
-// Make String a CreatableRawIdType. This is actually done in
+// We make String a CreatableRawIdType. This is actually done in
 // this Playground's Entities.swift file, so it is commented out here.
 /*
- var globalStringId: Int = 0
- extension String: CreatableRawIdType {
- public static func unique() -> String {
- globalStringId += 1
- return String(globalStringId)
- }
- }
- */
+var GlobalStringId: Int = 0
+extension String: CreatableRawIdType {
+	public static func unique() -> String {
+		GlobalStringId += 1
+		return String(GlobalStringId)
+	}
+}
+*/
 
-// Create a typealias because we do not expect JSON:API Resource
+// We create a typealias given that we do not expect JSON:API Resource
 // Objects for this particular API to have Metadata or Links associated
 // with them. We also expect them to have String Identifiers.
 typealias JSONEntity<Description: ResourceObjectDescription> = JSONAPI.ResourceObject<Description, NoMetadata, NoLinks, String>
 
-// Similarly, create a typealias for unidentified entities. JSON:API
+// Similarly, we create a typealias for unidentified entities. JSON:API
 // only allows unidentified entities (i.e. no "id" field) for client
 // requests that create new entities. In these situations, the server
 // is expected to assign the new entity a unique ID.
 typealias UnidentifiedJSONEntity<Description: ResourceObjectDescription> = JSONAPI.ResourceObject<Description, NoMetadata, NoLinks, Unidentified>
 
-// Create relationship typealiases because we do not expect
-// JSON:API Relationships for this particular API to have
-// Metadata or Links associated with them.
+// We create typealiases given that we do not expect JSON:API Relationships
+// for this particular API to have Metadata or Links associated
+// with them.
 typealias ToOneRelationship<Entity: Identifiable> = JSONAPI.ToOneRelationship<Entity, NoMetadata, NoLinks>
 typealias ToManyRelationship<Entity: Relatable> = JSONAPI.ToManyRelationship<Entity, NoMetadata, NoLinks>
 
-// Create a typealias for a Document because we do not expect
+// We create a typealias for a Document given that we do not expect
 // JSON:API Documents for this particular API to have Metadata, Links,
-// useful Errors, or an APIDescription (The *SPEC* calls this
-// "API Description" the "JSON:API Object").
+// useful Errors, or a JSON:API Object (i.e. APIDescription).
 typealias Document<PrimaryResourceBody: JSONAPI.ResourceBody, IncludeType: JSONAPI.Include> = JSONAPI.Document<PrimaryResourceBody, NoMetadata, NoLinks, IncludeType, NoAPIDescription, UnknownJSONAPIError>
 
 // MARK: Entity Definitions
 
 enum AuthorDescription: ResourceObjectDescription {
-    public static var jsonType: String { return "authors" }
+	public static var jsonType: String { return "authors" }
 
-    public struct Attributes: JSONAPI.Attributes {
-        public let name: Attribute<String>
-    }
+	public struct Attributes: JSONAPI.Attributes {
+		public let name: Attribute<String>
+	}
 
-    public typealias Relationships = NoRelationships
+	public typealias Relationships = NoRelationships
 }
 
 typealias Author = JSONEntity<AuthorDescription>
 
 enum ArticleDescription: ResourceObjectDescription {
-    public static var jsonType: String { return "articles" }
+	public static var jsonType: String { return "articles" }
 
-    public struct Attributes: JSONAPI.Attributes {
-        public let title: Attribute<String>
-        public let abstract: Attribute<String>
-    }
+	public struct Attributes: JSONAPI.Attributes {
+		public let title: Attribute<String>
+		public let abstract: Attribute<String>
+	}
 
-    public struct Relationships: JSONAPI.Relationships {
-        public let author: ToOneRelationship<Author>
-    }
+	public struct Relationships: JSONAPI.Relationships {
+		public let author: ToOneRelationship<Author>
+	}
 }
 
 typealias Article = JSONEntity<ArticleDescription>
@@ -84,38 +83,38 @@ typealias SingleArticleDocument = Document<SingleResourceBody<Article>, NoInclud
 // that creates a document. Note that this document is the entirety
 // of a JSON:API response body.
 func articleDocument(includeAuthor: Bool) -> Either<SingleArticleDocument, SingleArticleDocumentWithIncludes> {
-    // Let's pretend all of this is coming from a database:
+	// Let's pretend all of this is coming from a database:
 
-    let authorId = Author.Identifier(rawValue: "1234")
+	let authorId = Author.Identifier(rawValue: "1234")
 
-    let article = Article(id: .init(rawValue: "5678"),
-                          attributes: .init(title: .init(value: "JSON:API in Swift"),
-                                            abstract: .init(value: "Not yet written")),
-                          relationships: .init(author: .init(id: authorId)),
-                          meta: .none,
-                          links: .none)
+	let article = Article(id: .init(rawValue: "5678"),
+						  attributes: .init(title: .init(value: "JSON:API in Swift"),
+											abstract: .init(value: "Not yet written")),
+						  relationships: .init(author: .init(id: authorId)),
+						  meta: .none,
+						  links: .none)
 
-    let document = SingleArticleDocument(apiDescription: .none,
-                                         body: .init(resourceObject: article),
-                                         includes: .none,
-                                         meta: .none,
-                                         links: .none)
+	let document = SingleArticleDocument(apiDescription: .none,
+										 body: .init(resourceObject: article),
+										 includes: .none,
+										 meta: .none,
+										 links: .none)
 
-    switch includeAuthor {
-    case false:
-        return .init(document)
+	switch includeAuthor {
+	case false:
+		return .a(document)
 
-    case true:
-        let author = Author(id: authorId,
-                            attributes: .init(name: .init(value: "Janice Bluff")),
-                            relationships: .none,
-                            meta: .none,
-                            links: .none)
+	case true:
+		let author = Author(id: authorId,
+							attributes: .init(name: .init(value: "Janice Bluff")),
+							relationships: .none,
+							meta: .none,
+							links: .none)
 
-        let includes: Includes<SingleArticleDocumentWithIncludes.Include> = .init(values: [.init(author)])
+		let includes: Includes<SingleArticleDocumentWithIncludes.Include> = .init(values: [.init(author)])
 
-        return .init(document.including(includes))
-    }
+		return .b(document.including(.init(values: [.init(author)])))
+	}
 }
 
 let encoder = JSONEncoder()
@@ -125,8 +124,8 @@ encoder.outputFormatting = .prettyPrinted
 let responseBody = articleDocument(includeAuthor: true)
 let responseData = try! encoder.encode(responseBody)
 
-// Next step would be setting the HTTP body of a response.
-// We will just print it out instead:
+// Next step would be encoding and setting as the HTTP body of a response.
+// we will just print it out instead:
 print("-----")
 print(String(data: responseData, encoding: .utf8)!)
 
@@ -140,31 +139,31 @@ print(String(data: otherResponseData, encoding: .utf8)!)
 // MARK: - Client Pseudo-example
 
 enum NetworkError: Swift.Error {
-    case serverError
-    case quantityMismatch
+	case serverError
+	case quantityMismatch
 }
 
 // Skipping over all the API stuff, here's a chunk of code that will
 // decode a document. We will assume we have made a request for a
 // single article including the author.
 func docode(articleResponseData: Data) throws -> (article: Article, author: Author) {
-    let decoder = JSONDecoder()
-    decoder.keyDecodingStrategy = .convertFromSnakeCase
+	let decoder = JSONDecoder()
+	decoder.keyDecodingStrategy = .convertFromSnakeCase
 
-    let articleDocument = try decoder.decode(SingleArticleDocumentWithIncludes.self, from: articleResponseData)
+	let articleDocument = try decoder.decode(SingleArticleDocumentWithIncludes.self, from: articleResponseData)
 
-    switch articleDocument.body {
-    case .data(let data):
-        let authors = data.includes[Author.self]
+	switch articleDocument.body {
+	case .data(let data):
+		let authors = data.includes[Author.self]
 
-        guard authors.count == 1 else {
-            throw NetworkError.quantityMismatch
-        }
+		guard authors.count == 1 else {
+			throw NetworkError.quantityMismatch
+		}
 
-        return (article: data.primary.value, author: authors[0])
-    case .errors(let errors, meta: _, links: _):
-        throw NetworkError.serverError
-    }
+		return (article: data.primary.value, author: authors[0])
+	case .errors(let errors, meta: _, links: _):
+		throw NetworkError.serverError
+	}
 }
 
 let response = try! docode(articleResponseData: responseData)

JSONAPI.playground/Pages/Sparse Fieldsets Example.xcplaygroundpage/Contents.swift

@@ -1,72 +0,0 @@
-
-import JSONAPI
-import Foundation
-
-// MARK: - Resource Object
-
-enum ThingWithPropertiesDescription: JSONAPI.ResourceObjectDescription {
-    static let jsonType: String = "thing"
-
-    //
-    // NOTE: `JSONAPI.SparsableAttributes` as opposed to `JSONAPI.Attributes`
-    //
-    struct Attributes: JSONAPI.SparsableAttributes {
-        let stringThing: Attribute<String>
-        let numberThing: Attribute<Double>
-        let boolThing: Attribute<Bool?>
-
-        //
-        // NOTE: Special implementation of `CodingKeys`
-        //
-        enum CodingKeys: String, JSONAPI.SparsableCodingKey {
-            case stringThing
-            case numberThing
-            case boolThing
-        }
-    }
-
-    typealias Relationships = NoRelationships
-}
-
-typealias ThingWithProperties = JSONAPI.ResourceObject<ThingWithPropertiesDescription, NoMetadata, NoLinks, String>
-
-// MARK: - Document
-
-//
-// NOTE: Using `JSONAPI.EncodableResourceBody` which means the document type will be `Encodable` but not `Decodable`.
-//
-typealias Document<PrimaryResourceBody: JSONAPI.EncodableResourceBody, IncludeType: JSONAPI.Include> = JSONAPI.Document<PrimaryResourceBody, NoMetadata, NoLinks, IncludeType, NoAPIDescription, UnknownJSONAPIError>
-
-//
-// NOTE: Using `JSONAPI.EncodablePrimaryResource` which means the `ResourceBody` will be `Encodable` but not `Decodable.
-//
-typealias SingleDocument<T: JSONAPI.EncodablePrimaryResource> = Document<SingleResourceBody<T>, NoIncludes>
-
-// MARK: - Resource Initialization
-
-let resource = ThingWithProperties(id: .init(rawValue: "1234"),
-                                   attributes: .init(stringThing: .init(value: "hello world"),
-                                                     numberThing: .init(value: 10),
-                                                     boolThing: .init(value: nil)),
-                                   relationships: .none,
-                                   meta: .none,
-                                   links: .none)
-//
-// NOTE: Creating a sparse resource that will only encode
-//       the attribute named "stringThing"
-//
-let sparseResource = resource.sparse(with: [.stringThing])
-
-// MARK: - Encoding
-
-let encoder = JSONEncoder()
-
-let sparseResourceDoc = SingleDocument(apiDescription: .none,
-                                       body: .init(resourceObject: sparseResource),
-                                       includes: .none,
-                                       meta: .none,
-                                       links: .none)
-
-let data = try! encoder.encode(sparseResourceDoc)
-
-print(String(data: data, encoding: .utf8)!)

JSONAPI.playground/Pages/Usage.xcplaygroundpage/Contents.swift

@@ -8,7 +8,6 @@ Please enjoy these examples, but allow me the forced casting and the lack of err
 
 ********/
 
-
 // MARK: - Create a request or response body with one Dog in it
 let dogFromCode = try! Dog(name: "Buddy", owner: nil)
 
@@ -16,20 +15,17 @@ let singleDogDocument = SingleDogDocument(apiDescription: .none, body: .init(res
 
 let singleDogData = try! JSONEncoder().encode(singleDogDocument)
 
-
 // MARK: - Parse a request or response body with one Dog in it
 let dogResponse = try! JSONDecoder().decode(SingleDogDocument.self, from: singleDogData)
 let dogFromData = dogResponse.body.primaryResource?.value
 let dogOwner: Person.Identifier? = dogFromData.flatMap { $0 ~> \.owner }
 
-
-// MARK: - Parse a request or response body with one Dog in it using an alternative model
+// MARKL - Parse a request or response body with one Dog in it using an alternative model
 typealias AltSingleDogDocument = JSONAPI.Document<SingleResourceBody<AlternativeDog>, NoMetadata, NoLinks, NoIncludes, NoAPIDescription, UnknownJSONAPIError>
 let altDogResponse = try! JSONDecoder().decode(AltSingleDogDocument.self, from: singleDogData)
 let altDogFromData = altDogResponse.body.primaryResource?.value
 let altDogHuman: Person.Identifier? = altDogFromData.flatMap { $0 ~> \.human }
 
-
 // MARK: - Create a request or response with multiple people and dogs and houses included
 let personIds = [Person.Identifier(), Person.Identifier()]
 let dogs = try! [Dog(name: "Buddy", owner: personIds[0]), Dog(name: "Joy", owner: personIds[0]), Dog(name: "Travis", owner: personIds[1])]
@@ -40,7 +36,6 @@ let includes = dogs.map { BatchPeopleDocument.Include($0) } + houses.map { Batch
 let batchPeopleDocument = BatchPeopleDocument(apiDescription: .none, body: .init(resourceObjects: people), includes: .init(values: includes), meta: .none, links: .none)
 let batchPeopleData = try! JSONEncoder().encode(batchPeopleDocument)
 
-
 // MARK: - Parse a request or response body with multiple people in it and dogs and houses included
 
 let peopleResponse = try! JSONDecoder().decode(BatchPeopleDocument.self, from: batchPeopleData)
@@ -52,7 +47,6 @@ print("-----")
 print(peopleResponse)
 print("-----")
 
-
 // MARK: - Pass successfully parsed body to other parts of the code
 
 /*
@@ -65,7 +59,6 @@ if case let .data(bodyData) = peopleResponse.body {
 }
  */
 
-
 // MARK: - Work in the abstract
 
 func process<T: JSONAPIDocument>(document: T) {

JSONAPI.playground/contents.xcplayground

@@ -5,6 +5,5 @@
         <page name='Usage'/>
         <page name='Full Client &amp; Server Example'/>
         <page name='Full Document Verbose Generation'/>
-        <page name='Sparse Fieldsets Example'/>
     </pages>
 </playground>

JSONAPI.podspec

@@ -16,7 +16,7 @@ Pod::Spec.new do |spec|
   #
 
   spec.name         = "JSONAPI"
-  spec.version      = "1.0.0"
+  spec.version      = "0.30.0"
   spec.summary      = "Swift Codable JSON API framework."
 
   # This description is used to generate tags and improve search results.
@@ -93,7 +93,7 @@ See the JSON API Spec here: https://jsonapi.org/format/
   #  Not including the public_header_files will make all headers public.
   #
 
-  spec.source_files  = "Sources/JSONAPI/**/*.{swift}"
+  spec.source_files  = "Sources", "Sources/**/*.{swift}"
   # spec.exclude_files = "Classes/Exclude"
 
   # spec.public_header_files = "Classes/**/*.h"
@@ -119,6 +119,7 @@ See the JSON API Spec here: https://jsonapi.org/format/
   #  the lib prefix of their name.
   #
 
+  spec.framework  = "Poly"
   # spec.frameworks = "SomeFramework", "AnotherFramework"
 
   # spec.library   = "iconv"

Package.resolved

@@ -6,8 +6,8 @@
         "repositoryURL": "https://github.com/mattpolzin/Poly.git",
         "state": {
           "branch": null,
-          "revision": "38051821d7ef49e590e26e819a2fe447e50be9ff",
-          "version": "2.0.1"
+          "revision": "d24d4c1214dd05f89eb1182a46592856dd0a0645",
+          "version": "2.0.0"
         }
       }
     ]

Package.swift

@@ -18,7 +18,7 @@ let package = Package(
 			targets: ["JSONAPITesting"])
     ],
     dependencies: [
-		.package(url: "https://github.com/mattpolzin/Poly.git", .upToNextMajor(from: "2.0.0")),
+		.package(url: "https://github.com/mattpolzin/Poly.git", from: "2.0.0"),
     ],
     targets: [
         .target(
@@ -34,5 +34,5 @@ let package = Package(
             name: "JSONAPITestingTests",
             dependencies: ["JSONAPI", "JSONAPITesting"])
     ],
-  	swiftLanguageVersions: [.v5]
+  	swiftLanguageVersions: [.version("5.1")]
 )

Sources/JSONAPI/Document/Document.swift

@@ -7,26 +7,19 @@
 
 import Poly
 
-/// An `EncodableJSONAPIDocument` supports encoding but not decoding.
-/// It is actually more restrictive than `JSONAPIDocument` which supports both
-/// encoding and decoding.
-public protocol EncodableJSONAPIDocument: Equatable, Encodable {
-    associatedtype PrimaryResourceBody: JSONAPI.EncodableResourceBody
-    associatedtype MetaType: JSONAPI.Meta
-    associatedtype LinksType: JSONAPI.Links
-    associatedtype IncludeType: JSONAPI.Include
-    associatedtype APIDescription: APIDescriptionType
-    associatedtype Error: JSONAPIError
+public protocol JSONAPIDocument: Codable, Equatable {
+	associatedtype PrimaryResourceBody: JSONAPI.ResourceBody
+	associatedtype MetaType: JSONAPI.Meta
+	associatedtype LinksType: JSONAPI.Links
+	associatedtype IncludeType: JSONAPI.Include
+	associatedtype APIDescription: APIDescriptionType
+	associatedtype Error: JSONAPIError
 
-    typealias Body = Document<PrimaryResourceBody, MetaType, LinksType, IncludeType, APIDescription, Error>.Body
+	typealias Body = Document<PrimaryResourceBody, MetaType, LinksType, IncludeType, APIDescription, Error>.Body
 
-    var body: Body { get }
+	var body: Body { get }
 }
 
-/// A `JSONAPIDocument` supports encoding and decoding of a JSON:API
-/// compliant Document.
-public protocol JSONAPIDocument: EncodableJSONAPIDocument, Decodable where PrimaryResourceBody: JSONAPI.ResourceBody, IncludeType: Decodable {}
-
 /// A JSON API Document represents the entire body
 /// of a JSON API request or the entire body of
 /// a JSON API response.
@@ -34,7 +27,7 @@ public protocol JSONAPIDocument: EncodableJSONAPIDocument, Decodable where Prima
 /// API uses snake case, you will want to use
 /// a conversion such as the one offerred by the
 /// Foundation JSONEncoder/Decoder: `KeyDecodingStrategy`
-public struct Document<PrimaryResourceBody: JSONAPI.EncodableResourceBody, MetaType: JSONAPI.Meta, LinksType: JSONAPI.Links, IncludeType: JSONAPI.Include, APIDescription: APIDescriptionType, Error: JSONAPIError>: EncodableJSONAPIDocument {
+public struct Document<PrimaryResourceBody: JSONAPI.ResourceBody, MetaType: JSONAPI.Meta, LinksType: JSONAPI.Links, IncludeType: JSONAPI.Include, APIDescription: APIDescriptionType, Error: JSONAPIError>: JSONAPIDocument {
 	public typealias Include = IncludeType
 
 	/// The JSON API Spec calls this the JSON:API Object. It contains version
@@ -53,9 +46,7 @@ public struct Document<PrimaryResourceBody: JSONAPI.EncodableResourceBody, MetaT
 		case data(Data)
 
 		public struct Data: Equatable {
-            /// The document's Primary Resource object(s)
 			public let primary: PrimaryResourceBody
-            /// The document's included objects
 			public let includes: Includes<Include>
 			public let meta: MetaType
 			public let links: LinksType
@@ -68,8 +59,6 @@ public struct Document<PrimaryResourceBody: JSONAPI.EncodableResourceBody, MetaT
 			}
 		}
 
-        /// `true` if the document represents one or more errors. `false` if the
-        /// document represents JSON:API data and/or metadata.
 		public var isError: Bool {
 			guard case .errors = self else { return false }
 			return true
@@ -207,7 +196,7 @@ extension Document where IncludeType == NoIncludes, MetaType == NoMetadata, Link
 }
 */
 
-extension Document.Body.Data where PrimaryResourceBody: Appendable {
+extension Document.Body.Data where PrimaryResourceBody: AppendableResourceBody {
 	public func merging(_ other: Document.Body.Data,
 						combiningMetaWith metaMerge: (MetaType, MetaType) -> MetaType,
 						combiningLinksWith linksMerge: (LinksType, LinksType) -> LinksType) -> Document.Body.Data {
@@ -218,7 +207,7 @@ extension Document.Body.Data where PrimaryResourceBody: Appendable {
 	}
 }
 
-extension Document.Body.Data where PrimaryResourceBody: Appendable, MetaType == NoMetadata, LinksType == NoLinks {
+extension Document.Body.Data where PrimaryResourceBody: AppendableResourceBody, MetaType == NoMetadata, LinksType == NoLinks {
 	public func merging(_ other: Document.Body.Data) -> Document.Body.Data {
 		return merging(other,
 					   combiningMetaWith: { _, _ in .none },
@@ -284,6 +273,66 @@ extension Document {
 		case links
 		case jsonapi
 	}
+	
+	public init(from decoder: Decoder) throws {
+		let container = try decoder.container(keyedBy: RootCodingKeys.self)
+
+		if let noData = NoAPIDescription() as? APIDescription {
+			apiDescription = noData
+		} else {
+			apiDescription = try container.decode(APIDescription.self, forKey: .jsonapi)
+		}
+
+		let errors = try container.decodeIfPresent([Error].self, forKey: .errors)
+
+		let meta: MetaType?
+		if let noMeta = NoMetadata() as? MetaType {
+			meta = noMeta
+		} else {
+			do {
+				meta = try container.decode(MetaType.self, forKey: .meta)
+			} catch {
+				meta = nil
+			}
+		}
+
+		let links: LinksType?
+		if let noLinks = NoLinks() as? LinksType {
+			links = noLinks
+		} else {
+			do {
+				links = try container.decode(LinksType.self, forKey: .links)
+			} catch {
+				links = nil
+			}
+		}
+
+		// If there are errors, there cannot be a body. Return errors and any metadata found.
+		if let errors = errors {
+			body = .errors(errors, meta: meta, links: links)
+			return
+		}
+
+		let data: PrimaryResourceBody
+		if let noData = NoResourceBody() as? PrimaryResourceBody {
+			data = noData
+		} else {
+			data = try container.decode(PrimaryResourceBody.self, forKey: .data)
+		}
+
+		let maybeIncludes = try container.decodeIfPresent(Includes<Include>.self, forKey: .included)
+		
+		// TODO come back to this and make robust
+
+		guard let metaVal = meta else {
+			throw JSONAPIEncodingError.missingOrMalformedMetadata
+		}
+		guard let linksVal = links else {
+			throw JSONAPIEncodingError.missingOrMalformedLinks
+		}
+		
+		body = .data(.init(primary: data, includes: maybeIncludes ?? Includes<Include>.none, meta: metaVal, links: linksVal))
+	}
 
 	public func encode(to encoder: Encoder) throws {
 		var container = encoder.container(keyedBy: RootCodingKeys.self)
@@ -328,68 +377,6 @@ extension Document {
 	}
 }
 
-extension Document: Decodable, JSONAPIDocument where PrimaryResourceBody: ResourceBody, IncludeType: Decodable {
-    public init(from decoder: Decoder) throws {
-        let container = try decoder.container(keyedBy: RootCodingKeys.self)
-
-        if let noData = NoAPIDescription() as? APIDescription {
-            apiDescription = noData
-        } else {
-            apiDescription = try container.decode(APIDescription.self, forKey: .jsonapi)
-        }
-
-        let errors = try container.decodeIfPresent([Error].self, forKey: .errors)
-
-        let meta: MetaType?
-        if let noMeta = NoMetadata() as? MetaType {
-            meta = noMeta
-        } else {
-            do {
-                meta = try container.decode(MetaType.self, forKey: .meta)
-            } catch {
-                meta = nil
-            }
-        }
-
-        let links: LinksType?
-        if let noLinks = NoLinks() as? LinksType {
-            links = noLinks
-        } else {
-            do {
-                links = try container.decode(LinksType.self, forKey: .links)
-            } catch {
-                links = nil
-            }
-        }
-
-        // If there are errors, there cannot be a body. Return errors and any metadata found.
-        if let errors = errors {
-            body = .errors(errors, meta: meta, links: links)
-            return
-        }
-
-        let data: PrimaryResourceBody
-        if let noData = NoResourceBody() as? PrimaryResourceBody {
-            data = noData
-        } else {
-            data = try container.decode(PrimaryResourceBody.self, forKey: .data)
-        }
-
-        let maybeIncludes = try container.decodeIfPresent(Includes<Include>.self, forKey: .included)
-
-        // TODO come back to this and make robust
-
-        guard let metaVal = meta else {
-            throw JSONAPIEncodingError.missingOrMalformedMetadata
-        }
-        guard let linksVal = links else {
-            throw JSONAPIEncodingError.missingOrMalformedLinks
-        }
-
-        body = .data(.init(primary: data, includes: maybeIncludes ?? Includes<Include>.none, meta: metaVal, links: linksVal))
-    }
-}
-
 // MARK: - CustomStringConvertible
 
 extension Document: CustomStringConvertible {

Sources/JSONAPI/Document/Error.swift

@@ -9,9 +9,6 @@ public protocol JSONAPIError: Swift.Error, Equatable, Codable {
 	static var unknown: Self { get }
 }
 
-/// `UnknownJSONAPIError` can actually be used in any sitaution
-/// where you don't know what errors are possible _or_ you just don't
-/// care what errors might show up.
 public enum UnknownJSONAPIError: JSONAPIError {
 	case unknownError
 	

Sources/JSONAPI/Document/Includes.swift

@@ -7,19 +7,9 @@
 
 import Poly
 
-public typealias Include = EncodableJSONPoly
+public typealias Include = JSONPoly
 
-/// A structure holding zero or more included Resource Objects.
-/// The resources are accessed by their type using a subscript.
-///
-/// If you have
-///
-/// `let includes: Includes<Include2<Thing1, Thing2>> = ...`
-///
-/// then you can access all `Thing1` included resources with
-///
-/// `let includedThings = includes[Thing1.self]`
-public struct Includes<I: Include>: Encodable, Equatable {
+public struct Includes<I: Include>: Codable, Equatable {
 	public static var none: Includes { return .init(values: []) }
 	
 	let values: [I]
@@ -27,6 +17,23 @@ public struct Includes<I: Include>: Encodable, Equatable {
 	public init(values: [I]) {
 		self.values = values
 	}
+	
+	public init(from decoder: Decoder) throws {
+		var container = try decoder.unkeyedContainer()
+		
+		// If not parsing includes, no need to loop over them.
+		guard I.self != NoIncludes.self else {
+			values = []
+			return
+		}
+		
+		var valueAggregator = [I]()
+		while !container.isAtEnd {
+			valueAggregator.append(try container.decode(I.self))
+		}
+		
+		values = valueAggregator
+	}
 
 	public func encode(to encoder: Encoder) throws {
 		var container = encoder.unkeyedContainer()
@@ -45,25 +52,6 @@ public struct Includes<I: Include>: Encodable, Equatable {
 	}
 }
 
-extension Includes: Decodable where I: Decodable {
-    public init(from decoder: Decoder) throws {
-        var container = try decoder.unkeyedContainer()
-
-        // If not parsing includes, no need to loop over them.
-        guard I.self != NoIncludes.self else {
-            values = []
-            return
-        }
-
-        var valueAggregator = [I]()
-        while !container.isAtEnd {
-            valueAggregator.append(try container.decode(I.self))
-        }
-
-        values = valueAggregator
-    }
-}
-
 extension Includes {
 	public func appending(_ other: Includes<I>) -> Includes {
 		return Includes(values: values + other.values)

Sources/JSONAPI/Document/ResourceBody.swift

@@ -5,53 +5,29 @@
 //  Created by Mathew Polzin on 11/10/18.
 //
 
-/// This protocol allows for a `SingleResourceBody` to contain a `null`
-/// data object where `ManyResourceBody` cannot (because an empty
-/// array should be used for no results).
-public protocol OptionalEncodablePrimaryResource: Equatable, Encodable {}
+public protocol MaybePrimaryResource: Equatable, Codable {}
 
-/// An `EncodablePrimaryResource` is a `PrimaryResource` that only supports encoding.
-/// This is actually more restrictave than `PrimaryResource`, which supports both encoding and
-/// decoding.
-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 {}
-
-/// A `PrimaryResource` is a type that can be used in the body of a JSON API
+/// A PrimaryResource 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 PrimaryResource: MaybePrimaryResource {}
 
-extension Optional: OptionalEncodablePrimaryResource where Wrapped: EncodablePrimaryResource {}
-
-extension Optional: OptionalPrimaryResource where Wrapped: PrimaryResource {}
-
-/// 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 {}
+extension Optional: MaybePrimaryResource where Wrapped: PrimaryResource {}
 
 /// A ResourceBody 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 ResourceBody: Codable, Equatable {
+}
 
-/// A `ResourceBody` that has the ability to take on more primary
-/// resources by appending another similarly typed `ResourceBody`.
-public protocol Appendable {
+public protocol AppendableResourceBody: ResourceBody {
 	func appending(_ other: Self) -> Self
 }
 
-public func +<R: Appendable>(_ left: R, right: R) -> R {
+public func +<R: AppendableResourceBody>(_ 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 struct SingleResourceBody<Entity: JSONAPI.MaybePrimaryResource>: ResourceBody {
 	public let value: Entity
 
 	public init(resourceObject: Entity) {
@@ -59,8 +35,7 @@ public struct SingleResourceBody<Entity: JSONAPI.OptionalEncodablePrimaryResourc
 	}
 }
 
-/// A type allowing for a document body containing 0 or more primary resources.
-public struct ManyResourceBody<Entity: JSONAPI.EncodablePrimaryResource>: EncodableResourceBody, Appendable {
+public struct ManyResourceBody<Entity: JSONAPI.PrimaryResource>: AppendableResourceBody {
 	public let values: [Entity]
 
 	public init(resourceObjects: [Entity]) {
@@ -80,36 +55,41 @@ public struct NoResourceBody: ResourceBody {
 
 // MARK: Codable
 extension SingleResourceBody {
+	public init(from decoder: Decoder) throws {
+		let container = try decoder.singleValueContainer()
+
+		let anyNil: Any? = nil
+		if container.decodeNil(),
+			let val = anyNil as? Entity {
+			value = val
+			return
+		}
+
+		value = try container.decode(Entity.self)
+	}
+
 	public func encode(to encoder: Encoder) throws {
 		var container = encoder.singleValueContainer()
 
-        let anyNil: Any? = nil
-        let nilValue = anyNil as? Entity
-        guard value != nilValue else {
-            try container.encodeNil()
-            return
-        }
+		if (value as Any?) == nil {
+			try container.encodeNil()
+			return
+		}
 
 		try container.encode(value)
 	}
 }
 
-extension SingleResourceBody: Decodable, ResourceBody where Entity: OptionalPrimaryResource {
-    public init(from decoder: Decoder) throws {
-        let container = try decoder.singleValueContainer()
-
-        let anyNil: Any? = nil
-        if container.decodeNil(),
-            let val = anyNil as? Entity {
-            value = val
-            return
-        }
-
-        value = try container.decode(Entity.self)
-    }
-}
-
 extension ManyResourceBody {
+	public init(from decoder: Decoder) throws {
+		var container = try decoder.unkeyedContainer()
+		var valueAggregator = [Entity]()
+		while !container.isAtEnd {
+			valueAggregator.append(try container.decode(Entity.self))
+		}
+		values = valueAggregator
+	}
+
 	public func encode(to encoder: Encoder) throws {
 		var container = encoder.unkeyedContainer()
 
@@ -119,17 +99,6 @@ extension ManyResourceBody {
 	}
 }
 
-extension ManyResourceBody: Decodable, ResourceBody where Entity: PrimaryResource {
-    public init(from decoder: Decoder) throws {
-        var container = try decoder.unkeyedContainer()
-        var valueAggregator = [Entity]()
-        while !container.isAtEnd {
-            valueAggregator.append(try container.decode(Entity.self))
-        }
-        values = valueAggregator
-    }
-}
-
 // MARK: CustomStringConvertible
 
 extension SingleResourceBody: CustomStringConvertible {

Sources/JSONAPI/EmptyObjectDecoder.swift

@@ -1,215 +0,0 @@
-//
-//  EmptyObjectDecoder.swift
-//  JSONAPI
-//
-//  Created by Mathew Polzin on 7/2/19.
-//
-
-/// `EmptyObjectDecoder` exists internally for the sole purpose of
-/// allowing certain fallback logic paths to attempt to create `Decodable`
-/// types from empty containers (specifically in a way that is agnostic
-/// of any given encoding). In other words, this serves the same purpose
-/// as `JSONDecoder().decode(Thing.self, from: "{}".data(using: .utf8)!)`
-/// without needing to use a third party or `Foundation` library decoder.
-struct EmptyObjectDecoder: Decoder {
-
-    var codingPath: [CodingKey] = []
-
-    var userInfo: [CodingUserInfoKey : Any] = [:]
-
-    func container<Key>(keyedBy type: Key.Type) throws -> KeyedDecodingContainer<Key> where Key : CodingKey {
-        return KeyedDecodingContainer(EmptyKeyedContainer())
-    }
-
-    func unkeyedContainer() throws -> UnkeyedDecodingContainer {
-        return EmptyUnkeyedContainer()
-    }
-
-    func singleValueContainer() throws -> SingleValueDecodingContainer {
-        throw EmptyObjectDecodingError.emptyObjectCannotBeSingleValue
-    }
-}
-
-enum EmptyObjectDecodingError: Swift.Error {
-    case emptyObjectCannotBeSingleValue
-    case emptyObjectCannotBeUnkeyedValues
-    case emptyObjectCannotHaveKeyedValues
-    case emptyObjectCannotHaveNestedContainers
-    case emptyObjectCannotHaveSuper
-}
-
-struct EmptyUnkeyedContainer: UnkeyedDecodingContainer {
-    var codingPath: [CodingKey] { return [] }
-
-    var count: Int? { return 0 }
-
-    var isAtEnd: Bool { return true }
-
-    var currentIndex: Int { return 0 }
-
-    mutating func decodeNil() throws -> Bool {
-        throw EmptyObjectDecodingError.emptyObjectCannotBeUnkeyedValues
-    }
-
-    mutating func decode(_ type: Bool.Type) throws -> Bool {
-        throw EmptyObjectDecodingError.emptyObjectCannotBeUnkeyedValues
-    }
-
-    mutating func decode(_ type: String.Type) throws -> String {
-        throw EmptyObjectDecodingError.emptyObjectCannotBeUnkeyedValues
-    }
-
-    mutating func decode(_ type: Double.Type) throws -> Double {
-        throw EmptyObjectDecodingError.emptyObjectCannotBeUnkeyedValues
-    }
-
-    mutating func decode(_ type: Float.Type) throws -> Float {
-        throw EmptyObjectDecodingError.emptyObjectCannotBeUnkeyedValues
-    }
-
-    mutating func decode(_ type: Int.Type) throws -> Int {
-        throw EmptyObjectDecodingError.emptyObjectCannotBeUnkeyedValues
-    }
-
-    mutating func decode(_ type: Int8.Type) throws -> Int8 {
-        throw EmptyObjectDecodingError.emptyObjectCannotBeUnkeyedValues
-    }
-
-    mutating func decode(_ type: Int16.Type) throws -> Int16 {
-        throw EmptyObjectDecodingError.emptyObjectCannotBeUnkeyedValues
-    }
-
-    mutating func decode(_ type: Int32.Type) throws -> Int32 {
-        throw EmptyObjectDecodingError.emptyObjectCannotBeUnkeyedValues
-    }
-
-    mutating func decode(_ type: Int64.Type) throws -> Int64 {
-        throw EmptyObjectDecodingError.emptyObjectCannotBeUnkeyedValues
-    }
-
-    mutating func decode(_ type: UInt.Type) throws -> UInt {
-        throw EmptyObjectDecodingError.emptyObjectCannotBeUnkeyedValues
-    }
-
-    mutating func decode(_ type: UInt8.Type) throws -> UInt8 {
-        throw EmptyObjectDecodingError.emptyObjectCannotBeUnkeyedValues
-    }
-
-    mutating func decode(_ type: UInt16.Type) throws -> UInt16 {
-        throw EmptyObjectDecodingError.emptyObjectCannotBeUnkeyedValues
-    }
-
-    mutating func decode(_ type: UInt32.Type) throws -> UInt32 {
-        throw EmptyObjectDecodingError.emptyObjectCannotBeUnkeyedValues
-    }
-
-    mutating func decode(_ type: UInt64.Type) throws -> UInt64 {
-        throw EmptyObjectDecodingError.emptyObjectCannotBeUnkeyedValues
-    }
-
-    mutating func decode<T>(_ type: T.Type) throws -> T where T : Decodable {
-        throw EmptyObjectDecodingError.emptyObjectCannotBeUnkeyedValues
-    }
-
-    mutating func nestedContainer<NestedKey>(keyedBy type: NestedKey.Type) throws -> KeyedDecodingContainer<NestedKey> where NestedKey : CodingKey {
-        throw EmptyObjectDecodingError.emptyObjectCannotHaveNestedContainers
-    }
-
-    mutating func nestedUnkeyedContainer() throws -> UnkeyedDecodingContainer {
-        throw EmptyObjectDecodingError.emptyObjectCannotHaveNestedContainers
-    }
-
-    mutating func superDecoder() throws -> Decoder {
-        throw EmptyObjectDecodingError.emptyObjectCannotHaveSuper
-    }
-}
-
-struct EmptyKeyedContainer<Key: CodingKey>: KeyedDecodingContainerProtocol {
-    var codingPath: [CodingKey] { return [] }
-
-    var allKeys: [Key] { return [] }
-
-    func contains(_ key: Key) -> Bool {
-        return false
-    }
-
-    func decodeNil(forKey key: Key) throws -> Bool {
-        throw EmptyObjectDecodingError.emptyObjectCannotHaveKeyedValues
-    }
-
-    func decode(_ type: Bool.Type, forKey key: Key) throws -> Bool {
-        throw EmptyObjectDecodingError.emptyObjectCannotHaveKeyedValues
-    }
-
-    func decode(_ type: String.Type, forKey key: Key) throws -> String {
-        throw EmptyObjectDecodingError.emptyObjectCannotHaveKeyedValues
-    }
-
-    func decode(_ type: Double.Type, forKey key: Key) throws -> Double {
-        throw EmptyObjectDecodingError.emptyObjectCannotHaveKeyedValues
-    }
-
-    func decode(_ type: Float.Type, forKey key: Key) throws -> Float {
-        throw EmptyObjectDecodingError.emptyObjectCannotHaveKeyedValues
-    }
-
-    func decode(_ type: Int.Type, forKey key: Key) throws -> Int {
-        throw EmptyObjectDecodingError.emptyObjectCannotHaveKeyedValues
-    }
-
-    func decode(_ type: Int8.Type, forKey key: Key) throws -> Int8 {
-        throw EmptyObjectDecodingError.emptyObjectCannotHaveKeyedValues
-    }
-
-    func decode(_ type: Int16.Type, forKey key: Key) throws -> Int16 {
-        throw EmptyObjectDecodingError.emptyObjectCannotHaveKeyedValues
-    }
-
-    func decode(_ type: Int32.Type, forKey key: Key) throws -> Int32 {
-        throw EmptyObjectDecodingError.emptyObjectCannotHaveKeyedValues
-    }
-
-    func decode(_ type: Int64.Type, forKey key: Key) throws -> Int64 {
-        throw EmptyObjectDecodingError.emptyObjectCannotHaveKeyedValues
-    }
-
-    func decode(_ type: UInt.Type, forKey key: Key) throws -> UInt {
-        throw EmptyObjectDecodingError.emptyObjectCannotHaveKeyedValues
-    }
-
-    func decode(_ type: UInt8.Type, forKey key: Key) throws -> UInt8 {
-        throw EmptyObjectDecodingError.emptyObjectCannotHaveKeyedValues
-    }
-
-    func decode(_ type: UInt16.Type, forKey key: Key) throws -> UInt16 {
-        throw EmptyObjectDecodingError.emptyObjectCannotHaveKeyedValues
-    }
-
-    func decode(_ type: UInt32.Type, forKey key: Key) throws -> UInt32 {
-        throw EmptyObjectDecodingError.emptyObjectCannotHaveKeyedValues
-    }
-
-    func decode(_ type: UInt64.Type, forKey key: Key) throws -> UInt64 {
-        throw EmptyObjectDecodingError.emptyObjectCannotHaveKeyedValues
-    }
-
-    func decode<T>(_ type: T.Type, forKey key: Key) throws -> T where T : Decodable {
-        throw EmptyObjectDecodingError.emptyObjectCannotHaveKeyedValues
-    }
-
-    func nestedContainer<NestedKey>(keyedBy type: NestedKey.Type, forKey key: Key) throws -> KeyedDecodingContainer<NestedKey> where NestedKey : CodingKey {
-        throw EmptyObjectDecodingError.emptyObjectCannotHaveNestedContainers
-    }
-
-    func nestedUnkeyedContainer(forKey key: Key) throws -> UnkeyedDecodingContainer {
-        throw EmptyObjectDecodingError.emptyObjectCannotHaveNestedContainers
-    }
-
-    func superDecoder() throws -> Decoder {
-        throw EmptyObjectDecodingError.emptyObjectCannotHaveSuper
-    }
-
-    func superDecoder(forKey key: Key) throws -> Decoder {
-        throw EmptyObjectDecodingError.emptyObjectCannotHaveSuper
-    }
-}

Sources/JSONAPI/Meta/Meta.swift

@@ -19,8 +19,6 @@ public protocol Meta: Codable, Equatable {
 // 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() }
 

Sources/JSONAPI/Resource/Attribute.swift

@@ -17,9 +17,9 @@ public protocol AttributeType: Codable {
 /// 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 value: Transformer.To
-	
+
 	public init(rawValue: RawValue) throws {
 		self.rawValue = rawValue
 		value = try Transformer.transform(rawValue)

Sources/JSONAPI/Resource/Id.swift

@@ -28,9 +28,6 @@ public protocol CreatableRawIdType: RawIdType {
 
 extension String: RawIdType {}
 
-/// A type that can be used as the `MaybeRawId` for a `ResourceObject` that does not
-/// 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() {}
 	

Sources/JSONAPI/Resource/Poly+PrimaryResource.swift

@@ -15,10 +15,9 @@ import Poly
 /// disparate types under one roof for
 /// the purposes of JSON API compliant
 /// encoding or decoding.
-public typealias EncodableJSONPoly = Poly & EncodablePrimaryResource
+public typealias JSONPoly = Poly & PrimaryResource
 
-public typealias EncodablePolyWrapped = Encodable & Equatable
-public typealias PolyWrapped = EncodablePolyWrapped & Decodable
+public typealias PolyWrapped = Codable & Equatable
 
 extension Poly0: PrimaryResource {
 	public init(from decoder: Decoder) throws {
@@ -31,46 +30,28 @@ extension Poly0: PrimaryResource {
 }
 
 // MARK: - 1 type
-extension Poly1: EncodablePrimaryResource, OptionalEncodablePrimaryResource where A: EncodablePolyWrapped {}
-
-extension Poly1: PrimaryResource, OptionalPrimaryResource where A: PolyWrapped {}
+extension Poly1: PrimaryResource, MaybePrimaryResource where A: PolyWrapped {}
 
 // MARK: - 2 types
-extension Poly2: EncodablePrimaryResource, OptionalEncodablePrimaryResource where A: EncodablePolyWrapped, B: EncodablePolyWrapped {}
-
-extension Poly2: PrimaryResource, OptionalPrimaryResource where A: PolyWrapped, B: PolyWrapped {}
+extension Poly2: PrimaryResource, MaybePrimaryResource where A: PolyWrapped, B: PolyWrapped {}
 
 // MARK: - 3 types
-extension Poly3: EncodablePrimaryResource, OptionalEncodablePrimaryResource where A: EncodablePolyWrapped, B: EncodablePolyWrapped, C: EncodablePolyWrapped {}
-
-extension Poly3: PrimaryResource, OptionalPrimaryResource where A: PolyWrapped, B: PolyWrapped, C: PolyWrapped {}
+extension Poly3: PrimaryResource, MaybePrimaryResource where A: PolyWrapped, B: PolyWrapped, C: PolyWrapped {}
 
 // MARK: - 4 types
-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: PrimaryResource, MaybePrimaryResource where A: PolyWrapped, B: PolyWrapped, C: PolyWrapped, D: PolyWrapped {}
 
 // MARK: - 5 types
-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: PrimaryResource, MaybePrimaryResource where A: PolyWrapped, B: PolyWrapped, C: PolyWrapped, D: PolyWrapped, E: PolyWrapped {}
 
 // MARK: - 6 types
-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: PrimaryResource, MaybePrimaryResource where A: PolyWrapped, B: PolyWrapped, C: PolyWrapped, D: PolyWrapped, E: PolyWrapped, F: PolyWrapped {}
 
 // MARK: - 7 types
-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: PrimaryResource, MaybePrimaryResource where A: PolyWrapped, B: PolyWrapped, C: PolyWrapped, D: PolyWrapped, E: PolyWrapped, F: PolyWrapped, G: PolyWrapped {}
 
 // 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: PrimaryResource, OptionalPrimaryResource where A: PolyWrapped, B: PolyWrapped, C: PolyWrapped, D: PolyWrapped, E: PolyWrapped, F: PolyWrapped, G: PolyWrapped, H: PolyWrapped {}
+extension Poly8: PrimaryResource, MaybePrimaryResource where A: PolyWrapped, B: PolyWrapped, C: PolyWrapped, D: PolyWrapped, E: PolyWrapped, F: PolyWrapped, G: PolyWrapped, H: PolyWrapped {}
 
 // 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: PrimaryResource, OptionalPrimaryResource where A: PolyWrapped, B: PolyWrapped, C: PolyWrapped, D: PolyWrapped, E: PolyWrapped, F: PolyWrapped, G: PolyWrapped, H: PolyWrapped, I: PolyWrapped {}
+extension Poly9: PrimaryResource, MaybePrimaryResource where A: PolyWrapped, B: PolyWrapped, C: PolyWrapped, D: PolyWrapped, E: PolyWrapped, F: PolyWrapped, G: PolyWrapped, H: PolyWrapped, I: PolyWrapped {}

Sources/JSONAPI/Resource/PropertyWrappers.swift

@@ -0,0 +1,115 @@
+//
+//  PropertyWrappers.swift
+//  
+//
+//  Created by Mathew Polzin on 6/20/19.
+//
+
+
+// MARK: - Transformed
+@propertyWrapper
+public struct Transformed<Transformer: JSONAPI.Transformer> {
+
+    public typealias RawValue = Transformer.From
+    public typealias Value = Transformer.To
+
+    private var _value: Value?
+
+    public var wrappedValue: Value {
+        get {
+            guard let ret = _value else {
+                fatalError("Attribute read from before initialization.")
+            }
+            return ret
+        }
+        set {
+            _value = newValue
+        }
+    }
+
+    public init(initialValue: Value, _ transformer: Transformer.Type) {
+        self._value = initialValue
+    }
+
+    public init(_ transformer: Transformer.Type) {
+        self._value = nil
+    }
+
+    public init(rawValue: RawValue, _ transformer: Transformer.Type) throws {
+        self._value = try Transformer.transform(rawValue)
+    }
+}
+
+extension Transformed: Decodable where Transformer.From: Decodable {
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+
+        let rawVal = try container.decode(Transformer.From.self)
+
+        _value = try Transformer.transform(rawVal)
+    }
+}
+
+extension Transformed: Encodable where Transformer: ReversibleTransformer, Transformer.From: Encodable {
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+
+        guard let value = _value else {
+            fatalError("Attribute encoded before initialization.")
+        }
+
+        try container.encode(Transformer.reverse(value))
+    }
+}
+
+// MARK: - Nullable
+
+public protocol _Optional {
+    static var nilValue: Self { get }
+    var isNilValue: Bool { get }
+}
+
+extension Optional: _Optional {
+    public static var nilValue: Self {
+        return .none
+    }
+
+    public var isNilValue: Bool { return self == nil }
+}
+
+protocol _Nullable {}
+
+@propertyWrapper
+public struct Nullable<T: Decodable>: Decodable, _Optional, _Nullable {
+    public var wrappedValue: T?
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+
+        if container.decodeNil() {
+            wrappedValue = nil
+            return
+        }
+
+        wrappedValue = try container.decode(T.self)
+    }
+
+    public init(initialValue: T? = nil) {
+        wrappedValue = initialValue
+    }
+
+    public static var nilValue: Self {
+        return .init()
+    }
+
+    public var isNilValue: Bool {
+        return wrappedValue == nil
+    }
+}
+
+extension Nullable: Encodable where T: Encodable {
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+        try container.encode(wrappedValue)
+    }
+}

Sources/JSONAPI/Resource/Relationship.swift

@@ -190,6 +190,10 @@ extension ToOneRelationship: Codable where Identifiable.Identifier: OptionalId {
 	public func encode(to encoder: Encoder) throws {
 		var container = encoder.container(keyedBy: ResourceLinkageCodingKeys.self)
 
+		if (id as Any?) == nil {
+			try container.encodeNil(forKey: .data)
+		}
+
 		if MetaType.self != NoMetadata.self {
 			try container.encode(meta, forKey: .meta)
 		}

Sources/JSONAPI/Resource/ResourceObject.swift

@@ -5,7 +5,6 @@
 //  Created by Mathew Polzin on 7/24/18.
 //
 
-
 /// A JSON API structure within an ResourceObject that contains
 /// named properties of types `ToOneRelationship` and
 /// `ToManyRelationship`.
@@ -15,16 +14,6 @@ public protocol Relationships: Codable & Equatable {}
 /// properties of any types that are JSON encodable.
 public protocol Attributes: Codable & Equatable {}
 
-/// CodingKeys must be `CodingKey` and `Equatable` in order
-/// to support Sparse Fieldsets.
-public typealias SparsableCodingKey = CodingKey & Equatable
-
-/// Attributes containing publicly accessible and `Equatable`
-/// CodingKeys are required to support Sparse Fieldsets.
-public protocol SparsableAttributes: Attributes {
-    associatedtype CodingKeys: SparsableCodingKey
-}
-
 /// Can be used as `Relationships` Type for Entities that do not
 /// have any Relationships.
 public struct NoRelationships: Relationships {
@@ -58,7 +47,7 @@ public protocol ResourceObjectProxyDescription: JSONTyped {
 	associatedtype Relationships: Equatable
 }
 
-/// A `ResourceObjectDescription` describes a JSON API
+/// An `ResourceObjectDescription` describes a JSON API
 /// Resource Object. The Resource Object
 /// itself is encoded and decoded as an
 /// `ResourceObject`, which gets specialized on an
@@ -405,14 +394,14 @@ extension ResourceObject where MetaType == NoMetadata, LinksType == NoLinks, Ent
 // MARK: Pointer for Relationships use.
 public extension ResourceObject where EntityRawIdType: JSONAPI.RawIdType {
 
-	/// A `ResourceObject.Pointer` is a `ToOneRelationship` with no metadata or links.
-	/// This is just a convenient way to reference a `ResourceObject` so that
-	/// other ResourceObjects' Relationships can be built up from it.
+	/// An ResourceObject.Pointer is a `ToOneRelationship` with no metadata or links.
+	/// This is just a convenient way to reference an ResourceObject so that
+	/// other Entities' Relationships can be built up from it.
 	typealias Pointer = ToOneRelationship<ResourceObject, NoMetadata, NoLinks>
 
-	/// `ResourceObject.Pointers` is a `ToManyRelationship` with no metadata or links.
-	/// This is just a convenient way to reference a bunch of ResourceObjects so
-	/// that other ResourceObjects' Relationships can be built up from them.
+	/// ResourceObject.Pointers is a `ToManyRelationship` with no metadata or links.
+	/// This is just a convenient way to reference a bunch of Entities so
+	/// that other Entities' Relationships can be built up from them.
 	typealias Pointers = ToManyRelationship<ResourceObject, NoMetadata, NoLinks>
 
 	/// Get a pointer to this resource object that can be used as a
@@ -421,8 +410,6 @@ public extension ResourceObject where EntityRawIdType: JSONAPI.RawIdType {
 		return Pointer(resourceObject: self)
 	}
 
-    /// Get a pointer (i.e. `ToOneRelationship`) to this resource
-    /// object with the given metadata and links attached.
 	func pointer<MType: JSONAPI.Meta, LType: JSONAPI.Links>(withMeta meta: MType, links: LType) -> ToOneRelationship<ResourceObject, MType, LType> {
 		return ToOneRelationship(resourceObject: self, meta: meta, links: links)
 	}
@@ -430,20 +417,20 @@ public extension ResourceObject where EntityRawIdType: JSONAPI.RawIdType {
 
 // MARK: Identifying Unidentified Entities
 public extension ResourceObject where EntityRawIdType == Unidentified {
-	/// Create a new `ResourceObject` from this one with a newly created
+	/// Create a new ResourceObject from this one with a newly created
 	/// unique Id of the given type.
 	func identified<RawIdType: CreatableRawIdType>(byType: RawIdType.Type) -> ResourceObject<Description, MetaType, LinksType, RawIdType> {
 		return .init(attributes: attributes, relationships: relationships, meta: meta, links: links)
 	}
 
-	/// Create a new `ResourceObject` from this one with the given Id.
+	/// Create a new ResourceObject from this one with the given Id.
 	func identified<RawIdType: JSONAPI.RawIdType>(by id: RawIdType) -> ResourceObject<Description, MetaType, LinksType, RawIdType> {
 		return .init(id: ResourceObject<Description, MetaType, LinksType, RawIdType>.Identifier(rawValue: id), attributes: attributes, relationships: relationships, meta: meta, links: links)
 	}
 }
 
 public extension ResourceObject where EntityRawIdType: CreatableRawIdType {
-	/// Create a copy of this `ResourceObject` with a new unique Id.
+	/// Create a copy of this ResourceObject with a new unique Id.
 	func withNewIdentifier() -> ResourceObject {
 		return ResourceObject(attributes: attributes, relationships: relationships, meta: meta, links: links)
 	}
@@ -559,63 +546,61 @@ infix operator ~>
 
 // MARK: - Codable
 private enum ResourceObjectCodingKeys: String, CodingKey {
-    case type = "type"
-    case id = "id"
-    case attributes = "attributes"
-    case relationships = "relationships"
-    case meta = "meta"
-    case links = "links"
+	case type = "type"
+	case id = "id"
+	case attributes = "attributes"
+	case relationships = "relationships"
+	case meta = "meta"
+	case links = "links"
 }
 
 public extension ResourceObject {
-    func encode(to encoder: Encoder) throws {
-        var container = encoder.container(keyedBy: ResourceObjectCodingKeys.self)
+	func encode(to encoder: Encoder) throws {
+		var container = encoder.container(keyedBy: ResourceObjectCodingKeys.self)
+		
+		try container.encode(ResourceObject.jsonType, forKey: .type)
+		
+		if EntityRawIdType.self != Unidentified.self {
+			try container.encode(id, forKey: .id)
+		}
+		
+		if Description.Attributes.self != NoAttributes.self {
+			try container.encode(attributes, forKey: .attributes)
+		}
+		
+		if Description.Relationships.self != NoRelationships.self {
+			try container.encode(relationships, forKey: .relationships)
+		}
 
-        try container.encode(ResourceObject.jsonType, forKey: .type)
+		if MetaType.self != NoMetadata.self {
+			try container.encode(meta, forKey: .meta)
+		}
 
-        if EntityRawIdType.self != Unidentified.self {
-            try container.encode(id, forKey: .id)
-        }
+		if LinksType.self != NoLinks.self {
+			try container.encode(links, forKey: .links)
+		}
+	}
 
-        if Description.Attributes.self != NoAttributes.self {
-            let nestedEncoder = container.superEncoder(forKey: .attributes)
-            try attributes.encode(to: nestedEncoder)
-        }
+	init(from decoder: Decoder) throws {
+		
+		let container = try decoder.container(keyedBy: ResourceObjectCodingKeys.self)
+		
+		let type = try container.decode(String.self, forKey: .type)
+		
+		guard ResourceObject.jsonType == type else {
+			throw JSONAPIEncodingError.typeMismatch(expected: Description.jsonType, found: type)
+		}
 
-        if Description.Relationships.self != NoRelationships.self {
-            try container.encode(relationships, forKey: .relationships)
-        }
+		let maybeUnidentified = Unidentified() as? EntityRawIdType
+		id = try maybeUnidentified.map { ResourceObject.Id(rawValue: $0) } ?? container.decode(ResourceObject.Id.self, forKey: .id)
 
-        if MetaType.self != NoMetadata.self {
-            try container.encode(meta, forKey: .meta)
-        }
+		attributes = try (NoAttributes() as? Description.Attributes) ??
+			container.decode(Description.Attributes.self, forKey: .attributes)
 
-        if LinksType.self != NoLinks.self {
-            try container.encode(links, forKey: .links)
-        }
-    }
+		relationships = try (NoRelationships() as? Description.Relationships) ?? container.decode(Description.Relationships.self, forKey: .relationships)
 
-    init(from decoder: Decoder) throws {
-        let container = try decoder.container(keyedBy: ResourceObjectCodingKeys.self)
+		meta = try (NoMetadata() as? MetaType) ?? container.decode(MetaType.self, forKey: .meta)
 
-        let type = try container.decode(String.self, forKey: .type)
-
-        guard ResourceObject.jsonType == type else {
-            throw JSONAPIEncodingError.typeMismatch(expected: Description.jsonType, found: type)
-        }
-
-        let maybeUnidentified = Unidentified() as? EntityRawIdType
-        id = try maybeUnidentified.map { ResourceObject.Id(rawValue: $0) } ?? container.decode(ResourceObject.Id.self, forKey: .id)
-
-        attributes = try (NoAttributes() as? Description.Attributes) ??
-            container.decode(Description.Attributes.self, forKey: .attributes)
-
-        relationships = try (NoRelationships() as? Description.Relationships)
-            ?? container.decodeIfPresent(Description.Relationships.self, forKey: .relationships)
-            ?? Description.Relationships(from: EmptyObjectDecoder())
-
-        meta = try (NoMetadata() as? MetaType) ?? container.decode(MetaType.self, forKey: .meta)
-
-        links = try (NoLinks() as? LinksType) ?? container.decode(LinksType.self, forKey: .links)
-    }
+		links = try (NoLinks() as? LinksType) ?? container.decode(LinksType.self, forKey: .links)
+	}
 }