Update make_request function to use ApiEncoding for input encoding

Author: rakshith-ravi

frontend/common/src/utils/client/make_request.rs

@@ -10,18 +10,15 @@ use http::Method;
 use leptos::{
 	server_fn::{
 		client::browser::BrowserClient,
-		codec::{Encoding, FromReq, IntoReq, Json},
+		codec::{Encoding, FromReq, GetUrl, IntoReq, PostUrl},
 		middleware::Layer,
 		request::{browser::BrowserRequest, ClientReq},
 		ServerFn,
 	},
 	ServerFnError,
 };
 use matchit::Router;
-use models::{
-	prelude::*,
-	utils::{GenericResponse, IntoAxumResponse},
-};
+use models::{prelude::*, utils::GenericResponse};
 use preprocess::Preprocessable;
 use serde::{Serialize, de::DeserializeOwned};
 
@@ -47,15 +44,19 @@ where
 	E: ApiEndpoint,
 {
 	const CONTENT_TYPE: &'static str =
-		if <E::ResponseBody as IntoAxumResponse>::is::<GenericResponse>() {
+		if std::any::TypeId::of::<E::ResponseBody>() == std::any::TypeId::of::<GenericResponse>() {
 			// If the response body is a GenericResponse, then we can't know the
 			// content type of the response. So we just return the default content
 			// type of binary data.
 			"application/octet-stream"
 		} else {
-			Json::CONTENT_TYPE
+			GetUrl::CONTENT_TYPE
 		};
-	const METHOD: Method = E::METHOD;
+	const METHOD: Method = if Method::GET == E::METHOD {
+		Method::GET
+	} else {
+		Method::POST
+	};
 }
 
 /// A struct that holds the request to be made to the backend. This is used
@@ -81,7 +82,7 @@ where
 	type Error = ErrorType;
 	type InputEncoding = ApiEncoding<E>;
 	type Output = AppResponse<E>;
-	type OutputEncoding = Json;
+	type OutputEncoding = ApiEncoding<E>;
 	#[cfg(not(target_arch = "wasm32"))]
 	type ServerRequest = http::Request<axum::body::Body>;
 	#[cfg(target_arch = "wasm32")]
@@ -94,7 +95,51 @@ where
 	const PATH: &'static str = <E::RequestPath as TypedPath>::PATH;
 
 	async fn run_body(self) -> Result<Self::Output, ServerFnError<Self::Error>> {
-		todo!()
+		use std::net::{IpAddr, SocketAddr};
+
+		use axum::extract::ConnectInfo;
+		use axum_extra::routing::TypedPath;
+		use tower::{
+			ServiceBuilder,
+			ServiceExt,
+			service_fn,
+			util::{BoxCloneService, BoxLayer},
+		};
+
+		let ConnectInfo(socket_addr) = leptos_axum::extract::<ConnectInfo<SocketAddr>>()
+			.await
+			.map_err(ErrorType::server_error)?;
+		let layer = API_CALL_REGISTRY
+			.get()
+			.expect("API call registry not initialized")
+			.read()
+			.expect("API call registry poisoned")
+			.get(&E::METHOD)
+			.unwrap_or_else(|| panic!("API call registry does not contain {}", E::METHOD))
+			.at(<E::RequestPath as TypedPath>::PATH)
+			.unwrap_or_else(|_| {
+				panic!(
+					"could not find route at path `{}`",
+					<E::RequestPath as TypedPath>::PATH
+				)
+			})
+			.value
+			.downcast_ref::<BoxLayer<
+				BoxCloneService<(ApiRequest<E>, IpAddr), AppResponse<E>, ErrorType>,
+				(ApiRequest<E>, IpAddr),
+				AppResponse<E>,
+				ErrorType,
+			>>()
+			.expect("unable to downcast layer")
+			.to_owned();
+		ServiceBuilder::new()
+			.layer(layer)
+			.service(BoxCloneService::new(service_fn(|_| async move {
+				unreachable!()
+			})))
+			.oneshot((self.request, socket_addr.ip()))
+			.await
+			.map_err(ServerFnError::WrappedServerError)
 	}
 
 	fn middlewares() -> Vec<Arc<dyn Layer<Self::ServerRequest, Self::ServerResponse>>> {
@@ -115,9 +160,21 @@ where
 		accepts: &str,
 	) -> Result<BrowserRequest, ServerFnError<ErrorType>> {
 		if E::METHOD == Method::GET {
-			BrowserRequest::try_new_get(path, Json::CONTENT_TYPE, accepts, query)
+			BrowserRequest::try_new_get(
+				path,
+				GetUrl::CONTENT_TYPE,
+				accepts,
+				serde_urlencoded::to_string(self.request.query)
+					.unwrap()
+					.as_str(),
+			)
 		} else {
-			BrowserRequest::try_new_post(path, Json::CONTENT_TYPE, accepts, body)
+			BrowserRequest::try_new_post(
+				path,
+				PostUrl::CONTENT_TYPE,
+				accepts,
+				serde_json::to_string(&self.request.body).unwrap(),
+			)
 		}
 	}
 }
