appstruct-codegen 0.1.0

Deterministic Rust, SQL, OpenAPI, TypeScript, and React generation for AppStruct
Documentation
mod access;
mod api;
mod audit;
mod auth;
mod context;
mod entity;
mod extensions;
mod file;
mod jobs;
mod mail;
mod manifest;
mod operations;
mod query;
mod runtime;
mod startup;
mod tenant;
mod validation;

use crate::{Artifact, ArtifactKind, CodegenError, format_rust, generated_header};
use appstruct_ir::{AppIr, EntityIr, FieldTypeIr};
use proc_macro2::{Ident, Span, TokenStream};
use quote::quote;
use syn::LitStr;

pub(crate) fn plan(ir: &AppIr) -> Result<Vec<Artifact>, CodegenError> {
    let mut artifacts = vec![
        Artifact::text(
            "backend/Cargo.toml",
            manifest::cargo(ir),
            ArtifactKind::RustManifest,
        ),
        Artifact::text(
            "backend/runtime/Cargo.toml",
            manifest::runtime_cargo(),
            ArtifactKind::RustManifest,
        ),
        Artifact::text(
            "backend/contracts/Cargo.toml",
            manifest::contracts_cargo(),
            ArtifactKind::RustManifest,
        ),
        Artifact::text(
            "backend/contracts/src/lib.rs",
            embedded_crate_source(appstruct_contracts::__source::LIB),
            ArtifactKind::RustSource,
        ),
    ];
    artifacts.extend(embedded_runtime_artifacts());
    artifacts.extend([
        Artifact::text(
            "server/Cargo.toml",
            manifest::server_cargo(),
            ArtifactKind::RustManifest,
        ),
        Artifact::text(
            "server/src/main.rs",
            rust_template(include_str!("../templates/backend/server_main.rs"))?,
            ArtifactKind::RustSource,
        ),
        Artifact::text(
            "backend/src/main.rs",
            rust_template(include_str!("../templates/backend/main.rs"))?,
            ArtifactKind::RustSource,
        ),
        Artifact::text(
            "backend/src/error.rs",
            rust_template(include_str!("../templates/backend/error.rs"))?,
            ArtifactKind::RustSource,
        ),
        Artifact::text(
            "backend/src/entities/mod.rs",
            module_source(ir)?,
            ArtifactKind::RustSource,
        ),
        Artifact::text(
            "backend/src/api/mod.rs",
            module_source(ir)?,
            ArtifactKind::RustSource,
        ),
        Artifact::text(
            "backend/src/lib.rs",
            library_source(ir)?,
            ArtifactKind::RustSource,
        ),
        Artifact::text(
            "backend/src/openapi.rs",
            crate::openapi::rust_source(ir)?,
            ArtifactKind::RustSource,
        ),
        Artifact::text(
            "backend/src/extensions.rs",
            extensions::source(ir)?,
            ArtifactKind::RustSource,
        ),
        Artifact::text(
            "backend/src/operations.rs",
            operations::source(ir)?,
            ArtifactKind::RustSource,
        ),
    ]);
    artifacts.extend(audit::plan(ir)?);
    artifacts.extend(auth::plan(ir)?);
    artifacts.extend(file::plan(ir)?);
    artifacts.extend(jobs::plan(ir)?);
    artifacts.extend(mail::plan(ir)?);
    artifacts.extend(tenant::plan(ir)?);
    artifacts.extend(entity_artifacts(ir)?);
    Ok(artifacts)
}

fn embedded_runtime_artifacts() -> [Artifact; 3] {
    [
        Artifact::text(
            "backend/runtime/src/lib.rs",
            embedded_crate_source(appstruct_runtime::__source::LIB),
            ArtifactKind::RustSource,
        ),
        Artifact::text(
            "backend/runtime/src/lifecycle.rs",
            format!(
                "{}{}",
                generated_header("//"),
                appstruct_runtime::__source::LIFECYCLE
            ),
            ArtifactKind::RustSource,
        ),
        Artifact::text(
            "backend/runtime/src/supervisor.rs",
            format!(
                "{}{}",
                generated_header("//"),
                appstruct_runtime::__source::SUPERVISOR
            ),
            ArtifactKind::RustSource,
        ),
    ]
}

