feat: New nio-based concurrent executor

Author: NeedleInAJayStack

Sources/GraphQL/Execution/Execute.swift

@@ -149,6 +149,7 @@ public struct SerialFieldExecutionStrategy: QueryFieldExecutionStrategy,
  *
  * Each field is resolved as an individual task on a concurrent dispatch queue.
  */
+@available(*, deprecated, message: "Use ConcurrentFieldExecutionStrategy instead")
 public struct ConcurrentDispatchFieldExecutionStrategy: QueryFieldExecutionStrategy,
     SubscriptionFieldExecutionStrategy
 {
@@ -224,6 +225,37 @@ public struct ConcurrentDispatchFieldExecutionStrategy: QueryFieldExecutionStrat
     }
 }
 
+/**
+ * Serial field execution strategy that's suitable for the "Evaluating selection sets" section of the spec for "read" mode.
+ */
+public struct ConcurrentFieldExecutionStrategy: QueryFieldExecutionStrategy,
+SubscriptionFieldExecutionStrategy {
+    public init() {}
+
+    public func executeFields(
+        exeContext: ExecutionContext,
+        parentType: GraphQLObjectType,
+        sourceValue: Any,
+        path: IndexPath,
+        fields: OrderedDictionary<String, [Field]>
+    ) throws -> Future<OrderedDictionary<String, Any>> {
+        var results = OrderedDictionary<String, Future<Any>?>(minimumCapacity: fields.count)
+        for field in fields {
+            let fieldASTs = field.value
+            let fieldKey = field.key
+            let fieldPath = path.appending(fieldKey)
+            results[fieldKey] = try resolveField(
+                exeContext: exeContext,
+                parentType: parentType,
+                source: sourceValue,
+                fieldASTs: fieldASTs,
+                path: fieldPath
+            ).map { $0 ?? Map.null }
+        }
+        return results.compactMapValues { $0 }.flatten(on: exeContext.eventLoopGroup)
+    }
+}
+
 /**
  * Implements the "Evaluating requests" section of the GraphQL specification.
  *

Tests/GraphQLTests/FieldExecutionStrategyTests/FieldExecutionStrategyTests.swift

@@ -313,4 +313,49 @@ class FieldExecutionStrategyTests: XCTestCase {
         }
         // XCTAssertEqualWithAccuracy(0.1, result.seconds, accuracy: 0.25)
     }
+
+    func testConcurrentFieldExecutionStrategyWithSingleField() throws {
+        let result = try timing(graphql(
+            queryStrategy: ConcurrentFieldExecutionStrategy(),
+            schema: schema,
+            request: singleQuery,
+            eventLoopGroup: eventLoopGroup
+        ).wait())
+        XCTAssertEqual(result.value, singleExpected)
+    }
+
+    func testConcurrentFieldExecutionStrategyWithSingleFieldError() throws {
+        let result = try timing(graphql(
+            queryStrategy: ConcurrentFieldExecutionStrategy(),
+            schema: schema,
+            request: singleThrowsQuery,
+            eventLoopGroup: eventLoopGroup
+        ).wait())
+        XCTAssertEqual(result.value, singleThrowsExpected)
+    }
+
+    func testConcurrentFieldExecutionStrategyWithMultipleFields() throws {
+        let result = try timing(graphql(
+            queryStrategy: ConcurrentFieldExecutionStrategy(),
+            schema: schema,
+            request: multiQuery,
+            eventLoopGroup: eventLoopGroup
+        ).wait())
+        XCTAssertEqual(result.value, multiExpected)
+    }
+
+    func testConcurrentFieldExecutionStrategyWithMultipleFieldErrors() throws {
+        let result = try timing(graphql(
+            queryStrategy: ConcurrentFieldExecutionStrategy(),
+            schema: schema,
+            request: multiThrowsQuery,
+            eventLoopGroup: eventLoopGroup
+        ).wait())
+        XCTAssertEqual(result.value.data, multiThrowsExpectedData)
+        let resultErrors = result.value.errors
+        XCTAssertEqual(resultErrors.count, multiThrowsExpectedErrors.count)
+        for m in multiThrowsExpectedErrors {
+            XCTAssertTrue(resultErrors.contains(m), "Expecting result errors to contain \(m)")
+        }
+    }
 }