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 state(inferred_resources: &[TokenStream]) -> TokenStream {
    let definitions = definitions();
    let state = state_impl();
    let persistence = persistence(inferred_resources);
    let fanout = fanout();
    quote! {
        #definitions
        #state
        #persistence
        #fanout
    }
}

fn definitions() -> TokenStream {
    quote! {
        #[derive(Clone, Debug, Serialize)]
        pub struct RealtimeEvent {
            pub id: uuid::Uuid,
            pub event: String,
            pub data: serde_json::Value,
            pub resource: Option<String>,
            pub record_id: Option<String>,
            pub actor_id: Option<uuid::Uuid>,
            pub tenant_id: Option<uuid::Uuid>,
            pub occurred_at: chrono::DateTime<chrono::Utc>,
            #[serde(skip_serializing)]
            resource_model: bool,
        }

        struct RealtimeInner {
            sender: broadcast::Sender<RealtimeEvent>,
            database: Option<Database>,
            source_id: uuid::Uuid,
        }

        #[derive(Clone)]
        pub struct RealtimeState { inner: std::sync::Arc<RealtimeInner> }
    }
}

fn state_impl() -> TokenStream {
    quote! {
        impl Default for RealtimeState {
            fn default() -> Self { Self::build(None) }
        }
        impl RealtimeState {
            pub(crate) fn new(database: Database) -> Self {
                let state = Self::build(Some(database));
                state.spawn_fanout();
                state
            }
            fn build(database: Option<Database>) -> Self {
                let (sender, _) = broadcast::channel(1_024);
                Self { inner: std::sync::Arc::new(RealtimeInner {
                    sender, database, source_id: uuid::Uuid::now_v7(),
                }) }
            }
            fn spawn_fanout(&self) {
                let weak = std::sync::Arc::downgrade(&self.inner);
                if let Ok(runtime) = tokio::runtime::Handle::try_current() {
                    runtime.spawn(fanout_events(weak));
                } else {
                    tracing::warn!("realtime database fan-out requires a Tokio runtime");
                }
            }
            pub fn publish<T: Serialize>(
                &self, event: &str, data: &T, actor_id: Option<uuid::Uuid>,
                tenant_id: Option<uuid::Uuid>,
            ) -> Result<RealtimeEvent, serde_json::Error> {
                let resource = infer_resource(event);
                self.publish_scoped(event, resource, None, data, actor_id, tenant_id)
            }
            fn publish_scoped<T: Serialize>(
                &self, event: &str, resource: Option<&str>, record_id: Option<&str>,
                data: &T, actor_id: Option<uuid::Uuid>, tenant_id: Option<uuid::Uuid>,
            ) -> Result<RealtimeEvent, serde_json::Error> {
                self.dispatch(RealtimeEvent {
                    id: uuid::Uuid::now_v7(), event: event.to_owned(),
                    data: serde_json::to_value(data)?, resource: resource.map(str::to_owned),
                    record_id: record_id.map(str::to_owned), actor_id, tenant_id,
                    occurred_at: chrono::Utc::now(), resource_model: false,
                })
            }
            pub(crate) fn publish_resource_model<T: Serialize>(
                &self, event: &str, resource: &str, record_id: &str, data: &T,
                actor_id: Option<uuid::Uuid>, tenant_id: Option<uuid::Uuid>,
            ) -> Result<RealtimeEvent, serde_json::Error> {
                self.dispatch(RealtimeEvent {
                    id: uuid::Uuid::now_v7(), event: event.to_owned(),
                    data: serde_json::to_value(data)?, resource: Some(resource.to_owned()),
                    record_id: Some(record_id.to_owned()), actor_id, tenant_id,
                    occurred_at: chrono::Utc::now(), resource_model: true,
                })
            }
            fn dispatch(
                &self, event: RealtimeEvent,
            ) -> Result<RealtimeEvent, serde_json::Error> {
                let _ = self.inner.sender.send(event.clone());
                if let Some(database) = self.inner.database.clone() {
                    let persisted = event.clone();
                    let source_id = self.inner.source_id;
                    if let Ok(runtime) = tokio::runtime::Handle::try_current() {
                        runtime.spawn(async move {
                            if let Err(error) = persist_event(&database, source_id, &persisted).await {
                                tracing::warn!(?error, event = %persisted.event, "realtime event persistence failed");
                            }
                        });
                    }
                }
                Ok(event)
            }
            fn subscribe(&self) -> broadcast::Receiver<RealtimeEvent> {
                self.inner.sender.subscribe()
            }
        }
    }
}

