Bump to v0.1.265; switch macros to rustapi_rs

Release bump to v0.1.265 (Cargo.toml & Cargo.lock) and add RELEASE_NOTES_v0.1.265.md. Update public API examples and procedural-macro references from `rustapi::` to `rustapi_rs::` across README/docs/crates to reflect namespace changes. Add polish and expanded usage/docs content for multiple crates (cargo-rustapi, rustapi-core, extras, jobs, macros, openapi, testing, toon, validate, view, ws) and cookbook pages. Include CLI fixes summarized in release notes (positional name for `cargo rustapi new`, migrate command timeout fix, and doc test adjustment).

Author: Tuntii

CHANGELOG.md

@@ -54,7 +54,7 @@ This release delivers a **12x performance improvement**, bringing RustAPI from ~
 - **Unified Response Body**: Refactored `rustapi-core` to use a unified `Body`/`ResponseBody` abstraction for full and streaming responses. Standardized middleware and cache layers.
 - **Streaming Behavior**: Clarified flow behavior for streaming responses (e.g., explicit `Transfer-Encoding: chunked`).
 - **Server Lifecycle**: Added graceful shutdown signal method for better lifecycle control.
-- **OpenAPI Path Params**: Added support for custom schema type overrides for path parameters via `#[rustapi::param]` and `.param()`.
+- **OpenAPI Path Params**: Added support for custom schema type overrides for path parameters via `#[rustapi_rs::param]` and `.param()`.
 
 ### Fixed
 - **Validation Groups**: Fixed logic for default group application and context boundaries.
@@ -228,16 +228,16 @@ This release delivers a **12x performance improvement**, bringing RustAPI from ~
 - Response types with automatic serialization
 - Async handler support
 - Basic error handling with `ApiError`
-- `#[rustapi::get]`, `#[rustapi::post]` route macros
-- `#[rustapi::main]` async main macro
+- `#[rustapi_rs::get]`, `#[rustapi_rs::post]` route macros
+- `#[rustapi_rs::main]` async main macro
 
 #### Phase 2: Validation & OpenAPI
 - Automatic OpenAPI spec generation
 - Swagger UI at `/docs` endpoint
 - Request validation with validator crate
 - `#[validate]` attribute support
 - 422 Unprocessable Entity for validation errors
-- `#[rustapi::tag]` and `#[rustapi::summary]` macros
+- `#[rustapi_rs::tag]` and `#[rustapi_rs::summary]` macros
 - Schema derivation for request/response types
 
 #### Phase 3: Batteries Included

Cargo.lock

@@ -16,7 +16,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.1.233"
+version = "0.1.265"
 edition = "2021"
 authors = ["RustAPI Contributors"]
 license = "MIT OR Apache-2.0"
@@ -138,3 +138,4 @@ inherits = "release"
 debug = true
 strip = false
 
+

Cargo.toml

@@ -55,12 +55,12 @@ use rustapi_rs::prelude::*;
 #[derive(Serialize, Schema)]
 struct Message { text: String }
 
-#[rustapi::get("/hello/{name}")]
+#[rustapi_rs::get("/hello/{name}")]
 async fn hello(Path(name): Path<String>) -> Json<Message> {
     Json(Message { text: format!("Hello, {}!", name) })
 }
 
