autumn-web 0.4.0

//! # Autumn
//!
//! An opinionated, convention-over-configuration web framework for Rust.
//!
//! Autumn assembles proven Rust crates ([Axum], [Maud], [Diesel], htmx, Tailwind)
//! into a Spring Boot-style developer experience with proc-macro-driven
//! conventions and customization options at every level.
//!
//! ## Quick start
//!
//! ```rust,no_run
//! use autumn_web::prelude::*;
//!
//! #[get("/")]
//! async fn index() -> Markup {
//!     html! { h1 { "Hello, Autumn!" } }
//! }
//!
//! #[autumn_web::main]
//! async fn main() {
//!     autumn_web::app()
//!         .routes(routes![index])
//!         .run()
//!         .await;
//! }
//! ```
//!
//! ## Architecture overview
//!
//! | Layer | Crate | Purpose |
//! |-------|-------|---------|
//! | HTTP server | [Axum] | Routing, extractors, middleware |
//! | HTML templates | [Maud] | Type-safe, compiled HTML via `html!` macro |
//! | Database | [Diesel] | Async Postgres via `diesel-async` + deadpool |
//! | Client interactivity | htmx | Embedded JS served from same-origin `/static/js/` routes |
//! | Styling | Tailwind CSS | Downloaded + managed by `autumn-cli` |
//!
//! ## Modules
//!
//! - [`mod@app`] -- Application builder for configuring and launching the server.
//! - [`config`] -- Layered configuration: defaults, `autumn.toml`, env overrides.
//! - [`db`] -- Database connection pool and the [`Db`] request extractor.
//! - [`error`] -- Framework error type ([`AutumnError`]) and result alias.
//! - [`extract`] -- Re-exported Axum extractors ([`Form`],
//!   [`Json`], [`Path`], [`Query`], and optional multipart support).
//! - [`health`] -- Compatibility alias for readiness plus legacy health helpers.

//! - [`middleware`] -- Built-in middleware (request IDs).
//! - [`pagination`] -- Standardized `page`/`size` extractor and response wrapper.
//! - [`prelude`] -- Glob import for the most common types.

//!
//! ## Zero-config defaults
//!
//! An Autumn app runs out of the box with no configuration file. Every
//! setting has a sensible default (port 3000, `info` log level, etc.).
//! Override via `autumn.toml` or `AUTUMN_*` environment variables.
//! See [`config::AutumnConfig`] for the full list.
//!
//! [Axum]: https://docs.rs/axum
//! [Maud]: https://maud.lambda.xyz
//! [Diesel]: https://diesel.rs

// Allow `::autumn_web::` paths generated by proc macros to resolve
// within this crate itself (needed for tests and doctests).
#[allow(unused_extern_crates)]
extern crate self as autumn_web;

pub mod actuator;
pub mod app;
pub mod assets;
pub mod audit;
pub mod auth;
pub mod authorization;
pub mod cache;
#[cfg(feature = "ws")]
pub mod channels;
#[cfg(feature = "ws")]
pub use channels::{
    Broadcast, BroadcastError, BroadcastPayload, ChannelBackendConfigError, ChannelMessage,
    ChannelPublishError, ChannelStats, Channels, ChannelsBackend, LocalChannelsBackend,
};
pub mod config;
#[cfg(feature = "db")]
pub mod db;
pub mod error;
pub mod error_pages;
pub mod extract;
pub mod health;
#[cfg(feature = "db")]
pub mod hooks;
#[cfg(feature = "i18n")]
pub mod i18n;
/// Translation lookup macro with compile-time key validation.
///
/// Re-exported from [`crate::i18n::t`] for ergonomic
/// `autumn_web::t!(locale, "key")` usage.
#[cfg(feature = "i18n")]
pub use crate::i18n::t;
#[cfg(feature = "mail")]
pub mod mail;
#[cfg(feature = "db")]
pub mod migrate;
pub mod plugin;
pub mod plugin_conformance;
pub mod probe;
#[cfg(feature = "system-info")]
pub mod system_info;
pub use plugin::{Plugin, Plugins};

pub mod route_listing;

