utoipa Actix Web

https://docs.rs/utoipa-actix-web/0.1.2
Admin
utoipa Actix Web provides automatic OpenAPI specification generation for Actix Web applications by...
Tokens:12,672
Snippets:143
Trust Score:9.1
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install utoipa-actix-web dependency

Source: https://docs.rs/utoipa-actix-web/0.1.2/index.html

Add the crate to your Cargo.toml file to include it in your project.

```toml
[dependencies]
utoipa-actix-web = "0.1"
```

--------------------------------

### Create and Convert UtoipaApp

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/lib.rs.html?search=std%3A%3Avec

Demonstrates how to initialize a UtoipaApp instance or convert an existing actix_web::App into one.

```rust
# use utoipa_actix_web::{AppExt, UtoipaApp};
# use actix_web::App;
let utoipa_app = App::new().into_utoipa_app();
```

```rust
# use utoipa_actix_web::{AppExt, UtoipaApp};
# use actix_web::App;
let a: UtoipaApp<_> = actix_web::App::new().into();
```

--------------------------------

### OpenApiFactory Implementation

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/scope.rs.html?search=std%3A%3Avec

Handles path prefixing and schema extraction for OpenAPI documentation generation.

```rust
impl<T> OpenApiFactory for Scope<T> {
    fn paths(&self) -> utoipa::openapi::path::Paths {
        let prefix = self.2.take();
        let mut openapi = self.1.borrow_mut();
        let mut paths = std::mem::take(&mut openapi.paths);

        let prefixed_paths = paths
            .paths
            .into_iter()
            .map(|(path, item)| {
                let path = format!("{prefix}{path}");

                (path, item)
            })
            .collect::<utoipa::openapi::path::PathsMap<_, _>>();
        paths.paths = prefixed_paths;

        paths
    }

    fn schemas(
        &self,
        schemas: &mut Vec<(
            String,
            utoipa::openapi::RefOr<utoipa::openapi::schema::Schema>,
        )>,
    ) {
        let mut api = self.1.borrow_mut();
        if let Some(components) = &mut api.components {
            schemas.extend(std::mem::take(&mut components.schemas));
        }
    }
}
```

--------------------------------

### UtoipaApp::configure

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Configures the application using a closure, automatically collecting paths and schemas from the provided ServiceConfig.

```APIDOC
## UtoipaApp::configure<F>(f: F)

### Description
Extends the standard actix_web::App::configure method to automatically extract and merge OpenAPI paths and schemas from the service configuration into the UtoipaApp instance.

### Parameters
- **f** (FnOnce(&mut ServiceConfig)) - Required - A closure that configures the service.
```

--------------------------------

### Create a new scoped service

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/scope.rs.html?search=

Demonstrates how to use the scope function to define a scoped service with automatic OpenAPI documentation collection.

```rust
# use actix_web::{get, App};
# use utoipa_actix_web::{AppExt, scope};
#
 #[utoipa::path()]
 #[get("/handler")]
 pub async fn handler() -> &'static str {
     "OK"
 }
let _ = App::new()
    .into_utoipa_app()
    .service(scope::scope("/api/v1/inner").configure(|cfg| {
        cfg.service(handler);
    }));
```

--------------------------------

### into_utoipa_app

Source: https://docs.rs/utoipa-actix-web/0.1.2/utoipa_actix_web/trait.AppExt.html?search=u32+-%3E+bool

Converts an actix_web::App instance into a UtoipaApp.

```APIDOC
## fn into_utoipa_app(self) -> UtoipaApp<T>

### Description
Converts this `actix_web::App` to `UtoipaApp` to enable utoipa-related functionality.

### Signature
`fn into_utoipa_app(self) -> UtoipaApp<T>`
```

--------------------------------

### UtoipaApp::into_app

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Consumes the UtoipaApp and returns the underlying actix_web::App.

```APIDOC
## into_app() -> actix_web::App<T>

### Description
Converts the UtoipaApp wrapper back into a standard actix_web::App.
```

--------------------------------

### Collect OpenAPI paths from Actix Web services

Source: https://docs.rs/utoipa-actix-web/0.1.2/index.html

Use AppExt to automatically collect paths and schemas from service definitions annotated with #[utoipa::path].

```rust
use actix_web::web::Json;
use actix_web::{get, App};
use utoipa_actix_web::{scope, AppExt};

#[derive(utoipa::ToSchema, serde::Serialize)]
struct User {
    id: i32,
}

#[utoipa::path(responses((status = OK, body = User)))]
#[get("/user")]
async fn get_user() -> Json<User> {
    Json(User { id: 1 })
}

let (_, mut api) = App::new()
    .into_utoipa_app()
    .service(scope::scope("/api/v1").service(get_user))
    .split_for_parts();
```

