appstruct-codegen 0.2.0

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

#[allow(clippy::too_many_lines)]
pub(super) fn source(renderer: appstruct_ir::ReportRendererIr) -> TokenStream {
    let adapter = (renderer == appstruct_ir::ReportRendererIr::Chromium)
        .then(|| quote! { #[cfg_attr(not(unix), allow(dead_code, unused_imports))] mod adapter; });
    let render = match renderer {
        appstruct_ir::ReportRendererIr::Capture => {
            quote! { render_capture_pdf(work.id, &work.body, &input, &work.locale, &work.timezone, &work.paper, &work.orientation) }
        }
        appstruct_ir::ReportRendererIr::Chromium => quote! { adapter::render(&work, &input).await },
    };
    let lifecycle = super::lifecycle::source();
    quote! {
        #adapter
        #lifecycle
        #[derive(Clone)]
        pub(crate) struct ReportJobHandler {
            database: crate::database::Database,
            file: crate::FileState,
        }

        impl ReportJobHandler {
            pub(crate) fn new(
                database: crate::database::Database, file: crate::FileState,
            ) -> Self { Self { database, file } }

            async fn render(&self, job: &crate::Job) -> Result<(), String> {
                let payload: ReportJobPayload = serde_json::from_value(job.payload.clone())
                    .map_err(|_| "REPORT_JOB_PAYLOAD_INVALID".to_owned())?;
                let work = load_report_work(&self.database, job, payload.run_id).await?;
                if matches!(work.stage.as_str(), "succeeded" | "cancelled") { return Ok(()); }
                ensure_render_active(&self.database, job, work.id).await?;
                let configured = REPORT_TEMPLATES.iter().any(|template| template.name == work.template
                    && i32::try_from(template.version).ok() == Some(work.template_version)
                    && template.artifact_digest == work.artifact_digest && template.body == work.body);
                if !configured || work.renderer_version != REPORT_RENDERER_VERSION { return Err("REPORT_INVALID_TEMPLATE_ARTIFACT".into()); }
                update_report_stage(&self.database, work.id, "rendering", 10, None).await?;
                let snapshot = decrypt_snapshot(work.id, &work.snapshot_ciphertext)?;
                if sha256_hex(&snapshot) != work.snapshot_digest {
                    return Err("REPORT_SNAPSHOT_INVALID".to_owned());
                }
                let input: serde_json::Value = serde_json::from_slice(&snapshot)
                    .map_err(|_| "REPORT_SNAPSHOT_INVALID".to_owned())?;
                let content = tokio::select! {
                    result = async { #render } => result?,
                    error = wait_for_render_stop(&self.database, job, work.id) => return Err(error),
                };
                if content.len() as u64 > REPORT_MAX_OUTPUT_BYTES { return Err("REPORT_RESOURCE_LIMIT".into()); }
                publish_report(&self.database, &self.file, job, &work, &content).await
            }
        }

        #[async_trait::async_trait]
        impl crate::JobHandler for ReportJobHandler {
            async fn handle(&self, job: &crate::Job) -> Result<(), crate::JobHandlerError> {
                if job.kind == "report.cleanup" {
                    return cleanup_expired_reports(&self.database, &self.file)
                        .await.map_err(crate::JobHandlerError);
                }
                let result = self.render(job).await;
                if let Err(code) = &result {
                    if let Ok(payload) = serde_json::from_value::<ReportJobPayload>(job.payload.clone()) {
                        let stage = if job.attempts >= job.max_attempts || !retryable_job_error(&job.kind, code) { "failed" } else { "queued" };
                        let _ = update_report_failure(&self.database, job, payload.run_id, stage, code).await;
                    }
                }
                result.map_err(crate::JobHandlerError)
            }
        }

        async fn cleanup_expired_reports(
            database: &crate::database::Database, file: &crate::FileState,
        ) -> Result<(), String> {
            let rows = database.fetch_all(Sql::new("SELECT id, tenant_id, result_object_key FROM \"_appstruct_report_runs\" WHERE expires_at <= CURRENT_TIMESTAMP AND stage IN ('succeeded', 'failed', 'cancelled') ORDER BY expires_at, id LIMIT 100".to_owned(),
            )).await.map_err(|_| "REPORT_CLEANUP_LOAD_FAILED".to_owned())?;
            for row in rows {
                let id: uuid::Uuid = row.try_get("id")
                    .map_err(|_| "REPORT_CLEANUP_ROW_INVALID".to_owned())?;
                let tenant_id: Option<uuid::Uuid> = row.try_get("tenant_id")
                    .map_err(|_| "REPORT_CLEANUP_ROW_INVALID".to_owned())?;
                let object_key: Option<String> = row.try_get("result_object_key")
                    .map_err(|_| "REPORT_CLEANUP_ROW_INVALID".to_owned())?;
                let tenant = tenant_id.map_or_else(|| "global".to_owned(), |id| id.to_string());
                file.discard_unpublished(database, &format!("reports/{tenant}/{id}.pdf")).await
                    .map_err(|_| "REPORT_CLEANUP_FILE_FAILED".to_owned())?;
                if let Some(object_key) = object_key {
                    file.delete(&object_key, tenant_id).await
                        .map_err(|_| "REPORT_CLEANUP_FILE_FAILED".to_owned())?;
                }
                database.execute(Sql::bind(
                    "DELETE FROM \"_appstruct_report_runs\" WHERE id = $1 AND expires_at <= CURRENT_TIMESTAMP AND stage IN ('succeeded', 'failed', 'cancelled')",
                    [id.into()],
                )).await.map_err(|_| "REPORT_CLEANUP_DELETE_FAILED".to_owned())?;
            }
            Ok(())
        }

        struct ReportWork {
            id: uuid::Uuid,
            tenant_id: Option<uuid::Uuid>,
            template: String,
            template_version: i32,
            artifact_digest: String,
            renderer_version: String,
            body: String,
            snapshot_ciphertext: String,
            snapshot_digest: String,
            locale: String,
            timezone: String,
            paper: String,
            orientation: String,
            stage: String,
        }

        async fn load_report_work<C: DatabaseExecutor>(
            database: &C, job: &crate::Job, run_id: uuid::Uuid,
        ) -> Result<ReportWork, String> {
            let row = database.fetch_optional(Sql::bind(concat!(
                    "SELECT r.id, r.tenant_id, t.name AS template, t.version AS template_version, t.artifact_digest, t.renderer_version, t.body, r.snapshot_ciphertext, r.snapshot_digest, r.locale, r.timezone, r.paper::text AS paper, r.orientation::text AS orientation, r.stage::text AS stage ",
                    "FROM \"_appstruct_report_runs\" r JOIN \"_appstruct_report_templates\" t ON t.id = r.template_id WHERE r.id = $1 AND r.execution_job_id = $2 AND r.tenant_id IS NOT DISTINCT FROM $3"
                ),
                [run_id.into(), job.id.into(), job.tenant_id.into()],
            )).await.map_err(|_| "REPORT_RUN_LOAD_FAILED".to_owned())?
                .ok_or_else(|| "REPORT_RUN_NOT_FOUND".to_owned())?;
            Ok(ReportWork {
                id: row.try_get("id").map_err(|_| "REPORT_RUN_INVALID".to_owned())?,
                tenant_id: row.try_get("tenant_id").map_err(|_| "REPORT_RUN_INVALID".to_owned())?,
                template: row.try_get("template").map_err(|_| "REPORT_RUN_INVALID".to_owned())?,
                template_version: row.try_get("template_version").map_err(|_| "REPORT_RUN_INVALID".to_owned())?,
                artifact_digest: row.try_get("artifact_digest").map_err(|_| "REPORT_RUN_INVALID".to_owned())?,
                renderer_version: row.try_get("renderer_version").map_err(|_| "REPORT_RUN_INVALID".to_owned())?,
                body: row.try_get("body").map_err(|_| "REPORT_RUN_INVALID".to_owned())?,
                snapshot_ciphertext: row.try_get("snapshot_ciphertext").map_err(|_| "REPORT_RUN_INVALID".to_owned())?,
                snapshot_digest: row.try_get("snapshot_digest").map_err(|_| "REPORT_RUN_INVALID".to_owned())?,
                locale: row.try_get("locale").map_err(|_| "REPORT_RUN_INVALID".to_owned())?,
                timezone: row.try_get("timezone").map_err(|_| "REPORT_RUN_INVALID".to_owned())?,
                paper: row.try_get("paper").map_err(|_| "REPORT_RUN_INVALID".to_owned())?,
                orientation: row.try_get("orientation").map_err(|_| "REPORT_RUN_INVALID".to_owned())?,
                stage: row.try_get("stage").map_err(|_| "REPORT_RUN_INVALID".to_owned())?,
            })
        }

        async fn update_report_stage<C: DatabaseExecutor>(
            database: &C, id: uuid::Uuid, stage: &str, progress: i32, error_code: Option<&str>,
        ) -> Result<(), String> {
            database.execute(Sql::bind("UPDATE \"_appstruct_report_runs\" SET stage = $2, progress = $3, error_code = $4, completed_at = CASE WHEN $2 IN ('failed', 'cancelled') THEN CURRENT_TIMESTAMP ELSE completed_at END WHERE id = $1 AND stage <> 'cancelled'",
                [id.into(), stage.to_owned().into(), progress.into(), error_code.map(str::to_owned).into()],
            )).await.map_err(|_| "REPORT_STATE_UPDATE_FAILED".to_owned())?;
            Ok(())
        }
    }
}