feat: include organization info in /admin/users endpoint (#153)

Author: think-in-universe

crates/api/src/conversions.rs

@@ -540,6 +540,7 @@ pub fn db_user_to_admin_user(user: &database::User) -> AdminUserResponse {
         created_at: user.created_at,
         last_login_at: user.last_login_at,
         is_active: user.is_active,
+        organizations: None,
     }
 }
 

crates/api/src/models.rs

@@ -952,6 +952,16 @@ pub struct PublicUserResponse {
     pub created_at: DateTime<Utc>,
 }
 
+/// Organization details with spend limit (for admin user listing)
+#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
+pub struct AdminUserOrganizationDetails {
+    pub id: String,
+    pub name: String,
+    pub description: Option<String>,
+    #[serde(rename = "spendLimit", skip_serializing_if = "Option::is_none")]
+    pub spend_limit: Option<SpendLimit>,
+}
+
 /// Admin user response model (for owners/admins)
 /// Contains sensitive information only visible to organization owners/admins
 #[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
@@ -964,6 +974,8 @@ pub struct AdminUserResponse {
     pub created_at: DateTime<Utc>,
     pub last_login_at: Option<DateTime<Utc>>,
     pub is_active: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub organizations: Option<Vec<AdminUserOrganizationDetails>>,
 }
 
 /// User response model (full user profile)
