How should inheritance work with types?

[BryceBeagle]

There are three different ways that inheritance can be involved in the creation of Strawberry types:

1. Using interfaces

   @strawberry.interface
   class BaseClass:
       name: int
   
   @strawberry.type
   class Subclass1(BaseClass):
       age: int
   
   @strawberry.type
   class Subclass2(BaseClass):
       address: str

2. Using non-Strawberry base classes

   class BaseClass:
       name: int
   
   @strawberry.type
   class Subclass1(BaseClass):
       age: int
   
   @strawberry.type
   class Subclass2(BaseClass):
       address: str

3. Using Strawberry-type base classes

   @strawberry.type
   class BaseClass:
       name: int
   
   @strawberry.type
   class Subclass1(BaseClass):
       age: int
   
   @strawberry.type
   class Subclass2(BaseClass):
       address: str

Should all be accepted? My inclination is yes, which is the current but-not-specified behavior. Using @strawberry.interface and @strawberry.type ensure that the types get added to the GraphQL schema, but using a bare class means it will only exist in Python.

Secondly, what should the behavior for each be? What should happen if a subclass overrides a field on the parent class. Examples of overriding I can think of:

• Base class just defines a field with just a type; subclass adds a default value
• Base class gives a default value; subclass uses a resolver instead
• Base class uses a resolver; subclass defines a default value
• Base class uses one type; subclass uses a completely different type
• Base class uses a broad type (e.g. Optional[int]); subclass uses a more narrow type (e.g. int)

[coady]

I rely on inheritance, particularly for input types. Which can't use interfaces anyway, so that's a good use case.

I also rely on overriding fields to restrict types.