@voltkit-rtc/client 0.7.0 → 0.7.2

package/src/chat.ts

@@ -93,6 +93,8 @@ interface Pending {
   resolve: (v: unknown) => void;
   reject: (e: Error) => void;
   timer: ReturnType<typeof setTimeout>;
+  /** The socket it was sent on: only that socket can answer it. */
+  ws: WebSocket;
 }
 
 const RPC_TIMEOUT_MS = 15_000;
@@ -112,6 +114,11 @@ export class ChatClient {
   private token: string;
   private joinResult: ChatJoinResult | null = null;
   private closedByUs = false;
+  /**
+   * Bumped by close(). A connect() under way when it ran -- the app's, or a
+   * reconnect's -- sees the change after its await and stops.
+   */
+  private lifecycle = 0;
   private reconnecting = false;
   private reconnectAttempt = 0;
   /** Set by the first successful join. Only a session that has joined is reconnected. */
@@ -147,15 +154,23 @@ export class ChatClient {
   }
 
   async connect(): Promise<ChatJoinResult> {
+    const lifecycle = this.lifecycle;
     let result: ChatJoinResult;
+    // The socket this call opens. A later connect() replaces it, and this
+    // call's failure must then leave the newer socket alone.
+    let socket: WebSocket | null = null;
     try {
-      await this.openSocket();
+      const opening = this.openSocket();
+      socket = this.ws;
+      await opening;
       result = (await this.rpc('join', { token: this.token })) as ChatJoinResult;
+      if (lifecycle !== this.lifecycle) throw new Error('the chat was closed while connecting');
     } catch (err) {
       // Never joined: the app has the error. Left open, the socket would be
       // closed by the server's join deadline, and that would start
       // reconnecting a session that never began.
-      if (!this.joinedOnce) this.detachSocket();
+      const superseded = this.ws !== null && this.ws !== socket;
+      if (!this.joinedOnce && !superseded) this.detachSocket();
       throw err;
     }
     // Joined: the next drop gets every reconnect attempt again. Not when the
@@ -203,16 +218,30 @@ export class ChatClient {
     });
   }
 
-  private detachSocket(): void {
+  private detachSocket(reason = 'superseded', why = 'the connection was replaced'): void {
     const ws = this.ws;
     this.ws = null;
-    if (ws && ws.readyState <= WebSocket.OPEN) {
+    if (!ws) return;
+    if (ws.readyState <= WebSocket.OPEN) {
       try {
-        ws.close(1000, 'superseded');
+        ws.close(1000, reason);
       } catch {
         /* already closing */
       }
     }
+    // Its replies are no longer read: what waits on it fails now instead of
+    // waiting out its timeout. Never replayed.
+    this.failPending(ws, new Error(why));
+  }
+
+  /**
+   * A reconnect that ends the session lets go of its socket: a refused join
+   * leaves it open, and it would otherwise stay attached, and sending, after
+   * closed.
+   */
+  private releaseSocket(): void {
+    this.detachSocket('gave up', 'the chat has ended');
+    this.failAllPending(new Error('the chat has ended'));
   }
 
   /** Single-flight, with backoff: the same shape as the room client's. */
@@ -224,6 +253,7 @@ export class ChatClient {
         this.reconnectAttempt += 1;
         if (this.reconnectAttempt > MAX_RECONNECT_ATTEMPTS) {
           this.emit('error', new Error(`gave up after ${MAX_RECONNECT_ATTEMPTS} reconnect attempts`));
+          this.releaseSocket();
           this.closedByUs = true;
           this.emit('closed', 'gave-up');
           return;
@@ -235,11 +265,15 @@ export class ChatClient {
           await this.connect();
           return;
         } catch (err) {
+          // Closed while this attempt was under way, and that has been
+          // reported: nothing follows closed.
+          if (this.closedByUs) return;
           this.emit('error', err as Error);
           // A token that is wrong will be wrong next time too, and an account
           // that ran out stays out until topped up: the registry's terminal
           // codes, shared with StreamClient. Retrying only adds noise.
           if (err instanceof ChatRpcError && isTerminalError(err.code)) {
+            this.releaseSocket();
             this.closedByUs = true;
             this.emit('closed', 'gave-up');
             return;
@@ -252,12 +286,20 @@ export class ChatClient {
   }
 
   close(): void {
-    if (this.closedByUs) return;
+    // Whatever socket is held is released even when the session has already
+    // ended: one opened by a connect() after an earlier close() would
+    // otherwise be out of reach. `closed` is still reported once.
+    const wasOpen = !this.closedByUs;
     this.closedByUs = true;
+    this.lifecycle += 1;
     const ws = this.ws;
     this.ws = null;
     ws?.close(1000, 'client closed');
-    this.emit('closed', 'left');
+    // Detached first, so the socket's own close handler no longer fails what
+    // was waiting on it: done here, or a join or a send in flight would wait
+    // out its 15 s timeout.
+    this.failAllPending(new Error('the chat was closed'));
+    if (wasOpen) this.emit('closed', 'left');
   }
 
   private rpc(method: string, params: unknown = {}): Promise<unknown> {
@@ -271,11 +313,21 @@ export class ChatClient {
         this.pending.delete(id);
         reject(new Error(`${method} timed out`));
       }, RPC_TIMEOUT_MS);
-      this.pending.set(id, { resolve, reject, timer });
+      this.pending.set(id, { resolve, reject, timer, ws: this.ws });
       this.ws.send(JSON.stringify({ id, method, params }));
     });
   }
 
+  /** Fail what was sent on `ws` and is still waiting. */
+  private failPending(ws: WebSocket, err: Error): void {
+    for (const [id, p] of this.pending) {
+      if (p.ws !== ws) continue;
+      clearTimeout(p.timer);
+      this.pending.delete(id);
+      p.reject(err);
+    }
+  }
+
   private failAllPending(err: Error): void {
     for (const p of this.pending.values()) {
       clearTimeout(p.timer);
@@ -291,6 +343,9 @@ export class ChatClient {
     } catch {
       return;
     }
+    // Valid JSON that is not a message object ("null" would throw below) is
+    // ignored like any other frame that is not a message.
+    if (typeof msg !== 'object' || msg === null) return;
     if (typeof msg.id === 'number') {
       const p = this.pending.get(msg.id);
       if (!p) return;