--------------------------------

### into_utoipa_app

Source: https://docs.rs/utoipa-actix-web/0.1.2/utoipa_actix_web/trait.AppExt.html

Converts an instance of actix_web::App into a UtoipaApp to integrate utoipa functionality.

```APIDOC
## fn into_utoipa_app(self) -> UtoipaApp<T>

### Description
Converts this `actix_web::App` to `UtoipaApp` to enable utoipa-related features.

### Signature
`fn into_utoipa_app(self) -> UtoipaApp<T>`

### Returns
- **UtoipaApp<T>** - The converted application wrapper.
```

--------------------------------

### UtoipaApp::into_app

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/lib.rs.html

Consumes the UtoipaApp and returns the underlying Actix Web App.

```APIDOC
## fn into_app(self) -> actix_web::App<T>

### Description
Converts this UtoipaApp into the wrapped actix_web::App instance.
```

--------------------------------

### into_utoipa_app

Source: https://docs.rs/utoipa-actix-web/0.1.2/utoipa_actix_web/trait.AppExt.html?search=

Converts an actix_web::App instance into a UtoipaApp to facilitate OpenAPI documentation integration.

```APIDOC
## fn into_utoipa_app(self) -> UtoipaApp<T>

### Description
Converts the current `actix_web::App` instance into a `UtoipaApp` wrapper. This method is used to enable `utoipa` specific functionality on an existing Actix web application.

### Signature
`fn into_utoipa_app(self) -> UtoipaApp<T>`

### Returns
- **UtoipaApp<T>** - A wrapped version of the application configured for use with the `utoipa` library.
```

--------------------------------

### Create a new scoped service

Source: https://docs.rs/utoipa-actix-web/0.1.2/utoipa_actix_web/scope/fn.scope.html?search=

Demonstrates how to use the scope function to wrap a service configuration within an Actix Web application.

```rust
 #[utoipa::path()]
 #[get("/handler")]
 pub async fn handler() -> &'static str {
     "OK"
 }
let _ = App::new()
    .into_utoipa_app()
    .service(scope::scope("/api/v1/inner").configure(|cfg| {
        cfg.service(handler);
    }));
```

--------------------------------

### Registering Services and Routes in Scope

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/scope.rs.html?search=

Methods for registering services and routes within a scope, ensuring OpenAPI schemas and paths are merged into the global state.

```rust
pub fn service<F>(self, factory: F) -> Self
    where
        F: HttpServiceFactory + OpenApiFactory + 'static,
    {
        let mut schemas = Vec::<(String, utoipa::openapi::RefOr<utoipa::openapi::schema::Schema>,)>::new();
        {
            let mut openapi = self.1.borrow_mut();
            let other_paths = factory.paths();
            factory.schemas(&mut schemas);
            openapi.paths.merge(other_paths);
            let components = openapi
                .components
                .get_or_insert(utoipa::openapi::Components::new());
            components.schemas.extend(schemas);
        }

        let app = self.0.service(factory);

        Self(app, self.1, self.2)
    }

    /// Passthrough implementation for [`actix_web::Scope::route`].
    pub fn route(self, path: &str, route: Route) -> Self {
        Self(self.0.route(path, route), self.1, self.2)
    }

    /// Passthrough implementation for [`actix_web::Scope::default_service`].
    pub fn default_service<F, U>(self, f: F) -> Self
    where
        F: IntoServiceFactory<U, ServiceRequest>,
        U: ServiceFactory<
                ServiceRequest,
                Config = (),
                Response = ServiceResponse,
                Error = actix_web::Error,
            > + 'static,
        U::InitError: fmt::Debug,
    {
        Self(self.0.default_service(f), self.1, self.2)
    }

    /// Synonymous for [`UtoipaApp::map`][utoipa_app_map]
    ///
    /// [utoipa_app_map]: ../struct.UtoipaApp.html#method.map
    pub fn map<
        F: FnOnce(actix_web::Scope<T>) -> actix_web::Scope<NF>,
        NF: ServiceFactory<ServiceRequest, Config = (), Error = Error, InitError = ()>,
    >(
        self,
        op: F,
    ) -> Scope<NF> {
        let scope = op(self.0);
        Scope(scope, self.1, self.2)
    }
```

--------------------------------

### UtoipaApp::into_app

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/lib.rs.html?search=

Converts the UtoipaApp back into the wrapped actix_web::App.

```APIDOC
## into_app

### Description
Converts this UtoipaApp into the wrapped actix_web::App.

### Signature
pub fn into_app(self) -> actix_web::App<T>
```

--------------------------------

### UtoipaApp::split_for_parts

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Extracts the underlying actix_web::App and the generated OpenAPI documentation object.

