@resolveio/server-lib 22.3.219 → 22.3.221

package/src/managers/websocket.manager.ts

@@ -0,0 +1,746 @@
+import { randomBytes } from 'crypto';
+import { pack, unpack } from 'msgpackr';
+import { TextDecoder } from 'util';
+import { WebSocket } from 'ws';
+
+interface ServerResponseModel {
+	messageId: number;
+	hasError: boolean;
+	data: any;
+}
+
+interface PackedSendOptions {
+	passThrough?: boolean;
+}
+
+export class WebSocketManager {
+	private _mainServer;
+	private _messageBuffers: Map<string, ServerResponseModel[]> = new Map();
+	private _batchingTimers: Map<string, NodeJS.Timeout> = new Map();
+	private _maxMessageSize: number;
+	private _messageDelay: number;
+	private _webSockets: Map<string, WebSocket> = new Map();
+	private _chunkThresholdBytes: number;
+	private _chunkSizeBytes: number;
+	private readonly _chunkMetaFlag = '__chunked';
+	private _chunkingEnabled: boolean;
+	private readonly _textDecoder = new TextDecoder();
+	private _wsSendDebug = false;
+	private _wsSendLogThresholdMs = 2000;
+	private _wsSendLogBytes = 2 * 1024 * 1024;
+	private _wsSendLogBufferedBytes = 4 * 1024 * 1024;
+	private _packedChunkMinBytes = 64 * 1024;
+	private _sendQueues: Map<string, ServerResponseModel[][]> = new Map();
+	private _sendQueueTimers: Map<string, NodeJS.Timeout> = new Map();
+	private _sendThrottleMs = 0;
+	private _sendBackpressureBytes = 0;
+	private _sendMaxBatchesPerTick = 10;
+	private _aiWorkerDebug = false;
+	private _wsBackpressureLogAt: Map<string, number> = new Map();
+	private _wsBackpressureLogCooldownMs = 2000;
+
+	constructor() {}
+	
+	static create(mainServer, maxMessageSize: number = 256 * 1024, messageDelay: number = 25, chunkThresholdBytes: number = 512 * 1024, chunkSizeBytes: number = 1024 * 1024) {
+		const websocketManager = new WebSocketManager();
+		websocketManager.initialize(mainServer, maxMessageSize, messageDelay, chunkThresholdBytes, chunkSizeBytes);
+		return websocketManager;
+	}
+
+	public initialize(mainServer, maxMessageSize: number = 20480, messageDelay: number = 25, chunkThresholdBytes: number = 3 * 1024 * 1024, chunkSizeBytes: number = 4 * 1024 * 1024) {
+		this._mainServer = mainServer;
+		this._maxMessageSize = this.parsePositiveInt(process.env.WS_MAX_MESSAGE_SIZE_BYTES, maxMessageSize);
+		this._messageDelay = messageDelay;
+		this._chunkingEnabled = this.parseBoolean(process.env.WS_CHUNKING_ENABLED, true);
+		this._chunkThresholdBytes = this.parsePositiveInt(process.env.WS_CHUNK_THRESHOLD_BYTES, chunkThresholdBytes);
+		this._chunkSizeBytes = this.parsePositiveInt(process.env.WS_CHUNK_SIZE_BYTES, chunkSizeBytes);
+		this._wsSendDebug = this.parseDebugFlag(process.env.WS_SEND_DEBUG);
+		this._aiWorkerDebug = this.parseDebugFlag(process.env.AI_ASSISTANT_WORKER_DEBUG);
+		this._wsSendLogThresholdMs = this.parsePositiveInt(process.env.WS_SEND_LOG_THRESHOLD_MS, this._wsSendLogThresholdMs);
+		this._wsSendLogBytes = this.parsePositiveInt(process.env.WS_SEND_LOG_BYTES, this._wsSendLogBytes);
+		this._wsSendLogBufferedBytes = this.parsePositiveInt(process.env.WS_SEND_LOG_BUFFERED_BYTES, this._wsSendLogBufferedBytes);
+		const packedChunkFallback = Math.min(this._chunkThresholdBytes, this._packedChunkMinBytes);
+		const packedChunkRaw = process.env.WS_PACKED_CHUNK_MIN_BYTES;
+		this._packedChunkMinBytes = packedChunkRaw === '0'
+			? 0
+			: this.parsePositiveInt(packedChunkRaw, packedChunkFallback);
+		this._sendThrottleMs = this.parsePositiveInt(process.env.WS_SEND_THROTTLE_MS, this._sendThrottleMs);
+		const backpressureRaw = process.env.WS_SEND_BACKPRESSURE_BYTES;
+		if (backpressureRaw === '0') {
+			this._sendBackpressureBytes = 0;
+		}
+		else if (backpressureRaw === undefined || backpressureRaw === null || backpressureRaw === '') {
+			this._sendBackpressureBytes = this._wsSendLogBufferedBytes;
+		}
+		else {
+			this._sendBackpressureBytes = this.parsePositiveInt(backpressureRaw, this._sendBackpressureBytes);
+		}
+		this._sendMaxBatchesPerTick = this.parsePositiveInt(process.env.WS_SEND_MAX_BATCHES_PER_TICK, this._sendMaxBatchesPerTick);
+	}
+
+	private parseDebugFlag(value: any): boolean {
+		if (value === true) {
+			return true;
+		}
+
+		if (value === false || value === null || value === undefined) {
+			return false;
+		}
+
+		if (typeof value === 'number') {
+			return value === 1;
+		}
+
+		if (typeof value === 'string') {
+			const normalized = value.trim().toLowerCase();
+			return ['1', 'true', 'yes', 'y', 'on'].includes(normalized);
+		}
+
+		return false;
+	}
+
+	private parseBoolean(value: any, fallback: boolean): boolean {
+		if (value === null || value === undefined) {
+			return fallback;
+		}
+
+		return this.parseDebugFlag(value);
+	}
+
+	private parsePositiveInt(value: any, fallback: number): number {
+		const parsed = parseInt(value ?? '', 10);
+		if (Number.isNaN(parsed) || parsed <= 0) {
+			return fallback;
+		}
+		return parsed;
+	}
+
+	private isBackpressured(ws: WebSocket): boolean {
+		if (this._sendBackpressureBytes <= 0) {
+			return false;
+		}
+
+		const buffered = this.getBufferedAmount(ws);
+		return buffered !== null && buffered >= this._sendBackpressureBytes;
+	}
+
+	private shouldQueueSend(ws: WebSocket): boolean {
+		return this._sendThrottleMs > 0 || this.isBackpressured(ws);
+	}
+
+	private maybeLogBackpressure(ws: WebSocket, batchSize: number): void {
+		if (!this._aiWorkerDebug) {
+			return;
+		}
+		const wsId = ws ? ws['id_socket'] : null;
+		if (!wsId) {
+			return;
+		}
+		const now = Date.now();
+		const last = this._wsBackpressureLogAt.get(wsId) || 0;
+		if (now - last < this._wsBackpressureLogCooldownMs) {
+			return;
+		}
+		this._wsBackpressureLogAt.set(wsId, now);
+		const bufferedAmount = this.getBufferedAmount(ws);
+		const queueDepth = this._sendQueues.get(wsId)?.length ?? 0;
+		const backpressured = this.isBackpressured(ws);
+		const reason = backpressured ? 'backpressure' : (this._sendThrottleMs > 0 ? 'throttle' : 'queued');
+		console.warn(new Date(), '[AI Worker Debug] wsSendQueued', {
+			reason,
+			id_ws: wsId,
+			user: ws ? ws['user'] : null,
+			batchSize,
+			queueDepth,
+			bufferedAmount,
+			backpressureBytes: this._sendBackpressureBytes,
+			sendThrottleMs: this._sendThrottleMs
+		});
+	}
+
+	private getQueueDelayMs(ws: WebSocket): number {
+		if (this._sendThrottleMs > 0) {
+			return this._sendThrottleMs;
+		}
+
+		if (this.isBackpressured(ws)) {
+			return 25;
+		}
+
+		return 0;
+	}
+
+	private enqueueSend(ws: WebSocket, batch: ServerResponseModel[]): void {
+		if (!batch || !batch.length) {
+			return;
+		}
+
+		const wsId = ws['id_socket'];
+		let queue = this._sendQueues.get(wsId);
+		if (!queue) {
+			queue = [];
+			this._sendQueues.set(wsId, queue);
+		}
+
+		queue.push(batch);
+		this.maybeLogBackpressure(ws, batch.length);
+		this.scheduleSendDrain(ws);
+	}
+
+	private scheduleSendDrain(ws: WebSocket): void {
+		const wsId = ws['id_socket'];
+		if (this._sendQueueTimers.has(wsId)) {
+			return;
+		}
+
+		const delay = this.getQueueDelayMs(ws);
+		const timer = setTimeout(() => {
+			this._sendQueueTimers.delete(wsId);
+			this.drainSendQueue(ws);
+		}, delay);
+
+		this._sendQueueTimers.set(wsId, timer);
+	}
+
+	private drainSendQueue(ws: WebSocket): void {
+		const wsId = ws['id_socket'];
+		const queue = this._sendQueues.get(wsId);
+		if (!queue || !queue.length) {
+			this._sendQueues.delete(wsId);
+			return;
+		}
+
+		let sent = 0;
+		while (queue.length > 0 && sent < this._sendMaxBatchesPerTick && !this.isBackpressured(ws)) {
+			const batch = queue.shift();
+			if (batch && batch.length) {
+				this.transmitBatchNow(ws, batch);
+			}
+			sent += 1;
+		}
+
+		if (queue.length > 0) {
+			this.scheduleSendDrain(ws);
+		}
+		else {
+			this._sendQueues.delete(wsId);
+		}
+	}
+
+	private scheduleNextChunk(ws: WebSocket, next: () => void): void {
+		const wsId = ws['id_socket'];
+		const queueSize = this._sendQueues.get(wsId)?.length ?? 0;
+		const baseDelay = this.getQueueDelayMs(ws);
+		const delay = queueSize >= this._sendMaxBatchesPerTick ? Math.max(baseDelay, 25) : baseDelay;
+		if (delay > 0) {
+			setTimeout(next, delay);
+		}
+		else {
+			setImmediate(next);
+		}
+	}
+
+	private shouldLogSend(durationMs: number | null, totalBytes: number | null, bufferedAmount: number | null): boolean {
+		if (this._wsSendDebug) {
+			return true;
+		}
+
+		if (durationMs !== null && durationMs >= this._wsSendLogThresholdMs) {
+			return true;
+		}
+
+		if (totalBytes !== null && totalBytes >= this._wsSendLogBytes) {
+			return true;
+		}
+
+		if (bufferedAmount !== null && bufferedAmount >= this._wsSendLogBufferedBytes) {
+			return true;
+		}
+
+		return false;
+	}
+
+	private getBufferedAmount(ws: WebSocket): number | null {
+		if (!ws) {
+			return null;
+		}
+
+		const buffered = (ws as any).bufferedAmount;
+		return typeof buffered === 'number' ? buffered : null;
+	}
+
+	private logWsSend(event: string, ws: WebSocket, details: Record<string, any>): void {
+		if (!this._wsSendDebug) {
+			return;
+		}
+
+		const payload = Object.assign({
+			ts: new Date().toISOString(),
+			event,
+			id_ws: ws ? ws['id_socket'] : null,
+			user: ws ? ws['user'] : null
+		}, details);
+
+		console.log(JSON.stringify(payload));
+	}
+
+	public addWebSocket(ws: WebSocket): void {
+		const wsId = ws['id_socket'];
+		this._webSockets.set(wsId, ws);
+	}
+
+	private isSocketActive(ws: WebSocket): boolean {
+		if (!ws) {
+			return false;
+		}
+		return ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING;
+	}
+
+	public removeWebSocket(ws: WebSocket): void {
+		const wsId = ws['id_socket'];
+		this._webSockets.delete(wsId);
+		this._wsBackpressureLogAt.delete(wsId);
+		this.closeConnection(ws);
+	}
+
+	public getWebSocket(id_socket: string): WebSocket | undefined {
+		return this._webSockets.get(id_socket);
+	}
+
+	public getAllWebSockets(): WebSocket[] {
+		return Array.from(this._webSockets.values());
+	}
+
+	public getActiveWebSocketCount(): number {
+		return this.getAllWebSockets().filter(ws => this.isSocketActive(ws)).length;
+	}
+
+	public getUserWebSockets(id_user: string): WebSocket[] {
+		const targetUser = `${id_user || ''}`.trim();
+		if (!targetUser) {
+			return [];
+		}
+		return this.getAllWebSockets().filter(ws => this.isSocketActive(ws) && `${ws?.['id_user'] || ''}`.trim() === targetUser);
+	}
+
+	public send(ws: WebSocket, data: ServerResponseModel | string): void {
+		const wsId = ws['id_socket'];
+
+		if (!this._messageBuffers.has(wsId)) {
+			this._messageBuffers.set(wsId, []);
+		}
+
+		if (typeof data === 'string') {
+			if (ws && ws.readyState === WebSocket.OPEN) {
+				ws.send(data, (error) => {
+					if (error) {
+						this.handleSendError(ws, error);
+					}
+				});
+			}
+			return;
+		}
+		else {
+			// Handle string messages like 'ping' or 'pong'
+			const chunkContext = this.prepareChunkContext(data);
+			if (chunkContext) {
+				this.flushMessages(ws);
+				this.sendChunkSequence(ws, data, chunkContext);
+				return;
+			}
+
+			this._messageBuffers.get(wsId).push(data);
+		}
+
+		if (!this._batchingTimers.has(wsId)) {
+			// Set a timer to send the batch after a short delay
+			const timer = setTimeout(() => {
+				this.flushMessages(ws);
+			}, this._messageDelay);
+			this._batchingTimers.set(wsId, timer);
+		}
+	}
+
+	public sendPackedBuffer(
+		ws: WebSocket,
+		messageId: number,
+		hasError: boolean,
+		packedData: Uint8Array | Buffer,
+		encoding: 'msgpack' | 'json' = 'msgpack',
+		options: PackedSendOptions = {}
+	): void {
+		if (!ws || ws.readyState !== WebSocket.OPEN || !packedData || !packedData.byteLength) {
+			return;
+		}
+
+		const passThrough = !!options.passThrough;
+		const preferPackedChunk = this._packedChunkMinBytes > 0 && packedData.byteLength >= this._packedChunkMinBytes;
+		const canChunk = this._chunkingEnabled;
+		const shouldChunk = passThrough
+			? canChunk
+			: (canChunk && (packedData.byteLength > this._chunkThresholdBytes || preferPackedChunk));
+		if (!shouldChunk) {
+			const decoded = this.decodePackedPayload(packedData, encoding);
+			if (decoded !== undefined) {
+				this.send(ws, { messageId, hasError, data: decoded });
+				return;
+			}
+
+			if (!this._chunkingEnabled) {
+				return;
+			}
+		}
+
+		if (!canChunk) {
+			return;
+		}
+
+		const sendStartMs = Date.now();
+		const bufferedStart = this.getBufferedAmount(ws);
+		const chunkId = this.generateChunkId();
+		const totalChunks = Math.max(1, Math.ceil(packedData.byteLength / this._chunkSizeBytes));
+		const chunkSize = this._chunkSizeBytes;
+
+		if (this.shouldLogSend(null, packedData.byteLength, bufferedStart)) {
+			this.logWsSend('wsSendStart', ws, {
+				messageId,
+				totalBytes: packedData.byteLength,
+				totalChunks,
+				chunkSize,
+				encoding,
+				bufferedAmount: bufferedStart
+			});
+		}
+
+		// Flush any buffered messages so the chunk stream starts immediately.
+		this.flushMessages(ws);
+
+		const startMessage: ServerResponseModel = {
+			messageId: messageId,
+			hasError: hasError,
+			data: {
+				[this._chunkMetaFlag]: true,
+				chunkId: chunkId,
+				chunkStatus: 'start',
+				totalChunks: totalChunks,
+				totalBytes: packedData.byteLength,
+				chunkSize: chunkSize,
+				encoding: encoding
+			}
+		};
+
+		this.transmitBatch(ws, [startMessage]);
+
+		const sendChunk = (index: number) => {
+			if (!ws || ws.readyState !== WebSocket.OPEN) {
+				return;
+			}
+
+			if (index >= totalChunks) {
+				const endMessage: ServerResponseModel = {
+					messageId: messageId,
+					hasError: hasError,
+					data: {
+						[this._chunkMetaFlag]: true,
+						chunkId: chunkId,
+						chunkStatus: 'end'
+					}
+				};
+
+				this.transmitBatch(ws, [endMessage]);
+				const durationMs = Date.now() - sendStartMs;
+				const bufferedEnd = this.getBufferedAmount(ws);
+				if (this.shouldLogSend(durationMs, packedData.byteLength, bufferedEnd)) {
+					this.logWsSend('wsSendEnd', ws, {
+						messageId,
+						totalBytes: packedData.byteLength,
+						totalChunks,
+						chunkSize,
+						encoding,
+						durationMs,
+						bufferedAmount: bufferedEnd
+					});
+				}
+				return;
+			}
+
+			const start = index * chunkSize;
+			const end = Math.min(packedData.byteLength, start + chunkSize);
+			const slice = packedData.subarray(start, end);
+			const payload = encoding === 'msgpack' ? slice : this.toBase64(slice);
+
+			const chunkMessage: ServerResponseModel = {
+				messageId: messageId,
+				hasError: hasError,
+				data: {
+					[this._chunkMetaFlag]: true,
+					chunkId: chunkId,
+					chunkStatus: 'chunk',
+					chunkIndex: index,
+					payload: payload,
+					encoding: encoding
+				}
+			};
+
+			this.transmitBatch(ws, [chunkMessage]);
+
+			this.scheduleNextChunk(ws, () => sendChunk(index + 1));
+		};
+
+		this.scheduleNextChunk(ws, () => sendChunk(0));
+	}
+
+	private flushMessages(ws: WebSocket): void {
+		const wsId = ws['id_socket'];
+		const messages = this._messageBuffers.get(wsId);
+
+		if (messages && messages.length > 0) {
+			// Combine messages into one payload
+			this.transmitBatch(ws, messages);
+
+			this._messageBuffers.delete(wsId);
+			clearTimeout(this._batchingTimers.get(wsId));
+			this._batchingTimers.delete(wsId);
+		}
+	}
+
+	private sendMessagesInChunksBinary(ws: WebSocket, messages: ServerResponseModel[]): void {
+		let chunk: ServerResponseModel[] = [];
+		let chunkSize = 0;
+
+		for (const message of messages) {
+			const packedMessage = Buffer.from(<any>pack([message]));
+			const messageSize = packedMessage.byteLength;
+
+			if (chunkSize + messageSize > this._maxMessageSize) {
+				const packedChunk = Buffer.from(<any>pack(chunk));
+				ws.send(packedChunk, (error) => {
+					if (error) {
+						this.handleSendError(ws, error);
+					}
+				});
+
+				chunk = [message];
+				chunkSize = messageSize;
+			}
+			else {
+				chunk.push(message);
+				chunkSize += messageSize;
+			}
+		}
+
+		if (chunk.length > 0) {
+			const packedChunk = Buffer.from(<any>pack(chunk));
+			ws.send(packedChunk, (error) => {
+				if (error) {
+					this.handleSendError(ws, error);
+				}
+			});
+		}
+	}
+
+	private handleSendError(ws: WebSocket, error: Error): void {
+		if (this._mainServer.getSubscriptionManager()) {
+			// Handle send error, e.g., unsubscribe, close connection
+			if (this._mainServer.getSubscriptionManager().getEnableDebug()) {
+				console.log(new Date(), 'WebSocketManager', 'Unsub WS', ws['user'], ws['id_socket'], error);
+			}
+			this._mainServer.getSubscriptionManager().unsubscribeAll(ws);
+			this.removeWebSocket(ws);
+		}
+	}
+
+	public closeConnection(ws: WebSocket): void {
+		ws.close();
+		const wsId = ws['id_socket'];
+		// Clean up buffers and timers
+		this._messageBuffers.delete(wsId);
+		if (this._batchingTimers.has(wsId)) {
+			clearTimeout(this._batchingTimers.get(wsId));
+			this._batchingTimers.delete(wsId);
+		}
+		this._sendQueues.delete(wsId);
+		if (this._sendQueueTimers.has(wsId)) {
+			clearTimeout(this._sendQueueTimers.get(wsId));
+			this._sendQueueTimers.delete(wsId);
+		}
+		this._wsBackpressureLogAt.delete(wsId);
+        
+        process.nextTick(() => {
+            if ([WebSocket.OPEN, WebSocket.CLOSING].includes(<any>ws.readyState)) {
+                // Socket still hangs, hard close
+                ws.terminate();
+            }
+        });
+	}
+
+	private prepareChunkContext(message: ServerResponseModel): { buffer: Buffer, encoding: 'msgpack' | 'json' } | null {
+		if (!this._chunkingEnabled) {
+			return null;
+		}
+
+		if (!message || message.hasError) {
+			return null;
+		}
+
+		const data = message.data;
+		if (data === undefined || data === null) {
+			return null;
+		}
+
+		try {
+			const packed = Buffer.from(<any>pack(data));
+			if (packed.byteLength > this._chunkThresholdBytes) {
+				return { buffer: packed, encoding: 'msgpack' };
+			}
+		}
+		catch (err) {
+			if (this._mainServer.getSubscriptionManager()?.getEnableDebug()) {
+				console.log(new Date(), 'WebSocketManager', 'Chunking pack failed', err?.message || err);
+			}
+		}
+
+		return null;
+	}
+
+	private decodePackedPayload(packedData: Uint8Array | Buffer, encoding: 'msgpack' | 'json'): any | undefined {
+		try {
+			const source = packedData as Uint8Array;
+			if (encoding === 'msgpack') {
+				return unpack(source);
+			}
+
+			const text = this._textDecoder.decode(source);
+			return JSON.parse(text);
+		}
+		catch (err) {
+			if (this._mainServer.getSubscriptionManager()?.getEnableDebug()) {
+				console.log(new Date(), 'WebSocketManager', 'Packed decode failed', err?.message || err);
+			}
+			return undefined;
+		}
+	}
+
+	private sendChunkSequence(ws: WebSocket, original: ServerResponseModel, chunkContext: { buffer: Buffer, encoding: 'msgpack' | 'json' }): void {
+		const chunkId = this.generateChunkId();
+		const totalChunks = Math.ceil(chunkContext.buffer.byteLength / this._chunkSizeBytes);
+
+		const startMessage: ServerResponseModel = {
+			messageId: original.messageId,
+			hasError: original.hasError,
+			data: {
+				[this._chunkMetaFlag]: true,
+				chunkId: chunkId,
+				chunkStatus: 'start',
+				totalChunks: totalChunks,
+				totalBytes: chunkContext.buffer.byteLength,
+				chunkSize: this._chunkSizeBytes,
+				encoding: chunkContext.encoding
+			}
+		};
+
+		this.transmitBatch(ws, [startMessage]);
+
+		const sendChunk = (index: number) => {
+			if (!ws || ws.readyState !== WebSocket.OPEN) {
+				return;
+			}
+
+			if (index >= totalChunks) {
+				const endMessage: ServerResponseModel = {
+					messageId: original.messageId,
+					hasError: original.hasError,
+					data: {
+						[this._chunkMetaFlag]: true,
+						chunkId: chunkId,
+						chunkStatus: 'end'
+					}
+				};
+
+				this.transmitBatch(ws, [endMessage]);
+				return;
+			}
+
+			const start = index * this._chunkSizeBytes;
+			const end = Math.min(chunkContext.buffer.byteLength, start + this._chunkSizeBytes);
+			const slice = chunkContext.buffer.subarray(start, end);
+			const chunkPayload = slice;
+
+			const chunkMessage: ServerResponseModel = {
+				messageId: original.messageId,
+				hasError: original.hasError,
+				data: {
+					[this._chunkMetaFlag]: true,
+					chunkId: chunkId,
+					chunkStatus: 'chunk',
+					chunkIndex: index,
+					payload: chunkPayload,
+					encoding: chunkContext.encoding
+				}
+			};
+
+			this.transmitBatch(ws, [chunkMessage]);
+			this.scheduleNextChunk(ws, () => sendChunk(index + 1));
+		};
+
+		this.scheduleNextChunk(ws, () => sendChunk(0));
+	}
+
+	private transmitBatch(ws: WebSocket, batch: ServerResponseModel[]): void {
+		if (!batch || !batch.length) {
+			return;
+		}
+
+		const wsId = ws['id_socket'];
+		if (this.shouldQueueSend(ws) || this._sendQueues.has(wsId)) {
+			this.enqueueSend(ws, batch);
+			return;
+		}
+
+		this.transmitBatchNow(ws, batch);
+	}
+
+	private transmitBatchNow(ws: WebSocket, batch: ServerResponseModel[]): void {
+		if (!batch || !batch.length) {
+			return;
+		}
+
+		const isChunkEnvelope = batch.length === 1 && batch[0]?.data && typeof batch[0].data === 'object' && batch[0].data[this._chunkMetaFlag];
+
+		const packedData = Buffer.from(<any>pack(batch));
+		const dataSize = packedData.byteLength;
+		const bufferedAmount = this.getBufferedAmount(ws);
+
+		if (!isChunkEnvelope && dataSize > this._maxMessageSize) {
+			this.sendMessagesInChunksBinary(ws, batch);
+		}
+		else {
+			ws.send(packedData, (error) => {
+				if (error) {
+					this.handleSendError(ws, error);
+				}
+			});
+		}
+
+		if (this.shouldLogSend(null, dataSize, bufferedAmount)) {
+			this.logWsSend('wsBatchSend', ws, {
+				batchSize: batch.length,
+				dataSize,
+				isChunkEnvelope,
+				bufferedAmount
+			});
+		}
+	}
+
+	private generateChunkId(): string {
+		return randomBytes(8).toString('hex');
+	}
+
+	private toBase64(data: Uint8Array | Buffer): string {
+		if (Buffer.isBuffer(data)) {
+			return data.toString('base64');
+		}
+
+		return Buffer.from(data).toString('base64');
+	}
+}