fn embedded_crate_source(source: &str) -> String {
    let source = source
        .lines()
        .map(|line| {
            line.strip_prefix("//!")
                .map_or(line.to_owned(), |line| format!("//{line}"))
        })
        .collect::<Vec<_>>()
        .join("\n");
    format!("{}{}\n", generated_header("//"), source)
}

fn entity_artifacts(ir: &AppIr) -> Result<Vec<Artifact>, CodegenError> {
    if ir.entities.is_empty() {
        return Ok(Vec::new());
    }
    let workers = std::thread::available_parallelism()
        .map_or(1, usize::from)
        .min(ir.entities.len());
    let chunk_size = ir.entities.len().div_ceil(workers);
    std::thread::scope(|scope| {
        let handles = ir
            .entities
            .chunks(chunk_size)
            .map(|entities| {
                scope.spawn(move || {
                    entities
                        .iter()
                        .map(|entity| plan_entity(ir, entity))
                        .collect::<Result<Vec<_>, _>>()
                })
            })
            .collect::<Vec<_>>();
        let mut artifacts = Vec::with_capacity(ir.entities.len() * 2);
        for handle in handles {
            let planned = handle
                .join()
                .map_err(|_| CodegenError::new("backend generation worker panicked"))??;
            artifacts.extend(planned.into_iter().flatten());
        }
        Ok(artifacts)
    })
}

fn plan_entity(ir: &AppIr, entity: &EntityIr) -> Result<[Artifact; 2], CodegenError> {
    let module = module_name(entity);
    let entity_source = entity::source(ir, entity)
        .map_err(|error| CodegenError::new(format!("entity `{module}` failed: {error}")))?;
    let api_source = api::source(ir, entity)
        .map_err(|error| CodegenError::new(format!("API `{module}` failed: {error}")))?;
    Ok([
        Artifact::text(
            format!("backend/src/entities/{module}.rs"),
            entity_source,
            ArtifactKind::RustSource,
        ),
        Artifact::text(
            format!("backend/src/api/{module}.rs"),
            api_source,
            ArtifactKind::RustSource,
        ),
    ])
}

fn module_source(ir: &AppIr) -> Result<String, CodegenError> {
    let modules = ir
        .entities
        .iter()
        .map(|entity| format!("pub mod {};", module_name(entity)))
        .collect::<Vec<_>>()
        .join("\n");
    format_rust(&format!("{}{}\n", generated_header("//"), modules))
}

