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

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

@@ -9,58 +9,151 @@ import create_logger from '../logger.js';
 const { create_context_logger } = create_logger('create_index');
 
 /**
- * Creates or updates an index on a specified field in a collection.
- * @param {string} database_name - Name of the database
- * @param {string} collection_name - Name of the collection to create index for
- * @param {string} field_name - Name of the field to index
- * @param {Object} [options={}] - Index creation options
- * @param {boolean} [options.unique] - Whether the index should enforce uniqueness
- * @param {boolean} [options.sparse] - Whether the index should be sparse (skip null values)
- * @returns {Promise<Object>} Index creation result with operation details and message
- * @throws {Error} When database, collection name or field name is missing, or index creation fails
+ * Validates database name parameter.
+ * @param {string} database_name - Database name to validate
+ * @throws {Error} When database name is missing
  */
-const create_index_operation = async (database_name, collection_name, field_name, 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 field name parameter.
+ * @param {string} field_name - Field name to validate
+ * @throws {Error} When field name is missing
+ */
+const validate_field_name = (field_name) => {
   if (!field_name) {
     throw new Error('Field name is required');
   }
+};
+
+/**
+ * Validates all create index operation parameters.
+ * @param {string} database_name - Database name
+ * @param {string} collection_name - Collection name
+ * @param {string} field_name - Field name
+ */
+const validate_create_index_parameters = (database_name, collection_name, field_name) => {
+  validate_database_name(database_name);
+  validate_collection_name(collection_name);
+  validate_field_name(field_name);
+};
+
+/**
+ * Determines action verb based on operation type.
+ * @param {string} operation_type - Type of operation performed
+ * @returns {string} Action verb describing the operation
+ */
+const get_action_verb_for_operation = (operation_type) => {
+  switch (operation_type) {
+    case 'created':
+      return 'created';
+    case 'updated':
+      return 'updated';
+    default:
+      return 'already exists';
+  }
+};
+
+/**
+ * Creates success message for index operation.
+ * @param {string} action_verb - Action verb describing operation
+ * @param {string} database_name - Database name
+ * @param {string} collection_name - Collection name
+ * @param {string} field_name - Field name
+ * @returns {string} Success message
+ */
+const create_success_message = (action_verb, database_name, collection_name, field_name) => {
+  return `Index ${action_verb} on ${database_name}.${collection_name}.${field_name}`;
+};
+
+/**
+ * Logs successful index operation.
+ * @param {Function} log - Logger function
+ * @param {string} action_verb - Action verb describing operation
+ * @param {string} database_name - Database name
+ * @param {string} collection_name - Collection name
+ * @param {string} field_name - Field name
+ * @param {Object} options - Index options
+ * @param {string} operation_type - Type of operation performed
+ */
+const log_successful_index_operation = (log, action_verb, database_name, collection_name, field_name, options, operation_type) => {
+  log.info(`Index ${action_verb} successfully`, {
+    database: database_name,
+    collection: collection_name,
+    field: field_name,
+    options,
+    operation_type
+  });
+};
+
+/**
+ * Logs failed index operation.
+ * @param {Function} log - Logger function
+ * @param {string} database_name - Database name
+ * @param {string} collection_name - Collection name
+ * @param {string} field_name - Field name
+ * @param {Error} error - Error that occurred
+ */
+const log_failed_index_operation = (log, database_name, collection_name, field_name, error) => {
+  log.error('Failed to create/upsert index', {
+    database: database_name,
+    collection: collection_name,
+    field: field_name,
+    error: error.message
+  });
+};
+
+/**
+ * Creates index operation result with message.
+ * @param {Object} result - Index creation result
+ * @param {string} message - Success message
+ * @returns {Object} Enhanced result with message
+ */
+const create_index_operation_result = (result, message) => ({
+  ...result,
+  message
+});
+
+/**
+ * Creates or updates an index on a specified field in a collection.
+ * @param {string} database_name - Name of the database
+ * @param {string} collection_name - Name of the collection to create index for
+ * @param {string} field_name - Name of the field to index
+ * @param {Object} options - Index creation options
+ * @returns {Promise<Object>} Index creation result with operation details and message
+ */
+const create_index_operation = async (database_name, collection_name, field_name, options = {}) => {
+  const log = create_context_logger();
+  
+  validate_create_index_parameters(database_name, collection_name, field_name);
   
   try {
     const result = await create_index(database_name, collection_name, field_name, options);
     
     const operation_type = result.operation_type || 'created';
-    const action_verb = operation_type === 'created' ? 'created' : 
-                       operation_type === 'updated' ? 'updated' : 
-                       'already exists';
+    const action_verb = get_action_verb_for_operation(operation_type);
+    const success_message = create_success_message(action_verb, database_name, collection_name, field_name);
     
-    log.info(`Index ${action_verb} successfully`, {
-      database: database_name,
-      collection: collection_name,
-      field: field_name,
-      options,
-      operation_type
-    });
+    log_successful_index_operation(log, action_verb, database_name, collection_name, field_name, options, operation_type);
     
-    return {
-      ...result,
-      message: `Index ${action_verb} on ${database_name}.${collection_name}.${field_name}`
-    };
+    return create_index_operation_result(result, success_message);
   } catch (error) {
-    log.error('Failed to create/upsert index', {
-      database: database_name,
-      collection: collection_name,
-      field: field_name,
-      error: error.message
-    });
+    log_failed_index_operation(log, database_name, collection_name, field_name, error);
     throw error;
   }
 };

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

@@ -5,6 +5,75 @@ import create_logger from '../logger.js';
 
 const { create_context_logger } = create_logger('delete_many');
 
+/**
+ * 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 limit option.
+ * @param {number} limit - Limit to validate
+ * @throws {Error} When limit is invalid
+ */
+const validate_limit = (limit) => {
+  if (limit !== undefined && (typeof limit !== 'number' || limit < 0)) {
+    throw new Error('Limit must be a non-negative number');
+  }
+};
+
+/**
+ * Validates all delete many operation parameters.
+ * @param {string} database_name - Database name
+ * @param {string} collection_name - Collection name
+ * @param {Object} filter - Filter criteria
+ * @param {Object} options - Delete options
+ */
+const validate_delete_many_parameters = (database_name, collection_name, filter, options) => {
+  validate_database_name(database_name);
+  validate_collection_name(collection_name);
+  validate_filter(filter);
+  validate_limit(options.limit);
+};
+
+/**
+ * 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 +86,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,81 +95,155 @@ const matches_filter = (document, filter) => {
 };
 
 /**
- * Internal implementation of delete_many 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 documents for deletion
- * @param {Object} [options={}] - Delete options
- * @param {number} [options.limit] - Maximum number of documents to delete
- * @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_many_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 { limit } = options;
-  
-  if (limit !== undefined && (typeof limit !== 'number' || limit < 0)) {
-    throw new Error('Limit must be a non-negative number');
+const parse_document_safely = (value) => {
+  try {
+    return JSON.parse(value);
+  } catch (parse_error) {
+    return null;
   }
-  
-  const db = get_database();
+};
+
+/**
+ * Checks if deletion limit has been reached.
+ * @param {number} deleted_count - Current deleted count
+ * @param {number} limit - Maximum deletion limit
+ * @returns {boolean} True if limit reached
+ */
+const has_reached_deletion_limit = (deleted_count, limit) => {
+  return limit !== undefined && deleted_count >= limit;
+};
+
+/**
+ * Searches for and deletes matching documents 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 {number} limit - Maximum number of documents to delete
+ * @returns {Object} Delete result with count and deleted documents
+ */
+const find_and_delete_documents = (db, database_name, collection_name, filter, limit) => {
   let deleted_count = 0;
   const deleted_documents = [];
   
-  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) {
+    if (has_reached_deletion_limit(deleted_count, limit)) {
+      break;
+    }
     
-    const range = db.getRange({ start: collection_prefix, end: collection_prefix + '\xFF' });
-    for (const { key, value } of range) {
-      // NOTE: Check limit before processing more documents.
-      if (limit !== undefined && deleted_count >= limit) {
-        break;
-      }
-      
-      try {
-        const document = JSON.parse(value);
-        if (matches_filter(document, filter)) {
-          db.remove(key);
-          deleted_documents.push(document);
-          deleted_count++;
-        }
-      } catch (parse_error) {
-        // Skip documents that can't be parsed
-        continue;
-      }
+    const document = parse_document_safely(value);
+    if (!document) {
+      continue;
     }
-  });
+    
+    if (matches_filter(document, filter)) {
+      db.remove(key);
+      deleted_documents.push(document);
+      deleted_count++;
+    }
+  }
   