#[cfg(feature = "db")]
pub mod repository;
#[cfg(feature = "db")]
pub use repository::RepositoryError;

/// Router construction and integration with Axum.
///
/// This module is responsible for taking the application's configuration,
/// defined routes, middleware, and state, and building the final `axum::Router`
/// that will handle incoming HTTP requests.
pub(crate) mod router;

#[cfg(feature = "db")]
pub use hooks::{
    DraftField, FieldDiff, MutationContext, MutationHooks, MutationOp, NoHooks, Patch, UpdateDraft,
};
#[cfg(feature = "flash")]
pub mod flash;
#[cfg(feature = "htmx")]
pub(crate) mod htmx;
pub(crate) mod logging;
pub mod middleware;
pub mod openapi;
pub mod pagination;
pub mod paths;
pub mod prelude;
pub use paths::PathExt;
pub(crate) mod route;
pub use route::{RepositoryApiMeta, Route};
pub mod scheduler;
pub mod security;
pub mod session;
#[cfg(feature = "redis")]
pub(crate) mod session_redis;
pub mod sse;
/// Static site generation support.
pub mod static_gen;
#[cfg(feature = "storage")]
pub mod storage;

pub mod form;
pub mod job;
#[cfg(feature = "seed")]
pub mod seed;
pub mod task;
pub mod telemetry;
pub mod ui;
/// Changeset type carrying submitted values + per-field errors.
pub use form::Changeset;
/// Changeset form extractor — decodes body + validates, captures errors in [`form::Changeset`].
pub use form::ChangesetForm;
/// Trait implemented for all `validator::Validate` types to produce a [`Changeset`].
pub use form::IntoChangeset;
pub mod validation;
pub mod webhook;
#[cfg(feature = "ws")]
pub mod ws;

/// Private runtime helpers for code generated by Autumn proc macros.
///
/// This module is semver-exempt. Do not use it directly.
#[doc(hidden)]
pub mod __private {
    // Shared factory creation depth — bounds cyclic `#[factory_assoc]` chains
    // across all models in a single create() chain.
    //
    // Task-local (not thread-local) so it is maintained correctly when a
    // generated async `create()` future migrates between worker threads on a
    // work-stealing runtime such as Tokio's multi-thread scheduler.
    tokio::task_local! {
        pub static FACTORY_DEPTH: u32;
    }
}

/// Create a new [`app::AppBuilder`] for configuring and launching an Autumn server.
///
/// This is the primary entry point for every Autumn application.
///
/// # Examples
///
/// ```rust,no_run
/// use autumn_web::prelude::*;
///
/// #[get("/")]
/// async fn index() -> &'static str { "hello" }
///
/// #[autumn_web::main]
/// async fn main() {
///     autumn_web::app()
///         .routes(routes![index])
///         .run()
///         .await;
/// }
/// ```
pub use app::app;
/// Async database connection extractor.
///
/// Declare `db: Db` in a handler signature to get a pooled Postgres
/// connection. See [`db::Db`] for full documentation and examples.
#[cfg(feature = "db")]
pub use db::Db;

/// Framework error type and result alias.
///
/// [`AutumnError`] wraps any `Error + Send + Sync` with an HTTP status code.
/// [`AutumnResult<T>`] is `Result<T, AutumnError>`.
/// See the [`error`] module for details.
pub use error::{AutumnError, AutumnResult};

/// Paginated list response wrapper with navigation metadata.
///
/// See the [`pagination`] module for the full query contract and usage
/// patterns.
pub use pagination::Page;

/// Pagination parameters extracted from the query string.
///
/// See the [`pagination`] module for the full query contract and usage
/// patterns.
pub use pagination::PageRequest;

/// Cursor pagination response wrapper. Companion to [`CursorRequest`]
/// for keyset/seek pagination of real-time feeds.
///
/// See the [`pagination`] module for the full query contract and usage
/// patterns.
pub use pagination::CursorPage;

/// Cursor pagination parameters extracted from the query string.
///
/// See the [`pagination`] module for the full query contract and usage
/// patterns.
pub use pagination::CursorRequest;

