Standard return types and errors for hrandfield

Signed-off-by: Nilanshu Sharma <[email protected]>

Author: Nilanshu Sharma

Sources/Valkey/Commands/Custom/HashCustomCommands.swift

@@ -66,3 +66,150 @@ extension HSCAN {
         }
     }
 }
+
+extension HRANDFIELD {
+    /// Custom response type for HRANDFIELD command that handles all possible return scenarios
+    @_documentation(visibility: internal)
+    public struct Response: RESPTokenDecodable, Sendable {
+        /// The raw RESP token containing the response
+        public let token: RESPToken
+
+        @inlinable
+        public init(fromRESP token: RESPToken) throws {
+            self.token = token
+        }
+
+        /// Get single random field when HRANDFIELD was called without COUNT
+        /// - Returns: Random field name as ByteBuffer, or nil if key doesn't exist
+        /// - Throws: RESPDecodeError if response format is unexpected
+        @inlinable
+        public func singleField() throws -> ByteBuffer? {
+            switch token.value {
+            case .null:
+                return nil
+            case .bulkString(let buffer):
+                return buffer
+            default:
+                throw RESPDecodeError.tokenMismatch(expected: [.null, .bulkString], token: token)
+            }
+        }
+
+        /// Get multiple random fields when HRANDFIELD was called with COUNT but without WITHVALUES
+        /// - Returns: Array of field names as ByteBuffer, or empty array if key doesn't exist
+        /// - Throws: RESPDecodeError if response format is unexpected
+        @inlinable
+        public func multipleFields() throws -> [ByteBuffer] {
+            switch token.value {
+            case .null:
+                return []
+            case .array(let array):
+                return try array.decode(as: [ByteBuffer].self)
+            default:
+                throw RESPDecodeError.tokenMismatch(expected: [.null, .array], token: token)
+            }
+        }
+
+        /// Get multiple random field-value pairs when HRANDFIELD was called with COUNT and WITHVALUES
+        /// - Returns: Array of HashEntry (field-value pairs), or empty array if key doesn't exist
+        /// - Throws: RESPDecodeError if response format is unexpected
+        public func multipleFieldsWithValues() throws -> [HashEntry] {
+            switch token.value {
+            case .null:
+                return []
+            case .array(let array):
+                return try _decodeArrayAsHashEntries(array)
+            case .map(let map):
+                return try _decodeMapAsHashEntries(map)
+            default:
+                throw RESPDecodeError.tokenMismatch(expected: [.null, .array, .map], token: token)
+            }
+        }
+
+        /// Helper method to decode RESP array as hash entries
+        /// - Parameter array: RESP array to decode
+        /// - Returns: Array of HashEntry objects
+        /// - Throws: RESPDecodeError if format is invalid
+        internal func _decodeArrayAsHashEntries(_ array: RESPToken.Array) throws -> [HashEntry] {
+            // Convert to Swift array for easier access
+            let elements = Array(array)
+
+            guard !elements.isEmpty else {
+                return []
+            }
+
+            switch elements[0].value {
+            case .array:
+                // Format: [[field1, value1], [field2, value2], ...]
+                return try _decodeNestedArrayFormat(elements)
+            default:
+                // Format: [field1, value1, field2, value2, ...] (flat array)
+                return try _decodeFlatArrayFormat(elements)
+            }
+        }
+
+        /// Helper method to decode nested array format
+        /// - Parameter elements: Swift array of RESP tokens containing nested arrays
+        /// - Returns: Array of HashEntry objects
+        /// - Throws: RESPDecodeError if format is invalid
+        internal func _decodeNestedArrayFormat(_ elements: [RESPToken]) throws -> [HashEntry] {
+            var entries: [HashEntry] = []
+            entries.reserveCapacity(elements.count)
+
+            for element in elements {
+                guard case .array(let pairArray) = element.value else {
+                    throw RESPDecodeError.tokenMismatch(expected: [.array], token: element)
+                }
+
+                let pairElements = Array(pairArray)
+                guard pairElements.count == 2 else {
+                    throw RESPDecodeError(.invalidArraySize, token: element)
+                }
+
+                let field = try ByteBuffer(fromRESP: pairElements[0])
+                let value = try ByteBuffer(fromRESP: pairElements[1])
+                entries.append(HashEntry(field: field, value: value))
+            }
+
+            return entries
+        }
+
+        /// Helper method to decode flat array format
+        /// - Parameter elements: Swift array of RESP tokens containing alternating field-value pairs
+        /// - Returns: Array of HashEntry objects
+        /// - Throws: RESPDecodeError if format is invalid
+        internal func _decodeFlatArrayFormat(_ elements: [RESPToken]) throws -> [HashEntry] {
+            guard elements.count % 2 == 0 else {
+                throw RESPDecodeError(.invalidArraySize, token: token)
+            }
+
+            var entries: [HashEntry] = []
+            entries.reserveCapacity(elements.count / 2)
+
+            for i in stride(from: 0, to: elements.count, by: 2) {
+                let field = try ByteBuffer(fromRESP: elements[i])
+                let value = try ByteBuffer(fromRESP: elements[i + 1])
+                entries.append(HashEntry(field: field, value: value))
+            }
+
+            return entries
+        }
+
+        /// Helper method to decode RESP map as hash entries
+        /// - Parameter map: RESP map to decode
+        /// - Returns: Array of HashEntry objects
+        /// - Throws: RESPDecodeError if format is invalid
+        internal func _decodeMapAsHashEntries(_ map: RESPToken.Map) throws -> [HashEntry] {
+            var entries: [HashEntry] = []
+            entries.reserveCapacity(map.count)
+
+            for pair in map {
+                let field = try ByteBuffer(fromRESP: pair.key)
+                let value = try ByteBuffer(fromRESP: pair.value)
+                entries.append(HashEntry(field: field, value: value))
+            }
+
+            return entries
+        }
+
+    }
+}

