Use a fluent style for the middleware layers.

For endpoints that are unavailable, that default behaviour no longer needs to be specified: `Required(app)` will do that for you. For endpoints that are redirects until setup is completed, `Require(app).with_fallback(…response…)` will do that.

To make this a bit harder to break by accident, the default unavailable response is now its own type.

1 files changed, 36 insertions, 17 deletions

diff --git a/src/setup/required.rs b/src/setup/required.rs
index 5b7fe5b..2112e4b 100644
--- a/src/setup/required.rs
+++ b/src/setup/required.rs
@@ -5,34 +5,40 @@ use axum::{
 };
 use std::pin::Pin;
 use std::task::{Context, Poll};
-use tower::Service;
+use tower::{Layer, Service};
 
 use crate::{app::App, error::Internal};
 
-const UNAVAILABLE: (StatusCode, &str) = (
-    StatusCode::SERVICE_UNAVAILABLE,
-    "initial setup not completed",
-);
-
 #[derive(Clone)]
-pub struct Layer<F> {
-    app: App,
-    fallback: F,
-}
+pub struct Required(pub App);
 
-impl Layer<(StatusCode, &'static str)> {
-    pub fn or_unavailable(app: App) -> Self {
-        Self::with_fallback(app, UNAVAILABLE)
+impl Required {
+    pub fn with_fallback<F>(self, fallback: F) -> WithFallback<F> {
+        let Self(app) = self;
+        WithFallback { app, fallback }
     }
 }
 
-impl<F> Layer<F> {
-    pub fn with_fallback(app: App, fallback: F) -> Self {
-        Layer { app, fallback }
+impl<S> Layer<S> for Required {
+    type Service = Middleware<S, Unavailable>;
+
+    fn layer(&self, inner: S) -> Self::Service {
+        let Self(app) = self.clone();
+        Middleware {
+            inner,
+            app,
+            fallback: Unavailable,
+        }
     }
 }
 
-impl<S, F> tower::Layer<S> for Layer<F>
+#[derive(Clone)]
+pub struct WithFallback<F> {
+    app: App,
+    fallback: F,
+}
+
+impl<S, F> Layer<S> for WithFallback<F>
 where
     Self: Clone,
 {
@@ -86,3 +92,16 @@ where
         })
     }
 }
+
+#[derive(Clone)]
+pub struct Unavailable;
+
+impl IntoResponse for Unavailable {
+    fn into_response(self) -> Response {
+        (
+            StatusCode::SERVICE_UNAVAILABLE,
+            "initial setup not completed",
+        )
+            .into_response()
+    }
+}