feat: rename from ConnectionCredentials -> TokenSource

1egoman · 1egoman · commit 0a07961461bc · 2025-09-17T11:05:20.000-04:00
diff --git a/examples/demo/demo.ts b/examples/demo/demo.ts
@@ -11,7 +11,7 @@ import type {
 } from '../../src/index';
 import {
   BackupCodecPolicy,
-  ConnectionCredentials,
+  TokenSource,
   ConnectionQuality,
   ConnectionState,
   DisconnectReason,
@@ -165,13 +165,13 @@ const appActions = {
   ): Promise<Room | undefined> => {
     const room = new Room(roomOptions);
 
-    const credentials = new ConnectionCredentials.Literal({
+    const tokenSource = new TokenSource.Literal({
       serverUrl: url,
       participantToken: token,
     });
 
     startTime = Date.now();
-    await room.prepareConnection(credentials);
+    await room.prepareConnection(tokenSource);
     const prewarmTime = Date.now() - startTime;
     appendLog(`prewarmed connection in ${prewarmTime}ms`);
     room.localParticipant.on(ParticipantEvent.LocalTrackCpuConstrained, (track, publication) => {
@@ -412,7 +412,7 @@ const appActions = {
           reject(error);
         }
       });
-      await Promise.all([room.connect(credentials, 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`,
diff --git a/src/index.ts b/src/index.ts
@@ -58,7 +58,7 @@ export * from './room/errors';
 export * from './room/events';
 export * from './room/track/Track';
 export * from './room/track/create';
-export { ConnectionCredentials } from './room/ConnectionCredentials';
+export { TokenSource } from './room/TokenSource';
 export { facingModeFromDeviceLabel, facingModeFromLocalTrack } from './room/track/facingMode';
 export * from './room/track/options';
 export * from './room/track/processor/types';
diff --git a/src/logger.ts b/src/logger.ts
@@ -12,7 +12,7 @@ export enum LogLevel {
 export enum LoggerNames {
   Default = 'livekit',
   Room = 'livekit-room',
-  ConnectionCredentials = 'livekit-connection-credentials',
+  TokenSource = 'livekit-connection-credentials',
   Participant = 'livekit-participant',
   Track = 'livekit-track',
   Publication = 'livekit-track-publication',
diff --git a/src/room/Room.ts b/src/room/Room.ts
@@ -42,7 +42,7 @@ import type {
   RoomOptions,
 } from '../options';
 import { getBrowser } from '../utils/browserParser';
-import { ConnectionCredentials } from './ConnectionCredentials';
+import { TokenSource } from './TokenSource';
 import DeviceManager from './DeviceManager';
 import RTCEngine from './RTCEngine';
 import { RegionUrlProvider } from './RegionUrlProvider';
@@ -170,7 +170,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   /** future holding client initiated connection attempt */
   private connectFuture?: Future<void>;
 
-  private connectionCredentials?: ConnectionCredentials;
+  private connectionCredentials?: TokenSource;
 
   private disconnectLock: Mutex;
 
@@ -578,31 +578,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.
    */
-  prepareConnection(connectionCredentials: ConnectionCredentials): Promise<void>;
+  prepareConnection(connectionCredentials: TokenSource): Promise<void>;
   prepareConnection(url: string): Promise<void>;
-  /** @deprecated Use room.prepareConnection(new ConnectionCredentials.Literal({ serverUrl: "url", participantToken: "token" })) instead */
+  /** @deprecated Use room.prepareConnection(new TokenSource.Literal({ serverUrl: "url", participantToken: "token" })) instead */
   prepareConnection(url: string, token?: string): Promise<void>;
   async prepareConnection(
-    urlOrConnectionCredentials: ConnectionCredentials | string,
+    urlOrTokenSource: TokenSource | string,
     tokenOrUnknown?: string | undefined,
   ) {
     let url, token;
     if (
-      urlOrConnectionCredentials instanceof ConnectionCredentials &&
+      urlOrTokenSource instanceof TokenSource &&
       typeof tokenOrUnknown !== 'string'
     ) {
-      const result = await urlOrConnectionCredentials.generate();
+      const result = await urlOrTokenSource.generate();
       url = result.serverUrl;
       token = result.participantToken;
     } else if (
-      typeof urlOrConnectionCredentials === 'string' &&
+      typeof urlOrTokenSource === 'string' &&
       (typeof tokenOrUnknown === 'string' || typeof tokenOrUnknown === 'undefined')
     ) {
-      url = urlOrConnectionCredentials;
+      url = urlOrTokenSource;
       token = tokenOrUnknown;
     } else {
       throw new Error(
-        `Room.prepareConnection received invalid parameters - expected url, url/token or connectionCredentials, received ${urlOrConnectionCredentials}, ${tokenOrUnknown}`,
+        `Room.prepareConnection received invalid parameters - expected url, url/token or connectionCredentials, received ${urlOrTokenSource}, ${tokenOrUnknown}`,
       );
     }
 
@@ -630,26 +630,26 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   }
 
   connect: {
-    (connectionCredentials: ConnectionCredentials, opts?: RoomConnectOptions): Promise<void>;
-    /** @deprecated Use room.connect(new ConnectionCredentials.Literal({ serverUrl: "url", participantToken: "token" }), opts?: RoomConnectOptions) instead */
+    (connectionCredentials: TokenSource, opts?: RoomConnectOptions): Promise<void>;
+    /** @deprecated Use room.connect(new TokenSource.Literal({ serverUrl: "url", participantToken: "token" }), opts?: RoomConnectOptions) instead */
     (url: string, token: string, opts?: RoomConnectOptions): Promise<void>;
-  } = async (urlOrConnectionCredentials, tokenOrOpts, optsOrUnset?: unknown): Promise<void> => {
+  } = async (urlOrTokenSource, tokenOrOpts, optsOrUnset?: unknown): Promise<void> => {
     let opts: RoomConnectOptions = {};
     if (
-      urlOrConnectionCredentials instanceof ConnectionCredentials &&
+      urlOrTokenSource instanceof TokenSource &&
       typeof tokenOrOpts !== 'string'
     ) {
-      this.connectionCredentials = urlOrConnectionCredentials;
+      this.connectionCredentials = urlOrTokenSource;
       opts = tokenOrOpts ?? {};
-    } else if (typeof urlOrConnectionCredentials === 'string' && typeof tokenOrOpts === 'string') {
-      this.connectionCredentials = new ConnectionCredentials.Literal({
-        serverUrl: urlOrConnectionCredentials,
+    } else if (typeof urlOrTokenSource === 'string' && typeof tokenOrOpts === 'string') {
+      this.connectionCredentials = new TokenSource.Literal({
+        serverUrl: urlOrTokenSource,
         participantToken: tokenOrOpts,
       });
       opts = optsOrUnset ?? {};
     } else {
       throw new Error(
-        `Room.connect received invalid parameters - expected url/token or connectionCredentials, received ${urlOrConnectionCredentials}, ${tokenOrOpts}, ${optsOrUnset}`,
+        `Room.connect received invalid parameters - expected url/token or connectionCredentials, received ${urlOrTokenSource}, ${tokenOrOpts}, ${optsOrUnset}`,
       );
     }
 
diff --git a/src/room/TokenSource.ts b/src/room/TokenSource.ts
@@ -5,11 +5,11 @@ import log, { LoggerNames, getLogger } from '../logger';
 const ONE_SECOND_IN_MILLISECONDS = 1000;
 const ONE_MINUTE_IN_MILLISECONDS = 60 * ONE_SECOND_IN_MILLISECONDS;
 
-/** ConnectionCredentials handles generating credentials for connecting to a new Room */
-export abstract class ConnectionCredentials {
-  protected cachedResponse: ConnectionCredentials.Response | null = null;
+/** TokenSource handles generating credentials for connecting to a new Room */
+export abstract class TokenSource {
+  protected cachedResponse: TokenSource.Response | null = null;
 
-  constructor(response: ConnectionCredentials.Response | null = null) {
+  constructor(response: TokenSource.Response | null = null) {
     this.cachedResponse = response;
   }
 
@@ -70,9 +70,9 @@ export abstract class ConnectionCredentials {
     return this.getCachedResponseJwtPayload()?.attributes ?? null;
   }
 
-  abstract generate(): Promise<ConnectionCredentials.Response>;
+  abstract generate(): Promise<TokenSource.Response>;
 }
-export namespace ConnectionCredentials {
+export namespace TokenSource {
   export type Request = {
     /** The name of the room being requested when generating credentials */
     roomName?: string;
@@ -102,14 +102,14 @@ export namespace ConnectionCredentials {
   };
 
   /**
-   * ConnectionCredentials.Refreshable handles getting credentials for connecting to a new Room from
+   * TokenSource.Refreshable handles getting credentials for connecting to a new Room from
    * an async source, caching them and auto refreshing them if they expire. */
-  export abstract class Refreshable extends ConnectionCredentials {
-    private request: ConnectionCredentials.Request = {};
+  export abstract class Refreshable extends TokenSource {
+    private request: TokenSource.Request = {};
 
-    private inProgressFetch: Promise<ConnectionCredentials.Response> | null = null;
+    private inProgressFetch: Promise<TokenSource.Response> | null = null;
 
-    protected isSameAsCachedRequest(request: ConnectionCredentials.Request) {
+    protected isSameAsCachedRequest(request: TokenSource.Request) {
       if (!this.request) {
         return false;
       }
@@ -140,8 +140,8 @@ export namespace ConnectionCredentials {
     /**
      * Store request metadata which will be provide explicitly when fetching new credentials.
      *
-     * @example new ConnectionCredentials.Custom((request /* <= This value! *\/) => ({ serverUrl: "...", participantToken: "..." })) */
-    setRequest(request: ConnectionCredentials.Request) {
+     * @example new TokenSource.Custom((request /* <= This value! *\/) => ({ serverUrl: "...", participantToken: "..." })) */
+    setRequest(request: TokenSource.Request) {
       if (!this.isSameAsCachedRequest(request)) {
         this.cachedResponse = null;
       }
@@ -176,35 +176,35 @@ export namespace ConnectionCredentials {
     }
 
     protected abstract fetch(
-      request: ConnectionCredentials.Request,
-    ): Promise<ConnectionCredentials.Response>;
+      request: TokenSource.Request,
+    ): Promise<TokenSource.Response>;
   }
 
-  /** ConnectionCredentials.Literal contains a single, literal set of credentials.
+  /** TokenSource.Literal contains a single, literal set of credentials.
    * Note that refreshing credentials isn't implemented, because there is only one set provided.
    * */
-  export class Literal extends ConnectionCredentials {
+  export class Literal extends TokenSource {
     private log = log;
 
     constructor(payload: Response) {
       super(payload);
-      this.log = getLogger(LoggerNames.ConnectionCredentials);
+      this.log = getLogger(LoggerNames.TokenSource);
     }
 
     async generate() {
       if (this.isCachedResponseExpired()) {
         this.log.warn(
-          'The credentials within ConnectionCredentials.Literal have expired, so any upcoming uses of them will likely fail.',
+          'The credentials within TokenSource.Literal have expired, so any upcoming uses of them will likely fail.',
         );
       }
       return this.cachedResponse!;
     }
   }
 
-  /** ConnectionCredentials.Custom allows a user to define a manual function which generates new
+  /** TokenSource.Custom allows a user to define a manual function which generates new
    * {@link Response} values on demand. Use this to get credentials from custom backends / etc.
    * */
-  export class Custom extends ConnectionCredentials.Refreshable {
+  export class Custom extends TokenSource.Refreshable {
     protected fetch: (request: Request) => Promise<Response>;
 
     constructor(handler: (request: Request) => Promise<Response>) {
@@ -221,14 +221,14 @@ export namespace ConnectionCredentials {
     baseUrl?: string;
   };
 
-  /** ConnectionCredentials.SandboxTokenServer queries a sandbox token server for credentials,
+  /** TokenSource.SandboxTokenServer queries a sandbox token server for credentials,
    * which supports quick prototyping / getting started types of use cases.
    *
    * This token provider is INSECURE and should NOT be used in production.
    *
    * For more info:
    * @see https://cloud.livekit.io/projects/p_/sandbox/templates/token-server */
-  export class SandboxTokenServer extends ConnectionCredentials.Refreshable {
+  export class SandboxTokenServer extends TokenSource.Refreshable {
     protected options: SandboxTokenServerOptions;
 
     constructor(options: SandboxTokenServerOptions) {
