Add convert_case support to MutationType, make convert_case util less magic

Author: rafalp

ariadne_graphql_modules/convert_case.py

@@ -1,50 +1,42 @@
-from typing import Dict, Optional, Union, cast
+from functools import partial
+from typing import Optional, Union
 
 from ariadne import convert_camel_case_to_snake
-from graphql import DefinitionNode
+from graphql import FieldDefinitionNode
 
-from .types import FieldsDict
-
-Overrides = Dict[str, str]
-ArgsOverrides = Dict[str, Overrides]
+from .types import FieldsDict, InputFieldsDict
 
 
 def convert_case(
-    overrides_or_fields: Optional[Union[FieldsDict, dict]] = None,
-    map_fields_args=False,
+    overrides: Optional[dict] = None,
+    *,
+    object_fields: Optional[Union[FieldsDict, InputFieldsDict]] = None,
+    fields_args: Optional[FieldsDict] = None,
+    field_args: Optional[FieldDefinitionNode] = None,
 ):
-    no_args_call = convert_case_call_without_args(overrides_or_fields)
-
-    overrides = {}
-    if not no_args_call:
-        overrides = cast(dict, overrides_or_fields)
-
-    def create_case_mappings(fields: FieldsDict, map_fields_args=False):
-        if map_fields_args:
-            return convert_args_cas(fields, overrides)
-
-        return convert_aliases_case(fields, overrides)
-
-    if no_args_call:
-        fields = cast(FieldsDict, overrides_or_fields)
-        return create_case_mappings(fields, map_fields_args)
-
-    return create_case_mappings
+    if overrides and not object_fields and not fields_args and not field_args:
+        return partial(convert_case, overrides)
 
+    if object_fields:
+        return convert_object_fields_case(object_fields, overrides or {})
 
-def convert_case_call_without_args(
-    overrides_or_fields: Optional[Union[FieldsDict, dict]] = None
-) -> bool:
-    if overrides_or_fields is None:
-        return True
+    if fields_args:
+        return convert_fields_args_case(fields_args, overrides or {})
 
-    if isinstance(list(overrides_or_fields.values())[0], DefinitionNode):
-        return True
+    if field_args:
+        return convert_field_args_case(field_args, overrides or {})
 
-    return False
+    raise ValueError(
+        "convert_case was called without any arguments. "
+        "If you meant to use it for automatic case conversion, remove call "
+        "(convert_case() -> convert_case) or call it with dict of overrides "
+        "as only argument."
+    )
 
 
-def convert_aliases_case(fields: FieldsDict, overrides: Overrides) -> Overrides:
+def convert_object_fields_case(
+    fields: Union[FieldsDict, InputFieldsDict], overrides: dict
+):
     final_mappings = {}
     for field_name in fields:
         if field_name in overrides:
@@ -56,19 +48,25 @@ def convert_aliases_case(fields: FieldsDict, overrides: Overrides) -> Overrides:
     return final_mappings
 
 
-def convert_args_cas(fields: FieldsDict, overrides: ArgsOverrides) -> ArgsOverrides:
+def convert_fields_args_case(fields: FieldsDict, overrides: dict):
     final_mappings = {}
     for field_name, field_def in fields.items():
-        arg_overrides: Overrides = overrides.get(field_name, {})
-        arg_mappings = {}
-        for arg in field_def.arguments:
-            arg_name = arg.name.value
-            if arg_name in arg_overrides:
-                arg_name_final = arg_overrides[arg_name]
-            else:
-                arg_name_final = convert_camel_case_to_snake(arg_name)
-            if arg_name != arg_name_final:
-                arg_mappings[arg_name] = arg_name_final
+        arg_mappings = convert_field_args_case(
+            field_def, overrides.get(field_name) or {}
+        )
         if arg_mappings:
             final_mappings[field_name] = arg_mappings
     return final_mappings
+
+
+def convert_field_args_case(field: FieldDefinitionNode, overrides: dict):
+    final_mappings = {}
+    for arg in field.arguments:
+        arg_name = arg.name.value
+        if arg_name in overrides:
+            arg_name_final = overrides[arg_name]
+        else:
+            arg_name_final = convert_camel_case_to_snake(arg_name)
+        if arg_name != arg_name_final:
+            final_mappings[arg_name] = arg_name_final
+    return final_mappings

ariadne_graphql_modules/input_type.py

@@ -39,7 +39,7 @@ def __init_subclass__(cls) -> None:
 
         if callable(cls.__args__):
             # pylint: disable=not-callable
-            cls.__args__ = cls.__args__(cls.graphql_fields)
+            cls.__args__ = cls.__args__(object_fields=cls.graphql_fields)
 
         cls.__validate_args__()
 

