cratestack-macros 0.4.3

Rust-native schema-first framework for typed HTTP APIs, generated clients, and backend services.
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
82
83
84
85

//! Per-procedure token gathering for [`super::collect_server_schema`]:
//! procedure module, registry method, axum handler/route, transport
//! constants.

use std::collections::BTreeSet;

use cratestack_core::Schema;
use proc_macro::TokenStream;
use syn::LitStr;

use crate::axum::{generate_procedure_axum_handler, generate_procedure_axum_route};
use crate::procedure::{generate_procedure_module, generate_procedure_registry_method};
use crate::transport::{
    generate_procedure_transport_constants, generate_procedure_transport_entries,
};

use super::{Ts, compile_error};

pub(super) struct ProcedureCollected {
    pub(super) modules: Vec<Ts>,
    pub(super) registry_methods: Vec<Ts>,
    pub(super) axum_handler_defs: Vec<Ts>,
    pub(super) axum_routes: Vec<Ts>,
    pub(super) transport_constants: Vec<Ts>,
    pub(super) transport_entries: Vec<Ts>,
}

pub(super) fn collect_procedures(
    schema: &Schema,
    schema_path: &LitStr,
    enum_name_set: &BTreeSet<&str>,
    auth: Option<&cratestack_core::AuthBlock>,
) -> Result<ProcedureCollected, TokenStream> {
    let modules = schema
        .procedures
        .iter()
        .map(|procedure| {
            generate_procedure_module(
                procedure,
                &schema.models,
                &schema.types,
                enum_name_set,
                auth,
            )
        })
        .collect::<Result<Vec<_>, _>>()
        .map_err(|e| compile_error(schema_path, e))?;
    let registry_methods = schema
        .procedures
        .iter()
        .map(generate_procedure_registry_method)
        .collect::<Result<Vec<_>, _>>()
        .map_err(|e| compile_error(schema_path, e))?;
    let axum_handler_defs = schema
        .procedures
        .iter()
        .map(generate_procedure_axum_handler)
        .collect::<Result<Vec<_>, _>>()
        .map_err(|e| compile_error(schema_path, e))?;
    let axum_routes = schema
        .procedures
        .iter()
        .map(generate_procedure_axum_route)
        .collect();
    let transport_constants = schema
        .procedures
        .iter()
        .map(generate_procedure_transport_constants)
        .collect::<Result<Vec<_>, _>>()
        .map_err(|e| compile_error(schema_path, e))?;
    let transport_entries = schema
        .procedures
        .iter()
        .map(generate_procedure_transport_entries)
        .collect();

    Ok(ProcedureCollected {
        modules,
        registry_methods,
        axum_handler_defs,
        axum_routes,
        transport_constants,
        transport_entries,
    })
}