Shave an enormous yak

Author: nbudin

Cargo.lock

@@ -49,17 +49,18 @@ members = [
 [workspace.dependencies]
 Inflector = "*"
 askama = {version = "0.12.1", features = ["with-axum"]}
-askama_axum = "0.3.0"
-async-graphql = {version = "~6.0.10", features = ["tracing", "dataloader", "chrono"]}
-async-graphql-axum = "~6.0.10"
-async-graphql-value = {version = "~6.0.10"}
+askama_axum = "0.4.0"
+async-graphql = {git = "https://github.com/async-graphql/async-graphql.git", features = ["tracing", "dataloader", "chrono"]}
+async-graphql-axum = {git = "https://github.com/async-graphql/async-graphql.git"}
+async-graphql-value = {git = "https://github.com/async-graphql/async-graphql.git"}
 async-trait = "*"
-aws-config = "0.57.1"
-aws-sdk-sesv2 = "0.35.0"
+aws-config = "1.1.1"
+aws-sdk-sesv2 = "1.7.0"
+aws-smithy-runtime-api = "*"
 aws-smithy-types = "*"
-axum = {version = "~0.6.20", features = ["multipart", "macros", "headers"]}
-axum-extra = {version = "~0.8.0", features = ["cookie"]}
-axum-server = {version = "0.5.1", features = ["tls-rustls"]}
+axum = {version = "~0.7.2", features = ["multipart", "macros"]}
+axum-extra = {version = "~0.9.0", features = ["cookie"]}
+axum-server = {git = "https://github.com/programatik29/axum-server.git", features = ["tls-rustls"]}
 base64 = "0.21.5"
 bcrypt = "0.15.0"
 bumpalo = "3.14.0"
@@ -72,8 +73,8 @@ dyn-clone = "1.0.16"
 futures = "0.3.29"
 hex = "0.4.3"
 html-escape = "0.2.13"
-http = "0.2.9"
-hyper = "0.14.27"
+http = "1.0.0"
+hyper = "1.0.1"
 i18n-embed = {version = "0.14.1", features = ["fluent-system"]}
 i18n-embed-fl = "0.7"
 ics = "0.5.8"
@@ -131,8 +132,8 @@ syn = "2.0.39"
 time = "0.3.30"
 tokio = {version = "~1.34.0", features = ["rt-multi-thread", "macros", "signal", "tracing"]}
 tower = {version = "0.4.13", features = ["limit", "make"]}
-tower-http = {version = "0.4.4", features = ["catch-panic", "compression-br", "compression-deflate", "compression-gzip", "trace"]}
-tower-sessions = "~0.4.1"
+tower-http = {version = "0.5.0", features = ["catch-panic", "compression-br", "compression-deflate", "compression-gzip", "trace"]}
+tower-sessions = "~0.7.0"
 tracing = "0.1.40"
 tuple-conv = "~1.0.1"
 twilio = "1.0.3"
@@ -146,6 +147,7 @@ tokio-console = ["dep:console-subscriber", "tokio/full", "tokio/tracing"]
 
 [dependencies]
 async-graphql = {workspace = true}
+async-graphql-axum = {workspace = true}
 axum = {workspace = true}
 chrono = {workspace = true}
 chrono-tz = {workspace = true}

Cargo.toml

@@ -9,6 +9,7 @@ version = "0.1.0"
 async-graphql = {workspace = true}
 aws-config = {workspace = true}
 aws-sdk-sesv2 = {workspace = true}
+aws-smithy-runtime-api = {workspace = true}
 aws-smithy-types = {workspace = true}
 http = {workspace = true}
 intercode_entities = {workspace = true}

crates/intercode_email/Cargo.toml

@@ -1,18 +1,19 @@
-use aws_config::SdkConfig;
+use aws_config::{BehaviorVersion, SdkConfig};
 use aws_sdk_sesv2::{
   error::SdkError,
   operation::send_email::{SendEmailError, SendEmailOutput},
   types::{Body, Content, Destination, EmailContent, Message},
 };
-use aws_smithy_types::body::SdkBody;
-use http::Response;
+use aws_smithy_runtime_api::client::orchestrator::HttpResponse;
 use tokio::sync::OnceCell;
 
 static AWS_CONFIG: OnceCell<SdkConfig> = OnceCell::const_new();
 static SES_CLIENT: OnceCell<aws_sdk_sesv2::Client> = OnceCell::const_new();
 
 async fn get_aws_config() -> &'static SdkConfig {
-  AWS_CONFIG.get_or_init(aws_config::load_from_env).await
+  AWS_CONFIG
+    .get_or_init(|| aws_config::load_defaults(BehaviorVersion::latest()))
+    .await
 }
 
 async fn get_ses_client() -> &'static aws_sdk_sesv2::Client {