/// Auto-validating extractor. Wraps `Json<T>`, `Form<T>`, or `Query<T>`
/// and validates via `validator::Validate` before the handler runs.
/// Returns 422 with structured error details on validation failure.
pub use validation::Valid;

/// Proof that `T` has passed validation. See [`validation`] module.
pub use validation::Validated;

/// htmx version string embedded in the binary.
///
/// Useful for cache-busting or diagnostic logging. The corresponding
/// minified JS is served automatically at `/static/js/htmx.min.js`.
#[cfg(feature = "htmx")]
pub use htmx::{HTMX_CSRF_JS_PATH, HTMX_JS_PATH, HTMX_VERSION};
#[cfg(feature = "mail")]
pub use mail::{
    Mail, MailConfig, MailDeliveryQueue, MailDeliveryQueueHandle, MailError, MailTransport, Mailer,
    SmtpConfig, TlsMode, Transport,
};
/// Extension trait adding `.validate()` to all `validator::Validate` types.
pub use validation::ValidateExt;

// ── Proc-macro re-exports ──────────────────────────────────────────

/// Annotate an async function as a `DELETE` route handler.
///
/// Generates a companion function that returns a [`crate::route::Route`]
/// pairing the path with an Axum handler. In debug builds
/// `#[axum::debug_handler]` is applied automatically for better error
/// messages (zero cost in release).
///
/// # Examples
///
/// ```rust,no_run
/// use autumn_web::prelude::*;
///
/// #[delete("/items/{id}")]
/// async fn remove_item() -> &'static str {
///     "removed"
/// }
/// ```
pub use autumn_macros::delete;

/// Enrich a route handler's auto-generated `OpenAPI` documentation.
///
/// See the [`openapi`] module and the [`autumn_macros::api_doc`]
/// attribute docs for details on the supported keys.
///
/// # Example
///
/// ```rust,no_run
/// use autumn_web::prelude::*;
///
/// #[get("/users/{id}")]
/// #[api_doc(summary = "Fetch a user by id", tag = "users")]
/// async fn get_user(Path(id): Path<i32>) -> String {
///     format!("User {id}")
/// }
/// ```
pub use autumn_macros::api_doc;

/// Annotate an async function as a `GET` route handler.
///
/// Generates a companion function that returns a [`crate::route::Route`]
/// pairing the path with an Axum handler. In debug builds
/// `#[axum::debug_handler]` is applied automatically for better error
/// messages (zero cost in release).
///
/// # Examples
///
/// ```rust,no_run
/// use autumn_web::prelude::*;
///
/// #[get("/hello")]
/// async fn hello() -> &'static str {
///     "Hello, Autumn!"
/// }
/// ```
pub use autumn_macros::get;
/// Collect mailer preview registrations into an `AppBuilder`.
#[cfg(feature = "mail")]
pub use autumn_macros::mail_previews;
/// Generate ergonomic `send_*` and `deliver_later_*` helpers for mailer impls.
#[cfg(feature = "mail")]
pub use autumn_macros::mailer;
/// Register zero-argument mail template previews for the dev mail UI.
#[cfg(feature = "mail")]
pub use autumn_macros::mailer_preview;
/// Set up the Tokio async runtime for an Autumn application.
///
/// A thin wrapper around `#[tokio::main]`. The real framework setup
/// happens inside [`app::AppBuilder::run`].
///
/// # Examples
///
/// ```rust,no_run
/// use autumn_web::prelude::*;
///
/// #[get("/")]
/// async fn index() -> &'static str { "hi" }
///
/// #[autumn_web::main]
/// async fn main() {
///     autumn_web::app()
///         .routes(routes![index])
///         .run()
///         .await;
/// }
/// ```
pub use autumn_macros::main;

