Converting all errors in Cluster commands to RESPDecodeError

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

Author: Nilanshu Sharma

Sources/Valkey/Commands/Custom/ClusterCustomCommands.swift

@@ -35,29 +35,6 @@ extension CLUSTER.SLOTS {
     public typealias Response = [ValkeyClusterSlotRange]
 }
 
-package struct ValkeyClusterParseError: Error, Equatable {
-    package enum Reason: Error {
-        case clusterDescriptionTokenIsNotAnArray
-        case shardTokenIsNotAnArrayOrMap
-        case nodesTokenIsNotAnArray
-        case nodeTokenIsNotAnArrayOrMap
-        case slotsTokenIsNotAnArray
-        case invalidNodeRole
-        case invalidNodeHealth
-        case missingRequiredValueForNode
-        case shardIsMissingHashSlots
-        case shardIsMissingNode
-    }
-
-    package var reason: Reason
-    package var token: RESPToken
-
-    package init(reason: Reason, token: RESPToken) {
-        self.reason = reason
-        self.token = token
-    }
-}
-
 /// A description of a Valkey cluster.
 ///
 /// A description is return when you call ``ValkeyClientProtocol/clusterShards()``.
@@ -204,11 +181,7 @@ public struct ValkeyClusterDescription: Hashable, Sendable, RESPTokenDecodable {
     /// Creates a cluster description from the response token you provide.
     /// - Parameter respToken: The response token.
     public init(fromRESP respToken: RESPToken) throws {
-        do {
-            self = try Self.makeClusterDescription(respToken: respToken)
-        } catch {
-            throw ValkeyClusterParseError(reason: error, token: respToken)
-        }
+        self = try Self.makeClusterDescription(respToken: respToken)
     }
 
     /// Creates a cluster description from a list of shards you provide.
@@ -399,28 +372,28 @@ public struct ValkeyClusterSlotRange: Hashable, Sendable, RESPTokenDecodable {
 }
 
 extension ValkeyClusterDescription {
-    fileprivate static func makeClusterDescription(respToken: RESPToken) throws(ValkeyClusterParseError.Reason) -> ValkeyClusterDescription {
+    fileprivate static func makeClusterDescription(respToken: RESPToken) throws(RESPDecodeError) -> ValkeyClusterDescription {
         guard case .array(let shardsToken) = respToken.value else {
-            throw .clusterDescriptionTokenIsNotAnArray
+            throw RESPDecodeError.tokenMismatch(expected: [.array], token: respToken)
         }
-        let shards = try shardsToken.map { shardToken throws(ValkeyClusterParseError.Reason) in
+        let shards = try shardsToken.map { shardToken throws(RESPDecodeError) in
             try ValkeyClusterDescription.Shard(shardToken)
         }
         return ValkeyClusterDescription(shards)
     }
 }
 
 extension HashSlots {
-    fileprivate init(_ iterator: inout RESPToken.Array.Iterator) throws(ValkeyClusterParseError.Reason) {
+    fileprivate init(_ iterator: inout RESPToken.Array.Iterator) throws(RESPDecodeError) {
         guard let token = iterator.next() else {
-            throw .slotsTokenIsNotAnArray
+            throw RESPDecodeError(.tokenMismatch, token: .null, message: "Expected to find an array token but reached end of input")
         }
         self = try HashSlots(token)
     }
 
-    fileprivate init(_ token: RESPToken) throws(ValkeyClusterParseError.Reason) {
+    fileprivate init(_ token: RESPToken) throws(RESPDecodeError) {
         guard case .array(let array) = token.value else {
-            throw .slotsTokenIsNotAnArray
+            throw RESPDecodeError.tokenMismatch(expected: [.array], token: token)
         }
 
         var slotRanges = [ClosedRange<HashSlot>]()
@@ -441,29 +414,29 @@ extension HashSlots {
 }
 
 extension [ValkeyClusterDescription.Node] {
-    fileprivate init(_ iterator: inout RESPToken.Array.Iterator) throws(ValkeyClusterParseError.Reason) {
+    fileprivate init(_ iterator: inout RESPToken.Array.Iterator) throws(RESPDecodeError) {
         guard let token = iterator.next() else {
-            throw .nodesTokenIsNotAnArray
+            throw RESPDecodeError(.tokenMismatch, token: .null, message: "Expected to find an array token but reached end of input")
         }
         self = try Self(token)
     }
 
-    fileprivate init(_ token: RESPToken) throws(ValkeyClusterParseError.Reason) {
+    fileprivate init(_ token: RESPToken) throws(RESPDecodeError) {
         guard case .array(let array) = token.value else {
-            throw .nodesTokenIsNotAnArray
+            throw RESPDecodeError.tokenMismatch(expected: [.array], token: token)
         }
 
-        self = try array.map { token throws(ValkeyClusterParseError.Reason) in
+        self = try array.map { token throws(RESPDecodeError) in
             try ValkeyClusterDescription.Node(token)
         }
     }
 }
 
 extension ValkeyClusterDescription.Shard {
-    fileprivate init(_ token: RESPToken) throws(ValkeyClusterParseError.Reason) {
+    fileprivate init(_ token: RESPToken) throws(RESPDecodeError) {
         switch token.value {
         case .array(let array):
-            self = try Self.makeFromTokenSequence(MapStyleArray(underlying: array))
+            self = try Self.makeFromTokenSequence(MapStyleArray(underlying: array), token)
 
         case .map(let map):
             let mapped = map.lazy.compactMap { (keyNode, value) -> (String, RESPToken)? in
@@ -473,16 +446,17 @@ extension ValkeyClusterDescription.Shard {
                     return nil
                 }
             }
-            self = try Self.makeFromTokenSequence(mapped)
+            self = try Self.makeFromTokenSequence(mapped, token)
 
         default:
-            throw ValkeyClusterParseError.Reason.shardTokenIsNotAnArrayOrMap
+            throw RESPDecodeError.tokenMismatch(expected: [.array, .map], token: token)
         }
     }
 
     fileprivate static func makeFromTokenSequence<TokenSequence: Sequence>(
-        _ sequence: TokenSequence
-    ) throws(ValkeyClusterParseError.Reason) -> Self where TokenSequence.Element == (String, RESPToken) {
+        _ sequence: TokenSequence,
+        _ token: RESPToken
+    ) throws(RESPDecodeError) -> Self where TokenSequence.Element == (String, RESPToken) {
         var slotRanges = HashSlots()
         var nodes: [ValkeyClusterDescription.Node] = []
 
@@ -499,18 +473,18 @@ extension ValkeyClusterDescription.Shard {
             }
         }
 
-        if nodes.isEmpty { throw .shardIsMissingNode }
-        if slotRanges.isEmpty { throw .shardIsMissingHashSlots }
+        if nodes.isEmpty { throw RESPDecodeError.missingToken(key: "nodes", token: token) }
+        if slotRanges.isEmpty { throw RESPDecodeError.missingToken(key: "shards", token: token) }
 
         return .init(slots: slotRanges, nodes: nodes)
     }
 }
 
 extension ValkeyClusterDescription.Node {
-    fileprivate init(_ token: RESPToken) throws(ValkeyClusterParseError.Reason) {
+    fileprivate init(_ token: RESPToken) throws(RESPDecodeError) {
         switch token.value {
         case .array(let array):
-            self = try Self.makeFromTokenSequence(MapStyleArray(underlying: array))
+            self = try Self.makeFromTokenSequence(MapStyleArray(underlying: array), token)
 
         case .map(let map):
             let mapped = map.lazy.compactMap { (keyNode, value) -> (String, RESPToken)? in
@@ -520,16 +494,17 @@ extension ValkeyClusterDescription.Node {
                     return nil
                 }
             }
-            self = try Self.makeFromTokenSequence(mapped)
+            self = try Self.makeFromTokenSequence(mapped, token)
 
         default:
-            throw .nodeTokenIsNotAnArrayOrMap
+            throw RESPDecodeError.tokenMismatch(expected: [.array, .map], token: token)
         }
     }
 
     fileprivate static func makeFromTokenSequence<TokenSequence: Sequence>(
-        _ sequence: TokenSequence
-    ) throws(ValkeyClusterParseError.Reason) -> Self where TokenSequence.Element == (String, RESPToken) {
+        _ sequence: TokenSequence,
+        _ respToken: RESPToken
+    ) throws(RESPDecodeError) -> Self where TokenSequence.Element == (String, RESPToken) {
         var id: String?
         var port: Int64?
         var tlsPort: Int64?
@@ -557,7 +532,7 @@ extension ValkeyClusterDescription.Node {
                 endpoint = try? String(fromRESP: nodeVal)
             case "role":
                 guard let roleString = try? String(fromRESP: nodeVal), let roleValue = ValkeyClusterDescription.Node.Role(rawValue: roleString) else {
-                    throw .invalidNodeRole
+                    throw RESPDecodeError.missingToken(key: "role", token: respToken)
                 }
                 role = roleValue
 
@@ -567,7 +542,7 @@ extension ValkeyClusterDescription.Node {
                 guard let healthString = try? String(fromRESP: nodeVal),
                     let healthValue = ValkeyClusterDescription.Node.Health(rawValue: healthString)
                 else {
-                    throw .invalidNodeHealth
+                    throw RESPDecodeError.missingToken(key: "health", token: respToken)
                 }
                 health = healthValue
 
@@ -579,12 +554,12 @@ extension ValkeyClusterDescription.Node {
         guard let id = id, let ip = ip, let endpoint = endpoint, let role = role,
             let replicationOffset = replicationOffset, let health = health
         else {
-            throw .missingRequiredValueForNode
+            throw RESPDecodeError.missingToken(key: "id or ip or endpoint or role or replication-offset or health", token: respToken)
         }
 
         // we need at least port or tlsport
         if port == nil && tlsPort == nil {
-            throw .missingRequiredValueForNode
+            throw RESPDecodeError.missingToken(key: "port or tls-port", token: respToken)
         }
 
         return ValkeyClusterDescription.Node(