Minor validation logic improvements (#782)

Throws different type of error if server validation failed

---------

Co-authored-by: Błażej Pankowski <86720177+pblazej@users.noreply.github.com>

Author: hiroshihorie

.changes/validation-logic

@@ -0,0 +1 @@
+patch type="changed" "Minor validation logic improvements"

Sources/LiveKit/Core/SignalClient.swift

@@ -162,33 +162,47 @@ actor SignalClient: Loggable {
             }
 
             return connectResponse
-        } catch {
+        } catch let connectionError {
             // Skip validation if user cancelled
-            if error is CancellationError {
-                await cleanUp(withError: error)
-                throw error
+            if connectionError is CancellationError {
+                await cleanUp(withError: connectionError)
+                throw connectionError
             }
 
             // Skip validation if reconnect mode
             if reconnectMode != nil {
-                await cleanUp(withError: error)
-                throw error
+                await cleanUp(withError: connectionError)
+                throw LiveKitError(.network, internalError: connectionError)
             }
 
-            await cleanUp(withError: error)
+            await cleanUp(withError: connectionError)
 
-            // Validate...
+            // Attempt to validate with server
             let validateUrl = try Utils.buildUrl(url,
                                                  connectOptions: connectOptions,
                                                  participantSid: participantSid,
                                                  adaptiveStream: adaptiveStream,
                                                  validate: true)
-
             log("Validating with url: \(validateUrl)...")
-            let validationResponse = try await HTTP.requestValidation(from: validateUrl, token: token)
-            log("Validate response: \(validationResponse)")
-            // re-throw with validation response
-            throw LiveKitError(.network, message: "Validation response: \"\(validationResponse)\"")
+            do {
+                try await HTTP.requestValidation(from: validateUrl, token: token)
+                // Re-throw original error since validation passed
+                throw LiveKitError(.network, internalError: connectionError)
+            } catch let validationError as LiveKitError where validationError.type == .validation {
+                // Re-throw validation error
+                throw validationError
+            } catch {
+                let validationMessage = if let liveKitError = error as? LiveKitError {
+                    liveKitError.message ?? liveKitError.localizedDescription
+                } else {
+                    error.localizedDescription
+                }
+
+                // Preserve validation request failure details while keeping the original connection error.
+                throw LiveKitError(.network,
+                                   message: "Validation request failed: \(validationMessage)",
+                                   internalError: connectionError)
+            }
         }
     }
 

Sources/LiveKit/Errors.swift

@@ -30,6 +30,7 @@ public enum LiveKitErrorType: Int, Sendable {
     case webRTC = 201
 
     case network // Network issue
+    case validation // Validation issue
 
     // Server
     case duplicateIdentity = 500
@@ -80,6 +81,8 @@ extension LiveKitErrorType: CustomStringConvertible {
             "WebRTC error"
         case .network:
             "Network error"
+        case .validation:
+            "Validation error"
         case .duplicateIdentity:
             "Duplicate Participant identity"
         case .serverShutdown:
@@ -121,29 +124,40 @@ extension LiveKitErrorType: CustomStringConvertible {
 public class LiveKitError: NSError, @unchecked Sendable, Loggable {
     public let type: LiveKitErrorType
     public let message: String?
-    public let underlyingError: Error?
+    public let internalError: Error?
+
+    @available(*, deprecated, renamed: "internalError")
+    public var underlyingError: Error? { internalError }
 
     override public var underlyingErrors: [Error] {
-        [underlyingError].compactMap { $0 }
+        [internalError].compactMap { $0 }
     }
 
     public init(_ type: LiveKitErrorType,
                 message: String? = nil,
                 internalError: Error? = nil)
     {
         func _computeDescription() -> String {
+            var suffix = ""
             if let message {
-                return "\(String(describing: type))(\(message))"
+                suffix = "(\(message))"
+            } else if let internalError {
+                suffix = "(\(internalError.localizedDescription))"
             }
-            return String(describing: type)
+            return String(describing: type) + suffix
         }
 
         self.type = type
         self.message = message
-        underlyingError = internalError
+        self.internalError = internalError
+
+        var userInfo: [String: Any] = [NSLocalizedDescriptionKey: _computeDescription()]
+        if let internalError {
+            userInfo[NSUnderlyingErrorKey] = internalError as NSError
+        }
         super.init(domain: "io.livekit.swift-sdk",
                    code: type.rawValue,
-                   userInfo: [NSLocalizedDescriptionKey: _computeDescription()])
+                   userInfo: userInfo)
     }
 
     @available(*, unavailable)

Sources/LiveKit/Support/HTTP.swift

@@ -23,20 +23,40 @@ class HTTP: NSObject {
                                                    delegate: nil,
                                                    delegateQueue: operationQueue)
 
-    static func requestValidation(from url: URL, token: String) async throws -> String {
-        // let data = try await requestData(from: url, token: token)
+    static func requestValidation(from url: URL, token: String) async throws {
         var request = URLRequest(url: url,
                                  cachePolicy: .reloadIgnoringLocalAndRemoteCacheData,
                                  timeoutInterval: .defaultHTTPConnect)
         // Attach token to header
         request.addValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
+
         // Make the data request
-        let (data, _) = try await session.data(for: request)
-        // Convert to string
-        guard let string = String(data: data, encoding: .utf8) else {
-            throw LiveKitError(.failedToConvertData, message: "Failed to convert string")
+        let (data, response) = try await session.data(for: request)
+
+        guard let httpResponse = response as? HTTPURLResponse else {
+            throw URLError(.badServerResponse)
         }
 
-        return string
+        guard (200 ..< 300).contains(httpResponse.statusCode) else {
+            let statusCode = httpResponse.statusCode
+            let rawBody = String(data: data, encoding: .utf8)?
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+
+            let body = if let rawBody, !rawBody.isEmpty {
+                rawBody.count > 1024 ? String(rawBody.prefix(1024)) + "..." : rawBody
+            } else {
+                "(No server message)"
+            }
+
+            let details = "HTTP \(statusCode): \(body)"
+
+            // Treat request/token/permissions issues as validation errors.
+            if (400 ..< 500).contains(statusCode), statusCode != 429 {
+                throw LiveKitError(.validation, message: details)
+            }
+
+            // Treat server/rate-limit issues as network errors.
+            throw LiveKitError(.network, message: "Validation endpoint error: \(details)")
+        }
     }
 }