/// Derive Diesel and Serde traits for a database model struct.
///
/// Applies `Queryable`, `Selectable`, `Insertable`, `Serialize`, and
/// `Deserialize` derives plus a `#[diesel(table_name = ...)]` attribute.
/// The table name is either specified explicitly or inferred from the
/// struct name (`PascalCase` -> `snake_case` + `s`).
///
/// # Examples
///
/// Explicit table name:
///
/// ```rust,ignore
/// use autumn_web::model;
///
/// #[model(table = "users")]
/// pub struct User {
///     pub id: i64,
///     pub name: String,
/// }
/// ```
///
/// Inferred table name (`BlogPost` -> `blog_posts`):
///
/// ```rust,ignore
/// use autumn_web::model;
///
/// #[model]
/// pub struct BlogPost {
///     pub id: i64,
///     pub title: String,
/// }
/// ```
#[cfg(feature = "db")]
pub use autumn_macros::model;
/// Annotate an OAuth2/OIDC callback handler.
///
/// Convenience alias for `#[get(...)]` with callback-focused naming.
pub use autumn_macros::oauth2_callback;

/// Derive a repository with CRUD operations and derived queries.
///
/// See [`macro@repository`] for details.
#[cfg(feature = "db")]
pub use autumn_macros::repository;

/// Define a service for cross-model orchestration and non-DB side effects.
///
/// Generates a `XxxServiceImpl` struct with dependency injection.
/// Use when logic spans multiple repositories or involves non-DB work.
/// For single-model CRUD, use [`macro@repository`] instead.
///
/// # Examples
///
/// ```rust,ignore
/// use autumn_web::service;
///
/// #[service]
/// pub trait OrderService {
///     fn deps(order_repo: PgOrderRepository, inventory_repo: PgInventoryRepository);
/// }
///
/// impl OrderServiceImpl {
///     pub async fn place_order(&self, req: PlaceOrderRequest) -> AutumnResult<Order> {
///         let order = self.order_repo.save(&req.into()).await?;
///         self.inventory_repo.reserve(order.id).await?;
///         Ok(order)
///     }
/// }
/// ```
#[cfg(feature = "db")]
pub use autumn_macros::service;

/// Annotate an async function as a `PATCH` route handler.
///
/// Generates a companion function that returns a [`crate::route::Route`]
/// and a typed `__autumn_path_{name}(…) -> String` path helper.
///
/// # Examples
///
/// ```rust,no_run
/// use autumn_web::patch;
///
/// #[patch("/items/{id}")]
/// async fn patch_item() -> &'static str {
///     "patched"
/// }
/// ```
pub use autumn_macros::patch;

/// Emit a `pub mod paths { … }` re-exporting typed path helpers.
///
/// Takes the same comma-separated handler list as [`routes!`]. Invoke once
/// in the module where your handlers live:
///
/// ```ignore
/// autumn_web::paths![show_post, create_post];
/// // callers can then: use crate::routes::paths;
/// //                    paths::show_post(42)
/// ```
pub use autumn_macros::paths;

/// HTTP redirect response.
///
/// Re-exported from [Axum](https://docs.rs/axum) so route handlers can
/// return a redirect without a direct `axum` dependency.
///
/// Use [`Redirect::to`] with a path helper:
///
/// ```ignore
/// use autumn_web::Redirect;
/// Redirect::to(&paths::show_post(id))
/// ```
pub use axum::response::Redirect;

/// Annotate an async function as a `POST` route handler.
///
/// Generates a companion function that returns a [`crate::route::Route`]
/// pairing the path with an Axum handler. In debug builds
/// `#[axum::debug_handler]` is applied automatically for better error
/// messages (zero cost in release).
///
/// # Examples
///
/// ```rust,no_run
/// use autumn_web::prelude::*;
///
/// #[post("/items")]
/// async fn create_item() -> &'static str {
///     "created"
/// }
/// ```
pub use autumn_macros::post;

/// Annotate an async function as a `PUT` route handler.
///
/// Generates a companion function that returns a [`crate::route::Route`]
/// pairing the path with an Axum handler. In debug builds
/// `#[axum::debug_handler]` is applied automatically for better error
/// messages (zero cost in release).
///
/// # Examples
///
/// ```rust,no_run
/// use autumn_web::prelude::*;
///
/// #[put("/items/{id}")]
/// async fn update_item() -> &'static str {
///     "updated"
/// }
/// ```
pub use autumn_macros::put;