@@ -131,7 +188,7 @@ where
 	E::ResponseBody: Serialize + DeserializeOwned,
 {
 	async fn from_req(
-		req: http::Request<axum::body::Body>,
+		_req: http::Request<axum::body::Body>,
 	) -> Result<Self, ServerFnError<ErrorType>> {
 		todo!()
 	}
@@ -168,80 +225,10 @@ where
 {
 	#[cfg(not(target_arch = "wasm32"))]
 	{
-		use std::net::{IpAddr, SocketAddr};
-
-		use axum::extract::ConnectInfo;
-		use axum_extra::routing::TypedPath;
-		use tower::{
-			ServiceBuilder,
-			ServiceExt,
-			service_fn,
-			util::{BoxCloneService, BoxLayer},
-		};
-
-		let ConnectInfo(socket_addr) = leptos_axum::extract::<ConnectInfo<SocketAddr>>()
-			.await
-			.map_err(ErrorType::server_error)?;
-		let layer = API_CALL_REGISTRY
-			.get()
-			.expect("API call registry not initialized")
-			.read()
-			.expect("API call registry poisoned")
-			.get(&E::METHOD)
-			.unwrap_or_else(|| panic!("API call registry does not contain {}", E::METHOD))
-			.at(<E::RequestPath as TypedPath>::PATH)
-			.unwrap_or_else(|_| {
-				panic!(
-					"could not find route at path `{}`",
-					<E::RequestPath as TypedPath>::PATH
-				)
-			})
-			.value
-			.downcast_ref::<BoxLayer<
-				BoxCloneService<(ApiRequest<E>, IpAddr), AppResponse<E>, ErrorType>,
-				(ApiRequest<E>, IpAddr),
-				AppResponse<E>,
-				ErrorType,
-			>>()
-			.expect("unable to downcast layer")
-			.to_owned();
-		ServiceBuilder::new()
-			.layer(layer)
-			.service(BoxCloneService::new(service_fn(|_| async move {
-				unreachable!()
-			})))
-			.oneshot((request, socket_addr.ip()))
-			.await
-			.map_err(ServerFnError::WrappedServerError)
+		MakeRequest { request }.run_body().await
 	}
 	#[cfg(target_arch = "wasm32")]
 	{
-		use models::utils::Headers;
-
-		let response = REQWEST_CLIENT
-			.get_or_init(reqwest::Client::new)
-			.request(E::METHOD, format!("/api/{}", request.path.to_string()))
-			.headers(request.headers.to_header_map())
-			.query(&request.query)
-			.json(&request.body)
-			.send()
-			.await
-			.map_err(|err| ServerFnError::Request(err.to_string()))?;
-
-		let status_code = response.status();
-		let headers = E::ResponseHeaders::from_header_map(response.headers())
-			.map_err(|err| ServerFnError::Response(err.to_string()))?;
-		let text = response
-			.text()
-			.await
-			.map_err(|err| ServerFnError::Response(err.to_string()))?;
-		let body =
-			serde_json::from_str(&text).map_err(|err| ServerFnError::Response(err.to_string()))?;
-
-		Ok(AppResponse {
-			status_code,
-			headers,
-			body,
-		})
+		MakeRequest { request }.run_on_client().await
 	}
 }