WIP

Author: lukel97

Sources/GraphQL/Language/AST.swift

@@ -142,7 +142,7 @@ public protocol Node: TextOutputStreamable {
 }
 
 extension Node {
-    var printed: String {
+    public var printed: String {
         var s = ""
         self.write(to: &s)
         return s
@@ -248,17 +248,34 @@ public struct Document {
 
 extension Document : Equatable {
     public static func == (lhs: Document, rhs: Document) -> Bool {
-        guard lhs.definitions.count == rhs.definitions.count else {
-            return false
-        }
+        return lhs.definitions == rhs.definitions
+    }
+}
 
-        for (l, r) in zip(lhs.definitions, rhs.definitions) {
-            guard l == r else {
-                return false
-            }
+public struct ExecutableDocument {
+    public let loc: Location?
+    public var definitions: [ExecutableDefinition]
+
+    init(loc: Location? = nil, definitions: [ExecutableDefinition]) {
+        self.loc = loc
+        self.definitions = definitions
+    }
+
+    public mutating func descend(descender: inout Descender) {
+        descender.descend(&self, \.definitions)
+    }
+    
+    public func write<Target>(to target: inout Target) where Target : TextOutputStream {
+        definitions.forEach {
+            $0.write(to: &target)
+            target.write("\n\n")
         }
+    }
+}
 
-        return true
+extension ExecutableDocument: Equatable {
+    public static func == (lhs: ExecutableDocument, rhs: ExecutableDocument) -> Bool {
+        return lhs.definitions == rhs.definitions
     }
 }
 

Sources/GraphQL/Language/Visitor.swift

@@ -1,17 +1,19 @@
 public struct Descender {
 
-    enum Mutation<T: Node> {
-        case replace(T)
-        case remove
-    }
     private let visitor: Visitor
 
     fileprivate var parentStack: [VisitorParent] = []
     private var path: [AnyKeyPath] = []
     private var isBreaking = false
 
-    fileprivate mutating func go<H: Node>(node: inout H, key: AnyKeyPath?) -> Mutation<H>? {
-        if isBreaking { return nil }
+    /**
+        The meat of the traversal
+     
+        - Returns
+            `true` if node should be removed
+     */
+    fileprivate mutating func go<H: Node>(node: inout H, key: AnyKeyPath?) -> Bool {
+        if isBreaking { return false }
         let parent = parentStack.last
         let newPath: [AnyKeyPath]
         if let key = key {
@@ -20,23 +22,23 @@ public struct Descender {
             newPath = path
         }
 
-        var mutation: Mutation<H>? = nil
+        var shouldRemove = false
 
         switch visitor.enter(node: node, key: key, parent: parent, path: newPath, ancestors: parentStack) {
         case .skip:
-            return nil// .node(Optional(result))
+            return false
         case .continue:
             break
         case let .node(newNode):
             if let newNode = newNode {
-                mutation = .replace(newNode)
+                node = newNode
             } else {
                 // TODO: Should we still be traversing the children here?
-                mutation = .remove
+                shouldRemove = true
             }
         case .break:
             isBreaking = true
-            return nil
+            return false
         }
         parentStack.append(.node(node))
         if let key = key {
@@ -48,46 +50,39 @@ public struct Descender {
         }
         parentStack.removeLast()
 
-        if isBreaking { return mutation }
+        if isBreaking { return shouldRemove }
 
         switch visitor.leave(node: node, key: key, parent: parent, path: newPath, ancestors: parentStack) {
         case .skip, .continue:
-            return mutation
+            return shouldRemove
         case let .node(newNode):
             if let newNode = newNode {
-                return .replace(newNode)
+                node = newNode
+                return false
             } else {
                 // TODO: Should we still be traversing the children here?
-                return .remove
+                return true
             }
         case .break:
             isBreaking = true
-            return mutation
+            return shouldRemove
         }
     }
 
 
     mutating func descend<T: Node, U: Node>(_ node: inout T, _ kp: WritableKeyPath<T, U>) {
-        switch go(node: &node[keyPath: kp], key: kp) {
-        case nil:
-            break
-        case .replace(let child):
-            node[keyPath: kp] = child
-        case .remove:
+        if go(node: &node[keyPath: kp], key: kp) {
             fatalError("Can't remove this node")
         }
     }
     mutating func descend<T, U: Node>(_ node: inout T, _ kp: WritableKeyPath<T, U?>) {
         guard var oldVal = node[keyPath: kp] else {
             return
         }
-        switch go(node: &oldVal, key: kp) {
-        case nil:
-            node[keyPath: kp] = oldVal
-        case .replace(let child):
-            node[keyPath: kp] = child
-        case .remove:
+        if go(node: &oldVal, key: kp) {
             node[keyPath: kp] = nil
+        } else {
+            node[keyPath: kp] = oldVal
         }
     }
     mutating func descend<T, U: Node>(_ node: inout T, _ kp: WritableKeyPath<T, [U]>) {
@@ -97,12 +92,7 @@ public struct Descender {
 
         var i = node[keyPath: kp].startIndex
         while i != node[keyPath: kp].endIndex {
-            switch go(node: &node[keyPath: kp][i], key: \[U].[i]) {
-            case nil:
-                break
-            case .replace(let child):
-                node[keyPath: kp][i] = child
-            case .remove:
+            if go(node: &node[keyPath: kp][i], key: \[U].[i]) {
                 toRemove.append(i)
             }
             i = node[keyPath: kp].index(after: i)
@@ -112,12 +102,7 @@ public struct Descender {
     }
 
     mutating func descend<T: Node>(enumCase: inout T) {
-        switch go(node: &enumCase, key: nil) {
-        case nil:
-            break
-        case .replace(let node):
-            enumCase = node
-        case .remove:
+        if go(node: &enumCase, key: nil) {
             //TODO: figure this out
             fatalError("What happens here?")
         }
@@ -169,14 +154,10 @@ public func visit<T: Node, V: Visitor>(root: T, visitor: V) -> T {
     var descender = Descender(visitor: visitor)
 
     var result = root
-    switch descender.go(node: &result, key: nil) {
-    case .remove:
+    if descender.go(node: &result, key: nil) {
         fatalError("Root node in the AST was removed")
-    case .replace(let node):
-        return node
-    case nil:
-        return result
     }
+    return result
 }
 
 public enum VisitorParent {

Sources/GraphQL/Type/Definition.swift

@@ -915,11 +915,12 @@ public final class GraphQLUnionType {
     public let resolveType: GraphQLTypeResolve?
     private let typesThunk: () -> [GraphQLObjectType]
     public lazy var types = {
-        try! defineTypes(
-           name: name,
-           hasResolve: resolveType != nil,
-           types: typesThunk()
-       )
+        typesThunk()
+//        try! defineTypes(
+//           name: name,
+//           hasResolve: resolveType != nil,
+//           types: typesThunk()
+//       )
     }()
     public let possibleTypeNames: [String: Bool]
     public let kind: TypeKind = .union

Sources/GraphQL/Utilities/BuildClientSchema.swift

@@ -152,9 +152,16 @@ public func buildClientSchema(introspection: IntrospectionQuery) throws -> Graph
 
 //    let directives = []
 
+    let mutationType: GraphQLObjectType?
+    if let mutationTypeRef = schemaIntrospection.mutationType {
+        mutationType = try getObjectType(name: mutationTypeRef.name)
+    } else {
+        mutationType = nil
+    }
+    
     return try GraphQLSchema(
         query: try getObjectType(name: schemaIntrospection.queryType.name),
-        mutation: nil,
+        mutation: mutationType,
         subscription: nil,
         types: Array(typeMap.values),
         directives: []

Sources/GraphQL/Utilities/GetIntrospectionQuery.swift

@@ -1,4 +1,4 @@
-func getIntrospectionQuery(
+public func getIntrospectionQuery(
     descriptions: Bool = true,
     specifiedByUrl: Bool = false,
     directiveIsRepeatable: Bool = false,

Sources/GraphQL/Utilities/TypeComparators.swift

@@ -1,7 +1,7 @@
 /**
  * Provided two types, return true if the types are equal (invariant).
  */
-func isEqualType(_ typeA: GraphQLType, _ typeB: GraphQLType) -> Bool {
+public func isEqualType(_ typeA: GraphQLType, _ typeB: GraphQLType) -> Bool {
     // Equivalent types are equal.
     if typeA == typeB {
         return true
@@ -70,7 +70,7 @@ func == (lhs: GraphQLType, rhs: GraphQLType) -> Bool {
  * Provided a type and a super type, return true if the first type is either
  * equal or a subset of the second super type (covariant).
  */
-func isTypeSubTypeOf(
+public func isTypeSubTypeOf(
     _ schema: GraphQLSchema,
     _ maybeSubType: GraphQLType,
     _ superType: GraphQLType

Sources/GraphQL/Utilities/TypeFromAST.swift

@@ -1,4 +1,4 @@
-func typeFromAST(schema: GraphQLSchema, inputTypeAST: Type) -> GraphQLType? {
+public func typeFromAST(schema: GraphQLSchema, inputTypeAST: Type) -> GraphQLType? {
     switch inputTypeAST {
     case let .listType(listType):
         if let innerType = typeFromAST(schema: schema, inputTypeAST: listType.type) {