infrahub-server 1.2.11__py3-none-any.whl → 1.3.0b1__py3-none-any.whl

infrahub/graphql/mutations/main.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Mapping
+from typing import TYPE_CHECKING, Any
 
 from graphene import InputObjectType, Mutation
 from graphene.types.mutation import MutationOptions
@@ -9,12 +9,15 @@ from infrahub_sdk.utils import extract_fields
 from typing_extensions import Self
 
 from infrahub import config, lock
-from infrahub.core import registry
-from infrahub.core.constants import InfrahubKind, MutationAction, RelationshipCardinality, RelationshipKind
+from infrahub.core.constants import InfrahubKind, MutationAction
 from infrahub.core.constraint.node.runner import NodeConstraintRunner
 from infrahub.core.manager import NodeManager
-from infrahub.core.node import Node
-from infrahub.core.schema import MainSchemaTypes, NodeSchema, RelationshipSchema
+from infrahub.core.node.create import (
+    create_node,
+    get_profile_ids,
+    refresh_for_profile_update,
+)
+from infrahub.core.schema import MainSchemaTypes, NodeSchema
 from infrahub.core.schema.generic_schema import GenericSchema
 from infrahub.core.schema.profile_schema import ProfileSchema
 from infrahub.core.schema.template_schema import TemplateSchema
@@ -33,8 +36,7 @@ if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
 
     from infrahub.core.branch import Branch
-    from infrahub.core.protocols import CoreObjectTemplate
-    from infrahub.core.relationship.model import RelationshipManager
+    from infrahub.core.node import Node
     from infrahub.core.schema.schema_branch import SchemaBranch
     from infrahub.database import InfrahubDatabase
     from infrahub.graphql.types.context import ContextInput
@@ -143,33 +145,6 @@ class InfrahubMutationMixin:
 
         return mutation
 
