Hi all!

TL;DR: is there a way to split a single schema into multiple crates without having to resort to making completely different applications and federating them?

Longer explanation: In our project, we're trying to divide the codebase into multiple independent crates so that each encapsulates an entire business context, supplying all related entities, use cases, interfaces and implementations such as DB repositories, etc.

For instance, we would have a users crate providing the main User entity, a UserRepository interface with its PostgresUserRepository concrete implementation, a UserService that provides the various create(), change_name(), follow() business logic functions, etc...

Then we'd also have a posts crate with Post, PostRepository and yadda yadda.

The two crates are related (a Post has a creator that is a User, a User owns multiple Posts) but not strictly dependent as the link between the two entities is simply an ID.

We would love for each crate to also provide async-graphql Objects to contribute to the application schema, but I'm having trouble representing the relationship between the two without importing each other's types (which we can't do because of the cyclic dependency rule of Rust crates).

My goal is to be able to represent this query:

{
  users {
    posts {
      creator {
        posts {
          creator {
            id
          }
        }
      }
    }
  }
}

Each crate would provide its own root Query object, that is then passed to the schema via a merged object:

#[derive(Default, MergedObject)]
struct RootQuery(UsersQuery, PostsQuery);

let schema = Schema::build(RootQuery::default(), EmptyMutation, EmptySubscription)

I tried to make a struct in posts called User with just an ID field and marking it with #[graphql(extends)], but it doesn't seem to work as I think that's only for GQL Federation support.

#[derive(SimpleObject)]
#[graphql(complex)]
pub struct Post {
    id: ID,
    content: String,
    #[graphql(skip)]
    creator_id: ID,
}

#[ComplexObject]
impl Post {
    async fn creator(&self) -> User {
        User { id: self.creator_id.clone() }
    }
}

#[derive(SimpleObject)]
#[graphql(extends)]
struct User {
    id: ID,
}

If I try to run the application I get this error:

users::User and posts::User have the same GraphQL name User

So my question is: is there a way to split a single schema into multiple crates without having to resort to making completely different applications and federating them?