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

package/src/server/lib/operation_dispatcher.js

@@ -26,6 +26,35 @@ import admin_operation from './operations/admin.js';
 
 const { create_context_logger } = create_logger('operation_dispatcher');
 
+/**
+ * Checks if database name exceeds length limit.
+ * @param {string} database_name - Database name to check
+ * @returns {boolean} True if name exceeds limit
+ */
+const exceeds_length_limit = (database_name) => {
+  return database_name.length > 64;
+};
+
+/**
+ * Checks if database name is reserved.
+ * @param {string} database_name - Database name to check
+ * @returns {boolean} True if name is reserved
+ */
+const is_reserved_database_name = (database_name) => {
+  const reserved_names = ['admin', 'config', 'local'];
+  return reserved_names.includes(database_name.toLowerCase());
+};
+
+/**
+ * Checks if database name follows naming convention.
+ * @param {string} database_name - Database name to check
+ * @returns {boolean} True if name follows convention
+ */
+const follows_naming_convention = (database_name) => {
+  const valid_name_pattern = /^[a-zA-Z0-9_-]+$/;
+  return valid_name_pattern.test(database_name);
+};
+
 /**
  * Validates database name according to naming rules.
  * @param {string} database_name - Database name to validate
@@ -36,20 +65,268 @@ const validate_database_name = (database_name) => {
     return false;
   }
   
-  // NOTE: Check length limit.
-  if (database_name.length > 64) {
+  if (exceeds_length_limit(database_name)) {
     return false;
   }
   
-  // NOTE: Check for reserved names.
-  const reserved_names = ['admin', 'config', 'local'];
-  if (reserved_names.includes(database_name.toLowerCase())) {
+  if (is_reserved_database_name(database_name)) {
     return false;
   }
   
-  // NOTE: Check naming convention (alphanumeric, underscores, hyphens).
-  const valid_name_pattern = /^[a-zA-Z0-9_-]+$/;
-  return valid_name_pattern.test(database_name);
+  return follows_naming_convention(database_name);
+};
+
+/**
+ * Creates authentication error response.
+ * @returns {Object} Authentication error response
+ */
+const create_authentication_error_response = () => ({
+  ok: 0,
+  error: 'Authentication required'
+});
+
+/**
+ * Creates database name validation error response.
+ * @returns {Object} Database validation error response
+ */
+const create_database_validation_error_response = () => ({
+  ok: 0,
+  error: 'Invalid database name. Database names must be alphanumeric with underscores/hyphens, max 64 characters, and cannot be reserved names (admin, config, local).'
+});
+
+/**
+ * Sends encoded response to socket.
+ * @param {net.Socket} socket - Client socket
+ * @param {Object} response - Response object
+ */
+const send_encoded_response = (socket, response) => {
+  const encoded_response = encode_message(response);
+  socket.write(encoded_response);
+};
+
+/**
+ * Logs performance metrics for operation.
+ * @param {string} socket_id - Socket identifier
+ * @param {string} op_type - Operation type
+ * @param {string} collection - Collection name
+ * @param {number} duration_ms - Operation duration
+ * @param {string} status - Operation status
+ * @param {string} error_message - Error message if failed
+ * @param {number} request_size - Request size in bytes
+ * @param {number} response_size - Response size in bytes
+ */
+const log_operation_performance = (socket_id, op_type, collection, duration_ms, status, error_message, request_size, response_size) => {
+  performance_monitor.log_structured_operation(
+    socket_id,
+    op_type,
+    collection,
+    duration_ms,
+    status,
+    error_message,
+    request_size,
+    response_size
+  );
+};
+
+/**
+ * Logs operation completion details.
+ * @param {Function} log - Logger function
+ * @param {string} socket_id - Socket identifier
+ * @param {string} op_type - Operation type
+ * @param {string} collection - Collection name
+ * @param {number} duration_ms - Operation duration
+ * @param {string} status - Operation status
+ * @param {number} request_size - Request size in bytes
+ * @param {number} response_size - Response size in bytes
+ * @param {string} error_message - Error message if failed
+ */
+const log_operation_details = (log, socket_id, op_type, collection, duration_ms, status, request_size, response_size, error_message = null) => {
+  const log_data = {
+    client_id: socket_id,
+    op: op_type,
+    collection,
+    duration_ms,
+    status,
+    request_size
+  };
+
+  if (status === 'success') {
+    log_data.response_size = response_size;
+    log.info('Database operation completed', log_data);
+  } else {
+    log_data.error = error_message;
+    log.error('Database operation failed', log_data);
+  }
+};
+
+/**
+ * Executes database operation based on type.
+ * @param {string} op_type - Operation type
+ * @param {string} database_name - Database name
+ * @param {Object} data - Operation data
+ * @returns {Promise<Object>} Operation result
+ */
+const execute_database_operation = async (op_type, database_name, data) => {
+  switch (op_type) {
+    case 'insert_one':
+      return await insert_one(database_name, data.collection, data.document, data.options);
+      
+    case 'update_one':
+      return await update_one(database_name, data.collection, data.filter, data.update, data.options);
+      
+    case 'delete_one':
+      return await delete_one(database_name, data.collection, data.filter, data.options);
+      
+    case 'delete_many':
+      return await delete_many(database_name, data.collection, data.filter, data.options);
+      
+    case 'bulk_write':
+      return await bulk_write(database_name, data.collection, data.operations, data.options);
+      
+    case 'find_one':
+      return await find_one(database_name, data.collection, data.filter, data.options);
+      
+    case 'find':
+      return await find(database_name, data.collection, data.filter, data.options);
+      
+    case 'create_index':
+      return await create_index_operation(database_name, data.collection, data.field, data.options);
+      
+    case 'drop_index':
+      return await drop_index_operation(database_name, data.collection, data.field);
+      
+    case 'get_indexes':
+      return await get_indexes_operation(database_name, data.collection);
+      
+    default:
+      throw new Error(`Unsupported operation: ${op_type}`);
+  }
+};
+
+/**
+ * Formats operation result into response object.
+ * @param {string} op_type - Operation type
+ * @param {Object} result - Operation result
+ * @returns {Object} Formatted response
+ */
+const format_operation_response = (op_type, result) => {
+  if (op_type === 'find_one') {
+    return { ok: 1, document: result };
+  } else if (op_type === 'find') {
+    return { ok: 1, documents: result };
+  } else {
+    return { ok: 1, ...result };
+  }
+};
+
+/**
+ * Determines if operation is a write operation.
+ * @param {string} op_type - Operation type
+ * @returns {boolean} True if write operation
+ */
+const is_write_operation = (op_type) => {
+  const read_operations = ['find', 'find_one', 'get_indexes'];
+  return !read_operations.includes(op_type);
+};
+
+/**
+ * Queues operation for replication if it's a write operation.
+ * @param {string} op_type - Operation type
+ * @param {Object} data - Operation data
+ */
+const queue_replication_if_write_operation = (op_type, data) => {
+  if (!is_write_operation(op_type)) {
+    return;
+  }
+
+  const replication_manager = get_replication_manager();
+  replication_manager.queue_replication(op_type, data.collection, data);
+  
+  setImmediate(() => check_and_grow_map_size());
+};
+
+/**
+ * Handles successful database operation.
+ * @param {net.Socket} socket - Client socket
+ * @param {string} op_type - Operation type
+ * @param {Object} data - Operation data
+ * @param {Object} result - Operation result
+ * @param {number} start_time - Operation start time
+ * @param {number} raw_data_size - Request size in bytes
+ */
+const handle_successful_operation = (socket, op_type, data, result, start_time, raw_data_size) => {
+  const log = create_context_logger();
+  const duration_ms = Date.now() - start_time;
+  
+  const response = format_operation_response(op_type, result);
+  const encoded_response = encode_message(response);
+  const response_size = encoded_response.length;
+  
+  send_encoded_response(socket, response);
+  
+  log_operation_performance(
+    socket.id,
+    op_type,
+    data.collection,
+    duration_ms,
+    'success',
+    null,
+    raw_data_size,
+    response_size
+  );
+  
+  log_operation_details(
+    log,
+    socket.id,
+    op_type,
+    data.collection,
+    duration_ms,
+    'success',
+    raw_data_size,
+    response_size
+  );
+  
+  queue_replication_if_write_operation(op_type, data);
+};
+
+/**
+ * Handles failed database operation.
+ * @param {net.Socket} socket - Client socket
+ * @param {string} op_type - Operation type
+ * @param {Object} data - Operation data
+ * @param {Error} error - Operation error
+ * @param {number} start_time - Operation start time
+ * @param {number} raw_data_size - Request size in bytes
+ */
+const handle_failed_operation = (socket, op_type, data, error, start_time, raw_data_size) => {
+  const log = create_context_logger();
+  const duration_ms = Date.now() - start_time;
+  
+  log_operation_performance(
+    socket.id,
+    op_type,
+    data.collection,
+    duration_ms,
+    'error',
+    error.message,
+    raw_data_size,
+    0
+  );
+  
+  log_operation_details(
+    log,
+    socket.id,
+    op_type,
+    data.collection,
+    duration_ms,
+    'error',
+    raw_data_size,
+    0,
+    error.message
+  );
+  
+  const error_response = { ok: 0, error: error.message };
+  send_encoded_response(socket, error_response);
 };
 
 /**
@@ -58,181 +335,89 @@ const validate_database_name = (database_name) => {
  * @param {string} op_type - Type of database operation
  * @param {Object} data - Operation data
  * @param {Function} check_authentication - Function to check if socket is authenticated
- * @param {number} [raw_data_size=0] - Size of raw request data for monitoring
- * @param {Object} [connection_manager] - Connection manager instance (optional)
- * @param {Set} [authenticated_clients] - Set of authenticated client IDs (optional)
+ * @param {number} raw_data_size - Size of raw request data for monitoring
+ * @param {Object} connection_manager - Connection manager instance (optional)
+ * @param {Set} authenticated_clients - Set of authenticated client IDs (optional)
  */
 export const handle_database_operation = async (socket, op_type, data, check_authentication, raw_data_size = 0, connection_manager = null, authenticated_clients = null) => {
-  const log = create_context_logger();
   const start_time = Date.now();
   
   if (!check_authentication(socket)) {
-    const response = { ok: 0, error: 'Authentication required' };
-    const encoded_response = encode_message(response);
-    socket.write(encoded_response);
-    performance_monitor.log_structured_operation(socket.id, op_type, null, 0, 'error', 'Authentication required', raw_data_size, 0);
+    const response = create_authentication_error_response();
+    send_encoded_response(socket, response);
+    log_operation_performance(socket.id, op_type, null, 0, 'error', 'Authentication required', raw_data_size, 0);
     return;
   }
   
-  // NOTE: Extract and validate database name from request.
   const database_name = data.database || 'default';
   
   if (!validate_database_name(database_name)) {
-    const response = { ok: 0, error: 'Invalid database name. Database names must be alphanumeric with underscores/hyphens, max 64 characters, and cannot be reserved names (admin, config, local).' };
-    const encoded_response = encode_message(response);
-    socket.write(encoded_response);
-    performance_monitor.log_structured_operation(socket.id, op_type, data.collection, 0, 'error', 'Invalid database name', raw_data_size, 0);
+    const response = create_database_validation_error_response();
+    send_encoded_response(socket, response);
+    log_operation_performance(socket.id, op_type, data.collection, 0, 'error', 'Invalid database name', raw_data_size, 0);
     return;
   }
   
-  // NOTE: Check if this is a secondary node and should forward write operations.
   const write_forwarder = get_write_forwarder();
   const forwarded = await write_forwarder.forward_operation(socket, op_type, data);
   
   if (forwarded) {
-    // Operation was forwarded to primary, response will be handled by forwarder
     return;
   }
   
   try {
-    let result;
-    
-    switch (op_type) {
-      case 'insert_one':
-        result = await insert_one(database_name, data.collection, data.document, data.options);
-        break;
-        
-      case 'update_one':
-        result = await update_one(database_name, data.collection, data.filter, data.update, data.options);
-        break;
-        
-      case 'delete_one':
-        result = await delete_one(database_name, data.collection, data.filter, data.options);
-        break;
-        
-      case 'delete_many':
-        result = await delete_many(database_name, data.collection, data.filter, data.options);
-        break;
-        
-      case 'bulk_write':
-        result = await bulk_write(database_name, data.collection, data.operations, data.options);
-        break;
-        
-      case 'find_one':
-        result = await find_one(database_name, data.collection, data.filter, data.options);
-        break;
-        
-      case 'find':
-        result = await find(database_name, data.collection, data.filter, data.options);
-        break;
-        
-      case 'create_index':
-        result = await create_index_operation(database_name, data.collection, data.field, data.options);
-        break;
-        
-      case 'drop_index':
-        result = await drop_index_operation(database_name, data.collection, data.field);
-        break;
-        
-      case 'get_indexes':
-        result = await get_indexes_operation(database_name, data.collection);
-        break;
-        
-      default:
-        throw new Error(`Unsupported operation: ${op_type}`);
-    }
-    
-    const duration_ms = Date.now() - start_time;
-    
-    // NOTE: All operations now return structured responses for consistency.
-    let response;
-    if (op_type === 'find_one') {
-      response = { ok: 1, document: result };
-    } else if (op_type === 'find') {
-      response = { ok: 1, documents: result };
-    } else {
-      response = { ok: 1, ...result };
-    }
-    
-    const encoded_response = encode_message(response);
-    const response_size = encoded_response.length;
-    
-    socket.write(encoded_response);
-    
-    // NOTE: Log structured operation with performance monitoring.
-    performance_monitor.log_structured_operation(
-      socket.id, 
-      op_type, 
-      data.collection, 
-      duration_ms, 
-      'success', 
-      null, 
-      raw_data_size, 
-      response_size
-    );
-    
-    log.info('Database operation completed', {
-      client_id: socket.id,
-      op: op_type,
-      collection: data.collection,
-      duration_ms,
-      status: 'success',
-      request_size: raw_data_size,
-      response_size
-    });
-    
-    // NOTE: Queue write operations for replication to secondary nodes.
-    if (op_type !== 'find' && op_type !== 'find_one' && op_type !== 'get_indexes') {
-      const replication_manager = get_replication_manager();
-      replication_manager.queue_replication(op_type, data.collection, data);
-      
-      setImmediate(() => check_and_grow_map_size());
-    }
+    const result = await execute_database_operation(op_type, database_name, data);
+    handle_successful_operation(socket, op_type, data, result, start_time, raw_data_size);
   } catch (error) {
-    const duration_ms = Date.now() - start_time;
-    
-    // NOTE: Log structured operation with error.
-    performance_monitor.log_structured_operation(
-      socket.id, 
-      op_type, 
-      data.collection, 
-      duration_ms, 
-      'error', 
-      error.message, 
-      raw_data_size, 
-      0
-    );
-    
-    log.error('Database operation failed', {
-      client_id: socket.id,
-      op: op_type,
-      collection: data.collection,
-      duration_ms,
-      status: 'error',
-      error: error.message,
-      request_size: raw_data_size
-    });
-    
-    const error_response = { ok: 0, error: error.message };
-    const encoded_error_response = encode_message(error_response);
-    socket.write(encoded_error_response);
+    handle_failed_operation(socket, op_type, data, error, start_time, raw_data_size);
+  }
+};
+
+/**
+ * Creates admin authentication error response.
+ * @returns {Object} Admin authentication error response
+ */
+const create_admin_authentication_error_response = () => ({
+  ok: false,
+  error: 'Authentication required'
+});
+
+/**
+ * Creates admin operation response.
+ * @param {string} admin_action - Admin action type
+ * @param {Object} result - Operation result
+ * @returns {Object} Admin response object
+ */
+const create_admin_operation_response = (admin_action, result) => {
+  if (!admin_action) {
+    return { ok: true, ...result };
+  } else {
+    return { ok: 1, ...result };
   }
 };
 
