entity-derive-impl 0.3.0

Internal proc-macro implementation for entity-derive. Use entity-derive instead.
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

// SPDX-FileCopyrightText: 2025-2026 RAprogramm <andrey.rozanov.vl@gmail.com>
// SPDX-License-Identifier: MIT

//! Command enum generation.
//!
//! Generates the main command enum that wraps all command variants.
//!
//! # Generated Code
//!
//! For `User` entity with Register, UpdateEmail, Deactivate commands:
//!
//! ```rust,ignore
//! #[derive(Debug, Clone)]
//! pub enum UserCommand {
//!     Register(RegisterUser),
//!     UpdateEmail(UpdateEmailUser),
//!     Deactivate(DeactivateUser),
//! }
//!
//! impl entity_core::EntityCommand for UserCommand {
//!     fn kind(&self) -> entity_core::CommandKind { ... }
//!     fn name(&self) -> &'static str { ... }
//! }
//! ```

use proc_macro2::TokenStream;
use quote::{format_ident, quote};

use super::struct_gen::{command_struct_name, custom_payload_type, uses_custom_payload};
use crate::{
    entity::parse::{CommandDef, CommandKindHint, EntityDef},
    utils::marker
};

/// Generate the command enum and its implementations.
pub fn generate(entity: &EntityDef) -> TokenStream {
    let commands = entity.command_defs();
    if commands.is_empty() {
        return TokenStream::new();
    }

    let vis = &entity.vis;
    let entity_name = entity.name();
    let enum_name = format_ident!("{}Command", entity_name);
    let marker = marker::generated();

    let variants = generate_variants(entity, commands);
    let kind_arms = generate_kind_arms(commands);
    let name_arms = generate_name_arms(commands);

    let doc = format!(
        "Command enum for [`{}`] entity.\n\n\
         Wraps all business commands for type-safe dispatch.",
        entity_name
    );

    quote! {
        #marker
        #[doc = #doc]
        #[derive(Debug, Clone)]
        #vis enum #enum_name {
            #variants
        }

        impl entity_core::EntityCommand for #enum_name {
            fn kind(&self) -> entity_core::CommandKind {
                match self {
                    #kind_arms
                }
            }

            fn name(&self) -> &'static str {
                match self {
                    #name_arms
                }
            }
        }
    }
}

/// Generate enum variants.
fn generate_variants(entity: &EntityDef, commands: &[CommandDef]) -> TokenStream {
    let variants: Vec<TokenStream> = commands
        .iter()
        .map(|cmd| {
            let variant_name = &cmd.name;
            let payload_type = if uses_custom_payload(cmd) {
                let ty = custom_payload_type(cmd).unwrap();
                quote! { #ty }
            } else {
                let struct_name = command_struct_name(entity, cmd);
                quote! { #struct_name }
            };

            let doc = format!("{} command variant.", variant_name);

            quote! {
                #[doc = #doc]
                #variant_name(#payload_type),
            }
        })
        .collect();

    quote! { #(#variants)* }
}

/// Generate match arms for kind() method.
fn generate_kind_arms(commands: &[CommandDef]) -> TokenStream {
    let arms: Vec<TokenStream> = commands
        .iter()
        .map(|cmd| {
            let variant_name = &cmd.name;
            let kind = match cmd.kind {
                CommandKindHint::Create => quote! { entity_core::CommandKind::Create },
                CommandKindHint::Update => quote! { entity_core::CommandKind::Update },
                CommandKindHint::Delete => quote! { entity_core::CommandKind::Delete },
                CommandKindHint::Custom => quote! { entity_core::CommandKind::Custom }
            };

            quote! {
                Self::#variant_name(_) => #kind,
            }
        })
        .collect();

    quote! { #(#arms)* }
}

/// Generate match arms for name() method.
fn generate_name_arms(commands: &[CommandDef]) -> TokenStream {
    let arms: Vec<TokenStream> = commands
        .iter()
        .map(|cmd| {
            let variant_name = &cmd.name;
            let name_str = variant_name.to_string();

            quote! {
                Self::#variant_name(_) => #name_str,
            }
        })
        .collect();

    quote! { #(#arms)* }
}