infrahub-server 1.2.0b1__py3-none-any.whl → 1.2.1__py3-none-any.whl

infrahub/git/tasks.py

@@ -1,5 +1,12 @@
 from infrahub_sdk import InfrahubClient
-from infrahub_sdk.protocols import CoreArtifact, CoreArtifactDefinition, CoreCheckDefinition, CoreRepository
+from infrahub_sdk.protocols import (
+    CoreArtifact,
+    CoreArtifactDefinition,
+    CoreCheckDefinition,
+    CoreRepository,
+    CoreRepositoryValidator,
+    CoreUserValidator,
+)
 from infrahub_sdk.uuidt import UUIDT
 from prefect import flow, task
 from prefect.cache_policies import NONE
@@ -7,11 +14,12 @@ from prefect.logging import get_run_logger
 
 from infrahub import lock
 from infrahub.context import InfrahubContext
-from infrahub.core.constants import InfrahubKind, RepositoryInternalStatus, ValidatorConclusion, ValidatorState
+from infrahub.core.constants import InfrahubKind, RepositoryInternalStatus, ValidatorConclusion
 from infrahub.core.registry import registry
 from infrahub.exceptions import CheckError, RepositoryError
 from infrahub.message_bus import Meta, messages
 from infrahub.services import InfrahubServices
+from infrahub.validators.tasks import start_validator
 from infrahub.worker import WORKER_IDENTITY
 
 from ..core.manager import NodeManager
@@ -509,7 +517,9 @@ async def git_repository_diff_names_only(
     name="git-repository-user-checks-definition-trigger",
     flow_run_name="Trigger user defined checks for repository {model.repository_name}",
 )
-async def trigger_repository_user_checks_definitions(model: UserCheckDefinitionData, service: InfrahubServices) -> None:
+async def trigger_repository_user_checks_definitions(
+    model: UserCheckDefinitionData, context: InfrahubContext, service: InfrahubServices
+) -> None:
     await add_tags(branches=[model.branch_name], nodes=[model.proposed_change])
     log = get_run_logger()
 
