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

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

@@ -5,6 +5,62 @@ import create_logger from '../logger.js';
 
 const { create_context_logger } = create_logger('delete_one');
 
+/**
+ * Validates database name parameter.
+ * @param {string} database_name - Database name to validate
+ * @throws {Error} When database name is missing
+ */
+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 all delete operation parameters.
+ * @param {string} database_name - Database name
+ * @param {string} collection_name - Collection name
+ * @param {Object} filter - Filter criteria
+ */
+const validate_delete_parameters = (database_name, collection_name, filter) => {
+  validate_database_name(database_name);
+  validate_collection_name(collection_name);
+  validate_filter(filter);
+};
+
+/**
+ * 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
@@ -17,7 +73,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;
     }
   }
@@ -26,67 +82,127 @@ const matches_filter = (document, filter) => {
 };
 
 /**
- * Internal implementation of delete_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 for deletion
- * @param {Object} [options={}] - Delete options (currently unused)
- * @returns {Promise<Object>} Delete result with acknowledged and deleted_count
- * @throws {Error} When database name, collection name is missing or filter is invalid
+ * Attempts to parse document from JSON string.
+ * @param {string} value - JSON string
+ * @returns {Object|null} Parsed document or null
  */
-const delete_one_internal = async (database_name, collection_name, filter, options = {}) => {
-  const log = create_context_logger();
-  
-  if (!database_name) {
-    throw new Error('Database name is required');
-  }
-  
-  if (!collection_name) {
-    throw new Error('Collection name is required');
-  }
-  
-  if (!filter || typeof filter !== 'object') {
-    throw new Error('Filter must be a valid object');
+const parse_document_safely = (value) => {
+  try {
+    return JSON.parse(value);
+  } catch (parse_error) {
+    return null;
   }
-  
-  const db = get_database();
+};
+
+/**
+ * Searches for and deletes matching document within transaction.
+ * @param {Object} db - Database instance
+ * @param {string} database_name - Database name
+ * @param {string} collection_name - Collection name
+ * @param {Object} filter - Filter criteria
+ * @returns {Object} Delete result with count and deleted document
+ */
+const find_and_delete_document = (db, database_name, collection_name, filter) => {
   let deleted_count = 0;
   let deleted_document = null;
   
-  await db.transaction(() => {
-    const collection_prefix = `${database_name}:${collection_name}:`;
+  const collection_prefix = `${database_name}:${collection_name}:`;
+  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;
+    }
     
-    const range = db.getRange({ start: collection_prefix, end: collection_prefix + '\xFF' });
-    for (const { key, value } of range) {
-      try {
-        const document = JSON.parse(value);
-        if (matches_filter(document, filter)) {
-          db.remove(key);
-          deleted_document = document;
-          deleted_count = 1;
-          break;
-        }
-      } catch (parse_error) {
-        // Skip documents that can't be parsed
-        continue;
-      }
+    if (matches_filter(document, filter)) {
+      db.remove(key);
+      deleted_document = document;
+      deleted_count = 1;
+      break;
     }
-  });
+  }
   
+  return { deleted_count, deleted_document };
+};
+
+/**
+ * Updates indexes after document deletion.
+ * @param {string} database_name - Database name
+ * @param {string} collection_name - Collection name
+ * @param {Object} deleted_document - Deleted document
+ */
+const update_indexes_after_deletion = async (database_name, collection_name, deleted_document) => {
   if (deleted_document) {
     await update_indexes_on_delete(database_name, collection_name, deleted_document);
   }
-  
+};
+
+/**
+ * Logs delete operation completion.
+ * @param {Function} log - Logger function
+ * @param {string} database_name - Database name
+ * @param {string} collection_name - Collection name
+ * @param {number} deleted_count - Number of deleted documents
+ */
+const log_delete_completion = (log, database_name, collection_name, deleted_count) => {
   log.info('Delete operation completed', {
     database: database_name,
     collection: collection_name,
     deleted_count
   });
+};
+
+/**
+ * Creates delete operation result.
+ * @param {number} deleted_count - Number of deleted documents
+ * @returns {Object} Delete result object
+ */
+const create_delete_result = (deleted_count) => ({
+  acknowledged: true,
+  deleted_count
+});
+
+/**
+ * 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: 'delete_one',
+  database: database_name,
+  collection: collection_name,
+  filter_keys: Object.keys(filter || {})
+});
+
+/**
+ * Internal implementation of delete_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 for deletion
+ * @param {Object} options - Delete options (currently unused)
+ * @returns {Promise<Object>} Delete result with acknowledged and deleted_count
+ */
+const delete_one_internal = async (database_name, collection_name, filter, options = {}) => {
+  const log = create_context_logger();
+  
+  validate_delete_parameters(database_name, collection_name, filter);
+  
+  const db = get_database();
+  
+  const delete_result = await db.transaction(() => {
+    return find_and_delete_document(db, database_name, collection_name, filter);
+  });
   
-  return {
-    acknowledged: true,
-    deleted_count
-  };
+  const { deleted_count, deleted_document } = delete_result;
+  
+  await update_indexes_after_deletion(database_name, collection_name, deleted_document);
+  
+  log_delete_completion(log, database_name, collection_name, deleted_count);
+  
+  return create_delete_result(deleted_count);
 };
 
 /**
@@ -94,20 +210,16 @@ const delete_one_internal = async (database_name, collection_name, filter, optio
  * @param {string} database_name - Name of the database
  * @param {string} collection_name - Name of the collection
  * @param {Object} filter - Filter criteria to match document for deletion
- * @param {Object} [options={}] - Delete options
+ * @param {Object} options - Delete options
  * @returns {Promise<Object>} Delete result with acknowledged and deleted_count
  */
 const delete_one = async (database_name, collection_name, filter, 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(
     () => delete_one_internal(database_name, collection_name, filter, options),
-    {
-      operation: 'delete_one',
-      database: database_name,
-      collection: collection_name,
-      filter_keys: Object.keys(filter || {})
-    }
+    operation_metadata
   );
 };