Support multi-level chaining of find_also_related for querying multiple related entities

[cnwzhu]

SeaORM's find_also_related only supports two chained calls and does not allow multiple chained invocations. Is it possible to improve this? Otherwise, it's not feasible to query multiple related entities in a single call.
For example, the following pattern fails to compile or function as expected:

EntityA::find()
    .find_also_related::<EntityB>()
    .find_also_related::<EntityC>() 
    .find_also_related::<EntityD>()
    .find_also_related::<EntityE>()  
    .all(&db)
    .await?;

[For8stt]

find_also_related is not really designed as an unlimited multi-join / nested graph loader.

It has typed return shapes like:

(A, Option<B>)
(A, Option<B>, Option<C>)

So after a few chained calls the type-level result shape becomes hard to express and SeaORM only supports a limited number of those combinations.

For this case I’d probably use one of these approaches instead:

1. Use find_with_related for one-to-many

let rows: Vec<(a::Model, Vec<b::Model>)> = A::find()
    .find_with_related(B)
    .all(db)
    .await?;

2. Use manual joins + custom result model

If the query shape is fixed, this is usually cleaner:

#[derive(Debug, FromQueryResult)]
struct Row {
    a_id: i32,
    b_id: Option<i32>,
    c_id: Option<i32>,
}

let rows = A::find()
    .select_only()
    .column_as(a::Column::Id, "a_id")
    .column_as(b::Column::Id, "b_id")
    .column_as(c::Column::Id, "c_id")
    .join(JoinType::LeftJoin, a::Relation::B.def())
    .join(JoinType::LeftJoin, b::Relation::C.def())
    .into_model::<Row>()
    .all(db)
    .await?;

3. Load in batches

For bigger relation graphs, I’d avoid one huge join and do:

load A
load B where a_id IN (...)
load C where b_id IN (...)
load D where c_id IN (...)

Then group them in Rust.

So yeah, supporting more chained find_also_related calls would be nice, but I wouldn’t rely on that for deep graphs. Explicit joins or batched loading are usually easier to control and debug.