Add ValkeyClient.transaction

Signed-off-by: Adam Fowler <[email protected]>

Author: adam-fowler

Sources/Valkey/Connection/ValkeyConnection.swift

@@ -243,7 +243,10 @@ public final actor ValkeyConnection: ValkeyClientProtocol, Sendable {
         }
     }
 
-    /// Pipeline a series of commands to Valkey connection
+    /// Pipeline a series of commands as a transaction to Valkey connection
+    ///
+    /// Another client will never be served in the middle of the execution of these
+    /// commands. See https://valkey.io/topics/transactions/ for more information.
     ///
     /// Once all the responses for the commands have been received the function returns
     /// a parameter pack of Results, one for each command.
@@ -280,12 +283,15 @@ public final actor ValkeyConnection: ValkeyClientProtocol, Sendable {
         }.get()
     }
 
-    /// Pipeline a series of commands to Valkey connection
+    /// Pipeline a series of commands as a transaction to Valkey connection
+    ///
+    /// Another client will never be served in the middle of the execution of these
+    /// commands. See https://valkey.io/topics/transactions/ for more information.
     ///
     /// Once all the responses for the commands have been received the function returns
     /// an array of RESPToken Results, one for each command.
     ///
-    /// This is an alternative version of the pipelining function ``ValkeyConnection/execute(_:)->(_,_)``
+    /// This is an alternative version of the pipelining function ``ValkeyConnection/transaction(_:)->(_,_)``
     /// that allows for a collection of ValkeyCommands. It provides more flexibility but is
     /// slightly more expensive to run and the command responses are returned as ``RESPToken``
     /// instead of the response type for the command.

Sources/Valkey/Node/ValkeyNodeClient.swift

