Struct Tx 

pub struct Tx<DB: Marker, E = Error> { /* private fields */ }

An axum extractor for a database transaction.

&mut Tx implements sqlx::Executor so it can be used directly with sqlx::query() (and sqlx::query_as(), the corresponding macros, etc.):

use axum_sqlx_tx::Tx;
use sqlx::Sqlite;

async fn handler(mut tx: Tx<Sqlite>) -> Result<(), sqlx::Error> {
    sqlx::query("...").execute(&mut tx).await?;
    /* ... */
}

It also implements Deref<Target = sqlx::Transaction> and DerefMut, so you can call methods from Transaction and its traits:

use axum_sqlx_tx::Tx;
use sqlx::{Acquire as _, Sqlite};

async fn handler(mut tx: Tx<Sqlite>) -> Result<(), sqlx::Error> {
    let inner = tx.begin().await?;
    /* ... */
}

The E generic parameter controls the error type returned when the extractor fails. This can be used to configure the error response returned when the extractor fails:

use axum::response::IntoResponse;
use axum_sqlx_tx::Tx;
use sqlx::Sqlite;

struct MyError(axum_sqlx_tx::Error);

// The error type must implement From<axum_sqlx_tx::Error>
impl From<axum_sqlx_tx::Error> for MyError {
    fn from(error: axum_sqlx_tx::Error) -> Self {
        Self(error)
    }
}

// The error type must implement IntoResponse
impl IntoResponse for MyError {
    fn into_response(self) -> axum::response::Response {
        (http::StatusCode::INTERNAL_SERVER_ERROR, "internal server error").into_response()
    }
}

async fn handler(tx: Tx<Sqlite, MyError>) {
    /* ... */
}

Implementations

impl<DB: Marker, E> Tx<DB, E>

pub fn setup(pool: Pool<DB::Driver>) -> (State<DB>, Layer<DB, Error>)

Crate a State and Layer to enable the extractor.

This is convenient to use from a type alias, e.g.

type Tx = axum_sqlx_tx::Tx<sqlx::Sqlite>;

let pool: sqlx::SqlitePool = todo!();
let (state, layer) = Tx::setup(pool);

pub fn config(pool: Pool<DB::Driver>) -> Config<DB, Error>

Configure extractor behaviour.

See the Config API for available options.

This is convenient to use from a type alias, e.g.

type Tx = axum_sqlx_tx::Tx<sqlx::Sqlite>;

let config = Tx::config(pool);

pub async fn commit(self) -> Result<(), Error>

Explicitly commit the transaction.

By default, the transaction will be committed when a successful response is returned (specifically, when the Service middleware intercepts an HTTP 2XX or 3XX response). This method allows the transaction to be committed explicitly.

Note: trying to use the Tx extractor again after calling commit will currently generate Error::OverlappingExtractors errors. This may change in future.

Trait Implementations

impl<DB: Marker, E> AsMut<Transaction<'static, <DB as Marker>::Driver>> for Tx<DB, E>

fn as_mut(&mut self) -> &mut Transaction<'static, DB::Driver>

Converts this type into a mutable reference of the (usually inferred) input type.

impl<DB: Marker, E> AsRef<Transaction<'static, <DB as Marker>::Driver>> for Tx<DB, E>

fn as_ref(&self) -> &Transaction<'static, DB::Driver>

Converts this type into a shared reference of the (usually inferred) input type.

impl<DB: Marker, E> Debug for Tx<DB, E>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<DB: Marker, E> Deref for Tx<DB, E>

type Target = Transaction<'static, <DB as Marker>::Driver>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<DB: Marker, E> DerefMut for Tx<DB, E>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'c, DB, E> Executor<'c> for &'c mut Tx<DB, E>

where DB: Marker, for<'t> &'t mut <DB::Driver as Database>::Connection: Executor<'t, Database = DB::Driver>, E: Debug + Send,

type Database = <DB as Marker>::Driver

fn fetch_many<'e, 'q: 'e, Q>( self, query: Q, ) -> BoxStream<'e, Result<Either<<Self::Database as Database>::QueryResult, <Self::Database as Database>::Row>, Error>>

where Q: Execute<'q, Self::Database> + 'q, 'c: 'e,

Execute multiple queries and return the generated results as a stream from each query, in a stream.

fn fetch_optional<'e, 'q: 'e, Q>( self, query: Q, ) -> BoxFuture<'e, Result<Option<<Self::Database as Database>::Row>, Error>>

where Q: Execute<'q, Self::Database> + 'q, 'c: 'e,

Execute the query and returns at most one row.

fn prepare_with<'e, 'q: 'e>( self, sql: &'q str, parameters: &'e [<Self::Database as Database>::TypeInfo], ) -> BoxFuture<'e, Result<<Self::Database as Database>::Statement<'q>, Error>>

where 'c: 'e,

Prepare the SQL query, with parameter type information, to inspect the type information about its parameters and results.

fn execute<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return the total number of rows affected.

fn execute_many<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::QueryResult, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute multiple queries and return the rows affected from each query, in a stream.

fn fetch<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Stream<Item = Result<<Self::Database as Database>::Row, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return the generated results as a stream.

fn fetch_all<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<Vec<<Self::Database as Database>::Row>, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and return all the generated results, collected into a Vec.

fn fetch_one<'e, 'q, E>( self, query: E, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Row, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e, E: 'q + Execute<'q, Self::Database>,

Execute the query and returns exactly one row.

fn prepare<'e, 'q>( self, query: &'q str, ) -> Pin<Box<dyn Future<Output = Result<<Self::Database as Database>::Statement<'q>, Error>> + Send + 'e>>

where 'q: 'e, 'c: 'e,

Prepare the SQL query to inspect the type information of its parameters and results.

impl<DB: Marker, S, E> FromRequestParts<S> for Tx<DB, E>

where S: Sync, E: From<Error> + IntoResponse + Send, State<DB>: FromRef<S>,

type Rejection = E

If the extractor fails it’ll use this “rejection” type. A rejection is a kind of error that can be converted into a response.

async fn from_request_parts( parts: &mut Parts, _state: &S, ) -> Result<Self, Self::Rejection>

Perform the extraction.