Better frontend assets handling and move the react app to /account/ (#1324)

This makes the Vite assets handling better, namely:

 - make it possible to include any vite assets in the templates
 - include the right `<link rel="preload">` tags for assets
 - include Subresource Integrity hashes
 - pre-compress assets and remove on-the-fly compression by the Rust server
 - build the CSS used by templates through Vite

It also moves the React app from /app/ to /account/, and remove some of the old SSR account screens.

crates/oidc-client/src/http_service/hyper.rs

@@ -19,17 +19,13 @@
 use std::time::Duration;
 
 use http::{header::USER_AGENT, HeaderValue};
+use http_body::Full;
 use hyper::client::{connect::dns::GaiResolver, HttpConnector};
 use hyper_rustls::{ConfigBuilderExt, HttpsConnectorBuilder};
-use tower::{limit::ConcurrencyLimitLayer, BoxError, ServiceBuilder};
-use tower_http::{
-    decompression::DecompressionLayer, follow_redirect::FollowRedirectLayer,
-    set_header::SetRequestHeaderLayer, timeout::TimeoutLayer,
-};
+use mas_http::BodyToBytesResponseLayer;
+use tower::{BoxError, ServiceBuilder};
+use tower_http::{timeout::TimeoutLayer, ServiceBuilderExt};
 
-mod body_layer;
-
-use self::body_layer::BodyLayer;
 use super::HttpService;
 
 static MAS_USER_AGENT: HeaderValue = HeaderValue::from_static("mas-oidc-client/0.0.1");
@@ -60,14 +56,11 @@ pub fn hyper_service() -> HttpService {
 
     let client = ServiceBuilder::new()
         .map_err(BoxError::from)
-        .layer(BodyLayer::default())
-        .layer(DecompressionLayer::new())
-        .layer(SetRequestHeaderLayer::overriding(
-            USER_AGENT,
-            MAS_USER_AGENT.clone(),
-        ))
-        .layer(ConcurrencyLimitLayer::new(10))
-        .layer(FollowRedirectLayer::new())
+        .map_request_body(Full::new)
+        .layer(BodyToBytesResponseLayer::default())
+        .override_request_header(USER_AGENT, MAS_USER_AGENT.clone())
+        .concurrency_limit(10)
+        .follow_redirects()
         .layer(TimeoutLayer::new(Duration::from_secs(10)))
         .service(client);
 

crates/oidc-client/src/http_service/hyper/body_layer.rs

@@ -1,88 +0,0 @@
-// Copyright 2022 Kévin Commaille.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use std::task::Poll;
-
-use bytes::Bytes;
-use futures_util::future::BoxFuture;
-use http::{Request, Response};
-use http_body::{Body, Full};
-use hyper::body::to_bytes;
-use thiserror::Error;
-use tower::{BoxError, Layer, Service};
-
-#[derive(Debug, Error)]
-#[error(transparent)]
-pub enum BodyError<E> {
-    Decompression(BoxError),
-    Service(E),
-}
-
-#[derive(Clone)]
-pub struct BodyService<S> {
-    inner: S,
-}
-
-impl<S> BodyService<S> {
-    pub const fn new(inner: S) -> Self {
-        Self { inner }
-    }
-}
-
-impl<S, E, ResBody> Service<Request<Bytes>> for BodyService<S>
-where
-    S: Service<Request<Full<Bytes>>, Response = Response<ResBody>, Error = E>,
-    ResBody: Body<Data = Bytes, Error = BoxError> + Send,
-    S::Future: Send + 'static,
-{
-    type Error = BodyError<E>;
-    type Response = Response<Bytes>;
-    type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;
-
-    fn poll_ready(&mut self, cx: &mut std::task::Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.inner.poll_ready(cx).map_err(BodyError::Service)
-    }
-
-    fn call(&mut self, request: Request<Bytes>) -> Self::Future {
-        let (parts, body) = request.into_parts();
-        let body = Full::new(body);
-
-        let request = Request::from_parts(parts, body);
-
-        let fut = self.inner.call(request);
-
-        let fut = async {
-            let response = fut.await.map_err(BodyError::Service)?;
-
-            let (parts, body) = response.into_parts();
-            let body = to_bytes(body).await.map_err(BodyError::Decompression)?;
-
-            let response = Response::from_parts(parts, body);
-            Ok(response)
-        };
-
-        Box::pin(fut)
-    }
-}
-
-#[derive(Default, Clone, Copy)]
-pub struct BodyLayer(());
-
-impl<S> Layer<S> for BodyLayer {
-    type Service = BodyService<S>;
-
-    fn layer(&self, inner: S) -> Self::Service {
-        BodyService::new(inner)
-    }
-}