@@ -146,7 +146,7 @@ extension ValkeyNodeClient {
     /// - Parameter commands: Parameter pack of ValkeyCommands
     /// - Returns: Parameter pack holding the results of all the commands
     @inlinable
-    public func execute<each Command: ValkeyCommand>(
+    func execute<each Command: ValkeyCommand>(
         _ commands: repeat each Command
     ) async -> sending (repeat Result<(each Command).Response, Error>) {
         do {
@@ -171,7 +171,7 @@ extension ValkeyNodeClient {
     /// - Parameter commands: Collection of ValkeyCommands
     /// - Returns: Array holding the RESPToken responses of all the commands
     @inlinable
-    public func execute<Commands: Collection & Sendable>(
+    func execute<Commands: Collection & Sendable>(
         _ commands: Commands
     ) async -> sending [Result<RESPToken, Error>] where Commands.Element == any ValkeyCommand {
         do {
@@ -183,6 +183,49 @@ extension ValkeyNodeClient {
         }
     }
 
+    /// Pipeline a series of commands as a transaction to Valkey connection
+    ///
+    /// Another client will never be served in the middle of the execution of these
+    /// commands. See https://valkey.io/topics/transactions/ for more information.
+    ///
+    /// Once all the responses for the commands have been received the function returns
+    /// a parameter pack of Results, one for each command.
+    ///
+    /// - Parameter commands: Parameter pack of ValkeyCommands
+    /// - Returns: Parameter pack holding the responses of all the commands
+    @inlinable
+    func transaction<each Command: ValkeyCommand>(
+        _ commands: repeat each Command
+    ) async throws -> sending (repeat Result<(each Command).Response, Error>) {
+        try await self.withConnection { connection in
+            try await connection.transaction(repeat (each commands))
+        }
+    }
+
+    /// Pipeline a series of commands as a transaction to Valkey connection
+    ///
+    /// Another client will never be served in the middle of the execution of these
+    /// commands. See https://valkey.io/topics/transactions/ for more information.
+    ///
+    /// Once all the responses for the commands have been received the function returns
+    /// an array of RESPToken Results, one for each command.
+    ///
+    /// This is an alternative version of the pipelining function ``ValkeyNodeClient/transaction(_:)->(_,_)``
+    /// that allows for a collection of ValkeyCommands. It provides more flexibility but is
+    /// slightly more expensive to run and the command responses are returned as ``RESPToken``
+    /// instead of the response type for the command.
+    ///
+    /// - Parameter commands: Collection of ValkeyCommands
+    /// - Returns: Array holding the RESPToken responses of all the commands
+    @inlinable
+    func transaction<Commands: Collection & Sendable>(
+        _ commands: Commands
+    ) async throws -> sending [Result<RESPToken, Error>] where Commands.Element == any ValkeyCommand {
+        try await self.withConnection { connection in
+            try await connection.transaction(commands)
+        }
+    }
+
     /// Internal command used by cluster client, that precedes each command with a ASKING
     /// command
     func executeWithAsk<Commands: Collection & Sendable>(

Sources/Valkey/ValkeyClient.swift

@@ -217,6 +217,44 @@ extension ValkeyClient {
     ) async -> sending [Result<RESPToken, Error>] where Commands.Element == any ValkeyCommand {
         await node.execute(commands)
     }
+    /// Pipeline a series of commands as a transaction to Valkey connection
+    ///
+    /// Another client will never be served in the middle of the execution of these
+    /// commands. See https://valkey.io/topics/transactions/ for more information.
+    ///
+    /// Once all the responses for the commands have been received the function returns
+    /// a parameter pack of Results, one for each command.
+    ///
+    /// - Parameter commands: Parameter pack of ValkeyCommands
+    /// - Returns: Parameter pack holding the responses of all the commands
+    @inlinable
+    public func transaction<each Command: ValkeyCommand>(
+        _ commands: repeat each Command
+    ) async throws -> sending (repeat Result<(each Command).Response, Error>) {
+        try await node.transaction(repeat each commands)
+    }
+
+    /// Pipeline a series of commands as a transaction to Valkey connection
+    ///
+    /// Another client will never be served in the middle of the execution of these
+    /// commands. See https://valkey.io/topics/transactions/ for more information.
+    ///
+    /// Once all the responses for the commands have been received the function returns
+    /// an array of RESPToken Results, one for each command.
+    ///
+    /// This is an alternative version of the pipelining function ``ValkeyClient/transaction(_:)->(_,_)``
+    /// that allows for a collection of ValkeyCommands. It provides more flexibility but is
+    /// slightly more expensive to run and the command responses are returned as ``RESPToken``
+    /// instead of the response type for the command.
+    ///
+    /// - Parameter commands: Collection of ValkeyCommands
+    /// - Returns: Array holding the RESPToken responses of all the commands
+    @inlinable
+    public func transaction<Commands: Collection & Sendable>(
+        _ commands: Commands
+    ) async throws -> sending [Result<RESPToken, Error>] where Commands.Element == any ValkeyCommand {
+        try await node.transaction(commands)
+    }
 }
 
 #if ServiceLifecycleSupport

Tests/IntegrationTests/ClientIntegrationTests.swift

@@ -258,9 +258,9 @@ struct ClientIntegratedTests {
     func testTransactionSetIncrGet() async throws {
         var logger = Logger(label: "Valkey")
         logger.logLevel = .debug
-        try await withValkeyConnection(.hostname(valkeyHostname, port: 6379), logger: logger) { connection in
-            try await withKey(connection: connection) { key in
-                let responses = try await connection.transaction(
+        try await withValkeyClient(.hostname(valkeyHostname, port: 6379), logger: logger) { client in
+            try await withKey(connection: client) { key in
+                let responses = try await client.transaction(
                     SET(key, value: "100"),
                     INCR(key),
                     GET(key)
@@ -275,10 +275,10 @@ struct ClientIntegratedTests {
     func testInvalidTransactionSetIncrGet() async throws {
         var logger = Logger(label: "Valkey")
         logger.logLevel = .debug
-        try await withValkeyConnection(.hostname(valkeyHostname, port: 6379), logger: logger) { connection in
-            try await withKey(connection: connection) { key in
-                try await connection.set(key, value: "100")
-                let responses = try await connection.transaction(
+        try await withValkeyClient(.hostname(valkeyHostname, port: 6379), logger: logger) { client in
+            try await withKey(connection: client) { key in
+                try await client.set(key, value: "100")
+                let responses = try await client.transaction(
                     LPUSH(key, elements: ["Hello"]),
                     INCR(key),
                     GET(key)