Adds primary subscription entry point function

Author: Jay Herron

Sources/GraphQL/GraphQL.swift

@@ -1,5 +1,6 @@
 import Foundation
 import NIO
+import RxSwift
 
 public struct GraphQLResult : Equatable, Codable, CustomStringConvertible {
     public var data: Map?
@@ -151,3 +152,66 @@ public func graphql<Retrieval: PersistedQueryRetrieval>(
         )
     }
 }
+
+/// This is the primary entry point function for fulfilling GraphQL subscription
+/// operations by parsing, validating, and executing a GraphQL subscription
+/// document along side a GraphQL schema.
+///
+/// More sophisticated GraphQL servers, such as those which persist queries,
+/// may wish to separate the validation and execution phases to a static time
+/// tooling step, and a server runtime step.
+///
+/// - 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).
+/// - parameter contextValue:         A context value provided to all resolver 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 SubscriptionResult containing the subscription observable inside the key `observable` and any validation or execution errors inside the key `errors`. The
+/// value of `observable` might be `null` if, for example, the query is invalid. It's not possible to have both `observable` and `errors`. The observable payloads are
+/// GraphQLResults which contain 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`.
+/// 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 graphqlSubscribe(
+    queryStrategy: QueryFieldExecutionStrategy = SerialFieldExecutionStrategy(),
+    mutationStrategy: MutationFieldExecutionStrategy = SerialFieldExecutionStrategy(),
+    subscriptionStrategy: SubscriptionFieldExecutionStrategy = SerialFieldExecutionStrategy(),
+    instrumentation: Instrumentation = NoOpInstrumentation,
+    schema: GraphQLSchema,
+    request: String,
+    rootValue: Any = Void(),
+    context: Any = Void(),
+    eventLoopGroup: EventLoopGroup,
+    variableValues: [String: Map] = [:],
+    operationName: String? = nil
+) throws -> Future<SubscriptionResult> {
+
+    let source = Source(body: request, name: "GraphQL Subscription request")
+    let documentAST = try parse(instrumentation: instrumentation, source: source)
+    let validationErrors = validate(instrumentation: instrumentation, schema: schema, ast: documentAST)
+
+    guard validationErrors.isEmpty else {
+        return eventLoopGroup.next().makeSucceededFuture(SubscriptionResult(errors: validationErrors))
+    }
+
+    return subscribe(
+        queryStrategy: queryStrategy,
+        mutationStrategy: mutationStrategy,
+        subscriptionStrategy: subscriptionStrategy,
+        instrumentation: instrumentation,
+        schema: schema,
+        documentAST: documentAST,
+        rootValue: rootValue,
+        context: context,
+        eventLoopGroup: eventLoopGroup,
+        variableValues: variableValues,
+        operationName: operationName
+    )
+}

Tests/GraphQLTests/Subscription/SubscriptionTests.swift

@@ -5,7 +5,62 @@ import RxSwift
 
 /// This follows the graphql-js testing, with deviations where noted.
 class SubscriptionTests : XCTestCase {
-
+    
+    // MARK: Test primary graphqlSubscribe function
+    
+    /// This is not present in graphql-js.
+    func testGraphqlSubscribe() throws {
+        let db = EmailDb()
+        let schema = db.defaultSchema()
+        let query = """
+            subscription ($priority: Int = 0) {
+                importantEmail(priority: $priority) {
+                  email {
+                    from
+                    subject
+                  }
+                  inbox {
+                    unread
+                    total
+                  }
+                }
+              }
+        """
+        
+        let subscriptionResult = try graphqlSubscribe(
+            schema: schema,
+            request: query,
+            eventLoopGroup: eventLoopGroup
+        ).wait()
+        
+        let observable = subscriptionResult.observable!
+        
+        var currentResult = GraphQLResult()
+        let _ = observable.subscribe { event in
+            currentResult = try! event.element!.wait()
+        }.disposed(by: db.disposeBag)
+        
+        db.trigger(email: Email(
+            from: "[email protected]",
+            subject: "Alright",
+            message: "Tests are good",
+            unread: true
+        ))
+        
+        XCTAssertEqual(currentResult, GraphQLResult(
+            data: ["importantEmail": [
+                "inbox":[
+                    "total": 2,
+                    "unread": 1
+                ],
+                "email":[
+                    "subject": "Alright",
+                    "from": "[email protected]"
+                ]
+            ]]
+        ))
+    }
+    
     // MARK: Subscription Initialization Phase
 
     /// accepts multiple subscription fields defined in schema
@@ -701,12 +756,9 @@ class EmailDb {
         publisher.onNext(email)
     }
 
-    /// Generates a subscription to the database using a default schema and resolvers
-    func subscription (
-        query:String,
-        variableValues: [String: Map] = [:]
-    ) throws -> SubscriptionObservable {
-        let schema = emailSchemaWithResolvers(
+    /// Returns the default email schema, with standard resolvers.
+    func defaultSchema() -> GraphQLSchema {
+        return emailSchemaWithResolvers(
             resolve: {emailAny, _, _, eventLoopGroup, _ throws -> EventLoopFuture<Any?> in
                 let email = emailAny as! Email
                 return eventLoopGroup.next().makeSucceededFuture(EmailEvent(
@@ -718,8 +770,14 @@ class EmailDb {
                 return eventLoopGroup.next().makeSucceededFuture(self.publisher)
             }
         )
-        
-        return try createSubscription(schema: schema, query: query, variableValues: variableValues)
+    }
+    
+    /// Generates a subscription to the database using the default schema and resolvers
+    func subscription (
+        query:String,
+        variableValues: [String: Map] = [:]
+    ) throws -> SubscriptionObservable {
+        return try createSubscription(schema: defaultSchema(), query: query, variableValues: variableValues)
     }
 }