@peers-app/peers-sdk 0.27.4 → 0.27.5

package/dist/device/streamed-socket.js

@@ -1,255 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StreamedSocket = void 0;
-exports.createSocketStats = createSocketStats;
-const msgpack_1 = require("@msgpack/msgpack");
-const lodash_1 = require("lodash");
-const utils_1 = require("../utils");
-const socket_type_1 = require("./socket.type");
-const tx_encoding_1 = require("./tx-encoding");
-/** Creates a new stats object for tracking socket throughput */
-function createSocketStats() {
-    const now = Date.now();
-    return {
-        bytesSent: 0,
-        bytesReceived: 0,
-        messagesSent: 0,
-        messagesReceived: 0,
-        startTime: now,
-        // For calculating recent rates
-        lastSampleTime: now,
-        lastSampleBytesSent: 0,
-        lastSampleBytesReceived: 0,
-    };
-}
-// Encode chunk metadata + data into a single Uint8Array
-function encodeChunk(chunk) {
-    // Encode metadata using msgpack
-    const metadata = {
-        messageId: chunk.messageId,
-        chunkIndex: chunk.chunkIndex,
-        ...(chunk.totalChunks !== undefined && { totalChunks: chunk.totalChunks }),
-        ...(chunk.eventName !== undefined && { eventName: chunk.eventName }),
-    };
-    const metadataBytes = (0, msgpack_1.encode)(metadata);
-    const metadataLength = metadataBytes.length;
-    // Create combined buffer: [4 bytes length][metadata][data]
-    const combined = new Uint8Array(4 + metadataLength + chunk.data.length);
-    // Write metadata length as 32-bit unsigned integer (big-endian)
-    const view = new DataView(combined.buffer, combined.byteOffset, combined.byteLength);
-    view.setUint32(0, metadataLength, false); // big-endian
-    // Write metadata
-    combined.set(metadataBytes, 4);
-    // Write data
-    combined.set(chunk.data, 4 + metadataLength);
-    return combined;
-}
-// Decode binary chunk back into IMessageChunk
-function decodeChunk(bytes) {
-    // Ensure we have a proper Uint8Array with a valid ArrayBuffer
-    // Socket.io might send data that doesn't have a proper buffer property
-    let normalizedBytes;
-    if (bytes.buffer instanceof ArrayBuffer) {
-        normalizedBytes = bytes;
-    }
-    else {
-        // Create a new Uint8Array copy which will have a proper buffer
-        normalizedBytes = new Uint8Array(bytes);
-    }
-    // Read metadata length
-    const view = new DataView(normalizedBytes.buffer, normalizedBytes.byteOffset, normalizedBytes.byteLength);
-    const metadataLength = view.getUint32(0, false); // big-endian
-    // Extract metadata
-    const metadataBytes = normalizedBytes.subarray(4, 4 + metadataLength);
-    const metadata = (0, msgpack_1.decode)(metadataBytes);
-    // Extract data
-    const data = normalizedBytes.subarray(4 + metadataLength);
-    return {
-        messageId: metadata.messageId,
-        chunkIndex: metadata.chunkIndex,
-        totalChunks: metadata.totalChunks,
-        eventName: metadata.eventName,
-        data: data,
-    };
-}
-class StreamedSocket {
-    socket;
-    maxChunkSize;
-    safeSocketChunkEventName = "__streamed-socket-chunk";
-    safeSocketResponseEventName = "__streamed-socket-response";
-    stats = createSocketStats();
-    constructor(socket, maxChunkSize = socket_type_1.DEFAULT_MAX_CHUNK_SIZE) {
-        this.socket = socket;
-        this.maxChunkSize = maxChunkSize;
-        socket.on(this.safeSocketChunkEventName, (encodedChunk) => {
-            // Track received bytes
-            this.stats.bytesReceived += encodedChunk.length;
-            const chunk = decodeChunk(encodedChunk);
-            this.handleChunk(chunk);
-        });
-    }
-    get id() {
-        return this.socket.id;
-    }
-    get connected() {
-        return this.socket.connected;
-    }
-    disconnect(close) {
-        this.socket.disconnect(close);
-    }
-    callbacks = {};
-    emit(eventName, args, callback) {
-        const encoded = (0, tx_encoding_1.txEncode)(args);
-        // if (encoded.length < this.maxChunkSize) {
-        //   // If the data is small enough, send it directly
-        //   this.socket.emit(eventName, args, callback);
-        //   return;
-        // }
-        const messageId = (0, utils_1.newid)();
-        if (callback !== lodash_1.noop) {
-            this.callbacks[messageId] = callback;
-        }
-        const chunks = [];
-        // Reserve space for metadata overhead (typically ~50-100 bytes)
-        const metadataOverhead = 128;
-        if (this.maxChunkSize < metadataOverhead * 2) {
-            throw new Error(`maxChunkSize ${this.maxChunkSize} is too small to accommodate metadata overhead, must be greater than ${metadataOverhead * 2}`);
-        }
-        const effectiveChunkSize = this.maxChunkSize - metadataOverhead;
-        for (let i = 0; i < encoded.length; i += effectiveChunkSize) {
-            const chunkData = encoded.subarray(i, i + effectiveChunkSize);
-            chunks.push({
-                messageId,
-                chunkIndex: Math.floor(i / effectiveChunkSize),
-                data: chunkData,
-            });
-            if (i === 0) {
-                // The first chunk contains metadata about the chunks
-                chunks[0].eventName = eventName;
-                chunks[0].totalChunks = Math.ceil(encoded.length / effectiveChunkSize);
-            }
-        }
-        if (chunks.length > 1) {
-            console.debug(`Sending ${chunks.length} chunks for event ${eventName} with messageId ${messageId}`);
-        }
-        let totalBytesSent = 0;
-        for (const chunk of chunks) {
-            // Encode chunk with metadata into single Uint8Array
-            const encodedChunk = encodeChunk(chunk);
-            totalBytesSent += encodedChunk.length;
-            // TODO on error or timeout retry
-            // TODO respond to backpressure from socket
-            this.socket.emit(this.safeSocketChunkEventName, encodedChunk, lodash_1.noop);
-        }
-        // Track stats
-        this.stats.bytesSent += totalBytesSent;
-        this.stats.messagesSent++;
-    }
-    handlers = {};
-    on(eventName, handler) {
-        this.handlers[eventName] = handler;
-        // TODO I think this needs to come back to a handleResult method on this class
-        this.socket.on(eventName, handler);
-    }
-    removeAllListeners(eventName) {
-        this.socket.removeAllListeners(eventName);
-        delete this.handlers[eventName];
-    }
-    chunkBuffers = {};
-    async handleChunk(chunk) {
-        if (!this.chunkBuffers[chunk.messageId]) {
-            // TODO handle timeout for chunks and cleanup data to prevent memory leaks
-            this.chunkBuffers[chunk.messageId] = [];
-        }
-        const chunks = this.chunkBuffers[chunk.messageId];
-        const chunkIndex = chunk.chunkIndex;
-        if (chunkIndex < 0) {
-            console.warn(`Received chunk with negative index ${chunk.chunkIndex} for messageId: ${chunk.messageId}`, chunk);
-            return;
-        }
-        chunks[chunkIndex] = chunk;
-        const chunkZero = chunks[0];
-        if (!chunkZero && chunks.length > 100) {
-            console.error(`Received over 100 chunks without a chunkZero for messageId: ${chunk.messageId}. This could indicate a memory attack`, chunk);
-        }
-        if (chunkZero) {
-            if (chunkZero?.totalChunks <= chunkIndex) {
-                console.warn(`Received chunk with index ${chunk.chunkIndex} which is greater than totalChunks ${chunkZero.totalChunks} for messageId: ${chunk.messageId}`, chunk);
-                return;
-            }
-            if (chunks.length >= chunkZero.totalChunks) {
-                this.processChunks(chunks);
-            }
-        }
-    }
-    async processChunks(chunks) {
-        try {
-            const chunkZero = chunks[0];
-            // Reassemble Uint8Array chunks (already decoded from binary format)
-            const totalSize = chunks.reduce((sum, chunk) => sum + chunk.data.length, 0);
-            const reassembled = new Uint8Array(totalSize);
-            let offset = 0;
-            for (const chunk of chunks) {
-                reassembled.set(chunk.data, offset);
-                offset += chunk.data.length;
-            }
-            // Track message received
-            this.stats.messagesReceived++;
-            delete this.chunkBuffers[chunkZero.messageId];
-            const eventName = chunkZero.eventName;
-            const args = (0, tx_encoding_1.txDecode)(reassembled);
-            if (eventName === this.safeSocketResponseEventName) {
-                this.handleResponse(args.messageId, args.error, args.result);
-                return;
-            }
-            const handler = this.handlers[eventName];
-            if (!handler) {
-                throw new Error(`No handler registered for event ${eventName}`);
-            }
-            let error;
-            let result;
-            try {
-                await new Promise((resolve) => {
-                    handler(args, (...params) => {
-                        [error, result] = params;
-                        resolve();
-                    });
-                });
-            }
-            catch (err) {
-                error = err;
-            }
-            this.emit(this.safeSocketResponseEventName, {
-                messageId: chunkZero.messageId,
-                error,
-                result,
-            }, lodash_1.noop);
-        }
-        catch (error) {
-            if (String(error).includes("No handler registered for event")) {
-                console.warn(String(error));
-            }
-            else {
-                console.error(`Error handling chunked request:`, error);
-            }
-            return;
-        }
-    }
-    async handleResponse(messageId, error, result) {
-        const callback = this.callbacks[messageId];
-        if (!callback) {
-            console.warn(`No callback found for messageId ${messageId}`);
-        }
-        delete this.callbacks[messageId];
-        if (error) {
-            console.error(`Error in SafeSocket response for messageId ${messageId}:`, error);
-        }
-        try {
-            await callback(error, result);
-        }
-        catch (err) {
-            console.error(`Error in SafeSocket callback for messageId ${messageId}:`, err);
-        }
-    }
-}
-exports.StreamedSocket = StreamedSocket;