crudly 0.6.0

Derivable crud helpers for sqlx. Write your SELECT, INSERT, UPDATE and DELETE queries once and reuse them for all your entities.
Documentation
use sqlx::Database;
use sqlx::Executor;
use sqlx::IntoArguments;
use sqlx::Pool;
use sqlx::SqlSafeStr;
use sqlx::query_with;
use std::future::Future;
use std::pin::Pin;

type ReusableExecutorFuture<'a> = Pin<Box<dyn Future<Output = sqlx::Result<()>> + Send + 'a>>;

pub trait ReusableExecutor<DB: Database> {
    fn execute_query_with<'a, 'q: 'a>(
        &'a mut self,
        sql: impl SqlSafeStr + Send + Sync + 'q,
        arguments: DB::Arguments,
    ) -> ReusableExecutorFuture<'a>;
}

#[cfg(feature = "sqlite")]
impl ReusableExecutor<sqlx::Sqlite> for &mut sqlx::SqliteConnection {
    fn execute_query_with<'a, 'q: 'a>(
        &'a mut self,
        sql: impl SqlSafeStr + Send + Sync + 'q,
        arguments: <sqlx::Sqlite as Database>::Arguments,
    ) -> ReusableExecutorFuture<'a> {
        Box::pin(async move {
            query_with(sql, arguments).execute(&mut **self).await?;
            Ok(())
        })
    }
}

#[cfg(feature = "postgres")]
impl ReusableExecutor<sqlx::Postgres> for &mut sqlx::PgConnection {
    fn execute_query_with<'a, 'q: 'a>(
        &'a mut self,
        sql: impl SqlSafeStr + Send + Sync + 'q,
        arguments: <sqlx::Postgres as Database>::Arguments,
    ) -> ReusableExecutorFuture<'a> {
        Box::pin(async move {
            query_with(sql, arguments).execute(&mut **self).await?;
            Ok(())
        })
    }
}

#[cfg(feature = "mysql")]
impl ReusableExecutor<sqlx::MySql> for &mut sqlx::MySqlConnection {
    fn execute_query_with<'a, 'q: 'a>(
        &'a mut self,
        sql: impl SqlSafeStr + Send + Sync + 'q,
        arguments: <sqlx::MySql as Database>::Arguments,
    ) -> ReusableExecutorFuture<'a> {
        Box::pin(async move {
            query_with(sql, arguments).execute(&mut **self).await?;
            Ok(())
        })
    }
}

impl<DB: Database> ReusableExecutor<DB> for Pool<DB>
where
    <DB as Database>::Arguments: IntoArguments<DB>,
    for<'e> &'e mut DB::Connection: Executor<'e, Database = DB>,
{
    fn execute_query_with<'a, 'q: 'a>(
        &'a mut self,
        sql: impl SqlSafeStr + Send + Sync + 'q,
        arguments: DB::Arguments,
    ) -> ReusableExecutorFuture<'a> {
        Box::pin(async move {
            query_with(sql, arguments).execute(&*self).await?;
            Ok(())
        })
    }
}

impl<DB: Database> ReusableExecutor<DB> for &Pool<DB>
where
    <DB as Database>::Arguments: IntoArguments<DB>,
    for<'e> &'e mut DB::Connection: Executor<'e, Database = DB>,
{
    fn execute_query_with<'a, 'q: 'a>(
        &'a mut self,
        sql: impl SqlSafeStr + Send + Sync + 'q,
        arguments: DB::Arguments,
    ) -> ReusableExecutorFuture<'a> {
        Box::pin(async move {
            query_with(sql, arguments).execute(*self).await?;
            Ok(())
        })
    }
}

impl<DB: Database> ReusableExecutor<DB> for &mut Pool<DB>
where
    <DB as Database>::Arguments: IntoArguments<DB>,
    for<'e> &'e mut DB::Connection: Executor<'e, Database = DB>,
{
    fn execute_query_with<'a, 'q: 'a>(
        &'a mut self,
        sql: impl SqlSafeStr + Send + Sync + 'q,
        arguments: DB::Arguments,
    ) -> ReusableExecutorFuture<'a> {
        Box::pin(async move {
            query_with(sql, arguments).execute(&**self).await?;
            Ok(())
        })
    }
}