fix

backend/src/services/documents.rs

@@ -9,6 +9,7 @@ use diesel::{
     prelude::*,
     result::DatabaseErrorKind,
     sql_types::Text,
+    Connection,
 };
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Map, Value};
@@ -20,10 +21,9 @@ use uuid::Uuid;
 use crate::documents::{
     asset::{
         build_download_path, derive_document_title, filename_with_retained_extension,
-        load_asset_responses, load_asset_responses_with_conn, load_primary_assets,
-        to_asset_detail_response, to_asset_object_response, to_version_response,
-        DocumentAssetDetailResponse, DocumentAssetResponse, DocumentVersionDetailResponse,
-        DocumentVersionResponse,
+        load_asset_responses_with_conn, load_primary_assets, to_asset_detail_response,
+        to_asset_object_response, to_version_response, DocumentAssetDetailResponse,
+        DocumentAssetResponse, DocumentVersionDetailResponse, DocumentVersionResponse,
     },
     correspondents::{
         insert_document_correspondents, normalize_correspondent_ids, DocumentCorrespondentResponse,
@@ -49,7 +49,7 @@ use crate::schema::{
 };
 use crate::services::{
     correspondents::CorrespondentAssignmentInput, folders::gather_descendant_folder_ids,
-    helpers::load_active_document, TransactionExt,
+    helpers::load_active_document,
 };
 use crate::state::{AppState, PgPooledConnection};
 use crate::utils::{
@@ -372,7 +372,7 @@ impl<'a> DocumentsService<'a> {
             .cloned()
             .unwrap_or_else(|| (Vec::new(), Vec::new()));
 
-        let assets = load_asset_responses(self.state, tenant_id, current_version.id).await?;
+        let assets = load_asset_responses_with_conn(conn, tenant_id, current_version.id)?;
         let current_version_data = Some((to_version_response(current_version), assets));
 
         let response =
@@ -602,7 +602,7 @@ impl<'a> DocumentsService<'a> {
         }
 
         let docs: Vec<Document> = docs_query.load(conn)?;
-        let mut responses = self.hydrate_documents(conn, tenant_id, user_id, docs)?;
+        let mut responses = self.hydrate_documents(conn, user_id, docs)?;
 
         if let Some(order) = quickwit_order {
             let order_map: HashMap<Uuid, usize> = order
@@ -619,7 +619,6 @@ impl<'a> DocumentsService<'a> {
     pub fn hydrate_documents(
         &self,
         conn: &mut PgPooledConnection,
-        tenant_id: Uuid,
         user_id: Uuid,
         docs: Vec<Document>,
     ) -> AppResult<Vec<DocumentResponse>> {
@@ -629,7 +628,7 @@ impl<'a> DocumentsService<'a> {
 
         let doc_ids: Vec<Uuid> = docs.iter().map(|doc| doc.id).collect();
         let mut relations = load_tags_and_correspondents(conn, &doc_ids)?;
-        let primary_versions = load_primary_assets(self.state, tenant_id, &docs)?;
+        let primary_versions = load_primary_assets(conn, &docs)?;
 
         docs.into_iter()
             .map(|doc| {
@@ -644,6 +643,7 @@ impl<'a> DocumentsService<'a> {
 
     pub async fn upload_document(
         &self,
+        conn: &mut PgPooledConnection,
         tenant_id: Uuid,
         user_id: Uuid,
         request: DocumentUploadRequest,
@@ -661,10 +661,8 @@ impl<'a> DocumentsService<'a> {
             skip_if_existing,
         } = request;
 
-        let mut tenant_conn = self.state.db_for_tenant(tenant_id)?;
-
         if let Some(folder) = folder_id {
-            ensure_folder_exists_on_conn(&mut tenant_conn, tenant_id, folder)?;
+            ensure_folder_exists_on_conn(conn, tenant_id, folder)?;
         }
 
         let doc_id = Uuid::new_v4();
@@ -685,7 +683,7 @@ impl<'a> DocumentsService<'a> {
 
         if let Some(reused) = self
             .try_reuse_existing_document(
-                &mut tenant_conn,
+                conn,
                 tenant_id,
                 user_id,
                 &checksum_hex,
@@ -719,7 +717,7 @@ impl<'a> DocumentsService<'a> {
             metadata
         };
 
-        let (document, version) = match tenant_conn.transaction(|conn| {
+        let (document, version) = match conn.transaction(|conn| {
             let new_document = NewDocument {
                 id: doc_id,
                 filename: stored_filename.clone(),
@@ -767,13 +765,7 @@ impl<'a> DocumentsService<'a> {
         };
 
         let detail = {
-            assign_tags_to_document(
-                &mut tenant_conn,
-                tenant_id,
-                &document,
-                &tag_ids,
-                Some(user_id),
-            )?;
+            assign_tags_to_document(conn, tenant_id, &document, &tag_ids, Some(user_id))?;
 
             if !correspondents.is_empty() {
                 let raw_ids: Vec<Uuid> = correspondents
@@ -782,7 +774,7 @@ impl<'a> DocumentsService<'a> {
                     .collect();
                 let correspondent_ids = normalize_correspondent_ids(&raw_ids)?;
                 insert_document_correspondents(
-                    &mut tenant_conn,
+                    conn,
                     tenant_id,
                     document.id,
                     user_id,
@@ -790,8 +782,7 @@ impl<'a> DocumentsService<'a> {
                 )?;
             }
 
-            let tags_and_correspondents =
-                load_tags_and_correspondents(&mut tenant_conn, &[doc_id])?;
+            let tags_and_correspondents = load_tags_and_correspondents(conn, &[doc_id])?;
             let (tags, correspondents) = tags_and_correspondents
                 .get(&doc_id)
                 .cloned()
@@ -809,7 +800,7 @@ impl<'a> DocumentsService<'a> {
         };
 
         if let Err(err) = enqueue_job(
-            &mut tenant_conn,
+            conn,
             tenant_id,
             JOB_ANALYZE_DOCUMENT,
             json!({
@@ -907,12 +898,12 @@ impl<'a> DocumentsService<'a> {
         let document = load_active_document(conn, tenant_id, document_id)?;
 
         let version_id = document.current_version_id;
-        load_asset_responses(self.state, tenant_id, version_id).await
+        Ok(load_asset_responses_with_conn(conn, tenant_id, version_id)?)
     }
 
     pub async fn get_document_asset(
         &self,
-        conn: &mut PgPooledConnection,
+        mut conn: PgPooledConnection,
         tenant_id: Uuid,
         asset_id: Uuid,
         start: i32,
@@ -921,7 +912,7 @@ impl<'a> DocumentsService<'a> {
         let asset: DocumentAsset = match document_assets::table
             .find(asset_id)
             .filter(document_assets::tenant_id.eq(tenant_id))
-            .first(conn)
+            .first(&mut conn)
             .optional()?
         {
             Some(asset) => asset,
@@ -945,7 +936,9 @@ impl<'a> DocumentsService<'a> {
             .filter(document_asset_objects::ordinal.ge(start))
             .filter(document_asset_objects::ordinal.le(end))
             .order(document_asset_objects::ordinal.asc())
-            .load(conn)?;
+            .load(&mut conn)?;
+
+        drop(conn);
 
         let expires_at = Utc::now()
             .timestamp_millis()
@@ -1052,7 +1045,7 @@ impl<'a> DocumentsService<'a> {
         tenant_id: Uuid,
         document_id: Uuid,
     ) -> AppResult<()> {
-        conn.app_transaction(|conn| {
+        conn.transaction::<_, AppError, _>(|conn| {
             let document = documents::table
                 .find(document_id)
                 .filter(documents::tenant_id.eq(tenant_id))
@@ -1154,7 +1147,7 @@ impl<'a> DocumentsService<'a> {
 
         let tags_and_correspondents = load_tags_and_correspondents(conn, &[document_id])?;
         let version_id = current_version.id;
-        let assets = load_asset_responses(self.state, tenant_id, version_id).await?;
+        let assets = load_asset_responses_with_conn(conn, tenant_id, version_id)?;
         let version_response = to_version_response(current_version);
         let (tags, correspondents) = tags_and_correspondents
             .get(&document_id)