/// Collect route-annotated handlers into a `Vec<Route>`.
///
/// Each handler must have been annotated with a route macro ([`get`],
/// [`post`], [`put`], [`delete`]) which generates a companion
/// `__autumn_route_info_{name}()` function.
///
/// # Examples
///
/// ```rust,no_run
/// use autumn_web::prelude::*;
///
/// #[get("/hello")]
/// async fn hello() -> &'static str { "hello" }
///
/// #[post("/create")]
/// async fn create() -> &'static str { "created" }
///
/// # #[autumn_web::main]
/// # async fn main() {
/// let all_routes = routes![hello, create];
/// autumn_web::app().routes(all_routes).run().await;
/// # }
/// ```
pub use autumn_macros::routes;

/// Cache the return value of a function based on its arguments.
///
/// Wraps a function with an in-memory cache backed by a static
/// [`MokaCache`](cache::MokaCache) (default) via the [`Cache`](cache::Cache)
/// trait. Arguments must implement `Hash + Clone`; the return type must
/// be `Clone + Send + Sync + 'static`.
///
/// Use `result` to only cache `Ok` values from `Result`-returning
/// functions (common with [`AutumnResult`]).
///
/// # Examples
///
/// ```rust,ignore
/// use autumn_web::cached;
///
/// #[cached(ttl = "5m", max = 100, result)]
/// async fn get_user(id: i64) -> AutumnResult<User> {
///     db.find(id).await
/// }
/// ```
pub use autumn_macros::cached;

/// Annotate an async function as a WebSocket route handler.
///
/// The function follows the **two-function pattern**: it runs at HTTP
/// upgrade time and returns a closure implementing [`ws::WsHandler`]
/// that handles the live WebSocket connection.
///
/// Generates a GET route for the WebSocket upgrade, compatible with
/// [`routes!`]. Requires the `ws` feature.
///
/// # Examples
///
/// ```rust,ignore
/// use autumn_web::prelude::*;
/// use autumn_web::ws::{WebSocket, Message, WsHandler};
///
/// #[ws("/echo")]
/// async fn echo() -> impl WsHandler {
///     |mut socket: WebSocket| async move {
///         while let Some(Ok(msg)) = socket.recv().await {
///             if let Message::Text(text) = msg {
///                 socket.send(Message::Text(text)).await.ok();
///             }
///         }
///     }
/// }
/// ```
#[cfg(feature = "ws")]
pub use autumn_macros::ws;

/// Declare an on-demand background job. See [`mod@job`] module.
pub use autumn_macros::job;
/// Declare a scheduled background task. See [`mod@task`] module.
pub use autumn_macros::scheduled;
/// Declare a one-off operational task. See [`task::OneOffTaskInfo`].
pub use autumn_macros::task;

/// Extractor that yields a verified bearer-token principal for API routes.
///
/// Must be used with [`auth::RequireApiToken`] middleware. See the
/// [`auth`] module for a complete quick-start example.
pub use auth::ApiToken;

/// Tower layer that validates `Authorization: Bearer <token>` on API routes.
///
/// Verifies tokens against any [`auth::ApiTokenStore`] implementation.
/// Returns `401 Unauthorized` for missing, unknown, or revoked tokens.
pub use auth::RequireApiToken;

/// Postgres-backed API token store (requires `db` feature).
///
/// Production replacement for [`auth::InMemoryApiTokenStore`]. Hashes tokens
/// at rest and persists them across restarts. Use with [`API_TOKEN_MIGRATIONS`]
/// for dev/test startup checks; `autumn migrate` applies the token-table
/// framework migration in production.
#[cfg(feature = "db")]
pub use auth::DbApiTokenStore;

/// Embedded Diesel migrations for the `api_tokens` table (requires `db` feature).
///
/// Pass to `app().migrations()` so that dev/test startup migration checks can
/// create and validate the `api_tokens` table alongside your application
/// migrations.
#[cfg(feature = "db")]
pub use auth::API_TOKEN_MIGRATIONS;

