appstruct-codegen 0.1.0

Deterministic Rust, SQL, OpenAPI, TypeScript, and React generation for AppStruct
Documentation
use proc_macro2::TokenStream;
use quote::quote;

pub(super) fn contract() -> TokenStream {
    let methods = methods();
    let connection = connection_trait();
    quote! {
        #[derive(Clone, Copy)]
        enum RequestDatabase<'db> {
            Connection(&'db DatabaseConnection),
            Transaction(&'db DatabaseTransaction),
        }

        #[derive(Clone)]
        pub struct RequestContext<'db> {
            database: RequestDatabase<'db>,
            mail: &'db crate::MailState,
            file: Option<&'db crate::FileState>,
            actor: Option<Actor>,
            tenant: Option<TenantId>,
        }

        #methods
        #connection
    }
}

fn methods() -> TokenStream {
    quote! {
        impl<'db> RequestContext<'db> {
            pub fn connection(
                database: &'db DatabaseConnection,
                mail: &'db crate::MailState,
                actor: Option<Actor>,
                tenant: Option<TenantId>,
            ) -> Self {
                Self { database: RequestDatabase::Connection(database), mail, file: None, actor, tenant }
            }

            pub fn transaction(
                database: &'db DatabaseTransaction,
                mail: &'db crate::MailState,
                actor: Option<Actor>,
                tenant: Option<TenantId>,
            ) -> Self {
                Self { database: RequestDatabase::Transaction(database), mail, file: None, actor, tenant }
            }

            pub fn connection_with_file(
                database: &'db DatabaseConnection,
                mail: &'db crate::MailState,
                file: &'db crate::FileState,
                actor: Option<Actor>,
                tenant: Option<TenantId>,
            ) -> Self {
                Self { database: RequestDatabase::Connection(database), mail, file: Some(file), actor, tenant }
            }

            pub(crate) fn transaction_with_file(
                database: &'db DatabaseTransaction,
                mail: &'db crate::MailState,
                file: &'db crate::FileState,
                actor: Option<Actor>,
                tenant: Option<TenantId>,
            ) -> Self {
                Self { database: RequestDatabase::Transaction(database), mail, file: Some(file), actor, tenant }
            }

            pub fn database(&self) -> &Self { self }
            pub fn actor(&self) -> Option<&Actor> { self.actor.as_ref() }
            pub fn tenant(&self) -> Option<TenantId> { self.tenant }
            pub fn require_tenant(&self) -> Result<TenantId, ApiError> {
                self.tenant.ok_or(ApiError::InvalidTenant)
            }
            pub async fn send_mail(
                &self,
                template: &str,
                recipient: &str,
                variables: &std::collections::BTreeMap<String, String>,
            ) -> Result<crate::MailDelivery, crate::MailError> {
                self.mail.send_template(template, recipient, variables, self.tenant).await
            }
            pub async fn enqueue_job<T: serde::Serialize>(
                &self,
                queue: &str,
                kind: &str,
                payload: &T,
                idempotency_key: Option<&str>,
                run_at: Option<chrono::DateTime<chrono::Utc>>,
            ) -> Result<crate::JobReceipt, crate::JobError> {
                crate::jobs::enqueue(
                    self, queue, kind, payload, idempotency_key, run_at, self.tenant,
                ).await
            }
            pub async fn put_file(
                &self, object_key: &str, original_name: &str,
                content_type: &str, content: &[u8],
            ) -> Result<crate::FileMetadata, crate::FileError> {
                self.file.ok_or(crate::FileError::Disabled)?
                    .put(object_key, original_name, content_type, content, self.tenant).await
            }
            pub async fn get_file(
                &self, object_key: &str,
            ) -> Result<(crate::FileMetadata, Vec<u8>), crate::FileError> {
                self.file.ok_or(crate::FileError::Disabled)?.get(object_key, self.tenant).await
            }
            pub async fn delete_file(&self, object_key: &str) -> Result<(), crate::FileError> {
                self.file.ok_or(crate::FileError::Disabled)?.delete(object_key, self.tenant).await
            }
        }
    }
}

fn connection_trait() -> TokenStream {
    quote! {
        #[async_trait]
        impl ConnectionTrait for RequestContext<'_> {
            fn get_database_backend(&self) -> DbBackend {
                match self.database {
                    RequestDatabase::Connection(database) => database.get_database_backend(),
                    RequestDatabase::Transaction(database) => database.get_database_backend(),
                }
            }

            async fn execute_raw(&self, statement: Statement) -> Result<ExecResult, DbErr> {
                match self.database {
                    RequestDatabase::Connection(database) => database.execute_raw(statement).await,
                    RequestDatabase::Transaction(database) => database.execute_raw(statement).await,
                }
            }

            async fn execute_unprepared(&self, sql: &str) -> Result<ExecResult, DbErr> {
                match self.database {
                    RequestDatabase::Connection(database) => database.execute_unprepared(sql).await,
                    RequestDatabase::Transaction(database) => database.execute_unprepared(sql).await,
                }
            }

            async fn query_one_raw(&self, statement: Statement) -> Result<Option<QueryResult>, DbErr> {
                match self.database {
                    RequestDatabase::Connection(database) => database.query_one_raw(statement).await,
                    RequestDatabase::Transaction(database) => database.query_one_raw(statement).await,
                }
            }

            async fn query_all_raw(&self, statement: Statement) -> Result<Vec<QueryResult>, DbErr> {
                match self.database {
                    RequestDatabase::Connection(database) => database.query_all_raw(statement).await,
                    RequestDatabase::Transaction(database) => database.query_all_raw(statement).await,
                }
            }
        }
    }
}