Skip to content

Commit 182d86c

Browse files
raffomaniaraffomania
committed
change begin_with_config calls
1 parent 75e1520 commit 182d86c

File tree

12 files changed

+183
-245
lines changed

12 files changed

+183
-245
lines changed

‎src/database/connection.rs‎

Lines changed: 2 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -180,8 +180,7 @@ pub trait TransactionTrait {
180180
/// Returns a Transaction that can be committed or rolled back
181181
async fn begin_with_config(
182182
&self,
183-
isolation_level: Option<IsolationLevel>,
184-
access_mode: Option<AccessMode>,
183+
config: TransactionConfig,
185184
) -> Result<Self::Transaction, DbErr>;
186185

187186
/// Execute the function inside a transaction.
@@ -200,8 +199,7 @@ pub trait TransactionTrait {
200199
async fn transaction_with_config<F, T, E>(
201200
&self,
202201
callback: F,
203-
isolation_level: Option<IsolationLevel>,
204-
access_mode: Option<AccessMode>,
202+
config: TransactionConfig,
205203
) -> Result<T, TransactionError<E>>
206204
where
207205
F: for<'c> FnOnce(

‎src/database/db_connection.rs‎

Lines changed: 44 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -1,20 +1,19 @@
1-
use crate::{
2-
AccessMode, ConnectionTrait, DatabaseTransaction, ExecResult, IsolationLevel, QueryResult,
3-
Schema, SchemaBuilder, Statement, StatementBuilder, StreamTrait, TransactionError,
4-
TransactionTrait, error::*,
5-
};
1+
#[cfg(any(feature = "mock", feature = "proxy"))]
2+
use std::sync::Arc;
63
use std::{fmt::Debug, future::Future, pin::Pin};
7-
use tracing::instrument;
8-
use url::Url;
94

105
#[cfg(feature = "sqlx-dep")]
116
use sqlx::pool::PoolConnection;
7+
use tracing::instrument;
8+
use url::Url;
129

1310
#[cfg(feature = "rusqlite")]
1411
use crate::driver::rusqlite::{RusqliteInnerConnection, RusqliteSharedConnection};
15-
16-
#[cfg(any(feature = "mock", feature = "proxy"))]
17-
use std::sync::Arc;
12+
use crate::{
13+
ConnectionTrait, DatabaseTransaction, ExecResult, QueryResult, Schema, SchemaBuilder,
14+
Statement, StatementBuilder, StreamTrait, TransactionConfig, TransactionError,
15+
TransactionTrait, error::*,
16+
};
1817

1918
/// Handle a database connection depending on the backend enabled by the feature
2019
/// flags. This creates a connection pool internally (for SQLx connections),
@@ -351,15 +350,21 @@ impl TransactionTrait for DatabaseConnection {
351350
async fn begin(&self) -> Result<DatabaseTransaction, DbErr> {
352351
match &self.inner {
353352
#[cfg(feature = "sqlx-mysql")]
354-
DatabaseConnectionType::SqlxMySqlPoolConnection(conn) => conn.begin(None, None).await,
353+
DatabaseConnectionType::SqlxMySqlPoolConnection(conn) => {
354+
conn.begin(TransactionConfig::default()).await
355+
}
355356
#[cfg(feature = "sqlx-postgres")]
356357
DatabaseConnectionType::SqlxPostgresPoolConnection(conn) => {
357-
conn.begin(None, None).await
358+
conn.begin(TransactionConfig::default()).await
358359
}
359360
#[cfg(feature = "sqlx-sqlite")]
360-
DatabaseConnectionType::SqlxSqlitePoolConnection(conn) => conn.begin(None, None).await,
361+
DatabaseConnectionType::SqlxSqlitePoolConnection(conn) => {
362+
conn.begin(TransactionConfig::default()).await
363+
}
361364
#[cfg(feature = "rusqlite")]
362-
DatabaseConnectionType::RusqliteSharedConnection(conn) => conn.begin(None, None),
365+
DatabaseConnectionType::RusqliteSharedConnection(conn) => {
366+
conn.begin(TransactionConfig::default())
367+
}
363368
#[cfg(feature = "mock")]
364369
DatabaseConnectionType::MockDatabaseConnection(conn) => {
365370
DatabaseTransaction::new_mock(Arc::clone(conn), None).await
@@ -375,26 +380,17 @@ impl TransactionTrait for DatabaseConnection {
375380
#[instrument(level = "trace")]
376381
async fn begin_with_config(
377382
&self,
378-
_isolation_level: Option<IsolationLevel>,
379-
_access_mode: Option<AccessMode>,
383+
_config: TransactionConfig,
380384
) -> Result<DatabaseTransaction, DbErr> {
381385
match &self.inner {
382386
#[cfg(feature = "sqlx-mysql")]
383-
DatabaseConnectionType::SqlxMySqlPoolConnection(conn) => {
384-
conn.begin(_isolation_level, _access_mode).await
385-
}
387+
DatabaseConnectionType::SqlxMySqlPoolConnection(conn) => conn.begin(_config).await,
386388
#[cfg(feature = "sqlx-postgres")]
387-
DatabaseConnectionType::SqlxPostgresPoolConnection(conn) => {
388-
conn.begin(_isolation_level, _access_mode).await
389-
}
389+
DatabaseConnectionType::SqlxPostgresPoolConnection(conn) => conn.begin(_config).await,
390390
#[cfg(feature = "sqlx-sqlite")]
391-
DatabaseConnectionType::SqlxSqlitePoolConnection(conn) => {
392-
conn.begin(_isolation_level, _access_mode).await
393-
}
391+
DatabaseConnectionType::SqlxSqlitePoolConnection(conn) => conn.begin(_config).await,
394392
#[cfg(feature = "rusqlite")]
395-
DatabaseConnectionType::RusqliteSharedConnection(conn) => {
396-
conn.begin(_isolation_level, _access_mode)
397-
}
393+
DatabaseConnectionType::RusqliteSharedConnection(conn) => conn.begin(_config),
398394
#[cfg(feature = "mock")]
399395
DatabaseConnectionType::MockDatabaseConnection(conn) => {
400396
DatabaseTransaction::new_mock(Arc::clone(conn), None).await
@@ -408,7 +404,8 @@ impl TransactionTrait for DatabaseConnection {
408404
}
409405

410406
/// Execute the function inside a transaction.
411-
/// If the function returns an error, the transaction will be rolled back. If it does not return an error, the transaction will be committed.
407+
/// If the function returns an error, the transaction will be rolled back.
408+
/// If it does not return an error, the transaction will be committed.
412409
#[instrument(level = "trace", skip(_callback))]
413410
async fn transaction<F, T, E>(&self, _callback: F) -> Result<T, TransactionError<E>>
414411
where
@@ -422,19 +419,22 @@ impl TransactionTrait for DatabaseConnection {
422419
match &self.inner {
423420
#[cfg(feature = "sqlx-mysql")]
424421
DatabaseConnectionType::SqlxMySqlPoolConnection(conn) => {
425-
conn.transaction(_callback, None, None).await
422+
conn.transaction(_callback, TransactionConfig::default())
423+
.await
426424
}
427425
#[cfg(feature = "sqlx-postgres")]
428426
DatabaseConnectionType::SqlxPostgresPoolConnection(conn) => {
429-
conn.transaction(_callback, None, None).await
427+
conn.transaction(_callback, TransactionConfig::default())
428+
.await
430429
}
431430
#[cfg(feature = "sqlx-sqlite")]
432431
DatabaseConnectionType::SqlxSqlitePoolConnection(conn) => {
433-
conn.transaction(_callback, None, None).await
432+
conn.transaction(_callback, TransactionConfig::default())
433+
.await
434434
}
435435
#[cfg(feature = "rusqlite")]
436436
DatabaseConnectionType::RusqliteSharedConnection(conn) => {
437-
conn.transaction(_callback, None, None)
437+
conn.transaction(_callback, TransactionConfig::default())
438438
}
439439
#[cfg(feature = "mock")]
440440
DatabaseConnectionType::MockDatabaseConnection(conn) => {
@@ -455,13 +455,13 @@ impl TransactionTrait for DatabaseConnection {
455455
}
456456

457457
/// Execute the function inside a transaction.
458-
/// If the function returns an error, the transaction will be rolled back. If it does not return an error, the transaction will be committed.
458+
/// If the function returns an error, the transaction will be rolled back.
459+
/// If it does not return an error, the transaction will be committed.
459460
#[instrument(level = "trace", skip(_callback))]
460461
async fn transaction_with_config<F, T, E>(
461462
&self,
462463
_callback: F,
463-
_isolation_level: Option<IsolationLevel>,
464-
_access_mode: Option<AccessMode>,
464+
_config: TransactionConfig,
465465
) -> Result<T, TransactionError<E>>
466466
where
467467
F: for<'c> FnOnce(
@@ -474,22 +474,19 @@ impl TransactionTrait for DatabaseConnection {
474474
match &self.inner {
475475
#[cfg(feature = "sqlx-mysql")]
476476
DatabaseConnectionType::SqlxMySqlPoolConnection(conn) => {
477-
conn.transaction(_callback, _isolation_level, _access_mode)
478-
.await
477+
conn.transaction(_callback, _config).await
479478
}
480479
#[cfg(feature = "sqlx-postgres")]
481480
DatabaseConnectionType::SqlxPostgresPoolConnection(conn) => {
482-
conn.transaction(_callback, _isolation_level, _access_mode)
483-
.await
481+
conn.transaction(_callback, _config).await
484482
}
485483
#[cfg(feature = "sqlx-sqlite")]
486484
DatabaseConnectionType::SqlxSqlitePoolConnection(conn) => {
487-
conn.transaction(_callback, _isolation_level, _access_mode)
488-
.await
485+
conn.transaction(_callback, _config).await
489486
}
490487
#[cfg(feature = "rusqlite")]
491488
DatabaseConnectionType::RusqliteSharedConnection(conn) => {
492-
conn.transaction(_callback, _isolation_level, _access_mode)
489+
conn.transaction(_callback, _config)
493490
}
494491
#[cfg(feature = "mock")]
495492
DatabaseConnectionType::MockDatabaseConnection(conn) => {
@@ -556,8 +553,8 @@ impl DatabaseConnection {
556553

557554
#[cfg(feature = "rbac")]
558555
impl DatabaseConnection {
559-
/// Load RBAC data from the same database as this connection and setup RBAC engine.
560-
/// If the RBAC engine already exists, it will be replaced.
556+
/// Load RBAC data from the same database as this connection and setup RBAC
557+
/// engine. If the RBAC engine already exists, it will be replaced.
561558
pub async fn load_rbac(&self) -> Result<(), DbErr> {
562559
self.load_rbac_from(self).await
563560
}
@@ -575,7 +572,8 @@ impl DatabaseConnection {
575572
self.rbac.replace(engine);
576573
}
577574

578-
/// Create a restricted connection with access control specific for the user.
575+
/// Create a restricted connection with access control specific for the
576+
/// user.
579577
pub fn restricted_for(
580578
&self,
581579
user_id: crate::rbac::RbacUserId,

‎src/database/executor.rs‎

Lines changed: 11 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -1,10 +1,11 @@
1+
use std::future::Future;
2+
use std::pin::Pin;
3+
14
use crate::{
2-
AccessMode, ConnectionTrait, DatabaseConnection, DatabaseTransaction, DbBackend, DbErr,
3-
ExecResult, IsolationLevel, QueryResult, Statement, TransactionError, TransactionTrait,
5+
ConnectionTrait, DatabaseConnection, DatabaseTransaction, DbBackend, DbErr, ExecResult,
6+
QueryResult, Statement, TransactionConfig, TransactionError, TransactionTrait,
47
};
58
use crate::{Schema, SchemaBuilder};
6-
use std::future::Future;
7-
use std::pin::Pin;
89

910
/// A wrapper that holds either a reference to a [`DatabaseConnection`] or [`DatabaseTransaction`].
1011
#[derive(Debug)]
@@ -78,16 +79,11 @@ impl TransactionTrait for DatabaseExecutor<'_> {
7879

7980
async fn begin_with_config(
8081
&self,
81-
isolation_level: Option<IsolationLevel>,
82-
access_mode: Option<AccessMode>,
82+
config: TransactionConfig,
8383
) -> Result<DatabaseTransaction, DbErr> {
8484
match self {
85-
DatabaseExecutor::Connection(conn) => {
86-
conn.begin_with_config(isolation_level, access_mode).await
87-
}
88-
DatabaseExecutor::Transaction(trans) => {
89-
trans.begin_with_config(isolation_level, access_mode).await
90-
}
85+
DatabaseExecutor::Connection(conn) => conn.begin_with_config(config).await,
86+
DatabaseExecutor::Transaction(trans) => trans.begin_with_config(config).await,
9187
}
9288
}
9389

@@ -109,8 +105,7 @@ impl TransactionTrait for DatabaseExecutor<'_> {
109105
async fn transaction_with_config<F, T, E>(
110106
&self,
111107
callback: F,
112-
isolation_level: Option<IsolationLevel>,
113-
access_mode: Option<AccessMode>,
108+
config: TransactionConfig,
114109
) -> Result<T, TransactionError<E>>
115110
where
116111
F: for<'c> FnOnce(
@@ -122,13 +117,10 @@ impl TransactionTrait for DatabaseExecutor<'_> {
122117
{
123118
match self {
124119
DatabaseExecutor::Connection(conn) => {
125-
conn.transaction_with_config(callback, isolation_level, access_mode)
126-
.await
120+
conn.transaction_with_config(callback, config).await
127121
}
128122
DatabaseExecutor::Transaction(trans) => {
129-
trans
130-
.transaction_with_config(callback, isolation_level, access_mode)
131-
.await
123+
trans.transaction_with_config(callback, config).await
132124
}
133125
}
134126
}

‎src/database/restricted_connection.rs‎

Lines changed: 22 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -1,19 +1,24 @@
1-
use crate::rbac::{
2-
PermissionRequest, RbacEngine, RbacError, RbacPermissionsByResources,
3-
RbacResourcesAndPermissions, RbacRoleHierarchyList, RbacRolesAndRanks, RbacUserRolePermissions,
4-
ResourceRequest,
5-
entity::{role::RoleId, user::UserId},
1+
use std::{
2+
pin::Pin,
3+
sync::{Arc, RwLock},
64
};
5+
6+
use tracing::instrument;
7+
78
use crate::{
89
AccessMode, ConnectionTrait, DatabaseConnection, DatabaseTransaction, DbBackend, DbErr,
910
ExecResult, IsolationLevel, QueryResult, Statement, StatementBuilder, TransactionError,
1011
TransactionSession, TransactionTrait,
1112
};
12-
use std::{
13-
pin::Pin,
14-
sync::{Arc, RwLock},
13+
use crate::{
14+
TransactionConfig,
15+
rbac::{
16+
PermissionRequest, RbacEngine, RbacError, RbacPermissionsByResources,
17+
RbacResourcesAndPermissions, RbacRoleHierarchyList, RbacRolesAndRanks,
18+
RbacUserRolePermissions, ResourceRequest,
19+
entity::{role::RoleId, user::UserId},
20+
},
1521
};
16-
use tracing::instrument;
1722

1823
/// Wrapper of [`DatabaseConnection`] that performs authorization on all executed
1924
/// queries for the current user. Note that raw SQL [`Statement`] is not allowed
@@ -223,15 +228,11 @@ impl TransactionTrait for RestrictedConnection {
223228
#[instrument(level = "trace")]
224229
async fn begin_with_config(
225230
&self,
226-
isolation_level: Option<IsolationLevel>,
227-
access_mode: Option<AccessMode>,
231+
config: TransactionConfig,
228232
) -> Result<RestrictedTransaction, DbErr> {
229233
Ok(RestrictedTransaction {
230234
user_id: self.user_id,
231-
conn: self
232-
.conn
233-
.begin_with_config(isolation_level, access_mode)
234-
.await?,
235+
conn: self.conn.begin_with_config(config).await?,
235236
rbac: self.conn.rbac.clone(),
236237
})
237238
}
@@ -258,8 +259,7 @@ impl TransactionTrait for RestrictedConnection {
258259
async fn transaction_with_config<F, T, E>(
259260
&self,
260261
callback: F,
261-
isolation_level: Option<IsolationLevel>,
262-
access_mode: Option<AccessMode>,
262+
config: TransactionConfig,
263263
) -> Result<T, TransactionError<E>>
264264
where
265265
F: for<'c> FnOnce(
@@ -270,7 +270,7 @@ impl TransactionTrait for RestrictedConnection {
270270
E: std::fmt::Display + std::fmt::Debug + Send,
271271
{
272272
let transaction = self
273-
.begin_with_config(isolation_level, access_mode)
273+
.begin_with_config(config)
274274
.await
275275
.map_err(TransactionError::Connection)?;
276276
transaction.run(callback).await
@@ -293,15 +293,11 @@ impl TransactionTrait for RestrictedTransaction {
293293
#[instrument(level = "trace")]
294294
async fn begin_with_config(
295295
&self,
296-
isolation_level: Option<IsolationLevel>,
297-
access_mode: Option<AccessMode>,
296+
config: TransactionConfig,
298297
) -> Result<RestrictedTransaction, DbErr> {
299298
Ok(RestrictedTransaction {
300299
user_id: self.user_id,
301-
conn: self
302-
.conn
303-
.begin_with_config(isolation_level, access_mode)
304-
.await?,
300+
conn: self.conn.begin_with_config(config).await?,
305301
rbac: self.rbac.clone(),
306302
})
307303
}
@@ -328,8 +324,7 @@ impl TransactionTrait for RestrictedTransaction {
328324
async fn transaction_with_config<F, T, E>(
329325
&self,
330326
callback: F,
331-
isolation_level: Option<IsolationLevel>,
332-
access_mode: Option<AccessMode>,
327+
config: TransactionConfig,
333328
) -> Result<T, TransactionError<E>>
334329
where
335330
F: for<'c> FnOnce(
@@ -340,7 +335,7 @@ impl TransactionTrait for RestrictedTransaction {
340335
E: std::fmt::Display + std::fmt::Debug + Send,
341336
{
342337
let transaction = self
343-
.begin_with_config(isolation_level, access_mode)
338+
.begin_with_config(config)
344339
.await
345340
.map_err(TransactionError::Connection)?;
346341
transaction.run(callback).await

0 commit comments

Comments
 (0)