Standard return types and errors for hrandfield (#262)

* Standard return types and errors for hrandfield

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

* Consolidating tests and other minor fixes

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

* Fixing test format check

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

* Addressing PR comments

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

* Fixing format soundness

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

* Fixing tests

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

---------

Signed-off-by: Nilanshu Sharma <[email protected]>
Co-authored-by: Nilanshu Sharma <[email protected]>
Co-authored-by: Adam Fowler <[email protected]>

Author: 3 people

Sources/Valkey/Commands/Custom/HashCustomCommands.swift

@@ -66,3 +66,87 @@ extension HSCAN {
         }
     }
 }
+
+extension HRANDFIELD {
+    /// Custom response type for HRANDFIELD command that handles all possible return scenarios
+    public struct Response: RESPTokenDecodable, Sendable {
+        /// The raw RESP token containing the response
+        public let token: RESPToken
+
+        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
+        public func singleField() throws -> ByteBuffer? {
+            // Handle .null as it is expected when the key doesn't exist
+            if token.value == .null {
+                return nil
+            }
+            return try ByteBuffer(fromRESP: 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]? {
+            try [ByteBuffer]?(fromRESP: token)
+        }
+
+        /// Get multiple random field-value pairs when HRANDFIELD was called with COUNT and WITHVALUES
+        /// - Returns: Array of HashEntry (field-value pairs), or nil if key doesn't exist
+        /// - Throws: RESPDecodeError if response format is unexpected
+        public func multipleFieldsWithValues() throws -> [HashEntry]? {
+            switch token.value {
+            case .null:
+                return nil
+            case .array(let array):
+                guard array.count > 0 else {
+                    return []
+                }
+
+                // Check first element to determine format
+                var iterator = array.makeIterator()
+                guard let firstElement = iterator.next() else {
+                    return []
+                }
+                switch firstElement.value {
+                case .array:
+                    // Array of arrays format - can use HashEntry decode
+                    return try [HashEntry]?(fromRESP: token)
+                default:
+                    // Flat array format - handle manually
+                    return try _decodeFlatArrayFormat(array)
+                }
+            default:
+                throw RESPDecodeError.tokenMismatch(expected: [.null, .array], token: token)
+            }
+        }
+
+        /// Helper method to decode flat array format
+        /// - Parameter array: RESP array containing alternating field-value pairs
+        /// - Returns: Array of HashEntry objects
+        /// - Throws: RESPDecodeError if format is invalid
+        private func _decodeFlatArrayFormat(_ array: RESPToken.Array) throws -> [HashEntry] {
+            guard array.count % 2 == 0 else {
+                throw RESPDecodeError(.invalidArraySize, token: token)
+            }
+
+            var entries: [HashEntry] = []
+            entries.reserveCapacity(array.count / 2)
+
+            // Iterate over pairs
+            var iterator = array.makeIterator()
+            while let field = iterator.next(), let value = iterator.next() {
+                let fieldBuffer = try ByteBuffer(fromRESP: field)
+                let valueBuffer = try ByteBuffer(fromRESP: value)
+                entries.append(HashEntry(field: fieldBuffer, value: valueBuffer))
+            }
+
+            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))
     }
 

Tests/IntegrationTests/CommandIntegrationTests.swift

@@ -216,4 +216,74 @@ struct CommandIntegratedTests {
             _ = try await client.scriptExists(sha1s: [sha1])
         }
     }
+
+    @Test
+    @available(valkeySwift 1.0, *)
+    func testHrandfield() async throws {
+        var logger = Logger(label: "Valkey")
+        logger.logLevel = .debug
+        try await withValkeyClient(.hostname(valkeyHostname, port: 6379), logger: logger) { client in
+            try await withKey(connection: client) { key in
+
+                // Non-existent hash
+                var response = try await client.hrandfield(key)
+                var singleField = try response.singleField()
+                #expect(singleField == nil)
+                var multipleFields = try response.multipleFields()
+                #expect(multipleFields == nil)
+                var fieldValuePairs = try response.multipleFieldsWithValues()
+                #expect(fieldValuePairs == nil)
+
+                // Hash with multiple fields
+                _ = try await client.hset(
+                    key,
+                    data: [
+                        HSET.Data(field: "field1", value: "value1"),
+                        HSET.Data(field: "field2", value: "value2"),
+                        HSET.Data(field: "field3", value: "value3"),
+                    ]
+                )
+
+                // Get Single Field
+                response = try await client.hrandfield(key)
+                singleField = try response.singleField()
+                #expect(singleField != nil)
+                let fieldName = String(buffer: singleField!)
+                #expect(["field1", "field2", "field3"].contains(fieldName))
+
+                // Get multiple fields
+                var options = HRANDFIELD.Options(count: 2, withvalues: false)
+                response = try await client.hrandfield(key, options: options)
+                multipleFields = try response.multipleFields()
+                #expect(multipleFields != nil)
+                if let unwrappedFields = multipleFields {
+                    #expect(unwrappedFields.count == 2)
+                    let fieldNames = unwrappedFields.map { String(buffer: $0) }
+                    for fieldName in fieldNames {
+                        #expect(["field1", "field2", "field3"].contains(fieldName))
+                    }
+                    // Ensure we got unique fields
+                    let uniqueFieldNames = Set(fieldNames)
+                    #expect(uniqueFieldNames.count == fieldNames.count)
+                }
+
+                // Get multiple fields with values
+                options = HRANDFIELD.Options(count: 3, withvalues: true)
+                response = try await client.hrandfield(key, options: options)
+                fieldValuePairs = try response.multipleFieldsWithValues()
+                #expect(fieldValuePairs != nil)
+                if let unwrappedFieldValuePairs = fieldValuePairs {
+                    #expect(unwrappedFieldValuePairs.count == 3)
+                    var expectedPairs: [String: String] = [:]
+                    for pair in unwrappedFieldValuePairs {
+                        expectedPairs[String(buffer: pair.field)] = String(buffer: pair.value)
+                    }
+                    #expect(expectedPairs["field1"] == "value1")
+                    #expect(expectedPairs["field2"] == "value2")
+                    #expect(expectedPairs["field3"] == "value3")
+                }
+            }
+        }
+    }
+
 }