-    @classmethod
-    async def _get_profile_ids(cls, db: InfrahubDatabase, obj: Node) -> set[str]:
-        if not hasattr(obj, "profiles"):
-            return set()
-        profile_rels = await obj.profiles.get_relationships(db=db)
-        return {pr.peer_id for pr in profile_rels}
-
-    @classmethod
-    async def _refresh_for_profile_update(
-        cls, db: InfrahubDatabase, branch: Branch, obj: Node, previous_profile_ids: set[str] | None = None
-    ) -> Node:
-        if not hasattr(obj, "profiles"):
-            return obj
-        current_profile_ids = await cls._get_profile_ids(db=db, obj=obj)
-        if previous_profile_ids is None or previous_profile_ids != current_profile_ids:
-            refreshed_node = await NodeManager.get_one_by_id_or_default_filter(
-                db=db,
-                kind=cls._meta.active_schema.kind,
-                id=obj.get_id(),
-                branch=branch,
-                include_owner=True,
-                include_source=True,
-            )
-            refreshed_node._node_changelog = obj.node_changelog
-            return refreshed_node
-        return obj
-
     @classmethod
     async def _call_mutate_create_object(cls, data: InputObjectType, db: InfrahubDatabase, branch: Branch) -> Node:
         """
@@ -185,100 +160,6 @@ class InfrahubMutationMixin:
 
         return await cls.mutate_create_object(data=data, db=db, branch=branch)
 
-    @classmethod
-    async def _get_template_relationship_peers(
-        cls, db: InfrahubDatabase, template: CoreObjectTemplate, relationship: RelationshipSchema
-    ) -> Mapping[str, Node]:
-        """For a given relationship on the template, fetch the related peers."""
-        template_relationship_manager: RelationshipManager = getattr(template, relationship.name)
-        if relationship.cardinality == RelationshipCardinality.MANY:
-            return await template_relationship_manager.get_peers(db=db)
-
-        peers: dict[str, Node] = {}
-        template_relationship_peer = await template_relationship_manager.get_peer(db=db)
-        if template_relationship_peer:
-            peers[template_relationship_peer.id] = template_relationship_peer
-        return peers
-
-    @classmethod
-    async def _extract_peer_data(
-        cls,
-        db: InfrahubDatabase,
-        template_peer: Node,
-        obj_peer_schema: MainSchemaTypes,
-        parent_obj: Node,
-        current_template: CoreObjectTemplate,
-    ) -> Mapping[str, Any]:
-        obj_peer_data: dict[str, Any] = {}
-
-        for attr in template_peer.get_schema().attribute_names:
-            if attr not in obj_peer_schema.attribute_names:
-                continue
-            obj_peer_data[attr] = {"value": getattr(template_peer, attr).value, "source": template_peer.id}
-
-        for rel in template_peer.get_schema().relationship_names:
-            rel_manager: RelationshipManager = getattr(template_peer, rel)
-            if (
-                rel_manager.schema.kind not in [RelationshipKind.COMPONENT, RelationshipKind.PARENT]
-                or rel_manager.schema.name not in obj_peer_schema.relationship_names
-            ):
-                continue
-
-            if list(await rel_manager.get_peers(db=db)) == [current_template.id]:
-                obj_peer_data[rel] = {"id": parent_obj.id}
-
-        return obj_peer_data
-
-    @classmethod
-    async def _handle_template_relationships(
-        cls,
-        db: InfrahubDatabase,
-        branch: Branch,
-        obj: Node,
-        template: CoreObjectTemplate,
-        data: InputObjectType,
-        constraint_runner: NodeConstraintRunner | None = None,
-    ) -> None:
-        if constraint_runner is None:
-            component_registry = get_component_registry()
-            constraint_runner = await component_registry.get_component(NodeConstraintRunner, db=db, branch=branch)
-
-        for relationship in obj.get_relationships(kind=RelationshipKind.COMPONENT, exclude=list(data)):
-            template_relationship_peers = await cls._get_template_relationship_peers(
-                db=db, template=template, relationship=relationship
-            )
-            if not template_relationship_peers:
-                continue
-
-            for template_relationship_peer in template_relationship_peers.values():
-                # We retrieve peer schema for each peer in case we are processing a relationship which is based on a generic
-                obj_peer_schema = registry.schema.get_node_schema(
-                    name=template_relationship_peer.get_schema().kind.removeprefix("Template"),
-                    branch=branch,
-                    duplicate=False,
-                )
-                obj_peer_data = await cls._extract_peer_data(
-                    db=db,
-                    template_peer=template_relationship_peer,
-                    obj_peer_schema=obj_peer_schema,
-                    parent_obj=obj,
-                    current_template=template,
-                )
-
-                obj_peer = await Node.init(schema=obj_peer_schema, db=db, branch=branch)
-                await obj_peer.new(db=db, **obj_peer_data)
-                await constraint_runner.check(node=obj_peer, field_filters=list(obj_peer_data))
-                await obj_peer.save(db=db)
-
-                await cls._handle_template_relationships(
-                    db=db,
-                    branch=branch,
-                    constraint_runner=constraint_runner,
-                    obj=obj_peer,
-                    template=template_relationship_peer,
-                    data=data,
-                )
-
     @classmethod
     async def mutate_create(
         cls,
@@ -301,51 +182,15 @@ class InfrahubMutationMixin:
         db: InfrahubDatabase,
         branch: Branch,
     ) -> Node:
-        component_registry = get_component_registry()
-        node_constraint_runner = await component_registry.get_component(
-            NodeConstraintRunner, db=db.start_session(), branch=branch
+        schema = cls._meta.active_schema
+        if isinstance(schema, GenericSchema):
+            raise ValueError(f"Node of generic schema `{schema.name=}` can not be instantiated.")
+        return await create_node(
+            data=dict(data),
+            db=db,
+            branch=branch,
+            schema=schema,
         )
-        node_class = Node
-        if cls._meta.active_schema.kind in registry.node:
-            node_class = registry.node[cls._meta.active_schema.kind]
-
-        fields_to_validate = list(data)
-        if db.is_transaction:
-            obj = await node_class.init(db=db, schema=cls._meta.schema, branch=branch)
-            await obj.new(db=db, **data)
-            await node_constraint_runner.check(node=obj, field_filters=fields_to_validate)
-            await obj.save(db=db)
-
-            object_template = await obj.get_object_template(db=db)
-            if object_template:
-                await cls._handle_template_relationships(
-                    db=db,
-                    branch=branch,
-                    template=object_template,
-                    obj=obj,
-                    data=data,
-                )
-        else:
-            async with db.start_transaction() as dbt:
-                obj = await node_class.init(db=dbt, schema=cls._meta.schema, branch=branch)
-                await obj.new(db=dbt, **data)
-                await node_constraint_runner.check(node=obj, field_filters=fields_to_validate)
-                await obj.save(db=dbt)
-
-                object_template = await obj.get_object_template(db=dbt)
-                if object_template:
-                    await cls._handle_template_relationships(
-                        db=dbt,
-                        branch=branch,
-                        template=object_template,
-                        obj=obj,
-                        data=data,
-                    )
-
-        if await cls._get_profile_ids(db=db, obj=obj):
-            obj = await cls._refresh_for_profile_update(db=db, branch=branch, obj=obj)
-
-        return obj
 
     @classmethod
     async def mutate_create_to_graphql(cls, info: GraphQLResolveInfo, db: InfrahubDatabase, obj: Node) -> Self:
@@ -439,7 +284,7 @@ class InfrahubMutationMixin:
         component_registry = get_component_registry()
         node_constraint_runner = await component_registry.get_component(NodeConstraintRunner, db=db, branch=branch)
 
-        before_mutate_profile_ids = await cls._get_profile_ids(db=db, obj=obj)
+        before_mutate_profile_ids = await get_profile_ids(db=db, obj=obj)
         await obj.from_graphql(db=db, data=data)
         fields_to_validate = list(data)
         await node_constraint_runner.check(
@@ -453,8 +298,12 @@ class InfrahubMutationMixin:
 
         await obj.save(db=db, fields=fields)
 
-        obj = await cls._refresh_for_profile_update(
-            db=db, branch=branch, obj=obj, previous_profile_ids=before_mutate_profile_ids
+        obj = await refresh_for_profile_update(
+            db=db,
+            branch=branch,
+            obj=obj,
+            previous_profile_ids=before_mutate_profile_ids,
+            schema=cls._meta.active_schema,
         )
         return obj
 

infrahub/graphql/mutations/proposed_change.py

@@ -18,10 +18,10 @@ from infrahub.database import InfrahubDatabase, retry_db_transaction
 from infrahub.exceptions import BranchNotFoundError, PermissionDeniedError, ValidationError
 from infrahub.graphql.mutations.main import InfrahubMutationMixin
 from infrahub.graphql.types.enums import CheckType as GraphQLCheckType
-from infrahub.message_bus import messages
 from infrahub.proposed_change.constants import ProposedChangeState
-from infrahub.workflows.catalogue import PROPOSED_CHANGE_MERGE
+from infrahub.workflows.catalogue import PROPOSED_CHANGE_MERGE, REQUEST_PROPOSED_CHANGE_PIPELINE
 
+from ...proposed_change.models import RequestProposedChangePipeline
 from ..types.task import TaskInfo
 from .main import InfrahubMutationOptions
 
@@ -65,18 +65,18 @@ class InfrahubProposedChangeMutation(InfrahubMutationMixin, Mutation):
                 )
 
         if graphql_context.service:
-            message_list = [
-                messages.RequestProposedChangePipeline(
-                    proposed_change=proposed_change.id,
-                    source_branch=source_branch.name,
-                    source_branch_sync_with_git=source_branch.sync_with_git,
-                    destination_branch=destination_branch,
-                    context=graphql_context.get_context(),
-                ),
-            ]
-
-            for message in message_list:
-                await graphql_context.service.message_bus.send(message=message)
+            request_proposed_change_model = RequestProposedChangePipeline(
+                proposed_change=proposed_change.id,
+                source_branch=source_branch.name,
+                source_branch_sync_with_git=source_branch.sync_with_git,
+                destination_branch=destination_branch,
+            )
+
+            await graphql_context.service.workflow.submit_workflow(
+                workflow=REQUEST_PROPOSED_CHANGE_PIPELINE,
+                parameters={"model": request_proposed_change_model},
+                context=graphql_context.get_context(),
+            )
 
         return proposed_change, result
 
@@ -175,16 +175,19 @@ class ProposedChangeRequestRunCheck(Mutation):
         destination_branch = proposed_change.destination_branch.value
         source_branch = await _get_source_branch(db=graphql_context.db, name=proposed_change.source_branch.value)
 
-        message = messages.RequestProposedChangePipeline(
+        request_proposed_change_model = RequestProposedChangePipeline(
             proposed_change=proposed_change.id,
             source_branch=source_branch.name,
             source_branch_sync_with_git=source_branch.sync_with_git,
             destination_branch=destination_branch,
             check_type=check_type,
-            context=graphql_context.get_context(),
         )
         if graphql_context.service:
-            await graphql_context.service.message_bus.send(message=message)
+            await graphql_context.service.workflow.submit_workflow(
+                workflow=REQUEST_PROPOSED_CHANGE_PIPELINE,
+                parameters={"model": request_proposed_change_model},
+                context=graphql_context.get_context(),
+            )
 
         return {"ok": True}
 

infrahub/graphql/mutations/resource_manager.py

@@ -6,15 +6,17 @@ from graphene import Boolean, Field, InputField, InputObjectType, Int, List, Mut
 from graphene.types.generic import GenericScalar
 from typing_extensions import Self
 
-from infrahub.core import registry
+from infrahub.core import protocols, registry
 from infrahub.core.constants import InfrahubKind
 from infrahub.core.ipam.constants import PrefixMemberType
+from infrahub.core.manager import NodeManager
 from infrahub.core.schema import NodeSchema
+from infrahub.core.schema.attribute_parameters import NumberAttributeParameters
 from infrahub.database import retry_db_transaction
 from infrahub.exceptions import QueryValidationError, SchemaNotFoundError, ValidationError
 
 from ..queries.resource_manager import PoolAllocatedNode
-from .main import InfrahubMutationMixin, InfrahubMutationOptions
+from .main import DeleteResult, InfrahubMutationMixin, InfrahubMutationOptions
 
 if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
@@ -177,14 +179,16 @@ class InfrahubNumberPoolMutation(InfrahubMutationMixin, Mutation):
         database: InfrahubDatabase | None = None,  # noqa: ARG003
     ) -> Any:
         try:
-            pool_node = registry.schema.get(name=data["node"].value)
-            if not pool_node.is_generic_schema and not pool_node.is_node_schema:
+            schema_node = registry.schema.get(name=data["node"].value)
+            if not schema_node.is_generic_schema and not schema_node.is_node_schema:
                 raise ValidationError(input_value="The selected model is not a Node or a Generic")
         except SchemaNotFoundError as exc:
             exc.message = "The selected model does not exist"
             raise exc
 
-        attributes = [attribute for attribute in pool_node.attributes if attribute.name == data["node_attribute"].value]
+        attributes = [
+            attribute for attribute in schema_node.attributes if attribute.name == data["node_attribute"].value
+        ]
         if not attributes:
             raise ValidationError(input_value="The selected attribute doesn't exist in the selected model")
 
@@ -192,9 +196,22 @@ class InfrahubNumberPoolMutation(InfrahubMutationMixin, Mutation):
         if attribute.kind != "Number":
             raise ValidationError(input_value="The selected attribute is not of the kind Number")
 
-        if data["start_range"].value > data["end_range"].value:
+        start_range = data["start_range"].value
+        end_range = data["end_range"].value
+        if start_range > end_range:
             raise ValidationError(input_value="start_range can't be larger than end_range")
 
+        if not isinstance(attribute.parameters, NumberAttributeParameters):
+            raise ValidationError(
+                input_value="The selected attribute parameters are not of the kind NumberAttributeParameters"
+            )
+
+        if attribute.parameters.min_value is not None and start_range < attribute.parameters.min_value:
+            raise ValidationError(input_value="start_range can't be less than min_value")
+
+        if attribute.parameters.max_value is not None and end_range > attribute.parameters.max_value:
+            raise ValidationError(input_value="end_range can't be larger than max_value")
+
         return await super().mutate_create(info=info, data=data, branch=branch)
 
     @classmethod
@@ -221,3 +238,42 @@ class InfrahubNumberPoolMutation(InfrahubMutationMixin, Mutation):
                 raise ValidationError(input_value="start_range can't be larger than end_range")
 
         return number_pool, result
+
+    @classmethod
+    @retry_db_transaction(name="resource_manager_update")
+    async def mutate_delete(
+        cls,
+        info: GraphQLResolveInfo,
+        data: InputObjectType,
+        branch: Branch,
+    ) -> DeleteResult:
+        graphql_context: GraphqlContext = info.context
+
+        number_pool = await NodeManager.find_object(
+            db=graphql_context.db,
+            kind=protocols.CoreNumberPool,
+            id=data.get("id"),
+            hfid=data.get("hfid"),
+            branch=branch,
+        )
+
+        active_branches = registry.schema.get_branches()
+        violating_branches = []
+        for active_branch in active_branches:
+            try:
+                schema = registry.schema.get(name=number_pool.node.value, branch=active_branch)
+            except SchemaNotFoundError:
+                continue
+
+            if number_pool.node_attribute.value in schema.attribute_names:
+                attribute = schema.get_attribute(name=number_pool.node_attribute.value)
+                if attribute.kind == "NumberPool":
+                    violating_branches.append(active_branch)
+
+        if violating_branches:
+            raise ValidationError(
+                input_value=f"Unable to delete number pool {number_pool.node.value}.{number_pool.node_attribute.value}"
+                f" is in use (branches: {','.join(violating_branches)})"
+            )
+
+        return await super().mutate_delete(info=info, data=data, branch=branch)

infrahub/graphql/queries/convert_object_type_mapping.py

@@ -0,0 +1,36 @@
+from graphene import Field, ObjectType, String
+from graphene.types.generic import GenericScalar
+from graphql import GraphQLResolveInfo
+
+from infrahub.core import registry
+from infrahub.core.convert_object_type.schema_mapping import get_schema_mapping
+
+
+class FieldsMapping(ObjectType):
+    mapping = GenericScalar(required=True)
+
+
+async def fields_mapping_type_conversion_resolver(
+    root: dict,  # noqa: ARG001
+    info: GraphQLResolveInfo,  # noqa: ARG001
+    source_kind: str,
+    target_kind: str,
+    branch: str,
+) -> dict:
+    source_schema = registry.get_node_schema(name=source_kind, branch=branch)
+    target_schema = registry.get_node_schema(name=target_kind, branch=branch)
+
+    mapping = get_schema_mapping(source_schema=source_schema, target_schema=target_schema)
+    mapping_dict = {field_name: model.model_dump(mode="json") for field_name, model in mapping.items()}
+    return {"mapping": mapping_dict}
+
+
+FieldsMappingTypeConversion = Field(
+    FieldsMapping,
+    source_kind=String(),
+    target_kind=String(),
+    branch=String(),
+    description="Retrieve fields mapping for converting object type",
+    resolver=fields_mapping_type_conversion_resolver,
+    required=True,
+)

infrahub/graphql/queries/resource_manager.py

@@ -306,7 +306,13 @@ async def resolve_number_pool_allocation(
 async def resolve_number_pool_utilization(
     db: InfrahubDatabase, pool: CoreNode, at: Timestamp | str | None, branch: Branch
 ) -> dict:
-    number_pool = NumberUtilizationGetter(db=db, pool=pool, at=at, branch=branch)
+    """
+    Returns a mapping containg utilization info of a number pool.
+    The utilization is calculated as the percentage of the total number of values in the pool that are not excluded for the corresponding attribute.
+    """
+
+    core_number_pool = await registry.manager.get_one_by_id_or_default_filter(db=db, id=pool.id, kind="CoreNumberPool")
+    number_pool = NumberUtilizationGetter(db=db, pool=core_number_pool, at=at, branch=branch)
     await number_pool.load_data()
 
     return {

infrahub/graphql/schema.py

@@ -16,6 +16,7 @@ from .mutations.branch import (
     BranchValidate,
 )
 from .mutations.computed_attribute import UpdateComputedAttribute
+from .mutations.convert_object_type import ConvertObjectType
 from .mutations.diff import DiffUpdateMutation
 from .mutations.diff_conflict import ResolveDiffConflict
 from .mutations.generator import GeneratorDefinitionRequestRun
@@ -48,6 +49,7 @@ from .queries import (
     InfrahubStatus,
     Relationship,
 )
+from .queries.convert_object_type_mapping import FieldsMappingTypeConversion
 from .queries.diff.tree import DiffTreeQuery, DiffTreeSummaryQuery
 from .queries.event import Event
 from .queries.task import Task, TaskBranchStatus
@@ -77,6 +79,8 @@ class InfrahubBaseQuery(ObjectType):
     InfrahubResourcePoolAllocated = InfrahubResourcePoolAllocated
     InfrahubResourcePoolUtilization = InfrahubResourcePoolUtilization
 
+    FieldsMappingTypeConversion = FieldsMappingTypeConversion
+
 
 class InfrahubBaseMutation(ObjectType):
     InfrahubAccountTokenCreate = InfrahubAccountTokenCreate.Field()
@@ -109,3 +113,5 @@ class InfrahubBaseMutation(ObjectType):
     SchemaEnumAdd = SchemaEnumAdd.Field()
     SchemaEnumRemove = SchemaEnumRemove.Field()
     ResolveDiffConflict = ResolveDiffConflict.Field()
+
+    ConvertObjectType = ConvertObjectType.Field()

infrahub/menu/menu.py

@@ -246,6 +246,37 @@ default_menu = [
                 section=MenuSection.INTERNAL,
                 order_weight=2000,
             ),
+            MenuItemDefinition(
+                namespace="Builtin",
+                name="TriggerDefinition",
+                label="Events",
+                icon=_extract_node_icon(infrahub_schema.get(InfrahubKind.TRIGGERRULE)),
+                protected=True,
+                section=MenuSection.INTERNAL,
+                order_weight=6000,
+                children=[
+                    MenuItemDefinition(
+                        namespace="Core",
+                        name="TriggerRule",
+                        label="Rules",
+                        kind=InfrahubKind.TRIGGERRULE,
+                        icon=_extract_node_icon(infrahub_schema.get(InfrahubKind.TRIGGERRULE)),
+                        protected=True,
+                        section=MenuSection.INTERNAL,
+                        order_weight=1000,
+                    ),
+                    MenuItemDefinition(
+                        namespace="Core",
+                        name="Action",
+                        label="Actions",
+                        kind=InfrahubKind.ACTION,
+                        icon=_extract_node_icon(infrahub_schema.get(InfrahubKind.ACTION)),
+                        protected=True,
+                        section=MenuSection.INTERNAL,
+                        order_weight=2000,
+                    ),
+                ],
+            ),
         ],
     ),
     MenuItemDefinition(

infrahub/message_bus/messages/__init__.py

@@ -1,28 +1,18 @@
 from infrahub.message_bus import InfrahubMessage, InfrahubResponse
 
-from .check_generator_run import CheckGeneratorRun
-from .finalize_validator_execution import FinalizeValidatorExecution
 from .git_file_get import GitFileGet, GitFileGetResponse
 from .git_repository_connectivity import GitRepositoryConnectivity
-from .proposed_change.request_proposedchange_refreshartifacts import RequestProposedChangeRefreshArtifacts
 from .refresh_git_fetch import RefreshGitFetch
 from .refresh_registry_branches import RefreshRegistryBranches
 from .refresh_registry_rebasedbranch import RefreshRegistryRebasedBranch
-from .request_generatordefinition_check import RequestGeneratorDefinitionCheck
-from .request_proposedchange_pipeline import RequestProposedChangePipeline
 from .send_echo_request import SendEchoRequest, SendEchoRequestResponse
 
 MESSAGE_MAP: dict[str, type[InfrahubMessage]] = {
-    "check.generator.run": CheckGeneratorRun,
-    "finalize.validator.execution": FinalizeValidatorExecution,
     "git.file.get": GitFileGet,
     "git.repository.connectivity": GitRepositoryConnectivity,
     "refresh.git.fetch": RefreshGitFetch,
     "refresh.registry.branches": RefreshRegistryBranches,
     "refresh.registry.rebased_branch": RefreshRegistryRebasedBranch,
-    "request.generator_definition.check": RequestGeneratorDefinitionCheck,
-    "request.proposed_change.pipeline": RequestProposedChangePipeline,
-    "request.proposed_change.refresh_artifacts": RequestProposedChangeRefreshArtifacts,
     "send.echo.request": SendEchoRequest,
 }
 

infrahub/message_bus/operations/__init__.py

@@ -3,11 +3,8 @@ from prefect import Flow
 
 from infrahub.message_bus import RPCErrorResponse, messages
 from infrahub.message_bus.operations import (
-    check,
-    finalize,
     git,
     refresh,
-    requests,
     send,
 )
 from infrahub.message_bus.types import MessageTTL
@@ -15,16 +12,11 @@ from infrahub.services import InfrahubServices
 from infrahub.tasks.check import set_check_status
 
 COMMAND_MAP = {
-    "check.generator.run": check.generator.run,
-    "finalize.validator.execution": finalize.validator.execution,
     "git.file.get": git.file.get,
     "git.repository.connectivity": git.repository.connectivity,
     "refresh.git.fetch": git.repository.fetch,
     "refresh.registry.branches": refresh.registry.branches,
     "refresh.registry.rebased_branch": refresh.registry.rebased_branch,
-    "request.generator_definition.check": requests.generator_definition.check,
-    "request.proposed_change.pipeline": requests.proposed_change.pipeline,
-    "request.proposed_change.refresh_artifacts": requests.proposed_change.refresh_artifacts,
     "send.echo.request": send.echo.request,
 }
 

infrahub/patch/queries/consolidate_duplicated_nodes.py

@@ -22,8 +22,7 @@ WITH n.uuid AS node_uuid, count(*) as num_nodes_with_uuid
 WHERE num_nodes_with_uuid > 1
 WITH DISTINCT node_uuid
 MATCH (n:Node {uuid: node_uuid})
-CALL {
-    WITH n
+CALL (n) {
     WITH labels(n) AS n_labels
     UNWIND n_labels AS n_label
     WITH n_label
@@ -37,8 +36,7 @@ UNWIND nodes_to_delete AS node_to_delete
 //------------
 // Find the edges that we need to move to the selected node_to_keep
 //------------
-CALL {
-    WITH node_to_keep, node_to_delete
+CALL (node_to_keep, node_to_delete) {
     MATCH (node_to_delete)-[edge_to_delete]->(peer)
     RETURN {
         from_id: %(id_func_name)s(node_to_keep),
@@ -60,8 +58,7 @@ WITH node_to_delete, collect(edge_to_create) AS edges_to_create
 //------------
 // Find the edges that we need to remove from the duplicated nodes
 //------------
-CALL {
-    WITH node_to_delete
+CALL (node_to_delete) {
     MATCH (node_to_delete)-[e]->(peer)
     RETURN {
         db_id: %(id_func_name)s(e),