Use result type for websocket stream

.changeset/cool-tips-smoke.md

@@ -0,0 +1,5 @@
+---
+"livekit-client": patch
+---
+
+Use result type for websocket stream

eslint.config.mjs

@@ -2,6 +2,7 @@
 import js from '@eslint/js';
 import { configs, plugins, rules } from 'eslint-config-airbnb-extended';
 import { rules as prettierConfigRules } from 'eslint-config-prettier';
+import neverthrowMustUse from 'eslint-plugin-neverthrow-must-use';
 import prettierPlugin from 'eslint-plugin-prettier';
 
 const strictness = 'off';
@@ -31,6 +32,15 @@ const typescriptConfig = [
   rules.typescript.typescriptEslintStrict,
 ];
 
+const neverthrowConfig = [
+  {
+    name: 'neverthrow-must-use',
+    plugins: {
+      'neverthrow-must-use': neverthrowMustUse,
+    },
+  },
+];
+
 const prettierConfig = [
   // Prettier Plugin
   {
@@ -56,6 +66,7 @@ export default [
   ...typescriptConfig,
   // Prettier Config
   ...prettierConfig,
+  ...neverthrowConfig,
   {
     languageOptions: {
       parserOptions: {
@@ -158,6 +169,7 @@ export default [
       'one-var': strictness,
       'no-multi-assign': strictness,
       'new-cap': strictness,
+      'require-yield': strictness,
 
       radix: strictness,
       eqeqeq: strictness,

package.json

@@ -60,6 +60,7 @@
     "events": "^3.3.0",
     "jose": "^6.1.0",
     "loglevel": "^1.9.2",
+    "neverthrow": "^8.2.0",
     "sdp-transform": "^2.15.0",
     "ts-debounce": "^4.0.0",
     "tslib": "2.8.1",
@@ -96,6 +97,7 @@
     "eslint-config-prettier": "10.1.8",
     "eslint-plugin-compat": "^6.0.2",
     "eslint-plugin-import-x": "^4.16.1",
+    "eslint-plugin-neverthrow-must-use": "^0.1.2",
     "eslint-plugin-prettier": "^5.5.4",
     "gh-pages": "6.3.0",
     "happy-dom": "^17.2.0",

src/api/SignalClient.test.ts

@@ -6,10 +6,11 @@ import {
   SignalRequest,
   SignalResponse,
 } from '@livekit/protocol';
+import { ResultAsync } from 'neverthrow';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { ConnectionError, ConnectionErrorReason } from '../room/errors';
 import { SignalClient, SignalConnectionState } from './SignalClient';
-import type { WebSocketCloseInfo, WebSocketConnection } from './WebSocketStream';
+import type { WebSocketCloseInfo, WebSocketConnection, WebSocketError } from './WebSocketStream';
 import { WebSocketStream } from './WebSocketStream';
 
 // Mock the WebSocketStream
@@ -58,16 +59,27 @@ function createMockConnection(readable: ReadableStream<ArrayBuffer>): WebSocketC
 
 interface MockWebSocketStreamOptions {
   connection?: WebSocketConnection;
-  opened?: Promise<WebSocketConnection>;
-  closed?: Promise<WebSocketCloseInfo>;
+  opened?: ResultAsync<WebSocketConnection<ArrayBuffer>, WebSocketError>;
+  closed?: ResultAsync<WebSocketCloseInfo, WebSocketError>;
   readyState?: number;
 }
 
 function mockWebSocketStream(options: MockWebSocketStreamOptions = {}) {
   const {
     connection,
-    opened = connection ? Promise.resolve(connection) : new Promise(() => {}),
-    closed = new Promise(() => {}),
+    // eslint-disable-next-line neverthrow-must-use/must-use-result
+    opened = connection
+      ? ResultAsync.fromPromise(Promise.resolve(connection), (error) => ({
+          type: 'connection' as const,
+          error: error as Event,
+        }))
+      : // eslint-disable-next-line neverthrow-must-use/must-use-result
+        ResultAsync.fromPromise(new Promise(() => {}), (error) => ({
+          type: 'connection' as const,
+          error: error as Event,
+        })),
+    // eslint-disable-next-line neverthrow-must-use/must-use-result
+    closed = ResultAsync.fromPromise(new Promise(() => {}), (error) => error as WebSocketError),
     readyState = 1,
   } = options;
 
@@ -197,8 +209,8 @@ describe('SignalClient.connect', () => {
 
         return {
           url: 'wss://test.livekit.io',
-          opened: new Promise(() => {}), // Never resolves
-          closed: new Promise(() => {}),
+          opened: ResultAsync.fromPromise(new Promise(() => {}), (e) => e as WebSocketError), // Never resolves
+          closed: ResultAsync.fromPromise(new Promise(() => {}), (e) => e as WebSocketError),
           close: vi.fn(),
           readyState: 0,
         } as any;
@@ -253,10 +265,20 @@ describe('SignalClient.connect', () => {
       };
 
       vi.mocked(WebSocketStream).mockImplementation(() => {
+        // eslint-disable-next-line neverthrow-must-use/must-use-result
+        const opened = ResultAsync.fromPromise(Promise.resolve(mockConnection), (error) => ({
+          type: 'connection' as const,
+          error: error as Event,
+        }));
+        // eslint-disable-next-line neverthrow-must-use/must-use-result
+        const closed = ResultAsync.fromPromise(
+          new Promise(() => {}),
+          (error) => error as WebSocketError,
+        );
         return {
           url: 'wss://test.livekit.io',
-          opened: Promise.resolve(mockConnection),
-          closed: new Promise(() => {}),
+          opened,
+          closed,
           close: vi.fn(),
           readyState: 1,
         } as any;
@@ -301,7 +323,10 @@ describe('SignalClient.connect', () => {
   describe('Failure Case - WebSocket Connection Errors', () => {
     it('should reject with NotAllowed error for 4xx HTTP status', async () => {
       mockWebSocketStream({
-        opened: Promise.reject(new Error('Connection failed')),
+        opened: ResultAsync.fromPromise(
+          Promise.reject(new Error('Connection failed')),
+          (e) => e as WebSocketError,
+        ),
         readyState: 3,
       });
 
@@ -322,7 +347,10 @@ describe('SignalClient.connect', () => {
 
     it('should reject with ServerUnreachable when fetch fails', async () => {
       mockWebSocketStream({
-        opened: Promise.reject(new Error('Connection failed')),
+        opened: ResultAsync.fromPromise(
+          Promise.reject(new Error('Connection failed')),
+          (e) => e as WebSocketError,
+        ),
         readyState: 3,
       });
 
@@ -337,24 +365,26 @@ describe('SignalClient.connect', () => {
     });
 
     it('should handle ConnectionError from WebSocket rejection', async () => {
-      const customError = ConnectionError.internal('Custom error', { status: 500 });
+      const customError = ConnectionError.websocket('Custom error');
 
       mockWebSocketStream({
-        opened: Promise.reject(customError),
+        opened: ResultAsync.fromPromise(Promise.reject(customError), (e) => e as WebSocketError),
         readyState: 3,
       });
 
       // Mock fetch to return 500
       (global.fetch as any).mockResolvedValueOnce({
-        status: 500,
-        text: async () => 'Internal Server Error',
+        status: 200,
+        text: async () => 'ok',
       });
 
-      await expect(
-        signalClient.join('wss://test.livekit.io', 'test-token', defaultOptions),
-      ).rejects.toMatchObject({
-        reason: ConnectionErrorReason.InternalError,
-      });
+      const error = await signalClient
+        .join('wss://test.livekit.io', 'test-token', defaultOptions)
+        .catch((e) => e);
+
+      expect(error).toBeInstanceOf(ConnectionError);
+      expect(error.message).toBe('Custom error');
+      expect(error.reason).toBe(ConnectionErrorReason.WebSocket);
     });
   });
 
@@ -435,10 +465,13 @@ describe('SignalClient.connect', () => {
           closedResolve({ closeCode: 1006, reason: 'Connection lost' });
         });
 
+        // eslint-disable-next-line neverthrow-must-use/must-use-result
+        const closed = ResultAsync.fromPromise(closedPromise, (e) => e as WebSocketError);
+
         return {
           url: 'wss://test.livekit.io',
-          opened: new Promise(() => {}), // Never resolves
-          closed: closedPromise,
+          opened: ResultAsync.fromPromise(new Promise(() => {}), (e) => e as WebSocketError), // Never resolves
+          closed: closed,
           close: vi.fn(),
           readyState: 2, // CLOSING
         } as any;
@@ -448,7 +481,7 @@ describe('SignalClient.connect', () => {
         signalClient.join('wss://test.livekit.io', 'test-token', defaultOptions),
       ).rejects.toMatchObject({
         message: 'Websocket got closed during a (re)connection attempt: Connection lost',
-        reason: ConnectionErrorReason.InternalError,
+        reason: ConnectionErrorReason.WebSocket,
       });
     });
   });