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

package/src/server/lib/operations/update_one.js

@@ -5,6 +5,77 @@ import create_logger from '../logger.js';
 
 const { create_context_logger } = create_logger('update_one');
 
+/**
+ * Applies $set operator to document.
+ * @param {Object} document - Document to update
+ * @param {Object} operations - Set operations
+ * @returns {Object} Updated document
+ */
+const apply_set_operator = (document, operations) => {
+  return { ...document, ...operations };
+};
+
+/**
+ * Applies $unset operator to document.
+ * @param {Object} document - Document to update
+ * @param {Object} operations - Unset operations
+ * @returns {Object} Updated document
+ */
+const apply_unset_operator = (document, operations) => {
+  const updated_document = { ...document };
+  for (const field of Object.keys(operations)) {
+    delete updated_document[field];
+  }
+  return updated_document;
+};
+
+/**
+ * Applies $inc operator to document.
+ * @param {Object} document - Document to update
+ * @param {Object} operations - Increment operations
+ * @returns {Object} Updated document
+ */
+const apply_inc_operator = (document, operations) => {
+  const updated_document = { ...document };
+  for (const [field, value] of Object.entries(operations)) {
+    updated_document[field] = (updated_document[field] || 0) + value;
+  }
+  return updated_document;
+};
+
+/**
+ * Applies $push operator to document.
+ * @param {Object} document - Document to update
+ * @param {Object} operations - Push operations
+ * @returns {Object} Updated document
+ */
+const apply_push_operator = (document, operations) => {
+  const updated_document = { ...document };
+  for (const [field, value] of Object.entries(operations)) {
+    if (!Array.isArray(updated_document[field])) {
+      updated_document[field] = [];
+    }
+    updated_document[field] = [...updated_document[field], value];
+  }
+  return updated_document;
+};
+
+/**
+ * Applies $pull operator to document.
+ * @param {Object} document - Document to update
+ * @param {Object} operations - Pull operations
+ * @returns {Object} Updated document
+ */
+const apply_pull_operator = (document, operations) => {
+  const updated_document = { ...document };
+  for (const [field, value] of Object.entries(operations)) {
+    if (Array.isArray(updated_document[field])) {
+      updated_document[field] = updated_document[field].filter(item => item !== value);
+    }
+  }
+  return updated_document;
+};
+
 /**
  * Applies MongoDB-style update operators to a document.
  * @param {Object} document - Original document
@@ -13,41 +84,28 @@ const { create_context_logger } = create_logger('update_one');
  * @throws {Error} When unsupported update operator is used
  */
 const apply_update_operators = (document, update_operations) => {
-  const updated_document = { ...document };
+  let updated_document = { ...document };
   
   for (const [operator, operations] of Object.entries(update_operations)) {
     switch (operator) {
       case '$set':
-        Object.assign(updated_document, operations);
+        updated_document = apply_set_operator(updated_document, operations);
         break;
         
       case '$unset':
-        for (const field of Object.keys(operations)) {
-          delete updated_document[field];
-        }
+        updated_document = apply_unset_operator(updated_document, operations);
         break;
         
       case '$inc':
-        for (const [field, value] of Object.entries(operations)) {
-          updated_document[field] = (updated_document[field] || 0) + value;
-        }
+        updated_document = apply_inc_operator(updated_document, operations);
         break;
         
       case '$push':
-        for (const [field, value] of Object.entries(operations)) {
-          if (!Array.isArray(updated_document[field])) {
-            updated_document[field] = [];
-          }
-          updated_document[field].push(value);
-        }
+        updated_document = apply_push_operator(updated_document, operations);
         break;
         
       case '$pull':
-        for (const [field, value] of Object.entries(operations)) {
-          if (Array.isArray(updated_document[field])) {
-            updated_document[field] = updated_document[field].filter(item => item !== value);
-          }
-        }
+        updated_document = apply_pull_operator(updated_document, operations);
         break;
         
       default:
@@ -58,6 +116,17 @@ const apply_update_operators = (document, update_operations) => {
   return updated_document;
 };
 
+/**
+ * Checks if document field matches filter value.
+ * @param {Object} document - Document to check
+ * @param {string} field - Field name
+ * @param {any} value - Expected value
+ * @returns {boolean} True if field matches value
+ */
+const field_matches_value = (document, field, value) => {
+  return document[field] === value;
+};
+
 /**
  * Checks if a document matches the given filter criteria (simple equality check).
  * @param {Object} document - Document to test
@@ -70,7 +139,7 @@ const matches_filter = (document, filter) => {
   }
   
   for (const [field, value] of Object.entries(filter)) {
-    if (document[field] !== value) {
+    if (!field_matches_value(document, field, value)) {
       return false;
     }
   }
@@ -79,104 +148,228 @@ const matches_filter = (document, filter) => {
 };
 
 /**
- * Internal implementation of update_one operation without write queue serialization.
- * @param {string} database_name - Name of the database
- * @param {string} collection_name - Name of the collection
- * @param {Object} filter - Filter criteria to match document
- * @param {Object} update - Update operations to apply
- * @param {Object} [options={}] - Update options
- * @param {boolean} [options.upsert] - Create document if not found
- * @returns {Promise<Object>} Update result with acknowledged, matched_count, modified_count, and optional upserted_id
- * @throws {Error} When database name, collection name, filter, or update is invalid
+ * Validates database name parameter.
+ * @param {string} database_name - Database name to validate
+ * @throws {Error} When database name is missing
  */
-const update_one_internal = async (database_name, collection_name, filter, update, options = {}) => {
-  const log = create_context_logger();
-  
+const validate_database_name = (database_name) => {
   if (!database_name) {
     throw new Error('Database name is required');
   }
-  
+};
+
+/**
+ * Validates collection name parameter.
+ * @param {string} collection_name - Collection name to validate
+ * @throws {Error} When collection name is missing
+ */
+const validate_collection_name = (collection_name) => {
   if (!collection_name) {
     throw new Error('Collection name is required');
   }
-  
+};
+
+/**
+ * Validates filter parameter.
+ * @param {Object} filter - Filter to validate
+ * @throws {Error} When filter is invalid
+ */
+const validate_filter = (filter) => {
   if (!filter || typeof filter !== 'object') {
     throw new Error('Filter must be a valid object');
   }
-  
+};
+
+/**
+ * Validates update parameter.
+ * @param {Object} update - Update to validate
+ * @throws {Error} When update is invalid
+ */
+const validate_update = (update) => {
   if (!update || typeof update !== 'object') {
     throw new Error('Update must be a valid object');
   }
+};
+
+/**
+ * Validates all update operation parameters.
+ * @param {string} database_name - Database name
+ * @param {string} collection_name - Collection name
+ * @param {Object} filter - Filter criteria
+ * @param {Object} update - Update operations
+ */
+const validate_update_parameters = (database_name, collection_name, filter, update) => {
+  validate_database_name(database_name);
+  validate_collection_name(collection_name);
+  validate_filter(filter);
+  validate_update(update);
+};
+
+/**
+ * Attempts to parse document from JSON string.
+ * @param {string} value - JSON string
+ * @returns {Object|null} Parsed document or null
+ */
+const parse_document_safely = (value) => {
+  try {
+    return JSON.parse(value);
+  } catch (parse_error) {
+    return null;
+  }
+};
+
+/**
+ * Creates current timestamp string.
+ * @returns {string} ISO timestamp string
+ */
+const create_current_timestamp = () => {
+  return new Date().toISOString();
+};
+
+/**
+ * Adds updated timestamp to document.
+ * @param {Object} document - Document to update
+ * @returns {Object} Document with updated timestamp
+ */
+const add_updated_timestamp = (document) => {
+  return {
+    ...document,
+    _updated_at: create_current_timestamp()
+  };
+};
+
+/**
+ * Checks if document has been modified.
+ * @param {Object} original_document - Original document
+ * @param {Object} updated_document - Updated document
+ * @returns {boolean} True if document was modified
+ */
+const document_was_modified = (original_document, updated_document) => {
+  return JSON.stringify(original_document) !== JSON.stringify(updated_document);
+};
+
+/**
+ * Creates new document for upsert operation.
+ * @param {Object} filter - Filter criteria
+ * @param {Object} update - Update operations
+ * @returns {Object} New document for upsert
+ */
+const create_upsert_document = (filter, update) => {
+  const document_id = generate_document_id();
+  const current_timestamp = create_current_timestamp();
   
-  const db = get_database();
+  const base_document = {
+    ...filter,
+    _id: document_id,
+    _created_at: current_timestamp,
+    _updated_at: current_timestamp
+  };
+  
+  return apply_update_operators(base_document, update);
+};
+
+/**
+ * Processes document update within transaction.
+ * @param {Object} db - Database instance
+ * @param {string} database_name - Database name
+ * @param {string} collection_name - Collection name
+ * @param {Object} filter - Filter criteria
+ * @param {Object} update - Update operations
+ * @param {Object} options - Update options
+ * @returns {Object} Update result data
+ */
+const process_document_update = (db, database_name, collection_name, filter, update, options) => {
   let matched_count = 0;
   let modified_count = 0;
   let upserted_id = null;
-  
   let old_document = null;
   let new_document = null;
   let upserted_document = null;
   
-  await db.transaction(() => {
-    const collection_prefix = `${database_name}:${collection_name}:`;
-    let document_found = false;
-    
-    const range = db.getRange({ start: collection_prefix, end: collection_prefix + '\xFF' });
-    for (const { key, value } of range) {
-      let document;
-      try {
-        document = JSON.parse(value);
-      } catch (parse_error) {
-        // Skip documents that can't be parsed
-        continue;
-      }
-      
-      if (matches_filter(document, filter)) {
-        document_found = true;
-        matched_count = 1;
-        
-        const updated_document = apply_update_operators(document, update);
-        updated_document._updated_at = new Date().toISOString();
-        
-        if (JSON.stringify(document) !== JSON.stringify(updated_document)) {
-          db.put(key, JSON.stringify(updated_document));
-          old_document = document;
-          new_document = updated_document;
-          modified_count = 1;
-        }
-        
-        break;
-      }
+  const collection_prefix = `${database_name}:${collection_name}:`;
+  let document_found = false;
+  
+  const range = db.getRange({ start: collection_prefix, end: collection_prefix + '\xFF' });
+  for (const { key, value } of range) {
+    const document = parse_document_safely(value);
+    if (!document) {
+      continue;
     }
     
-    if (!document_found && options.upsert) {
-      const document_id = generate_document_id();
-      const collection_key = build_collection_key(database_name, collection_name, document_id);
+    if (matches_filter(document, filter)) {
+      document_found = true;
+      matched_count = 1;
       
-      const new_doc = {
-        ...filter,
-        _id: document_id,
-        _created_at: new Date().toISOString(),
-        _updated_at: new Date().toISOString()
-      };
+      const updated_document = apply_update_operators(document, update);
+      const timestamped_document = add_updated_timestamp(updated_document);
       
-      upserted_document = apply_update_operators(new_doc, update);
-      db.put(collection_key, JSON.stringify(upserted_document));
+      if (document_was_modified(document, timestamped_document)) {
+        db.put(key, JSON.stringify(timestamped_document));
+        old_document = document;
+        new_document = timestamped_document;
+        modified_count = 1;
+      }
       
-      upserted_id = document_id;
-      matched_count = 0;
-      modified_count = 0;
+      break;
     }
-  });
+  }
   
+  if (!document_found && options.upsert) {
+    upserted_document = create_upsert_document(filter, update);
+    const collection_key = build_collection_key(database_name, collection_name, upserted_document._id);
+    
+    db.put(collection_key, JSON.stringify(upserted_document));
+    
+    upserted_id = upserted_document._id;
+    matched_count = 0;
+    modified_count = 0;
+  }
+  
+  return {
+    matched_count,
+    modified_count,
+    upserted_id,
+    old_document,
+    new_document,
+    upserted_document
+  };
+};
+
+/**
+ * Updates indexes after document modification.
+ * @param {string} database_name - Database name
+ * @param {string} collection_name - Collection name
+ * @param {Object} old_document - Original document
+ * @param {Object} new_document - Updated document
+ */
+const update_indexes_after_modification = async (database_name, collection_name, old_document, new_document) => {
   if (old_document && new_document) {
     await update_indexes_on_update(database_name, collection_name, old_document, new_document);
   }
-  
+};
+
+/**
+ * Updates indexes after document upsert.
+ * @param {string} database_name - Database name
+ * @param {string} collection_name - Collection name
+ * @param {Object} upserted_document - Upserted document
+ */
+const update_indexes_after_upsert = async (database_name, collection_name, upserted_document) => {
   if (upserted_document) {
     await update_indexes_on_insert(database_name, collection_name, upserted_document);
   }
-  
+};
+
+/**
+ * Logs update operation completion.
+ * @param {Function} log - Logger function
+ * @param {string} database_name - Database name
+ * @param {string} collection_name - Collection name
+ * @param {number} matched_count - Number of matched documents
+ * @param {number} modified_count - Number of modified documents
+ * @param {string} upserted_id - ID of upserted document
+ */
+const log_update_completion = (log, database_name, collection_name, matched_count, modified_count, upserted_id) => {
   log.info('Update operation completed', {
     database: database_name,
     collection: collection_name,
@@ -184,7 +377,16 @@ const update_one_internal = async (database_name, collection_name, filter, updat
     modified_count,
     upserted_id
   });
-  
+};
+
+/**
+ * Creates update operation result.
+ * @param {number} matched_count - Number of matched documents
+ * @param {number} modified_count - Number of modified documents
+ * @param {string} upserted_id - ID of upserted document
+ * @returns {Object} Update result object
+ */
+const create_update_result = (matched_count, modified_count, upserted_id) => {
   const result = {
     acknowledged: true,
     matched_count,
@@ -198,27 +400,66 @@ const update_one_internal = async (database_name, collection_name, filter, updat
   return result;
 };
 
+/**
+ * Creates write queue operation metadata.
+ * @param {string} database_name - Database name
+ * @param {string} collection_name - Collection name
+ * @param {Object} filter - Filter criteria
+ * @returns {Object} Operation metadata
+ */
+const create_write_queue_metadata = (database_name, collection_name, filter) => ({
+  operation: 'update_one',
+  database: database_name,
+  collection: collection_name,
+  filter_keys: Object.keys(filter || {})
+});
+
+/**
+ * Internal implementation of update_one operation without write queue serialization.
+ * @param {string} database_name - Name of the database
+ * @param {string} collection_name - Name of the collection
+ * @param {Object} filter - Filter criteria to match document
+ * @param {Object} update - Update operations to apply
+ * @param {Object} options - Update options
+ * @returns {Promise<Object>} Update result with acknowledged, matched_count, modified_count, and optional upserted_id
+ */
+const update_one_internal = async (database_name, collection_name, filter, update, options = {}) => {
+  const log = create_context_logger();
+  
+  validate_update_parameters(database_name, collection_name, filter, update);
+  
+  const db = get_database();
+  
+  const update_result = await db.transaction(() => {
+    return process_document_update(db, database_name, collection_name, filter, update, options);
+  });
+  
+  const { matched_count, modified_count, upserted_id, old_document, new_document, upserted_document } = update_result;
+  
+  await update_indexes_after_modification(database_name, collection_name, old_document, new_document);
+  await update_indexes_after_upsert(database_name, collection_name, upserted_document);
+  
+  log_update_completion(log, database_name, collection_name, matched_count, modified_count, upserted_id);
+  
+  return create_update_result(matched_count, modified_count, upserted_id);
+};
+
 /**
  * Updates a single document in a collection with write queue serialization.
  * @param {string} database_name - Name of the database
  * @param {string} collection_name - Name of the collection
  * @param {Object} filter - Filter criteria to match document
  * @param {Object} update - Update operations to apply
- * @param {Object} [options={}] - Update options
- * @param {boolean} [options.upsert] - Create document if not found
+ * @param {Object} options - Update options
  * @returns {Promise<Object>} Update result with acknowledged, matched_count, modified_count, and optional upserted_id
  */
 const update_one = async (database_name, collection_name, filter, update, options = {}) => {
   const write_queue = get_write_queue();
+  const operation_metadata = create_write_queue_metadata(database_name, collection_name, filter);
   
   return await write_queue.enqueue_write_operation(
     () => update_one_internal(database_name, collection_name, filter, update, options),
-    {
-      operation: 'update_one',
-      database: database_name,
-      collection: collection_name,
-      filter_keys: Object.keys(filter || {})
-    }
+    operation_metadata
   );
 };
 

package/src/server/lib/send_response.js

@@ -8,39 +8,59 @@
 import { encode_message } from './tcp_protocol.js';
 
 /**
- * Sends a success response to the client.
+ * Creates a success response object.
+ * @param {Object} data - Response data
+ * @returns {Object} Success response object
+ */
+const create_success_response = (data) => ({
+  ok: true,
+  data: data
+});
+
+/**
+ * Creates an error response object.
+ * @param {Object} error - Error information
+ * @returns {Object} Error response object
+ */
+const create_error_response = (error) => ({
+  ok: false,
+  error: error
+});
+
+/**
+ * Encodes and writes response to socket.
  * @param {net.Socket} socket - Client socket connection
- * @param {Object} [data={}] - Response data to send
+ * @param {Object} response - Response object to send
  */
-export const send_success = (socket, data = {}) => {
-  const response = {
-    ok: true,
-    data: data
-  };
-  
+const write_encoded_response = (socket, response) => {
   const encoded_response = encode_message(response);
   socket.write(encoded_response);
 };
 
+/**
+ * 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 = create_success_response(data);
+  write_encoded_response(socket, response);
+};
+
 /**
  * Sends an error response to the client.
  * @param {net.Socket} socket - Client socket connection
- * @param {Object} [error={}] - Error information to send
+ * @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);
+  const response = create_error_response(error);
+  write_encoded_response(socket, response);
 };
 
 /**
  * Sends a simple message response to the client.
  * @param {net.Socket} socket - Client socket connection
- * @param {string} [message=''] - Message to send
+ * @param {string} message - Message to send
  */
 export const send_message = (socket, message = '') => {
   send_success(socket, { message: message });