```APIDOC
## split_for_parts() -> (actix_web::App<T>, utoipa::openapi::OpenApi)

### Description
Splits the UtoipaApp instance into its constituent parts: the configured Actix Web application and the generated OpenAPI specification.
```

--------------------------------

### Generate OpenAPI Specification for Actix Web App

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/lib.rs.html?search=std%3A%3Avec

Demonstrates configuring an Actix Web application with services, scopes, and custom middleware to generate an OpenAPI specification.

```rust
    fn test_app_generate_correct_openapi() {
        fn config(cfg: &mut service_config::ServiceConfig) {
            cfg.service(handler3)
                .map(|config| config.service(normal_service));
        }

        let (_, mut api) = App::new()
            .into_utoipa_app()
            .service(handler)
            .configure(config)
            .service(scope::scope("/path-prefix").service(handler2).map(|scope| {
                let s = scope.wrap_fn(|req, srv| {
                    let fut = srv.call(req);
                    async {
                        let mut res = fut.await?;
                        res.headers_mut()
                            .insert(CONTENT_TYPE, HeaderValue::from_static("text/plain"));
                        Ok(res)
                    }
                });

                s
            }))
            .service(scope::scope("/api/v1/inner").configure(|cfg| {
                cfg.service(inner::inner_handler)
                    .service(inner::inner_handler3)
                    .app_data(Data::new(String::new()));
            }))
            .split_for_parts();
        api.info = utoipa::openapi::info::Info::new("title", "version");
        let json = api.to_pretty_json().expect("OpenAPI is JSON serializable");
        println!("{json}");

        let expected = include_str!("../testdata/app_generated_openapi");
        assert_eq!(json.trim(), expected.trim());
    }
```

--------------------------------

### Service Registration and OpenAPI Integration

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/scope.rs.html?search=std%3A%3Avec

Registers a service with the scope and merges its OpenAPI paths and schemas into the shared state.

```rust
pub fn service<F>(self, factory: F) -> Self
    where
        F: HttpServiceFactory + OpenApiFactory + 'static,
    {
        let mut schemas = Vec::<(
            String,
            utoipa::openapi::RefOr<utoipa::openapi::schema::Schema>,
        )>::new();
        {
            let mut openapi = self.1.borrow_mut();
            let other_paths = factory.paths();
            factory.schemas(&mut schemas);
            openapi.paths.merge(other_paths);
            let components = openapi
                .components
                .get_or_insert(utoipa::openapi::Components::new());
            components.schemas.extend(schemas);
        }

        let app = self.0.service(factory);

        Self(app, self.1, self.2)
    }
```

--------------------------------

### scope

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/scope.rs.html

Creates a new Scope with a given path prefix, allowing for automatic OpenAPI documentation collection from services configured within the scope.

```APIDOC
## scope(path)

### Description
Creates a new `Scope` with the specified path prefix. This function behaves like `actix_web::Scope` but enables automatic collection of OpenAPI schemas and paths from services added to the scope.

### Parameters
- **scope** (I: Into<Scope<T>>) - Required - The path prefix for the scope (e.g., "/api/v1").

### Example
```rust
use utoipa_actix_web::scope;

let scoped_service = scope("/api/v1").configure(|cfg| {
    cfg.service(my_handler);
});
```
```

--------------------------------

### AppExt::into_utoipa_app

Source: https://docs.rs/utoipa-actix-web/0.1.2/utoipa_actix_web/trait.AppExt.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Converts an actix_web::App instance into a UtoipaApp to facilitate utoipa integration.

```APIDOC
## fn into_utoipa_app(self) -> UtoipaApp<T>

### Description
Converts the current `actix_web::App` instance into a `UtoipaApp`. This method is used to enable utoipa functionality on an existing Actix Web application.

### Signature
`fn into_utoipa_app(self) -> UtoipaApp<T>`

### Returns
- **UtoipaApp<T>** - The converted application instance configured for utoipa.
```

--------------------------------

### ServiceConfig Implementation

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/service_config.rs.html?search=

The ServiceConfig struct wraps actix_web::web::ServiceConfig and provides methods to register services while tracking OpenAPI metadata.

