bson-comp

Stop fighting the doc! macro. Make your types generic-compatible.

If you work with MongoDB in Rust, you’ve definitely hit this wall. You have a nice, strongly-typed Enum or Struct, and you just want to use it in a query.

The Problem

You try to do this:

1
let filter = doc! { "role": Role::Admin };

And the compiler screams at you with Error E0277:

the trait bound Bson: std::convert::From<Role> is not satisfied
required for Role to implement Into<Bson>

So you end up writing this boilerplate everywhere:

1
// ❌ The Ugly Way
2
// Manual conversion every time you use it.
3
let filter = doc! {
4
    "role": bson::to_bson(&Role::Admin).unwrap()
5
};

The Solution

bson_comp (BSON Compatibility) handles that boilerplate for you. It implements Into<Bson> for your types so they fit right into the doc! macro.

1
// ✅ The Clean Way
2
let filter = doc! { "role": Role::Admin };

Installation

Add this to your Cargo.toml:

1
[dependencies]
2
bson_comp = "0.1"
3
serde = { version = "1.0", features = ["derive"] }

How to use it

1. For Enums (The most common use case)

Perfect for status flags, user roles, or category types.

1
use serde::{Serialize, Deserialize};
2
use bson_comp::BsonComp;
3
use bson::doc;
4

5
#[derive(Serialize, Deserialize, BsonComp)]
6
#[serde(rename_all = "UPPERCASE")] // Optional: controls how it looks in Mongo
7
enum Role {
8
    Admin,
9
    User,
10
}
11

12
fn main() {
13
    // Works natively in doc!
14
    let query = doc! {
15
        "role": Role::Admin,
16
        "is_active": true
17
    };
18

19
    // Output: { "role": "ADMIN", "is_active": true }
20
}

2. For Structs

Useful when embedding objects inside other documents.

1
use serde::Serialize;
2
use bson_comp::BsonComp;
3
use bson::doc;
4

5
#[derive(Serialize, BsonComp)]
6
struct Address {
7
    city: String,
8
    zip: u32,
9
}
10

11
fn main() {
12
    let my_address = Address {
13
        city: "New York".to_string(),
14
        zip: 10001
15
    };
16

17
    // Embed it directly
18
    let profile = doc! {
19
        "username": "alice",
20
        "address": my_address
21
    };
22
}

How it works

Rust’s “Orphan Rules” prevent you from implementing From<YourType> for Bson because you don’t own the bson crate.

However, the doc! macro accepts anything that implements Into<Bson>. Since Into is a generic trait, you are allowed to implement it for your own types.

This macro simply generates:

1
impl Into<bson::Bson> for YourType {
2
    fn into(self) -> bson::Bson {
3
        bson::to_bson(&self).expect("Failed to serialize type for BSON macro")
4
    }
5
}

Requirements

Your type must derive serde::Serialize.
It panics if serialization fails (which shouldn’t happen for standard Enums/Structs unless you have custom serialization logic that fails).

License

MIT. Enjoy clean code.

Bson Comp