Create initial project structure (Frontend)

CHANGELOG.md

@@ -7,3 +7,4 @@ Bob Management GUI changelog
 #### Added
 
 - Initial project structure, backend only (#9)
+- Initial project stricture, frontend (#10)

Cargo.toml

@@ -30,3 +30,4 @@ codegen-units = 1
 [profile.min-size]
 inherits = "release"
 opt-level = "s"
+

README.md

@@ -1,2 +1,51 @@
 # bob-management
-Management UI for Bob
+
+Management UI for Bob
+
+## Commands
+
+Build backend server:
+
+```sh
+cargo build-backend
+```
+
+Run backend server:
+
+```sh
+cargo run-backend
+```
+
+Build frontend and move it into the backend's executable directory:
+
+```sh
+cargo build-frontend
+```
+
+---
+
+Run debug build (Backend + Frontend):
+
+```sh
+cargo run -- --default
+```
+
+---
+
+Make release build (Backend + Frontend):
+
+```sh
+cargo build --profile=release-lto
+```
+
+To run release build with default configuration:
+
+```sh
+cargo run --profile=release-lto -- --default
+```
+
+Or you can specify configuration file:
+
+```sh
+cargo run --profile=release-lto -- --config-file config.yaml
+```

backend/Cargo.toml

@@ -1,6 +1,7 @@
 [package]
 name = "backend"
-description = "Bob Management GUI"
+default-run = "backend"
+description = "Bob Management GUI: Backend"
 publish = false
 keywords = [ "BOB", "Management", "GUI" ]
 version.workspace = true
@@ -18,7 +19,7 @@ axum-macros = "0.3"
 axum-login = "0.6"
 axum-sessions = "0.5"
 tower = "0.4"
-tower-http = { version = "0.4", features = ["cors"] }
+tower-http = { version = "0.4", features = ["cors", "fs"] }
 
 ## Logging
 tracing = "0.1"
@@ -29,19 +30,23 @@ error-stack = "0.4"
 thiserror = "1.0"
 
 ## General
-tokio = { version = "1.32", features = ["rt", "macros", "rt-multi-thread"] }
+tokio = { version = "1.32", features = ["rt", "macros", "rt-multi-thread" ] }
 hyper = "0.14"
+lazy_static = "1.4"
 
 ## OpenAPI + Swagger
-utoipa = { version = "3.4", features = ["axum_extras",  "chrono", "openapi_extensions"], optional = true }
-utoipa-swagger-ui = { version = "3.1", features = ["axum"], optional = true }
-utoipa-redoc = { version = "0.1", features = ["axum"], optional = true }
-utoipa-rapidoc = { version = "0.1", features = ["axum"], optional = true }
+utoipa = { version = "4.0", features = ["yaml", "axum_extras",  "chrono", "openapi_extensions"], optional = true }
+utoipa-swagger-ui = { version = "4.0", features = ["axum"], optional = true }
+utoipa-redoc = { version = "1.0", features = ["axum"], optional = true }
+utoipa-rapidoc = { version = "1.0", features = ["axum"], optional = true }
 
 ## CLI
 cli = { path = "../cli" }
 
-[features]
-default = [ "swagger" ]
-swagger = [ "utoipa", "utoipa-swagger-ui" , "utoipa-redoc", "utoipa-rapidoc" ]
+## Frontend
+frontend = { path = "../frontend", optional = true }
 
+[features]
+default = [ "swagger", "frontend-bundle" ]
+swagger = [ "dep:utoipa", "dep:utoipa-swagger-ui" , "dep:utoipa-redoc", "dep:utoipa-rapidoc" ]
+frontend-bundle = [ "dep:frontend" ]

backend/src/error.rs

@@ -1,4 +1,5 @@
 #![allow(clippy::module_name_repetitions)]
+
 use axum::response::{IntoResponse, Response};
 use hyper::StatusCode;
 use thiserror::Error;

backend/src/lib.rs

@@ -1,21 +1,33 @@
-#![allow(clippy::multiple_crate_versions)]
+#![allow(clippy::multiple_crate_versions, clippy::module_name_repetitions)]
+
+#[cfg(all(feature = "swagger", debug_assertions))]
+use axum::{routing::get, Router};
 
-#[cfg(feature = "swagger")]
-use axum::Router;
-#[cfg(feature = "swagger")]
 use utoipa::OpenApi;
+
 pub mod config;
 pub mod connector;
 pub mod error;
 pub mod models;
+pub mod router;
 pub mod services;
 
+#[derive(OpenApi)]
+#[cfg_attr(not(all(feature = "swagger", debug_assertions)), openapi())]
+#[cfg_attr(all(feature = "swagger", debug_assertions), openapi(
+    paths(root),
+    tags(
+        (name = "bob", description = "BOB management API")
+    )
+))]
+pub struct ApiDoc;
+
 // [TEMP]
 // TODO: Remove when the actual API will be implemented
 #[allow(clippy::unused_async)]
