Merge pull request #57 from eliotfowler/upgrade-nio-to-2.10

Upgrade Swift-NIO to 2.10.1 and fix related errors and warnings

Author: paulofaria

Package.resolved

@@ -7,7 +7,7 @@ let package = Package(
         .library(name: "GraphQL", targets: ["GraphQL"]),
     ],
     dependencies: [
-        .package(url: "https://github.com/apple/swift-nio.git", .upToNextMajor(from: "1.14.1")),
+        .package(url: "https://github.com/apple/swift-nio.git", .upToNextMajor(from: "2.10.1")),
         .package(url: "https://github.com/wickwirew/Runtime.git", .upToNextMinor(from: "2.1.0"))
     ],
     targets: [

Package.swift

@@ -273,9 +273,9 @@ func execute(
             result: nil
         )
 
-        return eventLoopGroup.next().newSucceededFuture(result: GraphQLResult(errors: [error]))
+        return eventLoopGroup.next().makeSucceededFuture(GraphQLResult(errors: [error]))
     } catch {
-        return eventLoopGroup.next().newSucceededFuture(result: GraphQLResult(errors: [GraphQLError(error)]))
+        return eventLoopGroup.next().makeSucceededFuture(GraphQLResult(errors: [GraphQLError(error)]))
     }
 
     do {
@@ -285,7 +285,7 @@ func execute(
             exeContext: buildContext,
             operation: buildContext.operation,
             rootValue: rootValue
-        ).thenThrowing { data -> GraphQLResult in
+            ).flatMapThrowing { data -> GraphQLResult in
             var dataMap: Map = [:]
 
             for (key, value) in data {
@@ -300,12 +300,15 @@ func execute(
 
 //            executeErrors = buildContext.errors
             return result
-        }.mapIfError { error -> GraphQLResult in
+        }.flatMapError { error -> Future<GraphQLResult> in
+            let result: GraphQLResult
             if let error = error as? GraphQLError {
-                return GraphQLResult(errors: [error])
+                result = GraphQLResult(errors: [error])
+            } else {
+                result = GraphQLResult(errors: [GraphQLError(error)])
             }
 
-            return GraphQLResult(errors: [GraphQLError(error)])
+            return buildContext.eventLoopGroup.next().makeSucceededFuture(result)
         }.map { result -> GraphQLResult in
 //            instrumentation.operationExecution(
 //                processId: processId(),
@@ -325,9 +328,9 @@ func execute(
             return result
         }
     } catch let error as GraphQLError {
-        return eventLoopGroup.next().newSucceededFuture(result: GraphQLResult(errors: [error]))
+        return eventLoopGroup.next().makeSucceededFuture(GraphQLResult(errors: [error]))
     } catch {
-        return eventLoopGroup.next().newSucceededFuture(result: GraphQLResult(errors: [GraphQLError(error)]))
+        return eventLoopGroup.next().makeSucceededFuture(GraphQLResult(errors: [GraphQLError(error)]))
     }
 }
 
@@ -788,20 +791,20 @@ func completeValueCatchingError(
             info: info,
             path: path,
             result: result
-        ).mapIfError { error -> Any? in
+        ).flatMapError { error -> EventLoopFuture<Any?> in
             guard let error = error as? GraphQLError else {
                 fatalError()
             }
             exeContext.append(error: error)
-            return nil
+            return exeContext.eventLoopGroup.next().makeSucceededFuture(nil)
         }
 
         return completed
     } catch let error as GraphQLError {
         // If `completeValueWithLocatedError` returned abruptly (threw an error),
         // log the error and return .null.
         exeContext.append(error: error)
-        return exeContext.eventLoopGroup.next().newSucceededFuture(result: nil)
+        return exeContext.eventLoopGroup.next().makeSucceededFuture(nil)
     } catch {
         fatalError()
     }
@@ -825,7 +828,7 @@ func completeValueWithLocatedError(
             info: info,
             path: path,
             result: result
-        ).thenIfErrorThrowing { error -> Any? in
+        ).flatMapErrorThrowing { error -> Any? in
             throw locatedError(originalError: error, nodes: fieldASTs, path: path)
         }
         return completed
@@ -881,7 +884,7 @@ func completeValue(
                 info: info,
                 path: path,
                 result: .success(result)
-            ).thenThrowing { value -> Any? in
+            ).flatMapThrowing { value -> Any? in
                 guard let value = value else {
                     throw GraphQLError(message: "Cannot return null for non-nullable field \(info.parentType.name).\(info.fieldName).")
                 }
@@ -893,7 +896,7 @@ func completeValue(
         return result.flatMap(to: Any?.self) { result -> Future<Any?> in
             // If result value is null-ish (nil or .null) then return .null.
             guard let result = result, let r = unwrap(result) else {
-                return exeContext.eventLoopGroup.next().newSucceededFuture(result: nil)
+                return exeContext.eventLoopGroup.next().makeSucceededFuture(nil)
             }
 
             // If field type is List, complete each item in the list with the inner type
@@ -911,7 +914,7 @@ func completeValue(
             // If field type is a leaf type, Scalar or Enum, serialize to a valid value,
             // returning .null if serialization is not possible.
             if let returnType = returnType as? GraphQLLeafType {
-                return exeContext.eventLoopGroup.next().newSucceededFuture(result: try completeLeafValue(returnType: returnType, result: r))
+                return exeContext.eventLoopGroup.next().makeSucceededFuture(try completeLeafValue(returnType: returnType, result: r))
             }
 
             // If field type is an abstract type, Interface or Union, determine the
@@ -972,7 +975,7 @@ func completeListValue(
         // No need to modify the info object containing the path,
         // since from here on it is not ever accessed by resolver funcs.
         let fieldPath = path.appending(index)
-        let futureItem = item as? Future<Any?> ?? exeContext.eventLoopGroup.next().newSucceededFuture(result: item)
+        let futureItem = item as? Future<Any?> ?? exeContext.eventLoopGroup.next().makeSucceededFuture(item)
 
         let completedItem = try completeValueCatchingError(
             exeContext: exeContext,
@@ -1161,30 +1164,30 @@ func defaultResolve(
     info: GraphQLResolveInfo
 ) -> Future<Any?> {
     guard let source = unwrap(source) else {
-        return eventLoopGroup.next().newSucceededFuture(result: nil)
+        return eventLoopGroup.next().makeSucceededFuture(nil)
     }
 
     if let subscriptable = source as? KeySubscriptable {
         let value = subscriptable[info.fieldName]
-        return eventLoopGroup.next().newSucceededFuture(result: value)
+        return eventLoopGroup.next().makeSucceededFuture(value)
     }
 
     guard let encodable = source as? Encodable else {
-        return eventLoopGroup.next().newSucceededFuture(result: nil)
+        return eventLoopGroup.next().makeSucceededFuture(nil)
     }
 
     guard
         let typeInfo = try? typeInfo(of: type(of: encodable)),
         let property = try? typeInfo.property(named: info.fieldName)
     else {
-        return eventLoopGroup.next().newSucceededFuture(result: nil)
+        return eventLoopGroup.next().makeSucceededFuture(nil)
     }
 
     guard let value = try? property.get(from: encodable) else {
-        return eventLoopGroup.next().newSucceededFuture(result: nil)
+        return eventLoopGroup.next().makeSucceededFuture(nil)
     }
 
-    return eventLoopGroup.next().newSucceededFuture(result: value)
+    return eventLoopGroup.next().makeSucceededFuture(value)
 
 //    guard let any = try? AnyEncoder().encode(AnyEncodable(encodable)) else {
 //        return eventLoopGroup.next().newSucceededFuture(result: nil)

Sources/GraphQL/Execution/Execute.swift

@@ -80,7 +80,7 @@ public func graphql(
     let validationErrors = validate(instrumentation: instrumentation, schema: schema, ast: documentAST)
 
     guard validationErrors.isEmpty else {
-        return eventLoopGroup.next().newSucceededFuture(result: GraphQLResult(errors: validationErrors))
+        return eventLoopGroup.next().makeSucceededFuture(GraphQLResult(errors: validationErrors))
     }
 
     return execute(
@@ -134,7 +134,7 @@ public func graphql<Retrieval: PersistedQueryRetrieval>(
     case .parseError(let parseError):
         throw parseError
     case .validateErrors(_, let validationErrors):
-        return eventLoopGroup.next().newSucceededFuture(result: GraphQLResult(errors: validationErrors))
+        return eventLoopGroup.next().makeSucceededFuture(GraphQLResult(errors: validationErrors))
     case .result(let schema, let documentAST):
         return execute(
             queryStrategy: queryStrategy,

Sources/GraphQL/GraphQL.swift

@@ -557,7 +557,7 @@ public struct GraphQLField {
 
         self.resolve = { source, args, context, eventLoopGroup, info in
             let result = try resolve(source, args, context, info)
-            return eventLoopGroup.next().newSucceededFuture(result: result)
+            return eventLoopGroup.next().makeSucceededFuture(result)
         }
     }
 }

Sources/GraphQL/Type/Definition.swift

@@ -445,7 +445,7 @@ let SchemaMetaFieldDef = GraphQLFieldDefinition(
     type: GraphQLNonNull(__Schema),
     description: "Access the current type schema of this server.",
     resolve: { _, _, _, eventLoopGroup, info in
-        return eventLoopGroup.next().newSucceededFuture(result: info.schema)
+        return eventLoopGroup.next().makeSucceededFuture(info.schema)
     }
 )
 
@@ -461,7 +461,7 @@ let TypeMetaFieldDef = GraphQLFieldDefinition(
     ],
     resolve: { _, arguments, _, eventLoopGroup, info in
         let name = arguments["name"].string!
-        return eventLoopGroup.next().newSucceededFuture(result: info.schema.getType(name: name))
+        return eventLoopGroup.next().makeSucceededFuture(info.schema.getType(name: name))
     }
 )
 
@@ -470,6 +470,6 @@ let TypeNameMetaFieldDef = GraphQLFieldDefinition(
     type: GraphQLNonNull(GraphQLString),
     description: "The name of the current Object type at runtime.",
     resolve: { _, _, _, eventLoopGroup, info in
-        eventLoopGroup.next().newSucceededFuture(result: info.parentType.name)
+        eventLoopGroup.next().makeSucceededFuture(info.parentType.name)
     }
 )

Sources/GraphQL/Type/Introspection.swift

@@ -11,8 +11,8 @@ import NIO
 public typealias Future = EventLoopFuture
 
 extension Collection {
-    internal func flatten<T>(on eventLoopGroup: EventLoopGroup) -> Future<[T]> where Element == Future<T> {
-        return Future.whenAll(Array(self), eventLoop: eventLoopGroup.next())
+    public func flatten<T>(on eventLoopGroup: EventLoopGroup) -> Future<[T]> where Element == Future<T> {
+        return Future.whenAllSucceed(Array(self), on: eventLoopGroup.next())
     }
 }
 
@@ -31,23 +31,23 @@ extension Dictionary where Value : FutureType {
         var elements: [Key: Value.Expectation] = [:]
 
         guard self.count > 0 else {
-            return eventLoopGroup.next().newSucceededFuture(result: elements)
+            return eventLoopGroup.next().makeSucceededFuture(elements)
         }
 
-        let promise: EventLoopPromise<[Key: Value.Expectation]> = eventLoopGroup.next().newPromise()
+        let promise: EventLoopPromise<[Key: Value.Expectation]> = eventLoopGroup.next().makePromise()
         elements.reserveCapacity(self.count)
 
         for (key, value) in self {
             value.whenSuccess { expectation in
                 elements[key] = expectation
 
                 if elements.count == self.count {
-                    promise.succeed(result: elements)
+                    promise.succeed(elements)
                 }
             }
 
             value.whenFailure { error in
-                promise.fail(error: error)
+                promise.fail(error)
             }
         }
 
@@ -59,19 +59,19 @@ extension Future {
         to type: T.Type = T.self,
         _ callback: @escaping (Expectation) throws -> Future<T>
     ) -> Future<T> {
-        let promise = eventLoop.newPromise(of: T.self)
+        let promise = eventLoop.makePromise(of: T.self)
 
         self.whenSuccess { expectation in
             do {
                 let mapped = try callback(expectation)
-                mapped.cascade(promise: promise)
+                mapped.cascade(to: promise)
             } catch {
-                promise.fail(error: error)
+                promise.fail(error)
             }
         }
 
         self.whenFailure { error in
-            promise.fail(error: error)
+            promise.fail(error)
         }
 
         return promise.futureResult
@@ -85,6 +85,5 @@ public protocol FutureType {
 }
 
 extension Future : FutureType {
-    public typealias Expectation = T
-    
+    public typealias Expectation = Value
 }

Sources/GraphQL/Utilities/NIO+Extensions.swift

@@ -23,7 +23,7 @@ class FieldExecutionStrategyTests: XCTestCase {
                         }
 
                         group.wait()
-                        return eventLoopGroup.next().newSucceededFuture(result: "z")
+                        return eventLoopGroup.next().makeSucceededFuture("z")
                     }
                 ),
                 "bang": GraphQLField(
@@ -55,7 +55,7 @@ class FieldExecutionStrategyTests: XCTestCase {
 
                         g.wait()
 
-                        return eventLoopGroup.next().newFailedFuture(error: StrategyError.exampleError(
+                        return eventLoopGroup.next().makeFailedFuture(StrategyError.exampleError(
                             msg: "\(info.fieldName): \(info.path.elements.last!)"
                         ))
                     }