Upgrade to RediStack 2.0

Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version:5.2
+// swift-tools-version:5.5
 import PackageDescription
 
 let package = Package(
@@ -10,7 +10,7 @@ let package = Package(
         .library(name: "Redis", targets: ["Redis"])
     ],
     dependencies: [
-        .package(url: "https://gitlab.com/mordil/RediStack.git", from: "1.1.0"),
+        .package(url: "https://gitlab.com/mordil/RediStack.git", .revisionItem("0465b34ef3f45c45d751100ef572c1afb4b1b50c")),
         .package(url: "https://github.com/vapor/vapor.git", from: "4.50.0"),
     ],
     targets: [

Sources/Redis/Application+Redis.swift

@@ -21,59 +21,66 @@ extension Application {
 
 // MARK: RedisClient
 extension Application.Redis: RedisClient {
-    public var eventLoop: EventLoop {
-        self.application.eventLoopGroup.next()
-    }
+    public var eventLoop: EventLoop { self.application.eventLoopGroup.next() }
+    public var defaultLogger: Logger? { self.application.logger }
 
     public func logging(to logger: Logger) -> RedisClient {
         self.application.redis(self.id)
             .pool(for: self.eventLoop)
             .logging(to: logger)
     }
 
-    public func send(command: String, with arguments: [RESPValue]) -> EventLoopFuture<RESPValue> {
+    public func send<CommandResult>(
+        _ command: RedisCommand<CommandResult>,
+        eventLoop: EventLoop? = nil,
+        logger: Logger? = nil
+    ) -> EventLoopFuture<CommandResult> {
         self.application.redis(self.id)
             .pool(for: self.eventLoop)
             .logging(to: self.application.logger)
-            .send(command: command, with: arguments)
+            .send(command, eventLoop: eventLoop, logger: logger)
     }
 
     public func subscribe(
         to channels: [RedisChannelName],
+        eventLoop: EventLoop? = nil,
+        logger: Logger? = nil,
         messageReceiver receiver: @escaping RedisSubscriptionMessageReceiver,
-        onSubscribe subscribeHandler: RedisSubscriptionChangeHandler?,
-        onUnsubscribe unsubscribeHandler: RedisSubscriptionChangeHandler?
+        onSubscribe subscribeHandler: RedisSubscribeHandler?,
+        onUnsubscribe unsubscribeHandler: RedisUnsubscribeHandler?
     ) -> EventLoopFuture<Void> {
         self.application.redis(self.id)
             .pubsubClient
             .logging(to: self.application.logger)
-            .subscribe(to: channels, messageReceiver: receiver, onSubscribe: subscribeHandler, onUnsubscribe: unsubscribeHandler)
+            .subscribe(to: channels, eventLoop: eventLoop, logger: logger, messageReceiver: receiver, onSubscribe: subscribeHandler, onUnsubscribe: unsubscribeHandler)
     }
 
-    public func unsubscribe(from channels: [RedisChannelName]) -> EventLoopFuture<Void> {
+    public func unsubscribe(from channels: [RedisChannelName], eventLoop: EventLoop? = nil, logger: Logger? = nil) -> EventLoopFuture<Void> {
         self.application.redis(self.id)
             .pubsubClient
             .logging(to: self.application.logger)
-            .unsubscribe(from: channels)
+            .unsubscribe(from: channels, eventLoop: eventLoop, logger: logger)
     }
 
     public func psubscribe(
         to patterns: [String],
+        eventLoop: EventLoop? = nil,
+        logger: Logger? = nil,
         messageReceiver receiver: @escaping RedisSubscriptionMessageReceiver,
-        onSubscribe subscribeHandler: RedisSubscriptionChangeHandler?,
-        onUnsubscribe unsubscribeHandler: RedisSubscriptionChangeHandler?
+        onSubscribe subscribeHandler: RedisSubscribeHandler?,
+        onUnsubscribe unsubscribeHandler: RedisUnsubscribeHandler?
     ) -> EventLoopFuture<Void> {
         self.application.redis(self.id)
             .pubsubClient
             .logging(to: self.application.logger)
-            .psubscribe(to: patterns, messageReceiver: receiver, onSubscribe: subscribeHandler, onUnsubscribe: unsubscribeHandler)
+            .psubscribe(to: patterns, eventLoop: eventLoop, logger: logger, messageReceiver: receiver, onSubscribe: subscribeHandler, onUnsubscribe: unsubscribeHandler)
     }
 
-    public func punsubscribe(from patterns: [String]) -> EventLoopFuture<Void> {
+    public func punsubscribe(from patterns: [String], eventLoop: EventLoop? = nil, logger: Logger? = nil) -> EventLoopFuture<Void> {
         self.application.redis(self.id)
             .pubsubClient
             .logging(to: self.application.logger)
-            .punsubscribe(from: patterns)
+            .punsubscribe(from: patterns, eventLoop: eventLoop, logger: logger)
     }
 }
 

Sources/Redis/Redis+Cache.swift

@@ -82,7 +82,7 @@ private struct RedisCache<CacheEncoder: RedisCacheEncoder, CacheDecoder: RedisCa
             .tryFuture { try self.encoder.encode(value) }
             .flatMap {
                 if let expirationTime = expirationTime {
-                    return self.client.setex(RedisKey(key), to: $0, expirationInSeconds: expirationTime.seconds)
+                    return self.client.send(.setex(RedisKey(key), to: $0, expirationInSeconds: expirationTime.seconds), eventLoop: nil, logger: nil)
                 } else {
                     return self.client.set(RedisKey(key), to: $0)
                 }

Sources/Redis/Redis+Concurrency.swift

@@ -1,55 +1,64 @@
-#if compiler(>=5.5) && canImport(_Concurrency)
+#if canImport(_Concurrency)
 import NIOCore
 import Vapor
 
 @available(macOS 12, iOS 15, watchOS 8, tvOS 15, *)
 extension Application.Redis {
-    public func send(command: String, with arguments: [RESPValue]) async throws -> RESPValue {
+    public func send<CommandResult>(
+        _ command: RedisCommand<CommandResult>,
+        eventLoop: EventLoop? = nil,
+        logger: Logger? = nil
+    ) async throws -> CommandResult {
         try await self.application.redis(self.id)
             .pool(for: self.eventLoop)
             .logging(to: self.application.logger)
-            .send(command: command, with: arguments).get()
+            .send(command, eventLoop: eventLoop, logger: logger)
+            .get()
     }
 
     public func subscribe(
         to channels: [RedisChannelName],
+        eventLoop: EventLoop? = nil,
+        logger: Logger? = nil,
         messageReceiver receiver: @escaping RedisSubscriptionMessageReceiver,
-        onSubscribe subscribeHandler: RedisSubscriptionChangeHandler?,
-        onUnsubscribe unsubscribeHandler: RedisSubscriptionChangeHandler?
+        onSubscribe subscribeHandler: RedisSubscribeHandler?,
+        onUnsubscribe unsubscribeHandler: RedisUnsubscribeHandler?
     ) async throws {
         try await self.application.redis(self.id)
             .pubsubClient
             .logging(to: self.application.logger)
-            .subscribe(to: channels, messageReceiver: receiver, onSubscribe: subscribeHandler, onUnsubscribe: unsubscribeHandler)
+            .subscribe(to: channels, eventLoop: eventLoop, logger: logger, messageReceiver: receiver, onSubscribe: subscribeHandler, onUnsubscribe: unsubscribeHandler)
             .get()
     }
 
-    public func unsubscribe(from channels: [RedisChannelName]) async throws {
+    public func unsubscribe(from channels: [RedisChannelName], eventLoop: EventLoop?, logger: Logger?) async throws {
         try await self.application.redis(self.id)
             .pubsubClient
             .logging(to: self.application.logger)
-            .unsubscribe(from: channels)
+            .unsubscribe(from: channels, eventLoop: eventLoop, logger: logger)
             .get()
     }
 
     public func psubscribe(
         to patterns: [String],
+        eventLoop: EventLoop? = nil,
+        logger: Logger? = nil,
         messageReceiver receiver: @escaping RedisSubscriptionMessageReceiver,
-        onSubscribe subscribeHandler: RedisSubscriptionChangeHandler?,
-        onUnsubscribe unsubscribeHandler: RedisSubscriptionChangeHandler?
+        onSubscribe subscribeHandler: RedisSubscribeHandler?,
+        onUnsubscribe unsubscribeHandler: RedisUnsubscribeHandler?
     ) async throws {
         try await self.application.redis(self.id)
             .pubsubClient
             .logging(to: self.application.logger)
-            .psubscribe(to: patterns, messageReceiver: receiver, onSubscribe: subscribeHandler, onUnsubscribe: unsubscribeHandler)
+            .psubscribe(to: patterns, eventLoop: eventLoop, logger: logger, messageReceiver: receiver, onSubscribe: subscribeHandler, onUnsubscribe: unsubscribeHandler)
             .get()
     }
 
-    public func punsubscribe(from patterns: [String]) async throws {
+    public func punsubscribe(from patterns: [String], eventLoop: EventLoop? = nil, logger: Logger? = nil) async throws {
         try await self.application.redis(self.id)
             .pubsubClient
             .logging(to: self.application.logger)
-            .punsubscribe(from: patterns)
+            .punsubscribe(from: patterns, eventLoop: eventLoop, logger: logger)
             .get()
     }
 }
@@ -75,62 +84,69 @@ extension RedisClient {
     public func setex<E>(_ key: RedisKey, toJSON entity: E, expirationInSeconds expiration: Int) async throws
         where E: Encodable
     {
-        try await self.setex(key, to: JSONEncoder().encode(entity), expirationInSeconds: expiration).get()
+        try await self.send(.setex(key, to: JSONEncoder().encode(entity), expirationInSeconds: expiration), eventLoop: nil, logger: nil).get()
     }
 }
 
 @available(macOS 12, iOS 15, watchOS 8, tvOS 15, *)
 extension Request.Redis {
-    public func send(command: String, with arguments: [RESPValue]) async throws -> RESPValue {
+    public func send<CommandResult>(
+        _ command: RedisCommand<CommandResult>,
+        eventLoop: EventLoop? = nil,
+        logger: Logger? = nil
+    ) async throws -> CommandResult {
         try await self.request.application.redis(self.id)
             .pool(for: self.eventLoop)
             .logging(to: self.request.logger)
-            .send(command: command, with: arguments)
+            .send(command, eventLoop: eventLoop, logger: logger)
             .get()
     }
 
     public func subscribe(
         to channels: [RedisChannelName],
+        eventLoop: EventLoop? = nil,
+        logger: Logger? = nil,
         messageReceiver receiver: @escaping RedisSubscriptionMessageReceiver,
-        onSubscribe subscribeHandler: RedisSubscriptionChangeHandler?,
-        onUnsubscribe unsubscribeHandler: RedisSubscriptionChangeHandler?
+        onSubscribe subscribeHandler: RedisSubscribeHandler?,
+        onUnsubscribe unsubscribeHandler: RedisUnsubscribeHandler?
     ) async throws {
         try await self.request.application.redis(self.id)
             .pubsubClient
             .logging(to: self.request.logger)
-            .subscribe(to: channels, messageReceiver: receiver, onSubscribe: subscribeHandler, onUnsubscribe: unsubscribeHandler)
+            .subscribe(to: channels, eventLoop: eventLoop, logger: logger, messageReceiver: receiver, onSubscribe: subscribeHandler, onUnsubscribe: unsubscribeHandler)
             .get()
     }
 
-    public func unsubscribe(from channels: [RedisChannelName]) async throws {
+    public func unsubscribe(from channels: [RedisChannelName], eventLoop: EventLoop? = nil, logger: Logger? = nil) async throws {
         try await self.request.application.redis(self.id)
             .pubsubClient
             .logging(to: self.request.logger)
-            .unsubscribe(from: channels)
+            .unsubscribe(from: channels, eventLoop: eventLoop, logger: logger)
             .get()
     }
 
     public func psubscribe(
         to patterns: [String],
+        eventLoop: EventLoop? = nil,
+        logger: Logger? = nil,
         messageReceiver receiver: @escaping RedisSubscriptionMessageReceiver,
-        onSubscribe subscribeHandler: RedisSubscriptionChangeHandler?,
-        onUnsubscribe unsubscribeHandler: RedisSubscriptionChangeHandler?
+        onSubscribe subscribeHandler: RedisSubscribeHandler?,
+        onUnsubscribe unsubscribeHandler: RedisUnsubscribeHandler?
     ) async throws {
         try await self.request.application.redis(self.id)
             .pubsubClient
             .logging(to: self.request.logger)
-            .psubscribe(to: patterns, messageReceiver: receiver, onSubscribe: subscribeHandler, onUnsubscribe: unsubscribeHandler)
+            .psubscribe(to: patterns, eventLoop: eventLoop, logger: logger, messageReceiver: receiver, onSubscribe: subscribeHandler, onUnsubscribe: unsubscribeHandler)
             .get()
     }
 
-    public func punsubscribe(from patterns: [String]) async throws {
+    public func punsubscribe(from patterns: [String], eventLoop: EventLoop? = nil, logger: Logger? = nil) async throws {
         try await self.request.application.redis(self.id)
             .pubsubClient
             .logging(to: self.request.logger)
-            .punsubscribe(from: patterns)
+            .punsubscribe(from: patterns, eventLoop: eventLoop, logger: logger)
             .get()
     }
 }
 
-
 #endif