/// Secure a route handler with authentication and optional role checks.
///
/// Applied before a route macro (`#[get]`, `#[post]`, etc.), this attribute
/// injects an authentication guard at the top of the handler. The guard
/// checks the session for the configured auth key (default: `"user_id"`)
/// and, when roles are specified, verifies the user's role matches.
///
/// Returns `401 Unauthorized` if not authenticated, or `403 Forbidden`
/// if the user lacks the required role.
///
/// The handler must return [`AutumnResult<T>`] so the guard can use `?`
/// to short-circuit on failure.
///
/// # Forms
///
/// - `#[secured]` -- require authentication only
/// - `#[secured("admin")]` -- require a specific role
/// - `#[secured("admin", "editor")]` -- require any of the listed roles
///
/// # Examples
///
/// ```rust,no_run
/// use autumn_web::prelude::*;
///
/// #[get("/dashboard")]
/// #[secured]
/// async fn dashboard() -> AutumnResult<&'static str> {
///     Ok("welcome")
/// }
///
/// #[get("/admin")]
/// #[secured("admin")]
/// async fn admin_panel() -> AutumnResult<&'static str> {
///     Ok("admin area")
/// }
///
/// #[get("/content")]
/// #[secured("admin", "editor")]
/// async fn manage_content() -> AutumnResult<&'static str> {
///     Ok("content manager")
/// }
/// ```
pub use autumn_macros::secured;

/// Enforce a record-level [`Policy`](crate::authorization::Policy)
/// before a handler runs. Coexists with [`secured`](macro@secured):
/// `#[secured]` answers "are you in?", `#[authorize]` answers
/// "are you allowed to act on *this record*?"
///
/// # Examples
///
/// ```rust,ignore
/// use autumn_web::prelude::*;
///
/// #[get("/posts/{id}/edit")]
/// #[authorize("update", resource = Post)]
/// async fn edit_post(post: Post) -> AutumnResult<Markup> {
///     Ok(html! { h1 { (post.title) } })
/// }
/// ```
pub use autumn_macros::authorize;
/// Collect `#[job]` handlers into a `Vec<JobInfo>`.
pub use autumn_macros::jobs;

/// Collect `#[task]` handlers into a `Vec<task::OneOffTaskInfo>`.
pub use autumn_macros::one_off_tasks;

/// Collect `#[scheduled]` task handlers into a `Vec<TaskInfo>`.
pub use autumn_macros::tasks;

/// Collect `#[static_get]` handlers into a `Vec<StaticRouteMeta>`.
pub use autumn_macros::static_routes;

/// Annotate an async function as a statically pre-rendered GET route.
///
/// Like [`get`], this generates a route companion for Axum routing.
/// Additionally, it emits a `__autumn_static_meta_{name}()` companion
/// that registers the route for static HTML generation at build time
/// (`autumn build`).
///
/// Phase 1 restriction: path parameters (`{id}`) are **not** supported.
/// Use [`get`] for parameterized routes.
///
/// # Examples
///
/// ```rust,no_run
/// use autumn_web::prelude::*;
///
/// #[static_get("/about")]
/// async fn about() -> &'static str {
///     "About us"
/// }
/// ```
pub use autumn_macros::static_get;

// ── Maud re-exports ────────────────────────────────────────────────

/// Rendered HTML fragment produced by the [`html!`] macro.
///
/// This is the standard return type for handlers that render HTML.
/// Re-exported from [Maud](https://maud.lambda.xyz).
///
/// # Examples
///
/// ```rust,no_run
/// use autumn_web::prelude::*;
///
/// #[get("/")]
/// async fn index() -> Markup {
///     html! { h1 { "Welcome" } }
/// }
/// ```
#[cfg(feature = "maud")]
pub use maud::Markup;

/// Wrap a pre-escaped string so Maud renders it verbatim.
///
/// Use this when you have HTML that was already escaped or generated
/// by another system and you want to embed it in a Maud template
/// without double-escaping.
///
/// Re-exported from [Maud](https://maud.lambda.xyz).
///
/// # Examples
///
/// ```rust
/// use autumn_web::PreEscaped;
///
/// let raw_html = PreEscaped("<em>already escaped</em>".to_string());
/// ```
#[cfg(feature = "maud")]
pub use maud::PreEscaped;

