entity-derive 0.5.0

Derive macro for generating DTOs, repositories, and SQL from a single entity definition
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

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

use async_trait::async_trait;
use entity_derive::{Entity, EntityCommand};
use uuid::Uuid;

#[derive(Entity, Debug, Clone)]
#[entity(table = "users", commands)]
#[command(Register)]
#[command(UpdateEmail: email)]
#[command(Deactivate, requires_id)]
pub struct User {
    #[id]
    pub id: Uuid,

    #[field(create, update, response)]
    pub email: String,

    #[field(create, response)]
    pub name: String,
}

/// Mock command handler.
struct MockHandler;

/// Context for command execution.
struct Context;

#[async_trait]
impl UserCommandHandler for MockHandler {
    type Error = std::io::Error;
    type Context = Context;

    async fn handle_register(
        &self,
        cmd: RegisterUser,
        _ctx: &Self::Context,
    ) -> Result<User, Self::Error> {
        Ok(User {
            id: Uuid::new_v4(),
            email: cmd.email,
            name: cmd.name,
        })
    }

    async fn handle_update_email(
        &self,
        cmd: UpdateEmailUser,
        _ctx: &Self::Context,
    ) -> Result<User, Self::Error> {
        Ok(User {
            id: cmd.id,
            email: cmd.email,
            name: String::from("Updated"),
        })
    }

    async fn handle_deactivate(
        &self,
        _cmd: DeactivateUser,
        _ctx: &Self::Context,
    ) -> Result<(), Self::Error> {
        Ok(())
    }
}

fn main() {
    // Verify command structs exist
    let _register = RegisterUser {
        email: String::from("test@example.com"),
        name: String::from("Test User"),
    };

    let _update_email = UpdateEmailUser {
        id: Uuid::new_v4(),
        email: String::from("new@example.com"),
    };

    let _deactivate = DeactivateUser { id: Uuid::new_v4() };

    // Verify command enum exists
    let cmd: UserCommand = UserCommand::Register(_register.clone());
    assert_eq!(cmd.name(), "Register");

    // Verify EntityCommand trait implementation
    assert!(matches!(cmd.kind(), entity_derive::CommandKind::Create));

    // Verify result enum exists
    let _result: UserCommandResult = UserCommandResult::Deactivate;
}