appstruct-codegen 0.1.0

Deterministic Rust, SQL, OpenAPI, TypeScript, and React generation for AppStruct
Documentation
use super::{find_entity, module_name, optional_type, parse_ident, render, rust_type};
use crate::CodegenError;
use appstruct_ir::{AppIr, Cardinality, EntityIr, FieldIr, GeneratedValueIr, RelationIr};
use proc_macro2::{Span, TokenStream};
use quote::quote;
use syn::LitStr;

pub(super) fn source(ir: &AppIr, entity: &EntityIr) -> Result<String, CodegenError> {
    let table = LitStr::new(&entity.table_name, Span::call_site());
    let fields = entity
        .fields
        .iter()
        .map(entity_field)
        .collect::<Result<Vec<_>, _>>()?;
    let relations = relation_fields(ir, entity)?;
    render(quote! {
        use sea_orm::entity::prelude::*;
        use serde::{Deserialize, Serialize};

        #[sea_orm::model]
        #[derive(Clone, Debug, PartialEq, DeriveEntityModel, Serialize, Deserialize)]
        #[sea_orm(table_name = #table)]
        pub struct Model {
            #(#fields,)*
            #(#relations,)*
        }

        impl ActiveModelBehavior for ActiveModel {}
    })
}

fn entity_field(field: &FieldIr) -> Result<TokenStream, CodegenError> {
    let name = parse_ident(&field.rust_name)?;
    let ty = optional_type(rust_type(&field.ty), field.nullable);
    let column = LitStr::new(&field.column_name, Span::call_site());
    let attributes = if field.primary_key {
        let auto_increment = matches!(field.generated, Some(GeneratedValueIr::AutoIncrement));
        quote! { #[sea_orm(primary_key, auto_increment = #auto_increment, column_name = #column)] }
    } else if field.unique {
        quote! { #[sea_orm(unique, column_name = #column)] }
    } else {
        quote! { #[sea_orm(column_name = #column)] }
    };
    Ok(quote! { #attributes pub #name: #ty })
}

fn relation_fields(ir: &AppIr, entity: &EntityIr) -> Result<Vec<TokenStream>, CodegenError> {
    let mut fields = Vec::new();
    for relation in &ir.relations {
        if relation.source == entity.id {
            fields.push(belongs_to_field(ir, entity, relation)?);
        }
        if relation.target == entity.id {
            fields.push(inverse_relation_field(ir, relation)?);
        }
    }
    Ok(fields)
}

fn belongs_to_field(
    ir: &AppIr,
    entity: &EntityIr,
    relation: &RelationIr,
) -> Result<TokenStream, CodegenError> {
    let source_field = entity
        .fields
        .iter()
        .find(|field| relation.foreign_key_fields.contains(&field.id))
        .ok_or_else(|| CodegenError::new(format!("missing field for `{}`", relation.id.0)))?;
    let target = find_entity(ir, &relation.target.0)?;
    let target_key = target
        .fields
        .iter()
        .find(|field| field.primary_key)
        .ok_or_else(|| CodegenError::new(format!("missing key for `{}`", target.id)))?;
    let relation_name = source_field
        .rust_name
        .strip_suffix("_id")
        .unwrap_or(&source_field.rust_name);
    let name = parse_ident(relation_name)?;
    let from = LitStr::new(&source_field.rust_name, Span::call_site());
    let to = LitStr::new(&target_key.rust_name, Span::call_site());
    let target_module = parse_ident(&module_name(target))?;
    Ok(quote! {
        #[sea_orm(belongs_to, from = #from, to = #to)]
        pub #name: BelongsTo<super::#target_module::Entity>
    })
}

fn inverse_relation_field(ir: &AppIr, relation: &RelationIr) -> Result<TokenStream, CodegenError> {
    let source = find_entity(ir, &relation.source.0)?;
    let source_module = parse_ident(&module_name(source))?;
    match relation.cardinality {
        Cardinality::OneToOne => {
            let name = source_module.clone();
            Ok(quote! {
                #[sea_orm(has_one)]
                pub #name: HasOne<super::#source_module::Entity>
            })
        }
        Cardinality::ManyToOne => {
            let name = parse_ident(&source.table_name)?;
            Ok(quote! {
                #[sea_orm(has_many)]
                pub #name: HasMany<super::#source_module::Entity>
            })
        }
    }
}