vespera_macro 0.1.30

//! from_model implementation generation
//!
//! Generates async `from_model` implementations for SeaORM models with relations.

use proc_macro2::TokenStream;
use quote::quote;
use syn::Type;

use super::circular::{
    detect_circular_fields, generate_inline_struct_construction, generate_inline_type_construction,
    has_fk_relations, is_circular_relation_required,
};
use super::file_lookup::find_struct_from_schema_path;
use super::seaorm::RelationFieldInfo;
use crate::metadata::StructMetadata;

/// Build Entity path from Schema path.
/// e.g., `crate::models::user::Schema` -> `crate::models::user::Entity`
pub fn build_entity_path_from_schema_path(
    schema_path: &TokenStream,
    _source_module_path: &[String],
) -> TokenStream {
    // Parse the schema path to extract segments
    let path_str = schema_path.to_string();
    let segments: Vec<&str> = path_str.split("::").map(|s| s.trim()).collect();

    // Replace "Schema" with "Entity" in the last segment
    let entity_segments: Vec<String> = segments
        .iter()
        .map(|s| {
            if *s == "Schema" {
                "Entity".to_string()
            } else {
                s.to_string()
            }
        })
        .collect();

    // Build the path tokens
    let path_idents: Vec<syn::Ident> = entity_segments
        .iter()
        .map(|s| syn::Ident::new(s, proc_macro2::Span::call_site()))
        .collect();

    quote! { #(#path_idents)::* }
}

/// Generate `from_model` impl for SeaORM Model WITH relations (async version).
///
/// When circular references are detected, generates inline struct construction
/// that excludes circular fields (sets them to default values).
///
/// ```ignore
/// impl NewType {
///     pub async fn from_model(
///         model: SourceType,
///         db: &sea_orm::DatabaseConnection,
///     ) -> Result<Self, sea_orm::DbErr> {
///         // Load related entities
///         let user = model.find_related(user::Entity).one(db).await?;
///         let tags = model.find_related(tag::Entity).all(db).await?;
///
///         Ok(Self {
///             id: model.id,
///             // Inline construction with circular field defaulted:
///             user: user.map(|r| Box::new(user::Schema { id: r.id, memos: vec![], ... })),
///             tags: tags.into_iter().map(|r| tag::Schema { ... }).collect(),
///         })
///     }
/// }
/// ```
pub fn generate_from_model_with_relations(
    new_type_name: &syn::Ident,
    source_type: &Type,
    field_mappings: &[(syn::Ident, syn::Ident, bool, bool)],
    relation_fields: &[RelationFieldInfo],
    source_module_path: &[String],
    _schema_storage: &[StructMetadata],
) -> TokenStream {
    // Build relation loading statements
    let relation_loads: Vec<TokenStream> = relation_fields
        .iter()
        .map(|rel| {
            let field_name = &rel.field_name;
            let entity_path =
                build_entity_path_from_schema_path(&rel.schema_path, source_module_path);

            match rel.relation_type.as_str() {
                "HasOne" | "BelongsTo" => {
                    // Load single related entity
                    quote! {
                        let #field_name = model.find_related(#entity_path).one(db).await?;
                    }
                }
                "HasMany" => {
                    // Load multiple related entities
                    quote! {
                        let #field_name = model.find_related(#entity_path).all(db).await?;
                    }
                }
                _ => quote! {},
            }
        })
        .collect();

    // Check if we need a parent stub for HasMany relations with required circular back-refs
    // This is needed when: UserSchema.memos has MemoSchema which has required user: Box<UserSchema>
    // BUT: If the relation uses an inline type (which excludes circular fields), we don't need a parent stub
    let needs_parent_stub = relation_fields.iter().any(|rel| {
        if rel.relation_type != "HasMany" {
            return false;
        }
        // If using inline type, circular fields are excluded, so no parent stub needed
        if rel.inline_type_info.is_some() {
            return false;
        }
        let schema_path_str = rel.schema_path.to_string().replace(' ', "");
        let model_path_str = schema_path_str.replace("::Schema", "::Model");
        let related_model = find_struct_from_schema_path(&model_path_str);

        if let Some(ref model) = related_model {
            let circular_fields = detect_circular_fields(
                new_type_name.to_string().as_str(),
                source_module_path,
                &model.definition,
            );
            // Check if any circular field is a required relation
            circular_fields
                .iter()
                .any(|cf| is_circular_relation_required(&model.definition, cf))
        } else {
            false
        }
    });

    // Generate parent stub field assignments (non-relation fields from model)
    let parent_stub_fields: Vec<TokenStream> = if needs_parent_stub {
        field_mappings
            .iter()
            .map(|(new_ident, source_ident, _wrapped, is_relation)| {
                if *is_relation {
                    // For relation fields in stub, use defaults
                    if let Some(rel) = relation_fields
                        .iter()
                        .find(|r| &r.field_name == source_ident)
                    {
                        match rel.relation_type.as_str() {
                            "HasMany" => quote! { #new_ident: vec![] },
                            _ if rel.is_optional => quote! { #new_ident: None },
                            // Required single relations in parent stub - this shouldn't happen
                            // as we're creating stub to break circular ref
                            _ => quote! { #new_ident: None },
                        }
                    } else {
                        quote! { #new_ident: Default::default() }
                    }
                } else {
                    // Regular field - clone from model
                    quote! { #new_ident: model.#source_ident.clone() }
                }
            })
            .collect()
    } else {
        vec![]
    };

    // Build field assignments
    // For relation fields, check for circular references and use inline construction if needed
    let field_assignments: Vec<TokenStream> = field_mappings
        .iter()
        .map(|(new_ident, source_ident, wrapped, is_relation)| {
            if *is_relation {
                // Find the relation info for this field
                if let Some(rel) = relation_fields.iter().find(|r| &r.field_name == source_ident) {
                    let schema_path = &rel.schema_path;

                    // Try to find the related MODEL definition to check for circular refs
                    // The schema_path is like "crate::models::user::Schema", but the actual
                    // struct is "Model" in the same module. We need to look up the Model
                    // to see if it has relations pointing back to us.
                    let schema_path_str = schema_path.to_string().replace(' ', "");

                    // Convert schema path to model path: Schema -> Model
                    let model_path_str = schema_path_str.replace("::Schema", "::Model");

                    // Try to find the related Model definition from file
                    let related_model_from_file = find_struct_from_schema_path(&model_path_str);

                    // Get the definition string
                    let related_def_str = related_model_from_file.as_ref().map(|s| s.definition.as_str()).unwrap_or("");

                    // Check for circular references
                    // The source module path tells us what module we're in (e.g., ["crate", "models", "memo"])
                    // We need to check if the related model has any relation fields pointing back to our module
                    let circular_fields = detect_circular_fields(new_type_name.to_string().as_str(), source_module_path, related_def_str);

                    let has_circular = !circular_fields.is_empty();

                    // Check if we have inline type info - if so, use the inline type
                    // instead of the original schema path
                    if let Some((ref inline_type_name, ref included_fields)) = rel.inline_type_info {
                        // Use inline type construction
                        let inline_construct = generate_inline_type_construction(inline_type_name, included_fields, related_def_str, "r");

                        match rel.relation_type.as_str() {
                            "HasOne" | "BelongsTo" => {
                                if rel.is_optional {
                                    quote! {
                                        #new_ident: #source_ident.map(|r| Box::new(#inline_construct))
                                    }
                                } else {
                                    quote! {
                                        #new_ident: Box::new({
                                            let r = #source_ident.ok_or_else(|| sea_orm::DbErr::RecordNotFound(
                                                format!("Required relation '{}' not found", stringify!(#source_ident))
                                            ))?;
                                            #inline_construct
                                        })
                                    }
                                }
                            }
                            "HasMany" => {
                                quote! {
                                    #new_ident: #source_ident.into_iter().map(|r| #inline_construct).collect()
                                }
                            }
                            _ => quote! { #new_ident: Default::default() },
                        }
                    } else {
                        // No inline type - use original behavior
                        match rel.relation_type.as_str() {
                            "HasOne" | "BelongsTo" => {
                                if has_circular {
                                    // Use inline construction to break circular ref
                                    let inline_construct = generate_inline_struct_construction(schema_path, related_def_str, &circular_fields, "r");
                                    if rel.is_optional {
                                        quote! {
                                            #new_ident: #source_ident.map(|r| Box::new(#inline_construct))
                                        }
                                    } else {
                                        quote! {
                                            #new_ident: Box::new({
                                                let r = #source_ident.ok_or_else(|| sea_orm::DbErr::RecordNotFound(
                                                    format!("Required relation '{}' not found", stringify!(#source_ident))
                                                ))?;
                                                #inline_construct
                                            })
                                        }
                                    }
                                } else {
                                    // No circular ref - check if target schema has FK relations
                                    let target_has_fk = has_fk_relations(related_def_str);

                                    if target_has_fk {
                                        // Target schema has FK relations -> use async from_model()
                                        if rel.is_optional {
                                            quote! {
                                                #new_ident: match #source_ident {
                                                    Some(r) => Some(Box::new(#schema_path::from_model(r, db).await?)),
                                                    None => None,
                                                }
                                            }
                                        } else {
                                            quote! {
                                                #new_ident: Box::new(#schema_path::from_model(
                                                    #source_ident.ok_or_else(|| sea_orm::DbErr::RecordNotFound(
                                                        format!("Required relation '{}' not found", stringify!(#source_ident))
                                                    ))?,
                                                    db,
                                                ).await?)
                                            }
                                        }
                                    } else {
                                        // Target schema has no FK relations -> use sync From::from()
                                        if rel.is_optional {
                                            quote! {
                                                #new_ident: #source_ident.map(|r| Box::new(<#schema_path as From<_>>::from(r)))
                                            }
                                        } else {
                                            quote! {
                                                #new_ident: Box::new(<#schema_path as From<_>>::from(
                                                    #source_ident.ok_or_else(|| sea_orm::DbErr::RecordNotFound(
                                                        format!("Required relation '{}' not found", stringify!(#source_ident))
                                                    ))?
                                                ))
                                            }
                                        }
                                    }
                                }
                            }
                            "HasMany" => {
                                // HasMany is excluded by default, so this branch is only hit
                                // when explicitly picked. Use inline construction (no relations).
                                if has_circular {
                                    // Use inline construction to break circular ref
                                    let inline_construct = generate_inline_struct_construction(schema_path, related_def_str, &circular_fields, "r");
                                    quote! {
                                        #new_ident: #source_ident.into_iter().map(|r| #inline_construct).collect()
                                    }
                                } else {
                                    // No circular ref - check if target schema has FK relations
                                    let target_has_fk = has_fk_relations(related_def_str);

                                    if target_has_fk {
                                        // Target has FK relations but HasMany doesn't load nested data anyway,
                                        // so we use inline construction (flat fields only)
                                        let inline_construct = generate_inline_struct_construction(
                                            schema_path,
                                            related_def_str,
                                            &[], // no circular fields to exclude
                                            "r",
                                        );
                                        quote! {
                                            #new_ident: #source_ident.into_iter().map(|r| #inline_construct).collect()
                                        }
                                    } else {
                                        quote! {
                                            #new_ident: #source_ident.into_iter().map(|r| <#schema_path as From<_>>::from(r)).collect()
                                        }
                                    }
                                }
                            }
                            _ => quote! { #new_ident: Default::default() },
                        }
                    }
                } else {
                    quote! { #new_ident: Default::default() }
                }
            } else if *wrapped {
                quote! { #new_ident: Some(model.#source_ident) }
            } else {
                quote! { #new_ident: model.#source_ident }
            }
        })
        .collect();

    // Circular references are now handled automatically via inline construction
    // For HasMany with required circular back-refs, we create a parent stub first

    // Generate parent stub definition if needed
    let parent_stub_def = if needs_parent_stub {
        quote! {
            #[allow(unused_variables)]
            let __parent_stub__ = Self {
                #(#parent_stub_fields),*
            };
        }
    } else {
        quote! {}
    };

    quote! {
        impl #new_type_name {
            pub async fn from_model(
                model: #source_type,
                db: &sea_orm::DatabaseConnection,
            ) -> Result<Self, sea_orm::DbErr> {
                use sea_orm::ModelTrait;

                #(#relation_loads)*

                #parent_stub_def

                Ok(Self {
                    #(#field_assignments),*
                })
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use serial_test::serial;

    #[test]
    fn test_build_entity_path_from_schema_path() {
        let schema_path = quote! { crate::models::user::Schema };
        let result = build_entity_path_from_schema_path(&schema_path, &[]);
        let output = result.to_string();
        assert!(output.contains("crate"));
        assert!(output.contains("models"));
        assert!(output.contains("user"));
        assert!(output.contains("Entity"));
        assert!(!output.contains("Schema"));
    }

    #[test]
    fn test_build_entity_path_simple() {
        let schema_path = quote! { user::Schema };
        let result = build_entity_path_from_schema_path(&schema_path, &[]);
        let output = result.to_string();
        assert!(output.contains("user"));
        assert!(output.contains("Entity"));
    }

    #[test]
    fn test_build_entity_path_deeply_nested() {
        let schema_path = quote! { crate::api::models::entities::user::Schema };
        let result = build_entity_path_from_schema_path(&schema_path, &[]);
        let output = result.to_string();
        assert!(output.contains("api"));
        assert!(output.contains("models"));
        assert!(output.contains("entities"));
        assert!(output.contains("user"));
        assert!(output.contains("Entity"));
        assert!(!output.contains("Schema"));
    }

    #[test]
    fn test_build_entity_path_single_segment() {
        let schema_path = quote! { Schema };
        let result = build_entity_path_from_schema_path(&schema_path, &[]);
        let output = result.to_string();
        assert!(output.contains("Entity"));
    }

    // Tests for generate_from_model_with_relations

    fn create_test_relation_info(
        field_name: &str,
        relation_type: &str,
        schema_path: TokenStream,
        is_optional: bool,
    ) -> RelationFieldInfo {
        RelationFieldInfo {
            field_name: syn::Ident::new(field_name, proc_macro2::Span::call_site()),
            relation_type: relation_type.to_string(),
            schema_path,
            is_optional,
            inline_type_info: None,
        }
    }

    #[test]
    fn test_generate_from_model_with_required_relation() {
        let new_type_name = syn::Ident::new("MemoSchema", proc_macro2::Span::call_site());
        let source_type: Type = syn::parse_str("Model").unwrap();
        let field_mappings = vec![
            (
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                false,
                false,
            ),
            (
                syn::Ident::new("user", proc_macro2::Span::call_site()),
                syn::Ident::new("user", proc_macro2::Span::call_site()),
                false,
                true,
            ),
        ];
        // Required relation (is_optional = false)
        let relation_fields = vec![create_test_relation_info(
            "user",
            "HasOne",
            quote! { user::Schema },
            false,
        )];
        let source_module_path = vec![
            "crate".to_string(),
            "models".to_string(),
            "memo".to_string(),
        ];

        let tokens = generate_from_model_with_relations(
            &new_type_name,
            &source_type,
            &field_mappings,
            &relation_fields,
            &source_module_path,
            &[],
        );
        let output = tokens.to_string();

        assert!(output.contains("impl MemoSchema"));
        // Required relations should have RecordNotFound error handling
        assert!(output.contains("DbErr :: RecordNotFound"));
    }

    #[test]
    fn test_generate_from_model_with_wrapped_fields() {
        let new_type_name = syn::Ident::new("TestSchema", proc_macro2::Span::call_site());
        let source_type: Type = syn::parse_str("Model").unwrap();
        // Field with wrapped=true means it needs Some() wrapping
        let field_mappings = vec![(
            syn::Ident::new("id", proc_macro2::Span::call_site()),
            syn::Ident::new("id", proc_macro2::Span::call_site()),
            true, // wrapped
            false,
        )];
        let relation_fields = vec![];
        let source_module_path = vec!["crate".to_string()];

        let tokens = generate_from_model_with_relations(
            &new_type_name,
            &source_type,
            &field_mappings,
            &relation_fields,
            &source_module_path,
            &[],
        );
        let output = tokens.to_string();

        assert!(output.contains("Some (model . id)"));
    }

    #[test]
    fn test_generate_from_model_with_has_one_optional() {
        let new_type_name = syn::Ident::new("MemoSchema", proc_macro2::Span::call_site());
        let source_type: Type = syn::parse_str("Model").unwrap();
        let field_mappings = vec![
            (
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                false,
                false,
            ),
            (
                syn::Ident::new("user", proc_macro2::Span::call_site()),
                syn::Ident::new("user", proc_macro2::Span::call_site()),
                false,
                true,
            ),
        ];
        let relation_fields = vec![create_test_relation_info(
            "user",
            "HasOne",
            quote! { user::Schema },
            true,
        )];
        let source_module_path = vec![
            "crate".to_string(),
            "models".to_string(),
            "memo".to_string(),
        ];

        let tokens = generate_from_model_with_relations(
            &new_type_name,
            &source_type,
            &field_mappings,
            &relation_fields,
            &source_module_path,
            &[],
        );
        let output = tokens.to_string();

        assert!(output.contains("impl MemoSchema"));
        assert!(output.contains("pub async fn from_model"));
        // quote! produces spaced output like "sea_orm :: DatabaseConnection"
        assert!(output.contains("sea_orm :: DatabaseConnection"));
        assert!(output.contains("Result < Self , sea_orm :: DbErr >"));
        assert!(output.contains("find_related"));
        assert!(output.contains(". one (db)"));
    }

    #[test]
    fn test_generate_from_model_with_has_many() {
        let new_type_name = syn::Ident::new("UserSchema", proc_macro2::Span::call_site());
        let source_type: Type = syn::parse_str("Model").unwrap();
        let field_mappings = vec![
            (
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                false,
                false,
            ),
            (
                syn::Ident::new("memos", proc_macro2::Span::call_site()),
                syn::Ident::new("memos", proc_macro2::Span::call_site()),
                false,
                true,
            ),
        ];
        let relation_fields = vec![create_test_relation_info(
            "memos",
            "HasMany",
            quote! { memo::Schema },
            false,
        )];
        let source_module_path = vec![
            "crate".to_string(),
            "models".to_string(),
            "user".to_string(),
        ];

        let tokens = generate_from_model_with_relations(
            &new_type_name,
            &source_type,
            &field_mappings,
            &relation_fields,
            &source_module_path,
            &[],
        );
        let output = tokens.to_string();

        assert!(output.contains("impl UserSchema"));
        assert!(output.contains("pub async fn from_model"));
        assert!(output.contains(". all (db)"));
    }

    #[test]
    fn test_generate_from_model_with_belongs_to() {
        let new_type_name = syn::Ident::new("MemoSchema", proc_macro2::Span::call_site());
        let source_type: Type = syn::parse_str("Model").unwrap();
        let field_mappings = vec![
            (
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                false,
                false,
            ),
            (
                syn::Ident::new("user", proc_macro2::Span::call_site()),
                syn::Ident::new("user", proc_macro2::Span::call_site()),
                false,
                true,
            ),
        ];
        let relation_fields = vec![create_test_relation_info(
            "user",
            "BelongsTo",
            quote! { user::Schema },
            true,
        )];
        let source_module_path = vec![
            "crate".to_string(),
            "models".to_string(),
            "memo".to_string(),
        ];

        let tokens = generate_from_model_with_relations(
            &new_type_name,
            &source_type,
            &field_mappings,
            &relation_fields,
            &source_module_path,
            &[],
        );
        let output = tokens.to_string();

        assert!(output.contains("impl MemoSchema"));
        assert!(output.contains("find_related"));
        assert!(output.contains(". one (db)"));
    }

    #[test]
    fn test_generate_from_model_no_relations() {
        let new_type_name = syn::Ident::new("SimpleSchema", proc_macro2::Span::call_site());
        let source_type: Type = syn::parse_str("Model").unwrap();
        let field_mappings = vec![
            (
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                false,
                false,
            ),
            (
                syn::Ident::new("name", proc_macro2::Span::call_site()),
                syn::Ident::new("name", proc_macro2::Span::call_site()),
                false,
                false,
            ),
        ];
        let relation_fields = vec![];
        let source_module_path = vec!["crate".to_string()];

        let tokens = generate_from_model_with_relations(
            &new_type_name,
            &source_type,
            &field_mappings,
            &relation_fields,
            &source_module_path,
            &[],
        );
        let output = tokens.to_string();

        assert!(output.contains("impl SimpleSchema"));
        assert!(output.contains("id : model . id"));
        assert!(output.contains("name : model . name"));
    }

    #[test]
    fn test_generate_from_model_with_inline_type() {
        let new_type_name = syn::Ident::new("MemoSchema", proc_macro2::Span::call_site());
        let source_type: Type = syn::parse_str("Model").unwrap();
        let field_mappings = vec![
            (
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                false,
                false,
            ),
            (
                syn::Ident::new("user", proc_macro2::Span::call_site()),
                syn::Ident::new("user", proc_macro2::Span::call_site()),
                false,
                true,
            ),
        ];
        // Relation with inline type info (for circular references)
        let mut rel_info =
            create_test_relation_info("user", "HasOne", quote! { user::Schema }, true);
        rel_info.inline_type_info = Some((
            syn::Ident::new("MemoSchema_User", proc_macro2::Span::call_site()),
            vec!["id".to_string(), "name".to_string()],
        ));
        let relation_fields = vec![rel_info];
        let source_module_path = vec![
            "crate".to_string(),
            "models".to_string(),
            "memo".to_string(),
        ];

        let tokens = generate_from_model_with_relations(
            &new_type_name,
            &source_type,
            &field_mappings,
            &relation_fields,
            &source_module_path,
            &[],
        );
        let output = tokens.to_string();

        assert!(output.contains("impl MemoSchema"));
        assert!(output.contains("find_related"));
    }

    #[test]
    fn test_generate_from_model_unknown_relation_type() {
        let new_type_name = syn::Ident::new("TestSchema", proc_macro2::Span::call_site());
        let source_type: Type = syn::parse_str("Model").unwrap();
        let field_mappings = vec![
            (
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                false,
                false,
            ),
            (
                syn::Ident::new("unknown", proc_macro2::Span::call_site()),
                syn::Ident::new("unknown", proc_macro2::Span::call_site()),
                false,
                true,
            ),
        ];
        // Unknown relation type
        let relation_fields = vec![create_test_relation_info(
            "unknown",
            "UnknownType",
            quote! { some::Schema },
            true,
        )];
        let source_module_path = vec!["crate".to_string()];

        let tokens = generate_from_model_with_relations(
            &new_type_name,
            &source_type,
            &field_mappings,
            &relation_fields,
            &source_module_path,
            &[],
        );
        let output = tokens.to_string();

        // Unknown relation type should generate empty token (no load statement)
        assert!(output.contains("impl TestSchema"));
    }

    #[test]
    fn test_generate_from_model_relation_field_not_in_mappings() {
        let new_type_name = syn::Ident::new("TestSchema", proc_macro2::Span::call_site());
        let source_type: Type = syn::parse_str("Model").unwrap();
        let field_mappings = vec![
            (
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                false,
                false,
            ),
            // Relation field with different source_ident
            (
                syn::Ident::new("owner", proc_macro2::Span::call_site()),
                syn::Ident::new("different_name", proc_macro2::Span::call_site()),
                false,
                true,
            ),
        ];
        let relation_fields = vec![create_test_relation_info(
            "user",
            "HasOne",
            quote! { user::Schema },
            true,
        )];
        let source_module_path = vec!["crate".to_string()];

        let tokens = generate_from_model_with_relations(
            &new_type_name,
            &source_type,
            &field_mappings,
            &relation_fields,
            &source_module_path,
            &[],
        );
        let output = tokens.to_string();

        // Should still generate valid code
        assert!(output.contains("impl TestSchema"));
    }

    #[test]
    fn test_generate_from_model_with_has_many_inline() {
        let new_type_name = syn::Ident::new("UserSchema", proc_macro2::Span::call_site());
        let source_type: Type = syn::parse_str("Model").unwrap();
        let field_mappings = vec![
            (
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                false,
                false,
            ),
            (
                syn::Ident::new("memos", proc_macro2::Span::call_site()),
                syn::Ident::new("memos", proc_macro2::Span::call_site()),
                false,
                true,
            ),
        ];
        // HasMany with inline type
        let mut rel_info =
            create_test_relation_info("memos", "HasMany", quote! { memo::Schema }, false);
        rel_info.inline_type_info = Some((
            syn::Ident::new("UserSchema_Memos", proc_macro2::Span::call_site()),
            vec!["id".to_string(), "title".to_string()],
        ));
        let relation_fields = vec![rel_info];
        let source_module_path = vec![
            "crate".to_string(),
            "models".to_string(),
            "user".to_string(),
        ];

        let tokens = generate_from_model_with_relations(
            &new_type_name,
            &source_type,
            &field_mappings,
            &relation_fields,
            &source_module_path,
            &[],
        );
        let output = tokens.to_string();

        assert!(output.contains("impl UserSchema"));
        assert!(output.contains(". all (db)"));
        assert!(output.contains("into_iter"));
        assert!(output.contains("collect"));
    }

    // ============================================================
    // Coverage tests for file-based lookup branches
    // ============================================================

    #[test]
    #[serial]
    fn test_generate_from_model_needs_parent_stub_with_required_circular() {
        // Coverage for lines 96, 98, 106, 108-109, 111-114, 117, 120, 124, 307
        // Tests: HasMany relation where target model has REQUIRED circular back-ref
        // This triggers needs_parent_stub = true and generates parent stub fields
        use tempfile::TempDir;

        let temp_dir = TempDir::new().unwrap();
        let src_dir = temp_dir.path().join("src");
        let models_dir = src_dir.join("models");
        std::fs::create_dir_all(&models_dir).unwrap();

        // Create memo.rs with Model that has REQUIRED circular back-ref to user
        // The memo has `user: Box<UserSchema>` (not Option) - required
        let memo_model = r#"
pub struct Model {
    pub id: i32,
    pub title: String,
    pub user_id: i32,
    #[sea_orm(belongs_to = "super::user::Entity", from = "user_id")]
    pub user: BelongsTo<super::user::Entity>,
}
"#;
        std::fs::write(models_dir.join("memo.rs"), memo_model).unwrap();

        // Create user.rs
        let user_model = r#"
pub struct Model {
    pub id: i32,
    pub name: String,
}
"#;
        std::fs::write(models_dir.join("user.rs"), user_model).unwrap();

        // Save and set CARGO_MANIFEST_DIR
        let original_manifest_dir = std::env::var("CARGO_MANIFEST_DIR").ok();
        unsafe { std::env::set_var("CARGO_MANIFEST_DIR", temp_dir.path()) };

        let new_type_name = syn::Ident::new("UserSchema", proc_macro2::Span::call_site());
        let source_type: Type = syn::parse_str("crate::models::user::Model").unwrap();

        // Field mappings: id (regular), name (regular), memos (relation, HasMany)
        let field_mappings = vec![
            (
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                false,
                false,
            ),
            (
                syn::Ident::new("name", proc_macro2::Span::call_site()),
                syn::Ident::new("name", proc_macro2::Span::call_site()),
                false,
                false,
            ),
            (
                syn::Ident::new("memos", proc_macro2::Span::call_site()),
                syn::Ident::new("memos", proc_macro2::Span::call_site()),
                false,
                true, // is_relation
            ),
        ];

        // HasMany WITHOUT inline_type_info (triggers parent stub path)
        let relation_fields = vec![create_test_relation_info(
            "memos",
            "HasMany",
            quote! { crate::models::memo::Schema },
            false,
        )];

        let source_module_path = vec![
            "crate".to_string(),
            "models".to_string(),
            "user".to_string(),
        ];

        let tokens = generate_from_model_with_relations(
            &new_type_name,
            &source_type,
            &field_mappings,
            &relation_fields,
            &source_module_path,
            &[],
        );

        // Restore CARGO_MANIFEST_DIR
        unsafe {
            if let Some(dir) = original_manifest_dir {
                std::env::set_var("CARGO_MANIFEST_DIR", dir);
            } else {
                std::env::remove_var("CARGO_MANIFEST_DIR");
            }
        }

        let output = tokens.to_string();
        assert!(output.contains("impl UserSchema"));
        assert!(output.contains("from_model"));
        // Should have parent stub with __parent_stub__ (line 307)
        assert!(
            output.contains("__parent_stub__"),
            "Should have parent stub: {}",
            output
        );
    }

    #[test]
    #[serial]
    fn test_generate_from_model_circular_has_one_optional() {
        // Coverage for lines 200-202
        // Tests: HasOne with circular reference, optional
        use tempfile::TempDir;

        let temp_dir = TempDir::new().unwrap();
        let src_dir = temp_dir.path().join("src");
        let models_dir = src_dir.join("models");
        std::fs::create_dir_all(&models_dir).unwrap();

        // Create profile.rs with circular back-ref to user
        let profile_model = r#"
pub struct Model {
    pub id: i32,
    pub bio: String,
    pub user: BelongsTo<super::user::Entity>,
}
"#;
        std::fs::write(models_dir.join("profile.rs"), profile_model).unwrap();

        // Save and set CARGO_MANIFEST_DIR
        let original_manifest_dir = std::env::var("CARGO_MANIFEST_DIR").ok();
        unsafe { std::env::set_var("CARGO_MANIFEST_DIR", temp_dir.path()) };

        let new_type_name = syn::Ident::new("UserSchema", proc_macro2::Span::call_site());
        let source_type: Type = syn::parse_str("crate::models::user::Model").unwrap();

        let field_mappings = vec![
            (
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                false,
                false,
            ),
            (
                syn::Ident::new("profile", proc_macro2::Span::call_site()),
                syn::Ident::new("profile", proc_macro2::Span::call_site()),
                false,
                true,
            ),
        ];

        // HasOne, optional, WITHOUT inline_type_info
        let relation_fields = vec![create_test_relation_info(
            "profile",
            "HasOne",
            quote! { crate::models::profile::Schema },
            true, // optional
        )];

        let source_module_path = vec![
            "crate".to_string(),
            "models".to_string(),
            "user".to_string(),
        ];

        let tokens = generate_from_model_with_relations(
            &new_type_name,
            &source_type,
            &field_mappings,
            &relation_fields,
            &source_module_path,
            &[],
        );

        // Restore CARGO_MANIFEST_DIR
        unsafe {
            if let Some(dir) = original_manifest_dir {
                std::env::set_var("CARGO_MANIFEST_DIR", dir);
            } else {
                std::env::remove_var("CARGO_MANIFEST_DIR");
            }
        }

        let output = tokens.to_string();
        assert!(output.contains("impl UserSchema"));
        // Circular optional should have .map(|r| Box::new(...))
        assert!(
            output.contains(". map (| r |"),
            "Should have map for optional: {}",
            output
        );
    }

    #[test]
    #[serial]
    fn test_generate_from_model_circular_has_one_required() {
        // Coverage for line 206
        // Tests: HasOne with circular reference, required
        use tempfile::TempDir;

        let temp_dir = TempDir::new().unwrap();
        let src_dir = temp_dir.path().join("src");
        let models_dir = src_dir.join("models");
        std::fs::create_dir_all(&models_dir).unwrap();

        // Create profile.rs with circular back-ref to user
        let profile_model = r#"
pub struct Model {
    pub id: i32,
    pub bio: String,
    pub user: BelongsTo<super::user::Entity>,
}
"#;
        std::fs::write(models_dir.join("profile.rs"), profile_model).unwrap();

        // Save and set CARGO_MANIFEST_DIR
        let original_manifest_dir = std::env::var("CARGO_MANIFEST_DIR").ok();
        unsafe { std::env::set_var("CARGO_MANIFEST_DIR", temp_dir.path()) };

        let new_type_name = syn::Ident::new("UserSchema", proc_macro2::Span::call_site());
        let source_type: Type = syn::parse_str("crate::models::user::Model").unwrap();

        let field_mappings = vec![
            (
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                false,
                false,
            ),
            (
                syn::Ident::new("profile", proc_macro2::Span::call_site()),
                syn::Ident::new("profile", proc_macro2::Span::call_site()),
                false,
                true,
            ),
        ];

        // HasOne, REQUIRED, WITHOUT inline_type_info
        let relation_fields = vec![create_test_relation_info(
            "profile",
            "HasOne",
            quote! { crate::models::profile::Schema },
            false, // required
        )];

        let source_module_path = vec![
            "crate".to_string(),
            "models".to_string(),
            "user".to_string(),
        ];

        let tokens = generate_from_model_with_relations(
            &new_type_name,
            &source_type,
            &field_mappings,
            &relation_fields,
            &source_module_path,
            &[],
        );

        // Restore CARGO_MANIFEST_DIR
        unsafe {
            if let Some(dir) = original_manifest_dir {
                std::env::set_var("CARGO_MANIFEST_DIR", dir);
            } else {
                std::env::remove_var("CARGO_MANIFEST_DIR");
            }
        }

        let output = tokens.to_string();
        assert!(output.contains("impl UserSchema"));
        // Required circular should have Box::new with error handling
        assert!(
            output.contains("Box :: new"),
            "Should have Box::new for required: {}",
            output
        );
        assert!(
            output.contains("ok_or_else"),
            "Should have ok_or_else: {}",
            output
        );
    }

    #[test]
    fn test_generate_from_model_unknown_relation_with_inline_type() {
        // Coverage for line 192
        // Tests: Unknown relation type WITH inline_type_info -> Default::default()
        let new_type_name = syn::Ident::new("TestSchema", proc_macro2::Span::call_site());
        let source_type: Type = syn::parse_str("Model").unwrap();

        let field_mappings = vec![
            (
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                false,
                false,
            ),
            (
                syn::Ident::new("weird", proc_macro2::Span::call_site()),
                syn::Ident::new("weird", proc_macro2::Span::call_site()),
                false,
                true,
            ),
        ];

        // Unknown relation type WITH inline_type_info
        let mut rel_info = create_test_relation_info(
            "weird",
            "UnknownRelationType",
            quote! { some::Schema },
            true,
        );
        rel_info.inline_type_info = Some((
            syn::Ident::new("TestSchema_Weird", proc_macro2::Span::call_site()),
            vec!["id".to_string()],
        ));

        let relation_fields = vec![rel_info];
        let source_module_path = vec!["crate".to_string()];

        let tokens = generate_from_model_with_relations(
            &new_type_name,
            &source_type,
            &field_mappings,
            &relation_fields,
            &source_module_path,
            &[],
        );

        let output = tokens.to_string();
        assert!(output.contains("impl TestSchema"));
        // Unknown relation with inline type should use Default::default()
        assert!(
            output.contains("Default :: default ()"),
            "Should have Default::default(): {}",
            output
        );
    }

    #[test]
    #[serial]
    fn test_generate_from_model_non_circular_has_one_with_fk_optional() {
        // Coverage for lines 221-222
        // Tests: HasOne with FK relations in target, no circular, optional
        use tempfile::TempDir;

        let temp_dir = TempDir::new().unwrap();
        let src_dir = temp_dir.path().join("src");
        let models_dir = src_dir.join("models");
        std::fs::create_dir_all(&models_dir).unwrap();

        // Create address.rs with FK relations but NO circular back-ref to user
        let address_model = r#"
pub struct Model {
    pub id: i32,
    pub street: String,
    pub city_id: i32,
    pub city: BelongsTo<super::city::Entity>,
}
"#;
        std::fs::write(models_dir.join("address.rs"), address_model).unwrap();

        // Save and set CARGO_MANIFEST_DIR
        let original_manifest_dir = std::env::var("CARGO_MANIFEST_DIR").ok();
        unsafe { std::env::set_var("CARGO_MANIFEST_DIR", temp_dir.path()) };

        let new_type_name = syn::Ident::new("UserSchema", proc_macro2::Span::call_site());
        let source_type: Type = syn::parse_str("crate::models::user::Model").unwrap();

        let field_mappings = vec![
            (
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                false,
                false,
            ),
            (
                syn::Ident::new("address", proc_macro2::Span::call_site()),
                syn::Ident::new("address", proc_macro2::Span::call_site()),
                false,
                true,
            ),
        ];

        // HasOne, optional, no inline_type_info
        let relation_fields = vec![create_test_relation_info(
            "address",
            "HasOne",
            quote! { crate::models::address::Schema },
            true, // optional
        )];

        let source_module_path = vec![
            "crate".to_string(),
            "models".to_string(),
            "user".to_string(),
        ];

        let tokens = generate_from_model_with_relations(
            &new_type_name,
            &source_type,
            &field_mappings,
            &relation_fields,
            &source_module_path,
            &[],
        );

        // Restore CARGO_MANIFEST_DIR
        unsafe {
            if let Some(dir) = original_manifest_dir {
                std::env::set_var("CARGO_MANIFEST_DIR", dir);
            } else {
                std::env::remove_var("CARGO_MANIFEST_DIR");
            }
        }

        let output = tokens.to_string();
        assert!(output.contains("impl UserSchema"));
        // Non-circular with FK, optional should have match statement with async from_model
        assert!(
            output.contains("from_model (r , db) . await"),
            "Should have async from_model: {}",
            output
        );
    }

    #[test]
    #[serial]
    fn test_generate_from_model_non_circular_has_one_with_fk_required() {
        // Coverage for line 229
        // Tests: HasOne with FK relations in target, no circular, required
        use tempfile::TempDir;

        let temp_dir = TempDir::new().unwrap();
        let src_dir = temp_dir.path().join("src");
        let models_dir = src_dir.join("models");
        std::fs::create_dir_all(&models_dir).unwrap();

        // Create address.rs with FK relations but NO circular back-ref to user
        let address_model = r#"
pub struct Model {
    pub id: i32,
    pub street: String,
    pub city_id: i32,
    pub city: BelongsTo<super::city::Entity>,
}
"#;
        std::fs::write(models_dir.join("address.rs"), address_model).unwrap();

        // Save and set CARGO_MANIFEST_DIR
        let original_manifest_dir = std::env::var("CARGO_MANIFEST_DIR").ok();
        unsafe { std::env::set_var("CARGO_MANIFEST_DIR", temp_dir.path()) };

        let new_type_name = syn::Ident::new("UserSchema", proc_macro2::Span::call_site());
        let source_type: Type = syn::parse_str("crate::models::user::Model").unwrap();

        let field_mappings = vec![
            (
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                false,
                false,
            ),
            (
                syn::Ident::new("address", proc_macro2::Span::call_site()),
                syn::Ident::new("address", proc_macro2::Span::call_site()),
                false,
                true,
            ),
        ];

        // HasOne, REQUIRED, no inline_type_info
        let relation_fields = vec![create_test_relation_info(
            "address",
            "HasOne",
            quote! { crate::models::address::Schema },
            false, // required
        )];

        let source_module_path = vec![
            "crate".to_string(),
            "models".to_string(),
            "user".to_string(),
        ];

        let tokens = generate_from_model_with_relations(
            &new_type_name,
            &source_type,
            &field_mappings,
            &relation_fields,
            &source_module_path,
            &[],
        );

        // Restore CARGO_MANIFEST_DIR
        unsafe {
            if let Some(dir) = original_manifest_dir {
                std::env::set_var("CARGO_MANIFEST_DIR", dir);
            } else {
                std::env::remove_var("CARGO_MANIFEST_DIR");
            }
        }

        let output = tokens.to_string();
        assert!(output.contains("impl UserSchema"));
        // Required with FK should have Box::new with from_model call
        assert!(
            output.contains("Box :: new"),
            "Should have Box::new: {}",
            output
        );
        assert!(
            output.contains("from_model"),
            "Should have from_model: {}",
            output
        );
        assert!(
            output.contains("ok_or_else"),
            "Should have ok_or_else: {}",
            output
        );
    }

    #[test]
    #[serial]
    fn test_generate_from_model_has_many_with_circular() {
        // Coverage for lines 261-262
        // Tests: HasMany with circular reference
        use tempfile::TempDir;

        let temp_dir = TempDir::new().unwrap();
        let src_dir = temp_dir.path().join("src");
        let models_dir = src_dir.join("models");
        std::fs::create_dir_all(&models_dir).unwrap();

        // Create memo.rs with circular back-ref to user
        let memo_model = r#"
pub struct Model {
    pub id: i32,
    pub title: String,
    pub user: BelongsTo<super::user::Entity>,
}
"#;
        std::fs::write(models_dir.join("memo.rs"), memo_model).unwrap();

        // Save and set CARGO_MANIFEST_DIR
        let original_manifest_dir = std::env::var("CARGO_MANIFEST_DIR").ok();
        unsafe { std::env::set_var("CARGO_MANIFEST_DIR", temp_dir.path()) };

        let new_type_name = syn::Ident::new("UserSchema", proc_macro2::Span::call_site());
        let source_type: Type = syn::parse_str("crate::models::user::Model").unwrap();

        let field_mappings = vec![
            (
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                false,
                false,
            ),
            (
                syn::Ident::new("memos", proc_macro2::Span::call_site()),
                syn::Ident::new("memos", proc_macro2::Span::call_site()),
                false,
                true,
            ),
        ];

        // HasMany WITHOUT inline_type_info - will use generate_inline_struct_construction
        let relation_fields = vec![create_test_relation_info(
            "memos",
            "HasMany",
            quote! { crate::models::memo::Schema },
            false,
        )];

        let source_module_path = vec![
            "crate".to_string(),
            "models".to_string(),
            "user".to_string(),
        ];

        let tokens = generate_from_model_with_relations(
            &new_type_name,
            &source_type,
            &field_mappings,
            &relation_fields,
            &source_module_path,
            &[],
        );

        // Restore CARGO_MANIFEST_DIR
        unsafe {
            if let Some(dir) = original_manifest_dir {
                std::env::set_var("CARGO_MANIFEST_DIR", dir);
            } else {
                std::env::remove_var("CARGO_MANIFEST_DIR");
            }
        }

        let output = tokens.to_string();
        assert!(output.contains("impl UserSchema"));
        // HasMany with circular should have into_iter().map().collect()
        assert!(
            output.contains("into_iter ()"),
            "Should have into_iter: {}",
            output
        );
        assert!(
            output.contains(". map (| r |"),
            "Should have map: {}",
            output
        );
        assert!(
            output.contains("collect"),
            "Should have collect: {}",
            output
        );
    }

    #[test]
    #[serial]
    fn test_generate_from_model_has_many_with_fk_no_circular() {
        // Coverage for lines 272-276, 278
        // Tests: HasMany with FK relations in target, no circular
        use tempfile::TempDir;

        let temp_dir = TempDir::new().unwrap();
        let src_dir = temp_dir.path().join("src");
        let models_dir = src_dir.join("models");
        std::fs::create_dir_all(&models_dir).unwrap();

        // Create tag.rs with FK relations but NO circular back-ref to user
        let tag_model = r#"
pub struct Model {
    pub id: i32,
    pub name: String,
    pub category_id: i32,
    pub category: BelongsTo<super::category::Entity>,
}
"#;
        std::fs::write(models_dir.join("tag.rs"), tag_model).unwrap();

        // Save and set CARGO_MANIFEST_DIR
        let original_manifest_dir = std::env::var("CARGO_MANIFEST_DIR").ok();
        unsafe { std::env::set_var("CARGO_MANIFEST_DIR", temp_dir.path()) };

        let new_type_name = syn::Ident::new("UserSchema", proc_macro2::Span::call_site());
        let source_type: Type = syn::parse_str("crate::models::user::Model").unwrap();

        let field_mappings = vec![
            (
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                false,
                false,
            ),
            (
                syn::Ident::new("tags", proc_macro2::Span::call_site()),
                syn::Ident::new("tags", proc_macro2::Span::call_site()),
                false,
                true,
            ),
        ];

        // HasMany, no inline_type_info
        let relation_fields = vec![create_test_relation_info(
            "tags",
            "HasMany",
            quote! { crate::models::tag::Schema },
            false,
        )];

        let source_module_path = vec![
            "crate".to_string(),
            "models".to_string(),
            "user".to_string(),
        ];

        let tokens = generate_from_model_with_relations(
            &new_type_name,
            &source_type,
            &field_mappings,
            &relation_fields,
            &source_module_path,
            &[],
        );

        // Restore CARGO_MANIFEST_DIR
        unsafe {
            if let Some(dir) = original_manifest_dir {
                std::env::set_var("CARGO_MANIFEST_DIR", dir);
            } else {
                std::env::remove_var("CARGO_MANIFEST_DIR");
            }
        }

        let output = tokens.to_string();
        assert!(output.contains("impl UserSchema"));
        // HasMany with FK but no circular should use inline_struct_construction
        assert!(
            output.contains("into_iter ()"),
            "Should have into_iter: {}",
            output
        );
        assert!(
            output.contains(". map (| r |"),
            "Should have map: {}",
            output
        );
        assert!(
            output.contains("collect"),
            "Should have collect: {}",
            output
        );
    }

    #[test]
    #[serial]
    fn test_generate_from_model_inline_type_required() {
        // Coverage for lines in inline type with required relation
        // Tests: inline_type_info with required BelongsTo
        use tempfile::TempDir;

        let temp_dir = TempDir::new().unwrap();
        let src_dir = temp_dir.path().join("src");
        let models_dir = src_dir.join("models");
        std::fs::create_dir_all(&models_dir).unwrap();

        let user_model = r#"
pub struct Model {
    pub id: i32,
    pub name: String,
}
"#;
        std::fs::write(models_dir.join("user.rs"), user_model).unwrap();

        // Save and set CARGO_MANIFEST_DIR
        let original_manifest_dir = std::env::var("CARGO_MANIFEST_DIR").ok();
        unsafe { std::env::set_var("CARGO_MANIFEST_DIR", temp_dir.path()) };

        let new_type_name = syn::Ident::new("MemoSchema", proc_macro2::Span::call_site());
        let source_type: Type = syn::parse_str("crate::models::memo::Model").unwrap();

        let field_mappings = vec![
            (
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                false,
                false,
            ),
            (
                syn::Ident::new("user", proc_macro2::Span::call_site()),
                syn::Ident::new("user", proc_macro2::Span::call_site()),
                false,
                true,
            ),
        ];

        // BelongsTo with inline_type_info, REQUIRED
        let mut rel_info = create_test_relation_info(
            "user",
            "BelongsTo",
            quote! { crate::models::user::Schema },
            false, // required
        );
        rel_info.inline_type_info = Some((
            syn::Ident::new("MemoSchema_User", proc_macro2::Span::call_site()),
            vec!["id".to_string(), "name".to_string()],
        ));

        let relation_fields = vec![rel_info];
        let source_module_path = vec![
            "crate".to_string(),
            "models".to_string(),
            "memo".to_string(),
        ];

        let tokens = generate_from_model_with_relations(
            &new_type_name,
            &source_type,
            &field_mappings,
            &relation_fields,
            &source_module_path,
            &[],
        );

        // Restore CARGO_MANIFEST_DIR
        unsafe {
            if let Some(dir) = original_manifest_dir {
                std::env::set_var("CARGO_MANIFEST_DIR", dir);
            } else {
                std::env::remove_var("CARGO_MANIFEST_DIR");
            }
        }

        let output = tokens.to_string();
        assert!(output.contains("impl MemoSchema"));
        // Required inline type should have Box::new with ok_or_else
        assert!(
            output.contains("Box :: new"),
            "Should have Box::new: {}",
            output
        );
        assert!(
            output.contains("ok_or_else"),
            "Should have ok_or_else: {}",
            output
        );
    }

    #[test]
    #[serial]
    fn test_generate_from_model_parent_stub_all_relation_types() {
        // Coverage for lines 114, 117, 120
        // Tests: Parent stub generation with:
        use tempfile::TempDir;

        let temp_dir = TempDir::new().unwrap();
        let src_dir = temp_dir.path().join("src");
        let models_dir = src_dir.join("models");
        std::fs::create_dir_all(&models_dir).unwrap();

        // Create memo.rs with REQUIRED circular back-ref to user
        // This triggers needs_parent_stub = true
        let memo_model = r#"
pub struct Model {
    pub id: i32,
    pub title: String,
    pub user_id: i32,
    #[sea_orm(belongs_to = "super::user::Entity", from = "user_id")]
    pub user: BelongsTo<super::user::Entity>,
}
"#;
        std::fs::write(models_dir.join("memo.rs"), memo_model).unwrap();

        // Create profile.rs (for optional single relation)
        let profile_model = r#"
pub struct Model {
    pub id: i32,
    pub bio: String,
}
"#;
        std::fs::write(models_dir.join("profile.rs"), profile_model).unwrap();

        // Create settings.rs (for required single relation)
        let settings_model = r#"
pub struct Model {
    pub id: i32,
    pub theme: String,
}
"#;
        std::fs::write(models_dir.join("settings.rs"), settings_model).unwrap();

        // Save and set CARGO_MANIFEST_DIR
        let original_manifest_dir = std::env::var("CARGO_MANIFEST_DIR").ok();
        unsafe { std::env::set_var("CARGO_MANIFEST_DIR", temp_dir.path()) };

        let new_type_name = syn::Ident::new("UserSchema", proc_macro2::Span::call_site());
        let source_type: Type = syn::parse_str("crate::models::user::Model").unwrap();

        // Field mappings with various relation types
        let field_mappings = vec![
            // Regular field
            (
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                syn::Ident::new("id", proc_macro2::Span::call_site()),
                false,
                false,
            ),
            // HasMany (line 113) - this one triggers needs_parent_stub
            (
                syn::Ident::new("memos", proc_macro2::Span::call_site()),
                syn::Ident::new("memos", proc_macro2::Span::call_site()),
                false,
                true,
            ),
            // Optional single relation (line 114)
            (
                syn::Ident::new("profile", proc_macro2::Span::call_site()),
                syn::Ident::new("profile", proc_macro2::Span::call_site()),
                false,
                true,
            ),
            // Required single relation (line 117)
            (
                syn::Ident::new("settings", proc_macro2::Span::call_site()),
                syn::Ident::new("settings", proc_macro2::Span::call_site()),
                false,
                true,
            ),
            // Relation field NOT in relation_fields (line 120)
            (
                syn::Ident::new("orphan_rel", proc_macro2::Span::call_site()),
                syn::Ident::new("orphan_rel", proc_macro2::Span::call_site()),
                false,
                true,
            ),
        ];

        // Relation fields - note: orphan_rel is NOT included here (hits line 120)
        let relation_fields = vec![
            // HasMany without inline_type_info (triggers needs_parent_stub)
            create_test_relation_info(
                "memos",
                "HasMany",
                quote! { crate::models::memo::Schema },
                false,
            ),
            // Optional HasOne (hits line 114)
            create_test_relation_info(
                "profile",
                "HasOne",
                quote! { crate::models::profile::Schema },
                true, // optional
            ),
            // Required BelongsTo (hits line 117)
            create_test_relation_info(
                "settings",
                "BelongsTo",
                quote! { crate::models::settings::Schema },
                false, // required
            ),
            // Note: orphan_rel is NOT in relation_fields (hits line 120)
        ];

        let source_module_path = vec![
            "crate".to_string(),
            "models".to_string(),
            "user".to_string(),
        ];

        let tokens = generate_from_model_with_relations(
            &new_type_name,
            &source_type,
            &field_mappings,
            &relation_fields,
            &source_module_path,
            &[],
        );

        // Restore CARGO_MANIFEST_DIR
        unsafe {
            if let Some(dir) = original_manifest_dir {
                std::env::set_var("CARGO_MANIFEST_DIR", dir);
            } else {
                std::env::remove_var("CARGO_MANIFEST_DIR");
            }
        }

        let output = tokens.to_string();
        assert!(output.contains("impl UserSchema"));
        // Should have parent stub (line 307)
        assert!(
            output.contains("__parent_stub__"),
            "Should have parent stub: {}",
            output
        );
        // Parent stub should have various default values
        // Line 113: memos: vec![]
        assert!(
            output.contains("memos : vec ! []"),
            "Should have memos: vec![]: {}",
            output
        );
        // Line 114 & 117: profile/settings: None (both optional and required single relations)
        // (Both produce None in parent stub)
        assert!(
            output.contains("profile : None") || output.contains("settings : None"),
            "Should have None for single relations: {}",
            output
        );
        // Line 120: orphan_rel: Default::default()
        assert!(
            output.contains("Default :: default ()"),
            "Should have Default::default() for orphan: {}",
            output
        );
    }
}