+/**
+ * Creates admin operation error response.
+ * @param {string} error_message - Error message
+ * @returns {Object} Admin error response
+ */
+const create_admin_operation_error_response = (error_message) => ({
+  ok: 0,
+  error: `Admin operation failed: ${error_message}`
+});
+
 /**
  * Handles admin operations with authentication and error handling.
  * @param {net.Socket} socket - Client socket connection
  * @param {Object} data - Admin operation data
  * @param {Function} check_authentication - Function to check if socket is authenticated
- * @param {Object} [connection_manager] - Connection manager instance (optional)
- * @param {Set} [authenticated_clients] - Set of authenticated client IDs (optional)
+ * @param {Object} connection_manager - Connection manager instance (optional)
+ * @param {Set} authenticated_clients - Set of authenticated client IDs (optional)
  */
 export const handle_admin_operation = async (socket, data, check_authentication, connection_manager = null, authenticated_clients = null) => {
   if (!check_authentication(socket)) {
-    // NOTE: Unauthenticated admin requests should return ok: false.
-    const response = { ok: false, error: 'Authentication required' };
-    const encoded_response = encode_message(response);
-    socket.write(encoded_response);
+    const response = create_admin_authentication_error_response();
+    send_encoded_response(socket, response);
     return;
   }
   
@@ -241,24 +426,11 @@ export const handle_admin_operation = async (socket, data, check_authentication,
     const admin_data = data || {};
     
     const result = await admin_operation(admin_action, admin_data, connection_manager, authenticated_clients);
-    
-    // NOTE: Handle different response formats for admin operations.
-    if (!admin_action) {
-      // NOTE: Default admin operation (backward compatibility) - return result directly with ok: true.
-      const response = { ok: true, ...result };
-      const encoded_response = encode_message(response);
-      socket.write(encoded_response);
-    } else {
-      // NOTE: Specific admin actions - return result directly with ok: 1.
-      const response = { ok: 1, ...result };
-      const encoded_response = encode_message(response);
-      socket.write(encoded_response);
-    }
+    const response = create_admin_operation_response(admin_action, result);
+    send_encoded_response(socket, response);
   } catch (error) {
-    // NOTE: Admin operation errors use ok: 0.
-    const response = { ok: 0, error: `Admin operation failed: ${error.message}` };
-    const encoded_response = encode_message(response);
-    socket.write(encoded_response);
+    const response = create_admin_operation_error_response(error.message);
+    send_encoded_response(socket, response);
   }
 };
 
@@ -268,6 +440,5 @@ export const handle_admin_operation = async (socket, data, check_authentication,
  */
 export const handle_ping_operation = (socket) => {
   const ping_response = { ok: 1 };
-  const encoded_ping_response = encode_message(ping_response);
-  socket.write(encoded_ping_response);
+  send_encoded_response(socket, ping_response);
 };