diff --git a/http/src/util/mod.rs b/http/src/util/mod.rs
index ee6522708..7722b923d 100644
--- a/http/src/util/mod.rs
+++ b/http/src/util/mod.rs
@@ -9,3 +9,106 @@ pub(crate) mod futures;
 #[cfg(feature = "http1")]
 pub(crate) mod hint;
 pub(crate) mod keep_alive;
+
+pub mod cursed {
+    use std::{boxed::Box, marker::PhantomData};
+
+    use xitca_service::{
+        fn_build,
+        object::{
+            helpers::{ServiceObject, Wrapper},
+            ObjectConstructor,
+        },
+        BuildService, BuildServiceExt, Service,
+    };
+
+    /// A trait that serves a type-level function to convert a type from one lifetime to another.
+    ///
+    /// For example: `for<'a> <&'static str as Cursed>::Type<'a> = &'a str`
+    pub trait Cursed {
+        /// A projection that takes `Self` as type and a given lifetime `'a`
+        type Type<'a>: 'a;
+    }
+
+    /// Same as [Cursed] but works in value-level, rather than type-level.
+    ///
+    /// Cannot be merged with [Cursed], because of _rust issue number_.
+    pub trait CursedMap: Cursed {
+        /// A map that takes `Self` as a value and given lifetime, `'a`,
+        /// and outputs a value of type `Self::Type<'a>`.
+        fn map<'a>(self) -> Self::Type<'a>
+        where
+            Self: 'a;
+    }
+
+    impl<B: 'static> Cursed for http::Request<B> {
+        type Type<'a> = Self;
+    }
+    impl<B: 'static> CursedMap for http::Request<B> {
+        fn map<'a>(self) -> Self::Type<'a> {
+            self
+        }
+    }
+
+    impl<B: 'static> Cursed for crate::request::Request<B> {
+        type Type<'a> = Self;
+    }
+    impl<B: 'static> CursedMap for crate::request::Request<B> {
+        fn map<'a>(self) -> Self::Type<'a> {
+            self
+        }
+    }
+
+    impl Cursed for String {
+        type Type<'a> = Self;
+    }
+    impl CursedMap for String {
+        fn map<'a>(self) -> Self::Type<'a> {
+            self
+        }
+    }
+
+    /// An [object constructor](ObjectConstructor) for service with [cursed](Cursed)
+    /// request types.
+    pub struct CursedObjectConstructor<Req: Cursed>(PhantomData<Req>);
+
+    pub type CursedFactoryObject<Req: Cursed, BErr, Res, Err> =
+        impl BuildService<Error = BErr, Service = CursedServiceObject<Req, Res, Err>>;
+
+    pub type CursedServiceObject<Req: Cursed, Res, Err> =
+        impl for<'r> Service<Req::Type<'r>, Response = Res, Error = Err>;
+
+    impl<I, Svc, BErr, Req, Res, Err> ObjectConstructor<I> for CursedObjectConstructor<Req>
+    where
+        I: BuildService<Service = Svc, Error = BErr> + 'static,
+        Svc: for<'r> Service<Req::Type<'r>, Response = Res, Error = Err> + 'static,
+
+        Req: Cursed,
+
+        // This bound is necessary to guide type inference to infer `Req`.
+        // Because we can't  provide a static guarantee to exclude
+        // such rogue implementations:
+        // ```
+        // impl Cursed for &'_ str {
+        //      type Type<'a> = &'a u8;
+        // }
+        // ```
+        Svc: Service<Req>,
+    {
+        type Object = CursedFactoryObject<Req, BErr, Res, Err>;
+
+        fn into_object(inner: I) -> Self::Object {
+            let factory = fn_build(move |_arg: ()| {
+                let fut = inner.build(());
+                async move {
+                    let boxed_service = Box::new(Wrapper(fut.await?))
+                        as Box<dyn for<'r> ServiceObject<Req::Type<'r>, Response = _, Error = _>>;
+                    Ok(Wrapper(boxed_service))
+                }
+            })
+            .boxed_future();
+
+            Box::new(factory) as Box<dyn BuildService<Service = _, Error = _, Future = _>>
+        }
+    }
+}
diff --git a/http/src/util/service/context.rs b/http/src/util/service/context.rs
index 9a0a0e36f..4f5d0099d 100644
--- a/http/src/util/service/context.rs
+++ b/http/src/util/service/context.rs
@@ -3,6 +3,7 @@ use std::{future::Future, marker::PhantomData};
 use xitca_service::{pipeline::PipelineE, ready::ReadyService, BuildService, Service};
 
 use crate::request::{BorrowReq, BorrowReqMut};
