infrahub-server 1.5.0b0__py3-none-any.whl → 1.5.0b1__py3-none-any.whl

infrahub/server.py

@@ -10,7 +10,6 @@ from asgi_correlation_id import CorrelationIdMiddleware
 from asgi_correlation_id.context import correlation_id
 from fastapi import FastAPI, Request, Response
 from fastapi.logger import logger
-from fastapi.middleware.gzip import GZipMiddleware
 from fastapi.responses import RedirectResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
@@ -30,7 +29,7 @@ from infrahub.exceptions import Error, ValidationError
 from infrahub.graphql.api.endpoints import router as graphql_router
 from infrahub.lock import initialize_lock
 from infrahub.log import clear_log_context, get_logger, set_log_data
-from infrahub.middleware import InfrahubCORSMiddleware
+from infrahub.middleware import ConditionalGZipMiddleware, InfrahubCORSMiddleware
 from infrahub.services import InfrahubServices
 from infrahub.trace import add_span_exception, configure_trace, get_traceid
 from infrahub.worker import WORKER_IDENTITY
@@ -86,8 +85,12 @@ async def app_initialization(application: FastAPI, enable_scheduler: bool = True
     async with application.state.db.start_session() as db:
         await initialization(db=db, add_database_indexes=True)
 
+    # Initialize the workflow after the registry has been setup
+    await service.initialize_workflow()
+
     application.state.service = service
     application.state.response_delay = config.SETTINGS.miscellaneous.response_delay
+
     if enable_scheduler:
         await service.scheduler.start_schedule()
 
@@ -184,7 +187,17 @@ app.add_middleware(
     skip_paths=["/health"],
 )
 app.add_middleware(InfrahubCORSMiddleware)
-app.add_middleware(GZipMiddleware, minimum_size=100_000)
+app.add_middleware(
+    ConditionalGZipMiddleware,
+    minimum_size=100_000,
+    compresslevel=1,
+    include_paths=(
+        "/assets",
+        "/favicons",
+        "/docs",
+        "/api/schema",
+    ),
+)
 
 app.add_exception_handler(Error, generic_api_exception_handler)
 app.add_exception_handler(TimestampFormatError, partial(generic_api_exception_handler, http_code=400))

infrahub/services/__init__.py

@@ -110,14 +110,17 @@ class InfrahubServices:
         # This circular dependency could be removed if InfrahubScheduler only depends on what it needs.
         scheduler.service = service
 
-        if workflow is not None and isinstance(workflow, WorkflowWorkerExecution):
-            assert service.component is not None
+        return service
+
+    async def initialize_workflow(self) -> None:
+        if self.workflow is not None and isinstance(self.workflow, WorkflowWorkerExecution):
+            assert self.component is not None
             # Ideally `WorkflowWorkerExecution.initialize` would be directly part of WorkflowWorkerExecution
             # constructor but this requires some redesign as it depends on InfrahubComponent which is instantiated
             # after workflow instantiation.
-            await workflow.initialize(component_is_primary_server=await service.component.is_primary_gunicorn_worker())
-
-        return service
+            await self.component.refresh_heartbeat()
+            is_primary = await self.component.is_primary_gunicorn_worker()
+            await self.workflow.initialize(component_is_primary_server=is_primary)
 
     @property
     def component(self) -> InfrahubComponent:

infrahub/trigger/catalogue.py

@@ -4,6 +4,8 @@ from infrahub.computed_attribute.triggers import (
     TRIGGER_COMPUTED_ATTRIBUTE_ALL_SCHEMA,
     TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_SETUP_COMMIT,
 )
+from infrahub.display_labels.triggers import TRIGGER_DISPLAY_LABELS_ALL_SCHEMA
+from infrahub.hfid.triggers import TRIGGER_HFID_ALL_SCHEMA
 from infrahub.schema.triggers import TRIGGER_SCHEMA_UPDATED
 from infrahub.trigger.models import TriggerDefinition
 from infrahub.webhook.triggers import TRIGGER_WEBHOOK_DELETE, TRIGGER_WEBHOOK_SETUP_UPDATE
@@ -13,6 +15,8 @@ builtin_triggers: list[TriggerDefinition] = [
     TRIGGER_BRANCH_MERGED,
     TRIGGER_COMPUTED_ATTRIBUTE_ALL_SCHEMA,
     TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_SETUP_COMMIT,
+    TRIGGER_DISPLAY_LABELS_ALL_SCHEMA,
+    TRIGGER_HFID_ALL_SCHEMA,
     TRIGGER_SCHEMA_UPDATED,
     TRIGGER_WEBHOOK_DELETE,
     TRIGGER_WEBHOOK_SETUP_UPDATE,

infrahub/trigger/models.py

@@ -37,6 +37,8 @@ class TriggerType(str, Enum):
     COMPUTED_ATTR_JINJA2 = "computed_attr_jinja2"
     COMPUTED_ATTR_PYTHON = "computed_attr_python"
     COMPUTED_ATTR_PYTHON_QUERY = "computed_attr_python_query"
+    DISPLAY_LABEL_JINJA2 = "display_label_jinja2"
+    HUMAN_FRIENDLY_ID = "human_friendly_id"
     # OBJECT = "object"
 
 

infrahub/trigger/tasks.py

@@ -6,6 +6,7 @@ from infrahub.computed_attribute.gather import (
     gather_trigger_computed_attribute_jinja2,
     gather_trigger_computed_attribute_python,
 )
+from infrahub.display_labels.gather import gather_trigger_display_labels_jinja2
 from infrahub.trigger.catalogue import builtin_triggers
 from infrahub.webhook.gather import gather_trigger_webhook
 from infrahub.workers.dependencies import get_database
@@ -18,6 +19,7 @@ async def trigger_configure_all() -> None:
     database = await get_database()
     async with database.start_session() as db:
         webhook_trigger = await gather_trigger_webhook(db=db)
+        display_label_triggers = await gather_trigger_display_labels_jinja2()
         computed_attribute_j2_triggers = await gather_trigger_computed_attribute_jinja2()
         (
             computed_attribute_python_triggers,
@@ -28,6 +30,7 @@ async def trigger_configure_all() -> None:
             computed_attribute_j2_triggers
             + computed_attribute_python_triggers
             + computed_attribute_python_query_triggers
+            + display_label_triggers
             + builtin_triggers
             + webhook_trigger
             + action_rules

infrahub/workflows/catalogue.py

@@ -323,6 +323,62 @@ COMPUTED_ATTRIBUTE_JINJA2_UPDATE_VALUE = WorkflowDefinition(
     tags=[WorkflowTag.DATABASE_CHANGE],
 )
 
+DISPLAY_LABELS_PROCESS_JINJA2 = WorkflowDefinition(
+    name="display-label-process-jinja2",
+    type=WorkflowType.CORE,
+    module="infrahub.display_labels.tasks",
+    function="process_display_label",
+    tags=[WorkflowTag.DATABASE_CHANGE],
+)
+
+DISPLAY_LABEL_JINJA2_UPDATE_VALUE = WorkflowDefinition(
+    name="display-label-jinja2-update-value",
+    type=WorkflowType.CORE,
+    module="infrahub.display_labels.tasks",
+    function="display_label_jinja2_update_value",
+    tags=[WorkflowTag.DATABASE_CHANGE],
+)
+
+HFID_PROCESS = WorkflowDefinition(
+    name="hfid-process",
+    type=WorkflowType.CORE,
+    module="infrahub.hfid.tasks",
+    function="process_hfid",
+    tags=[WorkflowTag.DATABASE_CHANGE],
+)
+
+HFID_SETUP = WorkflowDefinition(
+    name="hfid-setup",
+    type=WorkflowType.CORE,
+    module="infrahub.hfid.tasks",
+    function="hfid_setup",
+)
+
+
+HFID_UPDATE_VALUE = WorkflowDefinition(
+    name="hfid-update-value",
+    type=WorkflowType.CORE,
+    module="infrahub.hfid.tasks",
+    function="hfid_update_value",
+    tags=[WorkflowTag.DATABASE_CHANGE],
+)
+
+TRIGGER_UPDATE_DISPLAY_LABELS = WorkflowDefinition(
+    name="trigger-update-display-labels",
+    type=WorkflowType.CORE,
+    module="infrahub.display_labels.tasks",
+    function="trigger_update_display_labels",
+    tags=[WorkflowTag.DATABASE_CHANGE],
+)
+
+TRIGGER_UPDATE_HFID = WorkflowDefinition(
+    name="trigger-update-hfid",
+    type=WorkflowType.CORE,
+    module="infrahub.hfid.tasks",
+    function="trigger_update_hfid",
+    tags=[WorkflowTag.DATABASE_CHANGE],
+)
+
 TRIGGER_UPDATE_JINJA_COMPUTED_ATTRIBUTES = WorkflowDefinition(
     name="trigger_update_jinja2_computed_attributes",
     type=WorkflowType.CORE,
@@ -359,6 +415,14 @@ COMPUTED_ATTRIBUTE_PROCESS_TRANSFORM = WorkflowDefinition(
     tags=[WorkflowTag.DATABASE_CHANGE],
 )
 
+DISPLAY_LABELS_SETUP_JINJA2 = WorkflowDefinition(
+    name="display-labels-setup-jinja2",
+    type=WorkflowType.CORE,
+    module="infrahub.display_labels.tasks",
+    function="display_labels_setup_jinja2",
+)
+
+
 QUERY_COMPUTED_ATTRIBUTE_TRANSFORM_TARGETS = WorkflowDefinition(
     name="query-computed-attribute-transform-targets",
     type=WorkflowType.CORE,
@@ -589,6 +653,9 @@ WORKFLOWS = [
     DIFF_REFRESH,
     DIFF_REFRESH_ALL,
     DIFF_UPDATE,
+    DISPLAY_LABELS_PROCESS_JINJA2,
+    DISPLAY_LABELS_SETUP_JINJA2,
+    DISPLAY_LABEL_JINJA2_UPDATE_VALUE,
     GIT_REPOSITORIES_CHECK_ARTIFACT_CREATE,
     GIT_REPOSITORIES_CREATE_BRANCH,
     GIT_REPOSITORIES_DIFF_NAMES_ONLY,
@@ -604,6 +671,9 @@ WORKFLOWS = [
     GIT_REPOSITORY_USER_CHECKS_TRIGGER,
     GIT_REPOSITORY_USER_CHECK_RUN,
     GRAPHQL_QUERY_GROUP_UPDATE,
+    HFID_PROCESS,
+    HFID_SETUP,
+    HFID_UPDATE_VALUE,
     IPAM_RECONCILIATION,
     PROFILE_REFRESH,
     PROFILE_REFRESH_MULTIPLE,
@@ -632,6 +702,8 @@ WORKFLOWS = [
     TRIGGER_ARTIFACT_DEFINITION_GENERATE,
     TRIGGER_CONFIGURE_ALL,
     TRIGGER_GENERATOR_DEFINITION_RUN,
+    TRIGGER_UPDATE_DISPLAY_LABELS,
+    TRIGGER_UPDATE_HFID,
     TRIGGER_UPDATE_JINJA_COMPUTED_ATTRIBUTES,
     TRIGGER_UPDATE_PYTHON_COMPUTED_ATTRIBUTES,
     VALIDATE_SCHEMA_NUMBER_POOLS,

infrahub/workflows/initialization.py

@@ -7,6 +7,8 @@ from prefect.exceptions import ObjectAlreadyExists
 from prefect.logging import get_run_logger
 
 from infrahub import config
+from infrahub.display_labels.gather import gather_trigger_display_labels_jinja2
+from infrahub.hfid.gather import gather_trigger_hfid
 from infrahub.trigger.catalogue import builtin_triggers
 from infrahub.trigger.models import TriggerType
 from infrahub.trigger.setup import setup_triggers
@@ -74,3 +76,17 @@ async def setup_task_manager() -> None:
         await setup_triggers(
             client=client, triggers=builtin_triggers, trigger_type=TriggerType.BUILTIN, force_update=True
         )
+        display_label_triggers = await gather_trigger_display_labels_jinja2()
+        await setup_triggers(
+            client=client,
+            triggers=display_label_triggers,
+            trigger_type=TriggerType.DISPLAY_LABEL_JINJA2,
+            force_update=True,
+        )  # type: ignore[misc]
+        hfid_triggers = await gather_trigger_hfid()
+        await setup_triggers(
+            client=client,
+            triggers=hfid_triggers,
+            trigger_type=TriggerType.HUMAN_FRIENDLY_ID,
+            force_update=True,
+        )  # type: ignore[misc]

infrahub_sdk/checks.py

@@ -33,7 +33,7 @@ class InfrahubCheckInitializer(BaseModel):
 class InfrahubCheck:
     name: str | None = None
     query: str = ""
-    timeout: int = 10
+    timeout: int = 60
 
     def __init__(
         self,

infrahub_sdk/ctl/cli_commands.py

@@ -25,6 +25,7 @@ from ..ctl.check import run as run_check
 from ..ctl.client import initialize_client, initialize_client_sync
 from ..ctl.exceptions import QueryNotFoundError
 from ..ctl.generator import run as run_generator
+from ..ctl.graphql import app as graphql_app
 from ..ctl.menu import app as menu_app
 from ..ctl.object import app as object_app
 from ..ctl.render import list_jinja2_transforms, print_template_errors
@@ -62,6 +63,7 @@ app.add_typer(validate_app, name="validate")
 app.add_typer(repository_app, name="repository")
 app.add_typer(menu_app, name="menu")
 app.add_typer(object_app, name="object")
+app.add_typer(graphql_app, name="graphql")
 
 app.command(name="dump")(dump)
 app.command(name="load")(load)

infrahub_sdk/ctl/generator.py

@@ -64,6 +64,8 @@ async def run(
             branch=branch or "",
             params=variables_dict,
             convert_query_response=generator_config.convert_query_response,
+            execute_in_proposed_change=generator_config.execute_in_proposed_change,
+            execute_after_merge=generator_config.execute_after_merge,
             infrahub_node=InfrahubNode,
         )
         await generator._init_client.schema.all(branch=generator.branch_name)
@@ -93,6 +95,8 @@ async def run(
                 branch=branch or "",
                 params=params,
                 convert_query_response=generator_config.convert_query_response,
+                execute_in_proposed_change=generator_config.execute_in_proposed_change,
+                execute_after_merge=generator_config.execute_after_merge,
                 infrahub_node=InfrahubNode,
             )
             data = execute_graphql_query(

infrahub_sdk/ctl/graphql.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+import ast
+from collections import defaultdict
+from pathlib import Path
+from typing import Optional
+
+import typer
+from ariadne_codegen.client_generators.package import PackageGenerator, get_package_generator
+from ariadne_codegen.exceptions import ParsingError
+from ariadne_codegen.plugins.explorer import get_plugins_types
+from ariadne_codegen.plugins.manager import PluginManager
+from ariadne_codegen.schema import (
+    filter_fragments_definitions,
+    filter_operations_definitions,
+    get_graphql_schema_from_path,
+)
+from ariadne_codegen.settings import ClientSettings, CommentsStrategy
+from ariadne_codegen.utils import ast_to_str
+from graphql import DefinitionNode, GraphQLSchema, NoUnusedFragmentsRule, parse, specified_rules, validate
+from rich.console import Console
+
+from ..async_typer import AsyncTyper
+from ..ctl.client import initialize_client
+from ..ctl.utils import catch_exception
+from ..graphql.utils import insert_fragments_inline, remove_fragment_import
+from .parameters import CONFIG_PARAM
+
+app = AsyncTyper()
+console = Console()
+
+ARIADNE_PLUGINS = [
+    "infrahub_sdk.graphql.plugin.PydanticBaseModelPlugin",
+    "infrahub_sdk.graphql.plugin.FutureAnnotationPlugin",
+    "infrahub_sdk.graphql.plugin.StandardTypeHintPlugin",
+]
+
+
+def find_gql_files(query_path: Path) -> list[Path]:
+    """
+    Find all files with .gql extension in the specified directory.
+
+    Args:
+        query_path: Path to the directory to search for .gql files
+
+    Returns:
+        List of Path objects for all .gql files found
+    """
+    if not query_path.exists():
+        raise FileNotFoundError(f"File or directory not found: {query_path}")
+
+    if not query_path.is_dir() and query_path.is_file():
+        return [query_path]
+
+    return list(query_path.glob("**/*.gql"))
+
+
+def get_graphql_query(queries_path: Path, schema: GraphQLSchema) -> tuple[DefinitionNode, ...]:
+    """Get GraphQL queries definitions from a single GraphQL file."""
+
+    if not queries_path.exists():
+        raise FileNotFoundError(f"File not found: {queries_path}")
+    if not queries_path.is_file():
+        raise ValueError(f"{queries_path} is not a file")
+
+    queries_str = queries_path.read_text(encoding="utf-8")
+    queries_ast = parse(queries_str)
+    validation_errors = validate(
+        schema=schema,
+        document_ast=queries_ast,
+        rules=[r for r in specified_rules if r is not NoUnusedFragmentsRule],
+    )
+    if validation_errors:
+        raise ValueError("\n\n".join(error.message for error in validation_errors))
+    return queries_ast.definitions
+
+
+def generate_result_types(directory: Path, package: PackageGenerator, fragment: ast.Module) -> None:
+    for file_name, module in package._result_types_files.items():
+        file_path = directory / file_name
+
+        insert_fragments_inline(module, fragment)
+        remove_fragment_import(module)
+
+        code = package._add_comments_to_code(ast_to_str(module), package.queries_source)
+        if package.plugin_manager:
+            code = package.plugin_manager.generate_result_types_code(code)
+        file_path.write_text(code)
+        package._generated_files.append(file_path.name)
+
+
+@app.callback()
+def callback() -> None:
+    """
+    Various GraphQL related commands.
+    """
+
+
+@app.command()
+@catch_exception(console=console)
+async def export_schema(
+    destination: Path = typer.Option("schema.graphql", help="Path to the GraphQL schema file."),
+    _: str = CONFIG_PARAM,
+) -> None:
+    """Export the GraphQL schema to a file."""
+
+    client = initialize_client()
+    schema_text = await client.schema.get_graphql_schema()
+
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    destination.write_text(schema_text)
+    console.print(f"[green]Schema exported to {destination}")
+
+
+@app.command()
+@catch_exception(console=console)
+async def generate_return_types(
+    query: Optional[Path] = typer.Argument(
+        None, help="Location of the GraphQL query file(s). Defaults to current directory if not specified."
+    ),
+    schema: Path = typer.Option("schema.graphql", help="Path to the GraphQL schema file."),
+    _: str = CONFIG_PARAM,
+) -> None:
+    """Create Pydantic Models for GraphQL query return types"""
+
+    query = Path.cwd() if query is None else query
+
+    # Load the GraphQL schema
+    if not schema.exists():
+        raise FileNotFoundError(f"GraphQL Schema file not found: {schema}")
+    graphql_schema = get_graphql_schema_from_path(schema_path=str(schema))
+
+    # Initialize the plugin manager
+    plugin_manager = PluginManager(
+        schema=graphql_schema,
+        plugins_types=get_plugins_types(plugins_strs=ARIADNE_PLUGINS),
+    )
+
+    # Find the GraphQL files and organize them by directory
+    gql_files = find_gql_files(query)
+    gql_per_directory: dict[Path, list[Path]] = defaultdict(list)
+    for gql_file in gql_files:
+        gql_per_directory[gql_file.parent].append(gql_file)
+
+    # Generate the Pydantic Models for the GraphQL queries
+    for directory, gql_files in gql_per_directory.items():
+        for gql_file in gql_files:
+            try:
+                definitions = get_graphql_query(queries_path=gql_file, schema=graphql_schema)
+            except ValueError as exc:
+                console.print(f"[red]Error generating result types for {gql_file}: {exc}")
+                continue
+            queries = filter_operations_definitions(definitions)
+            fragments = filter_fragments_definitions(definitions)
+
+            package_generator = get_package_generator(
+                schema=graphql_schema,
+                fragments=fragments,
+                settings=ClientSettings(
+                    schema_path=str(schema),
+                    target_package_name=directory.name,
+                    queries_path=str(directory),
+                    include_comments=CommentsStrategy.NONE,
+                ),
+                plugin_manager=plugin_manager,
+            )
+
+            parsing_failed = False
+            try:
+                for query_operation in queries:
+                    package_generator.add_operation(query_operation)
+            except ParsingError as exc:
+                console.print(f"[red]Unable to process {gql_file.name}: {exc}")
+                parsing_failed = True
+
+            if parsing_failed:
+                continue
+
+            module_fragment = package_generator.fragments_generator.generate()
+
+            generate_result_types(directory=directory, package=package_generator, fragment=module_fragment)
+
+            for file_name in package_generator._result_types_files.keys():
+                console.print(f"[green]Generated {file_name} in {directory}")

infrahub_sdk/ctl/schema.py

@@ -73,7 +73,9 @@ def display_schema_load_errors(response: dict[str, Any], schemas_data: list[Sche
             loc_type = loc_path[-1]
             input_str = error.get("input", None)
             error_message = f"{loc_type} ({input_str}) | {error['msg']} ({error['type']})"
-            console.print(f"  Node: {node.get('namespace', None)}{node.get('name', None)} | {error_message}")
+            console.print(
+                f"  Node: {node.get('namespace', None)}{node.get('name', None)} | {error_message}", markup=False
+            )
 
         elif len(loc_path) > 6:
             loc_type = loc_path[5]
@@ -91,7 +93,9 @@ def display_schema_load_errors(response: dict[str, Any], schemas_data: list[Sche
 
             input_str = error.get("input", None)
             error_message = f"{loc_type[:-1].title()}: {input_label} ({input_str}) | {error['msg']} ({error['type']})"
-            console.print(f"  Node: {node.get('namespace', None)}{node.get('name', None)} | {error_message}")
+            console.print(
+                f"  Node: {node.get('namespace', None)}{node.get('name', None)} | {error_message}", markup=False
+            )
 
 
 def handle_non_detail_errors(response: dict[str, Any]) -> None:

infrahub_sdk/generator.py

@@ -26,6 +26,8 @@ class InfrahubGenerator(InfrahubOperation):
         generator_instance: str = "",
         params: dict | None = None,
         convert_query_response: bool = False,
+        execute_in_proposed_change: bool = True,
+        execute_after_merge: bool = True,
         logger: logging.Logger | None = None,
         request_context: RequestContext | None = None,
     ) -> None:
@@ -44,6 +46,8 @@ class InfrahubGenerator(InfrahubOperation):
         self._client: InfrahubClient | None = None
         self.logger = logger if logger else logging.getLogger("infrahub.tasks")
         self.request_context = request_context
+        self.execute_in_proposed_change = execute_in_proposed_change
+        self.execute_after_merge = execute_after_merge
 
     @property
     def subscribers(self) -> list[str] | None:
@@ -81,8 +85,10 @@ class InfrahubGenerator(InfrahubOperation):
         unpacked = data.get("data") or data
         await self.process_nodes(data=unpacked)
 
+        group_type = "CoreGeneratorGroup" if self.execute_after_merge else "CoreGeneratorAwareGroup"
+
         async with self._init_client.start_tracking(
-            identifier=identifier, params=self.params, delete_unused_nodes=True, group_type="CoreGeneratorGroup"
+            identifier=identifier, params=self.params, delete_unused_nodes=True, group_type=group_type
         ) as self.client:
             await self.generate(data=unpacked)
 

infrahub_sdk/graphql/__init__.py

@@ -0,0 +1,12 @@
+from .constants import VARIABLE_TYPE_MAPPING
+from .query import Mutation, Query
+from .renderers import render_input_block, render_query_block, render_variables_to_string
+
+__all__ = [
+    "VARIABLE_TYPE_MAPPING",
+    "Mutation",
+    "Query",
+    "render_input_block",
+    "render_query_block",
+    "render_variables_to_string",
+]

infrahub_sdk/graphql/constants.py

@@ -0,0 +1 @@
+VARIABLE_TYPE_MAPPING = ((str, "String!"), (int, "Int!"), (float, "Float!"), (bool, "Boolean!"))

infrahub_sdk/graphql/plugin.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import ast
+from typing import TYPE_CHECKING
+
+from ariadne_codegen.plugins.base import Plugin
+
+if TYPE_CHECKING:
+    from graphql import ExecutableDefinitionNode
+
+
+class FutureAnnotationPlugin(Plugin):
+    @staticmethod
+    def insert_future_annotation(module: ast.Module) -> ast.Module:
+        # First check if the future annotation is already present
+        for item in module.body:
+            if isinstance(item, ast.ImportFrom) and item.module == "__future__":
+                if any(alias.name == "annotations" for alias in item.names):
+                    return module
+
+        module.body.insert(0, ast.ImportFrom(module="__future__", names=[ast.alias(name="annotations")], level=0))
+        return module
+
+    def generate_result_types_module(
+        self,
+        module: ast.Module,
+        operation_definition: ExecutableDefinitionNode,  # noqa: ARG002
+    ) -> ast.Module:
+        return self.insert_future_annotation(module)
+
+
+class StandardTypeHintPlugin(Plugin):
+    @classmethod
+    def replace_list_in_subscript(cls, subscript: ast.Subscript) -> ast.Subscript:
+        if isinstance(subscript.value, ast.Name) and subscript.value.id == "List":
+            subscript.value.id = "list"
+        if isinstance(subscript.slice, ast.Subscript):
+            subscript.slice = cls.replace_list_in_subscript(subscript.slice)
+
+        return subscript
+
+    @classmethod
+    def replace_list_annotations(cls, module: ast.Module) -> ast.Module:
+        for item in module.body:
+            if not isinstance(item, ast.ClassDef):
+                continue
+
+            # replace List with list in the annotations when list is used as a type
+            for class_item in item.body:
+                if not isinstance(class_item, ast.AnnAssign):
+                    continue
+                if isinstance(class_item.annotation, ast.Subscript):
+                    class_item.annotation = cls.replace_list_in_subscript(class_item.annotation)
+
+        return module
+
+    def generate_result_types_module(
+        self,
+        module: ast.Module,
+        operation_definition: ExecutableDefinitionNode,  # noqa: ARG002
+    ) -> ast.Module:
+        module = FutureAnnotationPlugin.insert_future_annotation(module)
+        return self.replace_list_annotations(module)
+
+
+class PydanticBaseModelPlugin(Plugin):
+    @staticmethod
+    def find_base_model_index(module: ast.Module) -> int:
+        for idx, item in enumerate(module.body):
+            if isinstance(item, ast.ImportFrom) and item.module == "base_model":
+                return idx
+        raise ValueError("BaseModel not found in module")
+
+    @classmethod
+    def replace_base_model_import(cls, module: ast.Module) -> ast.Module:
+        base_model_index = cls.find_base_model_index(module)
+        module.body[base_model_index] = ast.ImportFrom(module="pydantic", names=[ast.alias(name="BaseModel")], level=0)
+        return module
+
+    def generate_result_types_module(
+        self,
+        module: ast.Module,
+        operation_definition: ExecutableDefinitionNode,  # noqa: ARG002
+    ) -> ast.Module:
+        return self.replace_base_model_import(module)