Implement ConcurrentDispatchFieldExecutionStrategy (#13)

Author: williambailey

README.md

@@ -1,4 +1,4 @@
-# GraphQL 
+# GraphQL
 
 The Swift implementation for GraphQL, a query language for APIs created by Facebook.
 
@@ -36,7 +36,7 @@ import PackageDescription
 
 let package = Package(
     dependencies: [
-        .Package(url: "https://github.com/GraphQLSwift/GraphQL.git", majorVersion: 0, minor: 2),
+        .Package(url: "https://github.com/GraphQLSwift/GraphQL.git", majorVersion: 0),
     ]
 )
 ```
@@ -104,13 +104,36 @@ Output:
                     "line": 1,
                     "column": 3
                 }
-            ], 
+            ],
             "message": "Cannot query field \"boyhowdy\" on type \"RootQueryType\"."
         }
     ]
 }
 ```
 
+### Field Execution Strategies
+
+Depending on your needs you can alter the field execution strategies used for field value resolution.
+
+By default the `SerialFieldExecutionStrategy` is used for all operation types (`query`, `mutation`, `subscription`).
+
+To use a different strategy simply provide it to the `graphql` function:
+
+```swift
+try graphql(
+    queryStrategy: ConcurrentDispatchFieldExecutionStrategy(),
+    schema: schema,
+    request: query
+)
+```
+
+The following strategies are available:
+
+* `SerialFieldExecutionStrategy`
+* `ConcurrentDispatchFieldExecutionStrategy`
+
+**Please note:** Not all strategies are applicable for all operation types.
+
 ## License
 
 This project is released under the MIT license. See [LICENSE](LICENSE) for details.
@@ -127,4 +150,4 @@ This project is released under the MIT license. See [LICENSE](LICENSE) for detai
 [codecov-badge]: https://codecov.io/gh/GraphQLSwift/GraphQL/branch/master/graph/badge.svg
 [codecov-url]: https://codecov.io/gh/GraphQLSwift/GraphQL
 [codebeat-badge]: https://codebeat.co/badges/13293962-d1d8-4906-8e62-30a2cbb66b38
-[codebeat-url]: https://codebeat.co/projects/github-com-graphqlswift-graphql
+[codebeat-url]: https://codebeat.co/projects/github-com-graphqlswift-graphql

Sources/GraphQL/Execution/Execute.swift

@@ -1,3 +1,5 @@
+import Dispatch
+
 /**
  * Terminology
  *
@@ -26,21 +28,33 @@
  */
 public final class ExecutionContext {
 
-    let queryStrategy: FieldExecutionStrategy
-    let mutationStrategy: FieldExecutionStrategy
-    let subscriptionStrategy: FieldExecutionStrategy
-    let schema: GraphQLSchema
-    let fragments: [String: FragmentDefinition]
-    let rootValue: Any
-    let contextValue: Any
-    let operation: OperationDefinition
-    let variableValues: [String: Map]
-    var errors: [GraphQLError]
+    let queryStrategy: QueryFieldExecutionStrategy
+    let mutationStrategy: MutationFieldExecutionStrategy
+    let subscriptionStrategy: SubscriptionFieldExecutionStrategy
+    public let schema: GraphQLSchema
+    public let fragments: [String: FragmentDefinition]
+    public let rootValue: Any
+    public let contextValue: Any
+    public let operation: OperationDefinition
+    public let variableValues: [String: Map]
+
+    private var errorsSemaphore = DispatchSemaphore(value: 1)
+    private var _errors: [GraphQLError]
+
+    var errors: [GraphQLError] {
+        get {
+            errorsSemaphore.wait()
+            defer {
+                errorsSemaphore.signal()
+            }
+            return _errors
+        }
+    }
 
     init(
-        queryStrategy: FieldExecutionStrategy,
-        mutationStrategy: FieldExecutionStrategy,
-        subscriptionStrategy: FieldExecutionStrategy,
+        queryStrategy: QueryFieldExecutionStrategy,
+        mutationStrategy: MutationFieldExecutionStrategy,
+        subscriptionStrategy: SubscriptionFieldExecutionStrategy,
         schema: GraphQLSchema,
         fragments: [String: FragmentDefinition],
         rootValue: Any,
@@ -58,9 +72,17 @@ public final class ExecutionContext {
         self.contextValue = contextValue
         self.operation = operation
         self.variableValues = variableValues
-        self.errors = errors
+        self._errors = errors
+    }
 
+    public func append(error: GraphQLError) {
+        errorsSemaphore.wait()
+        defer {
+            errorsSemaphore.signal()
+        }
+        _errors.append(error)
     }
+
 }
 
 public protocol FieldExecutionStrategy {
@@ -73,10 +95,17 @@ public protocol FieldExecutionStrategy {
     ) throws -> [String: Any]
 }
 
+public protocol MutationFieldExecutionStrategy: FieldExecutionStrategy {}
+public protocol QueryFieldExecutionStrategy: FieldExecutionStrategy {}
+public protocol SubscriptionFieldExecutionStrategy: FieldExecutionStrategy {}
+
 /**
  * Serial field execution strategy that's suitable for the "Evaluating selection sets" section of the spec for "write" mode.
  */
-public struct SerialFieldExecutionStrategy: FieldExecutionStrategy {
+public struct SerialFieldExecutionStrategy: QueryFieldExecutionStrategy, MutationFieldExecutionStrategy, SubscriptionFieldExecutionStrategy {
+
+    public init () {}
+
     public func executeFields(
         exeContext: ExecutionContext,
         parentType: GraphQLObjectType,
@@ -103,16 +132,88 @@ public struct SerialFieldExecutionStrategy: FieldExecutionStrategy {
     }
 }
 
+/**
+ * Serial field execution strategy that's suitable for the "Evaluating selection sets" section of the spec for "read" mode.
+ *
+ * Each field is resolved as an individual task on a concurrent dispatch queue.
+ */
+public struct ConcurrentDispatchFieldExecutionStrategy: QueryFieldExecutionStrategy, SubscriptionFieldExecutionStrategy {
+
+    let dispatchQueue: DispatchQueue
+
+    public init(dispatchQueue: DispatchQueue) {
+        self.dispatchQueue = dispatchQueue
+    }
+
+    public init(queueLabel: String = "GraphQL field execution", queueQoS: DispatchQoS = .userInitiated) {
+        self.dispatchQueue = DispatchQueue(
+            label: queueLabel,
+            qos: queueQoS,
+            attributes: .concurrent
+        )
+    }
+
+    public func executeFields(
+        exeContext: ExecutionContext,
+        parentType: GraphQLObjectType,
+        sourceValue: Any,
+        path: [IndexPathElement],
+        fields: [String: [Field]]
+    ) throws -> [String: Any] {
+
+        let resultsQueue = DispatchQueue(
+            label: "\(dispatchQueue.label) results",
+            qos: dispatchQueue.qos
+        )
+        let group = DispatchGroup()
+        var results: [String: Any] = [:]
+        var err: Error? = nil
+
+        fields.forEach { field in
+            let fieldASTs = field.value
+            let fieldKey  = field.key
+            let fieldPath = path + [fieldKey] as [IndexPathElement]
+            dispatchQueue.async(group: group) {
+                guard err == nil else {
+                    return
+                }
+                do {
+                    let result = try resolveField(
+                        exeContext: exeContext,
+                        parentType: parentType,
+                        source: sourceValue,
+                        fieldASTs: fieldASTs,
+                        path: fieldPath
+                    )
+                    resultsQueue.async(group: group) {
+                        results[fieldKey] = result ?? Map.null
+                    }
+                } catch {
+                    resultsQueue.async(group: group) {
+                        err = error
+                    }
+                }
+            }
+        }
+        group.wait()
+        if let error = err {
+            throw error
+        }
+        return results
+    }
+
+}
+
 /**
  * Implements the "Evaluating requests" section of the GraphQL specification.
  *
  * If the arguments to this func do not result in a legal execution context,
  * a GraphQLError will be thrown immediately explaining the invalid input.
  */
 func execute(
-    queryStrategy: FieldExecutionStrategy,
-    mutationStrategy: FieldExecutionStrategy,
-    subscriptionStrategy: FieldExecutionStrategy,
+    queryStrategy: QueryFieldExecutionStrategy,
+    mutationStrategy: MutationFieldExecutionStrategy,
+    subscriptionStrategy: SubscriptionFieldExecutionStrategy,
     schema: GraphQLSchema,
     documentAST: Document,
     rootValue: Any,
@@ -166,9 +267,9 @@ func execute(
  * Throws a GraphQLError if a valid execution context cannot be created.
  */
 func buildExecutionContext(
-    queryStrategy: FieldExecutionStrategy,
-    mutationStrategy: FieldExecutionStrategy,
-    subscriptionStrategy: FieldExecutionStrategy,
+    queryStrategy: QueryFieldExecutionStrategy,
+    mutationStrategy: MutationFieldExecutionStrategy,
+    subscriptionStrategy: SubscriptionFieldExecutionStrategy,
     schema: GraphQLSchema,
     documentAST: Document,
     rootValue: Any,
@@ -608,7 +709,7 @@ func completeValueCatchingError(
     } catch let error as GraphQLError {
         // If `completeValueWithLocatedError` returned abruptly (threw an error),
         // log the error and return .null.
-        exeContext.errors.append(error)
+        exeContext.append(error: error)
         return nil
     } catch {
         fatalError()

Sources/GraphQL/GraphQL.swift

@@ -20,9 +20,9 @@
 ///
 /// - returns: returns a `Map` dictionary containing the result of the query inside the key `data` and any validation or execution errors inside the key `errors`. The value of `data` might be `null` if, for example, the query is invalid. It's possible to have both `data` and `errors` if an error occurs only in a specific field. If that happens the value of that field will be `null` and there will be an error inside `errors` specifying the reason for the failure and the path of the failed field.
 public func graphql(
-    queryStrategy: FieldExecutionStrategy = SerialFieldExecutionStrategy(),
-    mutationStrategy: FieldExecutionStrategy = SerialFieldExecutionStrategy(),
-    subscriptionStrategy: FieldExecutionStrategy = SerialFieldExecutionStrategy(),
+    queryStrategy: QueryFieldExecutionStrategy = SerialFieldExecutionStrategy(),
+    mutationStrategy: MutationFieldExecutionStrategy = SerialFieldExecutionStrategy(),
+    subscriptionStrategy: SubscriptionFieldExecutionStrategy = SerialFieldExecutionStrategy(),
     schema: GraphQLSchema,
     request: String,
     rootValue: Any = Void(),

Sources/GraphQL/Language/AST.swift

@@ -289,16 +289,16 @@ func == (lhs: Definition, rhs: Definition) -> Bool {
     return false
 }
 
-enum OperationType : String {
+public enum OperationType : String {
     case query = "query"
     case mutation = "mutation"
     // Note: subscription is an experimental non-spec addition.
     case subscription = "subscription"
 }
 
-final class OperationDefinition {
-    let kind: Kind = .operationDefinition
-    let loc: Location?
+public final class OperationDefinition {
+    public let kind: Kind = .operationDefinition
+    public let loc: Location?
     let operation: OperationType
     let name: Name?
     let variableDefinitions: [VariableDefinition]
@@ -314,7 +314,7 @@ final class OperationDefinition {
         self.selectionSet = selectionSet
     }
 
-    func get(key: String) -> NodeResult? {
+    public func get(key: String) -> NodeResult? {
         switch key {
         case "name":
             return name.map({ .node($0) })
@@ -337,11 +337,11 @@ final class OperationDefinition {
 }
 
 extension OperationDefinition : Hashable {
-    var hashValue: Int {
+    public var hashValue: Int {
         return ObjectIdentifier(self).hashValue
     }
 
-    static func == (lhs: OperationDefinition, rhs: OperationDefinition) -> Bool {
+    public static func == (lhs: OperationDefinition, rhs: OperationDefinition) -> Bool {
         return lhs.operation == rhs.operation &&
             lhs.name == rhs.name &&
             lhs.variableDefinitions == rhs.variableDefinitions &&
@@ -673,9 +673,9 @@ extension InlineFragment : Equatable {
     }
 }
 
-final class FragmentDefinition {
-    let kind: Kind = .fragmentDefinition
-    let loc: Location?
+public final class FragmentDefinition {
+    public let kind: Kind = .fragmentDefinition
+    public let loc: Location?
     let name: Name
     let typeCondition: NamedType
     let directives: [Directive]
@@ -689,7 +689,7 @@ final class FragmentDefinition {
         self.selectionSet = selectionSet
     }
 
-    func get(key: String) -> NodeResult? {
+    public func get(key: String) -> NodeResult? {
         switch key {
         case "name":
             return .node(name)
@@ -709,11 +709,11 @@ final class FragmentDefinition {
 }
 
 extension FragmentDefinition : Hashable {
-    var hashValue: Int {
+    public var hashValue: Int {
         return ObjectIdentifier(self).hashValue
     }
 
-    static func == (lhs: FragmentDefinition, rhs: FragmentDefinition) -> Bool {
+    public static func == (lhs: FragmentDefinition, rhs: FragmentDefinition) -> Bool {
         return lhs.name == rhs.name &&
         lhs.typeCondition == rhs.typeCondition &&
         lhs.directives == rhs.directives &&

Sources/GraphQL/Type/Definition.swift

@@ -452,11 +452,11 @@ public typealias GraphQLFieldResolve = (
 ) throws -> Any?
 
 public struct GraphQLResolveInfo {
-    let fieldName: String
+    public let fieldName: String
     let fieldASTs: [Field]
     let returnType: GraphQLOutputType
     let parentType: GraphQLCompositeType
-    let path: [IndexPathElement]
+    public let path: [IndexPathElement]
     let schema: GraphQLSchema
     let fragments: [String: FragmentDefinition]
     let rootValue: Any