autumn-web 0.10.0

An opinionated, convention-over-configuration web framework for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

// Stand-ins for the idempotency hooks. Built when `idempotency` is off.
//
// Unstable. Only macro output may name these items.

use axum::body::Body;
use axum::http::Response;
use std::{future::Future, pin::Pin};

/// Never resolves: no deferred commit exists without the layer.
type Never<'a> = Pin<Box<dyn Future<Output = Result<(), String>> + Send + 'a>>;

/// No replay exists without the layer. Nothing builds one.
#[derive(Clone)]
pub struct IdempotencyReplayResponse;

/// A route layer that passes every request through.
#[derive(Clone, Copy, Debug, Default)]
pub struct IdempotencyReplayLayer;

impl<S> tower::Layer<S> for IdempotencyReplayLayer {
    type Service = S;

    fn layer(&self, inner: S) -> S {
        inner
    }
}

#[must_use]
pub fn __replay_response(
    _: &Option<axum::extract::Extension<IdempotencyReplayResponse>>,
) -> Option<Response<Body>> {
    None
}

#[must_use]
pub fn __replay_finalized_session_response(
    _: &Option<axum::extract::Extension<IdempotencyReplayResponse>>,
) -> Option<Response<Body>> {
    None
}

pub async fn __replay_finalized_session_response_for_anonymous(
    _: &crate::session::Session,
    _: &str,
    _: &Option<axum::extract::Extension<IdempotencyReplayResponse>>,
) -> Option<Response<Body>> {
    None
}

#[derive(Clone)]
pub(crate) struct IdempotencySessionScope;

impl IdempotencySessionScope {
    pub(crate) fn new(_: Option<String>, _: Option<String>) -> Self {
        Self
    }
}

pub(crate) fn persistence_failed_response() -> Response<Body> {
    let mut response = Response::new(Body::empty());
    *response.status_mut() = axum::http::StatusCode::SERVICE_UNAVAILABLE;
    response
}

pub(crate) const fn has_deferred_session_commit(_: &Response<Body>) -> bool {
    false
}

pub(crate) fn finalize_deferred_session_commit(_: &mut Response<Body>) -> Option<Never<'_>> {
    None
}

pub(crate) fn add_deferred_session_replay_key(
    _: &Response<Body>,
    _: Option<&str>,
    _: bool,
    _: Option<&str>,
) {
}

pub(crate) fn reserve_deferred_session_replay_key(
    _: &Response<Body>,
    _: Option<&str>,
    _: bool,
    _: Option<&str>,
) -> Option<Never<'static>> {
    None
}

pub(crate) fn keep_deferred_session_commit_locked(_: &mut Response<Body>) {}