Struct SQLxMiddleware

pub struct SQLxMiddleware<DB>
where
    DB: Database,
    DB::Connection: Send + Sync + 'static,
{ /* private fields */ }

This middleware holds a pool of SQLx database connections, and automatically hands each tide::Request a connection, which may transparently be either a database transaction, or a direct pooled database connection.

By default, transactions are used for all http methods other than GET and HEAD.

When using this, use the SQLxRequestExt extenstion trait to get the connection.

Example

use sqlx::Acquire; // Or sqlx::prelude::*;
use sqlx::postgres::Postgres;

use tide_sqlx::SQLxMiddleware;
use tide_sqlx::SQLxRequestExt;

let mut app = tide::new();
app.with(SQLxMiddleware::<Postgres>::new("postgres://localhost/a_database").await?);

app.at("/").post(|req: tide::Request<()>| async move {
    let mut pg_conn = req.sqlx_conn::<Postgres>().await;

    sqlx::query("SELECT * FROM users")
        .fetch_optional(pg_conn.acquire().await?)
        .await;

    Ok("")
});

Implementations

impl<DB> SQLxMiddleware<DB>

where DB: Database, DB::Connection: Send + Sync + 'static,

pub async fn new(pgurl: &str) -> Result<Self, Error>

Create a new instance of SQLxMiddleware.

Trait Implementations

impl<DB> AsRef<Pool<DB>> for SQLxMiddleware<DB>

where DB: Database, DB::Connection: Send + Sync + 'static,

fn as_ref(&self) -> &Pool<DB>

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

impl<DB> Clone for SQLxMiddleware<DB>

where DB: Database + Clone, DB::Connection: Send + Sync + 'static,

fn clone(&self) -> SQLxMiddleware<DB>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<DB> Debug for SQLxMiddleware<DB>

where DB: Database + Debug, DB::Connection: Send + Sync + 'static,

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

Formats the value using the given formatter.

impl<DB> From<Pool<DB>> for SQLxMiddleware<DB>

where DB: Database, DB::Connection: Send + Sync + 'static,

fn from(pool: Pool<DB>) -> Self

Create a new instance of SQLxMiddleware from a sqlx::Pool.

impl<State, DB> Middleware<State> for SQLxMiddleware<DB>

where State: Clone + Send + Sync + 'static, DB: Database, DB::Connection: Send + Sync + 'static,

fn handle<'life0, 'life1, 'async_trait>( &'life0 self, req: Request<State>, next: Next<'life1, State>, ) -> Pin<Box<dyn Future<Output = Result> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Asynchronously handle the request, and return a response.

fn name(&self) -> &str

Set the middleware’s name. By default it uses the type signature.