@@ -520,8 +530,8 @@ async def trigger_repository_user_checks_definitions(model: UserCheckDefinitionD
     validator_execution_id = str(UUIDT())
     check_execution_ids: list[str] = []
     await proposed_change.validations.fetch()
-    validator = None
 
+    previous_validator: CoreUserValidator | None = None
     for relationship in proposed_change.validations.peers:
         existing_validator = relationship.peer
 
@@ -530,26 +540,21 @@ async def trigger_repository_user_checks_definitions(model: UserCheckDefinitionD
             and existing_validator.repository.id == model.repository_id
             and existing_validator.check_definition.id == model.check_definition_id
         ):
-            validator = existing_validator
-            service.log.info("Found the same validator", validator=validator)
-
-    if validator:
-        validator.conclusion.value = ValidatorConclusion.UNKNOWN.value
-        validator.state.value = ValidatorState.QUEUED.value
-        validator.started_at.value = ""
-        validator.completed_at.value = ""
-        await validator.save()
-    else:
-        validator = await service.client.create(
-            kind=InfrahubKind.USERVALIDATOR,
-            data={
-                "label": f"Check: {definition.name.value}",
-                "proposed_change": model.proposed_change,
-                "repository": model.repository_id,
-                "check_definition": model.check_definition_id,
-            },
-        )
-        await validator.save()
+            previous_validator = existing_validator
+            service.log.info("Found the same validator", validator=previous_validator)
+
+    validator = await start_validator(
+        service=service,
+        validator=previous_validator,
+        validator_type=CoreUserValidator,
+        proposed_change=model.proposed_change,
+        data={
+            "label": f"Check: {definition.name.value}",
+            "repository": model.repository_id,
+            "check_definition": model.check_definition_id,
+        },
+        context=context,
+    )
 
     if definition.targets.id:
         # Check against a group of targets
@@ -612,14 +617,22 @@ async def trigger_repository_user_checks_definitions(model: UserCheckDefinitionD
         for model in check_models
     ]
 
-    await run_checks_and_update_validator(checks_coroutines, validator)
+    await run_checks_and_update_validator(
+        checks=checks_coroutines,
+        validator=validator,
+        context=context,
+        service=service,
+        proposed_change_id=model.proposed_change,
+    )
 
 
 @flow(
     name="git-repository-trigger-user-checks",
     flow_run_name="Evaluating user-defined checks on repository {model.repository_name}",
 )
-async def trigger_user_checks(model: TriggerRepositoryUserChecks, service: InfrahubServices) -> None:
+async def trigger_user_checks(
+    model: TriggerRepositoryUserChecks, service: InfrahubServices, context: InfrahubContext
+) -> None:
     """Request to start validation checks on a specific repository for User-defined checks."""
 
     await add_tags(branches=[model.source_branch], nodes=[model.proposed_change])
@@ -645,7 +658,9 @@ async def trigger_user_checks(model: TriggerRepositoryUserChecks, service: Infra
             branch_diff=model.branch_diff,
         )
         await service.workflow.submit_workflow(
-            workflow=GIT_REPOSITORY_USER_CHECKS_DEFINITIONS_TRIGGER, parameters={"model": user_check_definition_model}
+            workflow=GIT_REPOSITORY_USER_CHECKS_DEFINITIONS_TRIGGER,
+            context=context,
+            parameters={"model": user_check_definition_model},
         )
 
 
@@ -653,7 +668,9 @@ async def trigger_user_checks(model: TriggerRepositoryUserChecks, service: Infra
     name="git-repository-trigger-internal-checks",
     flow_run_name="Running repository checks for repository {model.repository}",
 )
-async def trigger_internal_checks(model: TriggerRepositoryInternalChecks, service: InfrahubServices) -> None:
+async def trigger_internal_checks(
+    model: TriggerRepositoryInternalChecks, service: InfrahubServices, context: InfrahubContext
+) -> None:
     """Request to start validation checks on a specific repository."""
     await add_tags(branches=[model.source_branch], nodes=[model.proposed_change])
     log = get_run_logger()
@@ -669,7 +686,7 @@ async def trigger_internal_checks(model: TriggerRepositoryInternalChecks, servic
     await repository.checks.fetch()
 
     validator_name = f"Repository Validator: {repository.name.value}"
-    validator = None
+    previous_validator: CoreRepositoryValidator | None = None
     for relationship in proposed_change.validations.peers:
         existing_validator = relationship.peer
 
@@ -677,24 +694,19 @@ async def trigger_internal_checks(model: TriggerRepositoryInternalChecks, servic
             existing_validator.typename == InfrahubKind.REPOSITORYVALIDATOR
             and existing_validator.repository.id == model.repository
         ):
-            validator = existing_validator
-
-    if validator:
-        validator.conclusion.value = ValidatorConclusion.UNKNOWN.value
-        validator.state.value = ValidatorState.QUEUED.value
-        validator.started_at.value = ""
-        validator.completed_at.value = ""
-        await validator.save()
-    else:
-        validator = await service.client.create(
-            kind=InfrahubKind.REPOSITORYVALIDATOR,
-            data={
-                "label": validator_name,
-                "proposed_change": model.proposed_change,
-                "repository": model.repository,
-            },
-        )
-        await validator.save()
+            previous_validator = existing_validator
+
+    validator = await start_validator(
+        service=service,
+        validator=previous_validator,
+        validator_type=CoreRepositoryValidator,
+        proposed_change=model.proposed_change,
+        data={
+            "label": validator_name,
+            "repository": model.repository,
+        },
+        context=context,
+    )
 
     check_execution_id = str(UUIDT())
     check_execution_ids.append(check_execution_id)
@@ -718,7 +730,13 @@ async def trigger_internal_checks(model: TriggerRepositoryInternalChecks, servic
         expected_return=ValidatorConclusion,
     )
 
-    await run_checks_and_update_validator(checks=[check_coroutine], validator=validator)
+    await run_checks_and_update_validator(
+        checks=[check_coroutine],
+        validator=validator,
+        context=context,
+        service=service,
+        proposed_change_id=model.proposed_change,
+    )
 
 
 @flow(
@@ -822,7 +840,7 @@ async def run_user_check(model: UserCheckData, service: InfrahubServices) -> Val
             client=service.client,
             commit=model.commit,
             params=model.variables,
-        )
+        )  # type: ignore[misc]
         if check_run.passed:
             conclusion = ValidatorConclusion.SUCCESS
             severity = "info"

infrahub/git/utils.py

@@ -0,0 +1,48 @@
+from typing import TYPE_CHECKING
+
+from infrahub.core import registry
+from infrahub.core.constants import InfrahubKind
+from infrahub.core.manager import NodeManager
+from infrahub.database import InfrahubDatabase
+
+from .models import RepositoryBranchInfo, RepositoryData
+
+if TYPE_CHECKING:
+    from infrahub.core.protocols import CoreGenericRepository
+
+
+async def get_repositories_commit_per_branch(
+    db: InfrahubDatabase,
+) -> dict[str, RepositoryData]:
+    """Get a list of all repositories and their commit on each branches.
+
+    This method is similar to 'get_list_repositories' method in the Python SDK.
+
+    NOTE: At some point, we should refactor this function to use a single Database query instead of one per branch
+    """
+
+    repositories: dict[str, RepositoryData] = {}
+
+    for branch in list(registry.branch.values()):
+        repos: list[CoreGenericRepository] = await NodeManager.query(
+            db=db,
+            branch=branch,
+            fields={"id": None, "name": None, "commit": None, "internal_status": None},
+            schema=InfrahubKind.GENERICREPOSITORY,
+        )
+
+        for repository in repos:
+            repo_name = repository.name.value
+            if repo_name not in repositories:
+                repositories[repo_name] = RepositoryData(
+                    repository_id=repository.get_id(),
+                    repository_name=repo_name,
+                    branches={},
+                )
+
+            repositories[repo_name].branches[branch.name] = repository.commit.value  # type: ignore[attr-defined]
+            repositories[repo_name].branch_info[branch.name] = RepositoryBranchInfo(
+                internal_status=repository.internal_status.value
+            )
+
+    return repositories

infrahub/git/worktree.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Optional
 
 from pydantic import BaseModel
 
@@ -14,7 +13,7 @@ class Worktree(BaseModel):
     identifier: str
     directory: Path
     commit: str
-    branch: Optional[str] = None
+    branch: str | None = None
 
     @classmethod
     def init(cls, text: str) -> Worktree:

infrahub/git_credential/askpass.py

@@ -1,6 +1,5 @@
 import re
 import sys
-from typing import Optional
 
 import typer
 from infrahub_sdk import Config, InfrahubClientSync
@@ -16,7 +15,7 @@ REGEX_PASSWORD = r"^Password.*\'(.*\:\/\/)(.*)@(.*)\'"
 
 @app.command()
 def askpass(
-    text: Optional[list[str]] = typer.Argument(None),
+    text: list[str] | None = typer.Argument(None),
     config_file: str = typer.Option("infrahub.toml", envvar="INFRAHUB_CONFIG"),
 ) -> None:
     config.SETTINGS.initialize_and_exit(config_file=config_file)

infrahub/graphql/analyzer.py

@@ -258,6 +258,18 @@ class GraphQLQueryReport:
 
         return access
 
+    def fields_by_kind(self, kind: str) -> list[str]:
+        fields: list[str] = []
+        if access := self.requested_read.get(kind):
+            fields.extend(list(access.attributes))
+            fields.extend(list(access.relationships))
+
+        return fields
+
+    @cached_property
+    def top_level_kinds(self) -> list[str]:
+        return [query.infrahub_model.kind for query in self.queries if query.infrahub_model]
+
     @cached_property
     def kind_action_map(self) -> dict[str, set[MutateAction]]:
         access: dict[str, set[MutateAction]] = {}

infrahub/graphql/app.py

@@ -13,9 +13,7 @@ from typing import (
     AsyncGenerator,
     Awaitable,
     Callable,
-    Optional,
     Sequence,
-    Union,
     cast,
 )
 
@@ -87,7 +85,7 @@ GQL_ERROR = "error"
 GQL_START = "start"
 GQL_STOP = "stop"
 
-ContextValue = Union[Any, Callable[[HTTPConnection], Any]]
+ContextValue = Any | Callable[[HTTPConnection], Any]
 RootValue = Any
 
 
@@ -95,13 +93,13 @@ class InfrahubGraphQLApp:
     def __init__(
         self,
         permission_checker: GraphQLQueryPermissionChecker,
-        schema: Optional[graphene.Schema] = None,
+        schema: graphene.Schema | None = None,
         *,
-        on_get: Optional[Callable[[Request], Union[Response, Awaitable[Response]]]] = None,
+        on_get: Callable[[Request], Response | Awaitable[Response]] | None = None,
         root_value: RootValue = None,
-        middleware: Optional[Middleware] = None,
+        middleware: Middleware | None = None,
         error_formatter: Callable[[GraphQLError], GraphQLFormattedError] = format_error,
-        execution_context_class: Optional[type[ExecutionContext]] = None,
+        execution_context_class: type[ExecutionContext] | None = None,
     ) -> None:
         self._schema = schema
         self.on_get = on_get
@@ -116,7 +114,7 @@ class InfrahubGraphQLApp:
         db: InfrahubDatabase
         if scope["type"] == "http":
             request = Request(scope=scope, receive=receive)
-            response: Optional[Response] = None
+            response: Response | None = None
             jwt_auth = await jwt_scheme(request)
             api_key = await api_key_scheme(request)
             cookie_auth = await cookie_auth_scheme(request)
@@ -166,7 +164,7 @@ class InfrahubGraphQLApp:
         else:
             raise ValueError(f"Unsupported scope type: ${scope['type']}")
 
-    async def _get_on_get(self, request: Request) -> Optional[Response]:
+    async def _get_on_get(self, request: Request) -> Response | None:
         handler = self.on_get
 
         if handler is None:
@@ -388,8 +386,8 @@ class InfrahubGraphQLApp:
         graphql_params = await prepare_graphql_params(db=db, branch=branch)
 
         errors: list[GraphQLError] = []
-        operation: Optional[OperationDefinitionNode] = None
-        document: Optional[DocumentNode] = None
+        operation: OperationDefinitionNode | None = None
+        document: DocumentNode | None = None
 
         try:
             document = parse(query)
@@ -474,11 +472,11 @@ class InfrahubGraphQLApp:
             await websocket.send_json({"type": GQL_COMPLETE, "id": operation_id})
 
 
-async def _get_operation_from_request(request: Request) -> Union[dict[str, Any], list[Any]]:
+async def _get_operation_from_request(request: Request) -> dict[str, Any] | list[Any]:
     content_type = request.headers.get("Content-Type", "").split(";")[0]
     if content_type == "application/json":
         try:
-            return cast(Union[dict[str, Any], list[Any]], await request.json())
+            return cast(dict[str, Any] | list[Any], await request.json())
         except (TypeError, ValueError) as err:
             raise ValueError("Request body is not a valid JSON") from err
     elif content_type == "multipart/form-data":
@@ -487,7 +485,7 @@ async def _get_operation_from_request(request: Request) -> Union[dict[str, Any],
         raise ValueError("Content-type must be application/json or multipart/form-data")
 
 
-async def _get_operation_from_multipart(request: Request) -> Union[dict[str, Any], list[Any]]:
+async def _get_operation_from_multipart(request: Request) -> dict[str, Any] | list[Any]:
     try:
         request_body = await request.form()
     except Exception as err:
@@ -526,7 +524,7 @@ async def _get_operation_from_multipart(request: Request) -> Union[dict[str, Any
 
 def _inject_file_to_operations(ops_tree: Any, _file: UploadFile, path: Sequence[str]) -> None:
     k = path[0]
-    key: Union[str, int]
+    key: str | int
     try:
         key = int(k)
     except ValueError:

infrahub/graphql/context.py

@@ -17,6 +17,12 @@ async def apply_external_context(graphql_context: GraphqlContext, context_input:
     if not context_input or not context_input.account:
         return
 
+    if graphql_context.active_account_session.account_id == context_input.account.id:
+        # If the account_id from the request context is the same as the current account
+        # there's no point moving forward with other checks to override the current
+        # context we can just continue with what is already there.
+        return
+
     permission = define_global_permission_from_branch(
         permission=GlobalPermissions.OVERRIDE_CONTEXT, branch_name=graphql_context.branch.name
     )

infrahub/graphql/initialization.py

@@ -9,6 +9,7 @@ from infrahub.context import InfrahubContext
 from infrahub.core import registry
 from infrahub.core.timestamp import Timestamp
 from infrahub.exceptions import InitializationError
+from infrahub.graphql.resolvers.many_relationship import ManyRelationshipResolver
 from infrahub.graphql.resolvers.single_relationship import SingleRelationshipResolver
 from infrahub.permissions import PermissionManager
 
@@ -36,6 +37,7 @@ class GraphqlContext:
     branch: Branch
     types: dict
     single_relationship_resolver: SingleRelationshipResolver
+    many_relationship_resolver: ManyRelationshipResolver
     service: InfrahubServices | None = None
     at: Timestamp | None = None
     related_node_ids: set | None = None
@@ -111,6 +113,7 @@ async def prepare_graphql_params(
             db=db,
             branch=branch,
             single_relationship_resolver=SingleRelationshipResolver(),
+            many_relationship_resolver=ManyRelationshipResolver(),
             at=Timestamp(at),
             types=gqlm.get_graphql_types(),
             related_node_ids=set(),

infrahub/graphql/loaders/node.py

@@ -10,6 +10,8 @@ from infrahub.core.node import Node
 from infrahub.core.timestamp import Timestamp
 from infrahub.database import InfrahubDatabase
 
+from .shared import to_frozen_set
+
 
 @dataclass
 class GetManyParams:
@@ -68,15 +70,3 @@ class NodeDataLoader(DataLoader[str, Node | None]):
         for node_id in keys:
             results.append(nodes_by_id.get(node_id, None))
         return results
-
-
-def to_frozen_set(to_freeze: dict[str, Any]) -> frozenset:
-    freezing_dict = {}
-    for k, v in to_freeze.items():
-        if isinstance(v, dict):
-            freezing_dict[k] = to_frozen_set(v)
-        elif isinstance(v, list | set):
-            freezing_dict[k] = frozenset(v)
-        else:
-            freezing_dict[k] = v
-    return frozenset(freezing_dict)

infrahub/graphql/loaders/peers.py

@@ -0,0 +1,77 @@
+from dataclasses import dataclass
+from typing import Any
+
+from aiodataloader import DataLoader
+
+from infrahub.core.branch.models import Branch
+from infrahub.core.manager import NodeManager
+from infrahub.core.relationship.model import Relationship
+from infrahub.core.schema.relationship_schema import RelationshipSchema
+from infrahub.core.timestamp import Timestamp
+from infrahub.database import InfrahubDatabase
+
+from .shared import to_frozen_set
+
+
+@dataclass
+class QueryPeerParams:
+    branch: Branch | str
+    source_kind: str
+    schema: RelationshipSchema
+    filters: dict[str, Any]
+    fields: dict | None = None
+    at: Timestamp | str | None = None
+    branch_agnostic: bool = False
+
+    def __hash__(self) -> int:
+        frozen_fields: frozenset | None = None
+        if self.fields:
+            frozen_fields = to_frozen_set(self.fields)
+        frozen_filters = to_frozen_set(self.filters)
+        timestamp = Timestamp(self.at)
+        branch = self.branch.name if isinstance(self.branch, Branch) else self.branch
+        hash_str = "|".join(
+            [
+                str(hash(frozen_fields)),
+                str(hash(frozen_filters)),
+                timestamp.to_string(),
+                branch,
+                self.schema.name,
+                str(self.source_kind),
+                str(self.branch_agnostic),
+            ]
+        )
+        return hash(hash_str)
+
+
+class PeerRelationshipsDataLoader(DataLoader[str, list[Relationship]]):
+    def __init__(self, db: InfrahubDatabase, query_params: QueryPeerParams, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.query_params = query_params
+        self.db = db
+
+    async def batch_load_fn(self, keys: list[Any]) -> list[list[Relationship]]:  # pylint: disable=method-hidden
+        async with self.db.start_session() as db:
+            peer_rels = await NodeManager.query_peers(
+                db=db,
+                ids=keys,
+                source_kind=self.query_params.source_kind,
+                schema=self.query_params.schema,
+                filters=self.query_params.filters,
+                fields=self.query_params.fields,
+                at=self.query_params.at,
+                branch=self.query_params.branch,
+                branch_agnostic=self.query_params.branch_agnostic,
+                fetch_peers=True,
+            )
+        peer_rels_by_node_id: dict[str, list[Relationship]] = {}
+        for rel in peer_rels:
+            node_id = rel.node_id
+            if node_id not in peer_rels_by_node_id:
+                peer_rels_by_node_id[node_id] = []
+            peer_rels_by_node_id[node_id].append(rel)
+
+        results = []
+        for node_id in keys:
+            results.append(peer_rels_by_node_id.get(node_id, []))
+        return results

infrahub/graphql/loaders/shared.py

@@ -0,0 +1,13 @@
+from typing import Any
+
+
+def to_frozen_set(to_freeze: dict[str, Any]) -> frozenset:
+    freezing_dict = {}
+    for k, v in to_freeze.items():
+        if isinstance(v, dict):
+            freezing_dict[k] = to_frozen_set(v)
+        elif isinstance(v, list | set):
+            freezing_dict[k] = frozenset(v)
+        else:
+            freezing_dict[k] = v
+    return frozenset(freezing_dict)

infrahub/graphql/manager.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Iterable, Optional, Union
+from typing import TYPE_CHECKING, Any, Iterable
 
 import graphene
 
@@ -38,6 +38,7 @@ from .mutations.repository import InfrahubRepositoryMutation
 from .mutations.resource_manager import (
     InfrahubNumberPoolMutation,
 )
+from .mutations.webhook import InfrahubWebhookMutation
 from .resolvers.resolver import (
     account_resolver,
     ancestors_resolver,
@@ -75,9 +76,7 @@ class DeleteInput(graphene.InputObjectType):
     hfid = graphene.List(of_type=graphene.String, required=False)
 
 
-GraphQLTypes = Union[
-    type[InfrahubMutation], type[BaseAttributeType], type[graphene.Interface], type[graphene.ObjectType]
-]
+GraphQLTypes = type[InfrahubMutation] | type[BaseAttributeType] | type[graphene.Interface] | type[graphene.ObjectType]
 
 
 class OrderInput(graphene.InputObjectType):
@@ -513,6 +512,8 @@ class GraphQLSchemaManager:
                 InfrahubKind.NAMESPACE: InfrahubIPNamespaceMutation,
                 InfrahubKind.NUMBERPOOL: InfrahubNumberPoolMutation,
                 InfrahubKind.MENUITEM: InfrahubCoreMenuMutation,
+                InfrahubKind.STANDARDWEBHOOK: InfrahubWebhookMutation,
+                InfrahubKind.CUSTOMWEBHOOK: InfrahubWebhookMutation,
             }
 
             if isinstance(node_schema, NodeSchema) and node_schema.is_ip_prefix():
@@ -643,7 +644,9 @@ class GraphQLSchemaManager:
         self.set_type(name=type_name, graphql_type=relationship_property)
 
     def generate_graphql_mutations(
-        self, schema: NodeSchema | ProfileSchema | TemplateSchema, base_class: type[InfrahubMutation]
+        self,
+        schema: NodeSchema | ProfileSchema | TemplateSchema,
+        base_class: type[InfrahubMutation],
     ) -> GraphqlMutations:
         graphql_mutation_create_input = self.generate_graphql_mutation_create_input(schema)
         graphql_mutation_update_input = self.generate_graphql_mutation_update_input(schema)
@@ -682,7 +685,7 @@ class GraphQLSchemaManager:
                 slug = InputField(StringAttributeCreate, required=True)
                 description = InputField(StringAttributeCreate, required=False)
         """
-        attrs: dict[str, Union[graphene.String, graphene.InputField]] = {"id": graphene.String(required=False)}
+        attrs: dict[str, graphene.String | graphene.InputField] = {"id": graphene.String(required=False)}
 
         for attr in schema.attributes:
             if attr.read_only:
@@ -718,7 +721,7 @@ class GraphQLSchemaManager:
                 slug = InputField(StringAttributeUpdate, required=False)
                 description = InputField(StringAttributeUpdate, required=False)
         """
-        attrs: dict[str, Union[graphene.String, graphene.InputField]] = {
+        attrs: dict[str, graphene.String | graphene.InputField] = {
             "id": graphene.String(required=False),
             "hfid": graphene.List(of_type=graphene.String, required=False),
         }
@@ -759,7 +762,7 @@ class GraphQLSchemaManager:
                 slug = InputField(StringAttributeUpdate, required=True)
                 description = InputField(StringAttributeUpdate, required=False)
         """
-        attrs: dict[str, Union[graphene.String, graphene.InputField]] = {
+        attrs: dict[str, graphene.String | graphene.InputField] = {
             "id": graphene.String(required=False),
             "hfid": graphene.List(of_type=graphene.String, required=False),
         }
@@ -855,7 +858,7 @@ class GraphQLSchemaManager:
 
     def generate_filters(
         self, schema: MainSchemaTypes, top_level: bool = False, include_properties: bool = True
-    ) -> dict[str, Union[graphene.Scalar, graphene.List]]:
+    ) -> dict[str, graphene.Scalar | graphene.List]:
         """Generate the GraphQL filters for a given Schema object.
 
         The generated filter will be different if we are at the top_level (query)
@@ -920,7 +923,7 @@ class GraphQLSchemaManager:
         self,
         schema: MainSchemaTypes,
         node: type[InfrahubObject],
-        relation_property: Optional[type[InfrahubObject]] = None,
+        relation_property: type[InfrahubObject] | None = None,
         populate_cache: bool = False,
     ) -> type[InfrahubObject]:
         """Generate a edged GraphQL object Type from a Infrahub NodeSchema for pagination."""