```rust
//! Implement `utoipa` extended [`ServiceConfig`] for [`actix_web::web::ServiceConfig`].

use std::cell::Cell;

use actix_service::{IntoServiceFactory, ServiceFactory};
use actix_web::dev::{HttpServiceFactory, ServiceRequest, ServiceResponse};
use actix_web::{Error, Route};

use crate::OpenApiFactory;

/// Wrapper type for [`actix_web::web::ServiceConfig`], [`utoipa::openapi::path::Paths`] and
/// vec of [`utoipa::openapi::schema::Schema`] references.
pub struct ServiceConfig<'s>(
    pub(super) &'s mut actix_web::web::ServiceConfig,
    pub(super) Cell<utoipa::openapi::path::Paths>,
    pub(super)  Cell<
        Vec<(
            String,
            utoipa::openapi::RefOr<utoipa::openapi::schema::Schema>,
        )>,
    >,
);

impl<'s> ServiceConfig<'s> {
    /// Construct a new [`ServiceConfig`] from given [`actix_web::web::ServiceConfig`].
    pub fn new(conf: &'s mut actix_web::web::ServiceConfig) -> ServiceConfig<'s> {
        ServiceConfig(
            conf,
            Cell::new(utoipa::openapi::path::Paths::new()),
            Cell::new(Vec::new()),
        )
    }

    /// Passthrough implementation for [`actix_web::web::ServiceConfig::app_data`].
    pub fn app_data<U: 'static>(&mut self, ext: U) -> &mut Self {
        self.0.app_data(ext);
        self
    }

    /// Passthrough implementation for [`actix_web::web::ServiceConfig::default_service`].
    pub fn default_service<F, U>(&mut self, f: F) -> &mut Self
    where
        F: IntoServiceFactory<U, ServiceRequest>,
        U: ServiceFactory<ServiceRequest, Config = (), Response = ServiceResponse, Error = Error>
            + 'static,
        U::InitError: std::fmt::Debug,
    {
        self.0.default_service(f);
        self
    }

    /// Passthrough implementation for [`actix_web::web::ServiceConfig::configure`].
    pub fn configure<F>(&mut self, f: F) -> &mut Self
    where
        F: FnOnce(&mut ServiceConfig),
    {
        f(self);
        self
    }

    /// Passthrough implementation for [`actix_web::web::ServiceConfig::route`].
    pub fn route(&mut self, path: &str, route: Route) -> &mut Self {
        self.0.route(path, route);
        self
    }

    /// Counterpart for [`UtoipaApp::service`][utoipa_app_service].
    ///
    /// [utoipa_app_service]: ../struct.UtoipaApp.html#method.service
    pub fn service<F>(&mut self, factory: F) -> &mut Self
    where
        F: HttpServiceFactory + OpenApiFactory + 'static,
    {
        let mut paths = self.1.take();
        let other_paths = factory.paths();
        paths.merge(other_paths);

        let mut schemas = self.2.take();
        factory.schemas(&mut schemas);
        self.2.set(schemas);

        self.0.service(factory);
        self.1.set(paths);

        self
    }

    /// Passthrough implementation for [`actix_web::web::ServiceConfig::external_resource`].
    pub fn external_resource<N, U>(&mut self, name: N, url: U) -> &mut Self
    where
        N: AsRef<str>,
        U: AsRef<str>,
    {
        self.0.external_resource(name, url);
        self
    }

    /// Synonymous for [`UtoipaApp::map`][utoipa_app_map]
    ///
    /// [utoipa_app_map]: ../struct.UtoipaApp.html#method.map
    pub fn map<
        F: FnOnce(&mut actix_web::web::ServiceConfig) -> &mut actix_web::web::ServiceConfig,
    >(
        &mut self,
        op: F,
    ) -> &mut Self {
        op(self.0);

        self
    }
}
```

--------------------------------

### Replace OpenAPI Specification

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/lib.rs.html?search=std%3A%3Avec

Shows how to manually replace the OpenAPI specification wrapped within a UtoipaApp instance.

```rust
# use utoipa_actix_web::{AppExt, UtoipaApp};
# use actix_web::App;
# use utoipa::OpenApi;
#[derive(OpenApi)]
#[openapi(info(title = "Api title"))]
struct Api;

let _ = actix_web::App::new().into_utoipa_app().openapi(Api::openapi());
```

--------------------------------

### Scope Service and Routing Methods

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/scope.rs.html

Methods for registering services, routes, and default services within an Actix Web scope while maintaining OpenAPI schema integration.