fn persistence(inferred_resources: &[TokenStream]) -> TokenStream {
    quote! {
        fn infer_resource(event: &str) -> Option<&'static str> {
            match event.split_once('.').map_or(event, |(prefix, _)| prefix) {
                #(#inferred_resources,)*
                _ => None,
            }
        }

        async fn persist_event(
            database: &Database, source_id: uuid::Uuid, event: &RealtimeEvent,
        ) -> Result<(), DbErr> {
            database.execute(Sql::bind("INSERT INTO \"_appstruct_realtime_events\" (id, source_id, event, data, resource, record_id, actor_id, tenant_id, occurred_at, resource_model) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)",
                [event.id.into(), source_id.into(), event.event.clone().into(),
                 event.data.clone().into(), event.resource.clone().into(),
                 event.record_id.clone().into(), event.actor_id.into(), event.tenant_id.into(),
                 event.occurred_at.into(), event.resource_model.into()],
            )).await?;
            Ok(())
        }
    }
}

fn fanout() -> TokenStream {
    quote! {
        async fn fanout_events(inner: std::sync::Weak<RealtimeInner>) {
            let mut sequence = None;
            let base_delay = Duration::from_millis(100);
            let max_delay = Duration::from_secs(2);
            let mut idle_delay = base_delay;
            let mut last_cleanup = tokio::time::Instant::now();
            loop {
                let Some(inner) = inner.upgrade() else { break };
                let Some(database) = inner.database.clone() else { break };
                let source_id = inner.source_id;
                let sender = inner.sender.clone();
                drop(inner);
                if sequence.is_none() {
                    match latest_event_sequence(&database).await {
                        Ok(latest) => sequence = Some(latest),
                        Err(error) => {
                            tracing::warn!(?error, "realtime fan-out cursor initialization failed");
                            tokio::time::sleep(Duration::from_millis(100)).await;
                            continue;
                        }
                    }
                }
                match load_events(&database, sequence.unwrap_or_default()).await {
                    Ok(events) => {
                        let count = events.len();
                        for (next_sequence, event_source, event) in events {
                            sequence = Some(next_sequence);
                            if event_source != source_id { let _ = sender.send(event); }
                        }
                        if count > 0 {
                            idle_delay = base_delay;
                            if count == 256 { continue; }
                        }
                    }
                    Err(error) => tracing::warn!(?error, "realtime fan-out poll failed"),
                }
                if last_cleanup.elapsed() >= Duration::from_secs(60) {
                    let _ = database.execute_unprepared(
                        "DELETE FROM \"_appstruct_realtime_events\" WHERE occurred_at < CURRENT_TIMESTAMP - INTERVAL '5 minutes'",
                    ).await;
                    last_cleanup = tokio::time::Instant::now();
                }
                let sleep_for = idle_delay;
                idle_delay = idle_delay.saturating_mul(2).min(max_delay);
                tokio::time::sleep(sleep_for).await;
            }
        }

        async fn latest_event_sequence(database: &Database) -> Result<i64, DbErr> {
            let row = database.fetch_optional(Sql::new("SELECT COALESCE(MAX(sequence), 0) AS sequence FROM \"_appstruct_realtime_events\"".to_owned(),
            )).await?.ok_or_else(|| DbErr::Protocol("realtime cursor query returned no row".to_owned()))?;
            row.try_get("sequence")
        }

        async fn load_events(
            database: &Database, sequence: i64,
        ) -> Result<Vec<(i64, uuid::Uuid, RealtimeEvent)>, DbErr> {
            let rows = database.fetch_all(Sql::bind("SELECT sequence, id, source_id, event, data, resource, record_id, actor_id, tenant_id, occurred_at, resource_model FROM \"_appstruct_realtime_events\" WHERE sequence > $1 ORDER BY sequence LIMIT 256",
                [sequence.into()],
            )).await?;
            rows.into_iter().map(|row| Ok((
                row.try_get("sequence")?, row.try_get("source_id")?,
                RealtimeEvent {
                    id: row.try_get("id")?, event: row.try_get("event")?,
                    data: row.try_get("data")?, resource: row.try_get("resource")?,
                    record_id: row.try_get("record_id")?, actor_id: row.try_get("actor_id")?,
                    tenant_id: row.try_get("tenant_id")?, occurred_at: row.try_get("occurred_at")?,
                    resource_model: row.try_get("resource_model")?,
                },
            ))).collect()
        }
    }
}