Add Include support to OpenAPI schema of JSONAPI Document.

Sources/JSONAPIOpenAPI/OpenAPI/OpenAPITypes+Codable.swift

@@ -0,0 +1,194 @@
+//
+//  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
+		case example
+//		case constantValue = "const"
+	}
+
+	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)
+		}
+
+//		if constantValue != nil {
+//			try container.encode(constantValue, forKey: .constantValue)
+//		}
+
+		try container.encode(nullable, forKey: .nullable)
+
+		if example != nil {
+			try container.encode(example, forKey: .example)
+		}
+	}
+}
+
+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)
+		}
+
+		try container.encode(requiredProperties, forKey: .required)
+
+		try container.encode(minProperties, forKey: .minProperties)
+	}
+}
+
+extension JSONNode: Encodable {
+
+	private enum SubschemaCodingKeys: String, CodingKey {
+		case allOf
+		case oneOf
+		case anyOf
+		case not
+	}
+
+	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 .all(let nodes):
+			var container = encoder.container(keyedBy: SubschemaCodingKeys.self)
+
+			try container.encode(nodes, forKey: .allOf)
+
+		case .one(let nodes):
+			var container = encoder.container(keyedBy: SubschemaCodingKeys.self)
+
+			try container.encode(nodes, forKey: .oneOf)
+
+		case .any(let nodes):
+			var container = encoder.container(keyedBy: SubschemaCodingKeys.self)
+
+			try container.encode(nodes, forKey: .anyOf)
+
+		case .not(let node):
+			var container = encoder.container(keyedBy: SubschemaCodingKeys.self)
+
+			try container.encode(node, forKey: .not)
+		}
+	}
+}

Sources/JSONAPIOpenAPI/OpenAPI/SwiftPrimitiveTypes+OpenAPI.swift

@@ -0,0 +1,125 @@
+//
+//  PrimitiveTypes.swift
+//  JSONAPIOpenAPI
+//
+//  Created by Mathew Polzin on 01/13/19.
+//
+
+import AnyCodable
+
+/**
+
+Notable omissions in this library's default offerings:
+
+Base 64 encoded characters:
+.string(.byte)
+
+Any sequence of octets:
+.string(.binary)
+
+RFC3339 full-date:
+.string(.date)
+
+RFC3339 date-time:
+.string(.dateTime)
+
+A hint to UIs to obscure input:
+.string(.password)
+
+Any object:
+.object(.generic)
+
+**/
+
+extension Optional: OpenAPINodeType where Wrapped: OpenAPINodeType {
+	static public func openAPINode() throws -> JSONNode {
+		return try Wrapped.openAPINode().optionalNode()
+	}
+}
+
+extension Optional: RawOpenAPINodeType where Wrapped: RawRepresentable, Wrapped.RawValue: OpenAPINodeType {
+	static public func rawOpenAPINode() throws -> JSONNode {
+		return try Wrapped.RawValue.openAPINode().optionalNode()
+	}
+}
+
+extension Optional: WrappedRawOpenAPIType where Wrapped: RawOpenAPINodeType {
+	static public func wrappedOpenAPINode() throws -> JSONNode {
+		return try Wrapped.rawOpenAPINode().optionalNode()
+	}
+}
+
+extension Optional: DoubleWrappedRawOpenAPIType where Wrapped: WrappedRawOpenAPIType {
+	static public func wrappedOpenAPINode() throws -> JSONNode {
+		return try Wrapped.wrappedOpenAPINode().optionalNode()
+	}
+}
+
+extension Optional: AnyJSONCaseIterable where Wrapped: CaseIterable, Wrapped: Codable {
+	public static var allCases: [AnyCodable] {
+		return (try? allCases(from: Array(Wrapped.allCases))) ?? []
+	}
+}
+
+extension String: OpenAPINodeType {
+	static public func openAPINode() throws -> JSONNode {
+		return .string(.init(format: .generic,
+							 required: true),
+					   .init())
+	}
+}
+
+extension Bool: OpenAPINodeType {
+	static public func openAPINode() throws -> JSONNode {
+		return .boolean(.init(format: .generic,
+							  required: true))
+	}
+}
+
+extension Array: OpenAPINodeType where Element: OpenAPINodeType {
+	static public func openAPINode() throws -> JSONNode {
+		return .array(.init(format: .generic,
+							required: true),
+					  .init(items: try Element.openAPINode()))
+	}
+}
+
+extension Double: OpenAPINodeType {
+	static public func openAPINode() throws -> JSONNode {
+		return .number(.init(format: .double,
+							 required: true),
+					   .init())
+	}
+}
+
+extension Float: OpenAPINodeType {
+	static public func openAPINode() throws -> JSONNode {
+		return .number(.init(format: .float,
+							 required: true),
+					   .init())
+	}
+}
+
+extension Int: OpenAPINodeType {
+	static public func openAPINode() throws -> JSONNode {
+		return .integer(.init(format: .generic,
+							  required: true),
+						.init())
+	}
+}
+
+extension Int32: OpenAPINodeType {
+	static public func openAPINode() throws -> JSONNode {
+		return .integer(.init(format: .int32,
+							  required: true),
+						.init())
+	}
+}
+
+extension Int64: OpenAPINodeType {
+	static public func openAPINode() throws -> JSONNode {
+		return .integer(.init(format: .int64,
+							  required: true),
+						.init())
+	}
+}