```rust
pub fn service<F>(self, factory: F) -> Self
    where
        F: HttpServiceFactory + OpenApiFactory + 'static,
    {
        let mut schemas = Vec::<(String, utoipa::openapi::RefOr<utoipa::openapi::schema::Schema>,)>::new();
        {
            let mut openapi = self.1.borrow_mut();
            let other_paths = factory.paths();
            factory.schemas(&mut schemas);
            openapi.paths.merge(other_paths);
            let components = openapi
                .components
                .get_or_insert(utoipa::openapi::Components::new());
            components.schemas.extend(schemas);
        }

        let app = self.0.service(factory);

        Self(app, self.1, self.2)
    }

    pub fn route(self, path: &str, route: Route) -> Self {
        Self(self.0.route(path, route), self.1, self.2)
    }

    pub fn default_service<F, U>(self, f: F) -> Self
    where
        F: IntoServiceFactory<U, ServiceRequest>,
        U: ServiceFactory<
                ServiceRequest,
                Config = (),
                Response = ServiceResponse,
                Error = actix_web::Error,
            > + 'static,
        U::InitError: fmt::Debug,
    {
        Self(self.0.default_service(f), self.1, self.2)
    }

    pub fn map<
        F: FnOnce(actix_web::Scope<T>) -> actix_web::Scope<NF>,
        NF: ServiceFactory<ServiceRequest, Config = (), Error = Error, InitError = ()>,
    >(
        self,
        op: F,
    ) -> Scope<NF> {
        let scope = op(self.0);
        Scope(scope, self.1, self.2)
    }
```

--------------------------------

### UtoipaApp::split_for_parts

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/lib.rs.html

Splits the UtoipaApp into its constituent parts: the Actix Web App and the generated OpenAPI documentation.

```APIDOC
## fn split_for_parts(self) -> (actix_web::App<T>, utoipa::openapi::OpenApi)

### Description
Returns a tuple containing the underlying actix_web::App and the utoipa::openapi::OpenApi instance associated with this application.
```

--------------------------------

### Add middleware to UtoipaApp

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/lib.rs.html?search=std%3A%3Avec

Use the map method to apply custom middleware to the underlying actix_web::App instance.

```rust
 let _ = App::new()
    .into_utoipa_app()
    .map(|app| {
           app.wrap_fn(|req, srv| {
               let fut = srv.call(req);
               async {
                   let mut res = fut.await?;
                   res.headers_mut()
                       .insert(CONTENT_TYPE, HeaderValue::from_static("text/plain"));
                   Ok(res)
               }
           })
       });
```

--------------------------------

### Add middleware to UtoipaApp

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/lib.rs.html

Use the map method to apply custom middleware or configuration to the underlying actix-web App instance.

```rust
 # use utoipa_actix_web::{AppExt, UtoipaApp};
 # use actix_web::App;
 # use actix_service::Service;
 # use actix_web::http::header::{HeaderValue, CONTENT_TYPE};
  let _ = App::new()
     .into_utoipa_app()
     .map(|app| {
            app.wrap_fn(|req, srv| {
                let fut = srv.call(req);
                async {
                    let mut res = fut.await?;
                    res.headers_mut()
                        .insert(CONTENT_TYPE, HeaderValue::from_static("text/plain"));
                    Ok(res)
                }
            })
        });
```

--------------------------------

### UtoipaApp::map

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/lib.rs.html?search=

Allows applying custom configurations or middlewares to the underlying actix_web::App instance.

```APIDOC
## map

### Description
Convenience method to add custom configuration to actix_web::App that is not directly exposed via UtoipaApp, such as adding middlewares.

### Signature
pub fn map<F, NF>(self, op: F) -> UtoipaApp<NF>
where F: FnOnce(actix_web::App<T>) -> actix_web::App<NF>
```

--------------------------------

### HttpServiceFactory and OpenApiFactory Implementations

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/scope.rs.html?search=

Trait implementations for registering the scope with Actix Web and extracting OpenAPI paths and schemas.

```rust
impl<T, B> HttpServiceFactory for Scope<T>
where
    T: ServiceFactory<
            ServiceRequest,
            Config = (),
            Response = ServiceResponse<B>,
            Error = Error,
            InitError = (),
        > + 'static,
    B: MessageBody + 'static,
{
    fn register(self, config: &mut AppService) {
        let Scope(scope, ..) = self;
        scope.register(config);
    }
}

impl<T> OpenApiFactory for Scope<T> {
    fn paths(&self) -> utoipa::openapi::path::Paths {
        let prefix = self.2.take();
        let mut openapi = self.1.borrow_mut();
        let mut paths = std::mem::take(&mut openapi.paths);

        let prefixed_paths = paths
            .paths
            .into_iter()
            .map(|(path, item)| {
                let path = format!("{prefix}{path}");

                (path, item)
            })
            .collect::<utoipa::openapi::path::PathsMap<_, _>>();
        paths.paths = prefixed_paths;

        paths
    }

    fn schemas(
        &self,
        schemas: &mut Vec<(
            String,
            utoipa::openapi::RefOr<utoipa::openapi::schema::Schema>,
        )>,
    ) {
        let mut api = self.1.borrow_mut();
        if let Some(components) = &mut api.components {
            schemas.extend(std::mem::take(&mut components.schemas));
        }
    }
}
```

--------------------------------

### Passthrough Route and Default Service Methods

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/scope.rs.html?search=std%3A%3Avec

