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

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

@@ -14,65 +14,175 @@ import create_logger from '../logger.js';
 const { create_context_logger } = create_logger('insert_one');
 
 /**
- * Internal implementation of insert_one operation without write queue serialization.
- * @param {string} database_name - Name of the database
- * @param {string} collection_name - Name of the collection
- * @param {Object} document - Document to insert
- * @param {Object} [options={}] - Insert options
- * @returns {Promise<Object>} Insert result with acknowledged and inserted_id
- * @throws {Error} When database/collection name is missing, document is invalid, or document already exists
+ * Validates database name parameter.
+ * @param {string} database_name - Database name to validate
+ * @throws {Error} When database name is missing
  */
-const insert_one_internal = async (database_name, collection_name, document, 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 document parameter.
+ * @param {Object} document - Document to validate
+ * @throws {Error} When document is invalid
+ */
+const validate_document = (document) => {
   if (!document || typeof document !== 'object') {
     throw new Error('Document must be a valid object');
   }
-  
-  const db = get_database();
+};
+
+/**
+ * Validates all insert operation parameters.
+ * @param {string} database_name - Database name
+ * @param {string} collection_name - Collection name
+ * @param {Object} document - Document to insert
+ */
+const validate_insert_parameters = (database_name, collection_name, document) => {
+  validate_database_name(database_name);
+  validate_collection_name(collection_name);
+  validate_document(document);
+};
+
+/**
+ * Creates current timestamp string.
+ * @returns {string} ISO timestamp string
+ */
+const create_current_timestamp = () => {
+  return new Date().toISOString();
+};
+
+/**
+ * Prepares document for insertion with ID and timestamps.
+ * @param {Object} document - Original document
+ * @returns {Object} Document prepared for insertion
+ */
+const prepare_document_for_insertion = (document) => {
   const document_id = document._id || generate_document_id();
-  const collection_key = build_collection_key(database_name, collection_name, document_id);
+  const current_timestamp = create_current_timestamp();
   
-  const document_to_insert = {
+  return {
     ...document,
     _id: document_id,
-    _created_at: new Date().toISOString(),
-    _updated_at: new Date().toISOString()
+    _created_at: current_timestamp,
+    _updated_at: current_timestamp
   };
+};
+
+/**
+ * Checks if document already exists in collection.
+ * @param {Object} db - Database instance
+ * @param {string} collection_key - Collection key for document
+ * @param {string} document_id - Document ID
+ * @throws {Error} When document already exists
+ */
+const check_document_does_not_exist = (db, collection_key, document_id) => {
+  const existing_document = db.get(collection_key);
   
-  let inserted_document = null;
+  if (existing_document) {
+    throw new Error(`Document with _id ${document_id} already exists`);
+  }
+};
+
+/**
+ * Stores document in database within transaction.
+ * @param {Object} db - Database instance
+ * @param {string} collection_key - Collection key for document
+ * @param {Object} document_to_insert - Document to store
+ * @returns {Object} The inserted document
+ * @throws {Error} When document already exists or transaction fails
+ */
+const store_document_in_transaction = (db, collection_key, document_to_insert) => {
+  // Check for duplicate before starting transaction
+  check_document_does_not_exist(db, collection_key, document_to_insert._id);
   
-  await db.transaction(() => {
-    const existing_document = db.get(collection_key);
-    
-    if (existing_document) {
-      throw new Error(`Document with _id ${document_id} already exists`);
-    }
-    
+  // Perform the insert within transaction
+  db.transaction(() => {
+    // Double-check within transaction to handle race conditions
+    check_document_does_not_exist(db, collection_key, document_to_insert._id);
     db.put(collection_key, JSON.stringify(document_to_insert));
-    inserted_document = document_to_insert;
   });
   
-  await update_indexes_on_insert(database_name, collection_name, inserted_document);
-  
+  return document_to_insert;
+};
+
+/**
+ * Logs successful document insertion.
+ * @param {Function} log - Logger function
+ * @param {string} database_name - Database name
+ * @param {string} collection_name - Collection name
+ * @param {string} document_id - Document ID
+ */
+const log_successful_insertion = (log, database_name, collection_name, document_id) => {
   log.info('Document inserted successfully', {
     database: database_name,
     collection: collection_name,
     document_id: document_id
   });
+};
+
+/**
+ * Creates insert operation result.
+ * @param {string} document_id - ID of inserted document
+ * @returns {Object} Insert result object
+ */
+const create_insert_result = (document_id) => ({
+  acknowledged: true,
+  inserted_id: document_id
+});
+
+/**
+ * Creates write queue operation metadata.
+ * @param {string} database_name - Database name
+ * @param {string} collection_name - Collection name
+ * @param {Object} document - Document being inserted
+ * @returns {Object} Operation metadata
+ */
+const create_write_queue_metadata = (database_name, collection_name, document) => ({
+  operation: 'insert_one',
+  database: database_name,
+  collection: collection_name,
+  document_id: document._id || 'auto-generated'
+});
+
+/**
+ * Internal implementation of insert_one operation without write queue serialization.
+ * @param {string} database_name - Name of the database
+ * @param {string} collection_name - Name of the collection
+ * @param {Object} document - Document to insert
+ * @param {Object} options - Insert options
+ * @returns {Promise<Object>} Insert result with acknowledged and inserted_id
+ */
+const insert_one_internal = async (database_name, collection_name, document, options = {}) => {
+  const log = create_context_logger();
   
-  return {
-    acknowledged: true,
-    inserted_id: document_id
-  };
+  validate_insert_parameters(database_name, collection_name, document);
+  
+  const db = get_database();
+  const document_to_insert = prepare_document_for_insertion(document);
+  const collection_key = build_collection_key(database_name, collection_name, document_to_insert._id);
+  
+  const inserted_document = store_document_in_transaction(db, collection_key, document_to_insert);
+  
+  await update_indexes_on_insert(database_name, collection_name, inserted_document);
+  
+  log_successful_insertion(log, database_name, collection_name, document_to_insert._id);
+  
+  return create_insert_result(document_to_insert._id);
 };
 
 /**
@@ -80,33 +190,18 @@ const insert_one_internal = async (database_name, collection_name, document, opt
  * @param {string} database_name - Name of the database
  * @param {string} collection_name - Name of the collection
  * @param {Object} document - Document to insert
- * @param {Object} [options={}] - Insert options
+ * @param {Object} options - Insert options
  * @returns {Promise<Object>} Insert result with acknowledged and inserted_id
- * @throws {Error} When database/collection name is missing or document is invalid
  */
 const insert_one = async (database_name, collection_name, document, options = {}) => {
-  if (!database_name) {
-    throw new Error('Database name is required');
-  }
-  
-  if (!collection_name) {
-    throw new Error('Collection name is required');
-  }
-  
-  if (!document || typeof document !== 'object') {
-    throw new Error('Document must be a valid object');
-  }
+  validate_insert_parameters(database_name, collection_name, document);
   
   const write_queue = get_write_queue();
+  const operation_metadata = create_write_queue_metadata(database_name, collection_name, document);
   
   return await write_queue.enqueue_write_operation(
     () => insert_one_internal(database_name, collection_name, document, options),
-    {
-      operation: 'insert_one',
-      database: database_name,
-      collection: collection_name,
-      document_id: document._id || 'auto-generated'
-    }
+    operation_metadata
   );
 };