graphql-faker, but code-first and in Python

[LouisAmon]

Have you ever played around with Javascript's graphql-faker ?

It's a nice wrapper for schema-first GraphQL APIs that uses directives to generate fake data on the fly, which allows frontend teams to get started on their code without having to wait on their backend team.

Because it relies heavily on directives, it seems unsuitable for code-first frameworks as even rendering directives seems to be something that no code-first GraphQL framework can do (or wants to do for that matter)

I think that using faker would allow Strawberry to do the same thing, with the added benefit that you can also define your own generator on the fly (being a code-first framework) instead of solely relying on existing ones.

I'm thinking of something like this:

import random

import strawberry
import faker

fake = faker.Faker(locale="fr_FR")

@strawberry.type
class User:
    first_name: str = strawberry.field(factory=lambda: random.choice(["Rémi", "Jean"])
    last_name: str = strawberry.field(description="Family name", factory=fake.last_name)

Or something even more deeply integrated with the faker library:
last_name: str = strawberry.field(factory="last_name")
(in which case there is the question of setting a project-wide locale, in some sort of "strawberry settings" or via environment variable)

The idea of using factory instead of maybe using dataclasses.field.default_factory is that in production, you don't want an instance that has a missing attribute to be silently created with fake data: hence the idea of removing the default from default_factory

What do you think ? 🍓

[patrick91]

I like the idea, but I think this would be a good use case for a custom field function, like this:

import random

import strawberry
import faker

fake = faker.Faker(locale="fr_FR")

@strawberry.type
class User:
    first_name: str = fake_field(factory=fake.last_name)
    last_name: str = fake_field(factory=fake.last_name)

what do you think? :)

[LouisAmon]

I thought about that too : making my own field function for that purpose.

The messy thing about that approach is that I'd also need to subclass Field (because that's what gets generated in the end)
Pydantic also defines their own field function and Field class in order to achieve data validation

My feeling on the matter is that Python core devs who imagined the dataclasses have failed us here : they intended for everyone (e.g.: Strawberry, Pydantic, Faker) to own a namespace in the metadata attribute but instead everyone ended up needing to define their own mutually-exclusive definitions of dataclasses.Field and dataclasses.field that were mostly intended for internal use (according to the docs)

Realistically, I think the best solution here is to come up with a single superset which encompasses all possible usages. Why not have a single Field class that supports **kwargs and then whoever defines factory in there can in turn use that in their resolvers in the way they see fit ?

For example I would see a utility function in e.g. "strawberry/factories.py":

def factory(model) -> Any:
    """
    Generates fake data for a given model based on the `factory` function it may
    have defined on its fields

    Usage:
    ```python
    import strawberry

    @strawberry.type
    class User:
        first_name: str : strawberry.field(factory=lambda: "foo")
        last_name: str : strawberry.field(factory=lambda: "bar")

    >>> User.factory()
    >>> User(first_name="foo", last_name="bar")
    ```
    """
    generated_data = {
        field.name: field.factory()
        for field in dataclasses.fields(model)
        if hasattr(field, "factory")
    }
    return model(**generated_data)

(NB: the utility function could also be defined as a class method, I'm not sure how @strawberry.type actually works)

Then in a project's "resolvers.py":

def get_user(id) ->User:
    if os.environ.get("DEBUG"):
        return User.factory(
            # Force any number of attributes to a given value for debug purposes
            first_name="Patrick"
        )
    else:
        # Fetch from DB