A bit more clarification/correction

Feature/open api schema

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

@@ -1,5 +1,6 @@
 import Foundation
 import JSONAPI
+import Poly
 
 // MARK: - Preamble (setup)
 
@@ -40,7 +41,7 @@ typealias Document<PrimaryResourceBody: JSONAPI.ResourceBody, IncludeType: JSONA
 // MARK: Entity Definitions
 
 enum AuthorDescription: EntityDescription {
-	public static var type: String { return "authors" }
+	public static var jsonType: String { return "authors" }
 
 	public struct Attributes: JSONAPI.Attributes {
 		public let name: Attribute<String>
@@ -52,7 +53,7 @@ enum AuthorDescription: EntityDescription {
 typealias Author = JSONEntity<AuthorDescription>
 
 enum ArticleDescription: EntityDescription {
-	public static var type: String { return "articles" }
+	public static var jsonType: String { return "articles" }
 
 	public struct Attributes: JSONAPI.Attributes {
 		public let title: Attribute<String>

JSONAPI.playground/Pages/Full Document Verbose Generation.xcplaygroundpage/Contents.swift

@@ -65,7 +65,7 @@ struct ToManyRelationshipLinks: JSONAPI.Links {
 
 /// Description of an Author entity.
 enum AuthorDescription: EntityDescription {
-	static var type: String { return "authors" }
+	static var jsonType: String { return "authors" }
 
 	struct Attributes: JSONAPI.Attributes {
 		let name: Attribute<String>
@@ -80,7 +80,7 @@ typealias Author = JSONAPI.Entity<AuthorDescription, EntityMetadata, EntityLinks
 
 /// Description of an Article entity.
 enum ArticleDescription: EntityDescription {
-	static var type: String { return "articles" }
+	static var jsonType: String { return "articles" }
 
 	struct Attributes: JSONAPI.Attributes {
 		let title: Attribute<String>

JSONAPI.playground/Pages/Test Library.xcplaygroundpage/Contents.swift

@@ -2,7 +2,7 @@
 
 import Foundation
 import JSONAPI
-import JSONAPITestLib
+import JSONAPITesting
 
 /*******
 
@@ -11,12 +11,12 @@ Please enjoy these examples, but allow me the forced casting and the lack of err
 ********/
 
 // MARK: - Literal Expressibility
-// The JSONAPITestLib provides literal expressibility for key types to
+// The JSONAPITesting framework 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), meta: .none, links: .none)
 
 // MARK: - JSON API structure checking
-// The JSONAPITestLib provides a `check` function for each Entity type
+// The JSONAPITesting framework 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

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

@@ -11,8 +11,6 @@ Please enjoy these examples, but allow me the forced casting and the lack of err
 // MARK: - Create a request or response body with one Dog in it
 let dogFromCode = try! Dog(name: "Buddy", owner: nil)
 
-typealias SingleDogDocument = JSONAPI.Document<SingleResourceBody<Dog>, NoMetadata, NoLinks, NoIncludes, NoAPIDescription, UnknownJSONAPIError>
-
 let singleDogDocument = SingleDogDocument(apiDescription: .none, body: .init(entity: dogFromCode), includes: .none, meta: .none, links: .none)
 
 let singleDogData = try! JSONEncoder().encode(singleDogDocument)
@@ -34,8 +32,6 @@ let dogs = try! [Dog(name: "Buddy", owner: personIds[0]), Dog(name: "Joy", owner
 let houses = [House(attributes: .none, relationships: .none, meta: .none, links: .none), House(attributes: .none, relationships: .none, meta: .none, links: .none)]
 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 = 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(apiDescription: .none, body: .init(entities: people), includes: .init(values: includes), meta: .none, links: .none)
 let batchPeopleData = try! JSONEncoder().encode(batchPeopleDocument)

JSONAPI.playground/Sources/Entities.swift

@@ -31,7 +31,7 @@ public typealias ToMany<E: Relatable> = ToManyRelationship<E, NoMetadata, NoLink
 // MARK: - A few resource objects (entities)
 public enum PersonDescription: EntityDescription {
 
-	public static var type: String { return "people" }
+	public static var jsonType: String { return "people" }
 	
 	public struct Attributes: JSONAPI.Attributes {
 		public let name: Attribute<[String]>
@@ -63,14 +63,14 @@ public enum PersonDescription: EntityDescription {
 public typealias Person = ExampleEntity<PersonDescription>
 
 public extension Entity where Description == PersonDescription, MetaType == NoMetadata, LinksType == NoLinks, EntityRawIdType == String {
-	public init(id: Person.Id? = nil,name: [String], favoriteColor: String, friends: [Person], dogs: [Dog], home: House) throws {
+	init(id: Person.Id? = nil,name: [String], favoriteColor: String, friends: [Person], dogs: [Dog], home: House) throws {
 		self = Person(id: id ?? Person.Id(), attributes: .init(name: .init(value: name), favoriteColor: .init(value: favoriteColor)), relationships: .init(friends: .init(entities: friends), dogs: .init(entities: dogs), home: .init(entity: home)), meta: .none, links: .none)
 	}
 }
 
 public enum DogDescription: EntityDescription {
 
-	public static var type: String { return "dogs" }
+	public static var jsonType: String { return "dogs" }
 
 	public struct Attributes: JSONAPI.Attributes {
 		public let name: Attribute<String>
@@ -93,7 +93,7 @@ public typealias Dog = ExampleEntity<DogDescription>
 
 public enum AlternativeDogDescription: EntityDescription {
 
-	public static var type: String { return "dogs" }
+	public static var jsonType: String { return "dogs" }
 
 	public struct Attributes: JSONAPI.Attributes {
 		public let name: Attribute<String>
@@ -120,18 +120,18 @@ public enum AlternativeDogDescription: EntityDescription {
 public typealias AlternativeDog = ExampleEntity<AlternativeDogDescription>
 
 public extension Entity where Description == DogDescription, MetaType == NoMetadata, LinksType == NoLinks, EntityRawIdType == String {
-	public init(name: String, owner: Person?) throws {
+	init(name: String, owner: Person?) throws {
 		self = Dog(attributes: .init(name: .init(value: name)), relationships: DogDescription.Relationships(owner: .init(entity: owner)), meta: .none, links: .none)
 	}
 
-	public init(name: String, owner: Person.Id) throws {
+	init(name: String, owner: Person.Id) throws {
 		self = Dog(attributes: .init(name: .init(value: name)), relationships: .init(owner: .init(id: owner)), meta: .none, links: .none)
 	}
 }
 
 public enum HouseDescription: EntityDescription {
 
-	public static var type: String { return "houses" }
+	public static var jsonType: String { return "houses" }
 
 	public typealias Attributes = NoAttributes
 	public typealias Relationships = NoRelationships
@@ -139,4 +139,6 @@ public enum HouseDescription: EntityDescription {
 
 public typealias House = ExampleEntity<HouseDescription>
 
+public typealias SingleDogDocument = JSONAPI.Document<SingleResourceBody<Dog>, NoMetadata, NoLinks, NoIncludes, NoAPIDescription, UnknownJSONAPIError>
 
+public typealias BatchPeopleDocument = JSONAPI.Document<ManyResourceBody<Person>, NoMetadata, NoLinks, Include2<Dog, House>, NoAPIDescription, UnknownJSONAPIError>

JSONAPI.playground/contents.xcplayground

@@ -3,7 +3,7 @@
     <pages>
         <page name='Test Library'/>
         <page name='Usage'/>
-        <page name='Full Document Verbose Generation'/>
         <page name='Full Client &amp; Server Example'/>
+        <page name='Full Document Verbose Generation'/>
     </pages>
 </playground>

LICENSE.txt

@@ -0,0 +1,7 @@
+Copyright 2018 Mathew Polzin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Package.resolved

@@ -1,7 +1,15 @@
 {
   "object": {
     "pins": [
-
+      {
+        "package": "Poly",
+        "repositoryURL": "https://github.com/mattpolzin/Poly.git",
+        "state": {
+          "branch": null,
+          "revision": "77f45b8963a51c02d71fc4075eba5cff47ff0d07",
+          "version": "1.0.0"
+        }
+      }
     ]
   },
   "version": 1

Package.swift

@@ -10,21 +10,25 @@ let package = Package(
             name: "JSONAPI",
             targets: ["JSONAPI"]),
 		.library(
-			name: "JSONAPITestLib",
-			targets: ["JSONAPITestLib"])
+			name: "JSONAPITesting",
+			targets: ["JSONAPITesting"])
     ],
     dependencies: [
+		.package(url: "https://github.com/mattpolzin/Poly.git", from: "1.0.0"),
     ],
     targets: [
         .target(
             name: "JSONAPI",
-            dependencies: []),
+            dependencies: ["Poly"]),
 		.target(
-			name: "JSONAPITestLib",
+			name: "JSONAPITesting",
 			dependencies: ["JSONAPI"]),
         .testTarget(
             name: "JSONAPITests",
-            dependencies: ["JSONAPITestLib"])
+            dependencies: ["JSONAPI", "JSONAPITesting"]),
+        .testTarget(
+            name: "JSONAPITestingTests",
+            dependencies: ["JSONAPI", "JSONAPITesting"])
     ],
   	swiftLanguageVersions: [.v4_2]
 )

Sources/JSONAPI/Document/Document.swift

@@ -5,6 +5,8 @@
 //  Created by Mathew Polzin on 11/5/18.
 //
 
+import Poly
+
 public protocol JSONAPIDocument: Codable, Equatable {
 	associatedtype PrimaryResourceBody: JSONAPI.ResourceBody
 	associatedtype MetaType: JSONAPI.Meta

Sources/JSONAPI/Document/Includes.swift

@@ -5,7 +5,9 @@
 //  Created by Mathew Polzin on 11/10/18.
 //
 
-public typealias Include = Poly
+import Poly
+
+public typealias Include = JSONPoly
 
 public struct Includes<I: Include>: Codable, Equatable {
 	public static var none: Includes { return .init(values: []) }

Sources/JSONAPI/Resource/Attribute+Functor.swift

@@ -15,7 +15,7 @@ public extension TransformedAttribute {
 	/// 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> {
+	func map<T: Codable>(_ transform: (Transformer.To) throws -> T) rethrows -> Attribute<T> {
 		return Attribute<T>(value: try transform(value))
 	}
 }
@@ -30,7 +30,7 @@ public extension 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: (ValueType) throws -> T) rethrows -> Attribute<T> {
+	func map<T: Codable>(_ transform: (ValueType) throws -> T) rethrows -> Attribute<T> {
 		return Attribute<T>(value: try transform(value))
 	}
 }

Sources/JSONAPI/Resource/Attribute.swift

@@ -16,7 +16,7 @@ public protocol AttributeType: Codable {
 
 /// A TransformedAttribute takes a Codable type and attempts to turn it into another type.
 public struct TransformedAttribute<RawValue: Codable, Transformer: JSONAPI.Transformer>: AttributeType where Transformer.From == RawValue {
-	let rawValue: RawValue
+	public let rawValue: RawValue
 	
 	public let value: Transformer.To
 	

Sources/JSONAPI/Resource/Entity.swift

@@ -397,20 +397,20 @@ public extension Entity where EntityRawIdType: JSONAPI.RawIdType {
 	/// An Entity.Pointer is a `ToOneRelationship` with no metadata or links.
 	/// This is just a convenient way to reference an Entity so that
 	/// other Entities' Relationships can be built up from it.
-	public typealias Pointer = ToOneRelationship<Entity, NoMetadata, NoLinks>
+	typealias Pointer = ToOneRelationship<Entity, NoMetadata, NoLinks>
 
 	/// Entity.Pointers is a `ToManyRelationship` with no metadata or links.
 	/// This is just a convenient way to reference a bunch of Entities so
 	/// that other Entities' Relationships can be built up from them.
-	public typealias Pointers = ToManyRelationship<Entity, NoMetadata, NoLinks>
+	typealias Pointers = ToManyRelationship<Entity, NoMetadata, NoLinks>
 
 	/// Get a pointer to this entity that can be used as a
 	/// relationship to another entity.
-	public var pointer: Pointer {
+	var pointer: Pointer {
 		return Pointer(entity: self)
 	}
 
-	public func pointer<MType: JSONAPI.Meta, LType: JSONAPI.Links>(withMeta meta: MType, links: LType) -> ToOneRelationship<Entity, MType, LType> {
+	func pointer<MType: JSONAPI.Meta, LType: JSONAPI.Links>(withMeta meta: MType, links: LType) -> ToOneRelationship<Entity, MType, LType> {
 		return ToOneRelationship(entity: self, meta: meta, links: links)
 	}
 }
@@ -419,19 +419,19 @@ public extension Entity where EntityRawIdType: JSONAPI.RawIdType {
 public extension Entity where EntityRawIdType == Unidentified {
 	/// Create a new Entity from this one with a newly created
 	/// unique Id of the given type.
-	public func identified<RawIdType: CreatableRawIdType>(byType: RawIdType.Type) -> Entity<Description, MetaType, LinksType, RawIdType> {
+	func identified<RawIdType: CreatableRawIdType>(byType: RawIdType.Type) -> Entity<Description, MetaType, LinksType, RawIdType> {
 		return .init(attributes: attributes, relationships: relationships, meta: meta, links: links)
 	}
 
 	/// Create a new Entity from this one with the given Id.
-	public func identified<RawIdType: JSONAPI.RawIdType>(by id: RawIdType) -> Entity<Description, MetaType, LinksType, RawIdType> {
+	func identified<RawIdType: JSONAPI.RawIdType>(by id: RawIdType) -> Entity<Description, MetaType, LinksType, RawIdType> {
 		return .init(id: Entity<Description, MetaType, LinksType, RawIdType>.Identifier(rawValue: id), attributes: attributes, relationships: relationships, meta: meta, links: links)
 	}
 }
 
 public extension Entity where EntityRawIdType: CreatableRawIdType {
 	/// Create a copy of this Entity with a new unique Id.
-	public func withNewIdentifier() -> Entity {
+	func withNewIdentifier() -> Entity {
 		return Entity(attributes: attributes, relationships: relationships, meta: meta, links: links)
 	}
 }
@@ -471,19 +471,28 @@ public extension EntityProxy {
 	}
 }
 
+// MARK: Meta-Attribute Access
+public extension EntityProxy {
+	/// Access an attribute requiring a transformation on the RawValue _and_
+	/// a secondary transformation on this entity (self).
+	subscript<T>(_ path: KeyPath<Description.Attributes, (Self) -> T>) -> T {
+		return attributes[keyPath: path](self)
+	}
+}
+
 // MARK: Relationship Access
 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: Identifiable, MType: JSONAPI.Meta, LType: JSONAPI.Links>(entity: Self, path: KeyPath<Description.Relationships, ToOneRelationship<OtherEntity, MType, LType>>) -> OtherEntity.Identifier {
+	static func ~><OtherEntity: Identifiable, MType: JSONAPI.Meta, LType: JSONAPI.Links>(entity: Self, path: KeyPath<Description.Relationships, ToOneRelationship<OtherEntity, MType, LType>>) -> OtherEntity.Identifier {
 		return entity.relationships[keyPath: path].id
 	}
 
 	/// Access to an Id of an optional `ToOneRelationship`.
 	/// This allows you to write `entity ~> \.other` instead
 	/// of `entity.relationships.other?.id`.
-	public static func ~><OtherEntity: OptionalRelatable, MType: JSONAPI.Meta, LType: JSONAPI.Links>(entity: Self, path: KeyPath<Description.Relationships, ToOneRelationship<OtherEntity, MType, LType>?>) -> OtherEntity.Identifier {
+	static func ~><OtherEntity: OptionalRelatable, MType: JSONAPI.Meta, LType: JSONAPI.Links>(entity: Self, path: KeyPath<Description.Relationships, ToOneRelationship<OtherEntity, MType, LType>?>) -> OtherEntity.Identifier {
 		// Implementation Note: This signature applies to `ToOneRelationship<E?, _, _>?`
 		// whereas the one below applies to `ToOneRelationship<E, _, _>?`
 		return entity.relationships[keyPath: path]?.id
@@ -492,7 +501,7 @@ public extension EntityProxy {
 	/// Access to an Id of an optional `ToOneRelationship`.
 	/// This allows you to write `entity ~> \.other` instead
 	/// of `entity.relationships.other?.id`.
-	public static func ~><OtherEntity: Relatable, MType: JSONAPI.Meta, LType: JSONAPI.Links>(entity: Self, path: KeyPath<Description.Relationships, ToOneRelationship<OtherEntity, MType, LType>?>) -> OtherEntity.Identifier? {
+	static func ~><OtherEntity: Relatable, MType: JSONAPI.Meta, LType: JSONAPI.Links>(entity: Self, path: KeyPath<Description.Relationships, ToOneRelationship<OtherEntity, MType, LType>?>) -> OtherEntity.Identifier? {
 		// Implementation Note: This signature applies to `ToOneRelationship<E, _, _>?`
 		// whereas the one above applies to `ToOneRelationship<E?, _, _>?`
 		return entity.relationships[keyPath: path]?.id
@@ -501,18 +510,35 @@ public extension EntityProxy {
 	/// 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, MType: JSONAPI.Meta, LType: JSONAPI.Links>(entity: Self, path: KeyPath<Description.Relationships, ToManyRelationship<OtherEntity, MType, LType>>) -> [OtherEntity.Identifier] {
+	static func ~><OtherEntity: Relatable, MType: JSONAPI.Meta, LType: JSONAPI.Links>(entity: Self, path: KeyPath<Description.Relationships, ToManyRelationship<OtherEntity, MType, LType>>) -> [OtherEntity.Identifier] {
 		return entity.relationships[keyPath: path].ids
 	}
 
 	/// Access to all Ids of an optional `ToManyRelationship`.
 	/// This allows you to write `entity ~> \.others` instead
 	/// of `entity.relationships.others?.ids`.
-	public static func ~><OtherEntity: Relatable, MType: JSONAPI.Meta, LType: JSONAPI.Links>(entity: Self, path: KeyPath<Description.Relationships, ToManyRelationship<OtherEntity, MType, LType>?>) -> [OtherEntity.Identifier]? {
+	static func ~><OtherEntity: Relatable, MType: JSONAPI.Meta, LType: JSONAPI.Links>(entity: Self, path: KeyPath<Description.Relationships, ToManyRelationship<OtherEntity, MType, LType>?>) -> [OtherEntity.Identifier]? {
 		return entity.relationships[keyPath: path]?.ids
 	}
 }
 
+// MARK: Meta-Relationship Access
+public extension EntityProxy {
+	/// Access to an Id of a `ToOneRelationship`.
+	/// This allows you to write `entity ~> \.other` instead
+	/// of `entity.relationships.other.id`.
+	static func ~><Identifier: IdType>(entity: Self, path: KeyPath<Description.Relationships, (Self) -> Identifier>) -> Identifier {
+		return entity.relationships[keyPath: path](entity)
+	}
+
+	/// Access to all Ids of a `ToManyRelationship`.
+	/// This allows you to write `entity ~> \.others` instead
+	/// of `entity.relationships.others.ids`.
+	static func ~><Identifier: IdType>(entity: Self, path: KeyPath<Description.Relationships, (Self) -> [Identifier]>) -> [Identifier] {
+		return entity.relationships[keyPath: path](entity)
+	}
+}
+
 infix operator ~>
 
 // MARK: - Codable
@@ -526,7 +552,7 @@ private enum ResourceObjectCodingKeys: String, CodingKey {
 }
 
 public extension Entity {
-	public func encode(to encoder: Encoder) throws {
+	func encode(to encoder: Encoder) throws {
 		var container = encoder.container(keyedBy: ResourceObjectCodingKeys.self)
 		
 		try container.encode(Entity.jsonType, forKey: .type)
@@ -552,7 +578,7 @@ public extension Entity {
 		}
 	}
 
-	public init(from decoder: Decoder) throws {
+	init(from decoder: Decoder) throws {
 		
 		let container = try decoder.container(keyedBy: ResourceObjectCodingKeys.self)
 		

Sources/JSONAPI/Resource/Poly+PrimaryResource.swift

@@ -0,0 +1,57 @@
+//
+//  Poly+PrimaryResource.swift
+//  JSONAPI
+//
+//  Created by Mathew Polzin on 11/22/18.
+//
+
+import Poly
+
+/// Poly is a protocol to which types that
+/// are polymorphic belong to. Specifically,
+/// Poly1, Poly2, Poly3, etc. types conform
+/// to the Poly protocol. These types allow
+/// typesafe grouping of a number of
+/// disparate types under one roof for
+/// the purposes of JSON API compliant
+/// encoding or decoding.
+public typealias JSONPoly = Poly & PrimaryResource
+
+public typealias PolyWrapped = Codable & Equatable
+
+extension Poly0: PrimaryResource {
+	public init(from decoder: Decoder) throws {
+		throw JSONAPIEncodingError.illegalDecoding("Attempted to decode Poly0, which should represent a thing that is not expected to be found in a document.")
+	}
+
+	public func encode(to encoder: Encoder) throws {
+		throw JSONAPIEncodingError.illegalEncoding("Attempted to encode Poly0, which should represent a thing that is not expected to be found in a document.")
+	}
+}
+
+// MARK: - 1 type
+extension Poly1: PrimaryResource, MaybePrimaryResource where A: PolyWrapped {}
+
+// MARK: - 2 types
+extension Poly2: PrimaryResource, MaybePrimaryResource where A: PolyWrapped, B: PolyWrapped {}
+
+// MARK: - 3 types
+extension Poly3: PrimaryResource, MaybePrimaryResource where A: PolyWrapped, B: PolyWrapped, C: PolyWrapped {}
+
+// MARK: - 4 types
+extension Poly4: PrimaryResource, MaybePrimaryResource where A: PolyWrapped, B: PolyWrapped, C: PolyWrapped, D: PolyWrapped {}
+
+// MARK: - 5 types
+extension Poly5: PrimaryResource, MaybePrimaryResource where A: PolyWrapped, B: PolyWrapped, C: PolyWrapped, D: PolyWrapped, E: PolyWrapped {}
+
+// MARK: - 6 types
+extension Poly6: PrimaryResource, MaybePrimaryResource where A: PolyWrapped, B: PolyWrapped, C: PolyWrapped, D: PolyWrapped, E: PolyWrapped, F: PolyWrapped {}
+
+// MARK: - 7 types
+extension Poly7: PrimaryResource, MaybePrimaryResource where A: PolyWrapped, B: PolyWrapped, C: PolyWrapped, D: PolyWrapped, E: PolyWrapped, F: PolyWrapped, G: PolyWrapped {}
+
+// MARK: - 8 types
+extension Poly8: PrimaryResource, MaybePrimaryResource where A: PolyWrapped, B: PolyWrapped, C: PolyWrapped, D: PolyWrapped, E: PolyWrapped, F: PolyWrapped, G: PolyWrapped, H: PolyWrapped {}
+
+// MARK: - 9 types
+extension Poly9: PrimaryResource, MaybePrimaryResource where A: PolyWrapped, B: PolyWrapped, C: PolyWrapped, D: PolyWrapped, E: PolyWrapped, F: PolyWrapped, G: PolyWrapped, H: PolyWrapped, I: PolyWrapped {}

Sources/JSONAPITesting/EntityCheck.swift

@@ -1,6 +1,6 @@
 //
 //  EntityCheck.swift
-//  JSONAPITestLib
+//  JSONAPITesting
 //
 //  Created by Mathew Polzin on 11/27/18.
 //
@@ -55,7 +55,7 @@ extension TransformedAttribute: _AttributeType {}
 extension Attribute: _AttributeType {}
 
 public extension Entity {
-	public static func check(_ entity: Entity) throws {
+	static func check(_ entity: Entity) throws {
 		var problems = [EntityCheckError]()
 
 		let attributesMirror = Mirror(reflecting: entity.attributes)