@resolveio/server-lib 22.3.221 → 22.3.222

package/src/managers/websocket.manager.ts

@@ -1,746 +0,0 @@
-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');
-	}
-}