Merge pull request #147 from NeedleInAJayStack/feat/graphql-sdl

Author: paulofaria

MIGRATION.md

@@ -0,0 +1,39 @@
+# Migration
+
+## 1.0 to 2.0
+
+### TypeReference removal
+
+The `TypeReference` type was removed in v2.0.0, since it was made unnecessary when using the [GraphQL](https://github.com/GraphQLSwift/GraphQL)  closure-based `field` API. Simply replace any `TypeReference` usage with the actual type:
+
+```swift
+// Before
+let schema = try! Schema<HelloResolver, HelloContext> {
+    Type(Object1.self) { }
+    Type(Object2.self) {
+        Field("object1", at: \.object1, as: TypeReference<Object1>.self)
+    }
+}
+
+// After
+let schema = try! Schema<HelloResolver, HelloContext> {
+    Type(Object1.self) { }
+    Type(Object2.self) {
+        Field("object1", at: \.object1)
+    }
+}
+```
+
+### Field/InputField `as` argument removal
+
+Since TypeReference was removed, there is no longer a functional need for the `as` argument on `Field` and `InputField`
+types. To remove it, simply omit it and let the compiler determine the type from the signature of the `at` argument.
+
+### `Types` removal
+
+The deprecated `Types` type has been removed. Instead define types individually using the `Type` initializers.
+
+### Reflection `isEncodable`
+
+The deprecated `Reflection.isEncodable(type: Any.Type) -> Bool` function has been removed. Please re-implement in your
+package if this functionality is needed.

Package.resolved

@@ -7,7 +7,7 @@ let package = Package(
         .library(name: "Graphiti", targets: ["Graphiti"]),
     ],
     dependencies: [
-        .package(url: "https://github.com/GraphQLSwift/GraphQL.git", from: "2.10.0"),
+        .package(url: "https://github.com/GraphQLSwift/GraphQL.git", from: "3.0.0"),
     ],
     targets: [
         .target(name: "Graphiti", dependencies: ["GraphQL"]),

Package.swift

@@ -17,6 +17,10 @@ public class Argument<ArgumentsType: Decodable, ArgumentType>: ArgumentComponent
         return (name, argument)
     }
 
+    override func getName() -> String {
+        return name
+    }
+
     init(name: String) {
         self.name = name
     }

Sources/Graphiti/Argument/Argument.swift

@@ -9,6 +9,10 @@ public class ArgumentComponent<ArgumentsType: Decodable> {
     ) throws -> (String, GraphQLArgument) {
         fatalError()
     }
+
+    func getName() -> String {
+        fatalError()
+    }
 }
 
 public extension ArgumentComponent {

Sources/Graphiti/Argument/ArgumentComponent.swift

@@ -11,7 +11,6 @@ open class Component<Resolver, Context> {
     }
 
     func update(typeProvider _: SchemaTypeProvider, coders _: Coders) throws {}
-    func setGraphQLName(typeProvider _: SchemaTypeProvider) throws {}
 }
 
 public extension Component {
@@ -36,25 +35,4 @@ enum ComponentType {
     case type
     case types
     case union
-
-    /// An index used to sort components into the correct schema build order. This order goes
-    /// from "least other type references" to "most". By building in this order we are able to satisfy
-    /// hard ordering requirements (interfaces MUST be built before inheriting types), as well as
-    /// reduce unnecessary TypeReferences.
-    var buildOrder: Int {
-        switch self {
-        case .none: return 0
-        case .scalar: return 1
-        case .enum: return 2
-        case .interface: return 3
-        case .input: return 4
-        case .connection: return 5
-        case .type: return 6
-        case .types: return 7
-        case .union: return 8
-        case .query: return 9
-        case .mutation: return 10
-        case .subscription: return 11
-        }
-    }
 }

Sources/Graphiti/Component/Component.swift

@@ -4,19 +4,6 @@ public enum Reflection {
         return description.hasSuffix("Protocol")
     }
 
-    @available(*, deprecated, message: "No longer used")
-    public static func isEncodable(type: Any.Type) -> Bool {
-        if isProtocol(type: type) {
-            return true
-        }
-
-        if let type = type as? Wrapper.Type {
-            return isEncodable(type: type.wrappedType)
-        }
-
-        return type is Encodable.Type
-    }
-
     public static func name<Subject>(for instance: Subject) -> String {
         var typeName: [Character] = []
         var genericArgument: [Character] = []

Sources/Graphiti/Definition/Reflection.swift

@@ -66,22 +66,12 @@ extension TypeProvider {
                     from: GraphQLList(graphQLType),
                     isOptional: isOptional
                 )
-            case .reference:
-                let name = getGraphQLName(of: type.wrappedType)
-                let referenceType = GraphQLTypeReference(name)
-
-                return try getGraphQLOptionalType(from: referenceType, isOptional: isOptional)
             }
         } else {
-            if let graphQLType = graphQLTypeMap[AnyType(type)] {
-                return try getGraphQLOptionalType(from: graphQLType, isOptional: isOptional)
-            } else {
-                // If we haven't seen this type yet, just store it as a type reference and resolve later.
-                let name = getGraphQLName(of: type)
-                let referenceType = GraphQLTypeReference(name)
-
-                return try getGraphQLOptionalType(from: referenceType, isOptional: isOptional)
+            guard let graphQLType = graphQLTypeMap[AnyType(type)] else {
+                throw GraphQLError(message: "Type not found \(type).")
             }
+            return try getGraphQLOptionalType(from: graphQLType, isOptional: isOptional)
         }
     }
 

Sources/Graphiti/Definition/TypeProvider.swift

@@ -1,7 +1,6 @@
 enum WrapperModifier {
     case optional
     case list
-    case reference
 }
 
 protocol Wrapper {