Updated to NIO 2

Author: kimdv

Sources/SwiftDataLoader/DataLoader.swift

@@ -38,19 +38,19 @@ final public class DataLoader<Key: Hashable, Value> {
             return cachedFuture
         }
 
-        let promise: EventLoopPromise<Value> = eventLoop.next().newPromise()
+        let promise: EventLoopPromise<Value> = eventLoop.next().makePromise()
 
         if options.batchingEnabled {
             queue.append((key: key, promise: promise))
         } else {
             _ = try batchLoadFunction([key]).map { results  in
                 if results.isEmpty {
-                    promise.fail(error: DataLoaderError.noValueForKey("Did not return value for key: \(key)"))
+                    promise.fail(DataLoaderError.noValueForKey("Did not return value for key: \(key)"))
                 } else {
                     let result = results[0]
                     switch result {
-                    case .success(let value): promise.succeed(result: value)
-                    case .failure(let error): promise.fail(error: error)
+                    case .success(let value): promise.succeed(value)
+                    case .failure(let error): promise.fail(error)
                     }
                 }
             }
@@ -66,9 +66,9 @@ final public class DataLoader<Key: Hashable, Value> {
     }
 
     public func loadMany(keys: [Key], on eventLoop: EventLoopGroup) throws -> EventLoopFuture<[Value]> {
-        guard !keys.isEmpty else { return eventLoop.next().newSucceededFuture(result: []) }
+        guard !keys.isEmpty else { return eventLoop.next().makeSucceededFuture([]) }
 
-        let promise: EventLoopPromise<[Value]> = eventLoop.next().newPromise()
+        let promise: EventLoopPromise<[Value]> = eventLoop.next().makePromise()
 
         var result = [Value]()
 
@@ -79,7 +79,7 @@ final public class DataLoader<Key: Hashable, Value> {
                 result.append(value)
 
                 if result.count == keys.count {
-                    promise.succeed(result: result)
+                    promise.succeed(result)
                 }
             }
         }
@@ -102,8 +102,8 @@ final public class DataLoader<Key: Hashable, Value> {
         let cacheKey = options.cacheKeyFunction?(key) ?? key
 
         if futureCache[cacheKey] == nil {
-            let promise: EventLoopPromise<Value> = eventLoop.next().newPromise()
-            promise.succeed(result: value)
+            let promise: EventLoopPromise<Value> = eventLoop.next().makePromise()
+            promise.succeed(value)
 
             futureCache[cacheKey] = promise.futureResult
         }
@@ -112,33 +112,33 @@ final public class DataLoader<Key: Hashable, Value> {
     }
 
     // MARK: - Private
-    private func dispatchQueueBatch(queue: LoaderQueue<Key, Value>, on eventLoop: EventLoopGroup) throws { //}-> EventLoopFuture<[Value]> {
+    private func dispatchQueueBatch(queue: LoaderQueue<Key, Value>, on eventLoop: EventLoopGroup) throws {
         let keys = queue.map { $0.key }
 
         if keys.isEmpty {
-            return //eventLoop.next().newSucceededFuture(result: [])
+            return
         }
 
         // Step through the values, resolving or rejecting each Promise in the
         // loaded queue.
             _ = try batchLoadFunction(keys)
-            .thenThrowing { values in
-                if values.count != keys.count {
-                    throw DataLoaderError.typeError("The function did not return an array of the same length as the array of keys. \nKeys count: \(keys.count)\nValues count: \(values.count)")
-                }
+                .flatMapThrowing { values in
+                    if values.count != keys.count {
+                        throw DataLoaderError.typeError("The function did not return an array of the same length as the array of keys. \nKeys count: \(keys.count)\nValues count: \(values.count)")
+                    }
 
-                for entry in queue.enumerated() {
-                    let result = values[entry.offset]
+                    for entry in queue.enumerated() {
+                        let result = values[entry.offset]
 
-                    switch result {
-                    case .failure(let error): entry.element.promise.fail(error: error)
-                    case .success(let value): entry.element.promise.succeed(result: value)
+                        switch result {
+                        case .failure(let error): entry.element.promise.fail(error)
+                        case .success(let value): entry.element.promise.succeed(value)
+                        }
                     }
                 }
-            }
-            .mapIfError{ error in
-                self.failedDispatch(queue: queue, error: error)
-            }
+                .recover { error in
+                    self.failedDispatch(queue: queue, error: error)
+        }
     }
 
     public func dispatchQueue(on eventLoop: EventLoopGroup) throws {
@@ -163,7 +163,7 @@ final public class DataLoader<Key: Hashable, Value> {
     private func failedDispatch(queue: LoaderQueue<Key, Value>, error: Error) {
         queue.forEach { (key, promise) in
             _ = clear(key: key)
-            promise.fail(error: error)
+            promise.fail(error)
         }
     }
 }

Tests/SwiftDataLoaderTests/DataLoaderAbuseTests.swift

@@ -20,7 +20,7 @@ class DataLoaderAbuseTests: XCTestCase {
         }
 
         let identityLoader = DataLoader<Int, Int>(options: DataLoaderOptions(batchingEnabled: false)) { keys in
-            eventLoopGroup.next().newSucceededFuture(result: [])
+            eventLoopGroup.next().makeSucceededFuture([])
         }
 
         let value = try identityLoader.load(key: 1, on: eventLoopGroup)
@@ -37,7 +37,7 @@ class DataLoaderAbuseTests: XCTestCase {
         }
 
         let identityLoader = DataLoader<Int, Int>(options: DataLoaderOptions()) { keys in
-            eventLoopGroup.next().newSucceededFuture(result: [])
+            eventLoopGroup.next().makeSucceededFuture([])
         }
 
         let value = try identityLoader.load(key: 1, on: eventLoopGroup)
@@ -64,7 +64,7 @@ class DataLoaderAbuseTests: XCTestCase {
                 }
             }
 
-            return eventLoopGroup.next().newSucceededFuture(result: results)
+            return eventLoopGroup.next().makeSucceededFuture(results)
         }
 
         let value1 = try identityLoader.load(key: 1, on: eventLoopGroup)
@@ -94,7 +94,7 @@ class DataLoaderAbuseTests: XCTestCase {
                 }
             }
 
-            return eventLoopGroup.next().newSucceededFuture(result: results)
+            return eventLoopGroup.next().makeSucceededFuture(results)
         }
 
         let value1 = try identityLoader.load(key: 1, on: eventLoopGroup)

Tests/SwiftDataLoaderTests/DataLoaderTests.swift

@@ -16,7 +16,7 @@ final class DataLoaderTests: XCTestCase {
         let identityLoader = DataLoader<Int, Int>(options: DataLoaderOptions(batchingEnabled: false)) { keys in
             let results = keys.map { DataLoaderFutureValue.success($0) }
 
-            return eventLoopGroup.next().newSucceededFuture(result: results)
+            return eventLoopGroup.next().makeSucceededFuture(results)
         }
 
         let value = try identityLoader.load(key: 1, on: eventLoopGroup)
@@ -36,7 +36,7 @@ final class DataLoaderTests: XCTestCase {
         let identityLoader = DataLoader<Int, Int>() { keys in
             let results = keys.map { DataLoaderFutureValue.success($0) }
 
-            return eventLoopGroup.next().newSucceededFuture(result: results)
+            return eventLoopGroup.next().makeSucceededFuture(results)
         }
 
         let values = try identityLoader.loadMany(keys: [1, 2], on: eventLoopGroup)
@@ -63,7 +63,7 @@ final class DataLoaderTests: XCTestCase {
             loadCalls.append(keys)
             let results = keys.map { DataLoaderFutureValue.success($0) }
 
-            return eventLoopGroup.next().newSucceededFuture(result: results)
+            return eventLoopGroup.next().makeSucceededFuture(results)
         }
 
         let value1 = try identityLoader.load(key: 1, on: eventLoopGroup)
@@ -90,7 +90,7 @@ final class DataLoaderTests: XCTestCase {
             loadCalls.append(keys)
             let results = keys.map { DataLoaderFutureValue.success($0) }
 
-            return eventLoopGroup.next().newSucceededFuture(result: results)
+            return eventLoopGroup.next().makeSucceededFuture(results)
         }
 
         let value1 = try identityLoader.load(key: 1, on: eventLoopGroup)
@@ -119,7 +119,7 @@ final class DataLoaderTests: XCTestCase {
             loadCalls.append(keys)
             let results = keys.map { DataLoaderFutureValue.success($0) }
 
-            return eventLoopGroup.next().newSucceededFuture(result: results)
+            return eventLoopGroup.next().makeSucceededFuture(results)
         }
 
         let value1 = try identityLoader.load(key: 1, on: eventLoopGroup)
@@ -146,7 +146,7 @@ final class DataLoaderTests: XCTestCase {
             loadCalls.append(keys)
             let results = keys.map { DataLoaderFutureValue.success($0) }
 
-            return eventLoopGroup.next().newSucceededFuture(result: results)
+            return eventLoopGroup.next().makeSucceededFuture(results)
         }
 
         let value1 = try identityLoader.load(key: "A", on: eventLoopGroup)
@@ -193,7 +193,7 @@ final class DataLoaderTests: XCTestCase {
             loadCalls.append(keys)
             let results = keys.map { DataLoaderFutureValue.success($0) }
 
-            return eventLoopGroup.next().newSucceededFuture(result: results)
+            return eventLoopGroup.next().makeSucceededFuture(results)
         }
 
         let value1 = try identityLoader.load(key: "A", on: eventLoopGroup)
@@ -230,7 +230,7 @@ final class DataLoaderTests: XCTestCase {
             loadCalls.append(keys)
             let results = keys.map { DataLoaderFutureValue.success($0) }
 
-            return eventLoopGroup.next().newSucceededFuture(result: results)
+            return eventLoopGroup.next().makeSucceededFuture(results)
         }
 
         let value1 = try identityLoader.load(key: "A", on: eventLoopGroup)
@@ -267,7 +267,7 @@ final class DataLoaderTests: XCTestCase {
             loadCalls.append(keys)
             let results = keys.map { DataLoaderFutureValue.success($0) }
 
-            return eventLoopGroup.next().newSucceededFuture(result: results)
+            return eventLoopGroup.next().makeSucceededFuture(results)
         }
 
         _ = identityLoader.prime(key: "A", value: "A", on: eventLoopGroup)
@@ -295,7 +295,7 @@ final class DataLoaderTests: XCTestCase {
             loadCalls.append(keys)
             let results = keys.map { DataLoaderFutureValue.success($0) }
 
-            return eventLoopGroup.next().newSucceededFuture(result: results)
+            return eventLoopGroup.next().makeSucceededFuture(results)
         }
 
         _ = identityLoader.prime(key: "A", value: "X", on: eventLoopGroup)
@@ -335,7 +335,7 @@ final class DataLoaderTests: XCTestCase {
             loadCalls.append(keys)
             let results = keys.map { DataLoaderFutureValue.success($0) }
 
-            return eventLoopGroup.next().newSucceededFuture(result: results)
+            return eventLoopGroup.next().makeSucceededFuture(results)
         }
 
         _ = identityLoader.prime(key: "A", value: "X", on: eventLoopGroup)