Update linuxmain

Add test coverage for Meta and Links on Entity
give all top-level-ish headers the JSONAPI prefix
2026-07-10 12:18:40 -07:00 · 2018-12-03 18:46:03 -08:00 · 2018-12-03 18:45:07 -08:00 · 2018-12-03 18:14:05 -08:00 · 2018-12-03 18:10:36 -08:00 · 2018-12-03 18:09:40 -08:00
47 changed files with 3423 additions and 404 deletions
@@ -0,0 +1,24 @@
+//: [Previous](@previous)
+
+import Foundation
+import JSONAPI
+import JSONAPITestLib
+
+/*******
+
+Please enjoy these examples, but allow me the forced casting and the lack of error checking for the sake of brevity.
+
+********/
+
+// MARK: - Literal Expressibility
+// The JSONAPITestLib provides literal expressibility for key types to
+// make creating tests easier
+let dog = Dog(id: "1234", attributes: Dog.Attributes(name: "Buddy"), relationships: Dog.Relationships(owner: nil))
+
+// MARK: - JSON API structure checking
+// The JSONAPITestLib provides a `check` function for each Entity type
+// that uses reflection to catch mistakes that are not forbidden by
+// Swift's type system but will result in unexpected results when
+// encoding/decoding. It is a good idea to add a `check` to each of
+// your unit tests that create Entities.
+try Dog.check(dog)
@@ -11,7 +11,7 @@ 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)

-typealias SingleDogDocument = JSONAPIDocument<SingleResourceBody<Dog>, NoIncludes, BasicJSONAPIError>
+typealias SingleDogDocument = JSONAPI.Document<SingleResourceBody<Dog>, NoMetadata, NoLinks, NoIncludes, NoAPIDescription, UnknownJSONAPIError>

 let singleDogDocument = SingleDogDocument(body: SingleResourceBody(entity: dogFromCode))

@@ -19,7 +19,7 @@ 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.data?.primary.value
+let dogFromData = dogResponse.body.primaryData?.value

 // MARK: - Create a request or response with multiple people and dogs and houses included
 let personIds = [Person.Identifier(), Person.Identifier()]
