nautilus-orm-codegen 1.0.1

Code generator for Nautilus ORM schema files
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

//! Type mapping helpers for code generation.

use nautilus_schema::ir::DefaultValue;
use nautilus_schema::ir::{FieldIr, ResolvedFieldType, ScalarType};

/// Convert a `ScalarType` to its Rust type string.
pub(crate) fn scalar_to_rust_type(scalar: &ScalarType) -> String {
    scalar.rust_type().to_string()
}

/// Get the base Rust type for a field without optional wrappers.
pub(crate) fn field_to_rust_base_type(field: &FieldIr) -> String {
    let base_type = match &field.field_type {
        ResolvedFieldType::Scalar(scalar) => scalar_to_rust_type(scalar),
        ResolvedFieldType::Enum { enum_name } => enum_name.clone(),
        ResolvedFieldType::CompositeType { type_name } => type_name.clone(),
        ResolvedFieldType::Relation(rel) => rel.target_model.clone(),
    };

    if field.is_array && !matches!(field.field_type, ResolvedFieldType::Relation(_)) {
        format!("Vec<{}>", base_type)
    } else {
        base_type
    }
}

/// Get the Rust type for a field, including Option wrapper if nullable.
pub fn field_to_rust_type(field: &FieldIr) -> String {
    let base_type = field_to_rust_base_type(field);

    if matches!(field.field_type, ResolvedFieldType::Relation(_)) {
        return if field.is_array {
            format!("Vec<{}>", base_type)
        } else {
            format!("Option<Box<{}>>", base_type)
        };
    }

    if !field.is_required && !field.is_array {
        format!("Option<{}>", base_type)
    } else {
        base_type
    }
}

/// Get the Rust type used by `SUM()` outputs for a numeric field.
pub(crate) fn field_to_rust_sum_type(field: &FieldIr) -> String {
    match &field.field_type {
        ResolvedFieldType::Scalar(ScalarType::Int | ScalarType::BigInt) => "i64".to_string(),
        ResolvedFieldType::Scalar(ScalarType::Float) => "f64".to_string(),
        ResolvedFieldType::Scalar(ScalarType::Decimal { .. }) => {
            "rust_decimal::Decimal".to_string()
        }
        _ => field_to_rust_base_type(field),
    }
}

/// Get the Rust type used by `AVG()` outputs for a numeric field.
pub(crate) fn field_to_rust_avg_type(field: &FieldIr) -> String {
    match &field.field_type {
        ResolvedFieldType::Scalar(ScalarType::Decimal { .. }) => {
            "rust_decimal::Decimal".to_string()
        }
        _ => "f64".to_string(),
    }
}

/// Check if a field should be auto-generated (excluded from create builders).
pub fn is_auto_generated(field: &FieldIr) -> bool {
    if field.computed.is_some() {
        return true;
    }
    if let Some(default) = &field.default_value {
        matches!(
            default,
            DefaultValue::Function(func) if func.name == "autoincrement" || func.name == "uuid"
        )
    } else {
        false
    }
}