-  // NOTE: Update indexes for all deleted documents.
+  return { deleted_count, deleted_documents };
+};
+
+/**
+ * Updates indexes after document deletions.
+ * @param {string} database_name - Database name
+ * @param {string} collection_name - Collection name
+ * @param {Array<Object>} deleted_documents - Array of deleted documents
+ */
+const update_indexes_after_deletions = async (database_name, collection_name, deleted_documents) => {
   for (const deleted_document of deleted_documents) {
     await update_indexes_on_delete(database_name, collection_name, deleted_document);
   }
-  
+};
+
+/**
+ * Logs delete many 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
+ * @param {number} limit - Deletion limit
+ */
+const log_delete_many_completion = (log, database_name, collection_name, deleted_count, limit) => {
   log.info('Delete many operation completed', {
     database: database_name,
     collection: collection_name,
     deleted_count,
     limit: limit || 'none'
   });
+};
+
+/**
+ * Creates current timestamp string.
+ * @returns {string} ISO timestamp string
+ */
+const create_current_timestamp = () => {
+  return new Date().toISOString();
+};
+
+/**
+ * Creates delete many operation result.
+ * @param {number} deleted_count - Number of deleted documents
+ * @returns {Object} Delete result object
+ */
+const create_delete_many_result = (deleted_count) => ({
+  acknowledged: true,
+  deleted_count,
+  operation_time: create_current_timestamp()
+});
+
+/**
+ * Creates write queue operation metadata.
+ * @param {string} database_name - Database name
+ * @param {string} collection_name - Collection name
+ * @param {Object} filter - Filter criteria
+ * @param {number} limit - Deletion limit
+ * @returns {Object} Operation metadata
+ */
+const create_write_queue_metadata = (database_name, collection_name, filter, limit) => ({
+  operation: 'delete_many',
+  database: database_name,
+  collection: collection_name,
+  filter_keys: Object.keys(filter || {}),
+  limit
+});
+
+/**
+ * Internal implementation of delete_many 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 documents for deletion
+ * @param {Object} options - Delete options
+ * @returns {Promise<Object>} Delete result with acknowledged and deleted_count
+ */
+const delete_many_internal = async (database_name, collection_name, filter, options = {}) => {
+  const log = create_context_logger();
+  
+  validate_delete_many_parameters(database_name, collection_name, filter, options);
+  
+  const { limit } = options;
+  const db = get_database();
+  
+  const delete_result = await db.transaction(() => {
+    return find_and_delete_documents(db, database_name, collection_name, filter, limit);
+  });
   
-  return {
-    acknowledged: true,
-    deleted_count,
-    operation_time: new Date().toISOString()
-  };
+  const { deleted_count, deleted_documents } = delete_result;
+  
+  await update_indexes_after_deletions(database_name, collection_name, deleted_documents);
+  
+  log_delete_many_completion(log, database_name, collection_name, deleted_count, limit);
+  
+  return create_delete_many_result(deleted_count);
 };
 
 /**
@@ -108,22 +251,16 @@ const delete_many_internal = async (database_name, collection_name, filter, opti
  * @param {string} database_name - Name of the database
  * @param {string} collection_name - Name of the collection
  * @param {Object} filter - Filter criteria to match documents for deletion
- * @param {Object} [options={}] - Delete options
- * @param {number} [options.limit] - Maximum number of documents to delete
+ * @param {Object} options - Delete options
  * @returns {Promise<Object>} Delete result with acknowledged, deleted_count, and operation_time
  */
 const delete_many = 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, options.limit);
   
   return await write_queue.enqueue_write_operation(
     () => delete_many_internal(database_name, collection_name, filter, options),
-    {
-      operation: 'delete_many',
-      database: database_name,
-      collection: collection_name,
-      filter_keys: Object.keys(filter || {}),
-      limit: options.limit
-    }
+    operation_metadata
   );
 };