@@ -27,7 +27,7 @@ let dogs = try! [Dog(name: "Buddy", owner: personIds[0]), Dog(name: "Joy", owner
 let houses = [House(), House()]
 let people = try! [Person(id: personIds[0], name: ["Gary", "Doe"], favoriteColor: "Orange-Red", friends: [], dogs: [dogs[0], dogs[1]], home: houses[0]), Person(id: personIds[1], name: ["Elise", "Joy"], favoriteColor: "Red", friends: [], dogs: [dogs[2]], home: houses[1])]

-typealias BatchPeopleDocument = JSONAPIDocument<ManyResourceBody<Person>, Include2<Dog, House>, BasicJSONAPIError>
+typealias BatchPeopleDocument = JSONAPI.Document<ManyResourceBody<Person>, NoMetadata, NoLinks, Include2<Dog, House>, NoAPIDescription, UnknownJSONAPIError>

 let includes = dogs.map { BatchPeopleDocument.Include($0) } + houses.map { BatchPeopleDocument.Include($0) }
 let batchPeopleDocument = BatchPeopleDocument(body: .init(entities: people), includes: .init(values: includes))
@@ -36,6 +36,28 @@ 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)
-let peopleFromData = peopleResponse.body.data?.primary.values
-let dogsFromData = peopleResponse.body.data?.included[Dog.self]
-let housesFromData = peopleResponse.body.data?.included[House.self]
+let peopleFromData = peopleResponse.body.primaryData?.values
+let dogsFromData = peopleResponse.body.includes?[Dog.self]
+let housesFromData = peopleResponse.body.includes?[House.self]
+
+print("-----")
+print(peopleResponse)
+print("-----")
+
+// MARK: - Pass successfully parsed body to other parts of the code
+
+if case let .data(bodyData) = peopleResponse.body {
+	print("first person's name: \(bodyData.primary.values[0][\.fullName])")
+} else {
+	print("no body data")
+}
+
+// MARK: - Work in the abstract
+
+func process<T: JSONAPIDocument>(document: T) {
+	guard case let .data(body) = document.body else {
+		return
+	}
+	let x: T.Body.Data = body
+}
+process(document: peopleResponse)
@@ -24,7 +24,7 @@ extension String: CreatableRawIdType {
 }

 // MARK: - Entity typealias for convenience
-public typealias ExampleEntity<Description: EntityDescription> = Entity<Description, Id<String, Description>>
+public typealias ExampleEntity<Description: EntityDescription> = Entity<Description, String>

 // MARK: - A few resource objects (entities)
 public enum PersonDescription: EntityDescription {
@@ -34,20 +34,35 @@ public enum PersonDescription: EntityDescription {
 	public struct Attributes: JSONAPI.Attributes {
 		public let name: Attribute<[String]>
 		public let favoriteColor: Attribute<String>
+
+		public var fullName: Attribute<String> {
+			return name.map { $0.joined(separator: " ") }
+		}
+
+		public init(name: Attribute<[String]>, favoriteColor: Attribute<String>) {
+			self.name = name
+			self.favoriteColor = favoriteColor
+		}
 	}
 	
 	public struct Relationships: JSONAPI.Relationships {
 		public let friends: ToManyRelationship<Person>
 		public let dogs: ToManyRelationship<Dog>
 		public let home: ToOneRelationship<House>
+
+		public init(friends: ToManyRelationship<Person>, dogs: ToManyRelationship<Dog>, home: ToOneRelationship<House>) {
+			self.friends = friends
+			self.dogs = dogs
+			self.home = home
+		}
 	}
 }

 public typealias Person = ExampleEntity<PersonDescription>

-public extension Entity where Description == PersonDescription, Identifier == Id<String, PersonDescription> {
-	public init(id: Person.Identifier? = nil,name: [String], favoriteColor: String, friends: [Person], dogs: [Dog], home: House) throws {
-		self = try Person(id: id ?? Person.Identifier(), attributes: .init(name: .init(rawValue: name), favoriteColor: .init(rawValue: favoriteColor)), relationships: .init(friends: .init(entities: friends), dogs: .init(entities: dogs), home: .init(entity: home)))
+public extension Entity where Description == PersonDescription, EntityRawIdType == String {
+	public init(id: Person.Id? = nil,name: [String], favoriteColor: String, friends: [Person], dogs: [Dog], home: House) throws {
+		self = try Person(id: id ?? Person.Id(), attributes: .init(name: .init(rawValue: name), favoriteColor: .init(rawValue: favoriteColor)), relationships: .init(friends: .init(entities: friends), dogs: .init(entities: dogs), home: .init(entity: home)))
 	}
 }

@@ -57,21 +72,29 @@ public enum DogDescription: EntityDescription {

 	public struct Attributes: JSONAPI.Attributes {
 		public let name: Attribute<String>
+
+		public init(name: Attribute<String>) {
+			self.name = name
+		}
 	}

 	public struct Relationships: JSONAPI.Relationships {
 		public let owner: ToOneRelationship<Person?>
+
+		public init(owner: ToOneRelationship<Person?>) {
+			self.owner = owner
+		}
 	}
 }

 public typealias Dog = ExampleEntity<DogDescription>

-public extension Entity where Description == DogDescription, Identifier == Id<String, DogDescription> {
+public extension Entity where Description == DogDescription, EntityRawIdType == String {
 	public init(name: String, owner: Person?) throws {
 		self = try Dog(attributes: .init(name: .init(rawValue: name)), relationships: DogDescription.Relationships(owner: .init(entity: owner)))
 	}

-	public init(name: String, owner: Person.Identifier) throws {
+	public init(name: String, owner: Person.Id) throws {
 		self = try Dog(attributes: .init(name: .init(rawValue: name)), relationships: .init(owner: .init(id: owner)))
 	}
 }
@@ -81,7 +104,7 @@ public enum HouseDescription: EntityDescription {
 	public static var type: String { return "houses" }

 	public typealias Attributes = NoAttributes
-	public typealias Relationships = NoRelatives
+	public typealias Relationships = NoRelationships
 }

 public typealias House = ExampleEntity<HouseDescription>
@@ -1,4 +1,7 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<playground version='5.0' target-platform='macos' executeOnSourceChanges='false'>
-    <timeline fileName='timeline.xctimeline'/>
+<playground version='6.0' target-platform='macos' executeOnSourceChanges='false'>
+    <pages>
+        <page name='Test Library'/>
+        <page name='Usage'/>
+    </pages>
 </playground>
@@ -6,23 +6,27 @@ import PackageDescription
 let package = Package(
    name: "JSONAPI",
    products: [
-        // Products define the executables and libraries produced by a package, and make them visible to other packages.
        .library(
            name: "JSONAPI",
            targets: ["JSONAPI"]),
+		.library(
+			name: "JSONAPITestLib",
+			targets: ["JSONAPITestLib"])
    ],
    dependencies: [
+		// antitypical/Result without the Foundation requirement:
        .package(url: "https://github.com/mattpolzin/Result", .branch("master"))
    ],
    targets: [
-        // Targets are the basic building blocks of a package. A target can define a module or a test suite.
-        // Targets can depend on other targets in this package, and on products in packages which this package depends on.
        .target(
            name: "JSONAPI",
            dependencies: ["Result"]),
+		.target(
+			name: "JSONAPITestLib",
+			dependencies: ["JSONAPI"]),
        .testTarget(
            name: "JSONAPITests",
-            dependencies: ["JSONAPI"]),
+            dependencies: ["JSONAPITestLib"])
    ],
  	swiftLanguageVersions: [.v4_2]
 )
@@ -1,99 +1,88 @@
 # JSONAPI
 [![MIT license](http://img.shields.io/badge/license-MIT-lightgrey.svg)](http://opensource.org/licenses/MIT) [![Swift 4.2](http://img.shields.io/badge/Swift-4.2-blue.svg)](https://swift.org) [![Build Status](https://app.bitrise.io/app/c8295b9589aa401e/status.svg?token=vzcyqWD5bQ4xqQfZsaVzNw&branch=master)](https://app.bitrise.io/app/c8295b9589aa401e)

-A Swift package for encoding to- and decoding from *JSON API* compliant requests and responses.
+A Swift package for encoding to- and decoding from **JSON API** compliant requests and responses.

 See the JSON API Spec here: https://jsonapi.org/format/

 ## Primary Goals

 The primary goals of this framework are:
-1. Allow creation of Swift types that are easy to use in code but also can be encoded to- or decoded from *JSON API* compliant payloads without lots of boilerplate code.
+1. Allow creation of Swift types that are easy to use in code but also can be encoded to- or decoded from **JSON API v1.0 Spec** compliant payloads without lots of boilerplate code.
 2. Leverage `Codable` to avoid additional outside dependencies and get operability with non-JSON encoders/decoders for free.
 3. Do not sacrifice type safety.
 4. Be platform agnostic so that Swift code can be written once and used by both the client and the server.

-## Project Status
+### Caveat
+The big caveat is that, although the aim is to support the JSON API spec, this framework ends up being _naturally_ opinionated about certain things that the API Spec does not specify. These caveats are largely a side effect of attempting to write the library in a "Swifty" way.

-### Decoding
-#### Document
- [x] `data`
- [x] `included`
- [x] `errors`
- [x] `meta`
- [ ] `jsonapi`
- [x] `links`
+If you find something wrong with this library and it isn't already mentioned under **Project Status**, let me know! I want to keep working towards a library implementation that is useful in any application.

-#### Resource Object
- [x] `id`
- [x] `type`
- [x] `attributes`
- [x] `relationships`
- [ ] `links`
- [ ] `meta`
-
-#### Relationship Object
- [x] `data`
- [ ] `links`
- [ ] `meta`
-
-#### Links Object
- [x] `href`
- [x] `meta`
-
-### Encoding
-#### Document
- [x] `data`
- [x] `included`
- [x] `errors`
- [x] `meta`
- [ ] `jsonapi`
- [x] `links`
-
-#### Resource Object
- [x] `id`
- [x] `type`
- [x] `attributes`
- [x] `relationships`
- [ ] `links`
- [ ] `meta`
-
-#### Relationship Object
- [x] `data`
- [ ] `links`
- [ ] `meta`
-
-#### Links Object
- [x] `href`
- [x] `meta`
-
-### EntityDescription Validator (using reflection)
- [ ] Disallow optional array in `Attribute` and `Relationship` (should be empty array, not `null`).
- [ ] Only allow `Attribute` and `TransformAttribute` within `Attributes` struct.
- [ ] Only allow `ToManyRelationship` and `ToOneRelationship` within `Relationships` struct.
-
-### Strict Decoding/Encoding Settings
- [ ] Error (potentially while still encoding/decoding successfully) if an included entity is not related to a primary entity (Turned off by default).
-
-### Misc
- [x] Support transforms on `Attributes` values (e.g. to support different representations of `Date`)
- [x] Support ability to distinguish between `Attributes` fields that are optional (i.e. the key might not be there) and `Attributes` values that are optional (i.e. the key is guaranteed to be there but it might be `null`).
- [x] Fix `ToOneRelationship` so that it is possible to specify an optional relationship where the value is `null` rather than the key being omitted.
- [x] Conform to `CustomStringConvertible`
- [x] More tests around failing to decode improperly structured JSON (not bad JSON, but JSON that is not to spec)
- [ ] Use `KeyPath` to specify `Includes` thus creating type safety around the relationship between a primary resource type and the types of included resources????
- [x] For `NoIncludes`, do not even loop over the "included" JSON API section if it exists.
- [ ] Property-based testing (using `SwiftCheck`)
- [x] Roll my own `Result` or find an alternative that doesn't use `Foundation`.
- [ ] Create more descriptive errors that are easier to use for troubleshooting.
-
-## Usage
+## Dev Environment
 ### Prerequisites
 1. Swift 4.2+ and Swift Package Manager

-### `EntityDescription`
+### Xcode project
+To create an Xcode project for JSONAPI, run
+`swift package generate-xcodeproj`

-An `EntityDescription` is the `JSONAPI` framework's specification for what the JSON API spec calls a *Resource Object*. You might create the following `EntityDescription` to represent a person in a network of friends:
+### Running the Playground
+To run the included Playground files, create an Xcode project using Swift Package Manager, then create an Xcode Workspace in the root of the repository and add both the generated Xcode project and the playground to the Workspace.
+
+Note that Playground support for importing non-system Frameworks is still a bit touchy as of Swift 4.2. Sometimes building, cleaning and building, or commenting out and then uncommenting import statements (especially in the Entities.swift Playground Source file) can get things working for me when I am getting an error about `JSONAPI` not being found.
+
+## Project Status
+
+### Encoding/Decoding
+#### Document
+- [x] `data`
+- [x] `included`
+- [x] `errors`
+- [x] `meta`
+- [x] `jsonapi`
+- [x] `links`
+
+#### Resource Object
+- [x] `id`
+- [x] `type`
+- [x] `attributes`
+- [x] `relationships`
+- [x] `links`
+- [x] `meta`
+
+#### Relationship Object
+- [x] `data`
+- [ ] `links`
+- [ ] `meta`
+
+#### Links Object
+- [x] `href`
+- [x] `meta`
+
+### Misc
+- [x] Support transforms on `Attributes` values (e.g. to support different representations of `Date`)
+- [x] Support validation on `Attributes`.
+- [ ] Create more descriptive errors that are easier to use for troubleshooting.
+
+### JSONAPITestLib
+#### Entity Validator
+- [x] Disallow optional array in `Attribute` (should be empty array, not `null`).
+- [x] Only allow `TransformedAttribute` and its derivatives within `Attributes` struct.
+- [x] Only allow `ToManyRelationship` and `ToOneRelationship` within `Relationships` struct.
+
+### Potential Improvements
+- [ ] (Maybe) Use `KeyPath` to specify `Includes` thus creating type safety around the relationship between a primary resource type and the types of included resources.
+- [ ] (Maybe) Replace `SingleResourceBody` and `ManyResourceBody` with support at the `Document` level to just interpret `PrimaryResource`, `PrimaryResource?`, or `[PrimaryResource]` as the same decoding/encoding strategies.
+- [ ] Property-based testing (using `SwiftCheck`).
+- [ ] Error or warning if an included entity is not related to a primary entity or another included entity (Turned off or at least not throwing by default).
+
+## Usage
+
+In this documentation, in order to draw attention to the difference between the `JSONAPI` framework (this Swift library) and the **JSON API Spec** (the specification this library helps you follow), the specification will consistently be referred to below as simply the **SPEC**.
+
+### `JSONAPI.EntityDescription`
+
+An `EntityDescription` is the `JSONAPI` framework's representation of what the **SPEC** calls a *Resource Object*. You might create the following `EntityDescription` to represent a person in a network of friends:

 ```
 enum PersonDescription: IdentifiedEntityDescription {
@@ -111,13 +100,13 @@ enum PersonDescription: IdentifiedEntityDescription {
 ```

 The requirements of an `EntityDescription` are:
-1. A static `var` "type" that matches the JSON type; The JSON spec requires every *Resource Object* to have a "type".
+1. A static `var` "type" that matches the JSON type; The **SPEC** requires every *Resource Object* to have a "type".
 2. A `struct` of `Attributes` **- OR -** `typealias Attributes = NoAttributes`
-3. A `struct` of `Relationships` **- OR -** `typealias Relationships = NoRelatives`
+3. A `struct` of `Relationships` **- OR -** `typealias Relationships = NoRelationships`

 Note that an `enum` type is used here for the `EntityDescription`; it could have been a `struct`, but `EntityDescription`s do not ever need to be created so an `enum` with no `case`s is a nice fit for the job.

-This readme doesn't go into detail on the JSON API Spec, but the following JSON API *Resource Object* would be described by the above `PersonDescription`:
+This readme doesn't go into detail on the **SPEC**, but the following *Resource Object* would be described by the above `PersonDescription`:

 ```
 {
@@ -147,58 +136,74 @@ This readme doesn't go into detail on the JSON API Spec, but the following JSON
 }
 ```

-### `Entity`
+### `JSONAPI.Entity`

-Once you have an `EntityDescription`, you _create_, _encode_, and _decode_ `Entity`s that "fit the description". If you have a `CreatableRawIdType` (see the section on `RawIdType`s below) then you can create new `Entity`s that will automatically be given unique Ids, but even without a `CreatableRawIdType` you can encode, decode and work with entities.
+Once you have an `EntityDescription`, you _create_, _encode_, and _decode_ `Entities` that "fit the description". If you have a `CreatableRawIdType` (see the section on `RawIdType`s below) then you can create new `Entities` that will automatically be given unique Ids, but even without a `CreatableRawIdType` you can encode, decode and work with entities.

-The `Entity` and `EntityDescription` together embody the rules and properties of a JSON API *Resource Object*.
+The `Entity` and `EntityDescription` together with a `JSONAPI.Meta` type and a `JSONAPI.Links` type embody the rules and properties of a JSON API *Resource Object*.

-An `Entity` needs to be specialized on two generic types. The first is the `EntityDescription` described above. The second is the type of Id to use for the `Entity`.
+An `Entity` needs to be specialized on four generic types. The first is the `EntityDescription` described above. The others are a `Meta`, `Links`, and `MaybeRawId`.
+
+#### `Meta`
+
+The second generic specialization on `Entity` is `Meta`. This is described in its own section [below](#jsonapimeta). All `Meta` at any level of a JSON API Document follow the same rules.
+
+#### `Links`
+
+The third generic specialization on `Entity` is `Links`. This is described in its own section [below](#jsonnapilinks). All `Links` at any level of a JSON API Document follow the same rules, although the **SPEC** makes different suggestions as to what types of links might live on which parts of the Document.

 #### `IdType`

-An `IdType` packages up two pieces of information: A unique identifier of a given `RawIdType` and the `EntityDescription` of the type of entity the Id identifies. Having the `EntityDescription` type associated with the Id makes it easy to store all of your entities in a local hash broken out by `EntityDescription`; You can pass Ids around and always know where to look for the `Entity` to which the Id refers. `RawIdType`s are documented below.
+ The second is the raw type of `Id` to use for the `Entity`. The actual `Id` of the `Entity` will not be a `RawIdType`, though. The `Id` will package a value of `RawIdType` with a specialized reference back to the `Entity` type it identifies. This just looks like `Id<RawIdType, Entity<EntityDescription, RawIdType>>`.
+
+Having the `Entity` type associated with the `Id` makes it easy to store all of your entities in a hash broken out by `Entity` type; You can pass `Ids` around and always know where to look for the `Entity` to which the `Id` refers.
+
+A `RawIdType` is the underlying type that uniquely identifies an `Entity`. This is often a `String` or a `UUID`.
+
+#### `MaybeRawId`
+
+`MaybeRawId` is either a `RawIdType` that can be used to uniquely identify `Entities` or it is `Unidentified` which is used to indicate an `Entity` does not have an `Id` (which is useful when a client is requesting that the server create an `Entity` and assign it a new `Id`).

 #### Convenient `typealiases`

 Often you can use one `RawIdType` for many if not all of your `Entities`. That means you can save yourself some boilerplate by using `typealias`es like the following:
 ```
-public typealias Entity<Description: JSONAPI.EntityDescription> = JSONAPI.Entity<Description, Id<String, Description>>
+public typealias Entity<Description: JSONAPI.EntityDescription, Meta: JSONAPI.Meta, Links: JSONAPI.Links> = JSONAPI.Entity<Description, Meta, Links, String>

-public typealias NewEntity<Description: JSONAPI.EntityDescription> = JSONAPI.Entity<Description, Unidentified>
+public typealias NewEntity<Description: JSONAPI.EntityDescription, Meta: JSONAPI.Meta, Links: JSONAPI.Links> = JSONAPI.Entity<Description, Meta, Links, Unidentified>
 ```

 It can also be nice to create a `typealias` for each type of entity you want to work with:
 ```
-typealias Person = Entity<PersonDescription>
+typealias Person = Entity<PersonDescription, NoMetadata, NoLinks>

-typealias NewPerson = NewEntity<PersonDescription>
+typealias NewPerson = NewEntity<PersonDescription, NoMetadata, NoLinks>
 ```

-Note that I am assuming an unidentified person is a "new" person. I suspect that is generally an acceptable conflation because the only time JSON API spec allows a *Resource Object* to be encoded without an Id is when a client is requesting the given *Resource Object* be created by the server and the client wants the server to create the Id for that object.
+Note that I am assuming an unidentified person is a "new" person. I suspect that is generally an acceptable conflation because the only time the **SPEC** allows a *Resource Object* to be encoded without an `Id` is when a client is requesting the given *Resource Object* be created by the server and the client wants the server to create the `Id` for that object.

-### `Relationships`
+### `JSONAPI.Relationships`

-There are two types of `Relationship`s: `ToOneRelationship` and `ToManyRelationship`. An `EntityDescription`'s `Relationships` type can contain any number of `Relationship`s of either of these types. Do not store anything other than `Relationship`s in the `Relationships` struct of an `EntityDescription`.
+There are two types of `Relationships`: `ToOneRelationship` and `ToManyRelationship`. An `EntityDescription`'s `Relationships` type can contain any number of `Relationship` properties of either of these types. Do not store anything other than `Relationship` properties in the `Relationships` struct of an `EntityDescription`.

-To describe a relationship that may be omitted (i.e. the key is not even present in the JSON object), you make the entire `ToOneRelationship` or `ToManyRelationship` optional. However, this is not recommended because you can also represent optional relationships as nullable which means the key is always present. A `ToManyRelationship` can naturally represent no related objects exist with an empty array, so `ToManyRelationship` does not support nullability at all. A `ToOneRelationship` can be marked as nullable (i.e. the value might be `null` or it might be a resource identifier) like this:
+To describe a relationship that may be omitted (i.e. the key is not even present in the JSON object), you make the entire `ToOneRelationship` or `ToManyRelationship` optional. However, this is not recommended because you can also represent optional relationships as nullable which means the key is always present. A `ToManyRelationship` can naturally represent the absence of related values with an empty array, so `ToManyRelationship` does not support nullability at all. A `ToOneRelationship` can be marked as nullable (i.e. the value might be `null` or it might be a resource identifier) like this:
 ```
 let nullableRelative: ToOneRelationship<Person?>
 ```

 An entity that does not have relationships can be described by adding the following to an `EntityDescription`:
 ```
-typealias Relationships = NoRelatives
+typealias Relationships = NoRelationships
 ```

-`Relationship`s boil down to Ids of other entities. To access the Id of a related entity, you can use the shorthand `~>` operator with the `KeyPath` of the `Relationship` from which you want the Id. The friends of the above `Person` entity could be accessed as follows (type annotations for clarity):
+`Relationship` values boil down to `Ids` of other entities. To access the `Id` of a related `Entity`, you can use the custom `~>` operator with the `KeyPath` of the `Relationship` from which you want the `Id`. The friends of the above `Person` `Entity` can be accessed as follows (type annotations for clarity):
 ```
 let friendIds: [Person.Identifier] = person ~> \.friends
 ```

-### `Attributes`
+### `JSONAPI.Attributes`

-The `Attributes` of an `EntityDescription` can contain any JSON encodable/decodable types as long as they are wrapped in an `Attribute` or `TransformAttribute` `struct`. This is the place to store all attributes of an entity.
+The `Attributes` of an `EntityDescription` can contain any JSON encodable/decodable types as long as they are wrapped in an `Attribute`, `ValidatedAttribute`, or `TransformedAttribute` `struct`.

 To describe an attribute that may be omitted (i.e. the key might not even be in the JSON object), you make the entire `Attribute` optional:
 ```
@@ -222,12 +227,12 @@ let favoriteColor: String = person[\.favoriteColor]

 #### `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. To do this, you create a `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`.

 A `Transformer` just provides one static function that transforms one type to another. You might define one for an ISO 8601 compliant `Date` like this:
 ```
 enum ISODateTransformer: Transformer {
-	public static func transform(_ from: String) throws -> Date {
+	public static func transform(_ value: String) throws -> Date {
 		// parse Date out of input and return
 	}
 }
@@ -240,32 +245,60 @@ let date: TransformedAttribute<String, ISODateTransformer>

 Note that the first generic parameter of `TransformAttribute` is the type you expect to decode from JSON, not the type you want to end up with after transformation.

+If you make your `Transformer` a `ReversibleTransformer` then your life will be a bit easier when you construct `TransformedAttributes` because you have access to initializers for both the pre- and post-transformed value types. Continuing with the above example of a `ISODateTransformer`:
+```
+extension ISODateTransformer: ReversibleTransformer {
+	public static func reverse(_ value: Date) throws -> String {
+		// serialize Date to a String
+	}
+}
+
+let exampleAttribute = try? TransformedAttribute<String, ISODateTransformer>(transformedValue: Date())
+let otherAttribute = try? TransformedAttribute<String, ISODateTransformer>(rawValue: "2018-12-01 09:06:41 +0000")
+```
+
 #### `Validator`

-You can also creator `Validator`s and `ValidatedAttribute`s. A `Validator` is just a `Transformer` that by convention does not perform a transformation. It simply `throws` if an attribute value is invalid.
+You can also creator `Validators` and `ValidatedAttribute`s. A `Validator` is just a `Transformer` that by convention does not perform a transformation. It simply `throws` if an attribute value is invalid.

-### `JSONAPIDocument`
+#### Computed `Attribute`

-The entirety of a JSON API request or response is encoded or decoded from- or to a `JSONAPIDocument`. As an example, a JSON API response containing one `Person` and no included entities could be decoded as follows:
+You can add computed properties to your `EntityDescription.Attributes` struct if you would like to expose attributes that are not explicitly represented by the JSON. These computed properties should still have the type `Attribute` because that way you can take advantage of the quick access provided by `Entity`'s subscript operator. Here's an example of how you might take the `Person[\.name]` attribute from the example above and create a `fullName` computed property.
+
+```
+public var fullName: Attribute<String> {
+	return name.map { $0.joined(separator: " ") }
+}
+```
+
+### `JSONAPI.Document`
+
+The entirety of a JSON API request or response is encoded or decoded from- or to a `Document`. As an example, a JSON API response containing one `Person` and no included entities could be decoded as follows:
 ```
 let decoder = JSONDecoder()

-let responseStructure = JSONAPIDocument<SingleResourceBody<Person>, NoMetadata, NoLinks, NoIncludes, BasicJSONAPIError>.self
+let responseStructure = JSONAPI.Document<SingleResourceBody<Person>, NoMetadata, NoLinks, NoIncludes, UnknownJSONAPIError>.self

 let document = try decoder.decode(responseStructure, from: data)
 ```

-This document is guaranteed by the JSON API spec to be "data", "metadata", or "errors." If it is "data", it may also contain "metadata" and/or other "included" resources. If it is "errors," it may also contain "metadata."
+A JSON API Document is guaranteed by the **SPEC** to be "data", "metadata", or "errors." If it is "data", it may also contain "metadata" and/or other "included" resources. If it is "errors," it may also contain "metadata."

 #### `ResourceBody`

-The first generic type of a `JSONAPIDocument` is a `ResourceBody`. This can either be a `SingleResourceBody` or a `ManyResourceBody`. You will find zero or one `Entity` values in a JSON API document that has a `SingleResourceBody` and you will find zero or more `Entity` values in a JSON API document that has a `ManyResourceBody`. You can use the `Poly` types (`Poly1` through `Poly6`) to specify that a `ResourceBody` will be one of a few different types of `Entity`. These `Poly` types work in the same way as the `Include` types described below.
+The first generic type of a `JSONAPIDocument` is a `ResourceBody`. This can either be a `SingleResourceBody<PrimaryResource>` or a `ManyResourceBody<PrimaryResource>`. You will find zero or one `PrimaryResource` values in a JSON API document that has a `SingleResourceBody` and you will find zero or more `PrimaryResource` values in a JSON API document that has a `ManyResourceBody`. You can use the `Poly` types (`Poly1` through `Poly6`) to specify that a `ResourceBody` will be one of a few different types of `Entity`. These `Poly` types work in the same way as the `Include` types described below.

 If you expect a response to not have a "data" top-level key at all, then use `NoResourceBody` instead.

+##### nullable `PrimaryResource`
+
+If you expect a `SingleResourceBody` to sometimes come back `null`, you should make your `PrimaryResource` optional. If you do not make your `PrimaryResource` optional then a `null` primary resource will be considered an error when parsing the JSON.
+
+You cannot, however, use an optional `PrimaryResource` with a `ManyResourceBody` because the **SPEC** requires that an empty document in that case be represented by an empty array rather than `null`.
+
 #### `MetaType`

-The second generic type of a `JSONAPIDocument` is a `Meta`. This structure is entirely open-ended. As an example, the JSON API document may contain the following pagination info in its meta entry:
+The second generic type of a `JSONAPIDocument` is a `Meta`. This `Meta` follows the same rules as `Meta` at any other part of a JSON API Document. It is described below in its own section, but as an example, the JSON API document could contain the following pagination info in its meta entry:
 ```
 {
 	"meta": {
@@ -279,9 +312,9 @@ The second generic type of a `JSONAPIDocument` is a `Meta`. This structure is en
 You would then create the following `Meta` type:
 ```
 struct PageMetadata: JSONAPI.Meta {
-		let total: Int
-		let limit: Int
-		let offset: Int
+	let total: Int
+	let limit: Int
+	let offset: Int
 }
 ```

@@ -289,9 +322,7 @@ You can always use `NoMetadata` if this JSON API feature is not needed.

 #### `LinksType`

-The third generic type of a `JSONAPIDocument` is a `Links` struct. A `Links` struct must contain only `Link` properties. Each `Link` property can either be a `URL` or a `URL` and some `Meta`.
-
-You can specify `NoLinks` if the document should not contain any links.
+The third generic type of a `JSONAPIDocument` is a `Links` struct. `Links` are described in their own section [below](#jsonapilinks).

 #### `IncludeType`

@@ -301,11 +332,33 @@ The fourth generic type of a `JSONAPIDocument` is an `Include`. This type contro

 To specify that we expect friends of a person to be included in the above example `JSONAPIDocument`, we would use `Include1<Person>` instead of `NoIncludes`.

+#### `APIDescriptionType`
+
+The fifth generic type of a `JSONAPIDocument` is an `APIDescription`. The type represents the "JSON:API Object" described by the **SPEC**. This type describes the highest version of the **SPEC** supported and can carry additional metadata to describe the API.
+
+You can specify this is not part of the document by using the `NoAPIDescription` type.
+
+You can describe the API by a version with no metadata by using `APIDescription<NoMetadata>`.
+
+You can supply any `JSONAPI.Meta` type as the metadata type of the API description.
+
 #### `Error`

-The final generic type of a `JSONAPIDocument` is the `Error`. You should create an error type that can decode all the errors you expect your `JSONAPIDocument` to be able to decode. As prescribed by the JSON API Spec, these errors will be found in the root document member `errors`.
+The final generic type of a `JSONAPIDocument` is the `Error`. You should create an error type that can decode all the errors you expect your `JSONAPIDocument` to be able to decode. As prescribed by the **SPEC**, these errors will be found in the root document member `errors`.

-### `RawIdType`
+### `JSONAPI.Meta`
+
+A `Meta` struct is totally open-ended. It is described by the **SPEC** as a place to put any information that does not fit into the standard JSON API Document structure anywhere else.
+
+You can specify `NoMetadata` if the part of the document being described should not contain any `Meta`.
+
+### `JSONAPI.Links`
+
+A `Links` struct must contain only `Link` properties. Each `Link` property can either be a `URL` or a `URL` and some `Meta`. Each part of the document has some suggested common `Links` to include but generally any link can be included.
+
+You can specify `NoLinks` if the part of the document being described should not contain any `Links`.
+
+### `JSONAPI.RawIdType`

 If you want to create new `JSONAPI.Entity` values and assign them Ids then you will need to conform at least one type to `CreatableRawIdType`. Doing so is easy; here are two example conformances for `UUID` and `String` (via `UUID`):
 ```
@@ -321,3 +374,6 @@ extension String: CreatableRawIdType {
 	}
 }
 ```
+
+# JSONAPITestLib
+The `JSONAPI` framework is packaged with a test library to help you test your `JSONAPI` integration. The test library is called `JSONAPITestLib`. It provides literal expressibility for `Attribute`, `ToOneRelationship`, and `Id` in many situations so that you can easily write test `Entity` values into your unit tests. It also provides a `check()` function for each `Entity` type that can be used to catch problems with your `JSONAPI` structures that are not caught by Swift's type system. You can see the `JSONAPITestLib` in action in the Playground included with the `JSONAPI` repository.
@@ -0,0 +1,57 @@
+//
+//  APIDescription.swift
+//  JSONAPI
+//
+//  Created by Mathew Polzin on 12/1/18.
+//
+
+/// This is what the JSON API Spec calls the "JSON:API Object"
+public protocol APIDescriptionType: Codable, Equatable {
+	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 struct NoAPIDescription: APIDescriptionType, CustomStringConvertible {
+	public typealias Meta = NoMetadata
+
+	public init() {}
+
+	public static var none: NoAPIDescription { return .init() }
+
+	public var description: String { return "No JSON:API Object" }
+}
+
+extension APIDescription {
+	private enum CodingKeys: String, CodingKey {
+		case version
+		case meta
+	}
+
+	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"
+
+		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)
+
+		try container.encode(version, forKey: .version)
+
+		if Meta.self != NoMetadata.self {
+			try container.encode(meta, forKey: .meta)
+		}
+	}
+}
@@ -5,6 +5,19 @@
 //  Created by Mathew Polzin on 11/5/18.
 //

+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
+
+	var body: Body { get }
+}
+
 /// A JSON API Document represents the entire body
 /// of a JSON API request or the entire body of
 /// a JSON API response.
@@ -12,15 +25,37 @@
 /// API uses snake case, you will want to use
 /// a conversion such as the one offerred by the
 /// Foundation JSONEncoder/Decoder: `KeyDecodingStrategy`
-public struct JSONAPIDocument<ResourceBody: JSONAPI.ResourceBody, MetaType: JSONAPI.Meta, LinksType: JSONAPI.Links, IncludeType: JSONAPI.Include, Error: JSONAPIError>: Equatable {
+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
+	/// and metadata information about the API itself.
+	public let apiDescription: APIDescription
+
+	/// The Body of the Document. This body is either one or more errors
+	/// with links and metadata attempted to parse but not guaranteed or
+	/// it is a successful data struct containing all the primary and
+	/// included resources, the metadata, and the links that this
+	/// document type specifies.
 	public let body: Body
-//	public let jsonApi: APIDescription?
 	
 	public enum Body: Equatable {
 		case errors([Error], meta: MetaType?, links: LinksType?)
-		case data(primary: ResourceBody, included: Includes<Include>, meta: MetaType, links: LinksType)
+		case data(Data)
+
+		public struct Data: Equatable {
+			public let primary: PrimaryResourceBody
+			public let includes: Includes<Include>
+			public let meta: MetaType
+			public let links: LinksType
+
+			public init(primary: PrimaryResourceBody, includes: Includes<Include>, meta: MetaType, links: LinksType) {
+				self.primary = primary
+				self.includes = includes
+				self.meta = meta
+				self.links = links
+			}
+		}

 		public var isError: Bool {
 			guard case .errors = self else { return false }
@@ -32,20 +67,21 @@ public struct JSONAPIDocument<ResourceBody: JSONAPI.ResourceBody, MetaType: JSON
 			return errors
 		}
 		
-		public var primaryData: ResourceBody? {
-			guard case let .data(primary: body, included: _, meta: _, links: _) = self else { return nil }
-			return body
+		public var primaryData: PrimaryResourceBody? {
+			guard case let .data(data) = self else { return nil }
+			return data.primary
 		}

 		public var includes: Includes<Include>? {
-			guard case let .data(primary: _, included: includes, meta: _, links: _) = self else { return nil }
-			return includes
+			guard case let .data(data) = self else { return nil }
+			return data.includes
 		}

 		public var meta: MetaType? {
 			switch self {
-			case .data(primary: _, included: _, meta: let metadata, links: _),
-				 .errors(_, meta: let metadata?, links: _):
+			case .data(let data):
+				return data.meta
+			case .errors(_, meta: let metadata?, links: _):
 				return metadata
 			default:
 				return nil
@@ -54,8 +90,9 @@ public struct JSONAPIDocument<ResourceBody: JSONAPI.ResourceBody, MetaType: JSON

 		public var links: LinksType? {
 			switch self {
-			case .data(primary: _, included: _, meta: _, links: let links),
-				 .errors(_, meta: _, links: let links?):
+			case .data(let data):
+				return data.links
+			case .errors(_, meta: _, links: let links?):
 				return links
 			default:
 				return nil
@@ -63,58 +100,90 @@ public struct JSONAPIDocument<ResourceBody: JSONAPI.ResourceBody, MetaType: JSON
 		}
 	}

-	public init(errors: [Error], meta: MetaType? = nil, links: LinksType? = nil) {
+	public init(apiDescription: APIDescription, errors: [Error], meta: MetaType? = nil, links: LinksType? = nil) {
 		body = .errors(errors, meta: meta, links: links)
+		self.apiDescription = apiDescription
 	}

-	public init(body: ResourceBody, includes: Includes<Include>, meta: MetaType, links: LinksType) {
-		self.body = .data(primary: body, included: includes, meta: meta, links: links)
+	public init(apiDescription: APIDescription, body: PrimaryResourceBody, includes: Includes<Include>, meta: MetaType, links: LinksType) {
+		self.body = .data(.init(primary: body, includes: includes, meta: meta, links: links))
+		self.apiDescription = apiDescription
 	}
 }

-extension JSONAPIDocument where IncludeType == NoIncludes {
-	public init(body: ResourceBody, meta: MetaType, links: LinksType) {
-		self.body = .data(primary: body, included: .none, meta: meta, links: links)
+extension Document where IncludeType == NoIncludes {
+	public init(apiDescription: APIDescription, body: PrimaryResourceBody, meta: MetaType, links: LinksType) {
+		self.init(apiDescription: apiDescription, body: body, includes: .none, meta: meta, links: links)
 	}
 }

-extension JSONAPIDocument where MetaType == NoMetadata {
-	public init(body: ResourceBody, includes: Includes<Include>, links: LinksType) {
-		self.body = .data(primary: body, included: includes, meta: .none, links: links)
+extension Document where MetaType == NoMetadata {
+	public init(apiDescription: APIDescription, body: PrimaryResourceBody, includes: Includes<Include>, links: LinksType) {
+		self.init(apiDescription: apiDescription, body: body, includes: includes, meta: .none, links: links)
 	}
 }

-extension JSONAPIDocument where LinksType == NoLinks {
-	public init(body: ResourceBody, includes: Includes<Include>, meta: MetaType) {
-		self.body = .data(primary: body, included: includes, meta: meta, links: .none)
+extension Document where LinksType == NoLinks {
+	public init(apiDescription: APIDescription, body: PrimaryResourceBody, includes: Includes<Include>, meta: MetaType) {
+		self.init(apiDescription: apiDescription, body: body, includes: includes, meta: meta, links: .none)
 	}
 }

-extension JSONAPIDocument where IncludeType == NoIncludes, LinksType == NoLinks {
-	public init(body: ResourceBody, meta: MetaType) {
-		self.body = .data(primary: body, included: .none, meta: meta, links: .none)
+extension Document where APIDescription == NoAPIDescription {
+	public init(body: PrimaryResourceBody, includes: Includes<Include>, meta: MetaType, links: LinksType) {
+		self.init(apiDescription: .none, body: body, includes: includes, meta: meta, links: links)
 	}
 }

-extension JSONAPIDocument where IncludeType == NoIncludes, MetaType == NoMetadata {
-	public init(body: ResourceBody, links: LinksType) {
-		self.body = .data(primary: body, included: .none, meta: .none, links: links)
+extension Document where IncludeType == NoIncludes, LinksType == NoLinks {
+	public init(apiDescription: APIDescription, body: PrimaryResourceBody, meta: MetaType) {
+		self.init(apiDescription: apiDescription, body: body, meta: meta, links: .none)
 	}
 }

-extension JSONAPIDocument where MetaType == NoMetadata, LinksType == NoLinks {
-	public init(body: ResourceBody, includes: Includes<Include>) {
-		self.body = .data(primary: body, included: includes, meta: .none, links: .none)
+extension Document where IncludeType == NoIncludes, MetaType == NoMetadata {
+	public init(apiDescription: APIDescription, body: PrimaryResourceBody, links: LinksType) {
+		self.init(apiDescription: apiDescription, body: body, meta: .none, links: links)
 	}
 }

-extension JSONAPIDocument where IncludeType == NoIncludes, MetaType == NoMetadata, LinksType == NoLinks {
-	public init(body: ResourceBody) {
-		self.body = .data(primary: body, included: .none, meta: .none, links: .none)
+extension Document where IncludeType == NoIncludes, APIDescription == NoAPIDescription {
+	public init(body: PrimaryResourceBody, meta: MetaType, links: LinksType) {
+		self.init(apiDescription: .none, body: body, meta: meta, links: links)
 	}
 }

-extension JSONAPIDocument: Codable {
+extension Document where MetaType == NoMetadata, LinksType == NoLinks {
+	public init(apiDescription: APIDescription, body: PrimaryResourceBody, includes: Includes<Include>) {
+		self.init(apiDescription: apiDescription, body: body, includes: includes, links: .none)
+	}
+}
+
+extension Document where MetaType == NoMetadata, APIDescription == NoAPIDescription {
+	public init(body: PrimaryResourceBody, includes: Includes<Include>, links: LinksType) {
+		self.init(apiDescription: .none, body: body, includes: includes, links: links)
+	}
+}
+
+extension Document where IncludeType == NoIncludes, MetaType == NoMetadata, LinksType == NoLinks {
+	public init(apiDescription: APIDescription, body: PrimaryResourceBody) {
+		self.init(apiDescription: apiDescription, body: body, includes: .none)
+	}
+}
+
+extension Document where MetaType == NoMetadata, LinksType == NoLinks, APIDescription == NoAPIDescription {
+	public init(body: PrimaryResourceBody, includes: Includes<Include>) {
+		self.init(apiDescription: .none, body: body, includes: includes)
+	}
+}
+
+extension Document where IncludeType == NoIncludes, MetaType == NoMetadata, LinksType == NoLinks, APIDescription == NoAPIDescription {
+	public init(body: PrimaryResourceBody) {
+		self.init(apiDescription: .none, body: body)
+	}
+}
+
+extension Document {
 	private enum RootCodingKeys: String, CodingKey {
 		case data
 		case errors
@@ -127,6 +196,12 @@ extension JSONAPIDocument: Codable {
 	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?
@@ -157,11 +232,11 @@ extension JSONAPIDocument: Codable {
 			return
 		}

-		let data: ResourceBody
-		if let noData = NoResourceBody() as? ResourceBody {
+		let data: PrimaryResourceBody
+		if let noData = NoResourceBody() as? PrimaryResourceBody {
 			data = noData
 		} else {
-			data = try container.decode(ResourceBody.self, forKey: .data)
+			data = try container.decode(PrimaryResourceBody.self, forKey: .data)
 		}

 		let maybeIncludes = try container.decodeIfPresent(Includes<Include>.self, forKey: .included)
@@ -175,7 +250,7 @@ extension JSONAPIDocument: Codable {
 			throw JSONAPIEncodingError.missingOrMalformedLinks
 		}
 		
-		body = .data(primary: data, included: maybeIncludes ?? Includes<Include>.none, meta: metaVal, links: linksVal)
+		body = .data(.init(primary: data, includes: maybeIncludes ?? Includes<Include>.none, meta: metaVal, links: linksVal))
 	}

 	public func encode(to encoder: Encoder) throws {
@@ -199,28 +274,49 @@ extension JSONAPIDocument: Codable {
 				try container.encode(linksVal, forKey: .links)
 			}

-		case .data(primary: let resourceBody, included: let includes, let meta, links: let links):
-			try container.encode(resourceBody, forKey: .data)
+		case .data(let data):
+			try container.encode(data.primary, forKey: .data)

 			if Include.self != NoIncludes.self {
-				try container.encode(includes, forKey: .included)
+				try container.encode(data.includes, forKey: .included)
 			}

 			if MetaType.self != NoMetadata.self {
-				try container.encode(meta, forKey: .meta)
+				try container.encode(data.meta, forKey: .meta)
 			}

 			if LinksType.self != NoLinks.self {
-				try container.encode(links, forKey: .links)
+				try container.encode(data.links, forKey: .links)
 			}
 		}
+
+		if APIDescription.self != NoAPIDescription.self {
+			try container.encode(apiDescription, forKey: .jsonapi)
+		}
 	}
 }

 // MARK: - CustomStringConvertible

-extension JSONAPIDocument: CustomStringConvertible {
+extension Document: CustomStringConvertible {
 	public var description: String {
-		return "JSONAPIDocument(body: \(String(describing: body))"
+		return "Document(\(String(describing: body)))"
+	}
+}
+
+extension Document.Body: CustomStringConvertible {
+	public var description: String {
+		switch self {
+		case .errors(let errors, meta: let meta, links: let links):
+			return "errors: \(String(describing: errors)), meta: \(String(describing: meta)), links: \(String(describing: links))"
+		case .data(let data):
+			return String(describing: data)
+		}
+	}
+}
+
+extension Document.Body.Data: CustomStringConvertible {
+	public var description: String {
+		return "primary: \(String(describing: primary)), includes: \(String(describing: includes)), meta: \(String(describing: meta)), links: \(String(describing: links))"
 	}
 }
@@ -9,7 +9,7 @@ public protocol JSONAPIError: Swift.Error, Equatable, Codable {
 	static var unknown: Self { get }
 }

-public enum BasicJSONAPIError: JSONAPIError {
+public enum UnknownJSONAPIError: JSONAPIError {
 	case unknownError
 	
 	public init(from decoder: Decoder) throws {
@@ -21,7 +21,7 @@ public enum BasicJSONAPIError: JSONAPIError {
 		try container.encode("unknown")
 	}
 	
-	public static var unknown: BasicJSONAPIError {
+	public static var unknown: UnknownJSONAPIError {
 		return .unknownError
 	}
 }
@@ -1,24 +1,33 @@
 //
-//  ResourceBody.swift
+//  PrimaryResourceBody.swift
 //  JSONAPI
 //
 //  Created by Mathew Polzin on 11/10/18.
 //

-public protocol PrimaryResource: Equatable, Codable {}
+public protocol MaybePrimaryResource: Equatable, Codable {}

+/// A PrimaryResource is a type that can be used in the body of a JSON API
+/// document as the primary resource.
+public protocol PrimaryResource: MaybePrimaryResource {}
+
+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: Codable, Equatable {
 }

-public struct SingleResourceBody<Entity: JSONAPI.PrimaryResource>: ResourceBody {
-	public let value: Entity?
+public struct SingleResourceBody<Entity: JSONAPI.MaybePrimaryResource>: ResourceBody {
+	public let value: Entity

-	public init(entity: Entity?) {
+	public init(entity: Entity) {
 		self.value = entity
 	}
 }

-public struct ManyResourceBody<Entity: JSONAPI.EntityType>: ResourceBody {
+public struct ManyResourceBody<Entity: JSONAPI.PrimaryResource>: ResourceBody {
 	public let values: [Entity]

 	public init(entities: [Entity]) {
@@ -32,13 +41,15 @@ public struct NoResourceBody: ResourceBody {
 	public static var none: NoResourceBody { return NoResourceBody() }
 }

-// MARK: Decodable
+// MARK: Codable
 extension SingleResourceBody {
 	public init(from decoder: Decoder) throws {
 		let container = try decoder.singleValueContainer()

-		if container.decodeNil() {
-			value = nil
+		let anyNil: Any? = nil
+		if container.decodeNil(),
+			let val = anyNil as? Entity {
+			value = val
 			return
 		}

@@ -48,7 +59,7 @@ extension SingleResourceBody {
 	public func encode(to encoder: Encoder) throws {
 		var container = encoder.singleValueContainer()

-		if value == nil {
+		if (value as Any?) == nil {
 			try container.encodeNil()
 			return
 		}
@@ -80,12 +91,12 @@ extension ManyResourceBody {

 extension SingleResourceBody: CustomStringConvertible {
 	public var description: String {
-		return "ResourceBody(\(String(describing: value)))"
+		return "PrimaryResourceBody(\(String(describing: value)))"
 	}
 }

 extension ManyResourceBody: CustomStringConvertible {
 	public var description: String {
-		return "ResourceBody(\(String(describing: values)))"
+		return "PrimaryResourceBody(\(String(describing: values)))"
 	}
 }
@@ -9,16 +9,29 @@
 public protocol Links: Codable, Equatable {}

 /// Use NoLinks where no links should belong to a JSON API component
-public struct NoLinks: Links {
+public struct NoLinks: Links, CustomStringConvertible {
 	public static var none: NoLinks { return NoLinks() }
 	public init() {}
+
+	public var description: String { return "No Links" }
 }

-public protocol URL: Codable, Equatable {}
+public protocol JSONAPIURL: Codable, Equatable {}

-public struct Link<URL: JSONAPI.URL, Meta: JSONAPI.Meta>: Equatable, Codable {
+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
+	}
+}
+
+extension Link where Meta == NoMetadata {
+	public init(url: URL) {
+		self.init(url: url, meta: .none)
+	}
 }

 public extension Link {
@@ -19,8 +19,10 @@ public protocol Meta: Codable, Equatable {
 // nullable.
 extension Optional: Meta where Wrapped: Meta {}

-public struct NoMetadata: Meta {
+public struct NoMetadata: Meta, CustomStringConvertible {
 	public static var none: NoMetadata { return NoMetadata() }

 	public init() { }
+
+	public var description: String { return "No Metadata" }
 }
@@ -0,0 +1,21 @@
+//
+//  Attribute+Functor.swift
+//  JSONAPI
+//
+//  Created by Mathew Polzin on 11/28/18.
+//
+
+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.
+	public func map<T: Codable>(_ transform: (Transformer.To) throws -> T) rethrows -> Attribute<T> {
+		return Attribute<T>(value: try transform(value))
+	}
+}
@@ -5,7 +5,10 @@
 //  Created by Mathew Polzin on 11/13/18.
 //

-public struct TransformedAttribute<RawValue: Codable, Transformer: JSONAPI.Transformer>: Codable where Transformer.From == RawValue {
+public protocol AttributeType: Codable {
+}
+
+public struct TransformedAttribute<RawValue: Codable, Transformer: JSONAPI.Transformer>: AttributeType where Transformer.From == RawValue {
 	private let rawValue: RawValue
 	
 	public let value: Transformer.To
@@ -16,6 +19,13 @@ public struct TransformedAttribute<RawValue: Codable, Transformer: JSONAPI.Trans
 	}
 }

+extension TransformedAttribute where Transformer: ReversibleTransformer {
+	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)))"
@@ -24,6 +34,15 @@ extension TransformedAttribute: CustomStringConvertible {

 extension TransformedAttribute: Equatable where Transformer.From: Equatable, Transformer.To: Equatable {}

+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
+	}
+}
+
 public typealias ValidatedAttribute<RawValue: Codable, Validator: JSONAPI.Validator> = TransformedAttribute<RawValue, Validator> where RawValue == Validator.From

 public typealias Attribute<T: Codable> = TransformedAttribute<T, IdentityTransformer<T>>
@@ -16,11 +16,15 @@ public typealias Attributes = Codable & Equatable

 /// Can be used as `Relationships` Type for Entities that do not
 /// have any Relationships.
-public struct NoRelatives: Relationships {}
+public struct NoRelationships: Relationships {
+	public static var none: NoRelationships { return .init() }
+}

 /// Can be used as `Attributes` Type for Entities that do not
 /// have any Attributes.
-public struct NoAttributes: Attributes {}
+public struct NoAttributes: Attributes {
+	public static var none: NoAttributes { return .init() }
+}

 /// An `EntityDescription` describes a JSON API
 /// Resource Object. The Resource Object
@@ -34,42 +38,81 @@ public protocol EntityDescription {
 	static var type: String { get }
 }

+/// EntityProxy is a protocol that can be used to create
+/// types that _act_ like Entities but cannot be encoded
+/// or decoded as Entities.
+public protocol EntityProxy: Equatable {
+	associatedtype Description: EntityDescription
+	associatedtype EntityRawIdType: JSONAPI.MaybeRawId
+
+	typealias Id = JSONAPI.Id<EntityRawIdType, Self>
+
+	typealias Attributes = Description.Attributes
+	typealias Relationships = Description.Relationships
+
+	/// The `Entity`'s Id. This can be of type `Unidentified` if
+	/// the entity is being created clientside and the
+	/// server is being asked to create a unique Id. Otherwise,
+	/// this should be of a type conforming to `IdType`.
+	var id: Id { get }
+
+	/// The JSON API compliant attributes of this `Entity`.
+	var attributes: Attributes { get }
+
+	/// The JSON API compliant relationships of this `Entity`.
+	var relationships: Relationships { get }
+}
+
+extension EntityProxy {
+	/// The JSON API compliant "type" of this `Entity`.
+	public static var type: String { return Description.type }
+}
+
 /// EntityType is the protocol that Entity conforms to. This
 /// protocol lets other types accept any Entity as a generic
 /// specialization.
-public protocol EntityType: PrimaryResource {
-	associatedtype Description: EntityDescription
-	associatedtype Identifier: Equatable & Codable
+public protocol EntityType: EntityProxy, PrimaryResource {
 }

+public protocol IdentifiableEntityType: EntityType, Relatable where EntityRawIdType: JSONAPI.RawIdType {}
+
 /// An `Entity` is a single model type that can be
 /// encoded to or decoded from a JSON API
 /// "Resource Object."
 /// See https://jsonapi.org/format/#document-resource-objects
-public struct Entity<Description: JSONAPI.EntityDescription, Identifier: JSONAPI.Identifier>: EntityType {
-	
-	/// The JSON API compliant "type" of this `Entity`.
-	public static var type: String { return Description.type }
-	
+public struct Entity<Description: JSONAPI.EntityDescription, MetaType: JSONAPI.Meta, LinksType: JSONAPI.Links, EntityRawIdType: JSONAPI.MaybeRawId>: EntityType {
 	/// The `Entity`'s Id. This can be of type `Unidentified` if
 	/// the entity is being created clientside and the
 	/// server is being asked to create a unique Id. Otherwise,
 	/// this should be of a type conforming to `IdType`.
-	public let id: Identifier
+	public let id: Entity.Id
 	
 	/// The JSON API compliant attributes of this `Entity`.
 	public let attributes: Description.Attributes
 	
 	/// The JSON API compliant relationships of this `Entity`.
 	public let relationships: Description.Relationships
+
+	/// Any additional metadata packaged with the entity.
+	public let meta: MetaType
+
+	/// Links related to the entity.
+	public let links: LinksType
 	
-	public init(id: Identifier, attributes: Description.Attributes, relationships: Description.Relationships) {
+	public init(id: Entity.Id, attributes: Description.Attributes, relationships: Description.Relationships, meta: MetaType, links: LinksType) {
 		self.id = id
 		self.attributes = attributes
 		self.relationships = relationships
+		self.meta = meta
+		self.links = links
 	}
 }

+extension Entity: IdentifiableEntityType, Relatable, WrappedRelatable where EntityRawIdType: JSONAPI.RawIdType {
+	public typealias Identifier = Entity.Id
+	public typealias WrappedIdentifier = Identifier
+}
+
 extension Entity: CustomStringConvertible {
 	public var description: String {
 		return "Entity<\(Entity.type)>(id: \(String(describing: id)), attributes: \(String(describing: attributes)), relationships: \(String(describing: relationships)))"
@@ -77,52 +120,220 @@ extension Entity: CustomStringConvertible {
 }

 // MARK: Convenience initializers
-extension Entity where Identifier: CreatableIdType {
-	public init(attributes: Description.Attributes, relationships: Description.Relationships) {
-		self.id = Identifier()
+extension Entity where EntityRawIdType: CreatableRawIdType {
+	public init(attributes: Description.Attributes, relationships: Description.Relationships, meta: MetaType, links: LinksType) {
+		self.id = Entity.Id()
 		self.attributes = attributes
 		self.relationships = relationships
+		self.meta = meta
+		self.links = links
+	}
+}
+
+extension Entity where EntityRawIdType == Unidentified {
+	public init(attributes: Description.Attributes, relationships: Description.Relationships, meta: MetaType, links: LinksType) {
+		self.id = .unidentified
+		self.attributes = attributes
+		self.relationships = relationships
+		self.meta = meta
+		self.links = links
 	}
 }

 extension Entity where Description.Attributes == NoAttributes {
-	public init(id: Identifier, relationships: Description.Relationships) {
-		self.init(id: id, attributes: NoAttributes(), relationships: relationships)
+	public init(id: Entity.Id, relationships: Description.Relationships, meta: MetaType, links: LinksType) {
+		self.init(id: id, attributes: NoAttributes(), relationships: relationships, meta: meta, links: links)
 	}
 }

-extension Entity where Description.Attributes == NoAttributes, Identifier: CreatableIdType {
+extension Entity where Description.Attributes == NoAttributes, MetaType == NoMetadata {
+	public init(id: Entity.Id, relationships: Description.Relationships, links: LinksType) {
+		self.init(id: id, relationships: relationships, meta: .none, links: links)
+	}
+}
+
+extension Entity where Description.Attributes == NoAttributes, LinksType == NoLinks {
+	public init(id: Entity.Id, relationships: Description.Relationships, meta: MetaType) {
+		self.init(id: id, relationships: relationships, meta: meta, links: .none)
+	}
+}
+
+extension Entity where Description.Attributes == NoAttributes, MetaType == NoMetadata, LinksType == NoLinks {
+	public init(id: Entity.Id, relationships: Description.Relationships) {
+		self.init(id: id, relationships: relationships, links: .none)
+	}
+}
+
+extension Entity where Description.Attributes == NoAttributes, EntityRawIdType: CreatableRawIdType {
+	public init(relationships: Description.Relationships, meta: MetaType, links: LinksType) {
+		self.init(attributes: NoAttributes(), relationships: relationships, meta: meta, links: links)
+	}
+}
+
+extension Entity where Description.Attributes == NoAttributes, MetaType == NoMetadata, EntityRawIdType: CreatableRawIdType {
+	public init(relationships: Description.Relationships, links: LinksType) {
+		self.init(attributes: NoAttributes(), relationships: relationships, meta: .none, links: links)
+	}
+}
+
+extension Entity where Description.Attributes == NoAttributes, LinksType == NoLinks, EntityRawIdType: CreatableRawIdType {
+	public init(relationships: Description.Relationships, meta: MetaType) {
+		self.init(attributes: NoAttributes(), relationships: relationships, meta: meta, links: .none)
+	}
+}
+
+extension Entity where Description.Attributes == NoAttributes, MetaType == NoMetadata, LinksType == NoLinks, EntityRawIdType: CreatableRawIdType {
 	public init(relationships: Description.Relationships) {
-		self.init(attributes: NoAttributes(), relationships: relationships)
+		self.init(attributes: NoAttributes(), relationships: relationships, meta: .none, links: .none)
 	}
 }

-extension Entity where Description.Relationships == NoRelatives {
-	public init(id: Identifier, attributes: Description.Attributes) {
-		self.init(id: id, attributes: attributes, relationships: NoRelatives())
+extension Entity where Description.Attributes == NoAttributes, EntityRawIdType == Unidentified {
+	public init(relationships: Description.Relationships, meta: MetaType, links: LinksType) {
+		self.init(attributes: NoAttributes(), relationships: relationships, meta: meta, links: links)
 	}
 }

-extension Entity where Description.Relationships == NoRelatives, Identifier: CreatableIdType {
+extension Entity where Description.Relationships == NoRelationships {
+	public init(id: Entity.Id, attributes: Description.Attributes, meta: MetaType, links: LinksType) {
+		self.init(id: id, attributes: attributes, relationships: NoRelationships(), meta: meta, links: links)
+	}
+}
+
+extension Entity where Description.Relationships == NoRelationships, MetaType == NoMetadata {
+	public init(id: Entity.Id, attributes: Description.Attributes, links: LinksType) {
+		self.init(id: id, attributes: attributes, meta: .none, links: links)
+	}
+}
+
+extension Entity where Description.Relationships == NoRelationships, LinksType == NoLinks {
+	public init(id: Entity.Id, attributes: Description.Attributes, meta: MetaType) {
+		self.init(id: id, attributes: attributes, meta: meta, links: .none)
+	}
+}
+
+extension Entity where Description.Relationships == NoRelationships, MetaType == NoMetadata, LinksType == NoLinks {
+	public init(id: Entity.Id, attributes: Description.Attributes) {
+		self.init(id: id, attributes: attributes, meta: .none, links: .none)
+	}
+}
+
+extension Entity where Description.Relationships == NoRelationships, EntityRawIdType: CreatableRawIdType {
+	public init(attributes: Description.Attributes, meta: MetaType, links: LinksType) {
+		self.init(attributes: attributes, relationships: NoRelationships(), meta: meta, links: links)
+	}
+}
+
+extension Entity where Description.Relationships == NoRelationships, MetaType == NoMetadata, EntityRawIdType: CreatableRawIdType {
+	public init(attributes: Description.Attributes, links: LinksType) {
+		self.init(attributes: attributes, relationships: NoRelationships(), meta: .none, links: links)
+	}
+}
+
+extension Entity where Description.Relationships == NoRelationships, LinksType == NoLinks, EntityRawIdType: CreatableRawIdType {
+	public init(attributes: Description.Attributes, meta: MetaType) {
+		self.init(attributes: attributes, relationships: NoRelationships(), meta: meta, links: .none)
+	}
+}
+
+extension Entity where Description.Relationships == NoRelationships, MetaType == NoMetadata, LinksType == NoLinks, EntityRawIdType: CreatableRawIdType {
 	public init(attributes: Description.Attributes) {
-		self.init(attributes: attributes, relationships: NoRelatives())
+		self.init(attributes: attributes, relationships: NoRelationships(), meta: .none, links: .none)
 	}
 }

-extension Entity where Description.Attributes == NoAttributes, Description.Relationships == NoRelatives {
-	public init(id: Identifier) {
-		self.init(id: id, attributes: NoAttributes(), relationships: NoRelatives())
+extension Entity where Description.Relationships == NoRelationships, EntityRawIdType == Unidentified {
+	public init(attributes: Description.Attributes, meta: MetaType, links: LinksType) {
+		self.init(attributes: attributes, relationships: NoRelationships(), meta: meta, links: links)
 	}
 }

-extension Entity where Description.Attributes == NoAttributes, Description.Relationships == NoRelatives, Identifier: CreatableIdType {
+extension Entity where Description.Relationships == NoRelationships, MetaType == NoMetadata, EntityRawIdType == Unidentified {
+	public init(attributes: Description.Attributes, links: LinksType) {
+		self.init(attributes: attributes, relationships: NoRelationships(), meta: .none, links: links)
+	}
+}
+
+extension Entity where Description.Relationships == NoRelationships, LinksType == NoLinks, EntityRawIdType == Unidentified {
+	public init(attributes: Description.Attributes, meta: MetaType) {
+		self.init(attributes: attributes, relationships: NoRelationships(), meta: meta, links: .none)
+	}
+}
+
+extension Entity where Description.Relationships == NoRelationships, MetaType == NoMetadata, LinksType == NoLinks, EntityRawIdType == Unidentified {
+	public init(attributes: Description.Attributes) {
+		self.init(attributes: attributes, relationships: NoRelationships(), meta: .none, links: .none)
+	}
+}
+
+extension Entity where Description.Attributes == NoAttributes, Description.Relationships == NoRelationships {
+	public init(id: Entity.Id, meta: MetaType, links: LinksType) {
+		self.init(id: id, attributes: NoAttributes(), relationships: NoRelationships(), meta: meta, links: links)
+	}
+}
+
+extension Entity where Description.Attributes == NoAttributes, Description.Relationships == NoRelationships, MetaType == NoMetadata {
+	public init(id: Entity.Id, links: LinksType) {
+		self.init(id: id, attributes: NoAttributes(), relationships: NoRelationships(), meta: .none, links: links)
+	}
+}
+
+extension Entity where Description.Attributes == NoAttributes, Description.Relationships == NoRelationships, LinksType == NoLinks {
+	public init(id: Entity.Id, meta: MetaType) {
+		self.init(id: id, attributes: NoAttributes(), relationships: NoRelationships(), meta: meta, links: .none)
+	}
+}
+
+extension Entity where Description.Attributes == NoAttributes, Description.Relationships == NoRelationships, MetaType == NoMetadata, LinksType == NoLinks {
+	public init(id: Entity.Id) {
+		self.init(id: id, attributes: NoAttributes(), relationships: NoRelationships(), meta: .none, links: .none)
+	}
+}
+
+extension Entity where Description.Attributes == NoAttributes, Description.Relationships == NoRelationships, EntityRawIdType: CreatableRawIdType {
+	public init(meta: MetaType, links: LinksType) {
+		self.init(attributes: NoAttributes(), relationships: NoRelationships(), meta: meta, links: links)
+	}
+}
+
+extension Entity where Description.Attributes == NoAttributes, Description.Relationships == NoRelationships, MetaType == NoMetadata, EntityRawIdType: CreatableRawIdType {
+	public init(links: LinksType) {
+		self.init(attributes: NoAttributes(), relationships: NoRelationships(), meta: .none, links: links)
+	}
+}
+
+extension Entity where Description.Attributes == NoAttributes, Description.Relationships == NoRelationships, LinksType == NoLinks, EntityRawIdType: CreatableRawIdType {
+	public init(meta: MetaType) {
+		self.init(attributes: NoAttributes(), relationships: NoRelationships(), meta: meta, links: .none)
+	}
+}
+
+extension Entity where Description.Attributes == NoAttributes, Description.Relationships == NoRelationships, MetaType == NoMetadata, LinksType == NoLinks, EntityRawIdType: CreatableRawIdType {
 	public init() {
-		self.init(attributes: NoAttributes(), relationships: NoRelatives())
+		self.init(attributes: NoAttributes(), relationships: NoRelationships(), meta: .none, links: .none)
+	}
+}
+
+extension Entity where MetaType == NoMetadata {
+	public init(id: Entity.Id, attributes: Description.Attributes, relationships: Description.Relationships, links: LinksType) {
+		self.init(id: id, attributes: attributes, relationships: relationships, meta: .none, links: links)
+	}
+}
+
+extension Entity where LinksType == NoLinks {
+	public init(id: Entity.Id, attributes: Description.Attributes, relationships: Description.Relationships, meta: MetaType) {
+		self.init(id: id, attributes: attributes, relationships: relationships, meta: meta, links: .none)
+	}
+}
+
+extension Entity where MetaType == NoMetadata, LinksType == NoLinks {
+	public init(id: Entity.Id, attributes: Description.Attributes, relationships: Description.Relationships) {
+		self.init(id: id, attributes: attributes, relationships: relationships, meta: .none, links: .none)
 	}
 }

 // MARK: Pointer for Relationships use.
-public extension Entity where Identifier: IdType {
+public extension Entity where EntityRawIdType: JSONAPI.RawIdType {
 	/// Get a pointer to this entity that can be used as a
 	/// relationship to another entity.
 	public var pointer: ToOneRelationship<Entity> {
@@ -131,21 +342,21 @@ public extension Entity where Identifier: IdType {
 }

 // MARK: Attribute Access
-public extension Entity {
+public extension EntityProxy {
 	/// Access the attribute at the given keypath. This just
 	/// allows you to write `entity[\.propertyName]` instead
 	/// of `entity.relationships.propertyName`.
 	subscript<T, TFRM: Transformer>(_ path: KeyPath<Description.Attributes, TransformedAttribute<T, TFRM>>) -> TFRM.To {
 		return attributes[keyPath: path].value
 	}
-	
+
 	/// Access the attribute at the given keypath. This just
 	/// allows you to write `entity[\.propertyName]` instead
 	/// of `entity.relationships.propertyName`.
 	subscript<T, TFRM: Transformer>(_ path: KeyPath<Description.Attributes, TransformedAttribute<T, TFRM>?>) -> TFRM.To? {
 		return attributes[keyPath: path]?.value
 	}
-	
+
 	/// Access the attribute at the given keypath. This just
 	/// allows you to write `entity[\.propertyName]` instead
 	/// of `entity.relationships.propertyName`.
@@ -155,18 +366,18 @@ public extension Entity {
 }

 // MARK: Relationship Access
-public extension Entity {
+public extension EntityProxy {
 	/// Access to an Id of a `ToOneRelationship`.
 	/// This allows you to write `entity ~> \.other` instead
 	/// of `entity.relationships.other.id`.
-	public static func ~><OtherEntity: OptionalRelatable>(entity: Entity, path: KeyPath<Description.Relationships, ToOneRelationship<OtherEntity>>) -> OtherEntity.WrappedIdentifier {
+	public static func ~><OtherEntity: OptionalRelatable>(entity: Self, path: KeyPath<Description.Relationships, ToOneRelationship<OtherEntity>>) -> OtherEntity.WrappedIdentifier {
 		return entity.relationships[keyPath: path].id
 	}

 	/// Access to all Ids of a `ToManyRelationship`.
 	/// This allows you to write `entity ~> \.others` instead
 	/// of `entity.relationships.others.ids`.
-	public static func ~><OtherEntity: Relatable>(entity: Entity, path: KeyPath<Description.Relationships, ToManyRelationship<OtherEntity>>) -> [OtherEntity.Identifier] {
+	public static func ~><OtherEntity: Relatable>(entity: Self, path: KeyPath<Description.Relationships, ToManyRelationship<OtherEntity>>) -> [OtherEntity.Identifier] {
 		return entity.relationships[keyPath: path].ids
 	}
 }
@@ -179,6 +390,8 @@ private enum ResourceObjectCodingKeys: String, CodingKey {
 	case id = "id"
 	case attributes = "attributes"
 	case relationships = "relationships"
+	case meta = "meta"
+	case links = "links"
 }

 public extension Entity {
@@ -187,7 +400,7 @@ public extension Entity {
 		
 		try container.encode(Entity.type, forKey: .type)
 		
-		if Identifier.self != Unidentified.self {
+		if EntityRawIdType.self != Unidentified.self {
 			try container.encode(id, forKey: .id)
 		}
 		
@@ -195,9 +408,17 @@ public extension Entity {
 			try container.encode(attributes, forKey: .attributes)
 		}
 		
-		if Description.Relationships.self != NoRelatives.self {
+		if Description.Relationships.self != NoRelationships.self {
 			try container.encode(relationships, forKey: .relationships)
 		}
+
+		if MetaType.self != NoMetadata.self {
+			try container.encode(meta, forKey: .meta)
+		}
+
+		if LinksType.self != NoLinks.self {
+			try container.encode(links, forKey: .links)
+		}
 	}

 	public init(from decoder: Decoder) throws {
@@ -209,11 +430,16 @@ public extension Entity {
 		guard Entity.type == type else {
 			throw JSONAPIEncodingError.typeMismatch(expected: Description.type, found: type)
 		}
-		
-		id = try (Unidentified() as? Identifier) ?? container.decode(Identifier.self, forKey: .id)
+
+		let maybeUnidentified = Unidentified() as? EntityRawIdType
+		id = try maybeUnidentified.map { Entity.Id(rawValue: $0) } ?? container.decode(Entity.Id.self, forKey: .id)
 		
 		attributes = try (NoAttributes() as? Description.Attributes) ?? container.decode(Description.Attributes.self, forKey: .attributes)
 		
-		relationships = try (NoRelatives() as? Description.Relationships) ?? container.decode(Description.Relationships.self, forKey: .relationships)
+		relationships = try (NoRelationships() as? Description.Relationships) ?? container.decode(Description.Relationships.self, forKey: .relationships)
+
+		meta = try (NoMetadata() as? MetaType) ?? container.decode(MetaType.self, forKey: .meta)
+
+		links = try (NoLinks() as? LinksType) ?? container.decode(LinksType.self, forKey: .links)
 	}
 }
@@ -5,10 +5,16 @@
 //  Created by Mathew Polzin on 7/24/18.
 //

+/// All types that are RawIdType and additionally
+/// Unidentified conform to this protocol. You
+/// should not add conformance to this protocol
+/// directly.
+public protocol MaybeRawId: Codable, Equatable {}
+
 /// Any type that you would like to be encoded to and
 /// decoded from JSON API ids should conform to this
 /// protocol. Conformance for `String` is given.
-public protocol RawIdType: Codable, Equatable {}
+public protocol RawIdType: MaybeRawId, Hashable {}

 /// If you would like to be able to create new
 /// Entities with Ids backed by a RawIdType then
@@ -22,18 +28,18 @@ public protocol CreatableRawIdType: RawIdType {

 extension String: RawIdType {}

-public protocol Identifier: Codable, Equatable {}
-
-public struct Unidentified: Identifier, CustomStringConvertible {
+public struct Unidentified: MaybeRawId, CustomStringConvertible {
 	public init() {}
 	
-	public var description: String { return "Id(Unidentified)" }
+	public var description: String { return "Unidentified" }
 }

-public protocol IdType: Identifier, CustomStringConvertible {
-	associatedtype EntityDescription: JSONAPI.EntityDescription
-	associatedtype RawType: RawIdType
-	
+public protocol MaybeId: Codable {
+	associatedtype EntityType: JSONAPI.EntityProxy
+	associatedtype RawType: MaybeRawId
+}
+
+public protocol IdType: MaybeId, CustomStringConvertible, Hashable where RawType: RawIdType {
 	var rawValue: RawType { get }
 }

@@ -47,27 +53,33 @@ public protocol CreatableIdType: IdType {

 /// An Entity ID. These IDs can be encoded to or decoded from
 /// JSON API IDs.
-public struct Id<RawType: RawIdType, EntityDescription: JSONAPI.EntityDescription>: IdType {
+public struct Id<RawType: MaybeRawId, EntityType: JSONAPI.EntityProxy>: Codable, Equatable, MaybeId {

 	public let rawValue: RawType
 	
 	public init(rawValue: RawType) {
 		self.rawValue = rawValue
 	}
-	
+
 	public init(from decoder: Decoder) throws {
 		let container = try decoder.singleValueContainer()
 		rawValue = try container.decode(RawType.self)
 	}
-	
+
 	public func encode(to encoder: Encoder) throws {
 		var container = encoder.singleValueContainer()
 		try container.encode(rawValue)
 	}
 }

+extension Id: Hashable, CustomStringConvertible, IdType where RawType: RawIdType {}
+
 extension Id: CreatableIdType where RawType: CreatableRawIdType {
 	public init() {
 		rawValue = .unique()
 	}
 }
+
+extension Id where RawType == Unidentified {
+	public static var unidentified: Id { return .init(rawValue: Unidentified()) }
+}
@@ -98,7 +98,7 @@ extension Poly1: CustomStringConvertible {
 		case .a(let a):
 			str = String(describing: a)
 		}
-		return "Include(\(str))"
+		return "Poly(\(str))"
 	}
 }

@@ -177,7 +177,7 @@ extension Poly2: CustomStringConvertible {
 		case .b(let b):
 			str = String(describing: b)
 		}
-		return "Include(\(str))"
+		return "Poly(\(str))"
 	}
 }

@@ -271,7 +271,7 @@ extension Poly3: CustomStringConvertible {
 		case .c(let c):
 			str = String(describing: c)
 		}
-		return "Include(\(str))"
+		return "Poly(\(str))"
 	}
 }

@@ -380,7 +380,7 @@ extension Poly4: CustomStringConvertible {
 		case .d(let d):
 			str = String(describing: d)
 		}
-		return "Include(\(str))"
+		return "Poly(\(str))"
 	}
 }

@@ -504,7 +504,7 @@ extension Poly5: CustomStringConvertible {
 		case .e(let e):
 			str = String(describing: e)
 		}
-		return "Include(\(str))"
+		return "Poly(\(str))"
 	}
 }

@@ -643,6 +643,6 @@ extension Poly6: CustomStringConvertible {
 		case .f(let f):
 			str = String(describing: f)
 		}
-		return "Include(\(str))"
+		return "Poly(\(str))"
 	}
 }
@@ -5,17 +5,15 @@
 //  Created by Mathew Polzin on 8/31/18.
 //

+public protocol RelationshipType: Codable {}
+
 /// An Entity relationship that can be encoded to or decoded from
 /// a JSON API "Resource Linkage."
 /// See https://jsonapi.org/format/#document-resource-object-linkage
 /// A convenient typealias might make your code much more legible: `One<EntityDescription>`
-public struct ToOneRelationship<Relatable: JSONAPI.OptionalRelatable>: Equatable, Codable {
+public struct ToOneRelationship<Relatable: JSONAPI.OptionalRelatable>: RelationshipType, Equatable {

 	public let id: Relatable.WrappedIdentifier
-	
-	public var ids: [Relatable.WrappedIdentifier] {
-		return [id]
-	}

 	public init(id: Relatable.WrappedIdentifier) {
 		self.id = id
@@ -23,13 +21,13 @@ public struct ToOneRelationship<Relatable: JSONAPI.OptionalRelatable>: Equatable
 }

 extension ToOneRelationship where Relatable.WrappedIdentifier == Relatable.Identifier {
-	public init(entity: Entity<Relatable.Description, Relatable.Identifier>) {
+	public init<E: EntityType>(entity: E) where E.Description == Relatable.Description, E.Id == Relatable.Identifier {
 		id = entity.id
 	}
 }

-extension ToOneRelationship where Relatable.WrappedIdentifier == Optional<Relatable.Identifier> {
-	public init(entity: Entity<Relatable.Description, Relatable.Identifier>?) {
+extension ToOneRelationship where Relatable.WrappedIdentifier == Relatable.Identifier? {
+	public init<E: EntityType>(entity: E?) where E.Description == Relatable.Description, E.Id == Relatable.Identifier {
 		id = entity?.id
 	}
 }
@@ -38,10 +36,14 @@ extension ToOneRelationship where Relatable.WrappedIdentifier == Optional<Relata
 /// a JSON API "Resource Linkage."
 /// See https://jsonapi.org/format/#document-resource-object-linkage
 /// A convenient typealias might make your code much more legible: `Many<EntityDescription>`
-public struct ToManyRelationship<Relatable: JSONAPI.Relatable>: Equatable, Codable {
+public struct ToManyRelationship<Relatable: JSONAPI.Relatable>: RelationshipType, Equatable {

 	public let ids: [Relatable.Identifier]

+	public init(ids: [Relatable.Identifier]) {
+		self.ids = ids
+	}
+
 	public init<T: JSONAPI.Relatable>(relationships: [ToOneRelationship<T>]) where T.WrappedIdentifier == Relatable.Identifier {
 		ids = relationships.map { $0.id }
 	}
@@ -56,7 +58,7 @@ public struct ToManyRelationship<Relatable: JSONAPI.Relatable>: Equatable, Codab
 }

 extension ToManyRelationship {
-	public init(entities: [Entity<Relatable.Description, Relatable.Identifier>]) {
+	public init<E: EntityType>(entities: [E]) where E.Description == Relatable.Description, E.Id == Relatable.Identifier {
 		ids = entities.map { $0.id }
 	}
 }
@@ -74,10 +76,6 @@ public typealias OptionalRelatable = WrappedRelatable
 /// has an IdType Identifier
 public protocol Relatable: WrappedRelatable {}

-extension Entity: Relatable, WrappedRelatable where Identifier: JSONAPI.IdType {
-	public typealias WrappedIdentifier = Identifier
-}
-
 extension Optional: OptionalRelatable where Wrapped: Relatable {
 	public typealias Description = Wrapped.Description
 	public typealias Identifier = Wrapped.Identifier
@@ -182,5 +180,5 @@ extension ToOneRelationship: CustomStringConvertible {
 }

 extension ToManyRelationship: CustomStringConvertible {
-	public var description: String { return "Relationship(\(String(describing: ids)))" }
+	public var description: String { return "Relationship([\(ids.map(String.init(describing:)).joined(separator: ", "))])" }
 }
@@ -9,11 +9,16 @@ public protocol Transformer {
 	associatedtype From
 	associatedtype To

-	static func transform(_ from: From) throws -> To
+	static func transform(_ value: From) throws -> To
 }

-public enum IdentityTransformer<T>: Transformer {
-	public static func transform(_ from: T) throws -> T { return from }
+public protocol ReversibleTransformer: Transformer {
+	static func reverse(_ value: To) throws -> From
+}
+
+public enum IdentityTransformer<T>: ReversibleTransformer {
+	public static func transform(_ value: T) throws -> T { return value }
+	public static func reverse(_ value: T) throws -> T { return value }
 }

 // MARK: - Validator
@@ -22,10 +27,19 @@ public enum IdentityTransformer<T>: Transformer {
 /// is passed to it but it does not change the type of the value. Any
 /// Transformer will perform validation in one sense so a Validator is
 /// really just semantic sugar (it can provide clarity in its use).
-public protocol Validator: Transformer where From == To {}
+/// To enforce the semantics, any change of the value in your implementation
+/// of `Validator.transform()` will be ignored.
+public protocol Validator: ReversibleTransformer where From == To {
+}

 extension Validator {
+	public static func reverse(_ value: To) throws -> To {
+		let _ = try transform(value)
+		return value
+	}
+
 	public static func validate(_ value: To) throws -> To {
-		return try transform(value)
+		let _ = try transform(value)
+		return value
 	}
 }
@@ -0,0 +1,96 @@
+
+import JSONAPI
+
+extension TransformedAttribute: ExpressibleByUnicodeScalarLiteral where RawValue: ExpressibleByUnicodeScalarLiteral, Transformer == IdentityTransformer<RawValue> {
+	public typealias UnicodeScalarLiteralType = RawValue.UnicodeScalarLiteralType
+
+	public init(unicodeScalarLiteral value: RawValue.UnicodeScalarLiteralType) {
+		self.init(value: RawValue(unicodeScalarLiteral: value))
+	}
+}
+
+extension TransformedAttribute: ExpressibleByExtendedGraphemeClusterLiteral where RawValue: ExpressibleByExtendedGraphemeClusterLiteral, Transformer == IdentityTransformer<RawValue> {
+	public typealias ExtendedGraphemeClusterLiteralType = RawValue.ExtendedGraphemeClusterLiteralType
+
+	public init(extendedGraphemeClusterLiteral value: RawValue.ExtendedGraphemeClusterLiteralType) {
+		self.init(value: RawValue(extendedGraphemeClusterLiteral: value))
+	}
+}
+
+extension TransformedAttribute: ExpressibleByStringLiteral where RawValue: ExpressibleByStringLiteral, Transformer == IdentityTransformer<RawValue> {
+	public typealias StringLiteralType = RawValue.StringLiteralType
+
+	public init(stringLiteral value: RawValue.StringLiteralType) {
+		self.init(value: RawValue(stringLiteral: value))
+	}
+}
+
+extension TransformedAttribute: ExpressibleByNilLiteral where RawValue: ExpressibleByNilLiteral, Transformer == IdentityTransformer<RawValue> {
+	public init(nilLiteral: ()) {
+		self.init(value: RawValue(nilLiteral: ()))
+	}
+}
+
+extension TransformedAttribute: ExpressibleByFloatLiteral where RawValue: ExpressibleByFloatLiteral, Transformer == IdentityTransformer<RawValue> {
+	public typealias FloatLiteralType = RawValue.FloatLiteralType
+
+	public init(floatLiteral value: RawValue.FloatLiteralType) {
+		self.init(value: RawValue(floatLiteral: value))
+	}
+}
+
+extension TransformedAttribute: ExpressibleByBooleanLiteral where RawValue: ExpressibleByBooleanLiteral, Transformer == IdentityTransformer<RawValue> {
+	public typealias BooleanLiteralType = RawValue.BooleanLiteralType
+
+	public init(booleanLiteral value: BooleanLiteralType) {
+		self.init(value: RawValue(booleanLiteral: value))
+	}
+}
+
+extension TransformedAttribute: ExpressibleByIntegerLiteral where RawValue: ExpressibleByIntegerLiteral, Transformer == IdentityTransformer<RawValue> {
+	public typealias IntegerLiteralType = RawValue.IntegerLiteralType
+
+	public init(integerLiteral value: IntegerLiteralType) {
+		self.init(value: RawValue(integerLiteral: value))
+	}
+}
+
+// regretably, array and dictionary literals are not so easy because Dictionaries and Arrays
+// cannot be turned back into variadic arguments to pass onto the RawValue type's constructor.
+
+// we can still provide a case for the Array and Dictionary types, though.
+public protocol DictionaryType {
+	associatedtype Key: Hashable
+	associatedtype Value
+
+	init<S>(_ keysAndValues: S, uniquingKeysWith combine: (Dictionary<Key, Value>.Value, Dictionary<Key, Value>.Value) throws -> Dictionary<Key, Value>.Value) rethrows where S : Sequence, S.Element == (Key, Value)
+}
+extension Dictionary: DictionaryType {}
+
+extension TransformedAttribute: ExpressibleByDictionaryLiteral where RawValue: DictionaryType, Transformer == IdentityTransformer<RawValue> {
+	public typealias Key = RawValue.Key
+
+	public typealias Value = RawValue.Value
+
+	public init(dictionaryLiteral elements: (RawValue.Key, RawValue.Value)...) {
+
+		// we arbitrarily keep the first value if two values are assigned to the same key
+		self.init(value: RawValue(elements, uniquingKeysWith: { val, _ in val }))
+	}
+}
+
+public protocol ArrayType {
+	associatedtype Element
+
+	init<S>(_ s: S) where Element == S.Element, S : Sequence
+}
+extension Array: ArrayType {}
+extension ArraySlice: ArrayType {}
+
+extension TransformedAttribute: ExpressibleByArrayLiteral where RawValue: ArrayType, Transformer == IdentityTransformer<RawValue> {
+	public typealias ArrayLiteralElement = RawValue.Element
+
+	public init(arrayLiteral elements: ArrayLiteralElement...) {
+		self.init(value: RawValue(elements))
+	}
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Mathew Polzin	75c8ce7405	Update linuxmain	2018-12-03 18:46:03 -08:00
Mathew Polzin	3a8237ec0f	Add test coverage for Meta and Links on Entity	2018-12-03 18:45:07 -08:00
Mathew Polzin	49e33baa96	give all top-level-ish headers the JSONAPI prefix	2018-12-03 18:14:05 -08:00
Mathew Polzin	f2a9b5a7b9	That should do the trick	2018-12-03 18:10:36 -08:00
Mathew Polzin	24baadd7a8	try to make headers unique	2018-12-03 18:09:40 -08:00
Mathew Polzin	8d18be6154	Update README after adding Meta and Links to Entity.	2018-12-03 18:04:53 -08:00
Mathew Polzin	8aa887b527	Add metadata and links to resource objects (i.e. Entity). untested.	2018-12-02 22:57:59 -08:00
Mathew Polzin	7d0a686dd9	update linuxmain	2018-12-02 21:39:45 -08:00
Mathew Polzin	e4eb7816d7	Added an APIDescription type to Document that supports the JSON API Spec's JSON:API Object.	2018-12-02 21:35:09 -08:00
Mathew Polzin	482174f5b4	update linuxmain	2018-12-02 01:44:02 -08:00
Mathew Polzin	339480264e	Add JSON:API Object to Document as the APIDescription type. Begin to add testing around this new type.	2018-12-02 01:43:27 -08:00
Mathew Polzin	5d666ec998	move entity validator (i.e. check function) section of project status into a TestLib subsection.	2018-12-01 09:58:07 -08:00
Mathew Polzin	9cacbe9b8b	Revamp project status section and remove old todo list items.	2018-12-01 09:55:31 -08:00
Mathew Polzin	6663ad042e	A cleanup and clarification pass at the README	2018-12-01 01:13:05 -08:00
Mathew Polzin	07402259c4	Add ability to specify that a SingleResourceBody should be optional or not (or specifically that its PrimaryResource is nullable or not). add tests. update documentation.	2018-12-01 00:36:39 -08:00
Mathew Polzin	8274ecb523	Add tests confirming that initializers work as expected without using any TestLib conveniences	2018-11-30 23:56:18 -08:00
Mathew Polzin	853c7e892a	Fix playground bug caused by not running after removing a typealias	2018-11-30 20:18:08 -08:00
Mathew Polzin	04bf96a0cf	update linuxmain	2018-11-29 20:13:21 -08:00
Mathew Polzin	8668311307	better poly proxy tests	2018-11-29 20:10:56 -08:00
Mathew Polzin	689517c633	Add ability to differentiate between things that _act_ like Entities and things that _are_ entities in the sense that the latter are persisted between client and server but the former is just a clientside convenience.	2018-11-29 20:03:44 -08:00
Mathew Polzin	65b80ee0eb	Add ReversibleTransformer and tests. remove unneeded check in Entity.check().	2018-11-29 18:39:59 -08:00
Mathew Polzin	e91a03b396	Expose initializer for Document.Body.Data	2018-11-29 13:37:06 -08:00
Mathew Polzin	82088c7852	Remove BodyData which just aliased Body.Data	2018-11-29 13:15:07 -08:00
Mathew Polzin	34a4c8e7fc	Add TestLib ability to represent to-one relationships with the values of their IDs.	2018-11-29 11:31:17 -08:00
Mathew Polzin	6aeb859c24	Remove now deleted test from linuxmain	2018-11-28 21:13:47 -08:00
Mathew Polzin	163ac94c51	I did some more type wrangling to finally get the Id type to specialize on Entity rather than EntityDescription. The compiler gets into trouble depending on which of a few semantically identical routes are taken, but I finally stumbled upon the correct combination of protocols and extensions to get the job done. this was always the ideal outcome, but I was not sure the Swift compiler would allow it.	2018-11-28 21:13:07 -08:00
Mathew Polzin	e67b9fc142	Update playground and README for computed attributes.	2018-11-28 09:20:50 -08:00
Mathew Polzin	a628992fcb	Make Attribute a Functor to make computed attributes easier to write.	2018-11-28 09:09:23 -08:00
Mathew Polzin	cf47f88a61	Add tests to confirm that Entities can safely have computed attributes or relationships.	2018-11-28 08:15:57 -08:00
Mathew Polzin	0425e2adcb	rename folder in tests	2018-11-28 07:50:47 -08:00
Mathew Polzin	d3763ba713	Add array literal expressibility for ToManyRelationship	2018-11-27 23:59:12 -08:00
Mathew Polzin	fcc1796731	Expose Entity properties on EntityType protocol.	2018-11-27 18:58:48 -08:00
Mathew Polzin	921bcef05d	Ids are now Hashable	2018-11-27 18:39:57 -08:00
Mathew Polzin	661ff6eca5	A little renaming and easier access to important types under the JSONAPIDocument protocol	2018-11-27 18:20:01 -08:00
Mathew Polzin	e36180c9b9	Make properties of Body.Data public	2018-11-27 18:05:02 -08:00
Mathew Polzin	abee0c4d0e	Add body variable to JSONAPIDocument protocol	2018-11-27 17:55:56 -08:00
Mathew Polzin	9c8b2fbebb	Renamed JSONAPIDocument to Document and created a protocol describing a JSONAPI Document.	2018-11-27 17:35:13 -08:00
Mathew Polzin	a9ef71f383	indentation change	2018-11-27 17:15:15 -08:00
Mathew Polzin	232554ec51	Wrap JSONAPIDocument body up a bit nicer for use when the JSONAPIDocument does not represent errors.	2018-11-27 16:12:36 -08:00
Mathew Polzin	8f36bb40e3	Add note about the library being a bit 'opinionated'	2018-11-27 14:04:53 -08:00
Mathew Polzin	55f2f52676	minor README change	2018-11-27 13:59:01 -08:00
Mathew Polzin	dd5f3b1737	Added check for nullable array attributes	2018-11-27 13:57:55 -08:00
Mathew Polzin	7d7b3d7f19	Update linuxmain	2018-11-27 13:34:22 -08:00
Mathew Polzin	aedd5dc29b	Add Entity validation via a function in JSONAPITestLib.	2018-11-27 13:33:55 -08:00
Mathew Polzin	3964202ea2	Mention JSONAPITestLib in the README	2018-11-27 11:53:21 -08:00
Mathew Polzin	dcabafd583	Add a playground page to show off JSONAPITestLib and add nil literal expressibility to ToOneRelationship	2018-11-27 11:45:15 -08:00
Mathew Polzin	9df9efc2dc	rename NoRelatives to NoRelationships to better pair with NoAttributes and NoLinks	2018-11-27 11:08:53 -08:00
Mathew Polzin	a55a4cbed0	Added test library, attribute literal expressibility, and tests	2018-11-27 10:54:51 -08:00
Mathew Polzin	6f6ed87b4c	Update included playground	2018-11-27 09:14:47 -08:00
Mathew Polzin	59ff145aa8	Rename the included Error type.	2018-11-27 09:11:13 -08:00
Mathew Polzin	20a685e67b	Add goal of making it easier to construct Attributes values	2018-11-26 22:29:31 -08:00
Mathew Polzin	3d8d10584b	Add typealiases to make accessing Entity Relationships and Attributes types more convenient	2018-11-26 22:27:10 -08:00
Mathew Polzin	b93580c900	Allow ManyResourceBody to use any PrimaryResource type	2018-11-26 18:57:34 -08:00
Mathew Polzin	8927938d56	Rename URL to JSONAPIURL to avoid conflict with Foundation.URL	2018-11-26 18:29:24 -08:00