RomanEmreis · RomanEmreis · Feb 3, 2025 · Feb 3, 2025
diff --git a/src/di.rs b/src/di.rs
@@ -14,12 +14,21 @@ pub mod container;
 struct DiError;
 
 impl DiError {
+    #[inline]
     fn service_not_registered(type_name: &str) -> Error {
-        Error::client_error(format!("Services Error: service not registered: {}", type_name))
+        Error::server_error(format!("Services Error: service not registered: {}", type_name))
     }
 
+    #[inline]
     fn resolve_error(type_name: &str) -> Error {
-        Error::client_error(format!("Services Error: unable to resolve the service: {}", type_name))
+        Error::server_error(format!("Services Error: unable to resolve the service: {}", type_name))
+    }
+
+    #[inline]
+    fn resolve_transient_error() -> Error {
+        Error::server_error(
+            "Services Error: cannot resolve a `Transient` service as ref, use `resolve::<T>()` or `Dc<T>` instead",
+        )
     }
 }
 

diff --git a/src/di/container.rs b/src/di/container.rs
@@ -143,9 +143,7 @@ impl Container {
     /// Resolve a service as ref
     pub async fn resolve_ref<T: Inject + 'static>(&mut self) -> Result<&T, Error> {
         match self.get_service_entry::<T>()? {
-            ServiceEntry::Transient => Err(Error::server_error(
-                "cannot resolve a `Transient` service as ref, use `resolve::<T>()` or `Dc<T>` instead",
-            )),
+            ServiceEntry::Transient => Err(DiError::resolve_transient_error()),
             ServiceEntry::Singleton(instance) => Self::resolve_internal(instance),
             ServiceEntry::Scoped(cell) => {
                 let instance = cell

diff --git a/src/di/inject.rs b/src/di/inject.rs
@@ -64,6 +64,7 @@ pub trait Inject: Clone + Send + Sync {
 }
 
 impl<T: Default + Clone + Send + Sync> Inject for T {
+    #[inline]
     fn inject(_: &mut Container) -> impl Future<Output = Result<Self, Error>> + Send {
         ok(Self::default())
     }

diff --git a/src/http/request.rs b/src/http/request.rs
@@ -135,6 +135,13 @@ impl HttpRequest {
     pub async fn resolve<T: Inject + 'static>(&mut self) -> Result<T, Error> {
         self.container.resolve::<T>().await
     }
+
+    /// Resolves a service from Dependency Container and returns a reference
+    #[inline]
+    #[cfg(feature = "di")]
+    pub async fn resolve_ref<T: Inject + 'static>(&mut self) -> Result<&T, Error> {
+        self.container.resolve_ref::<T>().await
+    }
 
     /// Extracts a payload from request parts
     ///

diff --git a/src/middleware/http_context.rs b/src/middleware/http_context.rs
@@ -26,6 +26,7 @@ pub struct HttpContext {
 
 impl HttpContext {
     /// Creates a new [`HttpContext`]
+    #[inline]
     pub(crate) fn new(
         request: HttpRequest,
         handler: RouteHandler, 
@@ -34,6 +35,7 @@ impl HttpContext {
         Self { request, handler, error_handler }
     }
 
+    #[inline]
     #[allow(dead_code)]
     pub(super) fn into_parts(self) -> (HttpRequest, RouteHandler, WeakErrorHandler) {
         (self.request, self.handler, self.error_handler)
@@ -63,10 +65,18 @@ impl HttpContext {
     }
 
     /// Resolves a service from Dependency Container
+    #[inline]
     #[cfg(feature = "di")]
     pub async fn resolve<T: Inject + 'static>(&mut self) -> Result<T, Error> {
         self.request.resolve::<T>().await
     }
+
+    /// Resolves a service from Dependency Container and returns a reference
+    #[inline]
+    #[cfg(feature = "di")]
+    pub async fn resolve_ref<T: Inject + 'static>(&mut self) -> Result<&T, Error> {
+        self.request.resolve_ref::<T>().await
+    }
 
     /// Inserts the [`Header<T>`] to HTTP request headers
     #[inline]
@@ -75,6 +85,7 @@ impl HttpContext {
     }
 
     /// Executes the request handler for current HTTP request
+    #[inline]
     pub(crate) async fn execute(self) -> HttpResult {
         self.handler.call(self.request).await
     }