DataLoader automatically executes based on timer

Author: NeedleInAJayStack

README.md

@@ -8,33 +8,31 @@ This is a Swift version of the Facebook [DataLoader](https://github.com/facebook
 
 ## Installation 💻
 
-Update your `Package.swift` file.
+Include this repo in your `Package.swift` file.
 
 ```swift
 .Package(url: "https://github.com/GraphQLSwift/DataLoader.git", .upToNextMajor(from: "1.1.0"))
 ```
 
 ## Gettings started 🚀
 ### Batching
-Batching is not an advanced feature, it's DataLoader's primary feature. 
+Batching is not an advanced feature, it's DataLoader's primary feature.
 
-Create a DataLoader by providing a batch loading function
+Create a DataLoader by providing a batch loading function:
 ```swift
 let userLoader = Dataloader<Int, User>(batchLoadFunction: { keys in
   try User.query(on: req).filter(\User.id ~~ keys).all().map { users in
     return users.map { DataLoaderFutureValue.success($0) }
   }
 })
 ```
-#### Load single key
+#### Load individual keys
 ```swift
 let future1 = try userLoader.load(key: 1, on: eventLoopGroup)
 let future2 = try userLoader.load(key: 2, on: eventLoopGroup)
 let future3 = try userLoader.load(key: 1, on: eventLoopGroup)
 ```
 
-Now there is only one thing left and that is to dispathc it `try userLoader.dispatchQueue(on: req.eventLoop)`
-
 The example above will only fetch two users, because the user with key `1` is present twice in the list. 
 
 #### Load multiple keys
@@ -43,18 +41,42 @@ There is also a method to load multiple keys at once
 try userLoader.loadMany(keys: [1, 2, 3], on: eventLoopGroup)
 ```
 
+#### Execution
+By default, a DataLoader will wait for a short time (2ms) from the moment `load` is called to collect keys prior
+to running the `batchLoadFunction` and completing the `load` futures. This is to let keys accumulate and 
+batch into a smaller number of total requests. This amount of time is configurable using the `executionPeriod` 
+option:
+
+```swift
+let myLoader =  DataLoader<String, String>(
+    options: DataLoaderOptions(executionPeriod: .milliseconds(50)),
+    batchLoadFunction: { keys in 
+        self.someBatchLoader(keys: keys).map { DataLoaderFutureValue.success($0) }
+    }
+)
+```
+
+Longer execution periods reduce the number of total data requests, but also reduce the responsiveness of the
+`load` futures.
+
+If desired, you can manually execute the `batchLoadFunction` and complete the futures at any time, using the 
+`.execute()` method.
+
+Scheduled execution can be disabled by setting `executionPeriod` to `nil`, but be careful - you *must* call `.execute()` 
+manually in this case. Otherwise, the futures will never complete.
+
 #### Disable batching
-It is possible to disable batching `DataLoaderOptions(batchingEnabled: false)`
-It will invoke `batchLoadFunction` immediately whenever any key is loaded
+It is possible to disable batching by setting the   `batchingEnabled` option to `false`
+It will invoke the `batchLoadFunction` immediately when a key is loaded.
+
 
 ### Caching
 
-DataLoader provides a memoization cache for all loads which occur in a single
-request to your application. After `.load()` is called once with a given key,
-the resulting value is cached to eliminate redundant loads.
+DataLoader provides a memoization cache. After `.load()` is called with a key, the resulting value is cached 
+for the lifetime of the DataLoader object. This eliminates redundant loads.
 
-In addition to relieving pressure on your data storage, caching results per-request
-also creates fewer objects which may relieve memory pressure on your application:
+In addition to relieving pressure on your data storage, caching results also creates fewer objects which may 
+relieve memory pressure on your application:
 
 ```swift
 let userLoader = DataLoader<Int, Int>(...)
@@ -164,16 +186,20 @@ let myLoader = DataLoader<String, String>(batchLoadFunction: { keys in
 
 ## Contributing 🤘
 
-All your feedback and help to improve this project is very welcome. Please create issues for your bugs, ideas and enhancement requests, or better yet, contribute directly by creating a PR. 😎
+All your feedback and help to improve this project is very welcome. Please create issues for your bugs, ideas and
+enhancement requests, or better yet, contribute directly by creating a PR. 😎
 
-When reporting an issue, please add a detailed instruction, and if possible a code snippet or test that can be used as a reproducer of your problem. 💥
+When reporting an issue, please add a detailed instruction, and if possible a code snippet or test that can be used
+as a reproducer of your problem. 💥
 
-When creating a pull request, please adhere to the current coding style where possible, and create tests with your code so it keeps providing an awesome test coverage level 💪
+When creating a pull request, please adhere to the current coding style where possible, and create tests with your
+code so it keeps providing an awesome test coverage level 💪
 
 ## Acknowledgements 👏
 
-This library is entirely a Swift version of Facebooks [DataLoader](https://github.com/facebook/dataloader). Developed by  [Lee Byron](https://github.com/leebyron) and
-[Nicholas Schrock](https://github.com/schrockn) from [Facebook](https://www.facebook.com/).
+This library is entirely a Swift version of Facebooks [DataLoader](https://github.com/facebook/dataloader). 
+Developed by  [Lee Byron](https://github.com/leebyron) and [Nicholas Schrock](https://github.com/schrockn) 
+from [Facebook](https://www.facebook.com/).
 
 [swift-badge]: https://img.shields.io/badge/Swift-5.2-orange.svg?style=flat
 [swift-url]: https://swift.org

Sources/DataLoader/DataLoader.swift

@@ -25,6 +25,7 @@ final public class DataLoader<Key: Hashable, Value> {
     private var cache = [Key: EventLoopFuture<Value>]()
     private var queue = LoaderQueue<Key, Value>()
 
+    private var dispatchScheduled = false
     private let lock = Lock()
 
     public init(options: DataLoaderOptions<Key, Value> = DataLoaderOptions(), batchLoadFunction: @escaping BatchLoadFunction<Key, Value>) {
@@ -45,6 +46,12 @@ final public class DataLoader<Key: Hashable, Value> {
 
             if options.batchingEnabled {
                 queue.append((key: key, promise: promise))
+                if let executionPeriod = options.executionPeriod, !dispatchScheduled {
+                    eventLoopGroup.next().scheduleTask(in: executionPeriod) {
+                        try self.execute()
+                    }
+                    dispatchScheduled = true
+                }
             } else {
                 _ = try batchLoadFunction([key]).map { results  in
                     if results.isEmpty {
@@ -149,12 +156,22 @@ final public class DataLoader<Key: Hashable, Value> {
 
     /// Executes the queue of keys, completing the `EventLoopFutures`.
     ///
-    /// The client must run this manually to compete the `EventLoopFutures` of the keys.
+    /// If `executionPeriod` was provided in the options, this method is run automatically
+    /// after the specified time period. If `executionPeriod` was nil, the client must
+    /// run this manually to compete the `EventLoopFutures` of the keys.
     public func execute() throws {
+        // Take the current loader queue, replacing it with an empty queue.
         var batch = LoaderQueue<Key, Value>()
         lock.withLockVoid {
             batch = self.queue
             self.queue = []
+            if dispatchScheduled {
+                dispatchScheduled = false
+            }
+        }
+        
+        guard batch.count > 0 else {
+            return ()
         }
 
         // If a maxBatchSize was provided and the queue is longer, then segment the
@@ -194,11 +211,11 @@ final public class DataLoader<Key: Hashable, Value> {
                 }
             }
         }.recover { error in
-            self.failedDispatch(batch: batch, error: error)
+            self.failedExecution(batch: batch, error: error)
         }
     }
 
-    private func failedDispatch(batch: LoaderQueue<Key, Value>, error: Error) {
+    private func failedExecution(batch: LoaderQueue<Key, Value>, error: Error) {
         for (key, promise) in batch {
             _ = clear(key: key)
             promise.fail(error)

Sources/DataLoader/DataLoaderOptions.swift

@@ -1,3 +1,5 @@
+import NIO
+
 public struct DataLoaderOptions<Key: Hashable, Value> {
     /// Default `true`. Set to `false` to disable batching, invoking
     /// `batchLoadFunction` with a single load key. This is
@@ -13,16 +15,26 @@ public struct DataLoaderOptions<Key: Hashable, Value> {
     /// for every load of the same key.
     public let cachingEnabled: Bool
 
+    /// Default `2ms`. Defines the period of time that the DataLoader should
+    /// wait and collect its queue before executing. Faster times result
+    /// in smaller batches quicker resolution, slower times result in larger
+    /// batches but slower resolution.
+    /// This is irrelevant if batching is disabled.
+    public let executionPeriod: TimeAmount?
+    
     /// Default `nil`. Produces cache key for a given load key. Useful
     /// when objects are keys and two objects should be considered equivalent.
     public let cacheKeyFunction: ((Key) -> Key)?
 
     public init(batchingEnabled: Bool = true,
                 cachingEnabled: Bool = true,
                 maxBatchSize: Int? = nil,
-                cacheKeyFunction: ((Key) -> Key)? = nil) {
+                executionPeriod: TimeAmount? = .milliseconds(2),
+                cacheKeyFunction: ((Key) -> Key)? = nil
+    ) {
         self.batchingEnabled = batchingEnabled
         self.cachingEnabled = cachingEnabled
+        self.executionPeriod = executionPeriod
         self.maxBatchSize = maxBatchSize
         self.cacheKeyFunction = cacheKeyFunction
     }

Tests/DataLoaderTests/DataLoaderAbuseTests.swift

@@ -12,14 +12,14 @@ class DataLoaderAbuseTests: XCTestCase {
             XCTAssertNoThrow(try eventLoopGroup.syncShutdownGracefully())
         }
 
-        let identityLoader = DataLoader<Int, Int>(options: DataLoaderOptions(batchingEnabled: false)) { keys in
+        let identityLoader = DataLoader<Int, Int>(
+            options: DataLoaderOptions(batchingEnabled: false)
+        ) { keys in
             eventLoopGroup.next().makeSucceededFuture([])
         }
 
         let value = try identityLoader.load(key: 1, on: eventLoopGroup)
 
-        XCTAssertNoThrow(try identityLoader.execute())
-
         XCTAssertThrowsError(try value.wait(), "Did not return value for key: 1")
     }
 
@@ -29,14 +29,12 @@ class DataLoaderAbuseTests: XCTestCase {
             XCTAssertNoThrow(try eventLoopGroup.syncShutdownGracefully())
         }
 
-        let identityLoader = DataLoader<Int, Int>(options: DataLoaderOptions()) { keys in
+        let identityLoader = DataLoader<Int, Int>() { keys in
             eventLoopGroup.next().makeSucceededFuture([])
         }
 
         let value = try identityLoader.load(key: 1, on: eventLoopGroup)
 
-        XCTAssertNoThrow(try identityLoader.execute())
-
         XCTAssertThrowsError(try value.wait(), "The function did not return an array of the same length as the array of keys. \nKeys count: 1\nValues count: 0")
     }
 
@@ -46,7 +44,7 @@ class DataLoaderAbuseTests: XCTestCase {
             XCTAssertNoThrow(try eventLoopGroup.syncShutdownGracefully())
         }
 
-        let identityLoader = DataLoader<Int, Int>(options: DataLoaderOptions()) { keys in
+        let identityLoader = DataLoader<Int, Int>() { keys in
             var results = [DataLoaderFutureValue<Int>]()
 
             for key in keys {
@@ -63,8 +61,6 @@ class DataLoaderAbuseTests: XCTestCase {
         let value1 = try identityLoader.load(key: 1, on: eventLoopGroup)
         let value2 = try identityLoader.load(key: 2, on: eventLoopGroup)
 
-        XCTAssertNoThrow(try identityLoader.execute())
-
         XCTAssertThrowsError(try value2.wait())
 
         XCTAssertTrue(try value1.wait() == 1)
@@ -76,7 +72,9 @@ class DataLoaderAbuseTests: XCTestCase {
             XCTAssertNoThrow(try eventLoopGroup.syncShutdownGracefully())
         }
 
-        let identityLoader = DataLoader<Int, Int>(options: DataLoaderOptions(batchingEnabled: false)) { keys in
+        let identityLoader = DataLoader<Int, Int>(
+            options: DataLoaderOptions(batchingEnabled: false)
+        ) { keys in
             var results = [DataLoaderFutureValue<Int>]()
 
             for key in keys {
@@ -93,8 +91,6 @@ class DataLoaderAbuseTests: XCTestCase {
         let value1 = try identityLoader.load(key: 1, on: eventLoopGroup)
         let value2 = try identityLoader.load(key: 2, on: eventLoopGroup)
 
-        XCTAssertNoThrow(try identityLoader.execute())
-
         XCTAssertThrowsError(try value2.wait())
 
         XCTAssertTrue(try value1.wait() == 1)