!

Author: Tuntii

examples/auth-api/src/main.rs

@@ -151,6 +151,9 @@ async fn login(
 // ============================================
 
 /// Get current user's profile (requires authentication)
+#[rustapi_rs::get("/protected/profile")]
+#[rustapi_rs::tag("Protected")]
+#[rustapi_rs::summary("Get Profile")]
 async fn get_profile(AuthUser(claims): AuthUser<Claims>) -> Json<UserProfile> {
     Json(UserProfile {
         user_id: claims.sub,
@@ -160,6 +163,9 @@ async fn get_profile(AuthUser(claims): AuthUser<Claims>) -> Json<UserProfile> {
 }
 
 /// Admin-only endpoint
+#[rustapi_rs::get("/protected/admin")]
+#[rustapi_rs::tag("Protected")]
+#[rustapi_rs::summary("Admin Only")]
 async fn admin_only(AuthUser(claims): AuthUser<Claims>) -> Result<Json<Message>, ApiError> {
     if claims.role != "admin" {
         return Err(ApiError::forbidden("Admin access required"));
@@ -171,6 +177,9 @@ async fn admin_only(AuthUser(claims): AuthUser<Claims>) -> Result<Json<Message>,
 }
 
 /// Protected data endpoint
+#[rustapi_rs::get("/protected/data")]
+#[rustapi_rs::tag("Protected")]
+#[rustapi_rs::summary("Protected Data")]
 async fn get_protected_data(AuthUser(claims): AuthUser<Claims>) -> Json<Message> {
     Json(Message {
         message: format!("Secret data for user: {}", claims.username),
@@ -203,7 +212,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     // Create the app with JWT middleware for protected routes
     // Public routes (/health, /auth/login, /) are excluded from JWT validation
     // Docs has its own Basic Auth protection
-    let app = RustApi::new()
+    // Phase 6 / zero-config: routes + schemas are auto-registered via macros.
+    // We use `config().build()` to auto-mount routes first, then attach docs with Basic Auth.
+    let app = RustApi::config()
+        .docs_enabled(false)
         .body_limit(1024 * 1024) // 1MB limit
         .layer(RequestIdLayer::new())
         .layer(TracingLayer::new())
@@ -216,18 +228,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
             "/auth/login",
             "/",
         ]))
-        .register_schema::<LoginRequest>()
-        .register_schema::<LoginResponse>()
-        .register_schema::<UserProfile>()
-        .register_schema::<Message>()
-        // Public routes
-        .mount_route(welcome_route())
-        .mount_route(health_route())
-        .mount_route(login_route())
-        // Protected routes
-        .route("/protected/profile", get(get_profile))
-        .route("/protected/admin", get(admin_only))
-        .route("/protected/data", get(get_protected_data))
+        .build()
         // Docs with Basic Auth protection
         .docs_with_auth("/docs", "docs", "docs123");
 

examples/crud-api/src/main.rs

@@ -322,24 +322,13 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     println!();
     println!("Server running at http://127.0.0.1:8080");
 
-    RustApi::new()
+    // Phase 6 / zero-config: routes + schemas are auto-registered via macros.
+    // Swagger UI is enabled at /docs by default (when built with swagger-ui feature).
+    RustApi::auto()
         .state(store)
         .body_limit(1024 * 1024) // 1MB limit
         .layer(RequestIdLayer::new())
         .layer(TracingLayer::new())
-        .register_schema::<Task>()
-        .register_schema::<CreateTask>()
-        .register_schema::<UpdateTask>()
-        .register_schema::<PatchTask>()
-        .register_schema::<PaginatedTasks>()
-        .mount_route(list_tasks_route())
-        .mount_route(get_task_route())
-        .mount_route(create_task_route())
-        .mount_route(update_task_route())
-        .mount_route(patch_task_route())
-        .mount_route(delete_task_route())
-        .mount_route(health_route())
-        .docs("/docs")
         .run("127.0.0.1:8080")
         .await
 }

examples/hello-world/src/main.rs

@@ -117,15 +117,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     println!("  GET  /docs      - Swagger UI");
     println!();
 
-    RustApi::new()
-        .register_schema::<UserResponse>()
-        .register_schema::<CreateUser>()
-        .mount_route(hello_route())
-        .mount_route(health_route())
-        .mount_route(get_user_route())
-        .mount_route(create_user_route())
-        .mount_route(search_users_route())
-        .docs("/docs") // Enable Swagger UI!
-        .run("127.0.0.1:8080")
-        .await
+    // Phase 6 / zero-config: routes + schemas are auto-registered via macros.
+    // Swagger UI is enabled at /docs by default (when built with swagger-ui feature).
+    RustApi::auto().run("127.0.0.1:8080").await
 }

examples/proof-of-concept/src/handlers/auth.rs

@@ -10,6 +10,9 @@ use crate::stores::AppState;
 use crate::{JWT_SECRET, TOKEN_EXPIRY_SECS};
 
 /// Register a new user
+#[rustapi_rs::post("/auth/register")]
+#[rustapi_rs::tag("Auth")]
+#[rustapi_rs::summary("Register")]
 async fn register(
     State(state): State<Arc<AppState>>,
     ValidatedJson(body): ValidatedJson<RegisterRequest>,
@@ -59,6 +62,9 @@ async fn register(
 }
 
 /// Login with email and password
+#[rustapi_rs::post("/auth/login")]
+#[rustapi_rs::tag("Auth")]
+#[rustapi_rs::summary("Login")]
 async fn login(
     State(state): State<Arc<AppState>>,
     ValidatedJson(body): ValidatedJson<LoginRequest>,
@@ -103,12 +109,3 @@ async fn login(
         },
     }))
 }
-
-// Route functions
-pub fn register_route() -> Route {
-    post_route("/auth/register", register)
-}
-
-pub fn login_route() -> Route {
-    post_route("/auth/login", login)
-}

examples/proof-of-concept/src/handlers/bookmarks.rs

@@ -11,6 +11,9 @@ use crate::models::{
 use crate::stores::AppState;
 
 /// List bookmarks with pagination and filtering
+#[rustapi_rs::get("/bookmarks")]
+#[rustapi_rs::tag("Bookmarks")]
+#[rustapi_rs::summary("List Bookmarks")]
 async fn list_bookmarks(
     State(state): State<Arc<AppState>>,
     AuthUser(claims): AuthUser<Claims>,
@@ -66,6 +69,9 @@ async fn list_bookmarks(
 }
 
 /// Create a new bookmark
+#[rustapi_rs::post("/bookmarks")]
+#[rustapi_rs::tag("Bookmarks")]
+#[rustapi_rs::summary("Create Bookmark")]
 async fn create_bookmark(
     State(state): State<Arc<AppState>>,
     AuthUser(claims): AuthUser<Claims>,
@@ -98,6 +104,9 @@ async fn create_bookmark(
 }
 
 /// Get a single bookmark by ID
+#[rustapi_rs::get("/bookmarks/{id}")]
+#[rustapi_rs::tag("Bookmarks")]
+#[rustapi_rs::summary("Get Bookmark")]
 async fn get_bookmark(
     State(state): State<Arc<AppState>>,
     AuthUser(claims): AuthUser<Claims>,
@@ -120,6 +129,9 @@ async fn get_bookmark(
 }
 
 /// Update a bookmark
+#[rustapi_rs::put("/bookmarks/{id}")]
+#[rustapi_rs::tag("Bookmarks")]
+#[rustapi_rs::summary("Update Bookmark")]
 async fn update_bookmark(
     State(state): State<Arc<AppState>>,
     AuthUser(claims): AuthUser<Claims>,
@@ -174,6 +186,9 @@ async fn update_bookmark(
 }
 
 /// Delete a bookmark
+#[rustapi_rs::delete("/bookmarks/{id}")]
+#[rustapi_rs::tag("Bookmarks")]
+#[rustapi_rs::summary("Delete Bookmark")]
 async fn delete_bookmark(
     State(state): State<Arc<AppState>>,
     AuthUser(claims): AuthUser<Claims>,
@@ -203,6 +218,9 @@ async fn delete_bookmark(
 }
 
 /// Export bookmarks as JSON
+#[rustapi_rs::get("/bookmarks/export")]
+#[rustapi_rs::tag("Bookmarks")]
+#[rustapi_rs::summary("Export Bookmarks")]
 async fn export_bookmarks(
     State(state): State<Arc<AppState>>,
     AuthUser(claims): AuthUser<Claims>,
@@ -235,6 +253,9 @@ async fn export_bookmarks(
 }
 
 /// Import bookmarks from JSON
+#[rustapi_rs::post("/bookmarks/import")]
+#[rustapi_rs::tag("Bookmarks")]
+#[rustapi_rs::summary("Import Bookmarks")]
 async fn import_bookmarks(
     State(state): State<Arc<AppState>>,
     AuthUser(claims): AuthUser<Claims>,
@@ -294,32 +315,3 @@ async fn import_bookmarks(
         errors,
     })
 }
-
-// Route functions
-pub fn list_bookmarks_route() -> Route {
-    get_route("/bookmarks", list_bookmarks)
-}
-
-pub fn create_bookmark_route() -> Route {
-    post_route("/bookmarks", create_bookmark)
-}
-
-pub fn get_bookmark_route() -> Route {
-    get_route("/bookmarks/{id}", get_bookmark)
-}
-
-pub fn update_bookmark_route() -> Route {
-    put_route("/bookmarks/{id}", update_bookmark)
-}
-
-pub fn delete_bookmark_route() -> Route {
-    delete_route("/bookmarks/{id}", delete_bookmark)
-}
-
-pub fn export_bookmarks_route() -> Route {
-    get_route("/bookmarks/export", export_bookmarks)
-}
-
-pub fn import_bookmarks_route() -> Route {
-    post_route("/bookmarks/import", import_bookmarks)
-}

examples/proof-of-concept/src/handlers/categories.rs

@@ -10,6 +10,9 @@ use crate::models::{
 use crate::stores::AppState;
 
 /// List categories
+#[rustapi_rs::get("/categories")]
+#[rustapi_rs::tag("Categories")]
+#[rustapi_rs::summary("List Categories")]
 async fn list_categories(
     State(state): State<Arc<AppState>>,
     AuthUser(claims): AuthUser<Claims>,
@@ -28,6 +31,9 @@ async fn list_categories(
 }
 
 /// Create a new category
+#[rustapi_rs::post("/categories")]
+#[rustapi_rs::tag("Categories")]
+#[rustapi_rs::summary("Create Category")]
 async fn create_category(
     State(state): State<Arc<AppState>>,
     AuthUser(claims): AuthUser<Claims>,
@@ -59,6 +65,9 @@ async fn create_category(
 }
 
 /// Update a category
+#[rustapi_rs::put("/categories/{id}")]
+#[rustapi_rs::tag("Categories")]
+#[rustapi_rs::summary("Update Category")]
 async fn update_category(
     State(state): State<Arc<AppState>>,
     AuthUser(claims): AuthUser<Claims>,
@@ -102,6 +111,9 @@ async fn update_category(
 }
 
 /// Delete a category
+#[rustapi_rs::delete("/categories/{id}")]
+#[rustapi_rs::tag("Categories")]
+#[rustapi_rs::summary("Delete Category")]
 async fn delete_category(
     State(state): State<Arc<AppState>>,
     AuthUser(claims): AuthUser<Claims>,
@@ -128,20 +140,3 @@ async fn delete_category(
 
     Ok(NoContent)
 }
-
-// Route functions
-pub fn list_categories_route() -> Route {
-    get_route("/categories", list_categories)
-}
-
-pub fn create_category_route() -> Route {
-    post_route("/categories", create_category)
-}
-
-pub fn update_category_route() -> Route {
-    put_route("/categories/{id}", update_category)
-}
-
-pub fn delete_category_route() -> Route {
-    delete_route("/categories/{id}", delete_category)
-}

examples/proof-of-concept/src/handlers/events.rs

@@ -8,6 +8,9 @@ use crate::stores::AppState;
 
 /// SSE event stream endpoint - placeholder for now
 /// Real SSE implementation would require ResponseModifier for Sse type
+#[rustapi_rs::get("/events")]
+#[rustapi_rs::tag("Events")]
+#[rustapi_rs::summary("SSE Events")]
 async fn events(
     State(_state): State<Arc<AppState>>,
     AuthUser(_claims): AuthUser<Claims>,
@@ -18,8 +21,3 @@ async fn events(
         version: "SSE endpoint - use EventSource to connect".to_string(),
     })
 }
-
-// Route function
-pub fn events_route() -> Route {
-    get_route("/events", events)
-}

examples/proof-of-concept/src/handlers/mod.rs

@@ -10,13 +10,12 @@ use rustapi_rs::prelude::*;
 use crate::models::HealthResponse;
 
 /// Health check endpoint
+#[rustapi_rs::get("/health")]
+#[rustapi_rs::tag("System")]
+#[rustapi_rs::summary("Health Check")]
 async fn health() -> Json<HealthResponse> {
     Json(HealthResponse {
         status: "ok".to_string(),
         version: env!("CARGO_PKG_VERSION").to_string(),
     })
 }
-
-pub fn health_route() -> Route {
-    get_route("/health", health)
-}

examples/proof-of-concept/src/main.rs

@@ -62,9 +62,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     // Initialize application state
     let state = Arc::new(AppState::new());
 
-    // Create the app
-    let app = RustApi::new()
-        .state(state)
+    // Phase 6 / zero-config: routes + schemas are auto-registered via macros.
+    // We use `config()` so we can attach layers/body limit while still using auto routes.
+    let app = RustApi::config()
         .body_limit(1024 * 1024) // 1MB limit
         .layer(RequestIdLayer::new())
         .layer(TracingLayer::new())
@@ -77,42 +77,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
             "/auth/login",
             "/static",
         ]))
-        // Register schemas
-        .register_schema::<models::RegisterRequest>()
-        .register_schema::<models::LoginRequest>()
-        .register_schema::<models::AuthResponse>()
-        .register_schema::<models::UserInfo>()
-        .register_schema::<models::CreateBookmarkRequest>()
-        .register_schema::<models::UpdateBookmarkRequest>()
-        .register_schema::<models::BookmarkResponse>()
-        .register_schema::<models::CreateCategoryRequest>()
-        .register_schema::<models::UpdateCategoryRequest>()
-        .register_schema::<models::CategoryResponse>()
-        .register_schema::<models::CategoryListResponse>()
-        .register_schema::<models::ExportResponse>()
-        .register_schema::<models::ErrorResponse>()
-        // Auth routes
-        .mount_route(handlers::auth::register_route())
-        .mount_route(handlers::auth::login_route())
-        // Bookmark routes
-        .mount_route(handlers::bookmarks::list_bookmarks_route())
-        .mount_route(handlers::bookmarks::create_bookmark_route())
-        .mount_route(handlers::bookmarks::get_bookmark_route())
-        .mount_route(handlers::bookmarks::update_bookmark_route())
-        .mount_route(handlers::bookmarks::delete_bookmark_route())
-        .mount_route(handlers::bookmarks::export_bookmarks_route())
-        .mount_route(handlers::bookmarks::import_bookmarks_route())
-        // Category routes
-        .mount_route(handlers::categories::list_categories_route())
-        .mount_route(handlers::categories::create_category_route())
-        .mount_route(handlers::categories::update_category_route())
-        .mount_route(handlers::categories::delete_category_route())
-        // SSE events
-        .mount_route(handlers::events::events_route())
-        // Health check
-        .mount_route(handlers::health_route())
-        // Docs
-        .docs("/docs");
+        .build()
+        .state(state);
 
     app.run("127.0.0.1:8080").await
 }