Introduce persisted queries (#21)

* Instrumentation

* Persisted Queries

Author: williambailey

Sources/GraphQL/Execution/Execute.swift

@@ -31,6 +31,7 @@ public final class ExecutionContext {
     let queryStrategy: QueryFieldExecutionStrategy
     let mutationStrategy: MutationFieldExecutionStrategy
     let subscriptionStrategy: SubscriptionFieldExecutionStrategy
+    let instrumentation: Instrumentation
     public let schema: GraphQLSchema
     public let fragments: [String: FragmentDefinition]
     public let rootValue: Any
@@ -55,6 +56,7 @@ public final class ExecutionContext {
         queryStrategy: QueryFieldExecutionStrategy,
         mutationStrategy: MutationFieldExecutionStrategy,
         subscriptionStrategy: SubscriptionFieldExecutionStrategy,
+        instrumentation: Instrumentation,
         schema: GraphQLSchema,
         fragments: [String: FragmentDefinition],
         rootValue: Any,
@@ -66,6 +68,7 @@ public final class ExecutionContext {
         self.queryStrategy = queryStrategy
         self.mutationStrategy = mutationStrategy
         self.subscriptionStrategy = subscriptionStrategy
+        self.instrumentation = instrumentation
         self.schema = schema
         self.fragments = fragments
         self.rootValue = rootValue
@@ -214,50 +217,89 @@ func execute(
     queryStrategy: QueryFieldExecutionStrategy,
     mutationStrategy: MutationFieldExecutionStrategy,
     subscriptionStrategy: SubscriptionFieldExecutionStrategy,
+    instrumentation: Instrumentation,
     schema: GraphQLSchema,
     documentAST: Document,
     rootValue: Any,
     contextValue: Any,
     variableValues: [String: Map] = [:],
     operationName: String? = nil
 ) throws -> Map {
-    // If a valid context cannot be created due to incorrect arguments,
-    // this will throw an error.
-    let context = try buildExecutionContext(
-        queryStrategy: queryStrategy,
-        mutationStrategy: mutationStrategy,
-        subscriptionStrategy: subscriptionStrategy,
-        schema: schema,
-        documentAST: documentAST,
-        rootValue: rootValue,
-        contextValue: contextValue,
-        rawVariableValues: variableValues,
-        operationName: operationName
-    )
 
+    let executeStarted = instrumentation.now
+    let context: ExecutionContext
+    do {
+        // If a valid context cannot be created due to incorrect arguments,
+        // this will throw an error.
+        context = try buildExecutionContext(
+            queryStrategy: queryStrategy,
+            mutationStrategy: mutationStrategy,
+            subscriptionStrategy: subscriptionStrategy,
+            instrumentation: instrumentation,
+            schema: schema,
+            documentAST: documentAST,
+            rootValue: rootValue,
+            contextValue: contextValue,
+            rawVariableValues: variableValues,
+            operationName: operationName
+        )
+    } catch let error as GraphQLError {
+        instrumentation.operationExecution(
+            processId: processId(),
+            threadId: threadId(),
+            started: executeStarted,
+            finished: instrumentation.now,
+            schema: schema,
+            document: documentAST,
+            rootValue: rootValue,
+            contextValue: contextValue,
+            variableValues: variableValues,
+            operation: nil,
+            errors: [error],
+            result: nil
+        )
+        throw error
+    }
+
+    let executeResult: Map
+    let executeErrors: [GraphQLError]
     do {
         let data = try executeOperation(
             exeContext: context,
             operation: context.operation,
             rootValue: rootValue
         )
-
         var dataMap: Map = [:]
-
         for (key, value) in data {
             dataMap[key] = try map(from: value)
         }
-
         var result: [String: Map] = ["data": dataMap]
-
         if !context.errors.isEmpty {
             result["errors"] = context.errors.map
         }
-
-        return .dictionary(result)
+        executeResult = .dictionary(result)
+        executeErrors = context.errors
     } catch let error as GraphQLError {
-        return ["errors": [error].map]
+        executeResult = ["errors": [error].map]
+        executeErrors = [error]
     }
+
+    instrumentation.operationExecution(
+        processId: processId(),
+        threadId: threadId(),
+        started: executeStarted,
+        finished: instrumentation.now,
+        schema: schema,
+        document: documentAST,
+        rootValue: rootValue,
+        contextValue: contextValue,
+        variableValues: variableValues,
+        operation: context.operation,
+        errors: executeErrors,
+        result: executeResult
+    )
+
+    return executeResult
 }
 
 /**
@@ -270,6 +312,7 @@ func buildExecutionContext(
     queryStrategy: QueryFieldExecutionStrategy,
     mutationStrategy: MutationFieldExecutionStrategy,
     subscriptionStrategy: SubscriptionFieldExecutionStrategy,
+    instrumentation: Instrumentation,
     schema: GraphQLSchema,
     documentAST: Document,
     rootValue: Any,
@@ -323,6 +366,7 @@ func buildExecutionContext(
         queryStrategy: queryStrategy,
         mutationStrategy: mutationStrategy,
         subscriptionStrategy: subscriptionStrategy,
+        instrumentation: instrumentation,
         schema: schema,
         fragments: fragments,
         rootValue: rootValue,
@@ -629,6 +673,8 @@ public func resolveField(
         variableValues: exeContext.variableValues
     )
 
+    let resolveFieldStarted = exeContext.instrumentation.now
+
     // Get the resolve func, regardless of if its result is normal
     // or abrupt (error).
     let result = resolveOrError(
@@ -638,6 +684,18 @@ public func resolveField(
         context: context,
         info: info
     )
+
+    exeContext.instrumentation.fieldResolution(
+        processId: processId(),
+        threadId: threadId(), 
+        started: resolveFieldStarted,
+        finished: exeContext.instrumentation.now,
+        source: source,
+        args: args,
+        context: context,
+        info: info,
+        result: result
+    )
 
     return try completeValueCatchingError(
         exeContext: exeContext,
@@ -649,9 +707,9 @@ public func resolveField(
     )
 }
 
-enum ResultOrError {
-    case result(Any?)
-    case error(Error)
+public enum ResultOrError<T, E> {
+    case result(T)
+    case error(E)
 }
 
 // Isolates the "ReturnOrAbrupt" behavior to not de-opt the `resolveField`
@@ -662,7 +720,7 @@ func resolveOrError(
     args: Map,
     context: Any,
     info: GraphQLResolveInfo
-)-> ResultOrError {
+)-> ResultOrError<Any?, Error> {
     do {
         return try .result(resolve(source, args, context, info))
     } catch {
@@ -678,7 +736,7 @@ func completeValueCatchingError(
     fieldASTs: [Field],
     info: GraphQLResolveInfo,
     path: [IndexPathElement],
-    result: ResultOrError
+    result: ResultOrError<Any?, Error>
 ) throws -> Any? {
     // If the field type is non-nullable, then it is resolved without any
     // protection from errors, however it still properly locates the error.
@@ -724,7 +782,7 @@ func completeValueWithLocatedError(
     fieldASTs: [Field],
     info: GraphQLResolveInfo,
     path: [IndexPathElement],
-    result: ResultOrError
+    result: ResultOrError<Any?, Error>
 ) throws -> Any? {
     do {
         let completed = try completeValue(
@@ -773,7 +831,7 @@ func completeValue(
     fieldASTs: [Field],
     info: GraphQLResolveInfo,
     path: [IndexPathElement],
-    result: ResultOrError
+    result: ResultOrError<Any?, Error>
 ) throws -> Any? {
     switch result {
     case .error(let error):

Sources/GraphQL/GraphQL.swift

@@ -9,6 +9,7 @@
 /// - parameter queryStrategy:        The field execution strategy to use for query requests
 /// - parameter mutationStrategy:     The field execution strategy to use for mutation requests
 /// - parameter subscriptionStrategy: The field execution strategy to use for subscription requests
+/// - parameter instrumentation:      The instrumentation implementation to call during the parsing, validating, execution, and field resolution stages.
 /// - parameter schema:               The GraphQL type system to use when validating and executing a query.
 /// - parameter request:              A GraphQL language formatted string representing the requested operation.
 /// - parameter rootValue:            The value provided as the first argument to resolver functions on the top level type (e.g. the query object type).
@@ -23,16 +24,18 @@ public func graphql(
     queryStrategy: QueryFieldExecutionStrategy = SerialFieldExecutionStrategy(),
     mutationStrategy: MutationFieldExecutionStrategy = SerialFieldExecutionStrategy(),
     subscriptionStrategy: SubscriptionFieldExecutionStrategy = SerialFieldExecutionStrategy(),
+    instrumentation: Instrumentation = NoOpInstrumentation,
     schema: GraphQLSchema,
     request: String,
     rootValue: Any = Void(),
     contextValue: Any = Void(),
     variableValues: [String: Map] = [:],
     operationName: String? = nil
 ) throws -> Map {
+
     let source = Source(body: request, name: "GraphQL request")
-    let documentAST = try parse(source: source)
-    let validationErrors = validate(schema: schema, ast: documentAST)
+    let documentAST = try parse(instrumentation: instrumentation, source: source)
+    let validationErrors = validate(instrumentation: instrumentation, schema: schema, ast: documentAST)
 
     guard validationErrors.isEmpty else {
         return ["errors": try validationErrors.asMap()]
@@ -42,6 +45,7 @@ public func graphql(
         queryStrategy: queryStrategy,
         mutationStrategy: mutationStrategy,
         subscriptionStrategy: subscriptionStrategy,
+        instrumentation: instrumentation,
         schema: schema,
         documentAST: documentAST,
         rootValue: rootValue,
@@ -50,3 +54,55 @@ public func graphql(
         operationName: operationName
     )
 }
+
+/// This is the primary entry point function for fulfilling GraphQL operations
+/// by using persisted queries.
+///
+/// - parameter queryStrategy:        The field execution strategy to use for query requests
+/// - parameter mutationStrategy:     The field execution strategy to use for mutation requests
+/// - parameter subscriptionStrategy: The field execution strategy to use for subscription requests
+/// - parameter instrumentation:      The instrumentation implementation to call during the parsing, validating, execution, and field resolution stages.
+/// - parameter queryRetrieval:       The PersistedQueryRetrieval instance to use for looking up queries
+/// - parameter queryId:              The id of the query to execute
+/// - parameter rootValue:            The value provided as the first argument to resolver functions on the top level type (e.g. the query object type).
+/// - parameter contextValue:         A context value provided to all resolver functions functions
+/// - parameter variableValues:       A mapping of variable name to runtime value to use for all variables defined in the `request`.
+/// - parameter operationName:        The name of the operation to use if `request` contains multiple possible operations. Can be omitted if `request` contains only one operation.
+///
+/// - throws: throws GraphQLError if an error occurs while parsing the `request`.
+///
+/// - 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<Retrieval:PersistedQueryRetrieval>(
+    queryStrategy: QueryFieldExecutionStrategy = SerialFieldExecutionStrategy(),
+    mutationStrategy: MutationFieldExecutionStrategy = SerialFieldExecutionStrategy(),
+    subscriptionStrategy: SubscriptionFieldExecutionStrategy = SerialFieldExecutionStrategy(),
+    instrumentation: Instrumentation = NoOpInstrumentation,
+    queryRetrieval: Retrieval,
+    queryId: Retrieval.Id,
+    rootValue: Any = Void(),
+    contextValue: Any = Void(),
+    variableValues: [String: Map] = [:],
+    operationName: String? = nil
+) throws -> Map {
+    switch try queryRetrieval.lookup(queryId) {
+    case .unknownId(_):
+        throw GraphQLError(message: "Unknown query id")
+    case .parseError(let parseError):
+        throw parseError
+    case .validateErrors(_, let validationErrors):
+        return ["errors": try validationErrors.asMap()]
+    case .result(let schema, let documentAST):
+        return try execute(
+            queryStrategy: queryStrategy,
+            mutationStrategy: mutationStrategy,
+            subscriptionStrategy: subscriptionStrategy,
+            instrumentation: instrumentation,
+            schema: schema,
+            documentAST: documentAST,
+            rootValue: rootValue,
+            contextValue: contextValue,
+            variableValues: variableValues,
+            operationName: operationName
+        )
+    }
+}

Sources/GraphQL/Instrumentation/DispatchQueueInstrumentationWrapper.swift

@@ -0,0 +1,55 @@
+import Dispatch
+
+/// Proxies calls through to another `Instrumentation` instance via a DispatchQueue
+///
+/// Has two primary use cases:
+/// 1. Allows a non thread safe Instrumentation implementation to be used along side a multithreaded execution strategy
+/// 2. Allows slow or heavy instrumentation processing to happen outside of the current query execution
+public class DispatchQueueInstrumentationWrapper: Instrumentation {
+
+    let instrumentation:Instrumentation
+    let dispatchQueue: DispatchQueue
+    let dispatchGroup: DispatchGroup?
+
+    public init(_ instrumentation: Instrumentation, label: String = "GraphQL instrumentation wrapper", qos: DispatchQoS = .utility, attributes: DispatchQueue.Attributes = [], dispatchGroup: DispatchGroup? = nil ) {
+        self.instrumentation = instrumentation
+        self.dispatchQueue = DispatchQueue(label: label, qos: qos, attributes: attributes)
+        self.dispatchGroup = dispatchGroup
+    }
+
+    public init(_ instrumentation: Instrumentation, dispatchQueue: DispatchQueue, dispatchGroup: DispatchGroup? = nil ) {
+        self.instrumentation = instrumentation
+        self.dispatchQueue = dispatchQueue
+        self.dispatchGroup = dispatchGroup
+    }
+
+    public var now: DispatchTime {
+        return instrumentation.now
+    }
+
+    public func queryParsing(processId: Int, threadId: Int, started: DispatchTime, finished: DispatchTime, source: Source, result: ResultOrError<Document, GraphQLError>) {
+        dispatchQueue.async(group: dispatchGroup) {
+            self.instrumentation.queryParsing(processId: processId, threadId: threadId, started: started, finished: finished, source: source, result: result)
+        }
+    }
+
+    public func queryValidation(processId: Int, threadId: Int, started: DispatchTime, finished: DispatchTime, schema: GraphQLSchema, document: Document, errors: [GraphQLError]) {
+        dispatchQueue.async(group: dispatchGroup) {
+            self.instrumentation.queryValidation(processId: processId, threadId: threadId, started: started, finished: finished, schema: schema, document: document, errors: errors)
+        }
+    }
+
+    public func operationExecution(processId: Int, threadId: Int, started: DispatchTime, finished: DispatchTime, schema: GraphQLSchema, document: Document, rootValue: Any, contextValue: Any, variableValues: [String : Map], operation: OperationDefinition?, errors: [GraphQLError], result: Map) {
+        dispatchQueue.async(group: dispatchGroup) {
+            self.instrumentation.operationExecution(processId: processId, threadId: threadId, started: started, finished: finished, schema: schema, document: document, rootValue: rootValue, contextValue: contextValue, variableValues: variableValues, operation: operation, errors: errors, result: result)
+        }
+    }
+
+    public func fieldResolution(processId: Int, threadId: Int, started: DispatchTime, finished: DispatchTime, source: Any, args: Map, context: Any, info: GraphQLResolveInfo, result: ResultOrError<Any?, Error>) {
+        dispatchQueue.async(group: dispatchGroup) {
+            self.instrumentation.fieldResolution(processId: processId, threadId: threadId, started: started, finished: finished, source: source, args: args, context: context, info: info, result: result)
+        }
+    }
+
+}
+