@joystick.js/db-canary 0.0.0-canary.2251 → 0.0.0-canary.2252

package/src/server/lib/tcp_protocol.js

@@ -11,6 +11,49 @@ import create_logger from './logger.js';
 
 const { create_context_logger } = create_logger('tcp_protocol');
 
+/**
+ * Creates MessagePack encoding options for consistent serialization.
+ * @returns {Object} MessagePack encoding options
+ */
+const create_messagepack_options = () => ({
+  useFloat32: false,
+  int64AsType: 'number',
+  mapsAsObjects: true
+});
+
+/**
+ * Creates a 4-byte length header buffer.
+ * @param {number} data_length - Length of data to encode
+ * @returns {Buffer} Length header buffer
+ */
+const create_length_header = (data_length) => {
+  const length_buffer = Buffer.allocUnsafe(4);
+  length_buffer.writeUInt32BE(data_length, 0);
+  return length_buffer;
+};
+
+/**
+ * Logs message encoding details.
+ * @param {Function} log - Logger function
+ * @param {number} payload_size - Size of MessagePack payload
+ * @param {number} total_size - Total message size with header
+ */
+const log_message_encoding = (log, payload_size, total_size) => {
+  log.debug('Message encoded', {
+    payload_size,
+    total_size
+  });
+};
+
+/**
+ * Logs message encoding error.
+ * @param {Function} log - Logger function
+ * @param {Error} error - Encoding error
+ */
+const log_encoding_error = (log, error) => {
+  log.error('Failed to encode message', { error: error.message });
+};
+
 /**
  * Encodes a message with MessagePack and prepends a 4-byte length header.
  * @param {any} data - The data to encode
@@ -21,29 +64,120 @@ const encode_message = (data) => {
   const log = create_context_logger();
   
   try {
-    // NOTE: Use compatible MessagePack options to avoid parsing issues.
-    const messagepack_data = encode_messagepack(data, {
-      useFloat32: false,
-      int64AsType: 'number',
-      mapsAsObjects: true
-    });
-    const length_buffer = Buffer.allocUnsafe(4);
-    length_buffer.writeUInt32BE(messagepack_data.length, 0);
-    
+    const messagepack_data = encode_messagepack(data, create_messagepack_options());
+    const length_buffer = create_length_header(messagepack_data.length);
     const message = Buffer.concat([length_buffer, messagepack_data]);
     
-    log.debug('Message encoded', {
-      payload_size: messagepack_data.length,
-      total_size: message.length
-    });
+    log_message_encoding(log, messagepack_data.length, message.length);
     
     return message;
   } catch (error) {
-    log.error('Failed to encode message', { error: error.message });
+    log_encoding_error(log, error);
     throw error;
   }
 };
 
+/**
+ * Reads length prefix from buffer.
+ * @param {Buffer} buffer - Current buffer
+ * @returns {Object} Result with expected length and remaining buffer
+ */
+const read_length_prefix = (buffer) => {
+  if (buffer.length < 4) {
+    return { expected_length: null, remaining_buffer: buffer };
+  }
+  
+  const expected_length = buffer.readUInt32BE(0);
+  const remaining_buffer = buffer.slice(4);
+  
+  return { expected_length, remaining_buffer };
+};
+
+/**
+ * Logs length prefix reading.
+ * @param {Function} log - Logger function
+ * @param {number} expected_length - Expected message length
+ */
+const log_length_prefix_read = (log, expected_length) => {
+  log.debug('Length prefix read', { expected_length });
+};
+
+/**
+ * Extracts message data from buffer.
+ * @param {Buffer} buffer - Current buffer
+ * @param {number} expected_length - Expected message length
+ * @returns {Object} Result with message data and remaining buffer
+ */
+const extract_message_data = (buffer, expected_length) => {
+  const message_data = buffer.slice(0, expected_length);
+  const remaining_buffer = buffer.slice(expected_length);
+  
+  return { message_data, remaining_buffer };
+};
+
+/**
+ * Decodes MessagePack message data.
+ * @param {Buffer} message_data - Raw message data
+ * @returns {Object} Decoded message
+ * @throws {Error} When decoding fails
+ */
+const decode_message_data = (message_data) => {
+  return decode_messagepack(message_data, create_messagepack_options());
+};
+
+/**
+ * Logs successful message decoding.
+ * @param {Function} log - Logger function
+ * @param {number} message_size - Size of decoded message
+ */
+const log_message_decoding = (log, message_size) => {
+  log.debug('Message decoded', { message_size });
+};
+
+/**
+ * Logs message decoding error.
+ * @param {Function} log - Logger function
+ * @param {Buffer} message_data - Raw message data that failed to decode
+ * @param {Error} error - Decoding error
+ */
+const log_decoding_error = (log, message_data, error) => {
+  log.error('Failed to decode message', {
+    message_size: message_data.length,
+    error: error.message,
+    hex_data: message_data.toString('hex')
+  });
+};
+
+/**
+ * Processes complete message from buffer.
+ * @param {Buffer} buffer - Current buffer
+ * @param {number} expected_length - Expected message length
+ * @param {Function} log - Logger function
+ * @returns {Object} Result with decoded message and remaining buffer
+ * @throws {Error} When message decoding fails
+ */
+const process_complete_message = (buffer, expected_length, log) => {
+  const { message_data, remaining_buffer } = extract_message_data(buffer, expected_length);
+  
+  try {
+    const decoded_message = decode_message_data(message_data);
+    log_message_decoding(log, message_data.length);
+    
+    return { decoded_message, remaining_buffer };
+  } catch (error) {
+    log_decoding_error(log, message_data, error);
+    throw new Error(`Invalid message format: ${error.message}`);
+  }
+};
+
+/**
+ * Logs parser reset operation.
+ * @param {Function} log - Logger function
+ */
+const log_parser_reset = (log) => {
+  log.debug('Parser reset');
+};
+
 /**
  * Creates a message parser for handling TCP stream data with length-prefixed MessagePack messages.
  * @returns {Object} Parser object with parse_messages and reset methods
@@ -53,69 +187,40 @@ const create_message_parser = () => {
   let expected_length = null;
   const log = create_context_logger();
   
-  /**
-   * Parses incoming data and extracts complete messages.
-   * @param {Buffer} data - Raw TCP data
-   * @returns {Array} Array of decoded messages
-   * @throws {Error} When message format is invalid
-   */
   const parse_messages = (data) => {
     buffer = Buffer.concat([buffer, data]);
     const messages = [];
     
     while (buffer.length > 0) {
       if (expected_length === null) {
-        if (buffer.length < 4) {
+        const length_result = read_length_prefix(buffer);
+        expected_length = length_result.expected_length;
+        buffer = length_result.remaining_buffer;
+        
+        if (expected_length === null) {
           break;
         }
         
-        expected_length = buffer.readUInt32BE(0);
-        buffer = buffer.slice(4);
-        
-        log.debug('Length prefix read', { expected_length });
+        log_length_prefix_read(log, expected_length);
       }
       
       if (buffer.length < expected_length) {
         break;
       }
       
-      const message_data = buffer.slice(0, expected_length);
-      buffer = buffer.slice(expected_length);
+      const message_result = process_complete_message(buffer, expected_length, log);
+      messages.push(message_result.decoded_message);
+      buffer = message_result.remaining_buffer;
       expected_length = null;
-      
-      try {
-        // NOTE: Use compatible MessagePack options to avoid parsing issues.
-        const decoded_message = decode_messagepack(message_data, {
-          useFloat32: false,
-          int64AsType: 'number',
-          mapsAsObjects: true
-        });
-        messages.push(decoded_message);
-        
-        log.debug('Message decoded', {
-          message_size: message_data.length
-        });
-      } catch (error) {
-        log.error('Failed to decode message', {
-          message_size: message_data.length,
-          error: error.message,
-          hex_data: message_data.toString('hex')
-        });
-        
-        throw new Error(`Invalid message format: ${error.message}`);
-      }
     }
     
     return messages;
   };
   
-  /**
-   * Resets the parser state, clearing buffers and expected length.
-   */
   const reset = () => {
     buffer = Buffer.alloc(0);
     expected_length = null;
-    log.debug('Parser reset');
+    log_parser_reset(log);
   };
   
   return {