Sources/Valkey/Commands/HashCommands.swift

@@ -807,7 +807,6 @@ public struct HRANDFIELD: ValkeyCommand {
             RESPPureToken("WITHVALUES", withvalues).encode(into: &commandEncoder)
         }
     }
-    public typealias Response = RESPToken?
 
     @inlinable public static var name: String { "HRANDFIELD" }
 
@@ -1397,7 +1396,7 @@ extension ValkeyClientProtocol {
     ///     * [Array]: A list of fields. Returned in case `COUNT` was used.
     ///     * [Array]: Fields and their values. Returned in case `COUNT` and `WITHVALUES` were used. In RESP2 this is returned as a flat array.
     @inlinable
-    public func hrandfield(_ key: ValkeyKey, options: HRANDFIELD.Options? = nil) async throws -> RESPToken? {
+    public func hrandfield(_ key: ValkeyKey, options: HRANDFIELD.Options? = nil) async throws -> HRANDFIELD.Response {
         try await execute(HRANDFIELD(key, options: options))
     }
 

Sources/ValkeyConnectionPool/ConnectionPool.swift

@@ -593,6 +593,7 @@ extension DiscardingTaskGroup: TaskGroupProtocol {
     }
 }
 
+@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
 extension TaskGroup<Void>: TaskGroupProtocol {
     @inlinable
     mutating func addTask_(operation: @escaping @Sendable () async -> Void) {

Sources/ValkeyConnectionPool/ConnectionRequest.swift

@@ -1,3 +1,4 @@
+@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
 public struct ConnectionRequest<Connection: PooledConnection>: ConnectionRequestProtocol {
     public typealias ID = Int
 

Tests/IntegrationTests/ClientIntegrationTests.swift

@@ -627,4 +627,150 @@ struct ClientIntegratedTests {
         }
     }
 
+    @Test
+    @available(valkeySwift 1.0, *)
+    func testHrandfieldSingleField() 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
+                // Set up test hash with known fields
+                _ = try await connection.hset(key, data: [
+                    HSET.Data(field: "field1", value: "value1"),
+                    HSET.Data(field: "field2", value: "value2"),
+                    HSET.Data(field: "field3", value: "value3")
+                ])
+
+                // Test HRANDFIELD without options (should return single field)
+                let response = try await connection.hrandfield(key)
+
+                let singleField = try response.singleField()
+                #expect(singleField != nil)
+
+                let fieldName = String(buffer: singleField!)
+                #expect(["field1", "field2", "field3"].contains(fieldName))
+            }
+        }
+    }
+
+    @Test
+    @available(valkeySwift 1.0, *)
+    func testHrandfieldMultipleFields() 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
+                // Set up test hash with known fields
+                _ = try await connection.hset(key, data: [
+                    HSET.Data(field: "field1", value: "value1"),
+                    HSET.Data(field: "field2", value: "value2"),
+                    HSET.Data(field: "field3", value: "value3"),
+                    HSET.Data(field: "field4", value: "value4")
+                ])
+
+                // Test HRANDFIELD with COUNT option (no WITHVALUES)
+                let options = HRANDFIELD.Options(count: 2, withvalues: false)
+                let response = try await connection.hrandfield(key, options: options)
+
+                let multipleFields = try response.multipleFields()
+                #expect(multipleFields.count == 2)
+
+                let fieldNames = multipleFields.map { String(buffer: $0) }
+                for fieldName in fieldNames {
+                    #expect(["field1", "field2", "field3", "field4"].contains(fieldName))
+                }
+
+                // Ensure we got unique fields
+                let uniqueFieldNames = Set(fieldNames)
+                #expect(uniqueFieldNames.count == fieldNames.count)
+            }
+        }
+    }
+
+    @Test
+    @available(valkeySwift 1.0, *)
+    func testHrandfieldMultipleFieldsWithValues() 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
+                // Set up test hash with known field-value pairs
+                let testData = [
+                    ("field1", "value1"),
+                    ("field2", "value2"),
+                    ("field3", "value3"),
+                    ("field4", "value4")
+                ]
+
+                _ = try await connection.hset(key, data: testData.map {
+                    HSET.Data(field: $0.0, value: $0.1)
+                })
+
+                // Test HRANDFIELD with COUNT and WITHVALUES options
+                let options = HRANDFIELD.Options(count: 3, withvalues: true)
+                let response = try await connection.hrandfield(key, options: options)
+
+                let fieldValuePairs = try response.multipleFieldsWithValues()
+                #expect(fieldValuePairs.count == 3)
+
+                let expectedPairs = Dictionary(testData, uniquingKeysWith: { first, _ in first })
+
+                for entry in fieldValuePairs {
+                    let fieldName = String(buffer: entry.field)
+                    let fieldValue = String(buffer: entry.value)
+
+                    #expect(expectedPairs[fieldName] == fieldValue)
+                }
+            }
+        }
+    }
+
+    @Test
+    @available(valkeySwift 1.0, *)
+    func testHrandfieldNonExistentKey() 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
+                // Test HRANDFIELD on non-existent key
+                let response = try await connection.hrandfield(key)
+
+                let singleField = try response.singleField()
+                #expect(singleField == nil)
+
+                let multipleFields = try response.multipleFields()
+                #expect(multipleFields.isEmpty)
+
+                let fieldValuePairs = try response.multipleFieldsWithValues()
+                #expect(fieldValuePairs.isEmpty)
+            }
+        }
+    }
+
+    @Test
+    @available(valkeySwift 1.0, *)
+    func testHrandfieldErrorHandling() 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
+                // Set up test hash
+                _ = try await connection.hset(key, data: [
+                    HSET.Data(field: "field1", value: "value1")
+                ])
+
+                let response = try await connection.hrandfield(key)
+
+                // Test calling wrong method for response type should throw
+                #expect(throws: RESPDecodeError.self) {
+                    _ = try response.multipleFields() // Should throw since this is a single field response
+                }
+
+                #expect(throws: RESPDecodeError.self) {
+                    _ = try response.multipleFieldsWithValues() // Should throw since this is a single field response
+                }
+            }
+        }
+    }
+
 }