omitty 0.1.0

TypeScript-like Omit<> for Rust structs - no boilerplate
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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

# omitty


A Rust procedural macro for generating type variants with omitted fields.

## Features


- **Simple syntax** - Generate variants with just `#[omit_variant(VariantName, field1, field2)]`
- **Automatic derive** - Automatically generates Debug, Clone, Serialize, Deserialize, PartialEq, Eq
- **Serde compatible** - Works seamlessly with serde for JSON/serialization
- **Type-safe** - Compile-time guarantees for omitted fields

## Installation


Add this to your `Cargo.toml`:

```toml
[dependencies]
omitty = "0.1.0"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
```

## Usage


### Basic Example


```rust
use omitty::OmittableType;

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, OmittableType)]

#[omit_variant(UserPublic, secret_token)]

pub struct User {
    pub id: String,
    pub username: String,
    pub secret_token: String,
}
```

This generates a new `UserPublic` struct with only `id` and `username`:

```rust
pub struct UserPublic {
    pub id: String,
    pub username: String,
}
```

### Multiple Omitted Fields


```rust
use omitty::OmittableType;

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, OmittableType)]

#[omit_variant(UserPublic, secret_token, password, internal_id, email)]

pub struct User {
    pub id: String,
    pub username: String,
    pub secret_token: String,
    pub password: String,
    pub internal_id: i64,
    pub email: String,
}
```

### Multiple Variants


```rust
use omitty::OmittableType;

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, OmittableType)]

#[omit_variant(UserPublic, secret_token, password, email)]

#[omit_variant(UserMinimal, secret_token, password, email, bio, avatar_url)]

pub struct User {
    pub id: String,
    pub username: String,
    pub secret_token: String,
    pub password: String,
    pub email: String,
    pub bio: String,
    pub avatar_url: String,
}
```

This generates both `UserPublic` and `UserMinimal` structs with different fields omitted.

### Real-World Example: Discord-like API


```rust
use omitty::OmittableType;

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, OmittableType)]

#[omit_variant(UserPublic, secret_token)]

pub struct User {
    pub id: String,
    pub username: String,
    pub secret_token: String,
}

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]

pub struct Member {
    pub user: UserPublic,
    pub nick: String,
}

fn main() {
    let json = r#"{
        "user": {
            "id": "123",
            "username": "meetzli"
        },
        "nick": "Meetz"
    }"#;

    let member: Member = serde_json::from_str(json).unwrap();
    println!("Username: {}", member.user.username);
    println!("Nick: {}", member.nick);
}
```

## Syntax


```rust
#[omit_variant(VariantName, field1, field2, field3, ...)]

```

- **VariantName**: The name of the generated struct (identifier, not a string)
- **field1, field2, ...**: Names of fields to omit from the original struct

## Generated Derives


All generated variants automatically derive:
- `Debug`
- `Clone`
- `serde::Serialize`
- `serde::Deserialize`
- `PartialEq`
- `Eq`

## Use Cases


- **API responses** - Return public user data without sensitive fields
- **Database models** - Create DTO variants without internal fields
- **Multi-tier data access** - Different permission levels see different fields
- **Caching** - Store lightweight versions of structs
- **Testing** - Create test fixtures with subset of data

## Error Messages


The macro provides clear, actionable error messages:

```rust
// Error: Omittable can only be derived for structs with named fields (not tuple structs or unit structs)
// Error: field type must be a path type (e.g., User, MyType). Complex types like references, arrays, or tuples are not supported
// Error: missing variant name as first argument in omit_variant attribute. Usage: #[omit_variant(VariantName, field1, field2, ...)]
```

## License


MIT OR Apache-2.0