-#[cfg_attr(feature = "swagger", utoipa::path(
+#[cfg_attr(all(feature = "swagger", debug_assertions), utoipa::path(
         get,
-        path = "/",
+        path = "/root",
         responses(
             (status = 200, description = "Hello Bob!")
         )
@@ -25,35 +37,40 @@ pub async fn root() -> &'static str {
 }
 
 /// Generate openapi documentation for the project
-#[cfg(feature = "swagger")]
+#[cfg(all(feature = "swagger", debug_assertions))]
 pub fn openapi_doc() -> Router {
     use utoipa_rapidoc::RapiDoc;
     use utoipa_redoc::{Redoc, Servable};
     use utoipa_swagger_ui::SwaggerUi;
 
     /* Swagger-only routes */
-    #[derive(OpenApi)]
-    #[openapi(
-                paths(root),
-                tags(
-                    (name = "bob", description = "BOB management API")
-                )
-            )]
-    struct ApiDoc;
+    tracing::info!("Swagger ui available at /swagger-ui");
+
     /* Mount Swagger ui */
     Router::new()
         .merge(SwaggerUi::new("/swagger-ui").url("/api-docs/openapi.json", ApiDoc::openapi()))
         .merge(Redoc::with_url("/redoc", ApiDoc::openapi()))
         // There is no need to create `RapiDoc::with_openapi` because the OpenApi is served
         // via SwaggerUi instead we only make rapidoc to point to the existing doc.
         .merge(RapiDoc::new("/api-docs/openapi.json").path("/rapidoc"))
+        .route(
+            "/api-docs/openapi.yaml",
+            get(|| async {
+                ApiDoc::openapi()
+                    .to_yaml()
+                    .expect("Couldn't produce .yaml API scheme")
+            }),
+        )
     // Alternative to above
     // .merge(RapiDoc::with_openapi("/api-docs/openapi2.json", ApiDoc::openapi()).path("/rapidoc"))
 }
 
 pub mod prelude {
     #![allow(unused_imports)]
     pub use crate::error::AppError;
+    pub use crate::router::RouteError;
     pub use axum::response::Result as AxumResult;
     pub use error_stack::{Context, Report, Result, ResultExt};
+    // #[cfg(all(feature = "swagger", debug_assertions))]
+    pub use utoipa::OpenApi;
 }

backend/src/main.rs

@@ -1,14 +1,24 @@
 #![allow(clippy::multiple_crate_versions)]
 
-use axum::{routing::get, Router};
-use backend::{config::ConfigExt, prelude::*, root, services::api_router};
+use axum::Router;
+use backend::{
+    config::ConfigExt,
+    prelude::*,
+    root,
+    router::{NoApi, RouterApiExt},
+    services::api_router,
+    ApiDoc,
+};
 use cli::Parser;
 use error_stack::{Result, ResultExt};
-use std::path::PathBuf;
+use hyper::Method;
+use std::{env, path::PathBuf};
 use tower::ServiceBuilder;
-use tower_http::cors::CorsLayer;
+use tower_http::{cors::CorsLayer, services::ServeDir};
 use tracing::Level;
 
+const FRONTEND_FOLDER: &str = "frontend";
+
 #[tokio::main]
 #[allow(clippy::unwrap_used, clippy::expect_used)]
 async fn main() -> Result<(), AppError> {
@@ -28,7 +38,7 @@ async fn main() -> Result<(), AppError> {
     tracing::info!("Listening on {addr}");
 
     let app = router(cors);
-    #[cfg(feature = "swagger")]
+    #[cfg(all(feature = "swagger", debug_assertions))]
     let app = app.merge(backend::openapi_doc());
 
     axum::Server::bind(&addr)
@@ -46,10 +56,22 @@ fn init_tracer(_log_file: &Option<PathBuf>, trace_level: Level) {
 }
 
 fn router(cors: CorsLayer) -> Router {
-    // Add api
-    Router::new()
-        // Unsecured Routes
-        .route("/", get(root))
+    let mut frontend = env::current_exe().expect("Couldn't get current executable path.");
+    frontend.pop();
+    frontend.push(FRONTEND_FOLDER);
+    tracing::info!("serving frontend at: {frontend:?}");
+    let router = Router::new()
+        // Frontend
+        .nest_service("/", ServeDir::new(frontend));
+
+    // Add API
+    let router = router
+        .with_context::<NoApi, ApiDoc>()
+        .api_route("/root", Method::GET, root)
+        .expect("Couldn't register new API route")
+        .no_context();
+    // .no_context();
+    router
         .nest("/api", api_router())
         .layer(ServiceBuilder::new().layer(cors))
 }