Wrappers for Actix Web's route and default_service methods to maintain the Scope structure.

```rust
pub fn route(self, path: &str, route: Route) -> Self {
        Self(self.0.route(path, route), self.1, self.2)
    }
```

```rust
pub fn default_service<F, U>(self, f: F) -> Self
    where
        F: IntoServiceFactory<U, ServiceRequest>,
        U: ServiceFactory<
                ServiceRequest,
                Config = (),
                Response = ServiceResponse,
                Error = actix_web::Error,
            > + 'static,
        U::InitError: fmt::Debug,
    {
        Self(self.0.default_service(f), self.1, self.2)
    }
```

--------------------------------

### UtoipaApp::split_for_parts

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/lib.rs.html?search=

Splits the UtoipaApp into its constituent parts: the actix_web::App and the generated OpenAPI specification.

```APIDOC
## split_for_parts

### Description
Split this UtoipaApp into parts returning a tuple of the actix_web::App and the utoipa::openapi::OpenApi instance.

### Signature
pub fn split_for_parts(self) -> (actix_web::App<T>, utoipa::openapi::OpenApi)
```

--------------------------------

### scope

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/scope.rs.html?search=

Creates a new Scope instance with a given path prefix. This behaves like actix_web::Scope but enables automatic OpenAPI schema and path collection for services added to it.

```APIDOC
## fn scope

### Description
Creates a new `Scope` with the given path prefix. This function allows for the automatic collection of OpenAPI definitions from services registered within the scope.

### Signature
`pub fn scope<I, T>(scope: I) -> Scope<T>`

### Parameters
- **scope** (I) - Required - The path prefix for the scope, e.g., "/api/v1".

### Example
```rust
use utoipa_actix_web::scope;

let scoped_service = scope("/api/v1").configure(|cfg| {
    cfg.service(handler);
});
```
```

--------------------------------

### UtoipaApp::service

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Registers a service and automatically collects its OpenAPI paths and schemas.

```APIDOC
## UtoipaApp::service<F>(factory: F)

### Description
Registers an HTTP service factory and extracts its associated OpenAPI paths and schemas to update the internal OpenAPI specification.

### Parameters
- **factory** (HttpServiceFactory + OpenApiFactory) - Required - The service factory to register.
```

--------------------------------

### UtoipaApp::map

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Allows applying custom transformations or configurations to the underlying actix_web::App, such as adding middleware.

```APIDOC
## map<F, NF>(op: F) -> UtoipaApp<NF>

### Description
Applies a transformation function to the inner actix_web::App. This is useful for adding middleware or other configurations not directly exposed by UtoipaApp.

### Parameters
- **op** (FnOnce(actix_web::App<T>) -> actix_web::App<NF>) - Required - A closure that takes the current App and returns a modified App.
```

--------------------------------

### scope

Source: https://docs.rs/utoipa-actix-web/0.1.2/utoipa_actix_web/scope/fn.scope.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new Scope with the given path, allowing for automatic OpenAPI schema and path collection from service calls.

```APIDOC
## Function: scope

### Description
Creates a new `Scope` with the given path (e.g., "/api/v1"). This function behaves identically to `actix_web::Scope` but integrates with `utoipa` to allow automatic schema and path collection from `service(...)` calls.

### Signature
`pub fn scope<I: Into<Scope<T>>, T: ServiceFactory<ServiceRequest, Config = (), Error = Error, InitError = ()>>(scope: I) -> Scope<T>`

### Usage Example
```rust
#[utoipa::path()]
#[get("/handler")]
pub async fn handler() -> &'static str {
    "OK"
}

let _ = App::new()
    .into_utoipa_app()
    .service(scope::scope("/api/v1/inner").configure(|cfg| {
        cfg.service(handler);
    }));
```
```

--------------------------------

### Define the AppExt trait

Source: https://docs.rs/utoipa-actix-web/0.1.2/utoipa_actix_web/trait.AppExt.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

The trait definition for extending actix_web::App with Utoipa-specific functionality.

```rust
pub trait AppExt<T> {
    // Required method
    fn into_utoipa_app(self) -> UtoipaApp<T>;
}
```

--------------------------------

### UtoipaApp::openapi

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Replaces the wrapped OpenAPI specification with a custom one. This is useful for providing OpenAPI content that cannot be automatically generated.

```APIDOC
## UtoipaApp::openapi(openapi: utoipa::openapi::OpenApi)

### Description
Replaces the internal OpenAPI specification with a provided instance. This allows for manual overrides or prepending custom documentation.

### Parameters
- **openapi** (utoipa::openapi::OpenApi) - Required - The custom OpenAPI specification to use.
```

--------------------------------

### Define UtoipaApp struct

