@stream-io/video-client 0.1.5 → 0.1.6

package/dist/src/Call.d.ts

@@ -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

@@ -82,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/version.d.ts

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

package/package.json

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

package/src/Call.ts

@@ -1517,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

@@ -340,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();
+    });
+  });
+});

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

@@ -0,0 +1,44 @@
+import 'dotenv/config';
+import jwt from 'jsonwebtoken';
+import { beforeAll, describe, expect, it } from 'vitest';
+import { StreamVideoServerClient } from '../../StreamVideoServerClient';
+
+const apiKey = process.env.STREAM_API_KEY!;
+const secret = process.env.STREAM_SECRET!;
+
+describe('creating tokens', () => {
+  let client: StreamVideoServerClient;
+  const userId = 'john';
+
+  beforeAll(() => {
+    client = new StreamVideoServerClient(apiKey, {
+      secret,
+      logLevel: 'error',
+    });
+  });
+
+  it('with no expiration', () => {
+    const token = client.createToken(userId);
+    const decodedToken = jwt.verify(token, secret) as any;
+
+    expect(decodedToken.user_id).toBe(userId);
+  });
+
+  it('with expiration and issued at provided', () => {
+    const exp = Math.round(new Date().getTime() / 1000) + 60 * 60;
+    const iat = Math.round(new Date().getTime() / 1000);
+    const token = client.createToken(userId, exp, iat);
+    const decodedToken = jwt.verify(token, secret) as any;
+
+    expect(decodedToken.exp).toBe(exp);
+    expect(decodedToken.iat).toBe(iat);
+  });
+
+  it('with call IDs provided', () => {
+    const call_cids = ['default:call1', 'livestream:call2'];
+    const token = client.createToken(userId, undefined, undefined, call_cids);
+    const decodedToken = jwt.verify(token, secret) as any;
+
+    expect(decodedToken.call_cids).toEqual(call_cids);
+  });
+});

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

@@ -0,0 +1,28 @@
+import 'dotenv/config';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { StreamVideoServerClient } from '../../StreamVideoServerClient';
+
+const apiKey = process.env.STREAM_API_KEY!;
+const secret = process.env.STREAM_SECRET!;
+
+describe('server side user connect', () => {
+  let client: StreamVideoServerClient;
+
+  beforeEach(() => {
+    client = new StreamVideoServerClient(apiKey, {
+      browser: false,
+      secret,
+      allowServerSideConnect: true,
+    });
+  });
+
+  it('hold up API requests until connect is ready', async () => {
+    const userId = 'server-side-test';
+    const token = client.createToken(userId);
+    client.connectUser({ id: userId }, token);
+
+    const response = await client.queryCalls({});
+
+    expect(response).toBeDefined();
+  });
+});

package/src/coordinator/connection/client.ts

@@ -504,9 +504,6 @@ export class StreamClient {
         response,
       },
     );
-    this.logger('trace', `client:${type} - Response payload`, {
-      response,
-    });
   };
 
   _logApiError = (type: string, url: string, error: unknown) => {
@@ -562,9 +559,9 @@ export class StreamClient {
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
     } catch (e: any /**TODO: generalize error types  */) {
       e.client_request_id = requestConfig.headers?.['x-client-request-id'];
-      this._logApiError(type, url, e);
       this.consecutiveFailures += 1;
       if (e.response) {
+        this._logApiError(type, url, e.response);
         /** connection_fallback depends on this token expiration logic */
         if (
           e.response.data.code === KnownCodes.TOKEN_EXPIRED &&
@@ -578,6 +575,7 @@ export class StreamClient {
         }
         return this.handleResponse(e.response);
       } else {
+        this._logApiError(type, url, e);
         // eslint-disable-next-line no-throw-literal
         throw e as AxiosError<APIErrorResponse>;
       }

package/src/__tests__/StreamVideoServerClient.test.ts

@@ -1,110 +0,0 @@
-import { StreamVideoServerClient } from '../StreamVideoServerClient';
-import 'dotenv/config';
-import jwt from 'jsonwebtoken';
-import { beforeEach, describe, expect, it } from 'vitest';
-import { generateUUIDv4 } from '../coordinator/connection/utils';
-
-const apiKey = process.env.STREAM_API_KEY!;
-const secret = process.env.STREAM_SECRET!;
-
-describe('StreamVideoServerClient - docs snippets', () => {
-  let client: StreamVideoServerClient;
-
-  beforeEach(() => {
-    client = new StreamVideoServerClient(apiKey, {
-      secret,
-      // turn off
-      logger: () => {},
-    });
-  });
-
-  describe('creating tokens', () => {
-    const userId = 'john';
-
-    it('with no expiration', () => {
-      const token = client.createToken(userId);
-      const decodedToken = jwt.verify(token, secret) as any;
-
-      expect(decodedToken.user_id).toBe(userId);
-    });
-
-    it('with expiration and issued at provided', () => {
-      const exp = Math.round(new Date().getTime() / 1000) + 60 * 60;
-      const iat = Math.round(new Date().getTime() / 1000);
-      const token = client.createToken(userId, exp, iat);
-      const decodedToken = jwt.verify(token, secret) as any;
-
-      expect(decodedToken.exp).toBe(exp);
-      expect(decodedToken.iat).toBe(iat);
-    });
-
-    it('with call IDs provided', () => {
-      const call_cids = ['default:call1', 'livestream:call2'];
-      const token = client.createToken(userId, undefined, undefined, call_cids);
-      const decodedToken = jwt.verify(token, secret) as any;
-
-      expect(decodedToken.call_cids).toEqual(call_cids);
-    });
-  });
-
-  describe('call type CRUD API', () => {
-    const callTypeName = `calltype${generateUUIDv4()}`;
-
-    it('create', async () => {
-      const createResponse = await client.createCallType({
-        name: callTypeName,
-      });
-
-      expect(createResponse.name).toBe(callTypeName);
-    });
-
-    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' },
-        },
-      });
-
-      expect(updateResponse.settings.audio.mic_default_on).toBeFalsy();
-      expect(updateResponse.settings.audio.default_device).toBe('earpiece');
-    });
-
-    it('delete', async () => {
-      await client.deleteCallType(callTypeName);
-
-      await expect(() =>
-        client.getCallType(callTypeName),
-      ).rejects.toThrowError();
-    });
-  });
-});
-
-describe('StreamVideoServerClient - server side user connect', () => {
-  let client: StreamVideoServerClient;
-
-  beforeEach(() => {
-    client = new StreamVideoServerClient(apiKey, {
-      browser: false,
-      secret,
-      allowServerSideConnect: true,
-    });
-  });
-
-  it('hold up API requests until connect is ready', async () => {
-    const userId = 'server-side-test';
-    const token = client.createToken(userId);
-    client.connectUser({ id: userId }, token);
-
-    const response = await client.queryCalls({});
-
-    expect(response).toBeDefined();
-  });
-});