@nestjs/platform-ws 12.1.3 → 12.2.0

package/adapters/ws-adapter.d.ts

@@ -11,6 +11,20 @@ type WsMessageParser = (data: WsData) => {
 } | void;
 type WsAdapterOptions = {
     messageParser?: WsMessageParser;
+    /**
+     * How many messages a client may have handled at the same time. Later ones
+     * wait for their turn. Set it to `Infinity` to lift the limit.
+     *
+     * @default 1000
+     */
+    maxConcurrentMessages?: number;
+    /**
+     * How many bytes may be queued for a client that does not read what it is
+     * sent before it is disconnected. Set it to `0` to lift the limit.
+     *
+     * @default 134217728 (128 MB)
+     */
+    maxSendBufferSize?: number;
 };
 /**
  * @publicApi
@@ -21,6 +35,8 @@ export declare class WsAdapter extends AbstractWsAdapter {
     protected readonly wsServersRegistry: Map<number, WsServerRegistryEntry>;
     private readonly upgradeListenersRegistry;
     protected messageParser: WsMessageParser;
+    protected readonly maxConcurrentMessages: number;
+    protected readonly maxSendBufferSize: number;
     constructor(appOrHttpServer?: INestApplicationContext | object, options?: WsAdapterOptions);
     create(port: number, options?: Record<string, any> & {
         namespace?: string;
@@ -29,6 +45,15 @@ export declare class WsAdapter extends AbstractWsAdapter {
     }): any;
     bindMessageHandlers(client: any, handlers: MessageMappingProperties[], transform: (data: any) => Observable<any>): void;
     bindMessageHandler(buffer: any, handlersMap: Map<string, MessageMappingProperties>, transform: (data: any) => Observable<any>): Observable<any>;
+    /**
+     * Not reading from a client keeps it from asking for more, but what is
+     * already on its way to it still queues up: the replies to the messages
+     * being handled, values of Observables returned by handlers, and what
+     * exception filters send. This caps how much may be held for one client,
+     * like "maxSendBufferSize" of the TCP transport. Returns `false` once the
+     * client has been closed for exceeding it.
+     */
+    protected ensureSendBufferWithinLimit(client: any): boolean;
     bindErrorHandler(server: any): any;
     bindClientDisconnect(client: any, callback: Function): void;
     close(server: any): Promise<void>;

package/adapters/ws-adapter.js

@@ -3,9 +3,9 @@ import { AbstractWsAdapter } from '@nestjs/websockets';
 import * as http from 'http';
 import { createRequire } from 'module';
 import { EMPTY, fromEvent } from 'rxjs';
-import { catchError, filter, first, mergeMap, share, takeUntil, } from 'rxjs/operators';
+import { catchError, filter, first, share, takeUntil } from 'rxjs/operators';
 import { loadPackageSync, isNil, normalizePath } from '@nestjs/common/internal';
-import { CLOSE_EVENT, CONNECTION_EVENT, ERROR_EVENT, } from '@nestjs/websockets/internal';
+import { CLOSE_EVENT, CONNECTION_EVENT, DEFAULT_MAX_CONCURRENT_MESSAGES, ERROR_EVENT, mergeMapBounded, } from '@nestjs/websockets/internal';
 let wsPackage = {};
 var READY_STATE;
 (function (READY_STATE) {
@@ -15,11 +15,25 @@ var READY_STATE;
     READY_STATE[READY_STATE["CLOSED_STATE"] = 3] = "CLOSED_STATE";
 })(READY_STATE || (READY_STATE = {}));
 const UNDERLYING_HTTP_SERVER_PORT = 0;
+// Reading from a client stops while more than this is queued for it
+const SEND_BUFFER_HIGH_WATER_MARK = 1024 * 1024;
+const DEFAULT_MAX_SEND_BUFFER_SIZE = 128 * 1024 * 1024;
 // Kept out of the class so that an adapter can be compared against it to tell
 // whether the parser in use is still the built-in one.
 const defaultMessageParser = (data) => {
     return JSON.parse(data.toString());
 };
