kagou/

lib.rs

mod seaorm;
// 导入过程宏相关的核心库。proc_macro 是编译器提供的库，用于处理令牌流
use proc_macro::TokenStream;
// quote 库允许我们将 Rust 语法转换为 TokenStream
use quote::quote;
// syn 库用于解析 Rust 代码，提供语法树结构
use syn::{parse_macro_input, Data, DeriveInput, Fields, GenericArgument, ItemFn, PathArguments, Type};
// 数据库查询的 增删改查功能
#[proc_macro]
pub fn seaorm_curd(args: TokenStream) -> TokenStream {
    seaorm::curd::page(args)
    // if cfg!(feature = "seaorm_page") {
    //     //开启指定 features 特性
    //     // 调用其他函数
    //     seaorm::curd::page(args)
    // } else {
    //     seaorm::curd::page(args)
    // }
}
// 过程宏   只能包含以下三种宏之一：
// 函数式的过程宏 (proc_macro)
#[proc_macro]
pub fn my_macro(input: TokenStream) -> TokenStream {
    let input = input.to_string();
    let output = format!("println!(\"Hello from macro! Input was: {}\");", input);
    output.parse().unwrap()
}

// derive过程宏派生宏 (proc_macro_derive)
#[proc_macro_derive(MyDerive)]
pub fn my_derive(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let name = input.ident;

    let output = quote! {
        impl #name {
            fn hello(&self) {
                println!("Hello from derived impl for {}!", stringify!(#name));
            }
        }
    };

    output.into()
}

// 属性宏 (proc_macro_attribute)
#[proc_macro_attribute]
pub fn my_attr(attr: TokenStream, item: TokenStream) -> TokenStream {
    let attr = attr.to_string();
    let input = parse_macro_input!(item as ItemFn);
    let fn_name = &input.sig.ident;

    let output = quote! {
        #input

        fn #fn_name() {
            println!("This function was modified by my_attr with attribute: {}", #attr);
        }
    };

    output.into()
}

/// 为 SeaORM ActiveModel 生成从 JSON 值更新字段的方法
/// 这是一个派生宏(derive macro)，通过 #[derive(UpdateFromJson)] 使用
/// 输入是应用该宏的结构体的 TokenStream，输出是生成的代码的 TokenStream
/// 核心功能：根据提供的 JSON 数据（通常是 Option<T> 字段）更新 SeaORM ActiveModel
/// 只有 JSON 数据中存在的 Some(...) 字段才会被更新，未提供的字段保持原状
#[proc_macro_derive(UpdateFromJson)]
pub fn run(input: TokenStream) -> TokenStream {
    // 将输入的 TokenStream 解析为 DeriveInput 语法树结构
    // DeriveInput 包含了所有关于结构体、枚举或联合体的信息
    let input = parse_macro_input!(input as DeriveInput);

    // 获取结构体的名称（标识符），用于生成 impl 块
    let struct_name = &input.ident;

    // 处理结构体的数据（字段）
    // 检查输入数据是否是一个结构体
    let fields = if let Data::Struct(data_struct) = &input.data {
        &data_struct.fields
    } else {
        // 如果不是结构体，返回编译错误
        // 过程宏应该返回 TokenStream，这里使用 to_compile_error 创建错误信息
        return syn::Error::new_spanned(input, "`UpdateFromJson` 此宏仅支持应用于结构体中")
            .to_compile_error()
            .into();
    };

    // 为每个字段生成更新语句
    // 检查字段是否是有名字段（相对于元组结构体的无名字段）
    let update_arms = if let Fields::Named(fields_named) = fields {
        // 遍历所有有名字段，为每个字段生成更新代码
        fields_named.named.iter().map(|field| {
            // 获取字段的名称
            let field_name = &field.ident;
            // 将字段名转换为字符串，用于匹配
            let field_name_str = field_name.as_ref().unwrap().to_string();
            // 获取字段的类型，用于类型检查和转换
            let field_type = &field.ty;

            // 根据字段名和类型生成不同的处理逻辑
            // 使用字段名匹配来识别需要特殊处理的字段
            match field_name_str.as_str() {
                // 时间字段特殊处理：String -> DateTime
                // 假设数据库模型中对应字段是 DateTime 类型，但 JSON 数据中是字符串
                "time_line" => {
                    quote! {
                        #field_name_str => {
                            if let Some(time_str) = &data.#field_name {
                                // 将 RFC3339 格式的时间字符串解析为 DateTime
                                // 使用 with_timezone(&chrono::Utc) 转换为 UTC 时区
                                match chrono::DateTime::parse_from_rfc3339(time_str)
                                    .map(|dt| dt.with_timezone(&chrono::Utc))
                                {
                                    Ok(dt) => {
                                        // 解析成功，设置 ActiveModel 的对应字段
                                        active_model.#field_name = sea_orm::ActiveValue::Set(Some(dt));
                                    }
                                    Err(e) => {
                                        // 解析失败，记录警告日志但不中断程序
                                        log::warn!(
                                            "Failed to parse datetime string for field '{}': {}",
                                            #field_name_str,
                                            e
                                        );
                                    }
                                }
                            }
                        }
                    }
                }
                // 金额字段特殊处理：f64 -> Decimal (如果需要)
                // 假设数据库模型中对应字段是 Decimal 类型
                "price" | "fee" => {
                    quote! {
                        #field_name_str => {
                            if let Some(num) = data.#field_name {
                                // 这里假设 ActiveModel 的对应字段已经是 Decimal 类型
                                // 如果需要转换，可以在这里添加 f64 到 Decimal 的转换逻辑
                                active_model.#field_name = sea_orm::ActiveValue::Set(Some(num));
                            }
                        }
                    }
                }
                // JSON 字段特殊处理
                // 假设数据库模型中对应字段是 sea_orm::sea_query::types::Json 类型
                "rules" | "store_quanxain" => {
                    quote! {
                        #field_name_str => {
                            if let Some(json_value) = &data.#field_name {
                                // 将 fache::json::Value 转换为 sea_orm 的 Json 类型
                                active_model.#field_name = sea_orm::ActiveValue::Set(
                                    Some(sea_orm::sea_query::types::Json(json_value.clone()))
                                );
                            }
                        }
                    }
                }
                // 默认处理：直接赋值
                // 对于大多数字段，直接进行值赋值
                _ => {
                    // 检查字段类型，确保兼容性
                    if is_type_compatible(field_type) {
                        quote! {
                            #field_name_str => {
                                if let Some(value) = data.#field_name {
                                    // 直接设置字段值，假设类型兼容
                                    active_model.#field_name = sea_orm::ActiveValue::Set(value);
                                }
                            }
                        }
                    } else {
                        // 对于不兼容的类型，生成错误或跳过
                        quote! {
                            #field_name_str => {
                                println!("Field '{}' has incompatible type and will be skipped", #field_name_str);
                            }
                        }
                    }
                }
            }
        })
    } else {
        // 处理没有命名字段的结构体（如元组结构体）
        return syn::Error::new_spanned(input, "`UpdateFromJson` 仅支持有名字的结构体")
            .to_compile_error()
            .into();
    };

    // 生成最终的 impl 块代码
    // 使用 quote! 宏生成完整的实现代码
    let expanded = quote! {
        impl #struct_name {
            /// 根据提供的 JSON 数据更新 SeaORM ActiveModel 的字段
            /// 只有 JSON 数据中存在的 `Some(...)` 字段才会被更新
            /// 未提供的字段将保持其在 ActiveModel 中的原状（NotSet 或原有值）
            ///
            /// # 参数
            /// - `active_model`: 要更新的 SeaORM ActiveModel 的可变引用
            /// - `data`: 包含更新数据的结构体实例（&Self）
            ///
            /// # 注意
            /// 此方法只会更新提供的 Some(...) 字段，None 字段会被忽略
            pub fn update_active_model_from_json(
                &self,
                active_model: &mut sea_orm::ActiveModel,
            ) {
                let data = self;
                // 这里会生成一个匹配字段名的 match 语句（或类似逻辑）
                // 为了简化示例，我们直接遍历结构体的字段
                #(#update_arms)*
            }
        }
    };

    // 将生成的代码转换为 TokenStream 并返回
    // 编译器会将这个 TokenStream 插入到原始代码中
    TokenStream::from(expanded)
}