/// Type-safe HTML templating macro.
///
/// Produces a [`Markup`] value containing compiled HTML.
/// Re-exported from [Maud](https://maud.lambda.xyz). See the
/// [Maud book](https://maud.lambda.xyz) for full syntax reference.
///
/// # Examples
///
/// ```rust
/// use autumn_web::html;
///
/// let greeting = "world";
/// let page = html! {
///     h1 { "Hello, " (greeting) "!" }
/// };
/// ```
#[cfg(feature = "maud")]
pub use maud::html;

/// JSON request body extractor and response type.
///
/// When used as a handler parameter, deserializes the request body as JSON.
/// When returned from a handler, serializes the value as JSON with
/// `Content-Type: application/json`.
///
/// Wraps [Axum](https://docs.rs/axum)'s JSON extractor so parse failures use
/// Autumn's Problem Details error contract.
///
/// # Examples
///
/// ```rust,no_run
/// use autumn_web::prelude::*;
/// use serde::{Deserialize, Serialize};
///
/// #[derive(Deserialize)]
/// struct CreateItem { name: String }
///
/// #[derive(Serialize)]
/// struct Item { id: i64, name: String }
///
/// #[post("/items")]
/// async fn create(Json(input): Json<CreateItem>) -> Json<Item> {
///     Json(Item { id: 1, name: input.name })
/// }
/// ```
pub use crate::extract::Json;

/// Path extractor.
///
/// Extract typed path parameters from the URL.
///
/// Wraps [Axum](https://docs.rs/axum)'s path extractor so parse failures use
/// Autumn's Problem Details error contract.
///
/// # Examples
///
/// ```rust,no_run
/// use autumn_web::prelude::*;
///
/// #[get("/users/{id}")]
/// async fn get_user(Path(id): Path<i32>) -> String {
///     format!("User {id}")
/// }
/// ```
pub use crate::extract::Path;

/// Form data extractor.
pub use crate::extract::Form;

/// Query extractor.
pub use crate::extract::Query;

/// State extractor.
/// Re-exported from [Axum](https://docs.rs/axum).
pub use axum::extract::State;

/// Re-exports of upstream crates used in macro-generated code.
///
/// These are public so that code generated by `autumn-macros` can reference
/// them as `autumn_web::reexports::axum`, etc. without requiring the user to
/// add those crates as direct dependencies.
///
/// **For advanced use cases only.** Prefer the types re-exported in
/// [`prelude`] or at the crate root. Reach into `reexports` when you
/// need direct access to the underlying framework types (e.g.,
/// `autumn_web::reexports::axum::Router` for custom middleware).
///
/// # Available crates
///
/// | Crate | Re-exported as | Use case |
/// |-------|---------------|----------|
/// | `axum` | `autumn_web::reexports::axum` | Custom routers, middleware, extractors |
/// | `diesel` | `autumn_web::reexports::diesel` | Raw Diesel queries, schema types |
/// | `http` | `autumn_web::reexports::http` | HTTP types (`StatusCode`, `Method`, headers) |
/// | `serde_json` | `autumn_web::reexports::serde_json` | JSON values and conversion helpers |
/// | `tokio` | `autumn_web::reexports::tokio` | Async runtime, spawn, timers |
pub mod reexports {
    pub use axum;
    pub use chrono;
    #[cfg(feature = "db")]
    pub use diesel;
    #[cfg(feature = "db")]
    pub use diesel_async;
    pub use http;
    #[cfg(feature = "mail")]
    pub use lettre;
    #[cfg(feature = "db")]
    pub use scoped_futures;
    pub use serde_json;
    pub use tokio;
    pub use tokio_util;
    pub use tracing;
    pub use validator;
}

/// Shared application state passed to route handlers.
pub(crate) mod state;
#[allow(
    clippy::missing_panics_doc,
    clippy::must_use_candidate,
    clippy::field_reassign_with_default
)]
pub mod test;
pub use state::AppState;

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn app_fn_creates_builder() {
        let builder = app::app();
        // Just verify it compiles and can accept routes
        let _builder = builder.routes(vec![]);
    }
}