Crate serialize_fields

SerializeFields

A Rust procedural macro that enables dynamic field selection for struct serialization. Control exactly which fields get serialized at runtime using a hierarchical field selector system.

Features

• 🎯 Dynamic Field Selection: Choose which fields to serialize at runtime
• 🌳 Hierarchical Selection: Use dot notation for nested structs ("user.profile.name")
• 🔧 Type Safe: Compile-time validation of field paths
• 🚀 Zero Runtime Cost: Only enabled fields are processed during serialization
• 📦 Serde Integration: Works seamlessly with the serde ecosystem
• 🔄 Collection Support: Handles Vec, Option, HashMap, and other containers
• 🏗️ Generic Architecture: Single trait-based serialization implementation

Quick Start

use serialize_fields::{SerializeFields, SerializeFieldsTrait};
use serde::{Serialize, Deserialize};

#[derive(SerializeFields, Serialize, Deserialize)]
struct User {
    id: u32,
    name: Option<String>,
    email: Option<String>,
}

let user = User {
    id: 123,
    name: Some("Alice".to_string()),
    email: Some("alice@example.com".to_string()),
};

// Create field selector using the trait method
let mut fields = user.serialize_fields();
fields.enable_dot_hierarchy("id");
fields.enable_dot_hierarchy("name");

// Serialize with selected fields only
let json = serde_json::to_string(&SerializeFields(&user, &fields)).unwrap();
// Output: {"id":123,"name":"Alice"}

Advanced Usage

Nested Structs

#[derive(SerializeFields, Serialize, Deserialize)]
struct User {
    id: u32,
    profile: UserProfile,
}

#[derive(SerializeFields, Serialize, Deserialize)]
struct UserProfile {
    bio: Option<String>,
    avatar_url: Option<String>,
}

let mut fields = user.serialize_fields();
fields.enable_dot_hierarchy("id");
fields.enable_dot_hierarchy("profile.bio");  // Nested field selection

let json = serde_json::to_string(&SerializeFields(&user, &fields)).unwrap();
// Output: {"id":123,"profile":{"bio":"Software Engineer"}}

Dynamic Field Selection

fn serialize_user_with_fields(user: &User, requested_fields: &[&str]) -> String {
    let mut selector = user.serialize_fields();
     
    for field in requested_fields {
        selector.enable_dot_hierarchy(field);
    }
     
    serde_json::to_string(&SerializeFields(user, &selector)).unwrap()
}

// Usage: GET /users/123?fields=id,name
let fields = vec!["id", "name"];
let json = serialize_user_with_fields(&user, &fields);

Modules

utils

Utility functions for working with field selectors.

Macros

contains

Check if a field path is enabled in a field selector.

copy_selected_fields

Copy selected fields from a source struct to a new struct, using provided blocks for enabled fields.

field_path

Helper macro for creating field path patterns in filter_field_set!

filter_field_set

Create a BTreeSet of enabled field paths that match specified patterns.

filter_field_set_contains

Helper macro to check field paths of any depth for filter_field_set!

filter_field_set_helper

Helper macro for filter_field_set! to handle different field path patterns

flatten_get_selector

Structs

SerializeFields

A wrapper struct that combines data with a field selector for serialization.

Traits

FieldSelector

Helper trait for field selectors to provide common functionality.

SerializeFieldsTrait

Trait for types that can provide field selectors for dynamic serialization.

Derive Macros

SerializeFields

Derive macro for generating field selectors and dynamic serialization.