__fields_args__ = convert_case does not seem to work on MutationType

[LawrenceHunt]

Hi there! First of all, love the concept behind graphQL modules and apologies for the confusion, I'm sure I'm missing something trivial but I've tried making the examples work to no avail.

I have a simple mutation for updating a user flag, very much like the example in your documentation.

Here it is:

class UpdateUserHasOnboardedMutationType(MutationType):
    __schema__ = gql(
        """
        type Mutation {
            updateUserHasOnboarded(userId: String): Boolean!
        }
        """
    )
    __fields_args__ = convert_case
    __aliases__ = convert_case

    @staticmethod
    async def resolve_update_user_has_onboarded(*_: None, user_id: str) -> bool:
        <some DB logic not important cos we don't get here>
        return True

I run this mutation from graphQL playground as follows:

mutation {
       updateUserHasOnboarded(userId: "2516dc8e-6ba8-40c7-bae4-f0180cb3bbac")
}

and I get the error message:

"UpdateUserHasOnboardedMutationType.resolve_mutation() got an unexpected keyword argument 'userId'",

Change the kwarg userId to userid, so no need for case conversion, and it works fine.

Additionally, inheriting from the ObjectType instead of the MutationType and it also works fine!

What am I missing?

Looking at the code for MutationType, I don't see any mention of __fields_args__ - yet it's there on ObjectType. So how is this supposed to work?

And what does MutationType add, if you can run your mutation using the ObjectType anyway (the same as you do for a query)?

Thanks so much in advance!

[rafalp]

Hey!

In case of MutationType this option is called __args__. I see that reference is wrong here:

https://github.com/mirumee/ariadne-graphql-modules/blob/main/ariadne_graphql_modules/mutation_type.py#L19

Thanks for pointing this out. I'll update the reference tomorrow.

[LawrenceHunt]

My pleasure, and thanks for the rapid response!

A point of clarification if you wouldn't mind - when you say you've fixed the reference what was the exact change?

And if __args__ is the place to put our case conversion mappings, why is it a Dict and not something we can pass convert_case into as with ObjectType? This is a nice feature. I would say if possible just make it work the same way as ObjectType.

[rafalp]

By reference I mean the reference document that goes through most of features offered by library. I'll give readme a pass too so both files are in agreement :)

Please give it a look, it mentions that both __args__ (used by InputType and MutationType) and __fields__args__ (used by ObjectType) supports both explicit way with dict and automagic way with convert_case :)

I am thinking about a way to make both of them more obvious or easier to remember. I'm weary of using same name for all places because __fields__args__ means "arguments of fields", but for InputType there are no arguments on fields as fields themselves act as arguments for other argument elsewhere in schema, and for MutationType tere's only single field allowed, so having to name it feels redundant.

[LawrenceHunt]

OK so trying it again with specifically mapped fields, this works:

__args__ = {"userId": "user_id"}

Woop.

BUT. I'm trying it again with

 __args__ = convert_case

and immediately getting a type error:

Incompatible types in assignment (expression has type "Callable[[Union[Dict[str, FieldDefinitionNode], Dict[Any, Any], None], Any], Any]", base class "MutationType" defined the type as "Optional[Dict[str, str]]")  [assignment]

And it seems the type signature for __fields_args__ in ResolversMixin is as follows:

__fields_args__: Optional[Union[FieldsArgs, Callable[..., FieldsArgs]]] = None

Whereas the type signature for __args__ in MutationType is

 __args__: Optional[Dict[str, str]] = None

Does it just need a tweak to the type def of __args__ to also match convert_case?

[LawrenceHunt]

I also have a separate, minor comment to make, since you asked about the references in the documentation.

In the example here:

class UserRegisterMutation(MutationType):
    __schema__ = gql(
        """
        type Mutation {
            registerUser(
                userName: String!,
                email: String!,
                admin: Boolean,
            ): Boolean!
        }
        """
    )
    __args__ = {"userName": "username", "admin": "is_admin"}

    @staticmethod
    async def resolve_mutation(*_, username: str, email: str, is_admin: bool | None):
        user = await create_user(
            full_name=username,
            email=email,
            is_admin=bool(is_admin),
        )
        return bool(user)

That first arg in resolve_mutation, *_ - my linter is complaining that this is untyped. It appears to be None - should we type it as such? Or is there a specific linting rule that you recommend, in which case perhaps you should add this recommendation to the docs?

[rafalp]

This *_ will catch parent which AFAIR is always None for Mutation resolvers and second argument (info) which is GraphQLResolve info.

[rafalp]

@LawrenceHunt

Does it just need a tweak to the type def of __args__ to also match convert_case?

I've did a deep dive into the code and it seems that convert_case doesn't support MutationType at all. I've been OOL with Ariadne's internals for those last months being busy with other work. But I'll fix this now. Sorry for causing the misunderstanding here. 😔

[rafalp]

@LawrenceHunt I've released 0.6.0 with the fix.

[LawrenceHunt]

Many thanks!