Add total upstream count retrieval to UpstreamService

apps/api/src/errors/api_error.rs

@@ -1,14 +1,17 @@
 use axum::response::IntoResponse;
 use sea_orm::DbErr;
+use tracing::error;
 
 use crate::errors::service_error::ServiceError;
 
+#[derive(Debug)]
 pub enum ApiError {
     ServiceError(ServiceError),
 }
 
 impl From<ServiceError> for ApiError {
     fn from(err: ServiceError) -> Self {
+        error!("Service error occurred: {:?}", err);
         ApiError::ServiceError(err)
     }
 }
@@ -21,6 +24,7 @@ impl From<DbErr> for ApiError {
 
 impl IntoResponse for ApiError {
     fn into_response(self) -> axum::response::Response {
+        error!("API error occurred: {:?}", self);
         match self {
             ApiError::ServiceError(service_error) => service_error.into_response(),
         }

apps/api/src/middlewares.rs

@@ -9,7 +9,7 @@ use axum::{
     http::{HeaderValue, Method, StatusCode, Uri},
 };
 use tower::{ServiceBuilder, timeout::TimeoutLayer};
-use tower_http::cors::{AllowHeaders, AllowOrigin, CorsLayer};
+use tower_http::cors::{AllowHeaders, AllowMethods, AllowOrigin, CorsLayer};
 use tracing::warn;
 
 use crate::{configs::server::CORSSettings, routes::AppState};
@@ -34,6 +34,7 @@ pub fn apply_root_middleware(
 pub fn get_cors_layer(cors_settings: Arc<CORSSettings>) -> CorsLayer {
     let mut cors_layer = CorsLayer::new()
         .allow_credentials(true)
+        .allow_methods(AllowMethods::mirror_request())
         .allow_headers(AllowHeaders::mirror_request());
 
     let allowed_origins = &cors_settings.allowed_origins;

apps/api/src/routes/api/restricted/nginx/upstream/create_upstream.rs

@@ -83,7 +83,7 @@ impl From<CreateUpstreamRequestBody> for ConcreteCreateUpstreamRequestBody {
 #[axum::debug_handler]
 #[utoipa::path(
     post,
-    path = "/api/upstreams",
+    path = "/api/nginx/upstreams",
     request_body = CreateUpstreamRequestBody,
     responses(
         (status = 200, description = "Upstream created successfully", body = UpstreamInfoResponse),

apps/api/src/routes/api/restricted/nginx/upstream/create_upstream_target.rs

@@ -51,7 +51,7 @@ impl From<CreateUpstreamTargetInfo> for ConcreteCreateUpstreamTargetInfo {
 #[axum::debug_handler]
 #[utoipa::path(
     post,
-    path = "/api/upstreams/{upstream_id}/targets",
+    path = "/api/nginx/upstreams/{upstream_id}/targets",
     request_body = CreateUpstreamTargetInfo,
     responses(
         (status = 200, description = "Upstream target created successfully", body = UpstreamTargetInfoResponse),

apps/api/src/routes/api/restricted/nginx/upstream/get_upstream.rs

@@ -42,7 +42,7 @@ impl From<GetUpstreamParams> for ConcreteGetUpstreamParams {
 
 #[utoipa::path(
     get,
-    path = "/api/upstreams",
+    path = "/api/nginx/upstreams",
     responses(
         (status = 200, description = "List upstreams", body = UpstreamListResponse),
         (status = 500, description = "Internal server error"),
@@ -54,16 +54,32 @@ pub async fn get_upstream_list(
     State(state): State<Arc<AppState>>,
 ) -> AxumResult<Json<UpstreamListResponse>, ServiceError> {
     let upstream_service = &state.service.nginx.get_upstream_service();
-    let upstreams = upstream_service
+
-        .get_upstreams(Some(pagination.clone().into()), None)
+    let (upstreams_res, upstream_count_res) = tokio::join!(
-        .await?;
+        upstream_service.get_upstreams(
+            Some(pagination.clone().into()),
+            Some(GetUpstreamOptions {
+                include_targets: true,
+                filter_by_enabled: false,
+            }),
+            None,
+        ),
+        upstream_service.get_total_upstreams(None, None),
+    );
+
+    let upstreams = upstreams_res?;
+    let upstream_count = upstream_count_res?;
 
     //
     Ok(Json(UpstreamListResponse {
         items: upstreams.into_iter().map(|u| u.into()).collect(),
         pagination: PaginationInfo {
-            total_items: 0,
+            total_items: upstream_count,
-            total_pages: 0,
+            total_pages: if upstream_count == 0 {
+                0
+            } else {
+                (upstream_count as f32 / pagination.per_page as f32).ceil() as u32
+            },
             current_page: pagination.page,
             per_page: pagination.per_page,
         },
@@ -72,7 +88,7 @@ pub async fn get_upstream_list(
 
 #[utoipa::path(
     get,
-    path = "/api/upstreams/{upstream_id}",
+    path = "/api/nginx/upstreams/{upstream_id}",
     responses(
         (status = 200, description = "Get upstream info", body = UpstreamInfoResponse),
         (status = 404, description = "Not found"),
@@ -93,6 +109,7 @@ pub async fn get_upstream(
                 upstream_id,
                 Some(GetUpstreamOptions {
                     include_targets: true,
+                    filter_by_enabled: false,
                 }),
                 None,
             )
@@ -110,19 +127,21 @@ pub async fn get_upstream(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::sync::Arc;
+    use std::{collections::BTreeMap, sync::Arc};
 
     use axum::http::StatusCode;
     use axum_test::TestServer;
-    use sea_orm::{DatabaseBackend, DatabaseConnection, MockDatabase};
+    use sea_orm::{DatabaseBackend, DatabaseConnection, MockDatabase, Value};
 
     use database::generated::entities::{upstream, upstream_target};
 
-    use crate::configs::{FromConfig, ProgramSettings};
+    use crate::{
-
+        configs::{FromConfig, ProgramSettings},
-    use crate::routes::api::restricted::nginx::upstream::get_upstream_router;
+        routes::api::restricted::nginx::upstream::{
-    use crate::routes::api::restricted::nginx::upstream::info::response::UpstreamInfoResponse;
+            get_upstream_router, info::response::UpstreamInfoResponse,
-    use crate::services::get_app_service;
+        },
+        services::get_app_service,
+    };
 
     fn get_router_with_state(db: DatabaseConnection) -> axum::Router {
         let program_settings = ProgramSettings::mock();
@@ -159,7 +178,14 @@ mod tests {
         };
 
         let db = MockDatabase::new(DatabaseBackend::Sqlite)
-            .append_query_results(vec![vec![u1.clone(), u2.clone()]])
+            .append_query_results(vec![vec![
+                (u1.clone(), None::<upstream_target::Model>),
+                (u2.clone(), None::<upstream_target::Model>),
+            ]])
+            .append_query_results(vec![vec![BTreeMap::from([(
+                "count".to_string(),
+                Value::BigInt(Some(2)),
+            )])]])
             .into_connection();
 
         let router = get_router_with_state(db.clone());
@@ -170,6 +196,7 @@ mod tests {
         let body = res.json::<UpstreamListResponse>();
         assert_eq!(body.items.len(), 2);
         assert_eq!(body.pagination.current_page, 1u32);
+        assert_eq!(body.pagination.total_pages, 1u32);
     }
 
     #[tokio::test]
@@ -222,6 +249,10 @@ mod tests {
     async fn extractor_pagination_validation_rejects_bad_values() {
         let db = MockDatabase::new(DatabaseBackend::Sqlite)
             .append_query_results(vec![Vec::<sea_orm::MockRow>::new()])
+            .append_query_results(vec![vec![BTreeMap::from([(
+                "count".to_string(),
+                Value::BigInt(Some(0)),
+            )])]])
             .into_connection();
         let router = get_router_with_state(db.clone());
         let server = TestServer::new(router).expect("failed to create test server");
@@ -293,6 +324,10 @@ mod tests {
     async fn handler_get_upstream_list_empty_returns_empty_items() {
         let db = MockDatabase::new(DatabaseBackend::Sqlite)
             .append_query_results(vec![Vec::<sea_orm::MockRow>::new()])
+            .append_query_results(vec![vec![BTreeMap::from([(
+                "count".to_string(),
+                Value::BigInt(Some(0)),
+            )])]])
             .into_connection();
 
         let router = get_router_with_state(db.clone());

apps/api/src/routes/api/restricted/nginx/upstream/get_upstream_target.rs

@@ -38,7 +38,7 @@ impl From<GetUpstreamTargetsParams> for ConcreteGetUpstreamTargetsParams {
 
 #[utoipa::path(
     get,
-    path = "/api/upstream_targets/{upstream_target_id}",
+    path = "/api/nginx/upstream_targets/{upstream_target_id}",
     responses(
         (status = 200, description = "Get upstream target info", body = UpstreamTargetInfo),
         (status = 404, description = "Not found"),

apps/api/src/routes/api/restricted/nginx/upstream/remove_upstream.rs

@@ -16,7 +16,7 @@ use crate::{
 
 #[utoipa::path(
     delete,
-    path = "/api/upstreams/{upstream_id}",
+    path = "/api/nginx/upstreams/{upstream_id}",
     responses(
         (status = 200, description = "Upstream removed successfully", body = ()),
         (status = 401, description = "Unauthorized"),

apps/api/src/routes/api/restricted/nginx/upstream/remove_upstream_target.rs

@@ -16,7 +16,7 @@ use crate::{
 
 #[utoipa::path(
     delete,
-    path = "/api/upstream_targets/{upstream_target_id}",
+    path = "/api/nginx/upstream_targets/{upstream_target_id}",
     responses(
         (status = 200, description = "Upstream target removed successfully", body = ()),
         (status = 401, description = "Unauthorized"),

apps/api/src/routes/api/restricted/nginx/upstream/update_upstream.rs

@@ -50,7 +50,7 @@ impl From<UpdateUpstreamRequestBody> for UpdateUpstreamInfo {
 
 #[utoipa::path(
     patch,
-    path = "/api/upstreams/{upstream_id}",
+    path = "/api/nginx/upstreams/{upstream_id}",
     request_body = UpdateUpstreamRequestBody,
     responses(
         (status = 200, description = "Upstream updated successfully", body = UpdateUpstreamInfoResponse),

apps/api/src/routes/api/restricted/nginx/upstream/update_upstream_target.rs

@@ -42,7 +42,7 @@ impl From<UpdateUpstreamTargetRequestBody> for UpdateUpstreamTargetInfo {
 
 #[utoipa::path(
     patch,
-    path = "/api/upstream_targets/{upstream_target_id}",
+    path = "/api/nginx/upstream_targets/{upstream_target_id}",
     request_body = UpdateUpstreamTargetRequestBody,
     responses(
         (status = 200, description = "Upstream target updated successfully", body = UpdateUpstreamTargetInfoResponse),

apps/api/src/routes/api/restricted/user/me.rs

@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
 use axum::{
-    Extension, Json,
+    Json,
     extract::State,
     http::StatusCode,
     response::{IntoResponse, Response},
@@ -10,7 +10,7 @@ use serde::{Deserialize, Serialize};
 use tracing::error;
 
 use crate::{
-    middlewares::request_info::RequestInfo,
+    middlewares::request_info::AuthenticatedRequestInfo,
     routes::{AppState, api::openapi::tag::USER_TAG},
 };
 
@@ -38,15 +38,9 @@ pub struct UserInfo {
     )]
 pub async fn get_user_info(
     State(app_state): State<Arc<AppState>>,
-    request_info: Extension<Arc<RequestInfo>>,
+    request_info: AuthenticatedRequestInfo,
 ) -> Response {
-    let user_id = match request_info.user_id {
+    let user_id = request_info.user_id;
-        Some(id) => id,
-        None => {
-            error!("User ID not found in request info");
-            return (StatusCode::UNAUTHORIZED).into_response();
-        }
-    };
 
     match app_state.service.user.get_user_by_id(user_id, None).await {
         Ok(user) => {

apps/api/src/services/agent_client.rs

@@ -8,7 +8,7 @@ use agent_client::{
     },
     models::{ValidateAndReloadBody, ValidateBody, WriteConfigBody},
 };
-use tracing::warn;
+use tracing::{error, warn};
 
 use crate::{configs::agent::AgentSettings, errors::service_error::ServiceError};
 
@@ -23,6 +23,7 @@ pub enum AgentError {
 
 impl From<AgentError> for ServiceError {
     fn from(err: AgentError) -> Self {
+        error!("Agent error occurred: {:?}", err);
         match err {
             AgentError::ValidationFailed(_internal, user) => ServiceError::InternalError(user),
             AgentError::ApplicationFailed(_internal, user) => ServiceError::InternalError(user),

apps/api/src/services/nginx/builder.rs

@@ -36,7 +36,8 @@ impl NginxConfigProvider for NginxConfigBuilder {
         }
 
         // TODO: Add other sections like servers, locations, etc.
-
+        // trailing newline for file ending
+        config.push('\n');
         config
     }
 }

apps/api/src/services/nginx/info/upstream.rs

@@ -2,6 +2,7 @@ use chrono::{DateTime, Utc};
 
 use database::generated::entities::{upstream, upstream_target};
 use sea_orm::ActiveValue::{Set, Unchanged};
+use tracing::warn;
 use uuid::Uuid;
 
 use crate::{
@@ -13,6 +14,8 @@ use crate::{
     set_if_some,
 };
 
+const PLACEHOLDER_TARGET: &str = "server 127.0.0.1:65535 down; # placeholder target";
+
 #[derive(Clone)]
 pub struct UpstreamInfo {
     pub id: Uuid,
@@ -55,12 +58,53 @@ impl NginxConfigProvider for UpstreamInfo {
             .map(|target| target.to_nginx_config(Some(indent.unwrap_or(0) + INDENT_SIZE)))
             .collect();
 
-        format!(
+        let mut targets_config_str = {
-            "upstream {} {{\n{}\n}}",
+            let config_str = match self.algorithm.as_str() {
-            self.name,
+                "least-conn" => "least_conn",
-            targets_config.join("\n".indent(indent.unwrap_or(0) + INDENT_SIZE).as_str())
+                "ip-hash" => "ip_hash",
-        )
+                "round-robin" => "",
-        .indent(indent.unwrap_or(0))
+                v => {
+                    // TODO: allow arbitrary algorithms via config extensions/plugins
+                    warn!(
+                        "Unknown upstream algorithm '{}', defaulting to 'round-robin'",
+                        v
+                    );
+                    ""
+                }
+            }
+            .to_string();
+            // TODO: add support for sticky session / checking for nginx sticky module existence
+            // if self.sticky_session {
+            //   config_str.push_str("sticky")
+            // }
+            if config_str.trim().is_empty() {
+                String::new()
+            } else {
+                config_str + ";"
+            }
+        }
+        .indent(indent.unwrap_or(0) + INDENT_SIZE * 2);
+        targets_config_str.push('\n');
+
+        targets_config_str.push_str(
+            &(if targets_config.is_empty() {
+                // add placeholder if no targets
+                PLACEHOLDER_TARGET.to_string()
+            } else {
+                // normal targets
+                targets_config.join("\n")
+            }
+            .indent(indent.unwrap_or(0) + INDENT_SIZE)),
+        );
+
+        // add placeholder if all targets are backup
+        if self.upstream_targets.iter().all(|v| v.is_backup) {
+            targets_config_str.push('\n');
+            targets_config_str
+                .push_str(&PLACEHOLDER_TARGET.indent(indent.unwrap_or(0) + INDENT_SIZE));
+        }
+
+        format!("upstream {} {{\n{}\n}}", self.name, targets_config_str).indent(indent.unwrap_or(0))
     }
 }
 
@@ -106,6 +150,17 @@ impl From<upstream::Model> for UpstreamInfo {
     }
 }
 
+impl From<(upstream::Model, Option<Vec<upstream_target::Model>>)> for UpstreamInfo {
+    fn from(data: (upstream::Model, Option<Vec<upstream_target::Model>>)) -> Self {
+        let (upstream_model, upstream_target_models) = data;
+        if let Some(targets) = upstream_target_models {
+            UpstreamInfo::from((upstream_model, targets))
+        } else {
+            UpstreamInfo::from(upstream_model)
+        }
+    }
+}
+
 impl From<(upstream::Model, Vec<upstream_target::Model>)> for UpstreamInfo {
     fn from(data: (upstream::Model, Vec<upstream_target::Model>)) -> Self {
         let (upstream_model, upstream_target_models) = data;

apps/api/src/services/nginx/info/upstream_target.rs

@@ -130,7 +130,7 @@ impl From<UpstreamTargetCreateInfo> for upstream_target::ActiveModel {
 impl NginxConfigProvider for UpstreamTargetInfo {
     fn to_nginx_config(&self, indent: Option<usize>) -> String {
         format!(
-            "{}:{} weight={}{}{}",
+            "server {}:{} weight={}{}{};",
             self.target_host,
             self.target_port,
             self.weight,

apps/api/src/services/nginx/upstream.rs

@@ -1,8 +1,8 @@
 use std::sync::Arc;
 
 use sea_orm::{
-    ActiveModelTrait, ColumnTrait, DatabaseConnection, DatabaseTransaction, EntityTrait,
+    ActiveModelTrait, ColumnTrait, DatabaseConnection, DatabaseTransaction, EntityTrait, ExprTrait,
-    ModelTrait, QueryFilter, QuerySelect, TransactionTrait,
+    FromQueryResult, ModelTrait, QueryFilter, QuerySelect, QueryTrait, TransactionTrait,
 };
 
 use database::generated::entities::{upstream, upstream_target};
@@ -29,6 +29,11 @@ pub trait UpstreamService: Send + Sync {
         create_info: UpstreamCreateInfo,
         tx: Option<&mut DatabaseTransaction>,
     ) -> Result<UpstreamInfo, ServiceError>;
+    async fn get_total_upstreams(
+        &self,
+        options: Option<UpstreamTotalCountOptions>,
+        tx: Option<&mut DatabaseTransaction>,
+    ) -> Result<u64, ServiceError>;
     async fn get_upstream(
         &self,
         upstream_id: uuid::Uuid,
@@ -38,6 +43,7 @@ pub trait UpstreamService: Send + Sync {
     async fn get_upstreams(
         &self,
         pagination: Option<PaginationFilter>,
+        options: Option<GetUpstreamOptions>,
         tx: Option<&mut DatabaseTransaction>,
     ) -> Result<Vec<UpstreamInfo>, ServiceError>;
     async fn update_upstream(
@@ -93,8 +99,12 @@ pub struct UpstreamServiceImpl {
 #[derive(Default)]
 pub struct GetUpstreamOptions {
     pub include_targets: bool,
+    pub filter_by_enabled: bool,
 }
 
+#[allow(dead_code)]
+pub struct UpstreamTotalCountOptions {}
+
 #[derive(Default)]
 pub struct GetUpstreamTargetOptions {
     pub include_upstream: bool,
@@ -150,6 +160,27 @@ impl UpstreamService for UpstreamServiceImpl {
         Ok(r.into())
     }
 
+    async fn get_total_upstreams(
+        &self,
+        _options: Option<UpstreamTotalCountOptions>,
+        tx: Option<&mut DatabaseTransaction>,
+    ) -> Result<u64, ServiceError> {
+        #[derive(Debug, FromQueryResult)]
+        struct CountResult {
+            // The field name must match the column alias in the query
+            count: i64,
+        }
+        let count_info = with_conn!(&*self.connection, tx, conn, {
+            upstream::Entity::find()
+                .select_only()
+                .column_as(upstream::Column::Id, "count")
+                .into_model::<CountResult>()
+                .one(*conn)
+                .await?
+        });
+        Ok(count_info.map_or(0, |c| c.count) as u64)
+    }
+
     async fn get_upstream(
         &self,
         upstream_id: uuid::Uuid,
@@ -168,6 +199,9 @@ impl UpstreamService for UpstreamServiceImpl {
                     )))?;
                 let targets = upstream_target::Entity::find()
                     .filter(upstream_target::Column::UpstreamId.eq(upstream_id))
+                    .apply_if(Some(concrete_options.filter_by_enabled), |query, _v| {
+                        query.filter(upstream_target::Column::Enabled.eq(true))
+                    })
                     .all(*conn)
                     .await?;
                 (up, targets)
@@ -191,6 +225,7 @@ impl UpstreamService for UpstreamServiceImpl {
     async fn get_upstreams(
         &self,
         pagination: Option<PaginationFilter>,
+        options: Option<GetUpstreamOptions>,
         tx: Option<&mut DatabaseTransaction>,
     ) -> Result<Vec<UpstreamInfo>, ServiceError> {
         let r = with_conn!(&*self.connection, tx, conn, {
@@ -201,7 +236,24 @@ impl UpstreamService for UpstreamServiceImpl {
             } else {
                 find_query
             };
-            find_query.all(*conn).await?
+            let find_query = match options {
+                Some(opts) => {
+                    if opts.include_targets && opts.filter_by_enabled {
+                        find_query.filter(
+                            upstream_target::Column::Enabled
+                                .eq(true)
+                                .or(upstream_target::Column::Id.is_null()),
+                        )
+                    } else {
+                        find_query
+                    }
+                }
+                _ => find_query,
+            };
+            find_query
+                .find_with_related(upstream_target::Entity)
+                .all(*conn)
+                .await?
         });
 
         Ok(r.into_iter().map(|m| m.into()).collect())
@@ -375,7 +427,9 @@ impl UpstreamService for UpstreamServiceImpl {
         });
         let active_model = target.apply_to_model(current_model);
 
-        let r = active_model.update(&*self.connection).await?;
+        let r = with_conn!(&*self.connection, tx, conn, {
+            active_model.update(*conn).await?
+        });
         Ok(r.into())
     }
 
@@ -505,6 +559,7 @@ mod tests {
                 up_id,
                 Some(GetUpstreamOptions {
                     include_targets: true,
+                    filter_by_enabled: false,
                 }),
                 None,
             )
@@ -554,12 +609,15 @@ mod tests {
         };
 
         let db = MockDatabase::new(DatabaseBackend::Sqlite)
-            .append_query_results(vec![vec![u1.clone(), u2.clone()]])
+            .append_query_results(vec![vec![
+                (u1.clone(), None::<upstream_target::Model>),
+                (u2.clone(), None::<upstream_target::Model>),
+            ]])
             .into_connection();
 
         let svc = UpstreamServiceImpl::new(Arc::new(db));
 
-        let res = svc.get_upstreams(None, None).await;
+        let res = svc.get_upstreams(None, None, None).await;
         assert!(res.is_ok());
         let list = res.expect("Failed to get upstreams");
         assert_eq!(list.len(), 2);

apps/api/swagger.json

@@ -106,7 +106,7 @@
         }
       }
     },
-    "/api/upstream_targets/{upstream_target_id}": {
+    "/api/nginx/upstream_targets/{upstream_target_id}": {
       "get": {
         "tags": [
           "Nginx"
@@ -232,7 +232,7 @@
         }
       }
     },
-    "/api/upstreams": {
+    "/api/nginx/upstreams": {
       "get": {
         "tags": [
           "Nginx"
@@ -292,7 +292,7 @@
         }
       }
     },
-    "/api/upstreams/{upstream_id}": {
+    "/api/nginx/upstreams/{upstream_id}": {
       "get": {
         "tags": [
           "Nginx"
@@ -418,7 +418,7 @@
         }
       }
     },
-    "/api/upstreams/{upstream_id}/targets": {
+    "/api/nginx/upstreams/{upstream_id}/targets": {
       "post": {
         "tags": [
           "Nginx"

apps/frontend/app/generated/api-client/api-client.ts

@@ -151,7 +151,7 @@ export namespace Endpoints {
   };
   export type get_Get_upstream_target = {
     method: "GET";
-    path: "/api/upstream_targets/{upstream_target_id}";
+    path: "/api/nginx/upstream_targets/{upstream_target_id}";
     requestFormat: "json";
     parameters: {
       path: { upstream_target_id: string };
@@ -160,7 +160,7 @@ export namespace Endpoints {
   };
   export type delete_Remove_upstream_target = {
     method: "DELETE";
-    path: "/api/upstream_targets/{upstream_target_id}";
+    path: "/api/nginx/upstream_targets/{upstream_target_id}";
     requestFormat: "json";
     parameters: {
       path: { upstream_target_id: string };
@@ -169,7 +169,7 @@ export namespace Endpoints {
   };
   export type patch_Update_upstream_target = {
     method: "PATCH";
-    path: "/api/upstream_targets/{upstream_target_id}";
+    path: "/api/nginx/upstream_targets/{upstream_target_id}";
     requestFormat: "json";
     parameters: {
       path: { upstream_target_id: string };
@@ -186,14 +186,14 @@ export namespace Endpoints {
   };
   export type get_Get_upstream_list = {
     method: "GET";
-    path: "/api/upstreams";
+    path: "/api/nginx/upstreams";
     requestFormat: "json";
     parameters: never;
     responses: { 200: Schemas.UpstreamListResponse; 500: unknown };
   };
   export type post_Create_upstream = {
     method: "POST";
-    path: "/api/upstreams";
+    path: "/api/nginx/upstreams";
     requestFormat: "json";
     parameters: {
       body: Schemas.CreateUpstreamRequestBody;
@@ -202,7 +202,7 @@ export namespace Endpoints {
   };
   export type get_Get_upstream = {
     method: "GET";
-    path: "/api/upstreams/{upstream_id}";
+    path: "/api/nginx/upstreams/{upstream_id}";
     requestFormat: "json";
     parameters: {
       path: { upstream_id: string };
@@ -211,7 +211,7 @@ export namespace Endpoints {
   };
   export type delete_Remove_upstream = {
     method: "DELETE";
-    path: "/api/upstreams/{upstream_id}";
+    path: "/api/nginx/upstreams/{upstream_id}";
     requestFormat: "json";
     parameters: {
       path: { upstream_id: string };
@@ -220,7 +220,7 @@ export namespace Endpoints {
   };
   export type patch_Update_upstream = {
     method: "PATCH";
-    path: "/api/upstreams/{upstream_id}";
+    path: "/api/nginx/upstreams/{upstream_id}";
     requestFormat: "json";
     parameters: {
       path: { upstream_id: string };
@@ -231,7 +231,7 @@ export namespace Endpoints {
   };
   export type post_Add_upstream_target = {
     method: "POST";
-    path: "/api/upstreams/{upstream_id}/targets";
+    path: "/api/nginx/upstreams/{upstream_id}/targets";
     requestFormat: "json";
     parameters: {
       body: Schemas.CreateUpstreamTargetInfo;
@@ -254,23 +254,23 @@ export type EndpointByMethod = {
   post: {
     "/api/auth/init_admin": Endpoints.post_Init_admin;
     "/api/auth/login": Endpoints.post_Login;
-    "/api/upstreams": Endpoints.post_Create_upstream;
+    "/api/nginx/upstreams": Endpoints.post_Create_upstream;
-    "/api/upstreams/{upstream_id}/targets": Endpoints.post_Add_upstream_target;
+    "/api/nginx/upstreams/{upstream_id}/targets": Endpoints.post_Add_upstream_target;
   };
   get: {
     "/api/health/info": Endpoints.get_Get_health_info;
-    "/api/upstream_targets/{upstream_target_id}": Endpoints.get_Get_upstream_target;
+    "/api/nginx/upstream_targets/{upstream_target_id}": Endpoints.get_Get_upstream_target;
-    "/api/upstreams": Endpoints.get_Get_upstream_list;
+    "/api/nginx/upstreams": Endpoints.get_Get_upstream_list;
-    "/api/upstreams/{upstream_id}": Endpoints.get_Get_upstream;
+    "/api/nginx/upstreams/{upstream_id}": Endpoints.get_Get_upstream;
     "/api/user/me": Endpoints.get_Get_user_info;
   };
   delete: {
-    "/api/upstream_targets/{upstream_target_id}": Endpoints.delete_Remove_upstream_target;
+    "/api/nginx/upstream_targets/{upstream_target_id}": Endpoints.delete_Remove_upstream_target;
-    "/api/upstreams/{upstream_id}": Endpoints.delete_Remove_upstream;
+    "/api/nginx/upstreams/{upstream_id}": Endpoints.delete_Remove_upstream;
   };
   patch: {
-    "/api/upstream_targets/{upstream_target_id}": Endpoints.patch_Update_upstream_target;
+    "/api/nginx/upstream_targets/{upstream_target_id}": Endpoints.patch_Update_upstream_target;
-    "/api/upstreams/{upstream_id}": Endpoints.patch_Update_upstream;
+    "/api/nginx/upstreams/{upstream_id}": Endpoints.patch_Update_upstream;
   };
 };