fix: import cleanup

Author: jayy-lmao

src/common/builder_factory.rs

@@ -4,12 +4,12 @@
 //! create a factory pattern for generating query builders.
 
 use proc_macro2::TokenStream;
-use syn::DeriveInput;
 use quote::quote;
+use syn::DeriveInput;
 
-use crate::common::query_builder_gen::{QueryBuilderGenerator, QueryType};
-use crate::common::modern_builders::ModernManyQueryBuilder;
 use crate::common::field_analysis::analyze_struct_fields;
+use crate::common::modern_builders::ModernManyQueryBuilder;
+use crate::common::query_builder_gen::{QueryBuilderGenerator, QueryType};
 
 /// Factory for creating different types of query builders
 pub struct QueryBuilderFactory;
@@ -38,7 +38,7 @@ impl QueryBuilderFactory {
     /// Generate all query builders for a struct
     pub fn generate_all_builders(input: &DeriveInput) -> TokenStream {
         let many_builder = Self::generate_builder(QueryType::Many, input);
-        
+
         // In a complete implementation, we'd generate all builder types
         quote! {
             #many_builder
@@ -50,24 +50,48 @@ impl QueryBuilderFactory {
     pub fn analyze_query_capabilities(input: &DeriveInput) -> String {
         let fields = analyze_struct_fields(input);
         let mut report = String::new();
-        
+
         report.push_str(&format!("Query capabilities for {}:\n", input.ident));
         report.push_str(&format!("  Total fields: {}\n", fields.len()));
-        
+
         let key_fields: Vec<_> = fields.iter().filter(|f| f.is_key).collect();
         let unique_fields: Vec<_> = fields.iter().filter(|f| f.is_unique).collect();
         let auto_fields: Vec<_> = fields.iter().filter(|f| f.is_auto).collect();
         let enum_fields: Vec<_> = fields.iter().filter(|f| f.is_custom_enum).collect();
-        
-        report.push_str(&format!("  Key fields: {} ({:?})\n", key_fields.len(), 
-            key_fields.iter().map(|f| f.name.to_string()).collect::<Vec<_>>()));
-        report.push_str(&format!("  Unique fields: {} ({:?})\n", unique_fields.len(),
-            unique_fields.iter().map(|f| f.name.to_string()).collect::<Vec<_>>()));
-        report.push_str(&format!("  Auto fields: {} ({:?})\n", auto_fields.len(),
-            auto_fields.iter().map(|f| f.name.to_string()).collect::<Vec<_>>()));
-        report.push_str(&format!("  Enum fields: {} ({:?})\n", enum_fields.len(),
-            enum_fields.iter().map(|f| f.name.to_string()).collect::<Vec<_>>()));
-        
+
+        report.push_str(&format!(
+            "  Key fields: {} ({:?})\n",
+            key_fields.len(),
+            key_fields
+                .iter()
+                .map(|f| f.name.to_string())
+                .collect::<Vec<_>>()
+        ));
+        report.push_str(&format!(
+            "  Unique fields: {} ({:?})\n",
+            unique_fields.len(),
+            unique_fields
+                .iter()
+                .map(|f| f.name.to_string())
+                .collect::<Vec<_>>()
+        ));
+        report.push_str(&format!(
+            "  Auto fields: {} ({:?})\n",
+            auto_fields.len(),
+            auto_fields
+                .iter()
+                .map(|f| f.name.to_string())
+                .collect::<Vec<_>>()
+        ));
+        report.push_str(&format!(
+            "  Enum fields: {} ({:?})\n",
+            enum_fields.len(),
+            enum_fields
+                .iter()
+                .map(|f| f.name.to_string())
+                .collect::<Vec<_>>()
+        ));
+
         report
     }
 }
@@ -84,10 +108,11 @@ pub struct ManyQueryValidator;
 impl QueryBuilderValidator for ManyQueryValidator {
     fn validate(&self, input: &DeriveInput) -> Result<(), String> {
         let fields = analyze_struct_fields(input);
-        let non_key_unique_fields: Vec<_> = fields.iter()
+        let non_key_unique_fields: Vec<_> = fields
+            .iter()
             .filter(|f| !f.is_key && !f.is_unique)
             .collect();
-        
+
         if non_key_unique_fields.is_empty() {
             Err(format!(
                 "Struct {} has no non-key, non-unique fields available for many queries",
@@ -130,17 +155,17 @@ mod tests {
     #[test]
     fn test_many_query_validation() {
         let validator = ManyQueryValidator;
-        
+
         let valid_input: DeriveInput = parse_quote! {
             pub struct User {
                 #[key]
                 id: String,
                 name: String,
             }
         };
-        
+
         assert!(validator.validate(&valid_input).is_ok());
-        
+
         let invalid_input: DeriveInput = parse_quote! {
             pub struct User {
                 #[key]
@@ -149,7 +174,7 @@ mod tests {
                 email: String,
             }
         };
-        
+
         assert!(validator.validate(&invalid_input).is_err());
     }
 }

src/common/config.rs

@@ -4,11 +4,10 @@
 //! customization of query generation behavior.
 
 use std::collections::HashMap;
-use proc_macro2::Ident;
 use syn::DeriveInput;
 
-use crate::common::query_builder_gen::QueryType;
 use crate::common::field_analysis::FieldAnalysis;
+use crate::common::query_builder_gen::QueryType;
 
 /// Configuration options for customizing query generation
 #[derive(Clone, Debug)]
@@ -124,8 +123,14 @@ impl DbSetConfigBuilder {
         self
     }
 
-    pub fn field_override<S: Into<String>>(mut self, field_name: S, override_config: FieldOverride) -> Self {
-        self.config.field_overrides.insert(field_name.into(), override_config);
+    pub fn field_override<S: Into<String>>(
+        mut self,
+        field_name: S,
+        override_config: FieldOverride,
+    ) -> Self {
+        self.config
+            .field_overrides
+            .insert(field_name.into(), override_config);
         self
     }
 
@@ -148,7 +153,7 @@ impl Default for DbSetConfigBuilder {
 /// Extract configuration from derive input attributes
 pub fn extract_config_from_attributes(input: &DeriveInput) -> DbSetConfig {
     let mut config = DbSetConfig::default();
-    
+
     // Look for #[dbset(...)] attributes
     for attr in &input.attrs {
         if let syn::Meta::List(meta) = &attr.meta {
@@ -184,28 +189,31 @@ pub fn extract_config_from_attributes(input: &DeriveInput) -> DbSetConfig {
             }
         }
     }
-    
+
     config
 }
 
 /// Apply configuration-based field filtering
 pub fn apply_config_field_filter<'a>(
-    fields: &'a [FieldAnalysis], 
-    config: &DbSetConfig, 
-    query_type: QueryType
+    fields: &'a [FieldAnalysis],
+    config: &DbSetConfig,
+    query_type: QueryType,
 ) -> Vec<&'a FieldAnalysis> {
-    fields.iter().filter(|field| {
-        let field_name = field.name.to_string();
-        
-        // Check if field is excluded from this query type
-        if let Some(override_config) = config.field_overrides.get(&field_name) {
-            if override_config.exclude_from.contains(&query_type) {
-                return false;
+    fields
+        .iter()
+        .filter(|field| {
+            let field_name = field.name.to_string();
+
+            // Check if field is excluded from this query type
+            if let Some(override_config) = config.field_overrides.get(&field_name) {
+                if override_config.exclude_from.contains(&query_type) {
+                    return false;
+                }
             }
-        }
-        
-        true
-    }).collect()
+
+            true
+        })
+        .collect()
 }
 
 #[cfg(test)]
@@ -245,7 +253,7 @@ mod tests {
     #[test]
     fn test_field_filtering() {
         use crate::common::field_analysis::analyze_struct_fields;
-        
+
         let input: DeriveInput = parse_quote! {
             pub struct User {
                 id: String,
@@ -256,21 +264,21 @@ mod tests {
 
         let fields = analyze_struct_fields(&input);
         let mut config = DbSetConfig::default();
-        
+
         // Exclude 'email' field from Many queries
         config.field_overrides.insert(
-            "email".to_string(), 
+            "email".to_string(),
             FieldOverride {
                 column_name: None,
                 sql_type: None,
                 exclude_from: vec![QueryType::Many],
                 validation_rules: vec![],
-            }
+            },
         );
 
         let filtered = apply_config_field_filter(&fields, &config, QueryType::Many);
         let field_names: Vec<_> = filtered.iter().map(|f| f.name.to_string()).collect();
-        
+
         assert!(!field_names.contains(&"email".to_string()));
         assert!(field_names.contains(&"name".to_string()));
     }

src/common/demo.rs

@@ -12,14 +12,14 @@
 //! See the tests folder for realistic consumer usage examples.
 
 use proc_macro2::TokenStream;
-use syn::DeriveInput;
 use quote::quote;
+use syn::DeriveInput;
 
 use crate::common::{
-    config::{DbSetConfigBuilder, extract_config_from_attributes},
     builder_factory::QueryBuilderFactory,
-    query_builder_gen::QueryType,
+    config::{extract_config_from_attributes, DbSetConfigBuilder},
     field_analysis::analyze_struct_fields,
+    query_builder_gen::QueryType,
 };
 
 /// Demonstrates the usage of the new advanced system
@@ -30,23 +30,27 @@ impl AdvancedQueryBuilderDemo {
     pub fn generate_with_config(input: &DeriveInput) -> TokenStream {
         // Extract configuration from attributes
         let base_config = extract_config_from_attributes(input);
-        
+
         // Enhance with additional settings
         let _enhanced_config = DbSetConfigBuilder::new()
-            .table_name(base_config.table_name.unwrap_or_else(|| input.ident.to_string().to_lowercase()))
+            .table_name(
+                base_config
+                    .table_name
+                    .unwrap_or_else(|| input.ident.to_string().to_lowercase()),
+            )
             .include_validation(true)
             .async_methods(true)
             .build();
 
         // Analyze the struct capabilities
         let analysis_report = QueryBuilderFactory::analyze_query_capabilities(input);
-        
+
         // Generate comment with analysis
         let analysis_comment = format!("/*\n{}\n*/", analysis_report);
-        
+
         // Generate the query builders
         let many_builder = QueryBuilderFactory::generate_builder(QueryType::Many, input);
-        
+
         quote! {
             #[doc = #analysis_comment]
             #many_builder
@@ -101,12 +105,16 @@ impl ECommerceQueryBuilders {
     /// (For illustration only; not typical usage)
     pub fn generate_product_builders(input: &DeriveInput) -> TokenStream {
         let fields = analyze_struct_fields(input);
-        
+
         // Look for e-commerce specific fields
         let has_price = fields.iter().any(|f| f.name.to_string().contains("price"));
-        let has_inventory = fields.iter().any(|f| f.name.to_string().contains("inventory") || f.name.to_string().contains("stock"));
-        let has_category = fields.iter().any(|f| f.name.to_string().contains("category"));
-        
+        let has_inventory = fields.iter().any(|f| {
+            f.name.to_string().contains("inventory") || f.name.to_string().contains("stock")
+        });
+        let has_category = fields
+            .iter()
+            .any(|f| f.name.to_string().contains("category"));
+
         let specialized_methods = if has_price && has_inventory && has_category {
             quote! {
                 impl ProductSpecializedQueries {
@@ -178,10 +186,10 @@ mod tests {
 
         let result = AdvancedQueryBuilderDemo::generate_with_config(&input);
         let result_str = result.to_string();
-        
+
         // Should contain analysis comment
         assert!(result_str.contains("Query capabilities"));
-        
+
         // Should contain query builder
         assert!(result_str.contains("QueryBuilder"));
     }
@@ -200,7 +208,7 @@ mod tests {
 
         let result = ECommerceQueryBuilders::generate_product_builders(&product_input);
         let result_str = result.to_string();
-        
+
         // Should contain specialized methods
         assert!(result_str.contains("find_by_price_range"));
         assert!(result_str.contains("find_low_stock"));

src/common/field_analysis.rs

@@ -4,11 +4,9 @@
 //! for different query generation purposes.
 
 use proc_macro2::Ident;
-use syn::{Attribute, Type, DeriveInput};
+use syn::{Attribute, DeriveInput, Type};
 
-use crate::common::utils::{
-    get_all_fields, is_custom_enum_attr, get_inner_option_type,
-};
+use crate::common::utils::{get_all_fields, get_inner_option_type, is_custom_enum_attr};
 
 /// Represents a field with its metadata for query generation
 #[derive(Clone)]
@@ -69,7 +67,7 @@ impl FieldAnalysis {
 /// Analyze all fields in a struct and categorize them
 pub fn analyze_struct_fields(input: &DeriveInput) -> Vec<FieldAnalysis> {
     let all_fields = get_all_fields(input);
-    
+
     all_fields
         .iter()
         .map(|(name, field_type, attributes)| {
@@ -80,7 +78,10 @@ pub fn analyze_struct_fields(input: &DeriveInput) -> Vec<FieldAnalysis> {
 
 /// Get fields suitable for many queries (excluding keys and unique fields)
 pub fn get_many_query_fields(analyses: &[FieldAnalysis]) -> Vec<&FieldAnalysis> {
-    analyses.iter().filter(|f| f.is_many_query_field()).collect()
+    analyses
+        .iter()
+        .filter(|f| f.is_many_query_field())
+        .collect()
 }
 
 /// Get fields suitable for one queries (keys and unique fields)