Source: https://docs.rs/utoipa-actix-web/0.1.2/utoipa_actix_web/struct.UtoipaApp.html?search=std%3A%3Avec

The base structure definition for UtoipaApp.

```rust
pub struct UtoipaApp<T>(/* private fields */);
```

--------------------------------

### Define ServiceConfig struct

Source: https://docs.rs/utoipa-actix-web/0.1.2/utoipa_actix_web/service_config/struct.ServiceConfig.html?search=u32+-%3E+bool

The definition of the ServiceConfig wrapper type.

```rust
pub struct ServiceConfig<'s>(/* private fields */);
```

--------------------------------

### UtoipaApp::map

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/lib.rs.html

Allows applying custom transformations or adding middleware to the underlying actix_web::App instance.

```APIDOC
## fn map<F, NF>(self, op: F) -> UtoipaApp<NF>

### Description
Convenience method to add custom configuration to actix_web::App that is not directly exposed via UtoipaApp, such as adding middlewares.

### Parameters
- **op** (FnOnce(actix_web::App<T>) -> actix_web::App<NF>) - Required - A closure that takes the current App and returns a transformed App.
```

--------------------------------

### scope::scope

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/scope.rs.html?search=std%3A%3Avec

Creates a new Scope instance with a given path prefix. This function behaves like actix_web::Scope but enables automatic OpenAPI schema and path collection for services added to the scope.

```APIDOC
## scope(path)

### Description
Creates a new `Scope` with the given path prefix. This allows for grouping services and automatically collecting their OpenAPI definitions.

### Parameters
- **path** (&str) - Required - The path prefix for the scope (e.g., "/api/v1").

### Example
```rust
use utoipa_actix_web::scope;

let scoped_service = scope("/api/v1").configure(|cfg| {
    cfg.service(my_handler);
});
```
```

--------------------------------

### Scope Default Service

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/scope.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Delegates default service registration to the underlying actix_web::Scope.

```rust
pub fn default_service<F, U>(self, f: F) -> Self
    where
        F: IntoServiceFactory<U, ServiceRequest>,
        U: ServiceFactory<
                ServiceRequest,
                Config = (),
                Response = ServiceResponse,
                Error = actix_web::Error,
            > + 'static,
        U::InitError: fmt::Debug,
    {
        Self(self.0.default_service(f), self.1, self.2)
    }
```

--------------------------------

### HttpServiceFactory Implementation

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/scope.rs.html?search=std%3A%3Avec

Registers the scope with the underlying Actix Web application service.

```rust
impl<T, B> HttpServiceFactory for Scope<T>
where
    T: ServiceFactory<
            ServiceRequest,
            Config = (),
            Response = ServiceResponse<B>,
            Error = Error,
            InitError = (),
        > + 'static,
    B: MessageBody + 'static,
{
    fn register(self, config: &mut AppService) {
        let Scope(scope, ..) = self;
        scope.register(config);
    }
}
```

--------------------------------

### utoipa_actix_web::scope

Source: https://docs.rs/utoipa-actix-web/0.1.2/utoipa_actix_web/scope/fn.scope.html?search=u32+-%3E+bool

Creates a new Scope that behaves like actix_web::Scope but enables automatic schema and path collection from service calls.

```APIDOC
## Function: scope

### Description
Creates a new `Scope` with the given path. This function behaves identically to `actix_web::Scope` but provides additional functionality for automatic `schema` and `path` collection from `service(...)` calls.

### Signature
`pub fn scope<I: Into<Scope<T>>, T: ServiceFactory<ServiceRequest, Config = (), Error = Error, InitError = ()>>(scope: I) -> Scope<T>`

### Parameters
- **scope** (I) - The scope path or configuration, e.g., "/api/v1".

### Example
```rust
#[utoipa::path()]
#[get("/handler")]
pub async fn handler() -> &'static str {
    "OK"
}

let _ = App::new()
    .into_utoipa_app()
    .service(scope::scope("/api/v1/inner").configure(|cfg| {
        cfg.service(handler);
    }));
```
```

--------------------------------

### Scope::service

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/scope.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Registers a service factory to the scope and merges its OpenAPI paths and schemas into the global OpenAPI definition.

```APIDOC
## fn service<F>(self, factory: F) -> Self

### Description
Registers a service factory to the scope. This method automatically extracts OpenAPI paths and schemas from the provided factory and merges them into the scope's OpenAPI definition.

### Parameters
- **factory** (F) - Required - A factory that implements HttpServiceFactory and OpenApiFactory.
```

--------------------------------

### Scope::service

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/scope.rs.html?search=u32+-%3E+bool

Registers an HTTP service factory with the scope and merges its OpenAPI paths and schemas into the global OpenAPI definition.