fn library_source(ir: &AppIr) -> Result<String, CodegenError> {
    let routes = ir
        .entities
        .iter()
        .map(|entity| {
            let module = parse_ident(&module_name(entity))?;
            let path = LitStr::new(&format!("/api/{}/", entity.table_name), Span::call_site());
            Ok(quote! { .nest(#path, api::#module::router()) })
        })
        .collect::<Result<Vec<_>, CodegenError>>()?;
    let auth_exports = if ir.auth.enabled {
        quote! { pub use auth::{AuthMailSender, AuthState, DevMailSender, SmtpMailSender}; }
    } else {
        quote! { pub use auth::AuthState; }
    };
    let service_exports = service_exports(ir);
    let runtime = runtime::source(ir, &routes)?;
    let runtime_api_version = appstruct_runtime::RUNTIME_API_VERSION;
    render(quote! {
        pub mod api;
        pub mod entities;
        pub mod extensions;
        mod audit;
        mod auth;
        mod error;
        mod file;
        mod jobs;
        mod mail;
        mod openapi;
        mod operations;
        mod tenant;

        pub use error::{ApiError, FieldViolation};
        pub use appstruct_runtime::{
            Actor, BackgroundTaskExit, BackgroundTaskExitKind, BackgroundTaskObserver,
            ModuleDescriptor, ModuleEvent, ModuleObserver, ModulePhase, ModulePlan, ModuleRuntime,
            ModuleStarter, RUNTIME_API_VERSION, ServiceHandle, ServiceHandles, ShutdownError,
            ShutdownFailure, ShutdownFailureKind, ShutdownReport, StartupError,
            SupervisedTaskHandle, TenantId,
        };
        pub const GENERATED_RUNTIME_API_VERSION: u32 = #runtime_api_version;
        const _: [(); GENERATED_RUNTIME_API_VERSION as usize] =
            [(); appstruct_runtime::RUNTIME_API_VERSION as usize];
        pub use extensions::{AppExtensions, HookOperation, RequestContext};
        #service_exports
        #auth_exports
        #runtime
    })
}

fn service_exports(ir: &AppIr) -> TokenStream {
    let mail_job_exports = (ir.jobs.enabled && ir.mail.enabled).then(|| {
        quote! { pub use jobs::{MailJobHandler, MailJobPayload}; }
    });
    quote! {
        pub use file::{FileError, FileMetadata, FileProvider, FileState};
        pub use jobs::{
            Job, JobError, JobHandler, JobHandlerError, JobReceipt, JobWorker, JobWorkerHandle,
        };
        #mail_job_exports
        pub use mail::{MailDelivery, MailError, MailMessage, MailProvider, MailState};
    }
}

pub(super) fn rust_type(field_type: &FieldTypeIr) -> TokenStream {
    match field_type {
        FieldTypeIr::Uuid | FieldTypeIr::Relation { .. } => quote! { uuid::Uuid },
        FieldTypeIr::String | FieldTypeIr::Text | FieldTypeIr::Enum { .. } => quote! { String },
        FieldTypeIr::Integer => quote! { i32 },
        FieldTypeIr::Bigint => quote! { i64 },
        FieldTypeIr::Decimal => quote! { rust_decimal::Decimal },
        FieldTypeIr::Boolean => quote! { bool },
        FieldTypeIr::Date => quote! { chrono::NaiveDate },
        FieldTypeIr::Datetime => quote! { chrono::DateTime<chrono::Utc> },
        FieldTypeIr::Json => quote! { serde_json::Value },
    }
}

pub(super) fn optional_type(base: TokenStream, nullable: bool) -> TokenStream {
    if nullable {
        quote! { Option<#base> }
    } else {
        base
    }
}

pub(super) fn find_entity<'ir>(ir: &'ir AppIr, id: &str) -> Result<&'ir EntityIr, CodegenError> {
    ir.entities
        .iter()
        .find(|entity| entity.id.0 == id)
        .ok_or_else(|| CodegenError::new(format!("missing entity `{id}`")))
}

pub(super) fn module_name(entity: &EntityIr) -> String {
    let mut output = String::new();
    for (index, character) in entity.rust_name.chars().enumerate() {
        if character.is_ascii_uppercase() {
            if index > 0 {
                output.push('_');
            }
            output.push(character.to_ascii_lowercase());
        } else {
            output.push(character);
        }
    }
    output
}

pub(super) fn parse_ident(value: &str) -> Result<Ident, CodegenError> {
    syn::parse_str(value)
        .map_err(|error| CodegenError::new(format!("invalid Rust identifier `{value}`: {error}")))
}

pub(super) fn render(tokens: TokenStream) -> Result<String, CodegenError> {
    let syntax = syn::parse2(tokens)
        .map_err(|error| CodegenError::new(format!("generated Rust did not parse: {error}")))?;
    Ok(format!(
        "{}{}",
        generated_header("//"),
        prettyplease::unparse(&syntax)
    ))
}

fn rust_template(source: &str) -> Result<String, CodegenError> {
    format_rust(&format!("{}{}", generated_header("//"), source))
}