-#[rustapi::main]
+#[rustapi_rs::main]
 async fn main() {
     // 1 line to rule them all: Auto-discovery, OpenAPI, Validation
     RustApi::auto().run("127.0.0.1:8080").await

README.md

@@ -1,61 +1,48 @@
 # cargo-rustapi
 
-**The official CLI tool for the RustAPI framework.**
+**Lens**: "The Architect"  
+**Philosophy**: "Scaffolding best practices from day one."
 
-Use this tool to scaffold new projects, generate code, and fast-track your development workflow.
+The RustAPI CLI isn't just a project generator; it's a productivity multiplier.
 
 ## 📦 Installation
 
 ```bash
 cargo install cargo-rustapi
 ```
 
-## 🛠️ Usage
+## 🛠️ Commands
 
-### Creating a New Project
+| Command | Description |
+|---------|-------------|
+| `cargo rustapi new <name>` | Create a new project with the perfect directory structure |
+| `cargo rustapi run` | Run the development server |
+| `cargo rustapi run --reload` | Run with hot-reload (auto-rebuild on file changes) |
+| `cargo rustapi generate resource <name>` | Scaffold a new API resource (Model + Handlers + Tests) |
+| `cargo rustapi client --spec <path> --language <lang>` | Generate a client library (Rust, TS, Python) from OpenAPI spec |
+| `cargo rustapi deploy <platform>` | Generate deployment configs for Docker, Fly.io, Railway, or Shuttle |
+| `cargo rustapi migrate <action>` | Database migration commands (create, run, revert, status, reset) |
 
-Use the `new` command to generate a project structure.
+## 🚀 Quick Start
 
 ```bash
-# Interactive mode (Recommended)
-cargo rustapi new my-app
-
-# Quick start with specific template
+# Create a new project
 cargo rustapi new my-app --template api
-```
-
-**Available Templates:**
-- `minimal`: Basic `main.rs` and `Cargo.toml`.
-- `api`: REST API structure with separated `handlers` and `models`.
-- `web`: Web application with HTML templates (`rustapi-view`).
-- `full`: Complete example with Database, Auth, and Docker support.
 
-### Running Development Server
-
-Run your application with hot-reloading (requires `cargo-watch`).
-
-```bash
-cargo rustapi run
+# Run with auto-reload
+cd my-app
+cargo rustapi run --reload
 ```
 
-### Code Generation
-
-Save time by generating boilerplate.
+## 📁 Templates
 
-```bash
-# Generate a handler function and register it
-cargo rustapi generate handler users
-
-# Generate a database model
-cargo rustapi generate model User
-
-# Generate a full CRUD resource (Model + Handlers + Tests)
-cargo rustapi generate crud product
-```
+The templates used by the CLI are opinionated but flexible. They enforce:
+- Modular folder structure
+- Implementation of `State` pattern
+- Separation of `Error` types
 
-### Managing Migrations (Planned)
-
-```bash
-cargo rustapi migrate run
-cargo rustapi migrate revert
-```
+**Available Templates:**
+- `minimal`: Basic `main.rs` and `Cargo.toml`
+- `api`: REST API structure with separated `handlers` and `models`
+- `web`: Web application with HTML templates (`rustapi-view`)
+- `full`: Complete example with Database, Auth, and Docker support

crates/cargo-rustapi/README.md

@@ -106,3 +106,4 @@ http3-dev = ["http3", "dep:rcgen"]
 
 
 
+

crates/rustapi-core/Cargo.toml

@@ -1,37 +1,58 @@
-# RustAPI Core
+# rustapi-core
 
-**The internal engine of the RustAPI framework.**
+**Lens**: "The Engine"  
+**Philosophy**: "The foundational crate that glues everything together."
 
 > ⚠️ **Warning**: Most users should depend on `rustapi-rs` instead of using this crate directly. This crate's API is subject to change to support the higher-level facade.
 
-## Overview
+## Core Responsibilities
 
-`rustapi-core` handles the low-level HTTP mechanics, leveraging the best-in-class Rust async ecosystem:
+1. **Routing**: Mapping HTTP requests to Handlers
+2. **Extraction**: The `FromRequest` trait definition
+3. **Response**: The `IntoResponse` trait definition
+4. **Middleware**: The `Layer` and `Service` integration with Tower
+5. **HTTP/3**: Built-in QUIC support via `h3` and `quinn` (optional feature)
 
-- **Hyper 1.0**: For robust, correct HTTP/1 and HTTP/2 implementation.
-- **Matchit**: For extremely fast URL routing (radix tree based).
-- **Tower**: For middleware composition (Service, Layer).
-- **Tokio**: For the async runtime.
+## The `Router` Internals
 
-## Key Concepts
+We use `matchit`, a high-performance **Radix Tree** implementation for routing.
 
-### The `RustApi` Builder
-Responsible for assembling routes, middleware, and starting the Hyper server.
+### Why Radix Trees?
+- **Speed**: Lookup time is proportional to the length of the path, not the number of routes
+- **Priority**: Specific paths (`/users/profile`) always take precedence over wildcards (`/users/{id}`)
+- **Parameters**: Efficiently parses named parameters like `{id}` or `*path` without regular expressions
 
-### The `Handler` Trait
-The magic that allows functions with arbitrary arguments (extractors) to be used as request handlers.
+## The `Handler` Trait Magic
 
-```rust
-// This function...
-async fn my_handler(Json(body): Json<MyData>) -> impl Responder { ... }
+The `Handler` trait is what allows you to write functions with arbitrary arguments:
 
-// ...is converted into a Tower Service via the Handler trait.
+```rust
+// This looks simple...
+async fn my_handler(state: State<Db>, json: Json<Data>) { ... }
+
+// ...but under the hood, it compiles to something like:
+impl Handler for my_handler {
+    fn call(req: Request) -> Future<Output=Response> {
+        // 1. Extract State
+        // 2. Extract Json
+        // 3. Call original function
+        // 4. Convert return to Response
+    }
+}
 ```
 
-### Extractors
-`FromRequest` and `FromRequestParts` traits are defined here. They allow type-safe extraction of data from HTTP requests.
+This is achieved through **recursive trait implementations** on tuples. RustAPI supports handlers with up to **16 arguments**.
+
+## Middleware Architecture
+
+`rustapi-core` is built on top of `tower`. This means any standard Tower middleware works out of the box.
+
+```rust
+// The Service stack looks like an onion:
+// Outer Layer (Timeout)
+//  -> Middle Layer (Trace)
+//      -> Inner Layer (Router)
+//          -> Handler
+```
 
-- `Json<T>`
-- `Query<T>`
-- `Path<T>`
-- `State<T>`
+When you call `.layer()`, you are wrapping the inner service with a new outer layer.