Introspection query result json as input for codegen

[fishi0x01]

The codegen feature currently requires the schema to be written in strawberry. It would be great if codegen was server lib agnostic, i.e., it receives an introspection query result (json) as an input and generates classes based on that, similar to how other tools like https://github.com/profusion/sgqlc do. This would drastically increase the use-cases for the codegen feature.

Is this a reasonable thought?

[helderco]

That's a great idea 👍

I have a sort of federated setup where my Python schema is only a small subset of the larger API that I need to interact with. I'm going to need this feature now but I have to contrast the current capabilities and intended future direction with my needs. In case they align I have some bandwidth to contribute this.

This documentation refers to an experimental feature of Strawberry, these features may change significantly and without a warning before they become a part of the main strawberry API.

This documentation is aimed at early adopters and people who are curious. If you're interested in contributing to this feature join the discussion on our GitHub page.

- https://strawberry.rocks/docs/codegen/query-codegen

I couldn't find anything else on this this, is there another discussion or issue tracking design for codegen?

[patrick91]

@helderco we don't have any concrete plans for the query codegen feature, it might be nice to chat with (maybe on discord) about this, I want to understand your use case more!

[helderco]

I've already explored the strawberry capabilities and what I need.

I'm making a library for dagger which includes 2 parts:

1. Server side schema extension (sub-schema to extend the larger schema)
2. Client side API to talk to the whole API

Server schema

The server side sub-schema means that I can't just use the strawberry schema. I need to generate a client from the GraphQL endpoint. So, in effect, this feature doesn't actually depend on Strawberry. But if Strawberry codegen does what you propose and be lib agnostic, than that's less work on my side, or even one less dependency if some other tool does it.

Client API

This is my focus right now. The objective is to have a typed query builder so you use native Python objects to build a GraphQL query instead of using query strings.

I'm using the query builder from gql but it's not typed. It'll fail if you use the wrong field names, before even executing the query (runtime) but you don't have IDE auto-completion, etc.

So I'm building a typed API on top of that query builder, it'll look something like this:

>>> import dagger
>>> with dagger.Client() as api:
...  alpine = api.container().from_(address="python:alpine")
...  version = alpine.exec(args=["python", "-V"]).stdout().contents()
...  print(version)
...
Python 3.10.8

Which produces the following query:

{
    container {
        from(address="python:alpine") {
            exec(args: ["python", "-V"]) {
                stdout {
                    contents
                }
            }
        }
    }
}

And returns the last scalar directly (contents).

Codegen

The above implementation is tailored to Dagger as of now, but the general point here is to have a typed query builder. And then with codegen, use graphql inspection to generate these classes.

Here's a sample of the generated file:

# client.gen.py
from dagger.client.api import Type

class Query(Type):
    def container(self, id: Optional[ContainerID | str] = None) -> "Container":
        """
        Load a container from ID.
        Null ID returns an empty container (scratch).
        """
        ctx = self._select("container", {"id": id})
        return Container(ctx)


class Container(Type):
    """
    An OCI-compatible container, also known as a docker container
    """

    def from_(self, address: ContainerAddress | str) -> "Container":
        """
        Initialize this container from the base image published at the given address
        """
        ctx = self._select("from", {"address": address})
        return Container(ctx)

    def exec(self, args: list[str], opts: ExecOpts | None = None) -> "Container":
        """
        This container after executing the specified command inside it
        """
        ctx = self._select("exec", {"args": args, "opts": opts})
        return Container(ctx)

    def stdout(self) -> "File":
        """
        The output stream of the last executed command.
        Null if no command has been executed.
        """
        ctx = self._select("stdout", {})
        return File(ctx)


class File(Type):
    """
    A file
    """

    def contents(self) -> str:
        """
        The contents of the file
        """
        ctx = self._select("contents", {})
        return ctx.execute()

As of now I'm finalizing (testing) the API itself, next I need to codegen this.

TLDR

Since I can make my own plugin, I just need the introspection from the whole API instead of a strawberry schema.