implement default for routes required to work to get element to switch screens

src/api/client_server/mod.rs

@@ -1,3 +1,3 @@
 pub mod errors;
 pub mod r0;
-pub mod versions;
+pub mod versions;

src/api/client_server/r0/auth.rs

@@ -30,7 +30,6 @@ pub fn routes() -> axum::Router {
         .route("/r0/register/available", get(get_username_available))
 }
 
-#[tracing::instrument]
 async fn get_login_types() -> Result<RumaResponse<session::get_login_types::v3::Response>, ApiError>
 {
     use session::get_login_types::v3::*;
@@ -40,7 +39,6 @@ async fn get_login_types() -> Result<RumaResponse<session::get_login_types::v3::
     )))
 }
 
-#[tracing::instrument(skip_all)]
 async fn login(
     Extension(config): Extension<Arc<Config>>,
     Extension(db): Extension<SqlitePool>,
@@ -92,7 +90,6 @@ async fn login(
     }
 }
 
-#[tracing::instrument(skip_all)]
 async fn get_username_available(
     Extension(config): Extension<Arc<Config>>,
     Extension(db): Extension<SqlitePool>,
@@ -112,7 +109,6 @@ async fn get_username_available(
     Ok(RumaResponse(Response::new(!exists)))
 }
 
-#[tracing::instrument(skip_all)]
 async fn post_register(
     Extension(config): Extension<Arc<Config>>,
     Extension(db): Extension<SqlitePool>,

src/api/client_server/r0/filter.rs

@@ -0,0 +1,25 @@
+use std::sync::Arc;
+
+use axum::routing::post;
+use axum::Extension;
+
+use crate::api::client_server::errors::api_error::ApiError;
+use crate::models::users::User;
+use crate::ruma_wrapper::{RumaRequest, RumaResponse};
+
+use ruma::api::client::filter;
+
+pub fn routes() -> axum::Router {
+    axum::Router::new()
+        .route("/r0/user/:user_id/filter", post(create_filter))
+        .layer(axum::middleware::from_fn(super::authentication_middleware))
+}
+
+async fn create_filter(
+    Extension(_user): Extension<Arc<User>>,
+    RumaRequest(_req): RumaRequest<filter::create_filter::v3::IncomingRequest>,
+) -> Result<RumaResponse<filter::create_filter::v3::Response>, ApiError> {
+    use filter::create_filter::v3::*;
+
+    Ok(RumaResponse(Response::new("a".into())))
+}

src/api/client_server/r0/keys.rs

@@ -0,0 +1,25 @@
+use std::sync::Arc;
+
+use axum::routing::post;
+use axum::Extension;
+
+use crate::api::client_server::errors::api_error::ApiError;
+use crate::models::users::User;
+use crate::ruma_wrapper::{RumaRequest, RumaResponse};
+
+use ruma::api::client::keys;
+
+pub fn routes() -> axum::Router {
+    axum::Router::new()
+        .route("/r0/keys/query", post(get_keys))
+        .layer(axum::middleware::from_fn(super::authentication_middleware))
+}
+
+async fn get_keys(
+    Extension(_user): Extension<Arc<User>>,
+    RumaRequest(_req): RumaRequest<keys::get_keys::v3::IncomingRequest>,
+) -> Result<RumaResponse<keys::get_keys::v3::Response>, ApiError> {
+    use keys::get_keys::v3::*;
+
+    Ok(RumaResponse(Response::new()))
+}

src/api/client_server/r0/mod.rs

@@ -13,9 +13,12 @@ use crate::{models::sessions::Session, types::error_code::ErrorCode};
 use super::errors::ErrorResponse;
 
 pub mod auth;
-pub mod room;
+pub mod filter;
+pub mod keys;
 pub mod presence;
 pub mod push;
+pub mod room;
+pub mod sync;
 pub mod thirdparty;
 
 async fn authentication_middleware<B>(mut req: Request<B>, next: Next<B>) -> impl IntoResponse {

src/api/client_server/r0/presence.rs

@@ -0,0 +1,36 @@
+use std::sync::Arc;
+
+use axum::routing::{get, put};
+use axum::Extension;
+
+use crate::api::client_server::errors::api_error::ApiError;
+use crate::models::users::User;
+use crate::ruma_wrapper::{RumaRequest, RumaResponse};
+
+use ruma::api::client::presence;
+use ruma::presence::PresenceState;
+
+pub fn routes() -> axum::Router {
+    axum::Router::new()
+        .route("/r0/presence/:user_id/status", put(set_presence))
+        .route("/r0/presence/:user_id/status", get(get_presence))
+        .layer(axum::middleware::from_fn(super::authentication_middleware))
+}
+
+async fn set_presence(
+    Extension(_user): Extension<Arc<User>>,
+    RumaRequest(_req): RumaRequest<presence::set_presence::v3::IncomingRequest>,
+) -> Result<RumaResponse<presence::set_presence::v3::Response>, ApiError> {
+    use presence::set_presence::v3::*;
+
+    Ok(RumaResponse(Response::new()))
+}
+
+async fn get_presence(
+    Extension(_user): Extension<Arc<User>>,
+    RumaRequest(_req): RumaRequest<presence::get_presence::v3::IncomingRequest>,
+) -> Result<RumaResponse<presence::get_presence::v3::Response>, ApiError> {
+    use presence::get_presence::v3::*;
+
+    Ok(RumaResponse(Response::new(PresenceState::Unavailable)))
+}

src/api/client_server/r0/push.rs

@@ -0,0 +1,25 @@
+use std::sync::Arc;
+
+use axum::routing::get;
+use axum::Extension;
+
+use crate::api::client_server::errors::api_error::ApiError;
+use crate::models::users::User;
+use crate::ruma_wrapper::{RumaRequest, RumaResponse};
+
+use ruma::api::client::push;
+use ruma::push::Ruleset;
+
+pub fn routes() -> axum::Router {
+    axum::Router::new()
+        .route("/r0/pushrules/", get(get_pushrules))
+        .layer(axum::middleware::from_fn(super::authentication_middleware))
+}
+
+async fn get_pushrules(
+    Extension(_user): Extension<Arc<User>>,
+) -> Result<RumaResponse<push::get_pushrules_all::v3::Response>, ApiError> {
+    use push::get_pushrules_all::v3::*;
+
+    Ok(RumaResponse(Response::new(Ruleset::new())))
+}

src/api/client_server/r0/room.rs

@@ -0,0 +1,19 @@
+use axum::routing::post;
+
+use crate::api::client_server::errors::api_error::ApiError;
+use crate::ruma_wrapper::RumaRequest;
+
+use ruma::api::client::room;
+
+pub fn routes() -> axum::Router {
+    axum::Router::new()
+        .route("/r0/createRoom", post(create_room))
+        .layer(axum::middleware::from_fn(super::authentication_middleware))
+}
+
+async fn create_room(
+    RumaRequest(req): RumaRequest<room::create_room::v3::IncomingRequest>,
+) -> Result<String, ApiError> {
+    dbg!(req);
+    Ok("".into())
+}

src/api/client_server/r0/sync.rs

@@ -0,0 +1,29 @@
+use std::sync::Arc;
+
+use axum::routing::get;
+use axum::Extension;
+
+use crate::api::client_server::errors::api_error::ApiError;
+use crate::models::users::User;
+use crate::ruma_wrapper::{RumaRequest, RumaResponse};
+
+use ruma::api::client::sync;
+
+pub fn routes() -> axum::Router {
+    axum::Router::new()
+        .route("/r0/sync", get(sync_events))
+        .layer(axum::middleware::from_fn(super::authentication_middleware))
+}
+
+async fn sync_events(
+    Extension(_user): Extension<Arc<User>>,
+    RumaRequest(req): RumaRequest<sync::sync_events::v3::IncomingRequest>,
+) -> Result<RumaResponse<sync::sync_events::v3::Response>, ApiError> {
+    use sync::sync_events::v3::*;
+
+    if let Some(timeout) = req.timeout {
+        tokio::time::sleep(timeout).await;
+    }
+
+    Ok(RumaResponse(Response::new("todo".into())))
+}

src/api/client_server/r0/thirdparty.rs

@@ -3,9 +3,8 @@ use std::{collections::BTreeMap, sync::Arc};
 use axum::{routing::get, Extension};
 
 use crate::{
-    api::client_server::errors::api_error::ApiError,
+    api::client_server::errors::api_error::ApiError, models::users::User,
-    models::users::User,
+    ruma_wrapper::RumaResponse,
-    ruma_wrapper::{RumaRequest, RumaResponse},
 };
 
 use ruma::api::client::thirdparty;
@@ -16,7 +15,6 @@ pub fn routes() -> axum::Router {
         .layer(axum::middleware::from_fn(super::authentication_middleware))
 }
 
-#[tracing::instrument(skip_all)]
 async fn get_thirdparty_protocols(
     Extension(_user): Extension<Arc<User>>,
 ) -> Result<RumaResponse<thirdparty::get_protocols::v3::Response>, ApiError> {

src/api/client_server/versions.rs

@@ -7,7 +7,6 @@ pub fn routes() -> axum::Router {
     axum::Router::new().route("/versions", get(get_client_versions))
 }
 
-
 #[tracing::instrument]
 async fn get_client_versions() -> RumaResponse<discovery::get_supported_versions::Response> {
     use discovery::get_supported_versions::*;
@@ -18,4 +17,4 @@ async fn get_client_versions() -> RumaResponse<discovery::get_supported_versions
         "v1.1".to_owned(),
         "v1.2".to_owned(),
     ]))
-}
+}

