appstruct-codegen 0.1.0

Deterministic Rust, SQL, OpenAPI, TypeScript, and React generation for AppStruct
Documentation
use crate::generated_header;
use appstruct_ir::{AccessRuleIr, AppIr, EntityIr, FieldIr, FieldTypeIr, GeneratedValueIr};
use std::fmt::Write;

pub(super) fn source(ir: &AppIr) -> String {
    let imports = ir
        .entities
        .iter()
        .map(|entity| {
            format!(
                "import {{ {}Api }} from \"./client\";",
                lower_camel(&entity.rust_name)
            )
        })
        .collect::<Vec<_>>()
        .join("\n");
    let resources = ir
        .entities
        .iter()
        .map(resource_source)
        .collect::<Vec<_>>()
        .join(",\n");
    format!(
        "{}import type {{ AccessRule, ResourceApi, ResourceDefinition }} from \"../resource\";\n{}\n\nexport const resources: ResourceDefinition[] = [\n{}\n];\n\nexport const auditAccess: AccessRule = {};\n",
        generated_header("//"),
        imports,
        indent(&resources, 2),
        audit_access_source(ir),
    )
}

fn resource_source(entity: &EntityIr) -> String {
    let fields = entity
        .fields
        .iter()
        .filter(|field| {
            !matches!(
                field.generated,
                Some(GeneratedValueIr::Revision | GeneratedValueIr::Tenant)
            )
        })
        .map(field_source)
        .collect::<Vec<_>>()
        .join(",\n");
    let primary_key = entity
        .fields
        .iter()
        .find(|field| field.primary_key)
        .map_or("id", |field| field.rust_name.as_str());
    let api = format!("{}Api", lower_camel(&entity.rust_name));
    format!(
        "{{\n  id: {:?},\n  name: {:?},\n  label: {:?},\n  slug: {:?},\n  primaryKey: {:?},\n  softDelete: {},\n  access: {},\n  fields: [\n{}\n  ],\n  api: {} as unknown as ResourceApi,\n}}",
        entity.id.0,
        entity.rust_name,
        entity.label,
        entity.table_name,
        primary_key,
        entity.views.soft_delete,
        serde_json::to_string(&entity.access).expect("access IR is serializable"),
        indent(&fields, 4),
        api,
    )
}

fn audit_access_source(ir: &AppIr) -> String {
    let rules = ir
        .audit
        .reader_roles
        .iter()
        .map(|role| AccessRuleIr::Role { role: role.clone() })
        .collect::<Vec<_>>();
    let rule = match rules.as_slice() {
        [rule] => rule.clone(),
        _ => AccessRuleIr::Any { rules },
    };
    serde_json::to_string(&rule).expect("access IR is serializable")
}

fn field_source(field: &FieldIr) -> String {
    let mut properties = vec![
        format!("name: {:?}", field.rust_name),
        format!("label: {:?}", humanize(&field.api_name)),
        format!("kind: {:?}", field_kind(&field.ty)),
        format!("required: {}", !field.nullable && field.default.is_none()),
        format!("readOnly: {}", field.generated.is_some()),
        format!("primaryKey: {}", field.primary_key),
        format!("searchable: {}", field.capabilities.searchable),
        format!("filterable: {}", field.capabilities.filterable),
        format!("sortable: {}", field.capabilities.sortable),
    ];
    if let FieldTypeIr::Enum { values } = &field.ty {
        properties.push(format!("values: {values:?}"));
    }
    if let FieldTypeIr::Relation { target } = &field.ty {
        properties.push(format!("relation: {:?}", target.0));
    }
    if let Some(minimum) = &field.validation.minimum {
        properties.push(format!("minimum: {minimum:?}"));
    }
    if let Some(maximum) = &field.validation.maximum {
        properties.push(format!("maximum: {maximum:?}"));
    }
    if let Some(component) = &field.ui_component {
        properties.push(format!("uiComponent: {component:?}"));
    }
    if let Some(access) = &field.read_access {
        properties.push(format!(
            "readAccess: {}",
            serde_json::to_string(access).expect("access IR is serializable")
        ));
    }
    if let Some(access) = &field.write_access {
        properties.push(format!(
            "writeAccess: {}",
            serde_json::to_string(access).expect("access IR is serializable")
        ));
    }
    format!("{{ {} }}", properties.join(", "))
}

fn field_kind(field_type: &FieldTypeIr) -> &'static str {
    match field_type {
        FieldTypeIr::Uuid => "uuid",
        FieldTypeIr::String => "string",
        FieldTypeIr::Text => "text",
        FieldTypeIr::Integer => "integer",
        FieldTypeIr::Bigint => "bigint",
        FieldTypeIr::Decimal => "decimal",
        FieldTypeIr::Boolean => "boolean",
        FieldTypeIr::Date => "date",
        FieldTypeIr::Datetime => "datetime",
        FieldTypeIr::Json => "json",
        FieldTypeIr::Enum { .. } => "enum",
        FieldTypeIr::Relation { .. } => "relation",
    }
}

fn lower_camel(value: &str) -> String {
    let mut characters = value.chars();
    characters.next().map_or_else(String::new, |first| {
        first.to_lowercase().chain(characters).collect()
    })
}

fn humanize(value: &str) -> String {
    let value = value.strip_suffix("_id").unwrap_or(value);
    let mut words = value.split('_');
    words.next().map_or_else(String::new, |first| {
        let mut characters = first.chars();
        let first = characters
            .next()
            .map_or_else(String::new, |character| character.to_uppercase().collect());
        let mut output = format!("{first}{}", characters.collect::<String>());
        for word in words {
            let _ = write!(output, " {word}");
        }
        output
    })
}

fn indent(value: &str, spaces: usize) -> String {
    let prefix = " ".repeat(spaces);
    value
        .lines()
        .map(|line| format!("{prefix}{line}"))
        .collect::<Vec<_>>()
        .join("\n")
}