@@ -1337,7 +1349,7 @@ pub struct SpendLimitRequest {
 /// Examples:
 ///   $100.00 USD: amount=100000000000, scale=9, currency="USD"
 ///   $0.01 USD: amount=10000000, scale=9, currency="USD"
-#[derive(Debug, Serialize, Deserialize, ToSchema)]
+#[derive(Debug, Serialize, Deserialize, ToSchema, Clone)]
 pub struct SpendLimit {
     pub amount: i64,
     pub scale: i64,

crates/api/src/routes/admin.rs

@@ -1,9 +1,10 @@
 use crate::middleware::AdminUser;
 use crate::models::{
-    AdminAccessTokenResponse, AdminUserResponse, BatchUpdateModelApiRequest,
-    CreateAdminAccessTokenRequest, DecimalPrice, DeleteAdminAccessTokenRequest, ErrorResponse,
-    ListUsersResponse, ModelHistoryEntry, ModelHistoryResponse, ModelMetadata, ModelWithPricing,
-    OrgLimitsHistoryEntry, OrgLimitsHistoryResponse, SpendLimit, UpdateOrganizationLimitsRequest,
+    AdminAccessTokenResponse, AdminUserOrganizationDetails, AdminUserResponse,
+    BatchUpdateModelApiRequest, CreateAdminAccessTokenRequest, DecimalPrice,
+    DeleteAdminAccessTokenRequest, ErrorResponse, ListUsersResponse, ModelHistoryEntry,
+    ModelHistoryResponse, ModelMetadata, ModelWithPricing, OrgLimitsHistoryEntry,
+    OrgLimitsHistoryResponse, SpendLimit, UpdateOrganizationLimitsRequest,
     UpdateOrganizationLimitsResponse,
 };
 use axum::{
@@ -159,8 +160,8 @@ pub async fn batch_upsert_models(
     tag = "Admin",
     params(
         ("model_name" = String, Path, description = "Model name to get complete history for (URL-encode if it contains slashes)"),
-        ("limit" = i64, Query, description = "Maximum number of history entries to return (default: 50)"),
-        ("offset" = i64, Query, description = "Number of history entries to skip (default: 0)")
+        ("limit" = Option<i64>, Query, description = "Maximum number of history entries to return (default: 50)"),
+        ("offset" = Option<i64>, Query, description = "Number of history entries to skip (default: 0)")
     ),
     responses(
         (status = 200, description = "Model history retrieved successfully", body = ModelHistoryResponse),
@@ -372,8 +373,8 @@ pub async fn update_organization_limits(
     tag = "Admin",
     params(
         ("organization_id" = String, Path, description = "The organization's ID (as a UUID)"),
-        ("limit" = i64, Query, description = "Maximum number of history records to return (default: 50)"),
-        ("offset" = i64, Query, description = "Number of records to skip (default: 0)")
+        ("limit" = Option<i64>, Query, description = "Maximum number of history records to return (default: 50)"),
+        ("offset" = Option<i64>, Query, description = "Number of records to skip (default: 0)")
     ),
     responses(
         (status = 200, description = "Limits history retrieved successfully", body = OrgLimitsHistoryResponse),
@@ -543,8 +544,9 @@ pub async fn delete_model(
     path = "/admin/users",
     tag = "Admin",
     params(
-        ("limit" = i64, Query, description = "Maximum number of users to return (default: 50)"),
-        ("offset" = i64, Query, description = "Number of users to skip (default: 0)")
+        ("limit" = Option<i64>, Query, description = "Maximum number of users to return (default: 100)"),
+        ("offset" = Option<i64>, Query, description = "Number of users to skip (default: 0)"),
+        ("include_organizations" = Option<bool>, Query, description = "Whether to include organization information and spend limits for the first organization owned by each user (default: false)")
     ),
     responses(
         (status = 200, description = "Users retrieved successfully", body = ListUsersResponse),
@@ -563,44 +565,104 @@ pub async fn list_users(
     crate::routes::common::validate_limit_offset(params.limit, params.offset)?;
 
     debug!(
-        "List users request with limit={}, offset={}",
-        params.limit, params.offset
+        "List users request with limit={}, offset={}, include_organizations={}",
+        params.limit, params.offset, params.include_organizations
     );
 
-    let (users, total) = app_state
-        .admin_service
-        .list_users(params.limit, params.offset)
-        .await
-        .map_err(|e| {
-            error!("Failed to list users");
-            match e {
-                services::admin::AdminError::Unauthorized(msg) => (
-                    StatusCode::UNAUTHORIZED,
-                    ResponseJson(ErrorResponse::new(msg, "unauthorized".to_string())),
-                ),
-                _ => (
-                    StatusCode::INTERNAL_SERVER_ERROR,
-                    ResponseJson(ErrorResponse::new(
-                        "Failed to retrieve users".to_string(),
-                        "internal_server_error".to_string(),
-                    )),
-                ),
-            }
-        })?;
-
-    let user_responses: Vec<AdminUserResponse> = users
-        .into_iter()
-        .map(|u| AdminUserResponse {
-            id: u.id.to_string(),
-            email: u.email,
-            username: Some(u.username),
-            display_name: u.display_name,
-            avatar_url: u.avatar_url,
-            created_at: u.created_at,
-            last_login_at: u.last_login_at,
-            is_active: u.is_active,
-        })
-        .collect();
+    let (user_responses, total) = if params.include_organizations {
+        // Fetch users with their default organization and spend limit
+        let (users_with_orgs, total) = app_state
+            .admin_service
+            .list_users_with_organizations(params.limit, params.offset)
+            .await
+            .map_err(|e| {
+                error!("Failed to list users with organizations");
+                match e {
+                    services::admin::AdminError::Unauthorized(msg) => (
+                        StatusCode::UNAUTHORIZED,
+                        ResponseJson(ErrorResponse::new(msg, "unauthorized".to_string())),
+                    ),
+                    _ => (
+                        StatusCode::INTERNAL_SERVER_ERROR,
+                        ResponseJson(ErrorResponse::new(
+                            "Failed to retrieve users".to_string(),
+                            "internal_server_error".to_string(),
+                        )),
+                    ),
+                }
+            })?;
+
+        let responses: Vec<AdminUserResponse> = users_with_orgs
+            .into_iter()
+            .map(|(u, org_data)| {
+                let organizations = org_data.map(|org_info| {
+                    vec![AdminUserOrganizationDetails {
+                        id: org_info.id.to_string(),
+                        name: org_info.name,
+                        description: org_info.description,
+                        spend_limit: org_info.spend_limit.map(|amount| SpendLimit {
+                            amount,
+                            scale: 9,
+                            currency: "USD".to_string(),
+                        }),
+                    }]
+                });
+
+                AdminUserResponse {
+                    id: u.id.to_string(),
+                    email: u.email,
+                    username: Some(u.username),
+                    display_name: u.display_name,
+                    avatar_url: u.avatar_url,
+                    created_at: u.created_at,
+                    last_login_at: u.last_login_at,
+                    is_active: u.is_active,
+                    organizations,
+                }
+            })
+            .collect();
+
+        (responses, total)
+    } else {
+        // Return users data only
+        let (users, total) = app_state
+            .admin_service
+            .list_users(params.limit, params.offset)
+            .await
+            .map_err(|e| {
+                error!("Failed to list users");
+                match e {
+                    services::admin::AdminError::Unauthorized(msg) => (
+                        StatusCode::UNAUTHORIZED,
+                        ResponseJson(ErrorResponse::new(msg, "unauthorized".to_string())),
+                    ),
+                    _ => (
+                        StatusCode::INTERNAL_SERVER_ERROR,
+                        ResponseJson(ErrorResponse::new(
+                            "Failed to retrieve users".to_string(),
+                            "internal_server_error".to_string(),
+                        )),
+                    ),
+                }
+            })?;
+
+        let responses: Vec<AdminUserResponse> = users
+            .into_iter()
+            .map(|u| AdminUserResponse {
+                id: u.id.to_string(),
+                email: u.email,
+                username: Some(u.username),
+                display_name: u.display_name,
+                avatar_url: u.avatar_url,
+                created_at: u.created_at,
+                last_login_at: u.last_login_at,
+                is_active: u.is_active,
+                organizations: None,
+            })
+            .collect();
+
+        (responses, total)
+    };
 
     let response = ListUsersResponse {
         users: user_responses,
@@ -703,7 +765,7 @@ pub async fn create_admin_access_token(
     path = "/admin/access-tokens",
     tag = "Admin",
     params(
-        ("limit" = Option<i64>, Query, description = "Number of records to return (default: 50)"),
+        ("limit" = Option<i64>, Query, description = "Number of records to return (default: 100)"),
         ("offset" = Option<i64>, Query, description = "Number of records to skip (default: 0)")
     ),
     responses(
@@ -858,6 +920,8 @@ pub struct ListUsersQueryParams {
     pub limit: i64,
     #[serde(default)]
     pub offset: i64,
+    #[serde(default)]
+    pub include_organizations: bool,
 }
 
 #[derive(Debug, serde::Deserialize)]