Add TokenSource token fetching abstraction

.changeset/mean-mirrors-change.md

@@ -0,0 +1,5 @@
+---
+'livekit-client': patch
+---
+
+add TokenSource token fetching abstraction

examples/demo/demo.ts

@@ -24,6 +24,7 @@ import {
   Room,
   RoomEvent,
   ScreenSharePresets,
+  TokenSource,
   Track,
   TrackPublication,
   VideoPresets,
@@ -164,8 +165,13 @@ const appActions = {
   ): Promise<Room | undefined> => {
     const room = new Room(roomOptions);
 
+    const tokenSource = TokenSource.literal({
+      serverUrl: url,
+      participantToken: token,
+    });
+
     startTime = Date.now();
-    await room.prepareConnection(url, token);
+    await room.prepareConnection(tokenSource);
     const prewarmTime = Date.now() - startTime;
     appendLog(`prewarmed connection in ${prewarmTime}ms`);
     room.localParticipant.on(ParticipantEvent.LocalTrackCpuConstrained, (track, publication) => {
@@ -407,7 +413,7 @@ const appActions = {
           reject(error);
         }
       });
-      await Promise.all([room.connect(url, token, connectOptions), publishPromise]);
+      await Promise.all([room.connect(tokenSource, connectOptions), publishPromise]);
       const elapsed = Date.now() - startTime;
       appendLog(
         `successfully connected to ${room.name} in ${Math.round(elapsed)}ms`,

package.json

@@ -56,8 +56,9 @@
   },
   "dependencies": {
     "@livekit/mutex": "1.1.1",
-    "@livekit/protocol": "1.41.0",
+    "@livekit/protocol": "1.42.0",
     "events": "^3.3.0",
+    "jose": "^6.1.0",
     "loglevel": "^1.9.2",
     "sdp-transform": "^2.15.0",
     "ts-debounce": "^4.0.0",

src/index.ts

@@ -66,6 +66,7 @@ export * from './room/errors';
 export * from './room/events';
 export * from './room/track/Track';
 export * from './room/track/create';
+export { TokenSource } from './room/TokenSource';
 export { facingModeFromDeviceLabel, facingModeFromLocalTrack } from './room/track/facingMode';
 export * from './room/track/options';
 export * from './room/track/processor/types';

src/logger.ts

@@ -12,6 +12,7 @@ export enum LogLevel {
 export enum LoggerNames {
   Default = 'livekit',
   Room = 'livekit-room',
+  TokenSource = 'livekit-token-source',
   Participant = 'livekit-participant',
   Track = 'livekit-track',
   Publication = 'livekit-track-publication',

src/room/Room.ts

@@ -46,6 +46,7 @@ import { getBrowser } from '../utils/browserParser';
 import DeviceManager from './DeviceManager';
 import RTCEngine from './RTCEngine';
 import { RegionUrlProvider } from './RegionUrlProvider';
+import { TokenSource } from './TokenSource';
 import IncomingDataStreamManager from './data-stream/incoming/IncomingDataStreamManager';
 import {
   type ByteStreamHandler,
@@ -170,6 +171,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   /** future holding client initiated connection attempt */
   private connectFuture?: Future<void>;
 
+  private tokenSource?: TokenSource;
+
   private disconnectLock: Mutex;
 
   private e2eeManager: BaseE2EEManager | undefined;
@@ -588,7 +591,31 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
    * With LiveKit Cloud, it will also determine the best edge data center for
    * the current client to connect to if a token is provided.
    */
-  async prepareConnection(url: string, token?: string) {
+  prepareConnection(tokenSource: TokenSource): Promise<void>;
+  prepareConnection(url: string): Promise<void>;
+  /** @deprecated Use room.prepareConnection(new TokenSource.Literal({ server_url: "url", participant_token: "token" })) instead */
+  prepareConnection(url: string, token?: string): Promise<void>;
+  async prepareConnection(
+    urlOrTokenSource: TokenSource | string,
+    tokenOrUnknown?: string | undefined,
+  ) {
+    let url, token;
+    if (urlOrTokenSource instanceof TokenSource && typeof tokenOrUnknown !== 'string') {
+      const result = await urlOrTokenSource.generate();
+      url = result.serverUrl;
+      token = result.participantToken;
+    } else if (
+      typeof urlOrTokenSource === 'string' &&
+      (typeof tokenOrUnknown === 'string' || typeof tokenOrUnknown === 'undefined')
+    ) {
+      url = urlOrTokenSource;
+      token = tokenOrUnknown;
+    } else {
+      throw new Error(
+        `Room.prepareConnection received invalid parameters - expected url, url/token or tokenSource, received ${urlOrTokenSource}, ${tokenOrUnknown}`,
+      );
+    }
+
     if (this.state !== ConnectionState.Disconnected) {
       return;
     }
@@ -612,7 +639,29 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     }
   }
 
-  connect = async (url: string, token: string, opts?: RoomConnectOptions): Promise<void> => {
+  connect: {
+    (tokenSource: TokenSource, opts?: RoomConnectOptions): Promise<void>;
+    /** @deprecated Use room.connect(new TokenSource.Literal({ server_url: "url", participant_token: "token" }), opts?: RoomConnectOptions) instead */
+    (url: string, token: string, opts?: RoomConnectOptions): Promise<void>;
+  } = async (urlOrTokenSource, tokenOrOpts, optsOrUnset?: unknown): Promise<void> => {
+    let opts: RoomConnectOptions = {};
+    if (urlOrTokenSource instanceof TokenSource && typeof tokenOrOpts !== 'string') {
+      this.tokenSource = urlOrTokenSource;
+      opts = tokenOrOpts ?? {};
+    } else if (typeof urlOrTokenSource === 'string' && typeof tokenOrOpts === 'string') {
+      this.tokenSource = new TokenSource.Literal({
+        serverUrl: urlOrTokenSource,
+        participantToken: tokenOrOpts,
+      });
+      opts = optsOrUnset ?? {};
+    } else {
+      throw new Error(
+        `Room.connect received invalid parameters - expected url/token or tokenSource, received ${urlOrTokenSource}, ${tokenOrOpts}, ${optsOrUnset}`,
+      );
+    }
+
+    const { serverUrl: url, participantToken: token } = await this.tokenSource.generate();
+
     if (!isBrowserSupported()) {
       if (isReactNative()) {
         throw Error("WebRTC isn't detected, have you called registerGlobals?");
@@ -958,6 +1007,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       this.handleDisconnect(stopTracks, DisconnectReason.CLIENT_INITIATED);
       /* @ts-ignore */
       this.engine = undefined;
+      this.tokenSource?.generate();
     } finally {
       unlock();
     }