appstruct-codegen 0.1.0

Deterministic Rust, SQL, OpenAPI, TypeScript, and React generation for AppStruct
Documentation
use super::{find_entity, render};
use crate::{Artifact, ArtifactKind, CodegenError};
use appstruct_ir::AppIr;
use quote::quote;

pub(super) fn plan(ir: &AppIr) -> Result<Vec<Artifact>, CodegenError> {
    if !ir.auth.enabled {
        return Ok(vec![Artifact::text(
            "backend/src/auth.rs",
            disabled_source()?,
            ArtifactKind::RustSource,
        )]);
    }
    Ok(vec![
        generated(
            "backend/src/auth/config.rs",
            config_source(ir).map_err(|error| {
                CodegenError::new(format!("auth config generation failed: {error}"))
            })?,
        ),
        generated("backend/src/auth/mod.rs", template("auth/mod.rs")?),
        generated("backend/src/auth/session.rs", template("auth/session.rs")?),
        generated(
            "backend/src/auth/handlers.rs",
            handlers_template(ir.auth.oauth_enabled)?,
        ),
        generated("backend/src/auth/mail.rs", template("auth/mail.rs")?),
    ])
}

fn generated(path: &str, content: String) -> Artifact {
    Artifact::text(path, content, ArtifactKind::RustSource)
}

fn config_source(ir: &AppIr) -> Result<String, CodegenError> {
    let user_id = ir
        .auth
        .user_entity
        .as_ref()
        .expect("compiler requires auth user entity");
    let user = find_entity(ir, &user_id.0)?;
    let id = user
        .fields
        .iter()
        .find(|field| field.primary_key)
        .expect("compiler requires auth user primary key");
    let email = user
        .fields
        .iter()
        .find(|field| field.api_name == "email")
        .expect("compiler requires auth user email");
    let registration = ir.auth.registration_enabled;
    let password_reset = ir.auth.password_reset_enabled;
    let oauth = ir.auth.oauth_enabled;
    let jobs = ir.jobs.enabled;
    let mail = ir.mail.enabled;
    let file = ir.file.enabled;
    let tenant = ir.tenant.enabled;
    let audit = ir.audit.enabled;
    let default_role = ir
        .auth
        .default_role
        .as_deref()
        .expect("compiler requires default role");
    let user_table = &user.table_name;
    let user_id_column = &id.column_name;
    let user_email_column = &email.column_name;
    render(quote! {
        pub const REGISTRATION_ENABLED: bool = #registration;
        pub const PASSWORD_RESET_ENABLED: bool = #password_reset;
        #[allow(dead_code)]
        pub const OAUTH_ENABLED: bool = #oauth;
        pub const JOBS_ENABLED: bool = #jobs;
        pub const MAIL_ENABLED: bool = #mail;
        pub const FILE_ENABLED: bool = #file;
        pub const TENANT_ENABLED: bool = #tenant;
        pub const AUDIT_ENABLED: bool = #audit;
        pub const DEFAULT_ROLE: &str = #default_role;
        pub const USER_TABLE: &str = #user_table;
        pub const USER_ID_COLUMN: &str = #user_id_column;
        pub const USER_EMAIL_COLUMN: &str = #user_email_column;
    })
}

fn disabled_source() -> Result<String, CodegenError> {
    render(quote! {
        use crate::{Actor, ApiError, AppState};
        use axum::{Router, http::HeaderMap};
        use sea_orm::DatabaseConnection;
        use tower_http::cors::CorsLayer;

        #[derive(Clone, Default)]
        pub struct AuthState;

        impl AuthState {
            pub fn from_env() -> Result<Self, String> { Ok(Self) }
            pub async fn actor(
                &self,
                _database: &DatabaseConnection,
                _headers: &HeaderMap,
            ) -> Result<Option<Actor>, ApiError> { Ok(None) }
            pub async fn verify_csrf(
                &self,
                _database: &DatabaseConnection,
                _headers: &HeaderMap,
            ) -> Result<(), ApiError> { Ok(()) }
            pub fn cors_layer(&self) -> CorsLayer { CorsLayer::permissive() }
        }

        pub fn router() -> Router<AppState> { Router::new() }
    })
}

fn template(name: &str) -> Result<String, CodegenError> {
    let source = match name {
        "auth/mod.rs" => include_str!("../../templates/backend/auth/mod.rs"),
        "auth/session.rs" => include_str!("../../templates/backend/auth/session.rs"),
        "auth/handlers.rs" => include_str!("../../templates/backend/auth/handlers.rs"),
        "auth/mail.rs" => include_str!("../../templates/backend/auth/mail.rs"),
        _ => unreachable!(),
    };
    super::rust_template(source)
}

fn handlers_template(oauth_enabled: bool) -> Result<String, CodegenError> {
    let source = include_str!("../../templates/backend/auth/handlers.rs");
    if oauth_enabled {
        return super::rust_template(source);
    }
    let source = strip_oauth_sections(source)?;
    super::rust_template(&source)
}

fn strip_oauth_sections(source: &str) -> Result<String, CodegenError> {
    const START: &str = "// appstruct:oauth:start";
    const END: &str = "// appstruct:oauth:end";
    let mut output = String::with_capacity(source.len());
    let mut remaining = source;
    while let Some(start) = remaining.find(START) {
        output.push_str(&remaining[..start]);
        let after_start = &remaining[start + START.len()..];
        let end = after_start.find(END).ok_or_else(|| {
            CodegenError::new("auth OAuth template section is missing its end marker")
        })?;
        remaining = &after_start[end + END.len()..];
    }
    output.push_str(remaining);
    Ok(output)
}