links are now in the get method of the backend

server/src/tables_data/handlers/get_table_data.rs

@@ -1,9 +1,10 @@
 // src/tables_data/handlers/get_table_data.rs
+
 use tonic::Status;
 use sqlx::{PgPool, Row};
 use std::collections::HashMap;
 use common::proto::multieko2::tables_data::{GetTableDataRequest, GetTableDataResponse};
-use crate::shared::schema_qualifier::qualify_table_name_for_data; // Import schema qualifier
+use crate::shared::schema_qualifier::qualify_table_name_for_data;
 
 pub async fn get_table_data(
     db_pool: &PgPool,
@@ -48,27 +49,44 @@ pub async fn get_table_data(
             return Err(Status::internal("Invalid column format"));
         }
         let name = parts[0].trim_matches('"').to_string();
-        let sql_type = parts[1].to_string();
+        user_columns.push(name);
-        user_columns.push((name, sql_type));
     }
 
-    // Prepare all columns (system + user-defined)
+    // --- START OF FIX ---
-    let system_columns = vec![
-        ("id".to_string(), "BIGINT".to_string()),
-        ("deleted".to_string(), "BOOLEAN".to_string()),
-    ];
-    let all_columns: Vec<(String, String)> = system_columns
-        .into_iter()
-        .chain(user_columns.into_iter())
-        .collect();
 
-    // Build SELECT clause with COALESCE and type casting
+    // 1. Get all foreign key columns for this table
-    let columns_clause = all_columns
+    let fk_columns_query = sqlx::query!(
+        r#"SELECT ltd.table_name
+        FROM table_definition_links tdl
+        JOIN table_definitions ltd ON tdl.linked_table_id = ltd.id
+        WHERE tdl.source_table_id = $1"#,
+        table_def.id
+    )
+    .fetch_all(db_pool)
+    .await
+    .map_err(|e| Status::internal(format!("Foreign key lookup error: {}", e)))?;
+
+    // 2. Build the list of foreign key column names
+    let mut foreign_key_columns = Vec::new();
+    for fk in fk_columns_query {
+        let base_name = fk.table_name.split_once('_').map_or(fk.table_name.as_str(), |(_, rest)| rest);
+        foreign_key_columns.push(format!("{}_id", base_name));
+    }
+
+    // 3. Prepare a complete list of all columns to select
+    let mut all_column_names = vec!["id".to_string(), "deleted".to_string()];
+    all_column_names.extend(user_columns);
+    all_column_names.extend(foreign_key_columns);
+
+    // 4. Build the SELECT clause with all columns
+    let columns_clause = all_column_names
         .iter()
-        .map(|(name, _)| format!("COALESCE(\"{0}\"::TEXT, '') AS \"{0}\"", name))
+        .map(|name| format!("COALESCE(\"{0}\"::TEXT, '') AS \"{0}\"", name))
         .collect::<Vec<_>>()
         .join(", ");
 
+    // --- END OF FIX ---
+
     // Qualify table name with schema
     let qualified_table = qualify_table_name_for_data(&table_name)?;
 
@@ -87,7 +105,6 @@ pub async fn get_table_data(
         Ok(row) => row,
         Err(sqlx::Error::RowNotFound) => return Err(Status::not_found("Record not found")),
         Err(e) => {
-            // Handle "relation does not exist" error specifically
             if let Some(db_err) = e.as_database_error() {
                 if db_err.code() == Some(std::borrow::Cow::Borrowed("42P01")) {
                     return Err(Status::internal(format!(
@@ -100,9 +117,9 @@ pub async fn get_table_data(
         }
     };
 
-    // Build response data
+    // Build response data from the complete list of columns
     let mut data = HashMap::new();
-    for (column_name, _) in &all_columns {
+    for column_name in &all_column_names {
         let value: String = row
             .try_get(column_name.as_str())
             .map_err(|e| Status::internal(format!("Failed to get column {}: {}", column_name, e)))?;