+use crate::util::cursed::{Cursed, CursedMap};
 
 /// ServiceFactory type for constructing compile time checked stateful service.
 ///
@@ -99,6 +100,29 @@ impl<'a, Req, C> Context<'a, Req, C> {
     }
 }
 
+impl<Req, C> Cursed for Context<'_, Req, C>
+where
+    Req: Cursed,
+    C: 'static,
+{
+    type Type<'a> = Context<'a, Req::Type<'a>, C>;
+}
+impl<Req, C> CursedMap for Context<'_, Req, C>
+where
+    Req: CursedMap,
+    C: 'static,
+{
+    fn map<'a>(self) -> Self::Type<'a>
+    where
+        Self: 'a,
+    {
+        Context {
+            req: self.req.map(),
+            state: self.state,
+        }
+    }
+}
+
 impl<Req, C, T> BorrowReq<T> for Context<'_, Req, C>
 where
     Req: BorrowReq<T>,
@@ -151,7 +175,8 @@ pub struct ContextService<C, S> {
 
 impl<Req, C, S, Res, Err> Service<Req> for ContextService<C, S>
 where
-    S: for<'c> Service<Context<'c, Req, C>, Response = Res, Error = Err>,
+    S: for<'c> Service<Context<'c, Req::Type<'c>, C>, Response = Res, Error = Err>,
+    Req: CursedMap,
 {
     type Response = Res;
     type Error = Err;
@@ -161,7 +186,7 @@ where
         async move {
             self.service
                 .call(Context {
-                    req,
+                    req: req.map(),
                     state: &self.state,
                 })
                 .await
@@ -169,11 +194,12 @@ where
     }
 }
 
-impl<Req, C, S, R, Res, Err> ReadyService<Req> for ContextService<C, S>
+impl<Req, C, S> ReadyService<Req> for ContextService<C, S>
 where
-    S: for<'c> ReadyService<Context<'c, Req, C>, Response = Res, Error = Err, Ready = R>,
+    Self: Service<Req>,
+    S: ReadyService<Req>,
 {
-    type Ready = R;
+    type Ready = S::Ready;
     type ReadyFuture<'f> = impl Future<Output = Self::Ready> where Self: 'f;
 
     #[inline]
@@ -182,51 +208,6 @@ where
     }
 }
 
