@joystick.js/db-canary 0.0.0-canary.2209

package/src/server/lib/safe_json_parse.js

@@ -0,0 +1,21 @@
+/**
+ * @fileoverview Safe JSON parsing utility with error handling.
+ * 
+ * Provides a safe wrapper around JSON.parse that returns null instead of throwing
+ * exceptions when parsing fails, useful for handling potentially malformed JSON data.
+ */
+
+/**
+ * Safely parses a JSON string, returning null if parsing fails.
+ * @param {string} json_string - JSON string to parse
+ * @returns {Object|null} Parsed object or null if parsing fails
+ */
+const safe_json_parse = (json_string) => {
+  try {
+    return JSON.parse(json_string);
+  } catch (error) {
+    return null;
+  }
+};
+
+export default safe_json_parse;

package/src/server/lib/send_response.js

@@ -0,0 +1,47 @@
+/**
+ * @fileoverview Response utilities for sending formatted messages to TCP clients.
+ * 
+ * Provides standardized functions for sending success, error, and message responses
+ * to clients over TCP connections using the MessagePack protocol format.
+ */
+
+import { encode_message } from './tcp_protocol.js';
+
+/**
+ * Sends a success response to the client.
+ * @param {net.Socket} socket - Client socket connection
+ * @param {Object} [data={}] - Response data to send
+ */
+export const send_success = (socket, data = {}) => {
+  const response = {
+    ok: true,
+    data: data
+  };
+  
+  const encoded_response = encode_message(response);
+  socket.write(encoded_response);
+};
+
+/**
+ * Sends an error response to the client.
+ * @param {net.Socket} socket - Client socket connection
+ * @param {Object} [error={}] - Error information to send
+ */
+export const send_error = (socket, error = {}) => {
+  const response = {
+    ok: false,
+    error: error
+  };
+  
+  const encoded_response = encode_message(response);
+  socket.write(encoded_response);
+};
+
+/**
+ * Sends a simple message response to the client.
+ * @param {net.Socket} socket - Client socket connection
+ * @param {string} [message=''] - Message to send
+ */
+export const send_message = (socket, message = '') => {
+  send_success(socket, { message: message });
+};

package/src/server/lib/tcp_protocol.js

@@ -0,0 +1,130 @@
+/**
+ * @fileoverview TCP protocol handling for MessagePack-based client-server communication.
+ * 
+ * Provides message encoding/decoding with length-prefixed MessagePack format,
+ * stream parsing for TCP data, and error handling for protocol communication.
+ * Ensures compatibility between client and server message formats.
+ */
+
+import { encode as encode_messagepack, decode as decode_messagepack } from 'msgpackr';
+import create_logger from './logger.js';
+
+const { create_context_logger } = create_logger('tcp_protocol');
+
+/**
+ * Encodes a message with MessagePack and prepends a 4-byte length header.
+ * @param {any} data - The data to encode
+ * @returns {Buffer} The encoded message with length header
+ * @throws {Error} When encoding fails
+ */
+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 message = Buffer.concat([length_buffer, messagepack_data]);
+    
+    log.debug('Message encoded', {
+      payload_size: messagepack_data.length,
+      total_size: message.length
+    });
+    
+    return message;
+  } catch (error) {
+    log.error('Failed to encode message', { error: error.message });
+    throw error;
+  }
+};
+
+/**
+ * Creates a message parser for handling TCP stream data with length-prefixed MessagePack messages.
+ * @returns {Object} Parser object with parse_messages and reset methods
+ */
+const create_message_parser = () => {
+  let buffer = Buffer.alloc(0);
+  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) {
+          break;
+        }
+        
+        expected_length = buffer.readUInt32BE(0);
+        buffer = buffer.slice(4);
+        
+        log.debug('Length prefix read', { expected_length });
+      }
+      
+      if (buffer.length < expected_length) {
+        break;
+      }
+      
+      const message_data = buffer.slice(0, expected_length);
+      buffer = buffer.slice(expected_length);
+      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');
+  };
+  
+  return {
+    parse_messages,
+    reset
+  };
+};
+
+export {
+  encode_message,
+  create_message_parser
+};