/// 检查字段类型是否与 SeaORM ActiveValue 兼容
/// 这是一个简化版的实现，实际应用中应该根据具体需求进行更详细的检查
fn is_type_compatible(field_type: &Type) -> bool {
    println!("当前的类型 '{:#?}' ", field_type);
    // 处理路径类型（最常见的情况）
    if let Type::Path(type_path) = field_type {
        // 获取最后一段路径（通常是类型名称）
        if let Some(segment) = type_path.path.segments.last() {
            let type_name = segment.ident.to_string();
            // 检查基本类型
            match type_name.as_str() {
                // 基本数值类型
                "i8" | "i16" | "i32" | "i64" | "i128" | "isize" | "u8" | "u16" | "u32" | "u64"
                | "u128" | "usize" | "f32" | "f64" => return true,

                // 布尔类型
                "bool" => return true,

                // 字符串类型
                "String" | "str" => return true,

                // SeaORM 和常用类型
                "DateTime"
                | "DateTimeWithTimeZone"
                | "DateTimeUtc"
                | "DateTimeLocal"
                | "NaiveDate"
                | "NaiveDateTime"
                | "Decimal"
                | "Json" => return true,

                // JSON 类型 (serde 和 sea_orm)
                "Value" => {
                    // 检查是否是 serde_json::Value 或 sea_orm::sea_query::types::Json
                    if let Some(path) = type_path.path.segments.first() {
                        return path.ident == "serde_json" || path.ident == "sea_orm";
                    }
                    return false;
                }

                // Option<T> 类型 - 需要检查内部类型
                "Option" => {
                    if let PathArguments::AngleBracketed(args) = &segment.arguments {
                        if let Some(GenericArgument::Type(inner_type)) = args.args.first() {
                            // 递归检查内部的类型
                            return is_type_compatible(inner_type);
                        }
                    }
                    return false;
                }

                // 其他类型需要进一步检查
                _ => {}
            }
        }
    }

    // 处理引用类型 (&T, &mut T)
    if let Type::Reference(type_ref) = field_type {
        return is_type_compatible(&type_ref.elem);
    }

    // 处理数组类型 [T; N]
    if let Type::Array(type_array) = field_type {
        return is_type_compatible(&type_array.elem);
    }

    // 处理元组类型 (T, U, ...)
    if let Type::Tuple(type_tuple) = field_type {
        return type_tuple.elems.iter().all(is_type_compatible);
    }

    // 对于未知或复杂类型，默认返回 false
    // 在生产环境中，可以在这里添加更多特定的检查或记录警告
    false
}