Is it possible to define fields on types separately from the type itself?

[rohan-mehta]

I have a circular import in my code. It looks something like this:

# user.py
import strawberry
from .posts import Post

@strawberry.type
class User:
    name: str

    @strawberry.field   
    async def recent_post() -> Post:
      post_data: dict = fetch_post()
      return Post(**post_data)



# post.py
import strawberry
from .users import User

@strawberry.type
class Post:
    text: str
    uid: strawberry.Private[str]

    @strawberry.field   
    async def owner() -> User:
      user_data: dict = fetch_user(self.uid)
      return User(name=user_data["name"])
      

The Lazy types documentation doesn't really solve for this, because we don't just need the types for type checking - we actually need it at runtime to call the constructors for User() and Post().

My ideal solution would be to define the Post and User types as simple data model objects in one file. Then "extend" them by adding resolved fields from somewhere else. Something like this:

# user.py
import strawberry

@strawberry.type
class User:
    name: str


# post.py
import strawberry

@strawberry.type
class Post:
    text: str
    uid: strawberry.Private[str]

# user_extension.py
import strawberry
from .user import User
from .post import Post

async def fetch_recent_post(user: User) -> Post:
    ...

async def extend_user():
    User.add_field(
        "recent_post",
        fetch_recent_post
    )

# post_extension.py

import strawberry
from .user import User
from .post import Post

async def fetch_user(post: Post, uid: str) -> User:
    ...

async def extend_post():
    Post.add_field(
        "owner",
        fetch_user,
    )

# root_schema.py
from .post_extension import extend_post
from .user_extension import extend_user

schema = strawberry.Schema(query=Query, extend_with = [extend_user, extend_post])

Is something like that possible? Thanks!

[DoctorJohn]

If I understand you problem correctly, the following would be the easiest solution:

import strawberry
import typing

if typing.TYPE_CHECKING:
    from .posts import Post

@strawberry.type
class User:
    name: str

    @strawberry.field   
    async def recent_post() -> Annotated["Post", strawberry.lazy(".posts")]:
      from .posts import Post
      post_data: dict = fetch_post()
      return Post(**post_data)

However, you can also define field resolvers separately from the fields as shown in our resolvers documentation.

[rohan-mehta]

Thanks @DoctorJohn. Your solution is what I'm doing now, but I don't love local imports because of the various cons (worse readability, potential bad performance, runtime errors if you forget to import, etc)

However, you can also define field resolvers separately from the fields as shown in our resolvers documentation.

This unfortunately doesn't help. Because even if you define the resolver in a different file, you still need to import it, which means it causes the same issues. It might help if there were a "lazy resolver" perhaps?

[DoctorJohn]

I see, did you take a look at our tools documentation yet? Your extend_post proposal reminds me of our merge_types helper.

[rohan-mehta]

Oh interesting. That does seem related. Though I tried to come up with a solution using merge_types and I couldn't really 😅