-pub mod object {
-    use super::*;
-
-    use std::{boxed::Box, marker::PhantomData};
-
-    use xitca_service::{
-        fn_build,
-        object::{
-            helpers::{ServiceObject, Wrapper},
-            ObjectConstructor,
-        },
-        BuildService, BuildServiceExt, Service,
-    };
-
-    pub struct ContextObjectConstructor<Req, C>(PhantomData<(Req, C)>);
-
-    pub type ContextFactoryObject<Req, C, BErr, Res, Err> =
-        impl BuildService<Error = BErr, Service = ContextServiceObject<Req, C, Res, Err>>;
-
-    pub type ContextServiceObject<Req, C, Res, Err> =
-        impl for<'c> Service<Context<'c, Req, C>, Response = Res, Error = Err>;
-
-    impl<C, I, Svc, BErr, Req, Res, Err> ObjectConstructor<I> for ContextObjectConstructor<Req, C>
-    where
-        I: BuildService<Service = Svc, Error = BErr> + 'static,
-        Svc: for<'c> Service<Context<'c, Req, C>, Response = Res, Error = Err> + 'static,
-    {
-        type Object = ContextFactoryObject<Req, C, BErr, Res, Err>;
-
-        fn into_object(inner: I) -> Self::Object {
-            let factory = fn_build(move |_arg: ()| {
-                let fut = inner.build(());
-                async move {
-                    let boxed_service = Box::new(Wrapper(fut.await?))
-                        as Box<dyn for<'c> ServiceObject<Context<'c, Req, C>, Response = _, Error = _>>;
-                    Ok(Wrapper(boxed_service))
-                }
-            })
-            .boxed_future();
-
-            Box::new(factory) as Box<dyn BuildService<Service = _, Error = _, Future = _>>
-        }
-    }
-}
-
 #[cfg(test)]
 mod test {
     use std::convert::Infallible;
@@ -289,7 +270,8 @@ mod test {
             service.call(req).await
         }
 
-        let router = GenericRouter::with_custom_object::<super::object::ContextObjectConstructor<_, _>>()
+        let router = GenericRouter::with_cursed_object()
+            //let router = GenericRouter::with_custom_object::<super::object::ContextObjectConstructor<_, _>>()
             .insert("/", get(fn_service(handler)))
             .enclosed_fn(enclosed);
 
@@ -306,4 +288,50 @@ mod test {
 
         assert_eq!(res.status().as_u16(), 200);
     }
+
+    #[tokio::test]
+    async fn nested_lifetime_request() {
+        struct Req<'a> {
+            _r: &'a str,
+        }
+
+        impl Cursed for Req<'_> {
+            type Type<'a> = Req<'a>;
+        }
+        impl CursedMap for Req<'_> {
+            fn map<'a>(self) -> Self::Type<'a>
+            where
+                Self: 'a,
+            {
+                self
+            }
+        }
+
+        impl BorrowReq<http::Uri> for Req<'_> {
+            fn borrow(&self) -> &http::Uri {
+                Box::leak(Box::new(http::Uri::from_static("http://host.com/")))
+            }
+        }
+
+        async fn handler(req: Context<'_, Req<'_>, String>) -> Result<Response<()>, Infallible> {
+            let (_, state) = req.into_parts();
+            assert_eq!(state, "string_state");
+            Ok(Response::new(()))
+        }
+
+        let router = GenericRouter::with_cursed_object().insert("/", fn_service(handler));
+
+        let service = ContextBuilder::new(|| async { Ok::<_, Infallible>(String::from("string_state")) })
+            .service(router)
+            .build(())
+            .await
+            .ok()
+            .unwrap();
+
+        let r = String::new();
+
+        let res = service.call(Req { _r: r.as_str() }).await.unwrap();
+
+        assert_eq!(res.status().as_u16(), 200);
+    }
 }
diff --git a/http/src/util/service/router.rs b/http/src/util/service/router.rs
index cfbfa7c5c..a91bdd799 100644
--- a/http/src/util/service/router.rs
+++ b/http/src/util/service/router.rs
@@ -8,7 +8,11 @@ use xitca_service::{
     BuildService, Service,
 };
 
-use crate::{http, request::BorrowReq};
+use crate::{
+    http,
+    request::BorrowReq,
+    util::cursed::{Cursed, CursedObjectConstructor},
+};
 
 /// A [GenericRouter] specialized with [DefaultObjectConstructor]
 pub type Router<Req, Arg, BErr, Res, Err> =
@@ -38,6 +42,11 @@ impl<SF> GenericRouter<(), SF> {
         GenericRouter::new()
     }
 
+    /// Creates a new router with a [cursed object constructor](CursedObjectConstructor).
+    pub fn with_cursed_object<Req: Cursed>() -> GenericRouter<CursedObjectConstructor<Req>, SF> {
+        GenericRouter::new()
+    }
+
     /// Creates a new router with a custom [object constructor](ObjectConstructor).
     pub fn with_custom_object<ObjCons>() -> GenericRouter<ObjCons, SF> {
         GenericRouter::new()
diff --git a/web/src/app/mod.rs b/web/src/app/mod.rs
index 56406ea77..a4236bdb2 100644
--- a/web/src/app/mod.rs
+++ b/web/src/app/mod.rs
@@ -265,7 +265,7 @@ mod test {
         let mut req = Request::default();
         req.extensions_mut().insert(Foo);
 
-        let res = service.call(req).await.unwrap();
+        let res = Service::<Request<_>>::call(&service, req).await.unwrap();
 
         assert_eq!(res.status().as_u16(), 200);
         assert_eq!(res.headers().get(CONTENT_TYPE).unwrap(), TEXT_UTF8);
@@ -273,14 +273,14 @@ mod test {
         let mut req = Request::default();
         *req.uri_mut() = Uri::from_static("/abc");
 
-        let res = service.call(req).await.unwrap();
+        let res = Service::<Request<_>>::call(&service, req).await.unwrap();
 
         assert_eq!(res.status().as_u16(), 404);
 
         let mut req = Request::default();
         *req.method_mut() = Method::POST;
 
-        let res = service.call(req).await.unwrap();
+        let res = Service::<Request<_>>::call(&service, req).await.unwrap();
 
         assert_eq!(res.status().as_u16(), 405);
     }