DieselCrud traits and derives

crates/diesel_crud_derive/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "diesel-crud-derive"
+version = "0.1.0"
+edition = { workspace = true }
+rust-version = { workspace = true }
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = { workspace = true }
+quote = { workspace = true }
+deluxe = { workspace = true }
+proc-macro2 = { workspace = true }

crates/diesel_crud_derive/src/common.rs

@@ -0,0 +1,20 @@
+use quote::quote;
+
+pub(crate) fn function_body(body: proc_macro2::TokenStream) -> proc_macro2::TokenStream {
+    quote! {
+        let connection = self.pool.get().await;
+        match connection {
+            Ok(mut connection) => {
+                use diesel::associations::HasTable;
+                #body
+            }
+            Err(error) => Err(lib::diesel_crud_trait::CrudError::PoolError(error.to_string())),
+        }
+    }
+}
+
+pub(crate) fn return_type(output: proc_macro2::TokenStream) -> proc_macro2::TokenStream {
+    quote! {
+        std::pin::Pin<Box<dyn core::future::Future<Output = Result<#output, lib::diesel_crud_trait::CrudError>> + Send + 'b>>
+    }
+}

crates/diesel_crud_derive/src/create.rs

@@ -0,0 +1,49 @@
+use crate::{common, StructAttributes};
+use proc_macro2::Ident;
+use quote::quote;
+use syn::Expr;
+
+pub(crate) fn derive_diesel_crud_create_impl(
+    StructAttributes {
+        table,
+        entity,
+        create,
+        ..
+    }: &StructAttributes,
+    identifier: &Ident,
+) -> proc_macro2::TokenStream {
+    let body = function_body(table);
+    let return_type = common::return_type(quote! { Self::Entity });
+
+    quote! {
+        #[automatically_derived]
+        impl<'insertable, 'entity> lib::diesel_crud_trait::DieselCrudCreate<'insertable, 'entity, #table::table> for #identifier
+            where
+                'entity: 'insertable,
+        {
+            type Create = #create;
+            type Entity = #entity;
+            fn create<'a, 'b>(&'a self, create: &'insertable Self::Create) -> #return_type
+                where
+                    Self: Sync + 'a,
+                    'a: 'b,
+                    'insertable: 'b
+            {
+                Box::pin(async move {
+                    #body
+                })
+            }
+        }
+    }
+}
+
+fn function_body(table: &Expr) -> proc_macro2::TokenStream {
+    common::function_body(quote! {
+        diesel_async::RunQueryDsl::get_result(
+            diesel::dsl::insert_into(#table::table::table()).values(create),
+            &mut connection
+        )
+            .await
+            .map_err(Into::into)
+    })
+}

crates/diesel_crud_derive/src/delete.rs

@@ -0,0 +1,55 @@
+use crate::{common, StructAttributes};
+use proc_macro2::Ident;
+use quote::{quote, ToTokens};
+use syn::Expr;
+
+pub(crate) fn derive_diesel_crud_delete_impl(
+    StructAttributes {
+        table,
+        pk,
+        pk_field,
+        ..
+    }: &StructAttributes,
+    identifier: &Ident,
+) -> proc_macro2::TokenStream {
+    let body = function_body(
+        table,
+        pk_field
+            .clone()
+            .map(Expr::into_token_stream)
+            .unwrap_or_else(|| quote! { id }),
+    );
+    let return_type = common::return_type(quote! { usize });
+
+    quote! {
+        #[automatically_derived]
+        impl lib::diesel_crud_trait::DieselCrudDelete for #identifier {
+            type PK = #pk;
+            fn delete<'a, 'pk, 'b>(&'a self, pk: &'pk Self::PK) -> #return_type
+                where
+                    Self: Sync + 'a,
+                    'a: 'b,
+                    'pk: 'b,
+            {
+                Box::pin(async move {
+                    #body
+                })
+            }
+        }
+    }
+}
+
+fn function_body(table: &Expr, pk_field: proc_macro2::TokenStream) -> proc_macro2::TokenStream {
+    common::function_body(quote! {
+        use diesel::QueryDsl;
+        diesel_async::RunQueryDsl::execute(
+            diesel::delete(
+                #table::table
+                    .filter(diesel::expression_methods::ExpressionMethods::eq(#table::#pk_field, pk))
+            ),
+            &mut connection,
+        )
+            .await
+            .map_err(Into::into)
+    })
+}

crates/diesel_crud_derive/src/lib.rs

@@ -0,0 +1,183 @@
+extern crate proc_macro;
+
+use crate::create::derive_diesel_crud_create_impl;
+use crate::delete::derive_diesel_crud_delete_impl;
+use crate::list::derive_diesel_crud_list_impl;
+use crate::read::derive_diesel_crud_read_impl;
+use crate::update::derive_diesel_crud_update_impl;
+use deluxe::{extract_attributes, ExtractAttributes};
+use quote::quote;
+use syn::{parse_macro_input, DeriveInput, Expr, Type};
+
+mod common;
+mod create;
+mod delete;
+mod list;
+mod read;
+mod update;
+
+#[derive(ExtractAttributes)]
+#[deluxe(attributes(diesel_crud))]
+pub(crate) struct StructAttributes {
+    table: Expr,
+    #[deluxe(default)]
+    entity: Option<Type>,
+    #[deluxe(default)]
+    pk: Option<Type>,
+    #[deluxe(default)]
+    pk_field: Option<Expr>,
+    #[deluxe(default)]
+    create: Option<Type>, // TODO if None, use entity?
+    #[deluxe(default)]
+    update: Option<Type>, // TODO if None, use entity?
+}
+
+// TODO get pool field automatically or by attribute
+
+/// Derives 5 functions for CRUD operations
+/// 1. create
+/// 2. read
+/// 3. update
+/// 4. delete
+/// 5. list
+#[proc_macro_derive(DieselCrud, attributes(diesel_crud))]
+pub fn derive_diesel_crud(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let mut item = parse_macro_input!(item as DeriveInput);
+    let struct_attributes = extract_attributes(&mut item).unwrap();
+    let identifier = item.ident;
+
+    let create = derive_diesel_crud_create_impl(&struct_attributes, &identifier);
+    let read = derive_diesel_crud_read_impl(&struct_attributes, &identifier);
+    let update = derive_diesel_crud_update_impl(&struct_attributes, &identifier);
+    let delete = derive_diesel_crud_delete_impl(&struct_attributes, &identifier);
+    let list = derive_diesel_crud_list_impl(&struct_attributes, &identifier);
+
+    let table = struct_attributes.table;
+    let expanded = quote! {
+        #create
+        #read
+        #update
+        #delete
+        #list
+
+        impl<'insertable, 'entity> lib::diesel_crud_trait::DieselCrud<'insertable, 'entity, #table::table> for #identifier
+            where
+                'entity: 'insertable
+        {}
+    };
+    expanded.into()
+}
+
+/// Derives the create function for CRUD operations.
+/// Must be used on a struct with a field named `pool`, containing a `Pool<AsyncPgConnection>`.
+/// # Struct Attributes
+/// - table: Ident - The schema struct for the table
+/// - result: Type - The resulting model
+/// - create: Type - The insertable model
+/// # Example
+/// ```ignore
+/// use diesel_async::{AsyncPgConnection, pooled_connection::deadpool::Pool};
+///
+/// #[derive(diesel_crud_derive::DieselCrudCreate)]
+/// #[diesel_crud(table = crate::schema::user, result = crate::models::User, create = crate::models::InsertUser)]
+/// struct TestServiceCreate {
+///    pool: Pool<AsyncPgConnection>,
+/// }
+/// ```
+#[proc_macro_derive(DieselCrudCreate, attributes(diesel_crud))]
+pub fn derive_diesel_crud_create(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let mut item = syn::parse_macro_input!(item as DeriveInput);
+    let struct_attributes = extract_attributes(&mut item).unwrap();
+    derive_diesel_crud_create_impl(&struct_attributes, &item.ident).into()
+}
+
+/// Derives the read function for CRUD operations.
+/// Must be used on a struct with a field named `pool`, containing a `Pool<AsyncPgConnection>`.
+/// # Struct Attributes
+/// - table: Ident - The schema struct for the table
+/// - pk: Type - The primary key type
+/// - result: Type - The resulting model
+/// - pk_field (optional): Expr - The field to use as the primary key. Defaults to `id`
+/// # Example
+/// ```ignore
+/// use diesel_async::{AsyncPgConnection, pooled_connection::deadpool::Pool};
+///
+/// #[derive(diesel_crud_derive::DieselCrudRead)]
+/// #[diesel_crud(table = crate::schema::user, result = crate::models::User, pk = String)]
+/// struct TestServiceRead {
+///    pool: Pool<AsyncPgConnection>,
+/// }
+/// ```
+#[proc_macro_derive(DieselCrudRead, attributes(diesel_crud))]
+pub fn derive_diesel_crud_read(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let mut item = syn::parse_macro_input!(item as DeriveInput);
+    let struct_attributes = extract_attributes(&mut item).unwrap();
+    derive_diesel_crud_read_impl(&struct_attributes, &item.ident).into()
+}
+
+/// Derives the update function for CRUD operations.
+/// Must be used on a struct with a field named `pool`, containing a `Pool<AsyncPgConnection>`.
+/// # Struct Attributes
+/// - table: Ident - The schema struct for the table
+/// - update: Type - The update model
+/// # Example
+/// ```ignore
+/// use diesel_async::{AsyncPgConnection, pooled_connection::deadpool::Pool};
+///
+/// #[derive(diesel_crud_derive::DieselCrudUpdate)]
+/// #[diesel_crud(table = crate::schema::user, update = crate::models::User)]
+/// struct TestServiceUpdate {
+///   pool: Pool<AsyncPgConnection>,
+/// }
+/// ```
+#[proc_macro_derive(DieselCrudUpdate, attributes(diesel_crud))]
+pub fn derive_diesel_crud_update(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let mut item = syn::parse_macro_input!(item as DeriveInput);
+    let struct_attributes = extract_attributes(&mut item).unwrap();
+    derive_diesel_crud_update_impl(&struct_attributes, &item.ident).into()
+}
+
+/// Derives the delete function for CRUD operations.
+/// Must be used on a struct with a field named `pool`, containing a `Pool<AsyncPgConnection>`.
+/// # Struct Attributes
+/// - table: Ident - The schema struct for the table
+/// - pk: Type - The primary key type
+/// - pk_field (optional): Expr - The field to use as the primary key. Defaults to `id`
+/// # Example
+/// ```ignore
+/// use diesel_async::{AsyncPgConnection, pooled_connection::deadpool::Pool};
+///
+/// #[derive(diesel_crud_derive::DieselCrudDelete)]
+/// #[diesel_crud(table = crate::schema::user, pk = String)]
+/// struct TestServiceDelete {
+///  pool: Pool<AsyncPgConnection>,
+/// }
+/// ```
+#[proc_macro_derive(DieselCrudDelete, attributes(diesel_crud))]
+pub fn derive_diesel_crud_delete(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let mut item = syn::parse_macro_input!(item as DeriveInput);
+    let struct_attributes = extract_attributes(&mut item).unwrap();
+    derive_diesel_crud_delete_impl(&struct_attributes, &item.ident).into()
+}
+
+/// Derives the list function for CRUD operations.
+/// Must be used on a struct with a field named `pool`, containing a `Pool<AsyncPgConnection>`.
+/// # Struct Attributes
+/// - table: Ident - The schema struct for the table
+/// - result: Type - The resulting model
+/// # Example
+/// ```ignore
+/// use diesel_async::{AsyncPgConnection, pooled_connection::deadpool::Pool};
+///
+/// #[derive(diesel_crud_derive::DieselCrudList)]
+/// #[diesel_crud(table = crate::schema::user, result = crate::models::User)]
+/// struct TestServiceList {
+///   pool: Pool<AsyncPgConnection>,
+/// }
+/// ```
+#[proc_macro_derive(DieselCrudList, attributes(diesel_crud))]
+pub fn derive_diesel_crud_list(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let mut item = syn::parse_macro_input!(item as DeriveInput);
+    let struct_attributes = extract_attributes(&mut item).unwrap();
+    derive_diesel_crud_list_impl(&struct_attributes, &item.ident).into()
+}

crates/diesel_crud_derive/src/list.rs

@@ -0,0 +1,35 @@
+use proc_macro2::Ident;
+use quote::quote;
+use syn::Expr;
+
+use crate::{common, StructAttributes};
+
+pub(crate) fn derive_diesel_crud_list_impl(
+    StructAttributes { table, entity, .. }: &StructAttributes,
+    identifier: &Ident,
+) -> proc_macro2::TokenStream {
+    let body = function_body(table);
+    let return_type = common::return_type(quote! { Vec<Self::Entity> });
+
+    quote! {
+        #[automatically_derived]
+        impl lib::diesel_crud_trait::DieselCrudList for #identifier {
+            type Entity = #entity;
+            fn list<'a, 'b>(&'a self) -> #return_type
+                where
+                    Self: Sync + 'a,
+                    'a: 'b
+            {
+                Box::pin(async move {
+                    #body
+                })
+            }
+        }
+    }
+}
+
+fn function_body(table: &Expr) -> proc_macro2::TokenStream {
+    common::function_body(quote! {
+        diesel_async::RunQueryDsl::get_results(#table::table::table(), &mut connection).await.map_err(Into::into)
+    })
+}

crates/diesel_crud_derive/src/read.rs

@@ -0,0 +1,38 @@
+use proc_macro2::Ident;
+use quote::quote;
+use syn::Expr;
+
+use crate::{common, StructAttributes};
+
+pub(crate) fn derive_diesel_crud_read_impl(
+    StructAttributes {
+        table, entity, pk, ..
+    }: &StructAttributes,
+    identifier: &Ident,
+) -> proc_macro2::TokenStream {
+    let body = function_body(table);
+    let return_type = common::return_type(quote! { Self::Entity });
+
+    quote! {
+        #[automatically_derived]
+        impl lib::diesel_crud_trait::DieselCrudRead for #identifier {
+            type PK = #pk;
+            type Entity = #entity;
+            fn read<'a, 'b>(&'a self, pk: Self::PK) -> #return_type
+                where
+                    Self: Sync + 'a,
+                    'a: 'b
+            {
+                Box::pin(async move {
+                    #body
+                })
+            }
+        }
+    }
+}
+
+fn function_body(table: &Expr) -> proc_macro2::TokenStream {
+    common::function_body(quote! {
+        diesel_async::RunQueryDsl::get_result(diesel::QueryDsl::find(#table::table::table(), pk), &mut connection).await.map_err(Into::into)
+    })
+}

crates/diesel_crud_derive/src/update.rs

@@ -0,0 +1,39 @@
+use crate::{common, StructAttributes};
+use proc_macro2::Ident;
+use quote::quote;
+use syn::Expr;
+
+pub(crate) fn derive_diesel_crud_update_impl(
+    StructAttributes { table, update, .. }: &StructAttributes,
+    identifier: &Ident,
+) -> proc_macro2::TokenStream {
+    let body = function_body(table);
+    let return_type = common::return_type(quote! { usize });
+
+    quote! {
+        #[automatically_derived]
+        impl lib::diesel_crud_trait::DieselCrudUpdate for #identifier {
+            type Update = #update;
+            fn update<'a, 'b>(&'a self, update: Self::Update) -> #return_type
+                where
+                    Self: Sync + 'a,
+                    'a: 'b,
+            {
+                Box::pin(async move {
+                    #body
+                })
+            }
+        }
+    }
+}
+
+fn function_body(table: &Expr) -> proc_macro2::TokenStream {
+    common::function_body(quote! {
+        diesel_async::RunQueryDsl::execute(
+            diesel::dsl::update(#table::table::table()).set(update),
+            &mut connection,
+        )
+            .await
+            .map_err(Into::into)
+    })
+}

crates/diesel_crud_trait/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "diesel-crud-trait"
+version = "0.1.0"
+edition = { workspace = true }
+rust-version = { workspace = true }
+
+[dependencies]
+diesel = { workspace = true, features = ["postgres"] }
+diesel-async = { workspace = true, features = ["postgres", "deadpool"] }
+async-trait = "0.1"
+deadpool-diesel = { version = "0.6", features = ["postgres"] }
+thiserror = "1.0"

crates/diesel_crud_trait/src/error.rs

@@ -0,0 +1,22 @@
+use diesel::result::Error;
+use thiserror::Error;
+
+/// Error type for CRUD operations
+#[derive(Debug, Error)]
+pub enum CrudError {
+    #[error("Resource not found")]
+    NotFound,
+    #[error("Database pool error: {0}")]
+    PoolError(String),
+    #[error(transparent)]
+    Other(Error),
+}
+
+impl From<Error> for CrudError {
+    fn from(error: Error) -> Self {
+        match error {
+            Error::NotFound => CrudError::NotFound,
+            _ => CrudError::Other(error),
+        }
+    }
+}

crates/diesel_crud_trait/src/lib.rs

@@ -0,0 +1,102 @@
+mod error;
+
+pub use error::CrudError;
+
+use async_trait::async_trait;
+use diesel::{AsChangeset, Insertable};
+
+pub trait DieselCrud<'insertable, 'entity, Table>:
+    DieselCrudCreate<'insertable, 'entity, Table>
+    + DieselCrudRead
+    + DieselCrudUpdate
+    + DieselCrudDelete
+    + DieselCrudList
+where
+    'entity: 'insertable,
+{
+}
+
+/// Insert an entity into the database
+/// The entity must implement `Insertable<Table>` for the given table.
+///
+/// Implementing the trait requires the `async_trait` macro.
+/// # Associations
+/// - `Create` - The type to insert
+/// - `Entity` - The type that will be returned
+/// # Parameters
+/// - `create` - The entity to insert
+/// # Returns
+/// A result containing the inserted entity or a `CrudError`
+#[async_trait]
+pub trait DieselCrudCreate<'insertable, 'entity, Table>
+where
+    'entity: 'insertable,
+{
+    type Create: Insertable<Table>;
+    type Entity: 'entity;
+    async fn create(&self, create: &'insertable Self::Create) -> Result<Self::Entity, CrudError>;
+}
+
+/// Gets an entity from the database
+///
+/// Implementing the trait requires the `async_trait` macro.
+/// # Associations
+/// - `PK` - The primary key of the entity
+/// - `Entity` - The type that will be returned
+/// # Parameters
+/// - `pk` - The primary key of the entity
+/// # Returns
+/// A result containing the entity or a `CrudError`.
+/// If the entity is not found, the error should be `CrudError::NotFound`.
+#[async_trait]
+pub trait DieselCrudRead {
+    type PK;
+    type Entity;
+    async fn read(&self, pk: Self::PK) -> Result<Self::Entity, CrudError>;
+}
+
+/// Updates an entity in the database
+/// The entity must implement `AsChangeset` for the given table.
+///
+/// Implementing the trait requires the `async_trait` macro.
+/// # Associations
+/// - `Update` - The type to update
+/// # Parameters
+/// - `update` - The update to apply
+/// # Returns
+/// A result containing the number of rows updated or a `CrudError`.
+/// If the entity is not found, the error should be `CrudError::NotFound`.
+#[async_trait]
+pub trait DieselCrudUpdate {
+    type Update: AsChangeset;
+    async fn update(&self, update: Self::Update) -> Result<usize, CrudError>;
+}
+
+/// Deletes an entity from the database
+///
+/// Implementing the trait requires the `async_trait` macro.
+/// # Associations
+/// - `PK` - The primary key of the entity
+/// # Parameters
+/// - `pk` - The primary key of the entity
+/// # Returns
+/// A result containing the number of rows deleted or a `CrudError`.
+/// If the entity is not found, the error should be `CrudError::NotFound`.
+#[async_trait]
+pub trait DieselCrudDelete {
+    type PK;
+    async fn delete(&self, pk: &Self::PK) -> Result<usize, CrudError>;
+}
+
+/// Lists all entities in the table
+///
+/// Implementing the trait requires the `async_trait` macro.
+/// # Associations
+/// - `Entity` - The type that will be returned in a Vec
+/// # Returns
+/// A result containing a Vec of entities or a `CrudError`.
+#[async_trait]
+pub trait DieselCrudList {
+    type Entity;
+    async fn list(&self) -> Result<Vec<Self::Entity>, CrudError>;
+}

crates/tests/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "tests"
+version = "0.1.0"
+edition.workspace = true
+rust-version.workspace = true
+authors.workspace = true
+homepage.workspace = true
+
+[dependencies]
+diesel = { workspace = true }
+diesel-async = { workspace = true }
+lib = { path = "../../../lib", features = ["diesel", "derive"] }

crates/tests/src/lib.rs

@@ -0,0 +1 @@
+// This file is needed to make the tests directory a crate

crates/tests/tests/diesel_crud_derive.rs

@@ -0,0 +1,82 @@
+#![allow(unused)]
+use diesel::{AsChangeset, Insertable, Queryable, Selectable};
+use diesel_async::pooled_connection::deadpool::Pool;
+use diesel_async::pooled_connection::AsyncDieselConnectionManager;
+use diesel_async::AsyncPgConnection;
+use lib::diesel_crud_derive::{
+    DieselCrud, DieselCrudCreate, DieselCrudDelete, DieselCrudList, DieselCrudRead,
+    DieselCrudUpdate,
+};
+use lib::diesel_crud_trait::DieselCrudCreate;
+
+diesel::table! {
+    user (email) {
+        #[max_length = 255]
+        email -> Varchar,
+    }
+}
+
+#[derive(Queryable, Selectable, Insertable, AsChangeset)]
+#[diesel(table_name = user)]
+struct User {
+    email: String,
+}
+
+#[derive(Insertable)]
+#[diesel(table_name = user)]
+struct InsertUser {
+    email: String,
+}
+
+#[derive(DieselCrud)]
+#[diesel_crud(table = user, entity = User, pk = String, pk_field = email, create = InsertUser, update = User)]
+struct TestService {
+    pool: Pool<AsyncPgConnection>,
+}
+
+#[derive(DieselCrudCreate, DieselCrudRead, DieselCrudUpdate, DieselCrudDelete, DieselCrudList)]
+#[diesel_crud(table = user, entity = User, pk = String, pk_field = email, create = InsertUser, update = User)]
+struct TestServiceSeparate {
+    pool: Pool<AsyncPgConnection>,
+}
+
+#[derive(DieselCrudCreate)]
+#[diesel_crud(table = user, entity = User, create = InsertUser)]
+struct TestServiceCreate {
+    pool: Pool<AsyncPgConnection>,
+}
+
+#[derive(DieselCrudRead)]
+#[diesel_crud(table = user, entity = User, pk = String)]
+struct TestServiceRead {
+    pool: Pool<AsyncPgConnection>,
+}
+
+#[derive(DieselCrudUpdate)]
+#[diesel_crud(table = user, update = User)]
+struct TestServiceUpdate {
+    pool: Pool<AsyncPgConnection>,
+}
+
+#[derive(DieselCrudDelete)]
+#[diesel_crud(table = user, pk = String, pk_field = email)]
+struct TestServiceDelete {
+    pool: Pool<AsyncPgConnection>,
+}
+
+#[derive(DieselCrudList)]
+#[diesel_crud(table = user, entity = User)]
+struct TestServiceList {
+    pool: Pool<AsyncPgConnection>,
+}
+
+#[test]
+fn test_insert_user() {
+    let config = AsyncDieselConnectionManager::<AsyncPgConnection>::new("");
+    let pool = Pool::builder(config).max_size(10).build().unwrap();
+
+    let service = TestServiceCreate { pool };
+    service.create(&InsertUser {
+        email: "test".to_string(),
+    });
+}