ariadne_graphql_modules/interface_type.py

@@ -56,12 +56,12 @@ def __init_subclass__(cls) -> None:
         cls.__validate_requirements__(requirements, dependencies)
 
         if callable(cls.__fields_args__):
-            cls.__fields_args__ = cls.__fields_args__(cls.graphql_fields, True)
+            cls.__fields_args__ = cls.__fields_args__(fields_args=cls.graphql_fields)
 
         cls.__validate_fields_args__()
 
         if callable(cls.__aliases__):
-            cls.__aliases__ = cls.__aliases__(cls.graphql_fields)
+            cls.__aliases__ = cls.__aliases__(object_fields=cls.graphql_fields)
 
         cls.__validate_aliases__()
         cls.resolvers = cls.__get_resolvers__()

ariadne_graphql_modules/mutation_type.py

@@ -1,4 +1,4 @@
-from typing import Dict, Optional, Type, Union, cast
+from typing import Callable, Dict, List, Optional, Type, Union, cast
 
 from graphql import (
     DefinitionNode,
@@ -13,12 +13,13 @@
 from .types import RequirementsDict
 from .utils import parse_definition
 
+MutationArgs = Dict[str, str]
 ObjectNodeType = Union[ObjectTypeDefinitionNode, ObjectTypeExtensionNode]
 
 
 class MutationType(BindableType):
     __abstract__ = True
-    __args__: Optional[Dict[str, str]] = None
+    __args__: Optional[Union[MutationArgs, Callable[..., MutationArgs]]] = None
 
     graphql_name = "Mutation"
     graphql_type: Union[Type[ObjectTypeDefinitionNode], Type[ObjectTypeExtensionNode]]
@@ -50,7 +51,12 @@ def __init_subclass__(cls) -> None:
         dependencies = cls.__get_dependencies__(graphql_def)
         cls.__validate_requirements__(requirements, dependencies)
 
+        if callable(cls.__args__):
+            # pylint: disable=not-callable
+            cls.__args__ = cls.__args__(field_args=field)
+
         cls.__validate_args__(field)
+
         cls.__validate_resolve_mutation__()
 
     @classmethod
@@ -117,7 +123,7 @@ def __validate_args__(cls, field: FieldDefinitionNode):
             return
 
         field_args = [arg.name.value for arg in field.arguments]
-        invalid_args = set(cls.__args__) - set(field_args)
+        invalid_args = set(cast(List[str], cls.__args__)) - set(field_args)
         if invalid_args:
             raise ValueError(
                 f"{cls.__name__} class was defined with args not on "

ariadne_graphql_modules/object_type.py

@@ -47,12 +47,12 @@ def __init_subclass__(cls) -> None:
         cls.__validate_requirements__(requirements, dependencies)
 
         if callable(cls.__fields_args__):
-            cls.__fields_args__ = cls.__fields_args__(cls.graphql_fields, True)
+            cls.__fields_args__ = cls.__fields_args__(fields_args=cls.graphql_fields)
 
         cls.__validate_fields_args__()
 
         if callable(cls.__aliases__):
-            cls.__aliases__ = cls.__aliases__(cls.graphql_fields)
+            cls.__aliases__ = cls.__aliases__(object_fields=cls.graphql_fields)
 
         cls.__validate_aliases__()
         cls.resolvers = cls.__get_resolvers__()

tests/test_convert_case.py

@@ -1,4 +1,4 @@
-from ariadne_graphql_modules import InputType, ObjectType, convert_case
+from ariadne_graphql_modules import InputType, MutationType, ObjectType, convert_case
 
 
 def test_cases_are_mapped_for_aliases():
@@ -104,3 +104,42 @@ class ExampleObject(ObjectType):
             "thirdArg": "third_arg",
         },
     }
+
+
+def test_cases_are_mapped_for_mutation_args():
+    class ExampleMutation(MutationType):
+        __schema__ = """
+        type Mutation {
+            field(arg: Int, secondArg: Int): Int
+        }
+        """
+        __args__ = convert_case
+
+        @staticmethod
+        def resolve_mutation(*_, **__):
+            return 42
+
+    assert ExampleMutation.__args__ == {"secondArg": "second_arg"}
+
+
+def test_cases_are_mapped_for_mutation_args_with_overrides():
+    class ExampleMutation(MutationType):
+        __schema__ = """
+        type Mutation {
+            field(arg: Int, secondArg: Int): Int
+        }
+        """
+        __args__ = convert_case(
+            {
+                "arg": "override",
+            }
+        )
+
+        @staticmethod
+        def resolve_mutation(*_, **__):
+            return 42
+
+    assert ExampleMutation.__args__ == {
+        "arg": "override",
+        "secondArg": "second_arg",
+    }