simple_dto_mapper_derive 0.1.1

A derive macro for mapping DTOs with rename/transform/skip support
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

# simple_dto_mapper_derive

`simple_dto_mapper_derive` provides a custom derive macro `DtoFrom` that generates
`impl From<Source> for Target` to map model structs into DTOs. It focuses on a
small, explicit set of attributes for clarity and reliability.

## Features

- **Source struct**: `#[dto(from = Type)]` (required)
- **Field rename**: `#[dto(rename = "orig_name")]`
- **Custom transform**: `#[dto(transform_fn = path::to::function)]` (owned in → owned out)
- **Skip with default**: `#[dto(skip)]`
- **Infallible convert**: `#[dto(into)]` (uses `From<Src> for Dst`)
- **Clear diagnostics**: unknown/duplicate/conflicting attributes produce span-accurate compile errors (see `tests/ui`)

## Mapping Rules (at a glance)

- **Default (owned move)**  
  Same **name** & same **type** → `target = source.field`  
  “Compatible type” means:

  - Identical type, or
  - `#[dto(into)]` where `From<SourceFieldType> for FieldType` exists, or
  - `#[dto(transform_fn = ...)]` provides an explicit conversion

- **Field attributes**

  - `#[dto(rename = "orig_name")]` — read from another source field name
  - `#[dto(transform_fn = path)]` — call `path(source.orig_name)` before assignment
  - `#[dto(skip)]` — initialize with `Default::default()`
  - `#[dto(into)]` — call `Into::into(source.orig_name)` (requires `From`)

- **Struct attribute (required)**  
  `#[dto(from = Type)]` — specify the **source struct**.

## Usage

```rust
use simple_dto_mapper_derive::DtoFrom;

mod types {
    #[derive(Debug)]
    pub struct User {
        pub id: String,
        pub name: String,
        pub age: u32,
        pub password: String, // intentionally not mapped
        pub status: SourceStatus,
    }

    #[derive(Debug, Clone)]
    pub enum SourceStatus { Active, Inactive }

    #[derive(Debug, Clone)]
    pub enum DtoStatus { Active, Inactive }

    // For `#[dto(into)]`
    impl From<SourceStatus> for DtoStatus {
        fn from(s: SourceStatus) -> Self {
            match s { SourceStatus::Active => Self::Active, SourceStatus::Inactive => Self::Inactive }
        }
    }

    // For `#[dto(transform_fn = ...)]`
    pub fn mask_name(name: String) -> String {
        let ch = name.chars().next().unwrap_or('*');
        format!("{ch}***")
    }
}

#[derive(DtoFrom, Debug)]
#[dto(from = types::User)]
struct UserDto {
    // `rename` + `transform_fn`
    #[dto(rename = "name", transform_fn = types::mask_name)]
    display_name: String,

    // Direct mapping
    age: u32,

    // skip: default initialize
    #[dto(skip)]
    note: Option<String>,

    // `into`: uses `From<SourceStatus> for DtoStatus`
    #[dto(into)]
    status: types::DtoStatus,
}

fn main() {
    let user = types::User {
        id: "u1".into(),
        name: "Alice".into(),
        age: 30,
        password: "secret".into(),
        status: types::SourceStatus::Active,
    };
    let dto: UserDto = user.into();
    println!("{dto:?}");
}
```

## Collections & Option

Collections and Option do not auto-convert inner elements. Use a transform_fn helper or implement From&lt;Vec&lt;T&gt;&gt; for Vec&lt;U&gt; if you prefer #[dto(into)].

```rust
// same type, no transform needed
pub keywords: Vec<String>,

// Vec<SourceTag> → Vec<DtoTag> using a transform function
#[dto(rename = "labels", transform_fn = types::vec_into::<types::SourceTag, types::DtoTag>)]
pub tags: Vec<DtoTag>,

// Option<SourceAuthor> → Option<DtoAuthor>
#[dto(transform_fn = types::opt_into::<types::SourceAuthor, types::DtoAuthor>)]
pub author: Option<DtoAuthor>,
```

## Installation

Add this to your `Cargo.toml`:

```toml
[dependencies]
simple_dto_mapper_derive = "0.1.1"
```

## Diagnostics & Limitations

- Named-field structs only (tuple/unit structs & enums are not supported)
- Owned-only mapping (`impl From<Source> for Target`)
- `transform_fn` must be `FnOnce(SrcField) -> DstField`
- `into` requires `From<SrcField> for DstField`
- `skip` requires `Default`
- Clear errors for unknown/duplicate/conflicting attributes; see `tests/ui`

## License

Licensed under the MIT license.