So you have a scope with selection fields in the form scope { user { ... } friends { ... } }.

You would like the whole tree to be fetched during the same transaction, starting from the scope node and progressing into the inner fields.

I don't think you need a Dataloader, just the shared transaction for inner resolvers:

impl Mutation {
  fn scope(...) -> Scope {
    // do mutation with the first transaction, commit
    let tx = new_read_only_transaction();
    Scope {
        tx,
        dataloader: DbEntityLoader::new(tx),
        user_id,
        friends_ids,
    }
}

#[graphql(complex)]
struct Scope {
  tx: DatabaseTransaction,     // either this scope object keeps the transaction
  dataloader: DbEntityLoader,  // or it keeps the loader itself
  user_id: i64,
  friends_ids: Vec<i64>,
}

#[ComplexObject]
impl Scope {
    pub fn user(&self, ...) -> Result<User, _> {
        users::Entity::find(self.user_id).exec(self.tx)
    }

    pub fn friends(&self, ...) -> Result<Vec<Friend, _>> {
        self.dataloader.load_many(self.friends_ids).await  // makes calls through the transaction
    }

So you basically create a local context, which is used by all the inner resolvers.

This logic can be organized differently. In my code I have a few helper types:

• EntityLoader<SeaOrmEntity, GraphQLOutputType>(db) — implements async_graphql::dataloader::Loader and knows how to fetch SeaORM entities (SELECT *) and convert them into GraphQLOutputType
• Lazy<Loader: async_graphql::dataloader::Loader<i64>> — implements OutputType, ContainerType and ObjectType traits and if fields other than id were selected by users, then fetches the object through the dataloader
• ScopedLazy<...>(tx) — I don't have it, but it could be organized in the same way, and encapsulate the approach described above. Like fetch entities using the local transaction.