Struct SecurityRequirement

#[non_exhaustive]
pub struct SecurityRequirement { /* private fields */ }

OpenAPI security requirement object.

Security requirement holds list of required SecurityScheme names and possible scopes required to execute the operation. They can be defined in #[utoipa::path(...)] or in #[openapi(...)] of OpenApi.

Applying the security requirement to OpenApi will make it globally available to all operations. When applied to specific #[utoipa::path(...)] will only make the security requirements available for that operation. Only one of the requirements must be satisfied.

Implementations

impl SecurityRequirement

pub fn new<N: Into<String>, S: IntoIterator<Item = I>, I: Into<String>>( name: N, scopes: S, ) -> Self

Construct a new SecurityRequirement.

Accepts name for the security requirement which must match to the name of available SecurityScheme. Second parameter is IntoIterator of Into<String> scopes needed by the SecurityRequirement. Scopes must match to the ones defined in SecurityScheme.

Examples

Create new security requirement with scopes.

SecurityRequirement::new("api_oauth2_flow", ["edit:items", "read:items"]);

You can also create an empty security requirement with Default::default().

SecurityRequirement::default();

If you have more than one name in the security requirement you can use SecurityRequirement::add.

pub fn add<N: Into<String>, S: IntoIterator<Item = I>, I: Into<String>>( self, name: N, scopes: S, ) -> Self

Allows to add multiple names to security requirement.

Accepts name for the security requirement which must match to the name of available SecurityScheme. Second parameter is IntoIterator of Into<String> scopes needed by the SecurityRequirement. Scopes must match to the ones defined in SecurityScheme.

Examples

Make both API keys required:

#[derive(Debug, Serialize)]
struct Foo;

impl Modify for Foo {
    fn modify(&self, openapi: &mut openapi::OpenApi) {
        if let Some(schema) = openapi.components.as_mut() {
            schema.add_security_scheme(
                "api_key1",
                SecurityScheme::Http(
                    HttpBuilder::new()
                        .scheme(HttpAuthScheme::Bearer)
                        .bearer_format("JWT")
                        .build(),
                ),
            );
            schema.add_security_scheme(
                "api_key2",
                SecurityScheme::Http(
                    HttpBuilder::new()
                        .scheme(HttpAuthScheme::Bearer)
                        .bearer_format("JWT")
                        .build(),
                ),
            );
        }
    }
}

#[derive(Default, OpenApi)]
#[openapi(
    modifiers(&Foo),
    security(
        ("api_key1" = ["edit:items", "read:items"], "api_key2" = ["edit:items", "read:items"]),
    )
)]
struct ApiDoc;

Trait Implementations

impl Clone for SecurityRequirement

fn clone(&self) -> SecurityRequirement

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for SecurityRequirement

fn default() -> SecurityRequirement

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for SecurityRequirement

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for SecurityRequirement

fn eq(&self, other: &SecurityRequirement) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for SecurityRequirement

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for SecurityRequirement

impl StructuralPartialEq for SecurityRequirement