+// What ws answers on the servers it creates itself. A request left without an
+// answer keeps its connection open, and Node goes on queueing the requests
+// pipelined behind it until the heap runs out.
+const rejectNonUpgradeRequest = (_, res) => {
+    const body = http.STATUS_CODES[426];
+    res.writeHead(426, {
+        'Content-Length': body.length,
+        'Content-Type': 'text/plain',
+    });
+    res.end(body);
+};
 /**
  * @publicApi
  */
@@ -29,6 +43,8 @@ export class WsAdapter extends AbstractWsAdapter {
     wsServersRegistry = new Map();
     upgradeListenersRegistry = new Map();
     messageParser = defaultMessageParser;
+    maxConcurrentMessages;
+    maxSendBufferSize;
     constructor(appOrHttpServer, options) {
         super(appOrHttpServer);
         wsPackage = loadPackageSync('ws', 'WsAdapter', () => createRequire(import.meta.url)('ws'));
@@ -40,6 +56,10 @@ export class WsAdapter extends AbstractWsAdapter {
         if (options?.messageParser) {
             this.messageParser = options.messageParser;
         }
+        this.maxConcurrentMessages =
+            options?.maxConcurrentMessages ?? DEFAULT_MAX_CONCURRENT_MESSAGES;
+        this.maxSendBufferSize =
+            options?.maxSendBufferSize ?? DEFAULT_MAX_SEND_BUFFER_SIZE;
     }
     create(port, options) {
         const { server, path, ...wsOptions } = (options ?? {});
@@ -65,7 +85,9 @@ export class WsAdapter extends AbstractWsAdapter {
             // sharing a single HTTP/S server running on different port
             // than a regular HTTP application
             const httpServer = this.ensureHttpServerExists(port);
-            httpServer?.listen(port);
+            // ws listens with "host" and "backlog" only on a server it creates
+            // itself, and the one below has none (noServer)
+            httpServer?.listen(port, wsOptions.host, wsOptions.backlog);
             const wsServer = this.bindErrorHandler(new wsPackage.Server({
                 noServer: true,
                 ...wsOptions,
@@ -83,15 +105,47 @@ export class WsAdapter extends AbstractWsAdapter {
     bindMessageHandlers(client, handlers, transform) {
         const handlersMap = new Map();
         handlers.forEach(handler => handlersMap.set(handler.message, handler));
+        // ws reads everything a client sends, whether or not its messages can be
+        // handled yet and whether or not it reads the replies. Reading stops while
+        // messages wait for their turn, or while replies the client has not read
+        // pile up, and resumes once it has caught up.
+        let isBacklogged = false;
+        let pendingReplies = 0;
+        let isPaused = false;
+        const updatePaused = () => {
+            const shouldPause = isBacklogged ||
+                (pendingReplies > 0 &&
+                    client.bufferedAmount > SEND_BUFFER_HIGH_WATER_MARK);
+            if (shouldPause === isPaused) {
+                return;
+            }
+            isPaused = shouldPause;
+            if (isPaused) {
+                client.pause?.();
+            }
+            else {
+                client.resume?.();
+            }
+        };
         const close$ = fromEvent(client, CLOSE_EVENT).pipe(share(), first());
-        const source$ = fromEvent(client, 'message').pipe(mergeMap(data => this.bindMessageHandler(data, handlersMap, transform).pipe(filter(result => !isNil(result)), 
+        const source$ = fromEvent(client, 'message').pipe(
+        // ws still emits what a client sent before it got the close frame, e.g.
+        // after handleConnection() called client.close(). Like socket.io does
+        // for a disconnected socket, drop those instead of handling them.
+        filter(() => client.readyState === READY_STATE.OPEN_STATE), filter(() => this.ensureSendBufferWithinLimit(client)), 
+        // How many messages are pending at once is up to the client: ws emits
+        // all the messages of a read before any handler can settle.
+        mergeMapBounded(data => this.bindMessageHandler(data, handlersMap, transform).pipe(filter(result => !isNil(result)), 
         // a handler that rejects through an error filter that rethrows
         // would error the client's stream and silence every later message;
         // that rethrow is an app bug, so it gets logged, not dropped silently
         catchError(err => {
             this.logger.error(err);
             return EMPTY;
-        }))), takeUntil(close$));
+        })), this.maxConcurrentMessages, backlogged => {
+            isBacklogged = backlogged;
+            updatePaused();
+        }), takeUntil(close$));
         const onMessage = (response) => {
             if (client.readyState !== READY_STATE.OPEN_STATE) {
                 return;
@@ -108,7 +162,14 @@ export class WsAdapter extends AbstractWsAdapter {
                 this.logger.error(err);
                 return;
             }
-            client.send(payload);
+            pendingReplies++;
+            client.send(payload, () => {
+                pendingReplies--;
+                updatePaused();
+            });
+            if (this.ensureSendBufferWithinLimit(client)) {
+                updatePaused();
+            }
         };
         source$.subscribe(onMessage);
     }
@@ -147,6 +208,27 @@ export class WsAdapter extends AbstractWsAdapter {
             return EMPTY;
         }
     }
+    /**
+     * Not reading from a client keeps it from asking for more, but what is
+     * already on its way to it still queues up: the replies to the messages
+     * being handled, values of Observables returned by handlers, and what
+     * exception filters send. This caps how much may be held for one client,
+     * like "maxSendBufferSize" of the TCP transport. Returns `false` once the
+     * client has been closed for exceeding it.
+     */
+    ensureSendBufferWithinLimit(client) {
+        const bufferedAmount = client.bufferedAmount;
+        if (!this.maxSendBufferSize || !(bufferedAmount > this.maxSendBufferSize)) {
+            return true;
+        }
+        // The queue is dropped only once the socket has closed, so a client that
+        // is already closing is not closed and reported again
+        if (client.readyState === READY_STATE.OPEN_STATE) {
+            this.logger.warn(`Closing a client with ${bufferedAmount} bytes queued for it, more than "maxSendBufferSize" (${this.maxSendBufferSize})`);
+            client.terminate();
+        }
+        return false;
+    }
     bindErrorHandler(server) {
         server.on(CONNECTION_EVENT, (ws) => ws.on(ERROR_EVENT, (err) => this.logger.error(err)));
         server.on(ERROR_EVENT, (err) => this.logger.error(err));
@@ -184,7 +266,7 @@ export class WsAdapter extends AbstractWsAdapter {
     setMessageParser(parser) {
         this.messageParser = parser;
     }
-    ensureHttpServerExists(port, httpServer = http.createServer()) {
+    ensureHttpServerExists(port, httpServer = http.createServer(rejectNonUpgradeRequest)) {
         if (this.httpServersRegistry.has(port)) {
             return;
         }
@@ -209,6 +291,12 @@ export class WsAdapter extends AbstractWsAdapter {
                 }
             }
             catch (err) {
+                // Node hands the socket over without listeners of its own, and end()
+                // only half-closes it. A client resetting the connection afterwards
+                // would raise an unhandled 'error' event, and one that never closes
+                // would keep the socket open. ws's own abortHandshake() does the same.
+                socket.on(ERROR_EVENT, () => socket.destroy());
+                socket.once('finish', () => socket.destroy());
                 socket.end(`HTTP/1.1 400\r\n${err.message}`);
             }
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/platform-ws",
-  "version": "12.1.3",
+  "version": "12.2.0",
   "description": "Nest - modern, fast, powerful node.js web framework (@platform-ws)",
   "author": "Kamil Mysliwiec",
   "license": "MIT",
@@ -8,6 +8,7 @@
   "main": "./index.js",
   "exports": {
     ".": "./index.js",
+    "./package.json": "./package.json",
     "./*.js": "./*.js",
     "./*": "./*.js"
   },
@@ -33,5 +34,5 @@
     "@nestjs/websockets": "^12.0.0",
     "rxjs": "^7.1.0"
   },
-  "gitHead": "4514623279f6087808e3c8f08fbf9f37d3c17482"
+  "gitHead": "af37111368de7fd2dfab0bdec2f530c7845510c2"
 }