Struct tide_sqlx::SQLxMiddleware

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

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: Clone> Clone for SQLxMiddleware<DB> where
    DB: Database,
    DB::Connection: Send + Sync + 'static, 

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<DB: Debug> Debug for SQLxMiddleware<DB> where
    DB: Database,
    DB::Connection: Send + Sync + 'static, 

pub 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, 

pub 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, 

pub 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
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Asynchronously handle the request, and return a response.

pub fn name(&self) -> &str

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