@stream-io/video-client 0.1.4 → 0.1.6

package/dist/src/Call.d.ts

@@ -164,7 +164,6 @@ export declare class Call {
      */
     join: (data?: JoinCallData) => Promise<void>;
     private waitForJoinResponse;
-    private assertCallJoined;
     /**
      * Starts publishing the given video stream to the call.
      * The stream will be stopped if the user changes an input device, or if the user leaves the call.
@@ -276,6 +275,7 @@ export declare class Call {
      * @returns
      */
     updatePublishQuality: (enabledRids: string[]) => Promise<void | undefined>;
+    private assertCallJoined;
     /**
      * Sends a reaction to the other call participants.
      *
@@ -406,7 +406,7 @@ export declare class Call {
      * @param request
      * @returns
      */
-    queryMembers: (request: Omit<QueryMembersRequest, 'type' | 'id'>) => Promise<QueryMembersResponse>;
+    queryMembers: (request?: Omit<QueryMembersRequest, 'type' | 'id'>) => Promise<QueryMembersResponse>;
     /**
      * Will update the call members.
      *

package/dist/src/StreamVideoClient.d.ts

@@ -2,7 +2,7 @@ import { Call } from './Call';
 import { StreamClient } from './coordinator/connection/client';
 import { StreamVideoReadOnlyStateStore, StreamVideoWriteableStateStore } from './store';
 import type { ConnectedEvent, CreateDeviceRequest, CreateGuestRequest, CreateGuestResponse, GetEdgesResponse, ListDevicesResponse, QueryCallsRequest } from './gen/coordinator';
-import type { EventHandler, EventTypes, Logger, StreamClientOptions, TokenOrProvider, TokenProvider, User, UserWithId } from './coordinator/connection/types';
+import type { EventHandler, EventTypes, Logger, LogLevel, StreamClientOptions, TokenOrProvider, TokenProvider, User, UserWithId } from './coordinator/connection/types';
 /**
  * A `StreamVideoClient` instance lets you communicate with our API, and authenticate users.
  */
@@ -11,8 +11,7 @@ export declare class StreamVideoClient {
      * A reactive store that exposes all the state variables in a reactive manner - you can subscribe to changes of the different state variables. Our library is built in a way that all state changes are exposed in this store, so all UI changes in your application should be handled by subscribing to these variables.
      */
     readonly readOnlyStateStore: StreamVideoReadOnlyStateStore;
-    readonly user?: User;
-    readonly token?: TokenOrProvider;
+    readonly logLevel: LogLevel;
     readonly logger: Logger;
     protected readonly writeableStateStore: StreamVideoWriteableStateStore;
     streamClient: StreamClient;
@@ -38,7 +37,7 @@ export declare class StreamVideoClient {
      * @param user the user to connect.
      * @param token a token or a function that returns a token.
      */
-    connectUser(user?: User, token?: TokenOrProvider): Promise<void | ConnectedEvent>;
+    connectUser(user: User, token?: TokenOrProvider): Promise<void | ConnectedEvent>;
     /**
      * Disconnects the currently connected user from the client.
      *
@@ -83,7 +82,7 @@ export declare class StreamVideoClient {
      *
      * @param data the query data.
      */
-    queryCalls: (data: QueryCallsRequest) => Promise<{
+    queryCalls: (data?: QueryCallsRequest) => Promise<{
         calls: Call[];
         duration: string;
         next?: string | undefined;

package/dist/src/__tests__/server-side/call-types.test.d.ts

@@ -0,0 +1 @@
+import 'dotenv/config';

package/dist/src/__tests__/server-side/call.test.d.ts

@@ -0,0 +1 @@
+import 'dotenv/config';

package/dist/src/__tests__/server-side/create-token.test.d.ts

@@ -0,0 +1 @@
+import 'dotenv/config';

package/dist/src/__tests__/server-side/server-side-user.test.d.ts

@@ -0,0 +1 @@
+import 'dotenv/config';

package/dist/src/coordinator/connection/client.d.ts

@@ -39,8 +39,6 @@ export declare class StreamClient {
     rejectConnectionId?: Function;
     connectionIdPromise?: Promise<string | undefined>;
     private nextRequestAbortController;
-    private waitForConnectPromise?;
-    private resolveConnectPromise?;
     /**
      * Initialize a client.
      *
@@ -60,10 +58,6 @@ export declare class StreamClient {
     getLocationHint: (hintUrl?: string, timeout?: number) => Promise<string>;
     _getConnectionID: () => string | undefined;
     _hasConnectionID: () => boolean;
-    /**
-     * This will start a promise to hold API calls until `connectUser` is called, useful when user is set in `StreamVideoClient constructor`
-     */
-    startWaitingForConnection: () => void;
     /**
      * connectUser - Set the current user and open a WebSocket connection
      *

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "0.1.4";
+export declare const version = "0.1.6";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "packageManager": "yarn@3.2.4",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",

package/src/Call.ts

@@ -72,6 +72,7 @@ import {
 import {
   BehaviorSubject,
   debounce,
+  filter,
   map,
   pairwise,
   Subject,
@@ -371,12 +372,15 @@ export class Call {
    * Leave the call and stop the media streams that were published by the call.
    */
   leave = async ({ reject = false }: CallLeaveOptions = {}) => {
-    // TODO: handle case when leave is called during JOINING
     const callingState = this.state.callingState;
     if (callingState === CallingState.LEFT) {
       throw new Error('Cannot leave call that has already been left.');
     }
 
+    if (callingState === CallingState.JOINING) {
+      await this.assertCallJoined();
+    }
+
     if (this.ringing) {
       // I'm the one who started the call, so I should cancel it.
       const hasOtherParticipants = this.state.remoteParticipants.length > 0;
@@ -930,14 +934,6 @@ export class Call {
     });
   };
 
-  private assertCallJoined = () => {
-    return new Promise<void>((resolve) => {
-      this.state.callingState$
-        .pipe(takeWhile((state) => state !== CallingState.JOINED, true))
-        .subscribe(() => resolve());
-    });
-  };
-
   /**
    * Starts publishing the given video stream to the call.
    * The stream will be stopped if the user changes an input device, or if the user leaves the call.
@@ -1223,6 +1219,17 @@ export class Call {
     return this.publisher?.updateVideoPublishQuality(enabledRids);
   };
 
+  private assertCallJoined = () => {
+    return new Promise<void>((resolve) => {
+      this.state.callingState$
+        .pipe(
+          takeWhile((state) => state !== CallingState.JOINED, true),
+          filter((s) => s === CallingState.JOINED),
+        )
+        .subscribe(() => resolve());
+    });
+  };
+
   /**
    * Sends a reaction to the other call participants.
    *
@@ -1510,11 +1517,11 @@ export class Call {
    * @param request
    * @returns
    */
-  queryMembers = (request: Omit<QueryMembersRequest, 'type' | 'id'>) => {
+  queryMembers = (request?: Omit<QueryMembersRequest, 'type' | 'id'>) => {
     return this.streamClient.post<QueryMembersResponse, QueryMembersRequest>(
       '/call/members',
       {
-        ...request,
+        ...(request || {}),
         id: this.id,
         type: this.type,
       },

package/src/StreamVideoClient.ts

@@ -38,8 +38,7 @@ export class StreamVideoClient {
    * A reactive store that exposes all the state variables in a reactive manner - you can subscribe to changes of the different state variables. Our library is built in a way that all state changes are exposed in this store, so all UI changes in your application should be handled by subscribing to these variables.
    */
   readonly readOnlyStateStore: StreamVideoReadOnlyStateStore;
-  readonly user?: User;
-  readonly token?: TokenOrProvider;
+  readonly logLevel: LogLevel = 'warn';
   readonly logger: Logger;
 
   protected readonly writeableStateStore: StreamVideoWriteableStateStore;
@@ -109,17 +108,20 @@ export class StreamVideoClient {
             }.${sdkInfo.minor}.${sdkInfo.patch}`,
         );
       }
-      this.user = apiKeyOrArgs.user;
-      this.token = apiKeyOrArgs.token || apiKeyOrArgs.tokenProvider;
-      if (this.user) {
-        this.streamClient.startWaitingForConnection();
-      }
     }
 
     this.writeableStateStore = new StreamVideoWriteableStateStore();
     this.readOnlyStateStore = new StreamVideoReadOnlyStateStore(
       this.writeableStateStore,
     );
+
+    if (typeof apiKeyOrArgs !== 'string') {
+      const user = apiKeyOrArgs.user;
+      const token = apiKeyOrArgs.token || apiKeyOrArgs.tokenProvider;
+      if (user) {
+        this.connectUser(user, token);
+      }
+    }
   }
 
   /**
@@ -131,30 +133,30 @@ export class StreamVideoClient {
    * @param token a token or a function that returns a token.
    */
   async connectUser(
-    user?: User,
+    user: User,
     token?: TokenOrProvider,
   ): Promise<void | ConnectedEvent> {
-    const userToConnect = user || this.user;
-    const tokenToUse = token || this.token;
-    if (!userToConnect) {
-      throw new Error('Connect user is called without user');
-    }
-    if (userToConnect.type === 'anonymous') {
-      userToConnect.id = '!anon';
-      return this.connectAnonymousUser(userToConnect as UserWithId, tokenToUse);
+    if (user.type === 'anonymous') {
+      user.id = '!anon';
+      return this.connectAnonymousUser(user as UserWithId, token);
     }
-    if (userToConnect.type === 'guest') {
-      const response = await this.createGuestUser({
-        user: {
-          ...userToConnect,
-          role: 'guest',
-        },
-      });
-      return this.connectUser(response.user, response.access_token);
-    }
-    const connectUser = () => {
-      return this.streamClient.connectUser(userToConnect, tokenToUse);
+    let connectUser = () => {
+      return this.streamClient.connectUser(user, token);
     };
+    if (user.type === 'guest') {
+      connectUser = async () => {
+        const response = await this.createGuestUser({
+          user: {
+            ...user,
+            role: 'guest',
+          },
+        });
+        return this.streamClient.connectUser(
+          response.user,
+          response.access_token,
+        );
+      };
+    }
     this.connectionPromise = this.disconnectionPromise
       ? this.disconnectionPromise.then(() => connectUser())
       : connectUser();
@@ -199,7 +201,7 @@ export class StreamVideoClient {
       this.on('call.created', (event) => {
         if (event.type !== 'call.created') return;
         const { call, members } = event;
-        if (userToConnect.id === call.created_by.id) {
+        if (user.id === call.created_by.id) {
           this.logger(
             'warn',
             'Received `call.created` sent by the current user',
@@ -225,7 +227,7 @@ export class StreamVideoClient {
       this.on('call.ring', async (event) => {
         if (event.type !== 'call.ring') return;
         const { call, members } = event;
-        if (userToConnect.id === call.created_by.id) {
+        if (user.id === call.created_by.id) {
           this.logger(
             'debug',
             'Received `call.ring` sent by the current user so ignoring the event',
@@ -267,7 +269,7 @@ export class StreamVideoClient {
    *                https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent
    */
   disconnectUser = async (timeout?: number) => {
-    if (!this.streamClient.user) {
+    if (!this.streamClient.user && !this.connectionPromise) {
       return;
     }
     const disconnectUser = () => this.streamClient.disconnectUser(timeout);
@@ -338,7 +340,7 @@ export class StreamVideoClient {
    *
    * @param data the query data.
    */
-  queryCalls = async (data: QueryCallsRequest) => {
+  queryCalls = async (data: QueryCallsRequest = {}) => {
     const response = await this.streamClient.post<
       QueryCallsResponse,
       QueryCallsRequest

package/src/__tests__/StreamVideoClient.test.ts

@@ -2,20 +2,20 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { StreamVideoClient } from '../StreamVideoClient';
 import 'dotenv/config';
 import { generateUUIDv4 } from '../coordinator/connection/utils';
-import { WSConnectionFallback } from '../coordinator/connection/connection_fallback';
+import { StreamVideoServerClient } from '../StreamVideoServerClient';
 
 const apiKey = process.env.STREAM_API_KEY!;
-const tokenUrl = process.env.TOKEN_PROVIDER_URL!;
+const secret = process.env.STREAM_SECRET!;
 
 const tokenProvider = (userId: string) => {
+  const serverClient = new StreamVideoServerClient(apiKey, { secret });
   return async () => {
-    const url = new URL(tokenUrl);
-    url.searchParams.set('api_key', apiKey);
-    url.searchParams.set('user_id', userId);
-
-    const response = await fetch(url.toString());
-    const data = await response.json();
-    return data.token;
+    return new Promise<string>((resolve) => {
+      setTimeout(() => {
+        const token = serverClient.createToken(userId);
+        resolve(token);
+      }, 100);
+    });
   };
 };
 

package/src/__tests__/server-side/call-members.test.ts

@@ -0,0 +1,93 @@
+import 'dotenv/config';
+import { beforeAll, describe, expect, it, vi } from 'vitest';
+import { StreamVideoServerClient } from '../../StreamVideoServerClient';
+import { generateUUIDv4 } from '../../coordinator/connection/utils';
+import { Call } from '../../Call';
+
+const apiKey = process.env.STREAM_API_KEY!;
+const secret = process.env.STREAM_SECRET!;
+
+describe('call members API', () => {
+  let client: StreamVideoServerClient;
+  const callId = `call${generateUUIDv4()}`;
+  let call: Call;
+
+  beforeAll(() => {
+    client = new StreamVideoServerClient(apiKey, {
+      secret,
+      logLevel: 'error',
+    });
+
+    call = client.call('default', callId);
+  });
+
+  it('create with members', async () => {
+    const response = await call.getOrCreate({
+      data: {
+        created_by_id: 'john',
+        members: [{ user_id: 'john', role: 'admin' }, { user_id: 'jack' }],
+      },
+    });
+
+    expect(response.members[0].user_id).toBe('jack');
+    expect(response.members[1].user_id).toBe('john');
+    expect(response.members[1].role).toBe('admin');
+  });
+
+  it('add or update members', async () => {
+    const response = await call.updateCallMembers({
+      update_members: [
+        { user_id: 'sara' },
+        { user_id: 'jane', role: 'admin' },
+        { user_id: 'john', role: 'user' },
+      ],
+    });
+
+    expect(response.members[0].user_id).toBe('sara');
+    expect(response.members[1].user_id).toBe('jane');
+    expect(response.members[1].role).toBe('admin');
+    expect(response.members[2].user_id).toBe('john');
+    expect(response.members[2].role).toBe('user');
+  });
+
+  it('remove members', async () => {
+    const response = await call.updateCallMembers({
+      remove_members: ['sara'],
+    });
+
+    expect(response.duration).toBeDefined();
+  });
+
+  it('query members', async () => {
+    let response = await call.queryMembers();
+
+    let members = response.members;
+    expect(members.length).toBe(3);
+
+    const queryMembersReq = {
+      sort: [{ field: 'user_id', direction: 1 }],
+      limit: 2,
+    };
+    response = await call.queryMembers(queryMembersReq);
+
+    members = response.members;
+    expect(members.length).toBe(2);
+    expect(members[0].user_id).toBe('jack');
+    expect(members[1].user_id).toBe('jane');
+
+    response = await call.queryMembers({
+      ...queryMembersReq,
+      next: response.next,
+    });
+
+    expect(response.members.length).toBe(1);
+
+    response = await call.queryMembers({
+      filter_conditions: { role: { $eq: 'admin' } },
+    });
+    members = response.members;
+
+    expect(members.length).toBe(1);
+    members.forEach((m) => expect(m.role).toBe('admin'));
+  });
+});

package/src/__tests__/server-side/call-types.test.ts

@@ -0,0 +1,78 @@
+import 'dotenv/config';
+import { beforeAll, describe, expect, it } from 'vitest';
+import { StreamVideoServerClient } from '../../StreamVideoServerClient';
+import { generateUUIDv4 } from '../../coordinator/connection/utils';
+import { LogLevel } from '../../coordinator/connection/types';
+import { OwnCapability, RecordSettingsModeEnum } from '../../gen/coordinator';
+
+const apiKey = process.env.STREAM_API_KEY!;
+const secret = process.env.STREAM_SECRET!;
+
+describe('call types CRUD API', () => {
+  let client: StreamVideoServerClient;
+  const callTypeName = `calltype${generateUUIDv4()}`;
+
+  beforeAll(() => {
+    client = new StreamVideoServerClient(apiKey, {
+      secret,
+      logLevel: 'trace',
+      logger: (logLevel: LogLevel, message: string, ...args: unknown[]) => {
+        console.log(new Date().toISOString(), message, ...args);
+      },
+    });
+  });
+
+  it('create', async () => {
+    const createResponse = await client.createCallType({
+      name: callTypeName,
+      settings: {
+        audio: { mic_default_on: true, default_device: 'speaker' },
+      },
+      grants: {
+        admin: [
+          OwnCapability.SEND_AUDIO,
+          OwnCapability.SEND_VIDEO,
+          OwnCapability.MUTE_USERS,
+        ],
+        user: [OwnCapability.SEND_AUDIO, OwnCapability.SEND_VIDEO],
+      },
+    });
+
+    expect(createResponse.name).toBe(callTypeName);
+    expect(createResponse.settings.audio.mic_default_on).toBe(true);
+    expect(createResponse.settings.audio.default_device).toBe('speaker');
+    expect(createResponse.grants.admin).toBeDefined();
+    expect(createResponse.grants.user).toBeDefined();
+  });
+
+  it('read', async () => {
+    const readResponse = await client.getCallTypes();
+
+    expect(readResponse.call_types[callTypeName]).toContain({
+      name: callTypeName,
+    });
+  });
+
+  it('update', async () => {
+    const updateResponse = await client.updateCallType(callTypeName, {
+      settings: {
+        audio: { mic_default_on: false, default_device: 'earpiece' },
+        recording: {
+          mode: RecordSettingsModeEnum.DISABLED,
+        },
+      },
+    });
+
+    expect(updateResponse.settings.audio.mic_default_on).toBeFalsy();
+    expect(updateResponse.settings.audio.default_device).toBe('earpiece');
+    expect(updateResponse.settings.recording.mode).toBe(
+      RecordSettingsModeEnum.DISABLED,
+    );
+  });
+
+  it('delete', async () => {
+    await client.deleteCallType(callTypeName);
+
+    await expect(() => client.getCallType(callTypeName)).rejects.toThrowError();
+  });
+});

package/src/__tests__/server-side/call.test.ts

@@ -0,0 +1,147 @@
+import 'dotenv/config';
+import { beforeAll, describe, expect, it, vi } from 'vitest';
+import { StreamVideoServerClient } from '../../StreamVideoServerClient';
+import { generateUUIDv4 } from '../../coordinator/connection/utils';
+import { Call } from '../../Call';
+import {
+  RecordSettingsRequestModeEnum,
+  RecordSettingsRequestQualityEnum,
+} from '../../gen/coordinator';
+
+const apiKey = process.env.STREAM_API_KEY!;
+const secret = process.env.STREAM_SECRET!;
+
+describe('call API', () => {
+  let client: StreamVideoServerClient;
+  const callId = `call${generateUUIDv4()}`;
+  let call: Call;
+
+  beforeAll(() => {
+    client = new StreamVideoServerClient(apiKey, {
+      secret,
+      logLevel: 'error',
+    });
+
+    call = client.call('default', callId);
+  });
+
+  it('create', async () => {
+    const response = await call.getOrCreate({
+      data: { created_by_id: 'john' },
+    });
+
+    expect(response.call.created_by.id).toBe('john');
+  });
+
+  it('update', async () => {
+    const response = await call.update({
+      settings_override: {
+        audio: { mic_default_on: true, default_device: 'speaker' },
+      },
+      custom: { color: 'red' },
+    });
+
+    expect(response.call.settings.audio.mic_default_on).toBe(true);
+    expect(response.call.custom.color).toBe('red');
+  });
+
+  it('RTMP address', async () => {
+    const resp = await call.getOrCreate();
+    const address = resp.call.ingress.rtmp.address;
+
+    expect(address).toBeDefined();
+  });
+
+  it('query calls', async () => {
+    let response = await client.queryCalls();
+
+    let calls = response.calls;
+    expect(calls.length).toBeGreaterThanOrEqual(1);
+
+    const queryCallsReq = {
+      sort: [{ field: 'starts_at', direction: -1 }],
+      limit: 2,
+    };
+    response = await client.queryCalls(queryCallsReq);
+
+    calls = response.calls;
+    expect(calls.length).toBe(2);
+
+    response = await client.queryCalls({
+      ...queryCallsReq,
+      next: response.next,
+    });
+
+    expect(response.calls.length).toBeLessThanOrEqual(2);
+
+    response = await client.queryCalls({
+      filter_conditions: { backstage: { $eq: false } },
+    });
+
+    expect(response.calls.length).toBeGreaterThanOrEqual(1);
+  });
+
+  describe('recording', () => {
+    it('enable call recording', async () => {
+      let response = await call.update({
+        settings_override: {
+          recording: {
+            mode: RecordSettingsRequestModeEnum.DISABLED,
+          },
+        },
+      });
+      let settings = response.call.settings.recording;
+
+      expect(settings.mode).toBe(RecordSettingsRequestModeEnum.DISABLED);
+
+      response = await call.update({
+        settings_override: {
+          recording: {
+            mode: RecordSettingsRequestModeEnum.AVAILABLE,
+          },
+        },
+      });
+
+      settings = response.call.settings.recording;
+      expect(settings.mode).toBe(RecordSettingsRequestModeEnum.AVAILABLE);
+
+      response = await call.update({
+        settings_override: {
+          recording: {
+            audio_only: false,
+            quality: RecordSettingsRequestQualityEnum._1080P,
+          },
+        },
+      });
+
+      settings = response.call.settings.recording;
+      expect(settings.audio_only).toBe(false);
+      expect(settings.quality).toBe(RecordSettingsRequestQualityEnum._1080P);
+    });
+
+    it('start recording', async () => {
+      // somewhat dummy test, we should do a proper test in the future where we join a call and start recording
+      await expect(() => call.startRecording()).rejects.toThrowError(
+        'Stream error code 4: StartRecording failed with error: "cannot record inactive call"',
+      );
+    });
+
+    it('stop recording', async () => {
+      // somewhat dummy test, we should do a proper test in the future
+      await expect(() => call.stopRecording()).rejects.toThrowError(
+        'Stream error code 4: StopRecording failed with error: "call is not being recorded"',
+      );
+    });
+
+    it('query recordings', async () => {
+      // somewhat dummy test, we should do a proper test in the future
+      let response = await call.queryRecordings();
+
+      expect(response.recordings).toBeDefined();
+
+      response = await call.queryRecordings('session123');
+
+      expect(response.recordings).toBeDefined();
+    });
+  });
+});