src/main.rs

@@ -7,7 +7,12 @@ use axum::{
     Extension, Router,
 };
 use config::Config;
-use tower_http::{cors::CorsLayer, trace::TraceLayer};
+use tower_http::{
+    cors::CorsLayer,
+    trace::{DefaultMakeSpan, DefaultOnRequest, DefaultOnResponse, TraceLayer},
+    LatencyUnit,
+};
+use tracing::Level;
 
 mod api;
 mod config;
@@ -19,7 +24,7 @@ mod types;
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     if std::env::var("RUST_LOG").is_err() {
-        std::env::set_var("RUST_LOG", "debug,hyper=info");
+        std::env::set_var("RUST_LOG", "info,sqlx=off");
     }
 
     tracing_subscriber::fmt::init();
@@ -34,7 +39,10 @@ async fn main() -> anyhow::Result<()> {
         .allow_methods(tower_http::cors::Any)
         .allow_headers(tower_http::cors::Any);
 
-    let tracing_layer = TraceLayer::new_for_http();
+    let tracing_layer = TraceLayer::new_for_http()
+        .make_span_with(DefaultMakeSpan::new().level(Level::INFO))
+        .on_request(DefaultOnRequest::default().level(Level::INFO))
+        .on_response(DefaultOnResponse::default().level(Level::INFO));
 
     let client_server = Router::new()
         .merge(api::client_server::versions::routes())
@@ -42,7 +50,10 @@ async fn main() -> anyhow::Result<()> {
         .merge(api::client_server::r0::thirdparty::routes())
         .merge(api::client_server::r0::room::routes())
         .merge(api::client_server::r0::presence::routes())
-        .merge(api::client_server::r0::push::routes());
+        .merge(api::client_server::r0::push::routes())
+        .merge(api::client_server::r0::filter::routes())
+        .merge(api::client_server::r0::sync::routes())
+        .merge(api::client_server::r0::keys::routes());
 
     let router = Router::new()
         .nest("/_matrix/client", client_server)

src/ruma_wrapper.rs

@@ -37,14 +37,15 @@ where
             .await
             .map_err(|e| anyhow::anyhow!(e))?;
 
-        let json =
+        let json = serde_json::from_slice::<CanonicalJsonValue>(&body).ok();
-            serde_json::from_slice::<CanonicalJsonValue>(&body).map_err(|e| anyhow::anyhow!(e))?;
+
         let mut buf = BytesMut::new().writer();
         serde_json::to_writer(&mut buf, &json).expect("can't fail");
         let body = buf.into_inner().freeze();
 
         let builder = http::Request::builder().uri(req.uri()).method(req.method());
         let request = builder.body(body).map_err(|e| anyhow::anyhow!(e))?;
+
         Ok(Self(
             R::try_from_http_request(request, &path_params).map_err(|e| anyhow::anyhow!(e))?,
         ))