Mutable variant with setRequest

Author: pblazej

Sources/LiveKit/Auth/Sandbox.swift

@@ -25,6 +25,15 @@ public struct Sandbox: TokenEndpoint {
         ["X-Sandbox-ID": id]
     }
 
+    public var request: Token.Request?
+    public mutating func setRequest(_ request: Token.Request) {
+        self.request = request
+    }
+
+    public mutating func clearRequest() {
+        request = nil
+    }
+
     /// The sandbox ID provided by LiveKit Cloud.
     public let id: String
 

Sources/LiveKit/Auth/TokenSource.swift

@@ -82,7 +82,6 @@ public enum Token {
         }
     }
 
-    public typealias Options = Request
     public typealias Literal = Response
 }
 
@@ -91,18 +90,22 @@ public enum Token {
 /// Protocol for types that can provide connection credentials.
 /// Implement this protocol to create custom credential providers (e.g., fetching from your backend API).
 public protocol TokenSource: Sendable {
-    /// Fetch connection credentials for the given request.
-    /// - Parameter request: The token request containing room and participant information
+    var request: Token.Request? { get async }
+    mutating func setRequest(_ request: Token.Request) async
+    mutating func clearRequest() async
+    /// Get connection credentials for the given request.
     /// - Returns: A token response containing the server URL and participant token
     /// - Throws: An error if the token generation fails
-    func fetch(_ request: Token.Request) async throws -> Token.Response
+    func generate() async throws -> Token.Response
 }
 
 /// `Token.Literal` contains a single set of credentials, hard-coded or acquired from a static source.
 extension Token.Literal: TokenSource {
-    public func fetch(_: Token.Request) async throws -> Token.Response {
-        self
-    }
+    public var request: Token.Request? { nil }
+    public func setRequest(_: Token.Request) {}
+    public func clearRequest() {}
+
+    public func generate() async throws -> Token.Response { self }
 }
 
 // MARK: - Endpoint
@@ -123,17 +126,19 @@ public extension TokenEndpoint {
     var method: String { "POST" }
     var headers: [String: String] { [:] }
 
-    func fetch(_ request: Token.Request) async throws -> Token.Response {
+    func generate() async throws -> Token.Response {
         var urlRequest = URLRequest(url: url)
 
         urlRequest.httpMethod = method
         for (key, value) in headers {
             urlRequest.addValue(value, forHTTPHeaderField: key)
         }
-        urlRequest.httpBody = try JSONEncoder().encode(request)
+        urlRequest.httpBody = try await JSONEncoder().encode(request)
 
         let (data, response) = try await URLSession.shared.data(for: urlRequest)
 
+        try Task.checkCancellation()
+
         guard let httpResponse = response as? HTTPURLResponse else {
             throw LiveKitError(.network, message: "Error generating token from the token server, no response")
         }
@@ -159,7 +164,20 @@ public actor CachingTokenSource: TokenSource, Loggable {
     /// - Returns: `true` if the cached credentials are still valid, `false` otherwise
     public typealias TokenValidator = (Token.Request, Token.Response) -> Bool
 
-    private let source: TokenSource
+    public var request: Token.Request? {
+        get async { await source.request }
+    }
+
+    public func setRequest(_ request: Token.Request) async {
+        await source.setRequest(request)
+    }
+
+    public func clearRequest() async {
+        await source.clearRequest()
+        await store.clear()
+    }
+
+    private var source: TokenSource
     private let store: TokenStore
     private let validator: TokenValidator
 
@@ -178,30 +196,29 @@ public actor CachingTokenSource: TokenSource, Loggable {
         self.validator = validator
     }
 
-    public func fetch(_ request: Token.Request) async throws -> Token.Response {
-        if let (cachedRequest, cachedResponse) = await store.retrieve(),
-           cachedRequest == request,
+    public func generate() async throws -> Token.Response {
+        let request = await request ?? .init()
+
+        if let (cachedRequest, cachedResponse) = await store.retrieve(), cachedRequest == request,
            validator(cachedRequest, cachedResponse)
         {
             log("Using cached credentials", .debug)
             return cachedResponse
         }
 
         log("Requesting new credentials", .debug)
-        let response = try await source.fetch(request)
+        let response = try await source.generate()
+
+        guard validator(request, response) else {
+            throw LiveKitError(.network, message: "Invalid credentials")
+        }
+
         await store.store((request, response))
         return response
     }
 
-    /// Invalidate the cached credentials, forcing a fresh fetch on the next request.
-    public func invalidate() async {
-        await store.clear()
-    }
-
-    /// Get the cached credentials
-    /// - Returns: The cached token if found, nil otherwise
-    public func cachedToken() async -> Token.Response? {
-        await store.retrieve()?.1
+    var cachedResponse: Token.Response? {
+        get async { await store.retrieve()?.1 }
     }
 }
 

Sources/LiveKit/Core/Room.swift

@@ -412,13 +412,12 @@ public class Room: NSObject, @unchecked Sendable, ObservableObject, Loggable {
     }
 
     public func connect(tokenSource: TokenSource,
-                        tokenOptions: Token.Options = .init(),
                         connectOptions: ConnectOptions? = nil,
                         roomOptions: RoomOptions? = nil) async throws
     {
         self.tokenSource = tokenSource
 
-        let token = try await tokenSource.fetch(tokenOptions)
+        let token = try await tokenSource.generate()
         try await connect(url: token.serverURL.absoluteString, token: token.participantToken, connectOptions: connectOptions, roomOptions: roomOptions)
     }