Merge pull request #10 from mattpolzin/feature/OpenAPISchema

Feature/open api schema

JSONAPI.playground/Pages/OpenAPI Documentation.xcplaygroundpage/Contents.swift

@@ -0,0 +1,13 @@
+//: [Previous](@previous)
+
+import Foundation
+import JSONAPI
+import JSONAPIOpenAPI
+
+// print Entity Schema
+let encoder = JSONEncoder()
+encoder.outputFormatting = .prettyPrinted
+
+let personSchemaData = try? encoder.encode(Person.openAPINode())
+
+print(personSchemaData.map { String(data: $0, encoding: .utf8)! } ?? "Schema Construction Failed")

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/Sources/OpenAPISupport.swift

@@ -0,0 +1,16 @@
+import Foundation
+import JSONAPI
+import JSONAPITesting // for the convenience of literal initialization
+import JSONAPIOpenAPI
+
+extension PersonDescription.Attributes: Sampleable {
+	public static var sample: PersonDescription.Attributes {
+		return .init(name: ["Abbie", "Eibba"], favoriteColor: "Blue")
+	}
+}
+
+extension PersonDescription.Relationships: Sampleable {
+	public static var sample: PersonDescription.Relationships {
+		return .init(friends: ["1", "2"], dogs: ["2"], home: "1")
+	}
+}

JSONAPI.playground/contents.xcplayground

@@ -3,5 +3,8 @@
     <pages>
         <page name='Test Library'/>
         <page name='Usage'/>
+        <page name='Full Client &amp; Server Example'/>
+        <page name='Full Document Verbose Generation'/>
+        <page name='OpenAPI Documentation'/>
     </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,42 @@
 {
   "object": {
     "pins": [
-
+      {
+        "package": "AnyCodable",
+        "repositoryURL": "https://github.com/Flight-School/AnyCodable.git",
+        "state": {
+          "branch": null,
+          "revision": "396ccc3dba5bdee04c1e742e7fab40582861401e",
+          "version": "0.1.0"
+        }
+      },
+      {
+        "package": "FileCheck",
+        "repositoryURL": "https://github.com/llvm-swift/FileCheck.git",
+        "state": {
+          "branch": null,
+          "revision": "89b8480055f9adf8ce2f9ad5e2fac7ac1076242e",
+          "version": "0.0.8"
+        }
+      },
+      {
+        "package": "Poly",
+        "repositoryURL": "https://github.com/mattpolzin/Poly.git",
+        "state": {
+          "branch": "master",
+          "revision": "77f45b8963a51c02d71fc4075eba5cff47ff0d07",
+          "version": null
+        }
+      },
+      {
+        "package": "SwiftCheck",
+        "repositoryURL": "https://github.com/typelift/SwiftCheck.git",
+        "state": {
+          "branch": null,
+          "revision": "cf9958085b2ee1643e541e407c3233d1b76c18ff",
+          "version": "0.11.0"
+        }
+      }
     ]
   },
   "version": 1

Package.swift

@@ -10,21 +10,45 @@ let package = Package(
             name: "JSONAPI",
             targets: ["JSONAPI"]),
 		.library(
-			name: "JSONAPITestLib",
-			targets: ["JSONAPITestLib"])
+			name: "JSONAPITesting",
+			targets: ["JSONAPITesting"]),
+		.library(
+			name: "JSONAPIArbitrary",
+			targets: ["JSONAPIArbitrary"]),
+        .library(
+            name: "JSONAPIOpenAPI",
+            targets: ["JSONAPIOpenAPI"])
     ],
     dependencies: [
+		.package(url: "https://github.com/mattpolzin/Poly.git", .branch("master")),
+        .package(url: "https://github.com/Flight-School/AnyCodable.git", from: "0.1.0"),
+		.package(url: "https://github.com/typelift/SwiftCheck.git", from: "0.11.0")
     ],
     targets: [
         .target(
             name: "JSONAPI",
-            dependencies: []),
+            dependencies: ["Poly"]),
 		.target(
-			name: "JSONAPITestLib",
+			name: "JSONAPITesting",
 			dependencies: ["JSONAPI"]),
