Manually resolve type from root

[Object905]

Hello!

Is there a way to manually resolve objects to strawberry.type objects?
For example in my federation schema I'm doing this to get Provider object from models.Provider.

@federation.type(keys=["id"])
class Provider:
    id: strawberry.ID
    name: str
    slug: str
    consumed_by: "Provider | None"

    @classmethod
    def resolve_reference(cls, info: Info, **kwargs):
        obj: models.Provider = models.Provider.objects.get(id=kwargs["id"])
        return Provider(
            id=obj.pk,
            name=obj.name,
            slug=obj.slug,
            consumed_by=obj.consumed_by,
        )

Which is fine for objects with few fields, but becomes messy for larger ones.

Is there a helper function to be able to do something like this:

def resolve_reference(cls, info: Info, **kwargs):
    obj: models.Provider = models.Provider.objects.get(id=kwargs["id"])
    return resolve_type(cls, obj, info)

I've seen some code inside the library using strawberry.arguments.convert_argument, but was not able to use it correctly. And it seems that I'm misusing it altogeter.
This gives an error:

@classmethod
def resolve_reference(cls, info: Info, **kwargs):
    obj: models.Provider = models.Provider.objects.get(id=kwargs["id"])

    strawberry_schema = info.schema.extensions["strawberry-definition"]
    config = strawberry_schema.config
    scalar_registry = strawberry_schema.schema_converter.scalar_registry
    return convert_argument(obj, cls, scalar_registry=scalar_registry, config=config)

[jkimbo]

@Object905 there isn't a way of automatically converting ORM models to Strawberry types (unless you use strawberry-django). The pattern I usually follow is to define a from_instance class method on the type where the conversion happens. Taking your example:

@federation.type(keys=["id"])
class Provider:
    id: strawberry.ID
    name: str
    slug: str
    consumed_by: "Provider | None"

    @classmethod
    def from_instance(cls, instance: models.Provider):
        return cls(
            id=obj.pk,
            name=obj.name,
            slug=obj.slug,
            consumed_by=obj.consumed_by,
        )

    @classmethod
    def resolve_reference(cls, info: Info, **kwargs):
        obj: models.Provider = models.Provider.objects.get(id=kwargs["id"])
        return Provider.from_instance(obj)

[Object905]

Well that would be a useful feature to have and would eliminate redundant code.

Maybe in future I'll try to write some wrapper that would inherit target strawberry type, but actually will store all needed information and root object inside and resolve fields from it.

For objects with simple fields and simple function resolvers (that may resolve both from themselves and root object), like in example it seems like it would be fairly simple (just get all fields with StrawberryConfig.default_resolver and construct object from struct).

[jkimbo]

@Object905 it would reduce code but IMO it increases complexity. You need a way of defining the mapping of the Django field type to the Strawberry field type and then you have to do that conversion at runtime. Strawberry-django is the closest option since it allows you to "inherit" from a Django model and define the mapping from model to type: https://github.com/strawberry-graphql/strawberry-graphql-django