```APIDOC
## fn service<F>(self, factory: F) -> Self

### Description
Registers a service factory that implements both HttpServiceFactory and OpenApiFactory. It merges the service's paths and schemas into the scope's OpenAPI state.

### Parameters
- **factory** (F) - Required - An object implementing HttpServiceFactory and OpenApiFactory.
```

--------------------------------

### Scope::default_service

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/scope.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Registers a default service factory for the scope, acting as a passthrough to the underlying actix_web::Scope::default_service method.

```APIDOC
## fn default_service<F, U>(self, f: F) -> Self

### Description
Registers a default service factory to be used when no other routes match.

### Parameters
- **f** (F) - Required - A factory that implements IntoServiceFactory.
```

--------------------------------

### OpenApiFactory Trait Definition

Source: https://docs.rs/utoipa-actix-web/0.1.2/utoipa_actix_web/trait.OpenApiFactory.html

The core trait definition requiring implementation of paths and schemas collection methods.

```rust
pub trait OpenApiFactory {
    // Required methods
    fn paths(&self) -> Paths;
    fn schemas(&self, schemas: &mut Vec<(String, RefOr<Schema>)>);
}
```

--------------------------------

### Function Signature for scope

Source: https://docs.rs/utoipa-actix-web/0.1.2/utoipa_actix_web/scope/fn.scope.html?search=

The definition of the scope function as provided in the source.

```rust
pub fn scope<I: Into<Scope<T>>, T: ServiceFactory<ServiceRequest, Config = (), Error = Error, InitError = ()>>(
    scope: I,
) -> Scope<T>
```

--------------------------------

### Scope Route Passthrough

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/scope.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Delegates route registration to the underlying actix_web::Scope.

```rust
pub fn route(self, path: &str, route: Route) -> Self {
        Self(self.0.route(path, route), self.1, self.2)
    }
```

--------------------------------

### Scope::default_service

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/scope.rs.html?search=u32+-%3E+bool

Registers a default service for the scope, acting as a passthrough to the underlying actix_web::Scope::default_service method.

```APIDOC
## fn default_service<F, U>(self, f: F) -> Self

### Description
Registers a default service factory to handle requests that do not match any other routes in the scope.
```

--------------------------------

### Scope::map

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/scope.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Maps the current scope to a new scope using a provided closure, similar to UtoipaApp::map.

```APIDOC
## fn map<F, NF>(self, op: F) -> Scope<NF>

### Description
Applies a transformation function to the underlying actix_web::Scope and returns a new Scope instance.

### Parameters
- **op** (F) - Required - A closure that takes an actix_web::Scope and returns a new actix_web::Scope.
```

--------------------------------

### Scope Mapping

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/scope.rs.html?search=std%3A%3Avec

Maps the internal scope to a new scope while preserving the shared OpenAPI state.

```rust
pub fn map<
        F: FnOnce(actix_web::Scope<T>) -> actix_web::Scope<NF>,
        NF: ServiceFactory<ServiceRequest, Config = (), Error = Error, InitError = ()>,
    >(
        self,
        op: F,
    ) -> Scope<NF> {
        let scope = op(self.0);
        Scope(scope, self.1, self.2)
    }
```

--------------------------------

### Scope struct definition

Source: https://docs.rs/utoipa-actix-web/0.1.2/utoipa_actix_web/scope/struct.Scope.html

The definition of the Scope struct.

```rust
pub struct Scope<T>(/* private fields */);
```

--------------------------------

### Scope::route

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/scope.rs.html?search=u32+-%3E+bool

Registers a route to the scope, acting as a passthrough to the underlying actix_web::Scope::route method.

```APIDOC
## fn route(self, path: &str, route: Route) -> Self

### Description
Registers a new route for the given path within this scope.

### Parameters
- **path** (&str) - Required - The URL path for the route.
- **route** (Route) - Required - The route configuration.
```

--------------------------------

### Scope::route

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/scope.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Registers a route to the scope, acting as a passthrough to the underlying actix_web::Scope::route method.

```APIDOC
## fn route(self, path: &str, route: Route) -> Self

### Description
Registers a new route for the given path within this scope.

### Parameters
- **path** (&str) - Required - The path pattern for the route.
- **route** (Route) - Required - The route configuration.
```

--------------------------------

### Scope::map

Source: https://docs.rs/utoipa-actix-web/0.1.2/src/utoipa_actix_web/scope.rs.html?search=u32+-%3E+bool

Maps the current scope to a new scope using a provided closure, useful for transforming or wrapping the scope.

```APIDOC
## fn map<F, NF>(self, op: F) -> Scope<NF>

### Description
Applies a transformation function to the underlying actix_web::Scope and returns a new Scope instance.
```
Tokens:
Raw