From f0e15963b74f3ddcfd6249aa1e76895824d7fdef Mon Sep 17 00:00:00 2001
From: Chris Martinez <sydefekt@hotmail.com>
Date: Sun, 24 Dec 2023 11:06:00 -0800
Subject: [PATCH] Retain generic state parameter

---
 src/Cargo.toml      |  2 +-
 src/inject.rs       | 48 +++++++++++++++++++++++++++++++++------------
 src/inject_keyed.rs | 48 +++++++++++++++++++++++++++++++++------------
 3 files changed, 73 insertions(+), 25 deletions(-)

diff --git a/src/Cargo.toml b/src/Cargo.toml
index d90d99c..6318842 100644
--- a/src/Cargo.toml
+++ b/src/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "more-di-axum"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 authors = ["Chris Martinez <chris.s.martinez@hotmail.com>"]
 description = "Provides support dependency injection (DI) for Axum"
diff --git a/src/inject.rs b/src/inject.rs
index d92f5bf..1879029 100644
--- a/src/inject.rs
+++ b/src/inject.rs
@@ -37,10 +37,14 @@ fn unregistered_type<T: ?Sized>() -> String {
 }
 
 #[async_trait]
-impl<T: ?Sized + 'static> FromRequestParts<()> for TryInject<T> {
+impl<T, S> FromRequestParts<S> for TryInject<T>
+where
+    T: ?Sized + 'static,
+    S: Send + Sync,
+{
     type Rejection = Infallible;
 
-    async fn from_request_parts(parts: &mut Parts, _state: &()) -> Result<Self, Self::Rejection> {
+    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
         if let Some(provider) = parts.extensions.get::<ServiceProvider>() {
             Ok(Self(provider.get::<T>()))
         } else {
@@ -50,10 +54,14 @@ impl<T: ?Sized + 'static> FromRequestParts<()> for TryInject<T> {
 }
 
 #[async_trait]
-impl<T: ?Sized + 'static> FromRequestParts<()> for Inject<T> {
+impl<T, S> FromRequestParts<S> for Inject<T>
+where
+    T: ?Sized + 'static,
+    S: Send + Sync,
+{
     type Rejection = (StatusCode, String);
 
-    async fn from_request_parts(parts: &mut Parts, _state: &()) -> Result<Self, Self::Rejection> {
+    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
         if let Some(provider) = parts.extensions.get::<ServiceProvider>() {
             if let Some(service) = provider.get::<T>() {
                 return Ok(Self(service));
@@ -65,10 +73,14 @@ impl<T: ?Sized + 'static> FromRequestParts<()> for Inject<T> {
 }
 
 #[async_trait]
-impl<T: ?Sized + 'static> FromRequestParts<()> for TryInjectMut<T> {
+impl<T, S> FromRequestParts<S> for TryInjectMut<T>
+where
+    T: ?Sized + 'static,
+    S: Send + Sync,
+{
     type Rejection = Infallible;
 
-    async fn from_request_parts(parts: &mut Parts, _state: &()) -> Result<Self, Self::Rejection> {
+    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
         if let Some(provider) = parts.extensions.get::<ServiceProvider>() {
             Ok(Self(provider.get_mut::<T>()))
         } else {
@@ -78,10 +90,14 @@ impl<T: ?Sized + 'static> FromRequestParts<()> for TryInjectMut<T> {
 }
 
 #[async_trait]
-impl<T: ?Sized + 'static> FromRequestParts<()> for InjectMut<T> {
+impl<T, S> FromRequestParts<S> for InjectMut<T>
+where
+    T: ?Sized + 'static,
+    S: Send + Sync,
+{
     type Rejection = (StatusCode, String);
 
-    async fn from_request_parts(parts: &mut Parts, _state: &()) -> Result<Self, Self::Rejection> {
+    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
         if let Some(provider) = parts.extensions.get::<ServiceProvider>() {
             if let Some(service) = provider.get_mut::<T>() {
                 return Ok(Self(service));
@@ -93,10 +109,14 @@ impl<T: ?Sized + 'static> FromRequestParts<()> for InjectMut<T> {
 }
 
 #[async_trait]
-impl<T: ?Sized + 'static> FromRequestParts<()> for InjectAll<T> {
+impl<T, S> FromRequestParts<S> for InjectAll<T>
+where
+    T: ?Sized + 'static,
+    S: Send + Sync,
+{
     type Rejection = Infallible;
 
-    async fn from_request_parts(parts: &mut Parts, _state: &()) -> Result<Self, Self::Rejection> {
+    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
         if let Some(provider) = parts.extensions.get::<ServiceProvider>() {
             Ok(Self(provider.get_all::<T>().collect()))
         } else {
@@ -106,10 +126,14 @@ impl<T: ?Sized + 'static> FromRequestParts<()> for InjectAll<T> {
 }
 
 #[async_trait]
-impl<T: ?Sized + 'static> FromRequestParts<()> for InjectAllMut<T> {
+impl<T, S> FromRequestParts<S> for InjectAllMut<T>
+where
+    T: ?Sized + 'static,
+    S: Send + Sync,
+{
     type Rejection = Infallible;
 
-    async fn from_request_parts(parts: &mut Parts, _state: &()) -> Result<Self, Self::Rejection> {
+    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
         if let Some(provider) = parts.extensions.get::<ServiceProvider>() {
             Ok(Self(provider.get_all_mut::<T>().collect()))
         } else {
diff --git a/src/inject_keyed.rs b/src/inject_keyed.rs
index 214e23a..2401a31 100644
--- a/src/inject_keyed.rs
+++ b/src/inject_keyed.rs
@@ -38,10 +38,14 @@ fn unregistered_type_with_key<TKey, TSvc: ?Sized>() -> String {
 }
 
 #[async_trait]
-impl<TKey, TSvc: ?Sized + 'static> FromRequestParts<()> for TryInjectWithKey<TKey, TSvc> {
+impl<TKey, TSvc, S> FromRequestParts<S> for TryInjectWithKey<TKey, TSvc>
+where
+    TSvc: ?Sized + 'static,
+    S: Send + Sync,
+{
     type Rejection = Infallible;
 
-    async fn from_request_parts(parts: &mut Parts, _state: &()) -> Result<Self, Self::Rejection> {
+    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
         if let Some(provider) = parts.extensions.get::<ServiceProvider>() {
             Ok(Self(provider.get_by_key::<TKey, TSvc>()))
         } else {
@@ -51,10 +55,14 @@ impl<TKey, TSvc: ?Sized + 'static> FromRequestParts<()> for TryInjectWithKey<TKe
 }
 
 #[async_trait]
-impl<TKey, TSvc: ?Sized + 'static> FromRequestParts<()> for InjectWithKey<TKey, TSvc> {
+impl<TKey, TSvc, S> FromRequestParts<S> for InjectWithKey<TKey, TSvc>
+where
+    TSvc: ?Sized + 'static,
+    S: Send + Sync,
+{
     type Rejection = (StatusCode, String);
 
-    async fn from_request_parts(parts: &mut Parts, _state: &()) -> Result<Self, Self::Rejection> {
+    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
         if let Some(provider) = parts.extensions.get::<ServiceProvider>() {
             if let Some(service) = provider.get_by_key::<TKey, TSvc>() {
                 return Ok(Self(service));
@@ -69,10 +77,14 @@ impl<TKey, TSvc: ?Sized + 'static> FromRequestParts<()> for InjectWithKey<TKey,
 }
 
 #[async_trait]
-impl<TKey, TSvc: ?Sized + 'static> FromRequestParts<()> for TryInjectWithKeyMut<TKey, TSvc> {
+impl<TKey, TSvc, S> FromRequestParts<S> for TryInjectWithKeyMut<TKey, TSvc>
+where
+    TSvc: ?Sized + 'static,
+    S: Send + Sync,
+{
     type Rejection = Infallible;
 
-    async fn from_request_parts(parts: &mut Parts, _state: &()) -> Result<Self, Self::Rejection> {
+    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
         if let Some(provider) = parts.extensions.get::<ServiceProvider>() {
             Ok(Self(provider.get_by_key_mut::<TKey, TSvc>()))
         } else {
@@ -82,10 +94,14 @@ impl<TKey, TSvc: ?Sized + 'static> FromRequestParts<()> for TryInjectWithKeyMut<
 }
 
 #[async_trait]
-impl<TKey, TSvc: ?Sized + 'static> FromRequestParts<()> for InjectWithKeyMut<TKey, TSvc> {
+impl<TKey, TSvc, S> FromRequestParts<S> for InjectWithKeyMut<TKey, TSvc>
+where
+    TSvc: ?Sized + 'static,
+    S: Send + Sync,
+{
     type Rejection = (StatusCode, String);
 
-    async fn from_request_parts(parts: &mut Parts, _state: &()) -> Result<Self, Self::Rejection> {
+    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
         if let Some(provider) = parts.extensions.get::<ServiceProvider>() {
             if let Some(service) = provider.get_by_key_mut::<TKey, TSvc>() {
                 return Ok(Self(service));
@@ -100,10 +116,14 @@ impl<TKey, TSvc: ?Sized + 'static> FromRequestParts<()> for InjectWithKeyMut<TKe
 }
 
 #[async_trait]
-impl<TKey, TSvc: ?Sized + 'static> FromRequestParts<()> for InjectAllWithKey<TKey, TSvc> {
+impl<TKey, TSvc, S> FromRequestParts<S> for InjectAllWithKey<TKey, TSvc>
+where
+    TSvc: ?Sized + 'static,
+    S: Send + Sync,
+{
     type Rejection = Infallible;
 
-    async fn from_request_parts(parts: &mut Parts, _state: &()) -> Result<Self, Self::Rejection> {
+    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
         if let Some(provider) = parts.extensions.get::<ServiceProvider>() {
             Ok(Self(provider.get_all_by_key::<TKey, TSvc>().collect()))
         } else {
@@ -113,10 +133,14 @@ impl<TKey, TSvc: ?Sized + 'static> FromRequestParts<()> for InjectAllWithKey<TKe
 }
 
 #[async_trait]
-impl<TKey, TSvc: ?Sized + 'static> FromRequestParts<()> for InjectAllWithKeyMut<TKey, TSvc> {
+impl<TKey, TSvc, S> FromRequestParts<S> for InjectAllWithKeyMut<TKey, TSvc>
+where
+    TSvc: ?Sized + 'static,
+    S: Send + Sync,
+{
     type Rejection = Infallible;
 
-    async fn from_request_parts(parts: &mut Parts, _state: &()) -> Result<Self, Self::Rejection> {
+    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
         if let Some(provider) = parts.extensions.get::<ServiceProvider>() {
             Ok(Self(provider.get_all_by_key_mut::<TKey, TSvc>().collect()))
         } else {