+		.target(
+			name: "JSONAPIArbitrary",
+			dependencies: ["JSONAPI", "SwiftCheck"]),
+        .target(
+            name: "JSONAPIOpenAPI",
+            dependencies: ["JSONAPI", "AnyCodable", "JSONAPIArbitrary"]),
         .testTarget(
             name: "JSONAPITests",
-            dependencies: ["JSONAPITestLib"])
+            dependencies: ["JSONAPI", "JSONAPITesting"]),
+        .testTarget(
+            name: "JSONAPITestingTests",
+            dependencies: ["JSONAPI", "JSONAPITesting"]),
+		.testTarget(
+			name: "JSONAPIArbitraryTests",
+			dependencies: ["JSONAPI", "SwiftCheck", "JSONAPIArbitrary"]),
+        .testTarget(
+            name: "JSONAPIOpenAPITests",
+            dependencies: ["JSONAPI", "JSONAPIOpenAPI"])
     ],
   	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.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

@@ -471,6 +471,15 @@ 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`.
@@ -513,6 +522,23 @@ public extension EntityProxy {
 	}
 }
 
+// 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`.
+	public 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`.
+	public static func ~><Identifier: IdType>(entity: Self, path: KeyPath<Description.Relationships, (Self) -> [Identifier]>) -> [Identifier] {
+		return entity.relationships[keyPath: path](entity)
+	}
+}
+
 infix operator ~>
 
 // MARK: - Codable

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/JSONAPIArbitrary/Attribute+Arbitrary.swift

@@ -0,0 +1,20 @@
+//
+//  Attribute+Arbitrary.swift
+//  JSONAPIArbitrary
+//
+//  Created by Mathew Polzin on 1/15/19.
+//
+
+import SwiftCheck
+import JSONAPI
+
+extension Attribute: Arbitrary where RawValue: Arbitrary {
+	public static var arbitrary: Gen<Attribute<RawValue>> {
+		return RawValue.arbitrary.map { .init(value: $0) }
+	}
+}
+
+// Cannot extend TransformedAttribute here
+// because there is no way to guarantee that an arbitrary
+// RawValue will successfully transform or that an
+// arbitrary Value will successfully reverse-transform.

Sources/JSONAPIArbitrary/Entity+Arbitrary.swift

@@ -0,0 +1,50 @@
+//
+//  Entity+Arbitrary.swift
+//  JSONAPIArbitrary
+//
+//  Created by Mathew Polzin on 1/14/19.
+//
+
+import SwiftCheck
+import JSONAPI
+
+extension NoMetadata: Arbitrary {
+	public static var arbitrary: Gen<NoMetadata> {
+		return Gen.pure(.none)
+	}
+}
+
+extension NoLinks: Arbitrary {
+	public static var arbitrary: Gen<NoLinks> {
+		return Gen.pure(.none)
+	}
+}
+
+extension NoAttributes: Arbitrary {
+	public static var arbitrary: Gen<NoAttributes> {
+		return Gen.pure(.none)
+	}
+}
+
+extension NoRelationships: Arbitrary {
+	public static var arbitrary: Gen<NoRelationships> {
+		return Gen.pure(.none)
+	}
+}
+
+// NOTE: Arbitrary conformance for MetaType, LinksType, Description.Attributes,
+// and Description.Relationships must all be provided BY YOU for Entity to
+// gain Arbitrary conformance (with the exception of NoMetadata, NoLinks,
+// NoAttributes, and NoRelationships which all have Arbitrary conformance
+// out of the box).
+extension Entity: Arbitrary where MetaType: Arbitrary, LinksType: Arbitrary, Description.Attributes: Arbitrary, Description.Relationships: Arbitrary, EntityRawIdType: Arbitrary {
+	public static var arbitrary: Gen<Entity<Description, MetaType, LinksType, EntityRawIdType>> {
+		return Gen.compose { c in
+			Entity(id: c.generate(),
+				   attributes: c.generate(),
+				   relationships: c.generate(),
+				   meta: c.generate(),
+				   links: c.generate())
+		}
+	}
+}

Sources/JSONAPIArbitrary/Id+Arbitrary.swift

@@ -0,0 +1,21 @@
+//
+//  Id+Arbitrary.swift
+//  JSONAPIArbitrary
+//
+//  Created by Mathew Polzin on 1/14/19.
+//
+
+import SwiftCheck
+import JSONAPI
+
+extension Unidentified: Arbitrary {
+	public static var arbitrary: Gen<Unidentified> {
+		return Gen.pure(.init())
+	}
+}
+
+extension Id: Arbitrary where RawType: Arbitrary {
+	public static var arbitrary: Gen<Id<RawType, IdentifiableType>> {
+		return RawType.arbitrary.map { Id(rawValue: $0) }
+	}
+}

Sources/JSONAPIArbitrary/Relationship+Arbitrary.swift

@@ -0,0 +1,60 @@
+//
+//  Relationship+Arbitrary.swift
+//  JSONAPIArbitrary
+//
+//  Created by Mathew Polzin on 1/15/19.
+//
+
+import SwiftCheck
+import JSONAPI
+
+extension ToOneRelationship: Arbitrary where Identifiable.Identifier: Arbitrary, MetaType: Arbitrary, LinksType: Arbitrary {
+	public static var arbitrary: Gen<ToOneRelationship<Identifiable, MetaType, LinksType>> {
+		return Gen.compose { c in
+			return .init(id: c.generate(),
+						 meta: c.generate(),
+						 links: c.generate())
+		}
+	}
+}
+
+extension ToOneRelationship where MetaType: Arbitrary, LinksType: Arbitrary {
+	/// Create a generator of arbitrary ToOneRelationships that will all
+	/// point to one of the given entities. This allows you to create
+	/// arbitrary relationships that make sense in a broader context where
+	/// the relationship must actually point to another entity.
+	public static func arbitrary<E: EntityType>(givenEntities: [E]) -> Gen<ToOneRelationship<Identifiable, MetaType, LinksType>> where E.Id == Identifiable.Identifier {
+
+		return Gen.compose { c in
+			let idGen = Gen.fromElements(of: givenEntities).map { $0.id }
+			return .init(id: c.generate(using: idGen),
+						 meta: c.generate(),
+						 links: c.generate())
+		}
+	}
+}
+
+extension ToManyRelationship: Arbitrary where Relatable.Identifier: Arbitrary, MetaType: Arbitrary, LinksType: Arbitrary {
+	public static var arbitrary: Gen<ToManyRelationship<Relatable, MetaType, LinksType>> {
+		return Gen.compose { c in
+			return .init(ids: c.generate(),
+						 meta: c.generate(),
+						 links: c.generate())
+		}
+	}
+}
+
+extension ToManyRelationship where MetaType: Arbitrary, LinksType: Arbitrary {
+	/// Create a generator of arbitrary ToManyRelationships that will all
+	/// point to some number of the given entities. This allows you to create
+	/// arbitrary relationships that make sense in a broader context where
+	/// the relationship must actually point to other existing entities.
+	public static func arbitrary<E: EntityType>(givenEntities: [E]) -> Gen<ToManyRelationship<Relatable, MetaType, LinksType>> where E.Id == Relatable.Identifier {
+		return Gen.compose { c in
+			let idsGen = Gen.fromElements(of: givenEntities).map { $0.id }.proliferate
+			return .init(ids: c.generate(using: idsGen),
+						 meta: c.generate(),
+						 links: c.generate())
+		}
+	}
+}

Sources/JSONAPIOpenAPI/JSONAPIOpenAPITypes.swift

@@ -0,0 +1,156 @@
+//
+//  JSONAPIOpenAPITypes.swift
+//  JSONAPIOpenAPI
+//
+//  Created by Mathew Polzin on 1/13/19.
+//
+
+import JSONAPI
+import AnyCodable
+
+private protocol _Optional {}
+extension Optional: _Optional {}
+
+extension Attribute: OpenAPINodeType where RawValue: OpenAPINodeType {
+	static public func openAPINode() throws -> JSONNode {
+		// If the RawValue is not required, we actually consider it
+		// nullable. To be not required is for the Attribute itself
+		// to be optional.
+		if try !RawValue.openAPINode().required {
+			return try RawValue.openAPINode().requiredNode().nullableNode()
+		}
+		return try RawValue.openAPINode()
+	}
+}
+
+extension Attribute: RawOpenAPINodeType where RawValue: RawRepresentable, RawValue.RawValue: OpenAPINodeType {
+	static public func rawOpenAPINode() throws -> JSONNode {
+		// If the RawValue is not required, we actually consider it
+		// nullable. To be not required is for the Attribute itself
+		// to be optional.
+		if try !RawValue.RawValue.openAPINode().required {
+			return try RawValue.RawValue.openAPINode().requiredNode().nullableNode()
+		}
+		return try RawValue.RawValue.openAPINode()
+	}
+}
+
+extension Attribute: WrappedRawOpenAPIType where RawValue: RawOpenAPINodeType {
+	public static func wrappedOpenAPINode() throws -> JSONNode {
+		// If the RawValue is not required, we actually consider it
+		// nullable. To be not required is for the Attribute itself
+		// to be optional.
+		if try !RawValue.rawOpenAPINode().required {
+			return try RawValue.rawOpenAPINode().requiredNode().nullableNode()
+		}
+		return try RawValue.rawOpenAPINode()
+	}
+}
+
+extension Attribute: AnyJSONCaseIterable where RawValue: CaseIterable, RawValue: Codable {
+	public static var allCases: [AnyCodable] {
+		return (try? allCases(from: Array(RawValue.allCases))) ?? []
+	}
+}
+
+extension Attribute: AnyWrappedJSONCaseIterable where RawValue: AnyJSONCaseIterable {
+	public static var allCases: [AnyCodable] {
+		return RawValue.allCases
+	}
+}
+
+extension TransformedAttribute: OpenAPINodeType where RawValue: OpenAPINodeType {
+	static public func openAPINode() throws -> JSONNode {
+		// If the RawValue is not required, we actually consider it
+		// nullable. To be not required is for the Attribute itself
+		// to be optional.
+		if try !RawValue.openAPINode().required {
+			return try RawValue.openAPINode().requiredNode().nullableNode()
+		}
+		return try RawValue.openAPINode()
+	}
+}
+
+extension RelationshipType {
+	static func relationshipNode(nullable: Bool) -> JSONNode {
+		let propertiesDict: [String: JSONNode] = [
+			"id": .string(.init(format: .generic,
+								required: true),
+						  .init()),
+			"type": .string(.init(format: .generic,
+								  required: true),
+							.init())
+		]
+
+		return .object(.init(format: .generic,
+							 required: true,
+							 nullable: nullable),
+					   .init(properties: propertiesDict))
+	}
+}
+
+extension ToOneRelationship: OpenAPINodeType {
+	// TODO: const for json `type`
+	// TODO: metadata & links
+	static public func openAPINode() throws -> JSONNode {
+		let nullable = Identifiable.self is _Optional.Type
+		return .object(.init(format: .generic,
+							 required: true),
+					   .init(properties: [
+						"data": ToOneRelationship.relationshipNode(nullable: nullable)
+						]))
+	}
+}
+
+extension ToManyRelationship: OpenAPINodeType {
+	// TODO: const for json `type`
+	// TODO: metadata & links
+	static public func openAPINode() throws -> JSONNode {
+		return .object(.init(format: .generic,
+							 required: true),
+					   .init(properties: [
+						"data": .array(.init(format: .generic,
+											 required: true),
+									   .init(items: ToManyRelationship.relationshipNode(nullable: false)))
+						]))
+	}
+}
+
+extension Entity: OpenAPINodeType where Description.Attributes: Sampleable, Description.Relationships: Sampleable {
+	public static func openAPINode() throws -> JSONNode {
+		// TODO: metadata, links
+
+		let idNode = JSONNode.string(.init(format: .generic,
+										   required: true),
+									 .init())
+		let idProperty = ("id", idNode)
+
+		let typeNode = JSONNode.string(.init(format: .generic,
+											 required: true),
+									   .init())
+		let typeProperty = ("type", typeNode)
+
+		let attributesNode: JSONNode? = Description.Attributes.self == NoAttributes.self
+			? nil
+			: try Description.Attributes.genericObjectOpenAPINode()
+
+		let attributesProperty = attributesNode.map { ("attributes", $0) }
+
+		let relationshipsNode: JSONNode? = Description.Relationships.self == NoRelationships.self
+			? nil
+			: try Description.Relationships.genericObjectOpenAPINode()
+
+		let relationshipsProperty = relationshipsNode.map { ("relationships", $0) }
+
+		let propertiesDict = Dictionary([
+			idProperty,
+			typeProperty,
+			attributesProperty,
+			relationshipsProperty
+			].compactMap { $0 }) { _, value in value	}
+
+		return .object(.init(format: .generic,
+							 required: true),
+					   .init(properties: propertiesDict))
+	}
+}

Sources/JSONAPIOpenAPI/OpenAPITypes+Codable.swift

@@ -0,0 +1,176 @@
+//
+//  OpenAPITypes+Codable.swift
+//  JSONAPIOpenAPI
+//
+//  Created by Mathew Polzin on 1/14/19.
+//
+
+extension JSONNode.Context: Encodable {
+
+	private enum CodingKeys: String, CodingKey {
+		case type
+		case format
+		case allowedValues = "enum"
+		case nullable
+	}
+
+	public func encode(to encoder: Encoder) throws {
+		var container = encoder.container(keyedBy: CodingKeys.self)
+
+		try container.encode(format.jsonType, forKey: .type)
+
+		if format != Format.unspecified {
+			try container.encode(format, forKey: .format)
+		}
+
+		if allowedValues != nil {
+			try container.encode(allowedValues, forKey: .allowedValues)
+		}
+
+		try container.encode(nullable, forKey: .nullable)
+	}
+}
+
+extension JSONNode.NumericContext: Encodable {
+	private enum CodingKeys: String, CodingKey {
+		case multipleOf
+		case maximum
+		case exclusiveMaximum
+		case minimum
+		case exclusiveMinimum
+	}
+
+	public func encode(to encoder: Encoder) throws {
+		var container = encoder.container(keyedBy: CodingKeys.self)
+
+		if multipleOf != nil {
+			try container.encode(multipleOf, forKey: .multipleOf)
+		}
+
+		if maximum != nil {
+			try container.encode(maximum, forKey: .maximum)
+		}
+
+		if exclusiveMaximum != nil {
+			try container.encode(exclusiveMaximum, forKey: .exclusiveMaximum)
+		}
+
+		if minimum != nil {
+			try container.encode(minimum, forKey: .minimum)
+		}
+
+		if exclusiveMinimum != nil {
+			try container.encode(exclusiveMinimum, forKey: .exclusiveMinimum)
+		}
+	}
+}
+
+extension JSONNode.StringContext: Encodable {
+	private enum CodingKeys: String, CodingKey {
+		case maxLength
+		case minLength
+		case pattern
+	}
+
+	public func encode(to encoder: Encoder) throws {
+		var container = encoder.container(keyedBy: CodingKeys.self)
+
+		if maxLength != nil {
+			try container.encode(maxLength, forKey: .maxLength)
+		}
+
+		try container.encode(minLength, forKey: .minLength)
+
+		if pattern != nil {
+			try container.encode(pattern, forKey: .pattern)
+		}
+	}
+}
+
+extension JSONNode.ArrayContext: Encodable {
+	private enum CodingKeys: String, CodingKey {
+		case items
+		case maxItems
+		case minItems
+		case uniqueItems
+	}
+
+	public func encode(to encoder: Encoder) throws {
+		var container = encoder.container(keyedBy: CodingKeys.self)
+
+		try container.encode(items, forKey: .items)
+
+		if maxItems != nil {
+			try container.encode(maxItems, forKey: .maxItems)
+		}
+
+		try container.encode(minItems, forKey: .minItems)
+
+		try container.encode(uniqueItems, forKey: .uniqueItems)
+	}
+}
+
+extension JSONNode.ObjectContext : Encodable{
+	private enum CodingKeys: String, CodingKey {
+		case maxProperties
+		case minProperties
+		case properties
+		case additionalProperties
+		case required
+	}
+
+	public func encode(to encoder: Encoder) throws {
+		var container = encoder.container(keyedBy: CodingKeys.self)
+
+		if maxProperties != nil {
+			try container.encode(maxProperties, forKey: .maxProperties)
+		}
+
+		try container.encode(properties, forKey: .properties)
+
+		if additionalProperties != nil {
+			try container.encode(additionalProperties, forKey: .additionalProperties)
+		}
+
+		let required = properties.filter { (name, node) in
+			node.required
+		}.keys
+
+		try container.encode(Array(required), forKey: .required)
+
+		try container.encode(max(minProperties, required.count), forKey: .minProperties)
+	}
+}
+
+extension JSONNode: Encodable {
+	public func encode(to encoder: Encoder) throws {
+		switch self {
+		case .boolean(let context):
+			try context.encode(to: encoder)
+
+		case .object(let contextA as Encodable, let contextB as Encodable),
+			 .array(let contextA as Encodable, let contextB as Encodable),
+			 .number(let contextA as Encodable, let contextB as Encodable),
+			 .integer(let contextA as Encodable, let contextB as Encodable),
+			 .string(let contextA as Encodable, let contextB as Encodable):
+			try contextA.encode(to: encoder)
+			try contextB.encode(to: encoder)
+
+		case .allOf(let nodes):
+			// TODO
+			print("TODO")
+
+		case .oneOf(let nodes):
+			// TODO
+			print("TODO")
+
+		case .anyOf(let nodes):
+			// TODO
+			print("TODO")
+
+		case .not(let node):
+			// TODO
+			print("TODO")
+		}
+	}
+}