@@ -30,7 +31,7 @@ pub async fn send_email(
   subject: &str,
   body_html: Option<&str>,
   body_text: Option<&str>,
-) -> Result<SendEmailOutput, SdkError<SendEmailError, Response<SdkBody>>> {
+) -> Result<SendEmailOutput, SdkError<SendEmailError, HttpResponse>> {
   let client = get_ses_client().await;
   let mut body = Body::builder();
   if let Some(body_html) = body_html {

crates/intercode_email/src/send_email.rs

@@ -6,18 +6,15 @@ use async_graphql::{
   EmptySubscription, Schema,
 };
 use async_graphql_axum::{GraphQLBatchRequest, GraphQLResponse};
-use axum::{
-  extract::State,
-  response::{self, IntoResponse},
-};
+use axum::response::{self, IntoResponse};
 use intercode_graphql_core::liquid_renderer::{LiquidRenderer, LiquidRendererFromRequest};
 use intercode_graphql_loaders::LoaderManager;
 use intercode_server::AuthorizationInfoAndQueryDataFromRequest;
 
 pub type IntercodeSchema = Schema<api::QueryRoot, api::MutationRoot, EmptySubscription>;
 
-pub async fn graphql_handler(
-  State(schema): State<IntercodeSchema>,
+pub async fn graphql_handler_inner(
+  schema: IntercodeSchema,
   AuthorizationInfoAndQueryDataFromRequest(authorization_info, query_data): AuthorizationInfoAndQueryDataFromRequest,
   LiquidRendererFromRequest(liquid_renderer): LiquidRendererFromRequest,
   req: GraphQLBatchRequest,

crates/intercode_graphql/src/actions/graphql.rs

@@ -7,7 +7,6 @@ use axum::extract::FromRef;
 use axum::BoxError;
 use axum::{middleware::from_fn_with_state, routing::IntoMakeService, Extension, Router};
 use http::StatusCode;
-use hyper::body::HttpBody;
 use sea_orm::DatabaseConnection;
 use tower::limit::ConcurrencyLimitLayer;
 use tower::ServiceBuilder;
@@ -21,12 +20,11 @@ use crate::{
   request_bound_transaction::request_bound_transaction,
 };
 
-pub fn build_app<S, F, B>(state: S, build_routes: F) -> Result<IntoMakeService<Router<(), B>>>
+pub fn build_app<S, F>(state: S, build_routes: F) -> Result<IntoMakeService<Router>>
 where
   S: Clone + Send + Sync + 'static,
   Arc<DatabaseConnection>: FromRef<S>,
-  F: FnOnce(Router<S, B>) -> Router<S, B>,
-  B: HttpBody + Send + Sync + Unpin + 'static,
+  F: FnOnce(Router<S>) -> Router<S>,
 {
   let secret_bytes = hex::decode(env::var("SECRET_KEY_BASE")?)?;
   let secret: [u8; 64] = secret_bytes[0..64].try_into().unwrap_or_else(|_| {
@@ -39,7 +37,7 @@ where
   let csrf_config = CsrfConfig::new(&secret);
   let session_layer = SessionWithDbStoreFromTxLayer::new();
 
-  let app: Router<S, B> = Router::new();
+  let app: Router<S> = Router::new();
   let app = build_routes(app);
 
   let session_service = ServiceBuilder::new()

crates/intercode_server/src/app.rs

@@ -3,7 +3,7 @@
 
 use async_trait::async_trait;
 use axum::{
-  extract::FromRequestParts,
+  extract::{FromRequestParts, Request},
   http::{self, StatusCode},
   middleware::Next,
   response::{IntoResponse, IntoResponseParts, Response, ResponseParts},
@@ -14,7 +14,7 @@ use axum_extra::extract::{
 };
 use base64::Engine;
 use csrf::{ChaCha20Poly1305CsrfProtection, CsrfCookie, CsrfProtection, CsrfToken};
-use http::{request::Parts, Request};
+use http::request::Parts;
 use std::{
   borrow::Cow,
   fmt::{Debug, Display},
@@ -185,7 +185,7 @@ impl CsrfData {
     let lifespan = OffsetDateTime::now_utc() + self.config.lifespan;
 
     let mut cookie_builder =
-      Cookie::build(self.config.cookie_name.clone(), self.cookie.b64_string())
+      Cookie::build((self.config.cookie_name.clone(), self.cookie.b64_string()))
         .path(self.config.cookie_path.clone())
         .secure(self.config.cookie_secure)
         .http_only(self.config.cookie_http_only)
@@ -197,15 +197,15 @@ impl CsrfData {
         .same_site(self.config.cookie_same_site);
     }
 
-    cookie_builder.finish()
+    cookie_builder.build()
   }
 }
 
-pub async fn csrf_middleware<B: Send>(
+pub async fn csrf_middleware(
   token: CsrfData,
   jar: CookieJar,
-  req: Request<B>,
-  next: Next<B>,
+  req: Request,
+  next: Next,
 ) -> Result<Response, (StatusCode, String)> {
   let future = next.run(req);
   let response = future.await;

crates/intercode_server/src/csrf.rs

@@ -1,12 +1,9 @@
-use std::error::Error;
-
 use axum::{
   async_trait,
-  body::{Bytes, HttpBody},
   extract::{FromRequest, Multipart},
   Form,
 };
-use http::{Request, StatusCode};
+use http::StatusCode;
 use once_cell::sync::Lazy;
 use regex::bytes::Regex;
 
@@ -18,16 +15,13 @@ pub enum FormOrMultipart<T> {
 }
 
 #[async_trait]
-impl<T, S: Send + Sync, B: Send + Sync + 'static> FromRequest<S, B> for FormOrMultipart<T>
+impl<T, S: Send + Sync> FromRequest<S> for FormOrMultipart<T>
 where
-  Form<T>: FromRequest<S, B>,
-  B: HttpBody,
-  Bytes: From<<B as HttpBody>::Data>,
-  <B as HttpBody>::Error: Error + Send + Sync,
+  Form<T>: FromRequest<S>,
 {
   type Rejection = StatusCode;
 
-  async fn from_request(req: Request<B>, state: &S) -> Result<Self, Self::Rejection> {
+  async fn from_request(req: axum::extract::Request, state: &S) -> Result<Self, Self::Rejection> {
     if let Some(content_type) = req.headers().get("content-type") {
       let content_type = content_type
         .to_str()

crates/intercode_server/src/form_or_multipart.rs

@@ -1,17 +1,17 @@
 use std::sync::Arc;
 
 use axum::{
-  extract::State,
+  extract::{Request, State},
   middleware::Next,
   response::{IntoResponse, Response},
 };
-use http::{Request, StatusCode};
+use http::StatusCode;
 use sea_orm::{DatabaseConnection, DbErr, TransactionTrait};
 use seawater::ConnectionWrapper;
 
-async fn run_request_bound_transaction<B>(
-  mut request: Request<B>,
-  next: Next<B>,
+async fn run_request_bound_transaction(
+  mut request: Request,
+  next: Next,
   db: &DatabaseConnection,
 ) -> Result<Response, DbErr> {
   let extensions_mut = request.extensions_mut();
@@ -38,10 +38,10 @@ async fn run_request_bound_transaction<B>(
   Ok(response)
 }
 
-pub async fn request_bound_transaction<B>(
+pub async fn request_bound_transaction(
   State(db_conn): State<Arc<DatabaseConnection>>,
-  request: Request<B>,
-  next: Next<B>,
+  request: Request,
+  next: Next,
 ) -> Response {
   run_request_bound_transaction(request, next, &db_conn)
     .await

crates/intercode_server/src/request_bound_transaction.rs

@@ -3,11 +3,11 @@ use std::net::{IpAddr, Ipv4Addr, SocketAddr};
 use std::time::Duration;
 
 use async_graphql::Result;
-use axum_server::service::MakeServiceRef;
+use axum_server::service::MakeService;
 use axum_server::tls_rustls::{RustlsAcceptor, RustlsConfig};
 use axum_server::{Handle, Server};
 use http::Request;
-use hyper::server::conn::AddrStream;
+use hyper::body::Incoming;
 use opentelemetry::global::shutdown_tracer_provider;
 use tokio::time::sleep;
 use tracing::log::*;
@@ -70,7 +70,7 @@ async fn graceful_shutdown(handle: Handle) {
   }
 }
 
-pub async fn serve<M: MakeServiceRef<AddrStream, Request<hyper::Body>>>(app: M) -> Result<()> {
+pub async fn serve<M: MakeService<SocketAddr, Request<Incoming>>>(app: M) -> Result<()> {
   let addr = SocketAddr::new(
     IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)),
     env::var("PORT")