appstruct-codegen 0.2.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 Database),
            Transaction(&'db Transaction),
        }

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

        #methods
        #connection
    }
}

#[allow(clippy::too_many_lines)]
fn methods() -> TokenStream {
    quote! {
        impl<'db> RequestContext<'db> {
            pub fn connection(
                database: &'db Database,
                mail: &'db crate::MailState,
                actor: Option<Actor>,
                tenant: Option<TenantId>,
            ) -> Self {
                Self { database: RequestDatabase::Connection(database), mail, file: None, realtime: None, actor, tenant }
            }

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

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

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

            pub fn transaction_with_file(
                database: &'db Transaction,
                mail: &'db crate::MailState,
                file: &'db crate::FileState,
                realtime: &'db crate::RealtimeState,
                actor: Option<Actor>,
                tenant: Option<TenantId>,
            ) -> Self {
                Self {
                    database: RequestDatabase::Transaction(database), mail, file: Some(file),
                    realtime: Some(realtime), 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 publish_webhook<T: serde::Serialize>(
                &self, event: &str, payload: &T, idempotency_key: Option<&str>,
            ) -> Result<crate::WebhookReceipt, crate::WebhookError> {
                crate::webhooks::publish(
                    self, event, payload, idempotency_key, self.tenant,
                ).await
            }
            pub fn publish_realtime<T: serde::Serialize>(
                &self, event: &str, payload: &T,
            ) -> Result<crate::RealtimeEvent, serde_json::Error> {
                if let Some(realtime) = self.realtime {
                    realtime.publish(
                        event, payload, self.actor.as_ref().map(|actor| actor.id), self.tenant,
                    )
                } else {
                    crate::RealtimeState::default().publish(
                        event, payload, self.actor.as_ref().map(|actor| actor.id), self.tenant,
                    )
                }
            }
            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_with_connection(
                        self, 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_with_connection(self, object_key, self.tenant).await
            }
            pub async fn retain_file(&self, object_key: &str, entity: &str, record_id: &str) -> Result<(), crate::FileError> {
                self.file.ok_or(crate::FileError::Disabled)?
                    .retain_with_connection(self, object_key, entity, record_id, self.tenant).await
            }
            pub async fn release_file(&self, object_key: &str, entity: &str, record_id: &str) -> Result<(), crate::FileError> {
                self.file.ok_or(crate::FileError::Disabled)?
                    .release_with_connection(self, object_key, entity, record_id, self.tenant).await
            }
            pub async fn delete_file(&self, object_key: &str) -> Result<(), crate::FileError> {
                let file = self.file.ok_or(crate::FileError::Disabled)?;
                match self.database {
                    RequestDatabase::Connection(_) => file.delete(object_key, self.tenant).await,
                    RequestDatabase::Transaction(database) => file.delete_with_connection(database, object_key, self.tenant).await,
                }
            }
        }
    }
}

fn connection_trait() -> TokenStream {
    quote! {
        #[async_trait]
        impl DatabaseExecutor for RequestContext<'_> {
            async fn execute(&self, statement: Sql) -> Result<PgQueryResult, DbErr> {
                match self.database {
                    RequestDatabase::Connection(database) => database.execute(statement).await,
                    RequestDatabase::Transaction(database) => database.execute(statement).await,
                }
            }

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

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

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