Merge pull request #129 from mirumee/process_name_hook

Add process_name hook

Author: mat-sop

CHANGELOG.md

@@ -6,6 +6,7 @@
 - Added escaping of GraphQL names which are Python keywords by appending `_` to them.
 - Fixed parsing of list variables.
 - Changed base clients to remove unset arguments and input fields from variables payload.
+- Added `process_name` plugin hook.
 
 
 ## 0.5.0 (2023-04-05)

PLUGINS.md

@@ -284,6 +284,14 @@ def generate_init_code(self, generated_code: str) -> str:
 
 Hook executed on generation of init code. Result is used as content of `__init__.py`.
 
+### process_name
+
+```py
+def process_name(self, name: str, node: Optional[Node] = None) -> str:
+```
+
+Hook executed on processing of GraphQL field, argument or operation name.
+
 
 ## Example
 
@@ -298,7 +306,7 @@ from ariadne_codegen.plugins.base import Plugin
 class VersionPlugin(Plugin):
     def generate_init_module(self, module: ast.Module) -> ast.Module:
         version = (
-            self.config_dict.get("tools", {})
+            self.config_dict.get("tool", {})
             .get("version_plugin", {})
             .get("version", "0.1")
         )

ariadne_codegen/client_generators/arguments.py

@@ -58,7 +58,12 @@ def generate(
         dict_ = generate_dict()
         for variable_definition in variable_definitions:
             org_name = variable_definition.variable.name.value
-            name = process_name(org_name, self.convert_to_snake_case)
+            name = process_name(
+                org_name,
+                convert_to_snake_case=self.convert_to_snake_case,
+                plugin_manager=self.plugin_manager,
+                node=variable_definition,
+            )
             annotation, used_custom_scalar = self._parse_type_node(
                 variable_definition.type
             )

ariadne_codegen/client_generators/input_types.py

@@ -109,7 +109,12 @@ def _parse_input_definition(
         )
 
         for lineno, (org_name, field) in enumerate(definition.fields.items(), start=1):
-            name = process_name(org_name, self.convert_to_snake_case)
+            name = process_name(
+                org_name,
+                convert_to_snake_case=self.convert_to_snake_case,
+                plugin_manager=self.plugin_manager,
+                node=field,
+            )
             annotation, field_type = parse_input_field_type(
                 field.type, custom_scalars=self.custom_scalars
             )

ariadne_codegen/client_generators/package.py

@@ -180,7 +180,12 @@ def add_operation(self, definition: OperationDefinitionNode):
             raise ParsingError("Query without name.")
 
         return_type_name = str_to_pascal_case(name.value)
-        method_name = process_name(name.value, convert_to_snake_case=True)
+        method_name = process_name(
+            name.value,
+            convert_to_snake_case=True,
+            plugin_manager=self.plugin_manager,
+            node=definition,
+        )
         module_name = method_name
         file_name = f"{module_name}.py"
 

ariadne_codegen/client_generators/result_types.py

@@ -185,7 +185,7 @@ def _parse_type_definition(
             start=1,
         ):
             field_name = self._get_field_name(field)
-            name = self._process_field_name(field_name)
+            name = self._process_field_name(field_name, field=field)
             field_definition = self._get_field_from_schema(type_name, field.name.value)
             annotation, field_types_names = parse_operation_field(
                 field=field,
@@ -269,10 +269,15 @@ def _get_field_name(self, field: FieldNode) -> str:
             return field.alias.value
         return field.name.value
 
-    def _process_field_name(self, name: str) -> str:
+    def _process_field_name(self, name: str, field: FieldNode) -> str:
         if self.convert_to_snake_case and name == TYPENAME_FIELD_NAME:
             return "__typename__"
-        return process_name(name, self.convert_to_snake_case)
+        return process_name(
+            name,
+            convert_to_snake_case=self.convert_to_snake_case,
+            plugin_manager=self.plugin_manager,
+            node=field,
+        )
 
     def _get_field_from_schema(self, type_name: str, field_name: str) -> GraphQLField:
         try:

ariadne_codegen/plugins/base.py

@@ -1,12 +1,13 @@
 import ast
-from typing import Dict, Tuple, Union
+from typing import Dict, Optional, Tuple, Union
 
 from graphql import (
     FieldNode,
     GraphQLEnumType,
     GraphQLInputField,
     GraphQLInputObjectType,
     GraphQLSchema,
+    Node,
     OperationDefinitionNode,
     SelectionSetNode,
     VariableDefinitionNode,
@@ -144,3 +145,7 @@ def generate_scalars_code(self, generated_code: str) -> str:
 
     def generate_init_code(self, generated_code: str) -> str:
         return generated_code
+
+    # pylint: disable=unused-argument
+    def process_name(self, name: str, node: Optional[Node] = None) -> str:
+        return name

ariadne_codegen/plugins/manager.py

@@ -7,6 +7,7 @@
     GraphQLInputField,
     GraphQLInputObjectType,
     GraphQLSchema,
+    Node,
     OperationDefinitionNode,
     SelectionSetNode,
     VariableDefinitionNode,
@@ -186,3 +187,6 @@ def generate_scalars_code(self, generated_code: str) -> str:
 
     def generate_init_code(self, generated_code: str) -> str:
         return self._apply_plugins_on_object("generate_init_code", generated_code)
+
+    def process_name(self, name: str, node: Optional[Node] = None) -> str:
+        return self._apply_plugins_on_object("process_name", name, node=node)

ariadne_codegen/utils.py

@@ -2,10 +2,14 @@
 import re
 from keyword import iskeyword
 from textwrap import indent
+from typing import Optional
 
 import isort
 from autoflake import fix_code  # type: ignore
 from black import Mode, format_str
+from graphql import Node
+
+from .plugins.manager import PluginManager
 
 
 def ast_to_str(
@@ -73,12 +77,19 @@ def format_multiline_strings(source: str) -> str:
     return formatted_source
 
 
-def process_name(name: str, convert_to_snake_case: bool) -> str:
+def process_name(
+    name: str,
+    convert_to_snake_case: bool,
+    plugin_manager: Optional[PluginManager] = None,
+    node: Optional[Node] = None,
+) -> str:
     """Processes the GraphQL name to remove keywords
     and optionally convert to snake_case."""
     processed_name = name
     if convert_to_snake_case:
         processed_name = str_to_snake_case(processed_name)
     if iskeyword(processed_name):
         processed_name += "_"
+    if plugin_manager:
+        processed_name = plugin_manager.process_name(processed_name, node=node)
     return processed_name

tests/client_generators/input_types_generator/test_plugin_hooks.py

@@ -9,7 +9,9 @@
 from ariadne_codegen.client_generators.input_types import InputTypesGenerator
 
 
-def test_generator_triggers_generate_input_class_hook_for_every_input_type(mocker):
+def test_generator_triggers_generate_input_class_hook_for_every_input_type(
+    mocked_plugin_manager,
+):
     schema_str = """
     input TestInputA {
         fieldA: String!
@@ -19,7 +21,6 @@ def test_generator_triggers_generate_input_class_hook_for_every_input_type(mocke
         fieldB: Int!
     }
     """
-    mocked_plugin_manager = mocker.MagicMock()
 
     InputTypesGenerator(
         schema=build_ast_schema(parse(schema_str)),
@@ -37,7 +38,9 @@ def test_generator_triggers_generate_input_class_hook_for_every_input_type(mocke
     assert call1_input_type.name == "TestInputB"
 
 
-def test_generator_triggers_generate_input_field_hook_for_every_input_field(mocker):
+def test_generator_triggers_generate_input_field_hook_for_every_input_field(
+    mocked_plugin_manager,
+):
     schema_str = """
     input TestInputAB {
         fieldA: String!
@@ -48,7 +51,6 @@ def test_generator_triggers_generate_input_field_hook_for_every_input_field(mock
         fieldC: Int!
     }
     """
-    mocked_plugin_manager = mocker.MagicMock()
 
     InputTypesGenerator(
         schema=build_ast_schema(parse(schema_str)),
@@ -66,8 +68,7 @@ def test_generator_triggers_generate_input_field_hook_for_every_input_field(mock
     assert mock_calls[2].kwargs["field_name"] == "fieldC"
 
 
-def test_generate_triggers_generate_inputs_module_hook(mocker):
-    mocked_plugin_manager = mocker.MagicMock()
+def test_generate_triggers_generate_inputs_module_hook(mocked_plugin_manager):
     generator = InputTypesGenerator(
         schema=GraphQLSchema(),
         enums_module="enums",
@@ -77,3 +78,27 @@ def test_generate_triggers_generate_inputs_module_hook(mocker):
     generator.generate()
 
     assert mocked_plugin_manager.generate_inputs_module.called
+
+
+def test_generate_triggers_process_name_hook_for_every_field(mocked_plugin_manager):
+    schema_str = """
+    input TestInputAB {
+        fieldA: String!
+        fieldB: String!
+    }
+
+    input TestInputC {
+        fieldC: Int!
+    }
+    """
+
+    InputTypesGenerator(
+        schema=build_ast_schema(parse(schema_str)),
+        enums_module="enums",
+        convert_to_snake_case=False,
+        plugin_manager=mocked_plugin_manager,
+    )
+
+    assert mocked_plugin_manager.process_name.call_count == 3
+    mock_calls = mocked_plugin_manager.process_name.mock_calls
+    assert {call.args[0] for call in mock_calls} == {"fieldA", "fieldB", "fieldC"}

tests/client_generators/result_types_generator/test_plugin_hooks.py

@@ -7,9 +7,8 @@
 from .schema import SCHEMA_STR
 
 
-def test_generate_triggers_generate_result_types_module_hook(mocker):
+def test_generate_triggers_generate_result_types_module_hook(mocked_plugin_manager):
     query_str = "query CustomQuery { camelCaseQuery { id } }"
-    mocked_plugin_manager = mocker.MagicMock()
     generator = ResultTypesGenerator(
         schema=build_ast_schema(parse(SCHEMA_STR)),
         operation_definition=cast(
@@ -24,9 +23,10 @@ def test_generate_triggers_generate_result_types_module_hook(mocker):
     assert mocked_plugin_manager.generate_result_types_module.called
 
 
-def test_get_operation_as_str_triggers_generate_operation_str_hook(mocker):
+def test_get_operation_as_str_triggers_generate_operation_str_hook(
+    mocked_plugin_manager,
+):
     query_str = "query CustomQuery { camelCaseQuery { id } }"
-    mocked_plugin_manager = mocker.MagicMock()
     generator = ResultTypesGenerator(
         schema=build_ast_schema(parse(SCHEMA_STR)),
         operation_definition=cast(
@@ -41,9 +41,10 @@ def test_get_operation_as_str_triggers_generate_operation_str_hook(mocker):
     assert mocked_plugin_manager.generate_operation_str.called
 
 
-def test_generator_triggers_generate_result_class_hook_for_every_class(mocker):
+def test_generator_triggers_generate_result_class_hook_for_every_class(
+    mocked_plugin_manager,
+):
     query_str = "query CustomQuery { camelCaseQuery { id } }"
-    mocked_plugin_manager = mocker.MagicMock()
 
     ResultTypesGenerator(
         schema=build_ast_schema(parse(SCHEMA_STR)),
@@ -60,7 +61,9 @@ def test_generator_triggers_generate_result_class_hook_for_every_class(mocker):
     } == {"CustomQuery", "CustomQueryCamelCaseQuery"}
 
 
-def test_generator_triggers_generate_result_field_hook_for_every_field(mocker):
+def test_generator_triggers_generate_result_field_hook_for_every_field(
+    mocked_plugin_manager,
+):
     query_str = """
     query CustomQuery {
         camelCaseQuery {
@@ -71,7 +74,6 @@ def test_generator_triggers_generate_result_field_hook_for_every_field(mocker):
         }
     }
     """
-    mocked_plugin_manager = mocker.MagicMock()
 
     ResultTypesGenerator(
         schema=build_ast_schema(parse(SCHEMA_STR)),
@@ -87,3 +89,34 @@ def test_generator_triggers_generate_result_field_hook_for_every_field(mocker):
         c.kwargs["field"].name.value
         for c in mocked_plugin_manager.generate_result_field.mock_calls
     } == {"camelCaseQuery", "id", "field1", "fielda"}
+
+
+def test_generator_triggers_process_name_hook_for_every_field(mocked_plugin_manager):
+    query_str = """
+    query CustomQuery {
+        camelCaseQuery {
+            id
+            field1 {
+                fielda
+            }
+        }
+    }
+    """
+
+    ResultTypesGenerator(
+        schema=build_ast_schema(parse(SCHEMA_STR)),
+        operation_definition=cast(
+            OperationDefinitionNode, parse(query_str).definitions[0]
+        ),
+        enums_module_name="enums",
+        convert_to_snake_case=False,
+        plugin_manager=mocked_plugin_manager,
+    )
+
+    assert mocked_plugin_manager.process_name.call_count == 4
+    assert {c.args[0] for c in mocked_plugin_manager.process_name.mock_calls} == {
+        "camelCaseQuery",
+        "id",
+        "field1",
+        "fielda",
+    }

tests/client_generators/test_arguments_generator.py

@@ -320,8 +320,7 @@ def test_generate_returns_arguments_with_custom_scalar_and_used_serialize_method
     assert compare_ast(arguments_dict, expected_arguments_dict)
 
 
-def test_generate_triggers_generate_arguments_hook(mocker):
-    mocked_plugin_manager = mocker.MagicMock()
+def test_generate_triggers_generate_arguments_hook(mocked_plugin_manager):
     schema_str = """
         schema { query: Query }
         type Query { _skip: String! }
@@ -337,8 +336,7 @@ def test_generate_triggers_generate_arguments_hook(mocker):
     assert mocked_plugin_manager.generate_arguments.called
 
 
-def test_generate_triggers_generate_arguments_dict_hook(mocker):
-    mocked_plugin_manager = mocker.MagicMock()
+def test_generate_triggers_generate_arguments_dict_hook(mocked_plugin_manager):
     schema_str = """
         schema { query: Query }
         type Query { _skip: String! }
@@ -352,3 +350,25 @@ def test_generate_triggers_generate_arguments_dict_hook(mocker):
     )
 
     assert mocked_plugin_manager.generate_arguments_dict.called
+
+
+def test_generate_triggers_process_name_hook_for_every_arg(mocked_plugin_manager):
+    schema_str = """
+        schema { query: Query }
+        type Query { _skip: String! }
+        """
+    generator = ArgumentsGenerator(
+        schema=build_schema(schema_str), plugin_manager=mocked_plugin_manager
+    )
+
+    generator.generate(
+        _get_variable_definitions_from_query_str(
+            "query q($arg1: String!, $arg2: String) { _skip }"
+        )
+    )
+
+    assert mocked_plugin_manager.process_name.call_count == 2
+    name1 = mocked_plugin_manager.process_name.mock_calls[0].args[0]
+    name2 = mocked_plugin_manager.process_name.mock_calls[1].args[0]
+    assert name1 == "arg1"
+    assert name2 == "arg2"