diff --git a/CHANGELOG.md b/CHANGELOG.md
index 299b915a5..e18c26a4f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -19,6 +19,7 @@ Recommendation: for ease of reading, use the following order:
 - Private Datasets, `DatasetEntry` integration that will allow us to build dataset indexing
   - Extend `DatasetLifecycleMessageCreated` with `dataset_name` field
   - Introducing `DatasetLifecycleMessageRenamed`
+- Simplified error handling code in repositories
 
 ## [0.204.4] - 2024-09-30
 ### Changed
diff --git a/src/domain/accounts/domain/src/repos/access_token_repository.rs b/src/domain/accounts/domain/src/repos/access_token_repository.rs
index 935615205..40e295bd9 100644
--- a/src/domain/accounts/domain/src/repos/access_token_repository.rs
+++ b/src/domain/accounts/domain/src/repos/access_token_repository.rs
@@ -56,10 +56,10 @@ pub trait AccessTokenRepository: Send + Sync {
 #[derive(Error, Debug)]
 pub enum CreateAccessTokenError {
     #[error(transparent)]
-    Internal(InternalError),
+    Duplicate(CreateAccessTokenErrorDuplicate),
 
     #[error(transparent)]
-    Duplicate(CreateAccessTokenErrorDuplicate),
+    Internal(#[from] InternalError),
 }
 
 #[derive(Error, Debug)]
@@ -76,7 +76,7 @@ pub enum GetAccessTokenError {
     NotFound(AccessTokenNotFoundError),
 
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
 
 #[derive(Error, Debug)]
@@ -96,7 +96,7 @@ pub enum FindAccountByTokenError {
     NotFound(AccessTokenNotFoundError),
 
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -110,5 +110,7 @@ pub enum RevokeTokenError {
     NotFound(AccessTokenNotFoundError),
 
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/domain/accounts/domain/src/repos/account_repository.rs b/src/domain/accounts/domain/src/repos/account_repository.rs
index c1033f719..5e43f3d66 100644
--- a/src/domain/accounts/domain/src/repos/account_repository.rs
+++ b/src/domain/accounts/domain/src/repos/account_repository.rs
@@ -57,10 +57,10 @@ pub trait AccountRepository: Send + Sync {
 #[derive(Error, Debug)]
 pub enum CreateAccountError {
     #[error(transparent)]
-    Internal(InternalError),
+    Duplicate(CreateAccountErrorDuplicate),
 
     #[error(transparent)]
-    Duplicate(CreateAccountErrorDuplicate),
+    Internal(#[from] InternalError),
 }
 
 #[derive(Error, Debug)]
@@ -100,7 +100,7 @@ pub enum GetAccountByIdError {
     NotFound(AccountNotFoundByIdError),
 
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
 
 #[derive(Error, Debug)]
@@ -117,7 +117,7 @@ pub enum GetAccountByNameError {
     NotFound(AccountNotFoundByNameError),
 
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
 
 #[derive(Error, Debug)]
@@ -131,7 +131,7 @@ pub struct AccountNotFoundByNameError {
 #[derive(Error, Debug)]
 pub enum FindAccountIdByProviderIdentityKeyError {
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -139,7 +139,7 @@ pub enum FindAccountIdByProviderIdentityKeyError {
 #[derive(Error, Debug)]
 pub enum FindAccountIdByEmailError {
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -147,7 +147,7 @@ pub enum FindAccountIdByEmailError {
 #[derive(Error, Debug)]
 pub enum FindAccountIdByNameError {
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/domain/accounts/domain/src/repos/password_hash_repository.rs b/src/domain/accounts/domain/src/repos/password_hash_repository.rs
index cfdeb7b91..2bea73829 100644
--- a/src/domain/accounts/domain/src/repos/password_hash_repository.rs
+++ b/src/domain/accounts/domain/src/repos/password_hash_repository.rs
@@ -32,7 +32,7 @@ pub trait PasswordHashRepository: Send + Sync {
 #[derive(Error, Debug)]
 pub enum SavePasswordHashError {
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -40,7 +40,7 @@ pub enum SavePasswordHashError {
 #[derive(Error, Debug)]
 pub enum FindPasswordHashError {
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/domain/auth-rebac/domain/src/repos/rebac_repository.rs b/src/domain/auth-rebac/domain/src/repos/rebac_repository.rs
index 99546a768..b03484657 100644
--- a/src/domain/auth-rebac/domain/src/repos/rebac_repository.rs
+++ b/src/domain/auth-rebac/domain/src/repos/rebac_repository.rs
@@ -82,7 +82,7 @@ pub trait RebacRepository: Send + Sync {
 #[derive(Error, Debug)]
 pub enum SetEntityPropertyError {
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -93,7 +93,7 @@ pub enum DeleteEntityPropertyError {
     NotFound(EntityPropertyNotFoundError),
 
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
 
 impl DeleteEntityPropertyError {
@@ -126,7 +126,7 @@ pub enum DeleteEntityPropertiesError {
     NotFound(EntityNotFoundError),
 
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
 
 impl DeleteEntityPropertiesError {
@@ -142,7 +142,7 @@ impl DeleteEntityPropertiesError {
 #[derive(Error, Debug)]
 pub enum GetEntityPropertiesError {
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -153,7 +153,7 @@ pub enum InsertEntitiesRelationError {
     Duplicate(InsertEntitiesRelationDuplicateError),
 
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
 
 impl InsertEntitiesRelationError {
@@ -189,7 +189,7 @@ pub enum DeleteEntitiesRelationError {
     NotFound(EntitiesRelationNotFoundError),
 
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
 
 impl DeleteEntitiesRelationError {
@@ -222,7 +222,7 @@ pub struct EntitiesRelationNotFoundError {
 #[derive(Error, Debug)]
 pub enum SubjectEntityRelationsError {
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -230,7 +230,7 @@ pub enum SubjectEntityRelationsError {
 #[derive(Error, Debug)]
 pub enum SubjectEntityRelationsByObjectTypeError {
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -238,7 +238,7 @@ pub enum SubjectEntityRelationsByObjectTypeError {
 #[derive(Error, Debug)]
 pub enum GetRelationsBetweenEntitiesError {
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/domain/datasets/domain/src/repos/dataset_entry_repository.rs b/src/domain/datasets/domain/src/repos/dataset_entry_repository.rs
index 97d1b431b..68a29933a 100644
--- a/src/domain/datasets/domain/src/repos/dataset_entry_repository.rs
+++ b/src/domain/datasets/domain/src/repos/dataset_entry_repository.rs
@@ -60,7 +60,7 @@ pub enum GetDatasetEntryError {
     NotFound(#[from] DatasetEntryNotFoundError),
 
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
 
 #[derive(Error, Debug)]
@@ -83,7 +83,7 @@ pub enum GetDatasetEntryByNameError {
     NotFound(#[from] DatasetEntryByNameNotFoundError),
 
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
 
 #[derive(Error, Debug)]
@@ -107,7 +107,7 @@ impl DatasetEntryByNameNotFoundError {
 #[derive(Error, Debug)]
 pub enum GetDatasetEntriesByOwnerIdError {
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -121,7 +121,7 @@ pub enum SaveDatasetEntryError {
     NameCollision(#[from] DatasetEntryNameCollisionError),
 
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
 
 #[derive(Error, Debug)]
@@ -147,7 +147,7 @@ pub enum UpdateDatasetEntryNameError {
     NameCollision(#[from] DatasetEntryNameCollisionError),
 
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
 
 #[derive(Error, Debug)]
@@ -170,7 +170,7 @@ pub enum DeleteEntryDatasetError {
     NotFound(#[from] DatasetEntryNotFoundError),
 
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/domain/datasets/domain/src/repos/dataset_env_var_repository.rs b/src/domain/datasets/domain/src/repos/dataset_env_var_repository.rs
index e2274b2c3..775e1bf1d 100644
--- a/src/domain/datasets/domain/src/repos/dataset_env_var_repository.rs
+++ b/src/domain/datasets/domain/src/repos/dataset_env_var_repository.rs
@@ -64,10 +64,10 @@ pub trait DatasetEnvVarRepository: Send + Sync {
 #[derive(Error, Debug)]
 pub enum SaveDatasetEnvVarError {
     #[error(transparent)]
-    Internal(InternalError),
+    Duplicate(SaveDatasetEnvVarErrorDuplicate),
 
     #[error(transparent)]
-    Duplicate(SaveDatasetEnvVarErrorDuplicate),
+    Internal(#[from] InternalError),
 }
 
 #[derive(Error, Debug)]
@@ -85,7 +85,7 @@ pub enum GetDatasetEnvVarError {
     NotFound(DatasetEnvVarNotFoundError),
 
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
 
 #[derive(Error, Debug)]
@@ -102,7 +102,7 @@ pub enum DeleteDatasetEnvVarError {
     NotFound(DatasetEnvVarNotFoundError),
 
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -113,5 +113,7 @@ pub enum ModifyDatasetEnvVarError {
     NotFound(DatasetEnvVarNotFoundError),
 
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/infra/accounts/mysql/src/repos/mysql_access_token_repository.rs b/src/infra/accounts/mysql/src/repos/mysql_access_token_repository.rs
index 4a9fa00e4..101a97467 100644
--- a/src/infra/accounts/mysql/src/repos/mysql_access_token_repository.rs
+++ b/src/infra/accounts/mysql/src/repos/mysql_access_token_repository.rs
@@ -68,10 +68,7 @@ impl AccessTokenRepository for MySqlAccessTokenRepository {
     ) -> Result<(), CreateAccessTokenError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(CreateAccessTokenError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         sqlx::query!(
             r#"
@@ -101,10 +98,7 @@ impl AccessTokenRepository for MySqlAccessTokenRepository {
     async fn get_token_by_id(&self, token_id: &Uuid) -> Result<AccessToken, GetAccessTokenError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetAccessTokenError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let maybe_access_token = self
             .query_token_by_id(token_id, connection_mut)
@@ -126,10 +120,7 @@ impl AccessTokenRepository for MySqlAccessTokenRepository {
     ) -> Result<usize, GetAccessTokenError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetAccessTokenError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let access_token_count = sqlx::query_scalar!(
             r#"
@@ -142,7 +133,7 @@ impl AccessTokenRepository for MySqlAccessTokenRepository {
         )
         .fetch_one(connection_mut)
         .await
-        .map_int_err(GetAccessTokenError::Internal)?;
+        .int_err()?;
 
         Ok(usize::try_from(access_token_count).unwrap_or(0))
     }
@@ -154,10 +145,7 @@ impl AccessTokenRepository for MySqlAccessTokenRepository {
     ) -> Result<Vec<AccessToken>, GetAccessTokenError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetAccessTokenError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let access_token_rows = sqlx::query_as!(
             AccessTokenRowModel,
@@ -179,7 +167,7 @@ impl AccessTokenRepository for MySqlAccessTokenRepository {
         )
         .fetch_all(connection_mut)
         .await
-        .map_int_err(GetAccessTokenError::Internal)?;
+        .int_err()?;
 
         Ok(access_token_rows.into_iter().map(Into::into).collect())
     }
@@ -191,10 +179,7 @@ impl AccessTokenRepository for MySqlAccessTokenRepository {
     ) -> Result<(), RevokeTokenError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(RevokeTokenError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let maybe_existing_token = self
             .query_token_by_id(token_id, connection_mut)
@@ -220,7 +205,7 @@ impl AccessTokenRepository for MySqlAccessTokenRepository {
         )
         .execute(&mut *connection_mut)
         .await
-        .map_int_err(RevokeTokenError::Internal)?;
+        .int_err()?;
 
         Ok(())
     }
@@ -232,10 +217,7 @@ impl AccessTokenRepository for MySqlAccessTokenRepository {
     ) -> Result<Account, FindAccountByTokenError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(FindAccountByTokenError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let maybe_account_row = sqlx::query_as!(
             AccountWithTokenRowModel,
@@ -260,7 +242,7 @@ impl AccessTokenRepository for MySqlAccessTokenRepository {
         )
         .fetch_optional(connection_mut)
         .await
-        .map_int_err(FindAccountByTokenError::Internal)?;
+        .int_err()?;
 
         if let Some(account_row) = maybe_account_row {
             if token_hash != account_row.token_hash.as_slice() {
diff --git a/src/infra/accounts/mysql/src/repos/mysql_account_repository.rs b/src/infra/accounts/mysql/src/repos/mysql_account_repository.rs
index 1da0a61d0..45f0dfd44 100644
--- a/src/infra/accounts/mysql/src/repos/mysql_account_repository.rs
+++ b/src/infra/accounts/mysql/src/repos/mysql_account_repository.rs
@@ -37,10 +37,7 @@ impl AccountRepository for MySqlAccountRepository {
     async fn create_account(&self, account: &Account) -> Result<(), CreateAccountError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(CreateAccountError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         sqlx::query!(
             r#"
@@ -101,10 +98,7 @@ impl AccountRepository for MySqlAccountRepository {
     ) -> Result<Account, GetAccountByIdError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetAccountByIdError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let maybe_account_row = sqlx::query_as!(
             AccountRowModel,
@@ -127,8 +121,7 @@ impl AccountRepository for MySqlAccountRepository {
         )
         .fetch_optional(connection_mut)
         .await
-        .int_err()
-        .map_err(GetAccountByIdError::Internal)?;
+        .int_err()?;
 
         if let Some(account_row) = maybe_account_row {
             Ok(account_row.into())
@@ -145,10 +138,7 @@ impl AccountRepository for MySqlAccountRepository {
     ) -> Result<Vec<Account>, GetAccountByIdError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetAccountByIdError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let placeholders = account_ids.iter().map(|_| "?").collect::<Vec<_>>();
         let placeholders_str = if placeholders.is_empty() {
@@ -183,11 +173,7 @@ impl AccountRepository for MySqlAccountRepository {
             query = query.bind(account_id.to_string());
         }
 
-        let account_rows = query
-            .fetch_all(connection_mut)
-            .await
-            .int_err()
-            .map_err(GetAccountByIdError::Internal)?;
+        let account_rows = query.fetch_all(connection_mut).await.int_err()?;
 
         Ok(account_rows
             .into_iter()
@@ -214,10 +200,7 @@ impl AccountRepository for MySqlAccountRepository {
     ) -> Result<Account, GetAccountByNameError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetAccountByNameError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let maybe_account_row = sqlx::query_as!(
             AccountRowModel,
@@ -240,8 +223,7 @@ impl AccountRepository for MySqlAccountRepository {
         )
         .fetch_optional(connection_mut)
         .await
-        .int_err()
-        .map_err(GetAccountByNameError::Internal)?;
+        .int_err()?;
 
         if let Some(account_row) = maybe_account_row {
             Ok(account_row.into())
@@ -260,10 +242,7 @@ impl AccountRepository for MySqlAccountRepository {
     ) -> Result<Option<AccountID>, FindAccountIdByProviderIdentityKeyError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(FindAccountIdByProviderIdentityKeyError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let maybe_account_row = sqlx::query!(
             r#"
@@ -275,8 +254,7 @@ impl AccountRepository for MySqlAccountRepository {
         )
         .fetch_optional(connection_mut)
         .await
-        .int_err()
-        .map_err(FindAccountIdByProviderIdentityKeyError::Internal)?;
+        .int_err()?;
 
         Ok(maybe_account_row.map(|account_row| account_row.id))
     }
@@ -287,10 +265,7 @@ impl AccountRepository for MySqlAccountRepository {
     ) -> Result<Option<AccountID>, FindAccountIdByEmailError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(FindAccountIdByEmailError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let maybe_account_row = sqlx::query!(
             r#"
@@ -302,8 +277,7 @@ impl AccountRepository for MySqlAccountRepository {
         )
         .fetch_optional(connection_mut)
         .await
-        .int_err()
-        .map_err(FindAccountIdByEmailError::Internal)?;
+        .int_err()?;
 
         Ok(maybe_account_row.map(|account_row| account_row.id))
     }
@@ -314,10 +288,7 @@ impl AccountRepository for MySqlAccountRepository {
     ) -> Result<Option<AccountID>, FindAccountIdByNameError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(FindAccountIdByNameError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let maybe_account_row = sqlx::query!(
             r#"
@@ -329,8 +300,7 @@ impl AccountRepository for MySqlAccountRepository {
         )
         .fetch_optional(connection_mut)
         .await
-        .int_err()
-        .map_err(FindAccountIdByNameError::Internal)?;
+        .int_err()?;
 
         Ok(maybe_account_row.map(|account_row| account_row.id))
     }
@@ -347,10 +317,7 @@ impl PasswordHashRepository for MySqlAccountRepository {
     ) -> Result<(), SavePasswordHashError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(SavePasswordHashError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         // TODO: duplicates are prevented with unique indices, but handle error
 
@@ -376,10 +343,7 @@ impl PasswordHashRepository for MySqlAccountRepository {
     ) -> Result<Option<String>, FindPasswordHashError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(FindPasswordHashError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let maybe_password_row = sqlx::query!(
             r#"
@@ -391,8 +355,7 @@ impl PasswordHashRepository for MySqlAccountRepository {
         )
         .fetch_optional(connection_mut)
         .await
-        .int_err()
-        .map_err(FindPasswordHashError::Internal)?;
+        .int_err()?;
 
         Ok(maybe_password_row.map(|password_row| password_row.password_hash))
     }
diff --git a/src/infra/accounts/postgres/src/repos/postgres_access_token_repository.rs b/src/infra/accounts/postgres/src/repos/postgres_access_token_repository.rs
index 88985d6cf..354db1e86 100644
--- a/src/infra/accounts/postgres/src/repos/postgres_access_token_repository.rs
+++ b/src/infra/accounts/postgres/src/repos/postgres_access_token_repository.rs
@@ -70,10 +70,7 @@ impl AccessTokenRepository for PostgresAccessTokenRepository {
     ) -> Result<(), CreateAccessTokenError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(CreateAccessTokenError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         sqlx::query!(
             r#"
@@ -103,15 +100,9 @@ impl AccessTokenRepository for PostgresAccessTokenRepository {
     async fn get_token_by_id(&self, token_id: &Uuid) -> Result<AccessToken, GetAccessTokenError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetAccessTokenError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
-        let maybe_access_token = self
-            .query_token_by_id(token_id, connection_mut)
-            .await
-            .map_err(GetAccessTokenError::Internal)?;
+        let maybe_access_token = self.query_token_by_id(token_id, connection_mut).await?;
 
         if let Some(access_token) = maybe_access_token {
             Ok(access_token)
@@ -128,10 +119,7 @@ impl AccessTokenRepository for PostgresAccessTokenRepository {
     ) -> Result<usize, GetAccessTokenError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetAccessTokenError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let access_token_count = sqlx::query_scalar!(
             r#"
@@ -144,7 +132,7 @@ impl AccessTokenRepository for PostgresAccessTokenRepository {
         )
         .fetch_one(connection_mut)
         .await
-        .map_int_err(GetAccessTokenError::Internal)?;
+        .int_err()?;
 
         Ok(usize::try_from(access_token_count.unwrap_or(0)).unwrap())
     }
@@ -156,10 +144,7 @@ impl AccessTokenRepository for PostgresAccessTokenRepository {
     ) -> Result<Vec<AccessToken>, GetAccessTokenError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetAccessTokenError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let access_token_rows = sqlx::query_as!(
             AccessTokenRowModel,
@@ -181,7 +166,7 @@ impl AccessTokenRepository for PostgresAccessTokenRepository {
         )
         .fetch_all(connection_mut)
         .await
-        .map_int_err(GetAccessTokenError::Internal)?;
+        .int_err()?;
 
         Ok(access_token_rows.into_iter().map(Into::into).collect())
     }
@@ -193,15 +178,9 @@ impl AccessTokenRepository for PostgresAccessTokenRepository {
     ) -> Result<(), RevokeTokenError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(RevokeTokenError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
-        let maybe_existing_token = self
-            .query_token_by_id(token_id, connection_mut)
-            .await
-            .map_err(RevokeTokenError::Internal)?;
+        let maybe_existing_token = self.query_token_by_id(token_id, connection_mut).await?;
 
         if maybe_existing_token.is_none() {
             return Err(RevokeTokenError::NotFound(AccessTokenNotFoundError {
@@ -222,7 +201,7 @@ impl AccessTokenRepository for PostgresAccessTokenRepository {
         )
         .execute(&mut *connection_mut)
         .await
-        .map_int_err(RevokeTokenError::Internal)?;
+        .int_err()?;
 
         Ok(())
     }
@@ -234,10 +213,7 @@ impl AccessTokenRepository for PostgresAccessTokenRepository {
     ) -> Result<Account, FindAccountByTokenError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(FindAccountByTokenError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let maybe_account_row = sqlx::query_as!(
             AccountWithTokenRowModel,
@@ -262,7 +238,7 @@ impl AccessTokenRepository for PostgresAccessTokenRepository {
         )
         .fetch_optional(connection_mut)
         .await
-        .map_int_err(FindAccountByTokenError::Internal)?;
+        .int_err()?;
 
         if let Some(account_row) = maybe_account_row {
             if token_hash != account_row.token_hash.as_slice() {
diff --git a/src/infra/accounts/postgres/src/repos/postgres_account_repository.rs b/src/infra/accounts/postgres/src/repos/postgres_account_repository.rs
index ba37cb65c..d1d090863 100644
--- a/src/infra/accounts/postgres/src/repos/postgres_account_repository.rs
+++ b/src/infra/accounts/postgres/src/repos/postgres_account_repository.rs
@@ -36,10 +36,7 @@ impl AccountRepository for PostgresAccountRepository {
     async fn create_account(&self, account: &Account) -> Result<(), CreateAccountError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(CreateAccountError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         sqlx::query!(
             r#"
@@ -95,10 +92,7 @@ impl AccountRepository for PostgresAccountRepository {
     ) -> Result<Account, GetAccountByIdError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetAccountByIdError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let maybe_account_row = sqlx::query_as!(
             AccountRowModel,
@@ -121,8 +115,7 @@ impl AccountRepository for PostgresAccountRepository {
         )
         .fetch_optional(connection_mut)
         .await
-        .int_err()
-        .map_err(GetAccountByIdError::Internal)?;
+        .int_err()?;
 
         if let Some(account_row) = maybe_account_row {
             Ok(account_row.into())
@@ -139,10 +132,7 @@ impl AccountRepository for PostgresAccountRepository {
     ) -> Result<Vec<Account>, GetAccountByIdError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetAccountByIdError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let accounts_search: Vec<_> = account_ids
             .iter()
@@ -170,8 +160,7 @@ impl AccountRepository for PostgresAccountRepository {
         )
         .fetch_all(connection_mut)
         .await
-        .int_err()
-        .map_err(GetAccountByIdError::Internal)?;
+        .int_err()?;
 
         Ok(account_rows.into_iter().map(Into::into).collect())
     }
@@ -182,10 +171,7 @@ impl AccountRepository for PostgresAccountRepository {
     ) -> Result<Account, GetAccountByNameError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetAccountByNameError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let maybe_account_row = sqlx::query_as!(
             AccountRowModel,
@@ -208,8 +194,7 @@ impl AccountRepository for PostgresAccountRepository {
         )
         .fetch_optional(connection_mut)
         .await
-        .int_err()
-        .map_err(GetAccountByNameError::Internal)?;
+        .int_err()?;
 
         if let Some(account_row) = maybe_account_row {
             Ok(account_row.into())
@@ -228,10 +213,7 @@ impl AccountRepository for PostgresAccountRepository {
     ) -> Result<Option<AccountID>, FindAccountIdByProviderIdentityKeyError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(FindAccountIdByProviderIdentityKeyError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let maybe_account_row = sqlx::query!(
             r#"
@@ -243,8 +225,7 @@ impl AccountRepository for PostgresAccountRepository {
         )
         .fetch_optional(connection_mut)
         .await
-        .int_err()
-        .map_err(FindAccountIdByProviderIdentityKeyError::Internal)?;
+        .int_err()?;
 
         Ok(maybe_account_row.map(|account_row| account_row.id))
     }
@@ -255,10 +236,7 @@ impl AccountRepository for PostgresAccountRepository {
     ) -> Result<Option<AccountID>, FindAccountIdByEmailError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(FindAccountIdByEmailError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let maybe_account_row = sqlx::query!(
             r#"
@@ -270,8 +248,7 @@ impl AccountRepository for PostgresAccountRepository {
         )
         .fetch_optional(connection_mut)
         .await
-        .int_err()
-        .map_err(FindAccountIdByEmailError::Internal)?;
+        .int_err()?;
 
         Ok(maybe_account_row.map(|account_row| account_row.id))
     }
@@ -282,10 +259,7 @@ impl AccountRepository for PostgresAccountRepository {
     ) -> Result<Option<AccountID>, FindAccountIdByNameError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(FindAccountIdByNameError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let maybe_account_row = sqlx::query!(
             r#"
@@ -297,8 +271,7 @@ impl AccountRepository for PostgresAccountRepository {
         )
         .fetch_optional(connection_mut)
         .await
-        .int_err()
-        .map_err(FindAccountIdByNameError::Internal)?;
+        .int_err()?;
 
         Ok(maybe_account_row.map(|account_row| account_row.id))
     }
@@ -315,10 +288,7 @@ impl PasswordHashRepository for PostgresAccountRepository {
     ) -> Result<(), SavePasswordHashError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(SavePasswordHashError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         sqlx::query!(
             r#"
@@ -330,8 +300,7 @@ impl PasswordHashRepository for PostgresAccountRepository {
         )
         .execute(connection_mut)
         .await
-        .int_err()
-        .map_err(SavePasswordHashError::Internal)?;
+        .int_err()?;
 
         Ok(())
     }
@@ -342,10 +311,7 @@ impl PasswordHashRepository for PostgresAccountRepository {
     ) -> Result<Option<String>, FindPasswordHashError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(FindPasswordHashError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let maybe_password_row = sqlx::query!(
             r#"
@@ -357,8 +323,7 @@ impl PasswordHashRepository for PostgresAccountRepository {
         )
         .fetch_optional(connection_mut)
         .await
-        .int_err()
-        .map_err(FindPasswordHashError::Internal)?;
+        .int_err()?;
 
         Ok(maybe_password_row.map(|password_row| password_row.password_hash))
     }
diff --git a/src/infra/accounts/sqlite/src/repos/sqlite_access_token_repository.rs b/src/infra/accounts/sqlite/src/repos/sqlite_access_token_repository.rs
index 34a926d1f..c037fe18c 100644
--- a/src/infra/accounts/sqlite/src/repos/sqlite_access_token_repository.rs
+++ b/src/infra/accounts/sqlite/src/repos/sqlite_access_token_repository.rs
@@ -70,10 +70,7 @@ impl AccessTokenRepository for SqliteAccessTokenRepository {
     ) -> Result<(), CreateAccessTokenError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(CreateAccessTokenError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let token_id = access_token.id;
         let token_name = access_token.token_name.clone();
@@ -113,15 +110,9 @@ impl AccessTokenRepository for SqliteAccessTokenRepository {
     async fn get_token_by_id(&self, token_id: &Uuid) -> Result<AccessToken, GetAccessTokenError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetAccessTokenError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
-        let maybe_access_token = self
-            .query_token_by_id(token_id, connection_mut)
-            .await
-            .map_err(GetAccessTokenError::Internal)?;
+        let maybe_access_token = self.query_token_by_id(token_id, connection_mut).await?;
 
         if let Some(access_token) = maybe_access_token {
             Ok(access_token)
@@ -138,10 +129,8 @@ impl AccessTokenRepository for SqliteAccessTokenRepository {
     ) -> Result<usize, GetAccessTokenError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetAccessTokenError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
+
         let account_id_string = account_id.to_string();
 
         let access_token_count = sqlx::query_scalar!(
@@ -155,8 +144,7 @@ impl AccessTokenRepository for SqliteAccessTokenRepository {
         )
         .fetch_one(connection_mut)
         .await
-        .int_err()
-        .map_err(GetAccessTokenError::Internal)?;
+        .int_err()?;
 
         Ok(usize::try_from(access_token_count).unwrap_or(0))
     }
@@ -168,10 +156,8 @@ impl AccessTokenRepository for SqliteAccessTokenRepository {
     ) -> Result<Vec<AccessToken>, GetAccessTokenError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetAccessTokenError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
+
         let limit = i64::try_from(pagination.limit).unwrap();
         let offset = i64::try_from(pagination.offset).unwrap();
         let account_id_string = account_id.to_string();
@@ -196,8 +182,7 @@ impl AccessTokenRepository for SqliteAccessTokenRepository {
         )
         .fetch_all(connection_mut)
         .await
-        .int_err()
-        .map_err(GetAccessTokenError::Internal)?;
+        .int_err()?;
 
         Ok(access_token_rows.into_iter().map(Into::into).collect())
     }
@@ -209,15 +194,9 @@ impl AccessTokenRepository for SqliteAccessTokenRepository {
     ) -> Result<(), RevokeTokenError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(RevokeTokenError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
-        let maybe_existing_token = self
-            .query_token_by_id(token_id, connection_mut)
-            .await
-            .map_err(RevokeTokenError::Internal)?;
+        let maybe_existing_token = self.query_token_by_id(token_id, connection_mut).await?;
 
         if maybe_existing_token.is_none() {
             return Err(RevokeTokenError::NotFound(AccessTokenNotFoundError {
@@ -238,8 +217,7 @@ impl AccessTokenRepository for SqliteAccessTokenRepository {
         )
         .execute(&mut *connection_mut)
         .await
-        .int_err()
-        .map_err(RevokeTokenError::Internal)?;
+        .int_err()?;
 
         Ok(())
     }
@@ -251,10 +229,8 @@ impl AccessTokenRepository for SqliteAccessTokenRepository {
     ) -> Result<Account, FindAccountByTokenError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(FindAccountByTokenError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
+
         let token_id_search = *token_id;
 
         let maybe_account_row = sqlx::query_as!(
@@ -280,8 +256,7 @@ impl AccessTokenRepository for SqliteAccessTokenRepository {
         )
         .fetch_optional(connection_mut)
         .await
-        .int_err()
-        .map_err(FindAccountByTokenError::Internal)?;
+        .int_err()?;
 
         if let Some(account_row) = maybe_account_row {
             if token_hash != account_row.token_hash.as_slice() {
@@ -297,3 +272,5 @@ impl AccessTokenRepository for SqliteAccessTokenRepository {
         }
     }
 }
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/infra/auth-rebac/postgres/src/repos/postgres_rebac_repository.rs b/src/infra/auth-rebac/postgres/src/repos/postgres_rebac_repository.rs
index 9e7a41d3f..3e14ecc5a 100644
--- a/src/infra/auth-rebac/postgres/src/repos/postgres_rebac_repository.rs
+++ b/src/infra/auth-rebac/postgres/src/repos/postgres_rebac_repository.rs
@@ -40,10 +40,7 @@ impl RebacRepository for PostgresRebacRepository {
     ) -> Result<(), SetEntityPropertyError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(SetEntityPropertyError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         sqlx::query!(
             r#"
@@ -58,7 +55,7 @@ impl RebacRepository for PostgresRebacRepository {
         )
         .execute(connection_mut)
         .await
-        .map_int_err(SetEntityPropertyError::Internal)?;
+        .int_err()?;
 
         Ok(())
     }
@@ -70,10 +67,7 @@ impl RebacRepository for PostgresRebacRepository {
     ) -> Result<(), DeleteEntityPropertyError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(DeleteEntityPropertyError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let delete_result = sqlx::query!(
             r#"
@@ -89,7 +83,7 @@ impl RebacRepository for PostgresRebacRepository {
         )
         .execute(&mut *connection_mut)
         .await
-        .map_int_err(DeleteEntityPropertyError::Internal)?;
+        .int_err()?;
 
         if delete_result.rows_affected() == 0 {
             return Err(DeleteEntityPropertyError::not_found(entity, property_name));
@@ -104,10 +98,7 @@ impl RebacRepository for PostgresRebacRepository {
     ) -> Result<(), DeleteEntityPropertiesError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(DeleteEntityPropertiesError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let delete_result = sqlx::query!(
             r#"
@@ -121,7 +112,7 @@ impl RebacRepository for PostgresRebacRepository {
         )
         .execute(&mut *connection_mut)
         .await
-        .map_int_err(DeleteEntityPropertiesError::Internal)?;
+        .int_err()?;
 
         if delete_result.rows_affected() == 0 {
             return Err(DeleteEntityPropertiesError::not_found(entity));
@@ -136,10 +127,7 @@ impl RebacRepository for PostgresRebacRepository {
     ) -> Result<Vec<(PropertyName, PropertyValue)>, GetEntityPropertiesError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetEntityPropertiesError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let row_models = sqlx::query_as!(
             PropertyRowModel,
@@ -154,7 +142,7 @@ impl RebacRepository for PostgresRebacRepository {
         )
         .fetch_all(connection_mut)
         .await
-        .map_int_err(GetEntityPropertiesError::Internal)?;
+        .int_err()?;
 
         row_models
             .into_iter()
@@ -171,10 +159,7 @@ impl RebacRepository for PostgresRebacRepository {
     ) -> Result<(), InsertEntitiesRelationError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(InsertEntitiesRelationError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         sqlx::query!(
             r#"
@@ -213,10 +198,7 @@ impl RebacRepository for PostgresRebacRepository {
     ) -> Result<(), DeleteEntitiesRelationError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(DeleteEntitiesRelationError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let delete_result = sqlx::query!(
             r#"
@@ -236,7 +218,7 @@ impl RebacRepository for PostgresRebacRepository {
         )
         .execute(&mut *connection_mut)
         .await
-        .map_int_err(DeleteEntitiesRelationError::Internal)?;
+        .int_err()?;
 
         if delete_result.rows_affected() == 0 {
             return Err(DeleteEntitiesRelationError::not_found(
@@ -255,10 +237,7 @@ impl RebacRepository for PostgresRebacRepository {
     ) -> Result<Vec<EntityWithRelation>, SubjectEntityRelationsError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(SubjectEntityRelationsError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let row_models = sqlx::query_as!(
             EntityWithRelationRowModel,
@@ -275,7 +254,7 @@ impl RebacRepository for PostgresRebacRepository {
         )
         .fetch_all(connection_mut)
         .await
-        .map_int_err(SubjectEntityRelationsError::Internal)?;
+        .int_err()?;
 
         row_models
             .into_iter()
@@ -313,7 +292,7 @@ impl RebacRepository for PostgresRebacRepository {
         )
         .fetch_all(connection_mut)
         .await
-        .map_int_err(SubjectEntityRelationsByObjectTypeError::Internal)?;
+        .int_err()?;
 
         row_models
             .into_iter()
@@ -351,7 +330,7 @@ impl RebacRepository for PostgresRebacRepository {
         )
         .fetch_all(connection_mut)
         .await
-        .map_int_err(GetRelationsBetweenEntitiesError::Internal)?;
+        .int_err()?;
 
         row_models
             .into_iter()
diff --git a/src/infra/auth-rebac/sqlite/src/repos/sqlite_rebac_repository.rs b/src/infra/auth-rebac/sqlite/src/repos/sqlite_rebac_repository.rs
index c91ab8dcd..f5674edce 100644
--- a/src/infra/auth-rebac/sqlite/src/repos/sqlite_rebac_repository.rs
+++ b/src/infra/auth-rebac/sqlite/src/repos/sqlite_rebac_repository.rs
@@ -40,10 +40,7 @@ impl RebacRepository for SqliteRebacRepository {
     ) -> Result<(), SetEntityPropertyError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(SetEntityPropertyError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let entity_id_as_str = entity.entity_id.as_ref();
         let property_name_as_str = property_name.to_string();
@@ -62,7 +59,7 @@ impl RebacRepository for SqliteRebacRepository {
         )
         .execute(connection_mut)
         .await
-        .map_int_err(SetEntityPropertyError::Internal)?;
+        .int_err()?;
 
         Ok(())
     }
@@ -74,10 +71,7 @@ impl RebacRepository for SqliteRebacRepository {
     ) -> Result<(), DeleteEntityPropertyError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(DeleteEntityPropertyError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let entity_id_as_str = entity.entity_id.as_ref();
         let property_name_as_str = property_name.to_string();
@@ -96,7 +90,7 @@ impl RebacRepository for SqliteRebacRepository {
         )
         .execute(&mut *connection_mut)
         .await
-        .map_int_err(DeleteEntityPropertyError::Internal)?;
+        .int_err()?;
 
         if delete_result.rows_affected() == 0 {
             return Err(DeleteEntityPropertyError::not_found(entity, property_name));
@@ -111,10 +105,7 @@ impl RebacRepository for SqliteRebacRepository {
     ) -> Result<(), DeleteEntityPropertiesError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(DeleteEntityPropertiesError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let entity_id_as_str = entity.entity_id.as_ref();
 
@@ -130,7 +121,7 @@ impl RebacRepository for SqliteRebacRepository {
         )
         .execute(&mut *connection_mut)
         .await
-        .map_int_err(DeleteEntityPropertiesError::Internal)?;
+        .int_err()?;
 
         if delete_result.rows_affected() == 0 {
             return Err(DeleteEntityPropertiesError::not_found(entity));
@@ -145,10 +136,7 @@ impl RebacRepository for SqliteRebacRepository {
     ) -> Result<Vec<(PropertyName, PropertyValue)>, GetEntityPropertiesError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetEntityPropertiesError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let entity_id_as_str = entity.entity_id.as_ref();
 
@@ -165,7 +153,7 @@ impl RebacRepository for SqliteRebacRepository {
         )
         .fetch_all(connection_mut)
         .await
-        .map_int_err(GetEntityPropertiesError::Internal)?;
+        .int_err()?;
 
         row_models
             .into_iter()
@@ -182,10 +170,7 @@ impl RebacRepository for SqliteRebacRepository {
     ) -> Result<(), InsertEntitiesRelationError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(InsertEntitiesRelationError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let subject_entity_id_as_str = subject_entity.entity_id.as_ref();
         let relation_as_str = relationship.to_string();
@@ -227,10 +212,7 @@ impl RebacRepository for SqliteRebacRepository {
     ) -> Result<(), DeleteEntitiesRelationError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(DeleteEntitiesRelationError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let subject_entity_id_as_str = subject_entity.entity_id.as_ref();
         let relation_as_str = relationship.to_string();
@@ -254,7 +236,7 @@ impl RebacRepository for SqliteRebacRepository {
         )
         .execute(&mut *connection_mut)
         .await
-        .map_int_err(DeleteEntitiesRelationError::Internal)?;
+        .int_err()?;
 
         if delete_result.rows_affected() == 0 {
             return Err(DeleteEntitiesRelationError::not_found(
@@ -273,10 +255,7 @@ impl RebacRepository for SqliteRebacRepository {
     ) -> Result<Vec<EntityWithRelation>, SubjectEntityRelationsError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(SubjectEntityRelationsError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let subject_entity_id_as_str = subject_entity.entity_id.as_ref();
 
@@ -295,7 +274,7 @@ impl RebacRepository for SqliteRebacRepository {
         )
         .fetch_all(connection_mut)
         .await
-        .map_int_err(SubjectEntityRelationsError::Internal)?;
+        .int_err()?;
 
         row_models
             .into_iter()
@@ -311,10 +290,7 @@ impl RebacRepository for SqliteRebacRepository {
     ) -> Result<Vec<EntityWithRelation>, SubjectEntityRelationsByObjectTypeError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(SubjectEntityRelationsByObjectTypeError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let subject_entity_id_as_str = subject_entity.entity_id.as_ref();
 
@@ -335,7 +311,7 @@ impl RebacRepository for SqliteRebacRepository {
         )
         .fetch_all(connection_mut)
         .await
-        .map_int_err(SubjectEntityRelationsByObjectTypeError::Internal)?;
+        .int_err()?;
 
         row_models
             .into_iter()
@@ -351,10 +327,7 @@ impl RebacRepository for SqliteRebacRepository {
     ) -> Result<Vec<Relation>, GetRelationsBetweenEntitiesError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetRelationsBetweenEntitiesError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let subject_entity_id_as_str = subject_entity.entity_id.as_ref();
         let object_entity_id_as_str = object_entity.entity_id.as_ref();
@@ -376,7 +349,7 @@ impl RebacRepository for SqliteRebacRepository {
         )
         .fetch_all(connection_mut)
         .await
-        .map_int_err(GetRelationsBetweenEntitiesError::Internal)?;
+        .int_err()?;
 
         row_models
             .into_iter()
diff --git a/src/infra/datasets/postgres/src/repos/postgres_dataset_entry_repository.rs b/src/infra/datasets/postgres/src/repos/postgres_dataset_entry_repository.rs
index f46172e76..fa9a76a6f 100644
--- a/src/infra/datasets/postgres/src/repos/postgres_dataset_entry_repository.rs
+++ b/src/infra/datasets/postgres/src/repos/postgres_dataset_entry_repository.rs
@@ -36,10 +36,7 @@ impl DatasetEntryRepository for PostgresDatasetEntryRepository {
     async fn dataset_entries_count(&self) -> Result<usize, GetDatasetEntryError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetDatasetEntryError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let dataset_entries_count = sqlx::query_scalar!(
             r#"
@@ -49,7 +46,7 @@ impl DatasetEntryRepository for PostgresDatasetEntryRepository {
         )
         .fetch_one(connection_mut)
         .await
-        .map_int_err(GetDatasetEntryError::Internal)?;
+        .int_err()?;
 
         Ok(usize::try_from(dataset_entries_count.unwrap_or(0)).unwrap())
     }
@@ -60,10 +57,7 @@ impl DatasetEntryRepository for PostgresDatasetEntryRepository {
     ) -> Result<DatasetEntry, GetDatasetEntryError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetDatasetEntryError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let stack_dataset_id = dataset_id.as_did_str().to_stack_string();
 
@@ -81,7 +75,7 @@ impl DatasetEntryRepository for PostgresDatasetEntryRepository {
         )
         .fetch_optional(connection_mut)
         .await
-        .map_int_err(GetDatasetEntryError::Internal)?;
+        .int_err()?;
 
         if let Some(dataset_entry_row) = maybe_dataset_entry_row {
             Ok(dataset_entry_row.into())
@@ -97,10 +91,7 @@ impl DatasetEntryRepository for PostgresDatasetEntryRepository {
     ) -> Result<DatasetEntry, GetDatasetEntryByNameError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetDatasetEntryByNameError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let stack_owner_id = owner_id.as_did_str().to_stack_string();
 
@@ -120,7 +111,7 @@ impl DatasetEntryRepository for PostgresDatasetEntryRepository {
         )
         .fetch_optional(connection_mut)
         .await
-        .map_int_err(GetDatasetEntryByNameError::Internal)?;
+        .int_err()?;
 
         if let Some(dataset_entry_row) = maybe_dataset_entry_row {
             Ok(dataset_entry_row.into())
@@ -135,10 +126,7 @@ impl DatasetEntryRepository for PostgresDatasetEntryRepository {
     ) -> Result<Vec<DatasetEntry>, GetDatasetEntriesByOwnerIdError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetDatasetEntriesByOwnerIdError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let stack_owner_id = owner_id.as_did_str().to_stack_string();
 
@@ -156,7 +144,7 @@ impl DatasetEntryRepository for PostgresDatasetEntryRepository {
         )
         .fetch_all(connection_mut)
         .await
-        .map_int_err(GetDatasetEntriesByOwnerIdError::Internal)?;
+        .int_err()?;
 
         Ok(dataset_entry_rows.into_iter().map(Into::into).collect())
     }
@@ -167,10 +155,7 @@ impl DatasetEntryRepository for PostgresDatasetEntryRepository {
     ) -> Result<(), SaveDatasetEntryError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(SaveDatasetEntryError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let stack_dataset_id = dataset_entry.id.as_did_str().to_stack_string();
         let stack_owner_id = dataset_entry.owner_id.as_did_str().to_stack_string();
@@ -209,10 +194,7 @@ impl DatasetEntryRepository for PostgresDatasetEntryRepository {
     ) -> Result<(), UpdateDatasetEntryNameError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(UpdateDatasetEntryNameError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let stack_dataset_id = dataset_id.as_did_str().to_stack_string();
 
@@ -247,10 +229,7 @@ impl DatasetEntryRepository for PostgresDatasetEntryRepository {
     ) -> Result<(), DeleteEntryDatasetError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(DeleteEntryDatasetError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let stack_dataset_id = dataset_id.as_did_str().to_stack_string();
 
@@ -262,7 +241,7 @@ impl DatasetEntryRepository for PostgresDatasetEntryRepository {
         )
         .execute(&mut *connection_mut)
         .await
-        .map_int_err(DeleteEntryDatasetError::Internal)?;
+        .int_err()?;
 
         if delete_result.rows_affected() == 0 {
             return Err(DatasetEntryNotFoundError::new(dataset_id.clone()).into());
diff --git a/src/infra/datasets/postgres/src/repos/postgres_dataset_env_var_repository.rs b/src/infra/datasets/postgres/src/repos/postgres_dataset_env_var_repository.rs
index e93e9de4c..4650146ce 100644
--- a/src/infra/datasets/postgres/src/repos/postgres_dataset_env_var_repository.rs
+++ b/src/infra/datasets/postgres/src/repos/postgres_dataset_env_var_repository.rs
@@ -39,10 +39,7 @@ impl DatasetEnvVarRepository for PostgresDatasetEnvVarRepository {
     ) -> Result<(), SaveDatasetEnvVarError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(SaveDatasetEnvVarError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         sqlx::query!(
             r#"
@@ -82,10 +79,7 @@ impl DatasetEnvVarRepository for PostgresDatasetEnvVarRepository {
     ) -> Result<Vec<DatasetEnvVar>, GetDatasetEnvVarError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetDatasetEnvVarError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let dataset_env_var_rows = sqlx::query_as!(
             DatasetEnvVarRowModel,
@@ -107,8 +101,7 @@ impl DatasetEnvVarRepository for PostgresDatasetEnvVarRepository {
         )
         .fetch_all(connection_mut)
         .await
-        .int_err()
-        .map_err(GetDatasetEnvVarError::Internal)?;
+        .int_err()?;
 
         Ok(dataset_env_var_rows.into_iter().map(Into::into).collect())
     }
@@ -119,10 +112,7 @@ impl DatasetEnvVarRepository for PostgresDatasetEnvVarRepository {
     ) -> Result<usize, GetDatasetEnvVarError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetDatasetEnvVarError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let dataset_env_vars_count = sqlx::query_scalar!(
             r#"
@@ -135,8 +125,7 @@ impl DatasetEnvVarRepository for PostgresDatasetEnvVarRepository {
         )
         .fetch_one(connection_mut)
         .await
-        .int_err()
-        .map_err(GetDatasetEnvVarError::Internal)?;
+        .int_err()?;
 
         Ok(usize::try_from(dataset_env_vars_count.unwrap_or(0)).unwrap())
     }
@@ -148,10 +137,7 @@ impl DatasetEnvVarRepository for PostgresDatasetEnvVarRepository {
     ) -> Result<DatasetEnvVar, GetDatasetEnvVarError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetDatasetEnvVarError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let dataset_env_var_row_maybe = sqlx::query_as!(
             DatasetEnvVarRowModel,
@@ -172,8 +158,7 @@ impl DatasetEnvVarRepository for PostgresDatasetEnvVarRepository {
         )
         .fetch_optional(connection_mut)
         .await
-        .int_err()
-        .map_err(GetDatasetEnvVarError::Internal)?;
+        .int_err()?;
 
         if let Some(dataset_env_var_row) = dataset_env_var_row_maybe {
             return Ok(dataset_env_var_row.into());
@@ -191,10 +176,7 @@ impl DatasetEnvVarRepository for PostgresDatasetEnvVarRepository {
     ) -> Result<DatasetEnvVar, GetDatasetEnvVarError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetDatasetEnvVarError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let dataset_env_var_row_maybe = sqlx::query_as!(
             DatasetEnvVarRowModel,
@@ -213,8 +195,7 @@ impl DatasetEnvVarRepository for PostgresDatasetEnvVarRepository {
         )
         .fetch_optional(connection_mut)
         .await
-        .int_err()
-        .map_err(GetDatasetEnvVarError::Internal)?;
+        .int_err()?;
 
         if let Some(dataset_env_var_row) = dataset_env_var_row_maybe {
             return Ok(dataset_env_var_row.into());
@@ -232,10 +213,7 @@ impl DatasetEnvVarRepository for PostgresDatasetEnvVarRepository {
     ) -> Result<(), DeleteDatasetEnvVarError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(DeleteDatasetEnvVarError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let delete_result = sqlx::query!(
             r#"
@@ -245,8 +223,7 @@ impl DatasetEnvVarRepository for PostgresDatasetEnvVarRepository {
         )
         .execute(&mut *connection_mut)
         .await
-        .int_err()
-        .map_err(DeleteDatasetEnvVarError::Internal)?;
+        .int_err()?;
 
         if delete_result.rows_affected() == 0 {
             return Err(DeleteDatasetEnvVarError::NotFound(
@@ -266,10 +243,7 @@ impl DatasetEnvVarRepository for PostgresDatasetEnvVarRepository {
     ) -> Result<(), ModifyDatasetEnvVarError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(ModifyDatasetEnvVarError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let update_result = sqlx::query!(
             r#"
@@ -281,8 +255,7 @@ impl DatasetEnvVarRepository for PostgresDatasetEnvVarRepository {
         )
         .execute(&mut *connection_mut)
         .await
-        .int_err()
-        .map_err(ModifyDatasetEnvVarError::Internal)?;
+        .int_err()?;
 
         if update_result.rows_affected() == 0 {
             return Err(ModifyDatasetEnvVarError::NotFound(
@@ -294,3 +267,5 @@ impl DatasetEnvVarRepository for PostgresDatasetEnvVarRepository {
         Ok(())
     }
 }
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/infra/datasets/sqlite/src/repos/sqlite_dataset_env_var_repository.rs b/src/infra/datasets/sqlite/src/repos/sqlite_dataset_env_var_repository.rs
index 04eb00830..229d0b938 100644
--- a/src/infra/datasets/sqlite/src/repos/sqlite_dataset_env_var_repository.rs
+++ b/src/infra/datasets/sqlite/src/repos/sqlite_dataset_env_var_repository.rs
@@ -39,10 +39,8 @@ impl DatasetEnvVarRepository for SqliteDatasetEnvVarRepository {
     ) -> Result<(), SaveDatasetEnvVarError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(SaveDatasetEnvVarError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
+
         let dataset_env_var_id = dataset_env_var.id;
         let dataset_env_var_key = &dataset_env_var.key;
         let dataset_env_var_value = &dataset_env_var.value;
@@ -88,10 +86,8 @@ impl DatasetEnvVarRepository for SqliteDatasetEnvVarRepository {
     ) -> Result<Vec<DatasetEnvVar>, GetDatasetEnvVarError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetDatasetEnvVarError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
+
         let limit = i64::try_from(pagination.limit).unwrap();
         let offset = i64::try_from(pagination.offset).unwrap();
         let dataset_id_string = dataset_id.to_string();
@@ -116,8 +112,7 @@ impl DatasetEnvVarRepository for SqliteDatasetEnvVarRepository {
         )
         .fetch_all(connection_mut)
         .await
-        .int_err()
-        .map_err(GetDatasetEnvVarError::Internal)?;
+        .int_err()?;
 
         Ok(dataset_env_var_rows.into_iter().map(Into::into).collect())
     }
@@ -128,10 +123,8 @@ impl DatasetEnvVarRepository for SqliteDatasetEnvVarRepository {
     ) -> Result<usize, GetDatasetEnvVarError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetDatasetEnvVarError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
+
         let dataset_id_string = dataset_id.to_string();
 
         let dataset_env_vars_count = sqlx::query_scalar!(
@@ -145,8 +138,7 @@ impl DatasetEnvVarRepository for SqliteDatasetEnvVarRepository {
         )
         .fetch_one(connection_mut)
         .await
-        .int_err()
-        .map_err(GetDatasetEnvVarError::Internal)?;
+        .int_err()?;
 
         Ok(usize::try_from(dataset_env_vars_count).unwrap_or(0))
     }
@@ -157,10 +149,8 @@ impl DatasetEnvVarRepository for SqliteDatasetEnvVarRepository {
     ) -> Result<DatasetEnvVar, GetDatasetEnvVarError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetDatasetEnvVarError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
+
         let dataset_env_var_id_search = dataset_env_var_id;
 
         let dataset_env_var_row_maybe = sqlx::query_as!(
@@ -180,8 +170,7 @@ impl DatasetEnvVarRepository for SqliteDatasetEnvVarRepository {
         )
         .fetch_optional(connection_mut)
         .await
-        .int_err()
-        .map_err(GetDatasetEnvVarError::Internal)?;
+        .int_err()?;
 
         if let Some(dataset_env_var_row) = dataset_env_var_row_maybe {
             return Ok(dataset_env_var_row.into());
@@ -200,10 +189,8 @@ impl DatasetEnvVarRepository for SqliteDatasetEnvVarRepository {
     ) -> Result<DatasetEnvVar, GetDatasetEnvVarError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetDatasetEnvVarError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
+
         let dataset_id_string = dataset_id.to_string();
 
         let dataset_env_var_row_maybe = sqlx::query_as!(
@@ -225,8 +212,7 @@ impl DatasetEnvVarRepository for SqliteDatasetEnvVarRepository {
         )
         .fetch_optional(connection_mut)
         .await
-        .int_err()
-        .map_err(GetDatasetEnvVarError::Internal)?;
+        .int_err()?;
 
         if let Some(dataset_env_var_row) = dataset_env_var_row_maybe {
             return Ok(dataset_env_var_row.into());
@@ -244,10 +230,7 @@ impl DatasetEnvVarRepository for SqliteDatasetEnvVarRepository {
     ) -> Result<(), DeleteDatasetEnvVarError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(DeleteDatasetEnvVarError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let delete_result = sqlx::query!(
             r#"
@@ -257,8 +240,7 @@ impl DatasetEnvVarRepository for SqliteDatasetEnvVarRepository {
         )
         .execute(&mut *connection_mut)
         .await
-        .int_err()
-        .map_err(DeleteDatasetEnvVarError::Internal)?;
+        .int_err()?;
 
         if delete_result.rows_affected() == 0 {
             return Err(DeleteDatasetEnvVarError::NotFound(
@@ -278,10 +260,7 @@ impl DatasetEnvVarRepository for SqliteDatasetEnvVarRepository {
     ) -> Result<(), ModifyDatasetEnvVarError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(ModifyDatasetEnvVarError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let update_result = sqlx::query!(
             r#"
@@ -293,8 +272,7 @@ impl DatasetEnvVarRepository for SqliteDatasetEnvVarRepository {
         )
         .execute(&mut *connection_mut)
         .await
-        .int_err()
-        .map_err(ModifyDatasetEnvVarError::Internal)?;
+        .int_err()?;
 
         if update_result.rows_affected() == 0 {
             return Err(ModifyDatasetEnvVarError::NotFound(
@@ -306,3 +284,5 @@ impl DatasetEnvVarRepository for SqliteDatasetEnvVarRepository {
         Ok(())
     }
 }
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/infra/datasets/sqlite/src/repos/sqlite_dateset_entry_repository.rs b/src/infra/datasets/sqlite/src/repos/sqlite_dateset_entry_repository.rs
index 8e3968cdb..f81f56890 100644
--- a/src/infra/datasets/sqlite/src/repos/sqlite_dateset_entry_repository.rs
+++ b/src/infra/datasets/sqlite/src/repos/sqlite_dateset_entry_repository.rs
@@ -36,10 +36,7 @@ impl DatasetEntryRepository for SqliteDatasetEntryRepository {
     async fn dataset_entries_count(&self) -> Result<usize, GetDatasetEntryError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetDatasetEntryError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let dataset_entries_count = sqlx::query_scalar!(
             r#"
@@ -49,7 +46,7 @@ impl DatasetEntryRepository for SqliteDatasetEntryRepository {
         )
         .fetch_one(connection_mut)
         .await
-        .map_int_err(GetDatasetEntryError::Internal)?;
+        .int_err()?;
 
         Ok(usize::try_from(dataset_entries_count).unwrap_or(0))
     }
@@ -60,10 +57,7 @@ impl DatasetEntryRepository for SqliteDatasetEntryRepository {
     ) -> Result<DatasetEntry, GetDatasetEntryError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetDatasetEntryError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let stack_dataset_id = dataset_id.as_did_str().to_stack_string();
         let dataset_id_as_str = stack_dataset_id.as_str();
@@ -82,7 +76,7 @@ impl DatasetEntryRepository for SqliteDatasetEntryRepository {
         )
         .fetch_optional(connection_mut)
         .await
-        .map_int_err(GetDatasetEntryError::Internal)?;
+        .int_err()?;
 
         if let Some(dataset_entry_row) = maybe_dataset_entry_row {
             Ok(dataset_entry_row.into())
@@ -98,10 +92,7 @@ impl DatasetEntryRepository for SqliteDatasetEntryRepository {
     ) -> Result<DatasetEntry, GetDatasetEntryByNameError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetDatasetEntryByNameError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let stack_owner_id = owner_id.as_did_str().to_stack_string();
         let owner_id_as_str = stack_owner_id.as_str();
@@ -123,7 +114,7 @@ impl DatasetEntryRepository for SqliteDatasetEntryRepository {
         )
         .fetch_optional(connection_mut)
         .await
-        .map_int_err(GetDatasetEntryByNameError::Internal)?;
+        .int_err()?;
 
         if let Some(dataset_entry_row) = maybe_dataset_entry_row {
             Ok(dataset_entry_row.into())
@@ -138,10 +129,7 @@ impl DatasetEntryRepository for SqliteDatasetEntryRepository {
     ) -> Result<Vec<DatasetEntry>, GetDatasetEntriesByOwnerIdError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(GetDatasetEntriesByOwnerIdError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let stack_owner_id = owner_id.as_did_str().to_stack_string();
         let owner_id_as_str = stack_owner_id.as_str();
@@ -160,7 +148,7 @@ impl DatasetEntryRepository for SqliteDatasetEntryRepository {
         )
         .fetch_all(connection_mut)
         .await
-        .map_int_err(GetDatasetEntriesByOwnerIdError::Internal)?;
+        .int_err()?;
 
         Ok(dataset_entry_rows.into_iter().map(Into::into).collect())
     }
@@ -171,10 +159,7 @@ impl DatasetEntryRepository for SqliteDatasetEntryRepository {
     ) -> Result<(), SaveDatasetEntryError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(SaveDatasetEntryError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let stack_dataset_id = dataset_entry.id.as_did_str().to_stack_string();
         let dataset_id_as_str = stack_dataset_id.as_str();
@@ -217,10 +202,7 @@ impl DatasetEntryRepository for SqliteDatasetEntryRepository {
     ) -> Result<(), UpdateDatasetEntryNameError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(UpdateDatasetEntryNameError::Internal)?;
+        let connection_mut = tr.connection_mut().await?;
 
         let stack_dataset_id = dataset_id.as_did_str().to_stack_string();
         let dataset_id_as_str = stack_dataset_id.as_str();
@@ -274,7 +256,7 @@ impl DatasetEntryRepository for SqliteDatasetEntryRepository {
         )
         .execute(&mut *connection_mut)
         .await
-        .map_int_err(DeleteEntryDatasetError::Internal)?;
+        .int_err()?;
 
         if delete_result.rows_affected() == 0 {
             return Err(DatasetEntryNotFoundError::new(dataset_id.clone()).into());
diff --git a/src/infra/messaging-outbox/postgres/src/repos/outbox_postgres_message_consumption_repository.rs b/src/infra/messaging-outbox/postgres/src/repos/outbox_postgres_message_consumption_repository.rs
index faff35ed3..7ba01d287 100644
--- a/src/infra/messaging-outbox/postgres/src/repos/outbox_postgres_message_consumption_repository.rs
+++ b/src/infra/messaging-outbox/postgres/src/repos/outbox_postgres_message_consumption_repository.rs
@@ -9,7 +9,7 @@
 
 use database_common::{TransactionRef, TransactionRefT};
 use dill::{component, interface};
-use internal_error::{ErrorIntoInternal, InternalError};
+use internal_error::{ErrorIntoInternal, InternalError, ResultIntoInternal};
 
 use crate::domain::*;
 
@@ -87,10 +87,7 @@ impl OutboxMessageConsumptionRepository for PostgresOutboxMessageConsumptionRepo
     ) -> Result<(), CreateConsumptionBoundaryError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(|e| CreateConsumptionBoundaryError::Internal(e.int_err()))?;
+        let connection_mut = tr.connection_mut().await?;
 
         sqlx::query!(
             r#"
@@ -127,10 +124,7 @@ impl OutboxMessageConsumptionRepository for PostgresOutboxMessageConsumptionRepo
     ) -> Result<(), UpdateConsumptionBoundaryError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(|e| UpdateConsumptionBoundaryError::Internal(e.int_err()))?;
+        let connection_mut = tr.connection_mut().await?;
 
         let res = sqlx::query!(
             r#"
@@ -143,7 +137,7 @@ impl OutboxMessageConsumptionRepository for PostgresOutboxMessageConsumptionRepo
         )
         .execute(connection_mut)
         .await
-        .map_err(|e| UpdateConsumptionBoundaryError::Internal(e.int_err()))?;
+        .int_err()?;
 
         if res.rows_affected() != 1 {
             Err(UpdateConsumptionBoundaryError::ConsumptionBoundaryNotFound(
diff --git a/src/infra/messaging-outbox/postgres/src/repos/outbox_postgres_message_repository.rs b/src/infra/messaging-outbox/postgres/src/repos/outbox_postgres_message_repository.rs
index 01fd288fa..963f2a277 100644
--- a/src/infra/messaging-outbox/postgres/src/repos/outbox_postgres_message_repository.rs
+++ b/src/infra/messaging-outbox/postgres/src/repos/outbox_postgres_message_repository.rs
@@ -36,7 +36,7 @@ impl OutboxMessageRepository for PostgresOutboxMessageRepository {
     async fn push_message(&self, message: NewOutboxMessage) -> Result<(), InternalError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr.connection_mut().await.int_err()?;
+        let connection_mut = tr.connection_mut().await?;
 
         sqlx::query!(
             r#"
diff --git a/src/infra/messaging-outbox/sqlite/src/repos/sqlite_outbox_message_consumption_repository.rs b/src/infra/messaging-outbox/sqlite/src/repos/sqlite_outbox_message_consumption_repository.rs
index 74324ff4e..acff3a757 100644
--- a/src/infra/messaging-outbox/sqlite/src/repos/sqlite_outbox_message_consumption_repository.rs
+++ b/src/infra/messaging-outbox/sqlite/src/repos/sqlite_outbox_message_consumption_repository.rs
@@ -9,7 +9,7 @@
 
 use database_common::{TransactionRef, TransactionRefT};
 use dill::{component, interface};
-use internal_error::{ErrorIntoInternal, InternalError};
+use internal_error::{ErrorIntoInternal, InternalError, ResultIntoInternal};
 
 use crate::domain::*;
 
@@ -87,10 +87,7 @@ impl OutboxMessageConsumptionRepository for SqliteOutboxMessageConsumptionReposi
     ) -> Result<(), CreateConsumptionBoundaryError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(|e| CreateConsumptionBoundaryError::Internal(e.int_err()))?;
+        let connection_mut = tr.connection_mut().await?;
 
         let last_consumed_message_id = boundary.last_consumed_message_id.into_inner();
 
@@ -129,10 +126,7 @@ impl OutboxMessageConsumptionRepository for SqliteOutboxMessageConsumptionReposi
     ) -> Result<(), UpdateConsumptionBoundaryError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr
-            .connection_mut()
-            .await
-            .map_err(|e| UpdateConsumptionBoundaryError::Internal(e.int_err()))?;
+        let connection_mut = tr.connection_mut().await?;
 
         let last_consumed_message_id = boundary.last_consumed_message_id.into_inner();
 
@@ -147,7 +141,7 @@ impl OutboxMessageConsumptionRepository for SqliteOutboxMessageConsumptionReposi
         )
         .execute(connection_mut)
         .await
-        .map_err(|e| UpdateConsumptionBoundaryError::Internal(e.int_err()))?;
+        .int_err()?;
 
         if res.rows_affected() != 1 {
             Err(UpdateConsumptionBoundaryError::ConsumptionBoundaryNotFound(
diff --git a/src/infra/messaging-outbox/sqlite/src/repos/sqlite_outbox_message_repository.rs b/src/infra/messaging-outbox/sqlite/src/repos/sqlite_outbox_message_repository.rs
index b365967e3..260d0d8ed 100644
--- a/src/infra/messaging-outbox/sqlite/src/repos/sqlite_outbox_message_repository.rs
+++ b/src/infra/messaging-outbox/sqlite/src/repos/sqlite_outbox_message_repository.rs
@@ -36,7 +36,7 @@ impl OutboxMessageRepository for SqliteOutboxMessageRepository {
     async fn push_message(&self, message: NewOutboxMessage) -> Result<(), InternalError> {
         let mut tr = self.transaction.lock().await;
 
-        let connection_mut = tr.connection_mut().await.int_err()?;
+        let connection_mut = tr.connection_mut().await?;
 
         let message_content_json = message.content_json;
 
diff --git a/src/utils/messaging-outbox/src/repos/outbox_message_consumption_repository.rs b/src/utils/messaging-outbox/src/repos/outbox_message_consumption_repository.rs
index dabea3e39..63a263160 100644
--- a/src/utils/messaging-outbox/src/repos/outbox_message_consumption_repository.rs
+++ b/src/utils/messaging-outbox/src/repos/outbox_message_consumption_repository.rs
@@ -52,7 +52,7 @@ pub enum CreateConsumptionBoundaryError {
     DuplicateConsumptionBoundary(DuplicateConsumptionBoundaryError),
 
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
 
 #[derive(Error, Debug)]
@@ -73,7 +73,7 @@ pub enum UpdateConsumptionBoundaryError {
     ConsumptionBoundaryNotFound(ConsumptionBoundaryNotFoundError),
 
     #[error(transparent)]
-    Internal(InternalError),
+    Internal(#[from] InternalError),
 }
 
 #[derive(Error, Debug)]