appstruct-codegen 0.1.0

Deterministic Rust, SQL, OpenAPI, TypeScript, and React generation for AppStruct
Documentation
use super::{error_response, request_body, response, schema_ref};
use appstruct_ir::{AppIr, FieldTypeIr, OperationTypeIr, ValueFieldIr};
use serde_json::{Map, Value, json};

pub(super) fn add(ir: &AppIr, paths: &mut Map<String, Value>, schemas: &mut Map<String, Value>) {
    for value in &ir.value_objects {
        let properties = value
            .fields
            .iter()
            .map(|field| (field.rust_name.clone(), value_field_schema(field)))
            .collect::<Map<_, _>>();
        let required = value
            .fields
            .iter()
            .filter(|field| field.required)
            .map(|field| field.rust_name.clone())
            .collect::<Vec<_>>();
        schemas.insert(
            value.rust_name.clone(),
            json!({ "type": "object", "properties": properties, "required": required }),
        );
    }
    for command in &ir.commands {
        paths.insert(
            format!("/api/commands/{}", kebab_name(&command.rust_name)),
            json!({
                "post": {
                    "operationId": lower_camel(&command.rust_name),
                    "tags": ["Commands"],
                    "security": super::auth::security(&command.access),
                    "requestBody": request_body(&type_name(ir, &command.input)),
                    "responses": {
                        "200": response("Command result", &type_schema(ir, &command.output)),
                        "403": error_response(),
                        "422": error_response(),
                    }
                }
            }),
        );
    }
    for query in &ir.queries {
        let method = if let Some(input) = &query.input {
            json!({
                "operationId": lower_camel(&query.rust_name),
                "tags": ["Queries"],
                "security": super::auth::security(&query.access),
                "requestBody": request_body(&type_name(ir, input)),
                "responses": {
                    "200": response("Query result", &type_schema(ir, &query.output)),
                    "403": error_response(),
                }
            })
        } else {
            json!({
                "operationId": lower_camel(&query.rust_name),
                "tags": ["Queries"],
                "security": super::auth::security(&query.access),
                "responses": {
                    "200": response("Query result", &type_schema(ir, &query.output)),
                    "403": error_response(),
                }
            })
        };
        let verb = if query.input.is_some() { "post" } else { "get" };
        paths.insert(
            format!("/api/queries/{}", kebab_name(&query.rust_name)),
            Map::from_iter([(verb.to_owned(), method)]).into(),
        );
    }
}

fn value_field_schema(field: &ValueFieldIr) -> Value {
    let mut schema = match &field.ty {
        FieldTypeIr::Uuid | FieldTypeIr::Relation { .. } => {
            json!({ "type": "string", "format": "uuid" })
        }
        FieldTypeIr::String | FieldTypeIr::Text => json!({ "type": "string" }),
        FieldTypeIr::Integer => json!({ "type": "integer", "format": "int32" }),
        FieldTypeIr::Bigint => json!({ "type": "integer", "format": "int64" }),
        FieldTypeIr::Decimal => json!({ "type": "string", "format": "decimal" }),
        FieldTypeIr::Boolean => json!({ "type": "boolean" }),
        FieldTypeIr::Date => json!({ "type": "string", "format": "date" }),
        FieldTypeIr::Datetime => json!({ "type": "string", "format": "date-time" }),
        FieldTypeIr::Json => json!({}),
        FieldTypeIr::Enum { values } => json!({ "type": "string", "enum": values }),
    };
    if !field.required {
        schema["nullable"] = Value::Bool(true);
    }
    schema
}

fn type_schema(ir: &AppIr, operation_type: &OperationTypeIr) -> Value {
    schema_ref(&type_name(ir, operation_type))
}

fn type_name(ir: &AppIr, operation_type: &OperationTypeIr) -> String {
    match operation_type {
        OperationTypeIr::Entity { entity } => ir
            .entities
            .iter()
            .find(|candidate| candidate.id == *entity)
            .map(|entity| entity.rust_name.clone())
            .expect("compiler resolved operation entity"),
        OperationTypeIr::ValueObject { value_object } => ir
            .value_objects
            .iter()
            .find(|candidate| candidate.id == *value_object)
            .map(|value| value.rust_name.clone())
            .expect("compiler resolved operation value object"),
    }
}

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 kebab_name(value: &str) -> String {
    let mut output = String::new();
    for (index, character) in value.chars().enumerate() {
        if character.is_ascii_uppercase() {
            if index > 0 {
                output.push('-');
            }
            output.push(character.to_ascii_lowercase());
        } else {
            output.push(character);
        }
    }
    output
}