use lift to implement clone

src/core/jit/graphql_executor.rs

@@ -8,6 +8,7 @@
 use crate::core::http::RequestContext;
 use crate::core::jit;
 use crate::core::jit::ConstValueExecutor;
+use crate::core::lift::{CanLift, Lift};
 use crate::core::merge_right::MergeRight;
 
 #[derive(Clone)]
@@ -22,20 +23,23 @@
     }
 }
 
-fn clone_request(req: &async_graphql::Request) -> async_graphql::Request {
-    let mut request = async_graphql::Request::new(req.query.clone());
-    request.variables = req.variables.clone();
-    request.extensions = req.extensions.clone();
-    request.operation_name = req.operation_name.clone();
-    request
+impl Clone for Lift<async_graphql::Request> {
+    fn clone(&self) -> Self {
+        let mut request = async_graphql::Request::new(self.query.clone());
+        request.variables = self.variables.clone();
+        request.extensions = self.extensions.clone();
+        request.operation_name = self.operation_name.clone();
+        request.into()
+    }
 }
 
 impl Executor for JITExecutor {
     fn execute(&self, request: async_graphql::Request) -> impl Future<Output = Response> + Send {
-        let jit_request = jit::Request::from(clone_request(&request));
+        let request = request.lift();
+        let jit_request = jit::Request::from(request.clone().take());
 
         // execute only introspection requests with async graphql.
-        let introspection_req = request.only_introspection();
+        let introspection_req = request.take().only_introspection();
 
         async {
             match ConstValueExecutor::new(&jit_request, self.app_ctx.clone()) {
@@ -46,12 +50,12 @@
 
                     let jit_resp = exec
                         .execute(&self.req_ctx, jit_request)
                         .await
                         .into_async_graphql();
 
                     if is_introspection_query {
                         let async_resp = self.app_ctx.execute(introspection_req).await;
                         jit_resp.merge_right(async_resp)
                     } else {
                         jit_resp
                     }

src/core/lift.rs

@@ -1,7 +1,7 @@
 use std::ops::Deref;
 
 ///
-/// Just an empty wrapper around a value used to implement `From` for foreign
+/// Just an empty wrapper around a value used to implement foreign traits for foreign
 /// types.
 pub struct Lift<A>(A);
 impl<A> Deref for Lift<A> {
@@ -12,7 +12,6 @@
 }
 
 impl<A> Lift<A> {
-    #[allow(dead_code)]
     pub fn take(self) -> A {
         self.0
     }
@@ -23,3 +22,13 @@
         Lift(a)
     }
 }
+
+pub trait CanLift: Sized {
+    fn lift(self) -> Lift<Self>;
+}
+
+impl<A> CanLift for A {
+    fn lift(self) -> Lift<Self> {
+        Lift::from(self)
+    }
+}