@stream-io/video-client 1.23.0 → 1.23.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "1.23.0",
+  "version": "1.23.2",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",
   "browser": "dist/index.browser.es.js",

package/src/devices/MicrophoneManager.ts

@@ -149,16 +149,6 @@ export class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManager
         // no filter registration in React Native, its done in the native code on app init
         this.noiseCancellationRegistration = Promise.resolve();
       } else {
-        // Krisp recommends disabling the browser's built-in noise cancellation
-        // and echo cancellation when using Krisp, so we do that here.
-        // https://sdk-docs.krisp.ai/docs/getting-started-js
-        this.setDefaultConstraints({
-          ...this.state.defaultConstraints,
-          echoCancellation: false,
-          noiseSuppression: false,
-          autoGainControl: false,
-        });
-
         const registrationResult = this.registerFilter(
           noiseCancellation.toFilter(),
         );

package/src/rpc/__tests__/createClient.test.ts

@@ -6,6 +6,8 @@ import {
   withRequestTracer,
 } from '../createClient';
 import { TwirpFetchTransport } from '@protobuf-ts/twirp-transport';
+import { NextUnaryFn, UnaryCall } from '@protobuf-ts/runtime-rpc';
+import { promiseWithResolvers } from '../../helpers/promise';
 
 describe('createClient', () => {
   it('should create a client with TwirpFetchTransport', () => {
@@ -28,9 +30,8 @@ describe('createClient', () => {
 
   it('withRequestLogger should log the request', () => {
     const logger = vi.fn();
-    const level = 'debug';
-    const interceptor = withRequestLogger(logger, level);
-    const next = vi.fn();
+    const interceptor = withRequestLogger(logger, 'debug');
+    const next = vi.fn().mockReturnValue({});
     // @ts-expect-error - private field
     interceptor.interceptUnary(next, { name: 'test' }, null, null);
     expect(next).toHaveBeenCalled();
@@ -40,7 +41,8 @@ describe('createClient', () => {
   it('withRequestTracer should add trace to the request', () => {
     const trace = vi.fn();
     const interceptor = withRequestTracer(trace);
-    const next = vi.fn();
+    // @ts-expect-error - partial implementation
+    const next: NextUnaryFn = vi.fn(() => ({ then: () => Promise.resolve() }));
     interceptor.interceptUnary(
       next,
       // @ts-expect-error - invalid name
@@ -52,25 +54,32 @@ describe('createClient', () => {
     expect(trace).toHaveBeenCalledWith('TestMethod', { param: 'value' });
   });
 
-  it('withRequestTracer should add an error trace', () => {
+  it('withRequestTracer should add a failure trace when the SFU returns an error', async () => {
     const trace = vi.fn();
     const interceptor = withRequestTracer(trace);
-    const err = new Error('test error');
-    const next = vi.fn(() => {
-      throw err;
-    });
-    expect(() =>
-      interceptor.interceptUnary(
-        next,
-        // @ts-expect-error - invalid name
-        { name: 'TestMethod' },
-        { param: 'value' },
-        { meta: {} },
-      ),
-    ).toThrow('test error');
-    expect(trace).toHaveBeenLastCalledWith('TestMethodOnFailure', [
+    const { promise, resolve } = promiseWithResolvers<UnaryCall['then']>();
+    // @ts-expect-error - partial implementation
+    const next = vi.fn<NextUnaryFn>(() => ({
+      // @ts-expect-error - incompatible type
+      then: (...args) => promise.then(...args),
+    }));
+    interceptor.interceptUnary(
+      next,
+      // @ts-expect-error - invalid name
+      { name: 'TestMethod' },
+      { param: 'value' },
+      { meta: {} },
+    );
+    expect(next).toHaveBeenCalled();
+
+    // @ts-expect-error - partial data
+    resolve({ response: { error: { msg: 'err' } } });
+    await promise;
+
+    expect(trace).toHaveBeenCalledWith('TestMethod', { param: 'value' });
+    expect(trace).toHaveBeenCalledWith('TestMethodOnFailure', [
+      { msg: 'err' },
       { param: 'value' },
-      err,
     ]);
   });
 });

package/src/rpc/createClient.ts

@@ -12,6 +12,7 @@ import {
 import { SignalServerClient } from '../gen/video/sfu/signal_rpc/signal.client';
 import { Logger, LogLevel } from '../coordinator/connection/types';
 import type { Trace } from '../stats';
+import type { SfuResponseWithError } from './retryable';
 
 const defaultOptions: TwirpOptions = {
   baseUrl: '',
@@ -49,16 +50,13 @@ export const withRequestLogger = (
       input: object,
       options: RpcOptions,
     ): UnaryCall => {
-      let invocation: UnaryCall | undefined;
-      try {
-        invocation = next(method, input, options);
-      } finally {
-        logger(level, `Invoked SFU RPC method ${method.name}`, {
-          request: invocation?.request,
-          headers: invocation?.requestHeaders,
-          response: invocation?.response,
-        });
-      }
+      const invocation = next(method, input, options);
+      logger(level, `Invoked SFU RPC method ${method.name}`, {
+        request: invocation.request,
+        headers: invocation.requestHeaders,
+        response: invocation.response,
+      });
+
       return invocation;
     },
   };
@@ -69,6 +67,9 @@ export const withRequestTracer = (trace: Trace): RpcInterceptor => {
     [K in keyof SignalServerClient as Capitalize<K>]: boolean;
   };
 
+  const traceError = (name: string, input: object, err: unknown) =>
+    trace(`${name}OnFailure`, [err, input]);
+
   const exclusions: Record<string, boolean | undefined> = {
     SendStats: true,
   } satisfies Partial<RpcMethodNames>;
@@ -82,13 +83,17 @@ export const withRequestTracer = (trace: Trace): RpcInterceptor => {
       if (exclusions[method.name as keyof RpcMethodNames]) {
         return next(method, input, options);
       }
-      try {
-        trace(method.name, input);
-        return next(method, input, options);
-      } catch (err) {
-        trace(`${method.name}OnFailure`, [input, err]);
-        throw err;
-      }
+
+      trace(method.name, input);
+      const unaryCall = next(method, input, options);
+      unaryCall.then(
+        (invocation) => {
+          const err = (invocation.response as SfuResponseWithError)?.error;
+          if (err) traceError(method.name, input, err);
+        },
+        (err) => traceError(method.name, input, err),
+      );
+      return unaryCall;
     },
   };
 };