fix(server/client): rename document_id to id in DocumentUploadResponse, again

src/routes/documents/crud.rs

@@ -109,7 +109,7 @@ pub async fn upload_document(
             }
             
             Ok(Json(DocumentUploadResponse {
-                document_id: document.id,
+                id: document.id,
                 filename: document.filename,
                 file_size: document.file_size,
                 mime_type: document.mime_type,
@@ -120,7 +120,7 @@ pub async fn upload_document(
         Ok(IngestionResult::ExistingDocument(existing_doc)) => {
             warn!("Duplicate document upload attempted: {}", existing_doc.id);
             Ok(Json(DocumentUploadResponse {
-                document_id: existing_doc.id,
+                id: existing_doc.id,
                 filename: existing_doc.filename,
                 file_size: existing_doc.file_size,
                 mime_type: existing_doc.mime_type,

src/routes/documents/types.rs

@@ -29,7 +29,7 @@ pub struct DeleteLowConfidenceRequest {
 
 #[derive(Deserialize, Serialize, ToSchema)]
 pub struct DocumentUploadResponse {
-    pub document_id: uuid::Uuid,
+    pub id: uuid::Uuid,
     pub filename: String,
     pub file_size: i64,
     pub mime_type: String,

tests/integration_document_deletion_integration_tests.rs

@@ -381,25 +381,25 @@ async fn test_single_document_deletion_success() {
     let document = client.upload_document(test_content, "test_deletion.txt")
         .await.expect("Failed to upload document");
     
-    println!("Uploaded document: {}", document.document_id);
+    println!("Uploaded document: {}", document.id);
     
     // Verify document exists
-    let retrieved_doc = client.get_document(&document.document_id.to_string())
+    let retrieved_doc = client.get_document(&document.id.to_string())
         .await.expect("Failed to get document");
     assert!(retrieved_doc.is_some(), "Document should exist before deletion");
     
     // Delete the document
-    let delete_result = client.delete_document(&document.document_id.to_string())
+    let delete_result = client.delete_document(&document.id.to_string())
         .await.expect("Failed to delete document");
     
     // Verify deletion response (server returns 204 No Content, so we get our fallback response)
     assert_eq!(delete_result["success"], true);
-    assert_eq!(delete_result["document_id"], document.document_id.to_string());
+    assert_eq!(delete_result["id"], document.id.to_string());
     // Note: filename is "deleted" because server returns empty response
     assert_eq!(delete_result["filename"], "deleted");
     
     // Verify document no longer exists
-    let retrieved_doc_after = client.get_document(&document.document_id.to_string())
+    let retrieved_doc_after = client.get_document(&document.id.to_string())
         .await.expect("Failed to check document existence");
     assert!(retrieved_doc_after.is_none(), "Document should not exist after deletion");
     
@@ -425,7 +425,7 @@ async fn test_bulk_document_deletion_success() {
         let test_content = format!("This is test document number {}", i);
         let document = client.upload_document(test_content.as_bytes(), &format!("test_bulk_{}.txt", i))
             .await.expect("Failed to upload document");
-        document_ids.push(document.document_id.to_string());
+        document_ids.push(document.id.to_string());
     }
     
     println!("Uploaded {} documents for bulk deletion", document_ids.len());
@@ -536,7 +536,7 @@ async fn test_bulk_delete_mixed_existing_nonexistent() {
     
     // Create a list with real and fake IDs
     let fake_id = Uuid::new_v4().to_string();
-    let mixed_ids = vec![real_document.document_id.to_string(), fake_id];
+    let mixed_ids = vec![real_document.id.to_string(), fake_id];
     
     // Perform bulk deletion
     let delete_result = client.bulk_delete_documents(&mixed_ids)
@@ -554,10 +554,10 @@ async fn test_bulk_delete_mixed_existing_nonexistent() {
         .collect();
     
     assert_eq!(deleted_ids.len(), 1);
-    assert_eq!(deleted_ids[0], real_document.document_id.to_string());
+    assert_eq!(deleted_ids[0], real_document.id.to_string());
     
     // Verify real document was deleted
-    let retrieved_doc = client.get_document(&real_document.document_id.to_string())
+    let retrieved_doc = client.get_document(&real_document.id.to_string())
         .await.expect("Failed to check document existence");
     assert!(retrieved_doc.is_none(), "Real document should be deleted");
     
@@ -613,7 +613,7 @@ async fn test_cross_user_deletion_protection() {
         .await.expect("Failed to upload document as user 1");
     
     // User 2 tries to delete user 1's document
-    let delete_result = client2.delete_document(&user1_document.document_id.to_string()).await;
+    let delete_result = client2.delete_document(&user1_document.id.to_string()).await;
     
     // Should return 404 (document not found for user 2)
     assert!(delete_result.is_err(), "Cross-user deletion should fail");
@@ -621,7 +621,7 @@ async fn test_cross_user_deletion_protection() {
     assert!(error_msg.contains("404"), "Should return 404 for document not owned by user");
     
     // Verify user 1's document still exists
-    let retrieved_doc = client1.get_document(&user1_document.document_id.to_string())
+    let retrieved_doc = client1.get_document(&user1_document.id.to_string())
         .await.expect("Failed to check document existence");
     assert!(retrieved_doc.is_some(), "User 1's document should still exist after failed cross-user deletion");
     
@@ -659,15 +659,15 @@ async fn test_admin_can_delete_any_document() {
         .await.expect("Failed to upload document as user");
     
     // Admin deletes user's document
-    let delete_result = admin_client.delete_document(&user_document.document_id.to_string())
+    let delete_result = admin_client.delete_document(&user_document.id.to_string())
         .await.expect("Admin should be able to delete any document");
     
     // Verify deletion response
     assert_eq!(delete_result["success"], true);
-    assert_eq!(delete_result["document_id"], user_document.document_id.to_string());
+    assert_eq!(delete_result["id"], user_document.id.to_string());
     
     // Verify document no longer exists
-    let retrieved_doc = user_client.get_document(&user_document.document_id.to_string())
+    let retrieved_doc = user_client.get_document(&user_document.id.to_string())
         .await.expect("Failed to check document existence");
     assert!(retrieved_doc.is_none(), "Document should be deleted by admin");
     
@@ -711,8 +711,8 @@ async fn test_document_count_updates_after_deletion() {
         let test_content = format!("Test document {}", i);
         let document = client.upload_document(test_content.as_bytes(), &format!("count_test_{}.txt", i))
             .await.expect("Failed to upload document");
-        document_ids.push(document.document_id.to_string());
+        document_ids.push(document.id.to_string());
-        println!("📤 Uploaded document {}: {}", i, document.document_id);
+        println!("📤 Uploaded document {}: {}", i, document.id);
     }
     
     // Wait a moment for documents to be indexed

tests/integration_document_routes_tests.rs

@@ -196,7 +196,7 @@ mod document_routes_deletion_tests {
 
         assert_eq!(success_response["success"], true);
         assert!(success_response["message"].is_string());
-        assert_eq!(success_response["document_id"], document.id.to_string());
+        assert_eq!(success_response["id"], document.id.to_string());
 
         // Test error response format
         let error_response = json!({

tests/integration_documents_database_tests.rs

@@ -150,7 +150,7 @@ mod tests {
         });
         
         assert!(ocr_response.is_object());
-        assert_eq!(ocr_response["document_id"], document.id.to_string());
+        assert_eq!(ocr_response["id"], document.id.to_string());
         assert_eq!(ocr_response["filename"], document.filename);
         assert_eq!(ocr_response["has_ocr_text"], true);
         assert_eq!(ocr_response["ocr_text"], document.ocr_text.unwrap());

tests/integration_file_processing_pipeline_tests.rs

@@ -166,7 +166,7 @@ impl FileProcessingTestClient {
         println!("🟢 DEBUG: Upload response: {}", response_text);
         
         let document: DocumentUploadResponse = serde_json::from_str(&response_text)?;
-        println!("✅ DEBUG: Successfully parsed document: {}", document.document_id);
+        println!("✅ DEBUG: Successfully parsed document: {}", document.id);
         Ok(document)
     }
     
@@ -198,7 +198,7 @@ impl FileProcessingTestClient {
         println!("🟢 DEBUG: Binary upload response: {}", response_text);
         
         let document: DocumentUploadResponse = serde_json::from_str(&response_text)?;
-        println!("✅ DEBUG: Successfully parsed binary document: {}", document.document_id);
+        println!("✅ DEBUG: Successfully parsed binary document: {}", document.id);
         Ok(document)
     }
     
@@ -367,7 +367,7 @@ End of test document."#;
     let document = client.upload_file(text_content, "test_pipeline.txt", "text/plain").await
         .expect("Failed to upload text file");
     
-    let document_id = document.document_id.to_string();
+    let document_id = document.id.to_string();
     println!("✅ Text file uploaded: {}", document_id);
     
     // Validate initial document properties
@@ -402,7 +402,7 @@ End of test document."#;
     let ocr_results = client.get_ocr_results(&document_id).await
         .expect("Failed to get OCR results");
     
-    assert_eq!(ocr_results["document_id"], document_id);
+    assert_eq!(ocr_results["id"], document_id);
     assert_eq!(ocr_results["has_ocr_text"], true);
     
     if let Some(ocr_text) = ocr_results["ocr_text"].as_str() {
@@ -471,7 +471,7 @@ async fn test_multiple_file_format_support() {
         
         match client.upload_file(content, filename, mime_type).await {
             Ok(document) => {
-                println!("✅ Uploaded {}: {}", filename, document.document_id);
+                println!("✅ Uploaded {}: {}", filename, document.id);
                 uploaded_documents.push((document, mime_type, filename, content));
             }
             Err(e) => {
@@ -487,7 +487,7 @@ async fn test_multiple_file_format_support() {
     for (document, mime_type, filename, original_content) in &uploaded_documents {
         println!("🔄 Processing {} ({})...", filename, mime_type);
         
-        let document_id = document.document_id.to_string();
+        let document_id = document.id.to_string();
         
         // Wait for processing (with shorter timeout for multiple files)
         match client.wait_for_processing(&document_id).await {
@@ -496,7 +496,7 @@ async fn test_multiple_file_format_support() {
                 
                 // Test OCR results
                 if let Ok(ocr_results) = client.get_ocr_results(&document_id).await {
-                    assert_eq!(ocr_results["document_id"], document_id);
+                    assert_eq!(ocr_results["id"], document_id);
                     
                     if ocr_results["has_ocr_text"] == true {
                         if let Some(ocr_text) = ocr_results["ocr_text"].as_str() {
@@ -554,7 +554,7 @@ async fn test_image_processing_pipeline() {
     let document = client.upload_binary_file(png_data.clone(), "test_image.png", "image/png").await
         .expect("Failed to upload PNG image");
     
-    let document_id = document.document_id.to_string();
+    let document_id = document.id.to_string();
     println!("✅ PNG image uploaded: {}", document_id);
     
     // Validate image document properties
@@ -621,7 +621,7 @@ async fn test_image_processing_pipeline() {
     let ocr_results = client.get_ocr_results(&document_id).await
         .expect("Failed to get OCR results for image");
     
-    assert_eq!(ocr_results["document_id"], document_id);
+    assert_eq!(ocr_results["id"], document_id);
     
     // Image might not have text, so OCR could be empty
     if ocr_results["has_ocr_text"] == true {
@@ -657,10 +657,10 @@ async fn test_processing_error_recovery() {
     let empty_result = client.upload_file("", "empty.txt", "text/plain").await;
     match empty_result {
         Ok(document) => {
-            println!("✅ Empty file uploaded: {}", document.document_id);
+            println!("✅ Empty file uploaded: {}", document.id);
             
             // Try to process empty file
-            match client.wait_for_processing(&document.document_id.to_string()).await {
+            match client.wait_for_processing(&document.id.to_string()).await {
                 Ok(processed) => {
                     println!("✅ Empty file processing completed: {:?}", processed.ocr_status);
                 }
@@ -682,7 +682,7 @@ async fn test_processing_error_recovery() {
     
     match large_result {
         Ok(document) => {
-            println!("✅ Large file uploaded: {} (size: {} bytes)", document.document_id, document.file_size);
+            println!("✅ Large file uploaded: {} (size: {} bytes)", document.id, document.file_size);
             
             // Give more time for large file processing
             let start = Instant::now();
@@ -697,7 +697,7 @@ async fn test_processing_error_recovery() {
                     
                 if let Ok(resp) = response {
                     if let Ok(docs) = resp.json::<Vec<DocumentResponse>>().await {
-                        if let Some(doc) = docs.iter().find(|d| d.id.to_string() == document.document_id.to_string()) {
+                        if let Some(doc) = docs.iter().find(|d| d.id.to_string() == document.id.to_string()) {
                             match doc.ocr_status.as_deref() {
                                 Some("completed") => {
                                     println!("✅ Large file processing completed");
@@ -732,10 +732,10 @@ async fn test_processing_error_recovery() {
     
     match corrupted_result {
         Ok(document) => {
-            println!("✅ Corrupted file uploaded: {}", document.document_id);
+            println!("✅ Corrupted file uploaded: {}", document.id);
             
             // Processing should handle the mismatch gracefully
-            match client.wait_for_processing(&document.document_id.to_string()).await {
+            match client.wait_for_processing(&document.id.to_string()).await {
                 Ok(processed) => {
                     println!("✅ Corrupted file processed: {:?}", processed.ocr_status);
                 }
@@ -757,10 +757,10 @@ async fn test_processing_error_recovery() {
     
     match special_result {
         Ok(document) => {
-            println!("✅ File with special characters uploaded: {}", document.document_id);
+            println!("✅ File with special characters uploaded: {}", document.id);
             println!("✅ Filename preserved: {}", document.filename);
             
-            match client.wait_for_processing(&document.document_id.to_string()).await {
+            match client.wait_for_processing(&document.id.to_string()).await {
                 Ok(_) => println!("✅ Special filename file processed successfully"),
                 Err(e) => println!("⚠️  Special filename file processing failed: {}", e),
             }
@@ -806,12 +806,12 @@ async fn test_pipeline_performance_monitoring() {
         println!("✅ {} uploaded in {:?}", filename, upload_time);
         
         // Wait for processing and measure time
-        match client.wait_for_processing(&document.document_id.to_string()).await {
+        match client.wait_for_processing(&document.id.to_string()).await {
             Ok(processed_doc) => {
                 let total_processing_time = processing_start.elapsed();
                 
                 // Get OCR results to check reported processing time
-                if let Ok(ocr_results) = client.get_ocr_results(&document.document_id.to_string()).await {
+                if let Ok(ocr_results) = client.get_ocr_results(&document.id.to_string()).await {
                     let reported_time = ocr_results["ocr_processing_time_ms"]
                         .as_i64()
                         .map(|ms| Duration::from_millis(ms as u64));
@@ -954,7 +954,7 @@ async fn test_concurrent_file_processing() {
     for handle in upload_handles {
         match handle.await.expect("Upload task should complete") {
             Ok((index, document, upload_time)) => {
-                println!("✅ Document {} uploaded in {:?}: {}", index + 1, upload_time, document.document_id);
+                println!("✅ Document {} uploaded in {:?}: {}", index + 1, upload_time, document.id);
                 uploaded_documents.push(document);
             }
             Err((index, error)) => {
@@ -972,7 +972,7 @@ async fn test_concurrent_file_processing() {
     for document in uploaded_documents {
         let token = client.token.clone().unwrap();
         let client_clone = client.client.clone();
-        let document_id = document.document_id.to_string();
+        let document_id = document.id.to_string();
         
         let handle = tokio::spawn(async move {
             let start = Instant::now();
@@ -1125,18 +1125,18 @@ async fn test_real_test_images_processing() {
         };
         
         let upload_time = upload_start.elapsed();
-        println!("✅ {} uploaded in {:?}: {}", test_image.filename, upload_time, document.document_id);
+        println!("✅ {} uploaded in {:?}: {}", test_image.filename, upload_time, document.id);
         
         // Wait for OCR processing
         let processing_start = std::time::Instant::now();
-        match client.wait_for_processing(&document.document_id.to_string()).await {
+        match client.wait_for_processing(&document.id.to_string()).await {
             Ok(processed_doc) => {
                 let processing_time = processing_start.elapsed();
                 println!("✅ {} processed in {:?}: status = {:?}", 
                     test_image.filename, processing_time, processed_doc.ocr_status);
                 
                 // Get OCR results and verify content
-                if let Ok(ocr_results) = client.get_ocr_results(&document.document_id.to_string()).await {
+                if let Ok(ocr_results) = client.get_ocr_results(&document.id.to_string()).await {
                     if let Some(ocr_text) = ocr_results["ocr_text"].as_str() {
                         let normalized_ocr = ocr_text.trim().to_lowercase();
                         let normalized_expected = test_image.expected_content.as_ref().map(|s| s.trim().to_lowercase()).unwrap_or_default();

tests/integration_integration_tests.rs

@@ -219,7 +219,7 @@ Technology: Rust + Axum + SQLx"#;
     let document = client.upload_document(test_content, "rust_test.txt").await
         .expect("Failed to upload document");
     
-    println!("✅ Document uploaded: {}", document.document_id);
+    println!("✅ Document uploaded: {}", document.id);
     
     // Validate document response structure using our types
     assert!(!document.filename.is_empty());
@@ -227,18 +227,18 @@ Technology: Rust + Axum + SQLx"#;
     assert_eq!(document.mime_type, "text/plain");
     
     // Wait for OCR processing
-    let ocr_completed = client.wait_for_ocr_completion(&document.document_id.to_string()).await
+    let ocr_completed = client.wait_for_ocr_completion(&document.id.to_string()).await
         .expect("Failed to wait for OCR completion");
     
     assert!(ocr_completed, "OCR processing did not complete within timeout");
     println!("✅ OCR processing completed");
     
     // Retrieve OCR text
-    let ocr_data = client.get_ocr_text(&document.document_id.to_string()).await
+    let ocr_data = client.get_ocr_text(&document.id.to_string()).await
         .expect("Failed to retrieve OCR text");
     
     // Validate OCR response structure
-    assert_eq!(ocr_data["document_id"], document.document_id.to_string());
+    assert_eq!(ocr_data["id"], document.id.to_string());
     assert_eq!(ocr_data["filename"], document.filename);
     assert!(ocr_data["has_ocr_text"].as_bool().unwrap_or(false));
     
@@ -363,7 +363,7 @@ async fn test_document_list_structure() {
         .expect("Failed to parse documents as DocumentResponse");
     
     // Find our uploaded document
-    let found_doc = documents.iter().find(|d| d.id.to_string() == document.document_id.to_string())
+    let found_doc = documents.iter().find(|d| d.id.to_string() == document.id.to_string())
         .expect("Uploaded document should be in list");
     
     // Validate structure matches our types

tests/integration_labels_integration_tests.rs

@@ -397,7 +397,7 @@ async fn test_document_label_assignment() -> Result<(), Box<dyn std::error::Erro
     println!("Uploading test document...");
     let document_content = b"This is a test document for label assignment testing.";
     let document = client.upload_document(document_content, "test_document.txt").await?;
-    let document_id = document["document_id"].as_str().unwrap();
+    let document_id = document["id"].as_str().unwrap();
 
     // Test: Assign single label
     println!("Testing single label assignment...");
@@ -501,7 +501,7 @@ async fn test_system_labels_access() -> Result<(), Box<dyn std::error::Error>> {
     println!("Testing system label assignment...");
     let document_content = b"This is a test document for system label assignment.";
     let document = client.upload_document(document_content, "system_label_test.txt").await?;
-    let document_id = document["document_id"].as_str().unwrap();
+    let document_id = document["id"].as_str().unwrap();
 
     // Find a system label to assign
     let important_label = system_labels.iter()

tests/integration_ocr_corruption_tests.rs

@@ -110,7 +110,7 @@ impl OcrTestClient {
         }
         
         let document: DocumentUploadResponse = response.json().await?;
-        Ok((document.document_id, content.to_string()))
+        Ok((document.id, content.to_string()))
     }
     
     /// Get document details including OCR status
@@ -197,7 +197,7 @@ impl OcrTestClient {
                     }
                     
                     let document: DocumentUploadResponse = response.json().await?;
-                    Ok::<(Uuid, String), Box<dyn std::error::Error>>((document.document_id, content_owned))
+                    Ok::<(Uuid, String), Box<dyn std::error::Error>>((document.id, content_owned))
                 }
             })
             .collect();

tests/integration_ocr_queue_management_tests.rs

@@ -181,7 +181,7 @@ impl OCRQueueTestClient {
         
         let document: DocumentUploadResponse = response.json().await?;
         println!("📄 Document uploaded: {} (filename: {}, size: {})", 
-                 document.document_id, filename, document.file_size);
+                 document.id, filename, document.file_size);
         Ok(document)
     }
     
@@ -322,7 +322,7 @@ async fn test_queue_stats_monitoring() {
     let document = client.upload_document("Test document for queue monitoring", "queue_test.txt").await
         .expect("Failed to upload document");
     
-    println!("✅ Document uploaded: {}", document.document_id);
+    println!("✅ Document uploaded: {}", document.id);
     
     // Wait a moment for queue to update
     sleep(Duration::from_secs(2)).await;

tests/integration_ocr_retry_tests.rs

@@ -247,7 +247,7 @@ impl OcrRetryTestHelper {
         }
         
         let upload_result: Value = response.json().await?;
-        let doc_id = upload_result["document_id"].as_str()
+        let doc_id = upload_result["id"].as_str()
             .ok_or("No document ID in upload response")?
             .to_string();
             
@@ -411,7 +411,7 @@ async fn test_document_retry_history() {
             println!("✅ Document retry history endpoint working");
             
             // Verify response structure
-            assert!(history["document_id"].is_string(), "Should have document_id");
+            assert!(history["id"].is_string(), "Should have document_id");
             assert!(history["retry_history"].is_array(), "Should have retry_history array");
             assert!(history["total_retries"].is_number(), "Should have total_retries count");
             

tests/integration_performance_load_tests.rs

@@ -317,7 +317,7 @@ async fn test_high_volume_document_uploads() {
             let result = client_clone.timed_upload(&content, &filename).await;
             
             match result {
-                Ok((document, duration)) => (i, true, duration, Some(document.document_id.to_string())),
+                Ok((document, duration)) => (i, true, duration, Some(document.id.to_string())),
                 Err(_) => (i, false, Duration::ZERO, None),
             }
         });
@@ -491,7 +491,7 @@ async fn test_search_performance_with_load() {
         
         match client.timed_upload(&content, &filename).await {
             Ok((document, _)) => {
-                document_ids.push(document.document_id.to_string());
+                document_ids.push(document.id.to_string());
             }
             Err(e) => {
                 println!("⚠️  Failed to upload document {}: {}", i, e);

tests/integration_role_based_access_control_tests.rs

@@ -409,7 +409,7 @@ async fn test_document_ownership_isolation() {
         "user1_private.txt"
     ).await.expect("Failed to upload User1 document");
     
-    let user1_doc_id = user1_doc["id"].as_str().expect("Document should have ID");
+    let user1_doc_id = user1_doc["id"].as_str().expect("Document should have document_id");
     println!("✅ User1 uploaded document: {}", user1_doc_id);
     
     // User2 uploads a document
@@ -419,7 +419,7 @@ async fn test_document_ownership_isolation() {
         "user2_private.txt"
     ).await.expect("Failed to upload User2 document");
     
-    let user2_doc_id = user2_doc["id"].as_str().expect("Document should have ID");
+    let user2_doc_id = user2_doc["id"].as_str().expect("Document should have document_id");
     println!("✅ User2 uploaded document: {}", user2_doc_id);
     
     // Test document list isolation