infrahub-server 1.4.13__py3-none-any.whl → 1.5.0__py3-none-any.whl

infrahub/graphql/mutations/computed_attribute.py

@@ -2,20 +2,28 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
-from graphene import Boolean, InputObjectType, Mutation, String
+from graphene import Boolean, InputObjectType, List, Mutation, NonNull, String
 
 from infrahub.core.account import ObjectPermission
 from infrahub.core.constants import ComputedAttributeKind, PermissionAction, PermissionDecision
 from infrahub.core.manager import NodeManager
+from infrahub.core.protocols import CoreTransformPython
 from infrahub.core.registry import registry
 from infrahub.database import retry_db_transaction
 from infrahub.events import EventMeta
 from infrahub.events.node_action import NodeUpdatedEvent
-from infrahub.exceptions import NodeNotFoundError, ValidationError
+from infrahub.exceptions import NodeNotFoundError, ProcessingError, ValidationError
 from infrahub.graphql.context import apply_external_context
 from infrahub.graphql.types.context import ContextInput
 from infrahub.log import get_log_data
 from infrahub.worker import WORKER_IDENTITY
+from infrahub.workers.dependencies import get_workflow
+from infrahub.workflows.catalogue import (
+    COMPUTED_ATTRIBUTE_PROCESS_JINJA2,
+    COMPUTED_ATTRIBUTE_PROCESS_TRANSFORM,
+    TRIGGER_UPDATE_JINJA_COMPUTED_ATTRIBUTES,
+    TRIGGER_UPDATE_PYTHON_COMPUTED_ATTRIBUTES,
+)
 
 if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
@@ -89,7 +97,7 @@ class UpdateComputedAttribute(Mutation):
             raise NodeNotFoundError(
                 node_type="target_node",
                 identifier=str(data.id),
-                message="The indicated not does not have the specified attribute_name",
+                message="The indicated node does not have the specified attribute_name",
             )
         if attribute_field.value != str(data.value):
             attribute_field.value = str(data.value)
@@ -117,3 +125,102 @@ class UpdateComputedAttribute(Mutation):
         result: dict[str, Any] = {"ok": True}
 
         return cls(**result)
+
+
+class InfrahubComputedAttributeRecomputeInput(InputObjectType):
+    kind = String(required=True, description="Kind of the node to update")
+    attribute = String(required=True, description="Name of the computed attribute that must be recomputed")
+    node_ids = List(NonNull(String), description="ID of the nodes for which the attribute must be recomputed")
+
+
+class RecomputeComputedAttribute(Mutation):
+    class Arguments:
+        data = InfrahubComputedAttributeRecomputeInput(required=True)
+        context = ContextInput(required=False)
+
+    ok = Boolean()
+
+    @classmethod
+    @retry_db_transaction(name="update_computed_attribute")
+    async def mutate(
+        cls,
+        _: dict,
+        info: GraphQLResolveInfo,
+        data: InfrahubComputedAttributeRecomputeInput,
+        context: ContextInput | None = None,
+    ) -> RecomputeComputedAttribute:
+        graphql_context: GraphqlContext = info.context
+        node_schema = registry.schema.get_node_schema(
+            name=str(data.kind), branch=graphql_context.branch.name, duplicate=False
+        )
+
+        graphql_context.active_permissions.raise_for_permission(
+            permission=ObjectPermission(
+                namespace=node_schema.namespace,
+                name=node_schema.name,
+                action=PermissionAction.UPDATE.value,
+                decision=PermissionDecision.ALLOW_DEFAULT.value
+                if graphql_context.branch.name == registry.default_branch
+                else PermissionDecision.ALLOW_OTHER.value,
+            )
+        )
+        await apply_external_context(graphql_context=graphql_context, context_input=context)
+
+        attribute = node_schema.get_attribute(name=str(data.attribute))
+
+        if not attribute:
+            raise ProcessingError(
+                message=f"The indicated node does not have the specified attribute '{data.attribute}'"
+            )
+        if not attribute.computed_attribute:
+            raise ProcessingError(
+                message=f"The indicated node does not use a computed attribute for the specified attribute '{data.attribute}'"
+            )
+
+        recalculate_single_workflow = COMPUTED_ATTRIBUTE_PROCESS_JINJA2
+        recalculate_all_workflow = TRIGGER_UPDATE_JINJA_COMPUTED_ATTRIBUTES
+        if attribute.computed_attribute.kind == ComputedAttributeKind.TRANSFORM_PYTHON:
+            if not await NodeManager.query(
+                db=graphql_context.db,
+                branch=graphql_context.branch,
+                schema=CoreTransformPython,
+                filters={"name__value": attribute.computed_attribute.transform},
+            ):
+                raise ProcessingError(
+                    message=f"The transform for the indicated node computed attribute for the specified attribute '{data.attribute}' does not exist"
+                )
+
+            recalculate_single_workflow = COMPUTED_ATTRIBUTE_PROCESS_TRANSFORM
+            recalculate_all_workflow = TRIGGER_UPDATE_PYTHON_COMPUTED_ATTRIBUTES
+
+        if data.node_ids:
+            nodes = await NodeManager.get_many(
+                db=graphql_context.db, branch=graphql_context.branch, ids=list(data.node_ids)
+            )
+            for node in nodes.values():
+                await get_workflow().submit_workflow(
+                    workflow=recalculate_single_workflow,
+                    context=graphql_context.get_context(),
+                    parameters={
+                        "branch_name": graphql_context.branch.name,
+                        "computed_attribute_name": str(data.attribute),
+                        "computed_attribute_kind": node_schema.kind,
+                        "node_kind": node_schema.kind,
+                        "object_id": node.id,
+                        "context": context,
+                    },
+                )
+        else:
+            await get_workflow().submit_workflow(
+                workflow=recalculate_all_workflow,
+                context=graphql_context.get_context(),
+                parameters={
+                    "branch_name": graphql_context.branch.name,
+                    "computed_attribute_name": str(data.attribute),
+                    "computed_attribute_kind": node_schema.kind,
+                    "context": context,
+                },
+            )
+
+        result: dict[str, Any] = {"ok": True}
+        return cls(**result)

infrahub/graphql/mutations/convert_object_type.py

@@ -5,11 +5,16 @@ from graphene.types.generic import GenericScalar
 from graphql import GraphQLResolveInfo
 
 from infrahub.core import registry
-from infrahub.core.convert_object_type.conversion import InputForDestField, convert_object_type
+from infrahub.core.constants.infrahubkind import READONLYREPOSITORY, REPOSITORY
+from infrahub.core.convert_object_type.object_conversion import ConversionFieldInput, convert_and_validate_object_type
+from infrahub.core.convert_object_type.repository_conversion import convert_repository_type
 from infrahub.core.convert_object_type.schema_mapping import get_schema_mapping
 from infrahub.core.manager import NodeManager
+from infrahub.exceptions import ValidationError
+from infrahub.repositories.create_repository import RepositoryFinalizer
 
 if TYPE_CHECKING:
+    from infrahub.core.attribute import BaseAttribute
     from infrahub.graphql.initialization import GraphqlContext
 
 
@@ -44,26 +49,52 @@ class ConvertObjectType(Mutation):
         source_schema = registry.get_node_schema(name=node_to_convert.get_kind(), branch=graphql_context.branch)
         target_schema = registry.get_node_schema(name=str(data.target_kind), branch=graphql_context.branch)
 
-        fields_mapping: dict[str, InputForDestField] = {}
+        fields_mapping: dict[str, ConversionFieldInput] = {}
         if not isinstance(data.fields_mapping, dict):
-            raise ValueError(f"Expected `fields_mapping` to be a `dict`, got {type(fields_mapping)}")
+            raise ValidationError(
+                input_value=f"Expected `fields_mapping` to be a `dict`, got {type(data.fields_mapping)}"
+            )
 
         for field_name, input_for_dest_field_str in data.fields_mapping.items():
-            fields_mapping[field_name] = InputForDestField(**input_for_dest_field_str)
+            fields_mapping[field_name] = ConversionFieldInput(**input_for_dest_field_str)
+
+        node_to_convert = await NodeManager.get_one(
+            id=str(data.node_id), db=graphql_context.db, branch=graphql_context.branch
+        )
+        for attribute_name in source_schema.attribute_names:
+            attribute: BaseAttribute = getattr(node_to_convert, attribute_name)
+            if attribute.is_from_profile:
+                raise ValidationError(
+                    input_value=f"The attribute '{attribute_name}' is from a profile, converting objects that use profiles is not yet supported."
+                )
 
         # Complete fields mapping with auto-mapping.
         mapping = get_schema_mapping(source_schema=source_schema, target_schema=target_schema)
         for field_name, mapping_value in mapping.items():
             if mapping_value.source_field_name is not None and field_name not in fields_mapping:
-                fields_mapping[field_name] = InputForDestField(source_field=mapping_value.source_field_name)
-
-        new_node = await convert_object_type(
-            node=node_to_convert,
-            target_schema=target_schema,
-            mapping=fields_mapping,
-            branch=graphql_context.branch,
-            db=graphql_context.db,
-        )
+                fields_mapping[field_name] = ConversionFieldInput(source_field=mapping_value.source_field_name)
+
+        if target_schema.kind in [REPOSITORY, READONLYREPOSITORY]:
+            new_node = await convert_repository_type(
+                repository=node_to_convert,
+                target_schema=target_schema,
+                mapping=fields_mapping,
+                branch=graphql_context.branch,
+                db=graphql_context.db,
+                repository_post_creator=RepositoryFinalizer(
+                    account_session=graphql_context.active_account_session,
+                    services=graphql_context.active_service,
+                    context=graphql_context.get_context(),
+                ),
+            )
+        else:
+            new_node = await convert_and_validate_object_type(
+                node=node_to_convert,
+                target_schema=target_schema,
+                mapping=fields_mapping,
+                branch=graphql_context.branch,
+                db=graphql_context.db,
+            )
 
         dict_node = await new_node.to_graphql(db=graphql_context.db, fields={})
         result: dict[str, Any] = {"ok": True, "node": dict_node}

infrahub/graphql/mutations/display_label.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from graphene import Boolean, InputObjectType, Mutation, String
+
+from infrahub.core.account import ObjectPermission
+from infrahub.core.constants import GlobalPermissions, PermissionAction, PermissionDecision
+from infrahub.core.manager import NodeManager
+from infrahub.core.registry import registry
+from infrahub.database import retry_db_transaction
+from infrahub.events import EventMeta
+from infrahub.events.node_action import NodeUpdatedEvent
+from infrahub.exceptions import NodeNotFoundError, ValidationError
+from infrahub.graphql.context import apply_external_context
+from infrahub.graphql.types.context import ContextInput
+from infrahub.log import get_log_data
+from infrahub.permissions import define_global_permission_from_branch
+from infrahub.worker import WORKER_IDENTITY
+
+if TYPE_CHECKING:
+    from graphql import GraphQLResolveInfo
+
+    from infrahub.graphql.initialization import GraphqlContext
+
+
+class InfrahubDisplayLabelUpdateInput(InputObjectType):
+    id = String(required=True)
+    kind = String(required=True)
+    value = String(required=True)
+
+
+class UpdateDisplayLabel(Mutation):
+    class Arguments:
+        data = InfrahubDisplayLabelUpdateInput(required=True)
+        context = ContextInput(required=False)
+
+    ok = Boolean()
+
+    @classmethod
+    @retry_db_transaction(name="update_display_label")
+    async def mutate(
+        cls,
+        _: dict,
+        info: GraphQLResolveInfo,
+        data: InfrahubDisplayLabelUpdateInput,
+        context: ContextInput | None = None,
+    ) -> UpdateDisplayLabel:
+        graphql_context: GraphqlContext = info.context
+        node_schema = registry.schema.get_node_schema(
+            name=str(data.kind), branch=graphql_context.branch.name, duplicate=False
+        )
+        if not node_schema.display_label:
+            raise ValidationError(input_value=f"{node_schema.kind}.display_label has not been defined for this kind.")
+
+        graphql_context.active_permissions.raise_for_permissions(
+            permissions=[
+                define_global_permission_from_branch(
+                    permission=GlobalPermissions.UPDATE_OBJECT_HFID_DISPLAY_LABEL,
+                    branch_name=graphql_context.branch.name,
+                ),
+                ObjectPermission(
+                    namespace=node_schema.namespace,
+                    name=node_schema.name,
+                    action=PermissionAction.UPDATE.value,
+                    decision=PermissionDecision.ALLOW_DEFAULT.value
+                    if graphql_context.branch.name == registry.default_branch
+                    else PermissionDecision.ALLOW_OTHER.value,
+                ),
+            ]
+        )
+        await apply_external_context(graphql_context=graphql_context, context_input=context)
+
+        if not (
+            target_node := await NodeManager.get_one(
+                db=graphql_context.db,
+                kind=node_schema.kind,
+                id=str(data.id),
+                branch=graphql_context.branch,
+                fields={"display_label": None},
+            )
+        ):
+            raise NodeNotFoundError(
+                node_type=node_schema.kind,
+                identifier=str(data.id),
+                message="The targeted node was not found in the database",
+            )
+
+        existing_label = (
+            await target_node.get_display_label(db=graphql_context.db) if target_node.has_display_label() else None
+        )
+        if str(data.value) != existing_label:
+            await target_node.set_display_label(value=str(data.value))
+
+            async with graphql_context.db.start_transaction() as dbt:
+                await target_node.save(db=dbt, fields=["display_label"])
+
+            log_data = get_log_data()
+            request_id = log_data.get("request_id", "")
+
+            event = NodeUpdatedEvent(
+                kind=node_schema.kind,
+                node_id=target_node.get_id(),
+                changelog=target_node.node_changelog.model_dump(),
+                fields=["display_label"],
+                meta=EventMeta(
+                    context=graphql_context.get_context(),
+                    initiator_id=WORKER_IDENTITY,
+                    request_id=request_id,
+                    account_id=graphql_context.active_account_session.account_id,
+                    branch=graphql_context.branch,
+                ),
+            )
+            await graphql_context.active_service.event.send(event=event)
+
+        result: dict[str, Any] = {"ok": True}
+
+        return cls(**result)

infrahub/graphql/mutations/generator.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING
 from graphene import Boolean, Field, InputField, InputObjectType, List, Mutation, NonNull, String
 
 from infrahub.core.manager import NodeManager
+from infrahub.core.protocols import CoreGeneratorDefinition, CoreGenericRepository, CoreGraphQLQuery, CoreStandardGroup
 from infrahub.generators.models import ProposedChangeGeneratorDefinition, RequestGeneratorDefinitionRun
 from infrahub.graphql.context import apply_external_context
 from infrahub.graphql.types.context import ContextInput
@@ -44,11 +45,18 @@ class GeneratorDefinitionRequestRun(Mutation):
         db = graphql_context.db
         await apply_external_context(graphql_context=graphql_context, context_input=context)
         generator_definition = await NodeManager.get_one(
-            id=str(data.id), db=db, branch=graphql_context.branch, prefetch_relationships=True, raise_on_error=True
+            id=str(data.id),
+            kind=CoreGeneratorDefinition,
+            db=db,
+            branch=graphql_context.branch,
+            prefetch_relationships=True,
+            raise_on_error=True,
         )
-        query = await generator_definition.query.get_peer(db=db)
-        repository = await generator_definition.repository.get_peer(db=db)
-        group = await generator_definition.targets.get_peer(db=db)
+        query = await generator_definition.query.get_peer(db=db, peer_type=CoreGraphQLQuery, raise_on_error=True)
+        repository = await generator_definition.repository.get_peer(
+            db=db, peer_type=CoreGenericRepository, raise_on_error=True
+        )
+        group = await generator_definition.targets.get_peer(db=db, peer_type=CoreStandardGroup, raise_on_error=True)
 
         request_model = RequestGeneratorDefinitionRun(
             generator_definition=ProposedChangeGeneratorDefinition(
@@ -57,11 +65,21 @@ class GeneratorDefinitionRequestRun(Mutation):
                 class_name=generator_definition.class_name.value,
                 file_path=generator_definition.file_path.value,
                 query_name=query.name.value,
-                query_models=query.models.value,
+                query_models=query.models.value or [],
                 repository_id=repository.id,
-                parameters=generator_definition.parameters.value,
+                parameters=generator_definition.parameters.value
+                if isinstance(generator_definition.parameters.value, dict)
+                else {},
                 group_id=group.id,
-                convert_query_response=generator_definition.convert_query_response.value or False,
+                convert_query_response=generator_definition.convert_query_response.value
+                if generator_definition.convert_query_response.value is not None
+                else False,
+                execute_in_proposed_change=generator_definition.execute_in_proposed_change.value
+                if generator_definition.execute_in_proposed_change.value is not None
+                else True,
+                execute_after_merge=generator_definition.execute_after_merge.value
+                if generator_definition.execute_after_merge.value is not None
+                else True,
             ),
             branch=graphql_context.branch.name,
             target_members=data.get("nodes", []),

infrahub/graphql/mutations/hfid.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, cast
+
+from graphene import Boolean, InputObjectType, List, Mutation, NonNull, String
+
+from infrahub.core.account import ObjectPermission
+from infrahub.core.constants import GlobalPermissions, PermissionAction, PermissionDecision
+from infrahub.core.manager import NodeManager
+from infrahub.core.registry import registry
+from infrahub.database import retry_db_transaction
+from infrahub.events import EventMeta
+from infrahub.events.node_action import NodeUpdatedEvent
+from infrahub.exceptions import NodeNotFoundError, ValidationError
+from infrahub.graphql.context import apply_external_context
+from infrahub.graphql.types.context import ContextInput
+from infrahub.log import get_log_data
+from infrahub.permissions import define_global_permission_from_branch
+from infrahub.worker import WORKER_IDENTITY
+
+if TYPE_CHECKING:
+    from graphql import GraphQLResolveInfo
+
+    from infrahub.graphql.initialization import GraphqlContext
+
+
+class InfrahubHFIDUpdateInput(InputObjectType):
+    id = String(required=True)
+    kind = String(required=True)
+    value = List(NonNull(String), required=True)
+
+
+class UpdateHFID(Mutation):
+    class Arguments:
+        data = InfrahubHFIDUpdateInput(required=True)
+        context = ContextInput(required=False)
+
+    ok = Boolean()
+
+    @classmethod
+    @retry_db_transaction(name="update_hfid")
+    async def mutate(
+        cls,
+        _: dict,
+        info: GraphQLResolveInfo,
+        data: InfrahubHFIDUpdateInput,
+        context: ContextInput | None = None,
+    ) -> UpdateHFID:
+        graphql_context: GraphqlContext = info.context
+        node_schema = registry.schema.get_node_schema(
+            name=str(data.kind), branch=graphql_context.branch.name, duplicate=False
+        )
+        if node_schema.human_friendly_id is None:
+            raise ValidationError(
+                input_value=f"{node_schema.kind}.human_friendly_id has not been defined for this kind."
+            )
+
+        updated_hfid = cast(list[str], data.value)
+
+        if len(node_schema.human_friendly_id) != len(updated_hfid):
+            raise ValidationError(
+                input_value=f"{node_schema.kind}.human_friendly_id requires {len(node_schema.human_friendly_id)} parts data has {len(updated_hfid)}"
+            )
+
+        graphql_context.active_permissions.raise_for_permissions(
+            permissions=[
+                define_global_permission_from_branch(
+                    permission=GlobalPermissions.UPDATE_OBJECT_HFID_DISPLAY_LABEL,
+                    branch_name=graphql_context.branch.name,
+                ),
+                ObjectPermission(
+                    namespace=node_schema.namespace,
+                    name=node_schema.name,
+                    action=PermissionAction.UPDATE.value,
+                    decision=PermissionDecision.ALLOW_DEFAULT.value
+                    if graphql_context.branch.name == registry.default_branch
+                    else PermissionDecision.ALLOW_OTHER.value,
+                ),
+            ]
+        )
+        await apply_external_context(graphql_context=graphql_context, context_input=context)
+
+        if not (
+            target_node := await NodeManager.get_one(
+                db=graphql_context.db,
+                kind=node_schema.kind,
+                id=str(data.id),
+                branch=graphql_context.branch,
+                fields={"human_friendly_id": None},
+            )
+        ):
+            raise NodeNotFoundError(
+                node_type=node_schema.kind,
+                identifier=str(data.id),
+                message="The targeted node was not found in the database",
+            )
+
+        existing = await target_node.get_hfid(db=graphql_context.db) if target_node.has_human_friendly_id() else None
+        if updated_hfid != existing:
+            await target_node.set_human_friendly_id(value=updated_hfid)
+
+            async with graphql_context.db.start_transaction() as dbt:
+                await target_node.save(db=dbt, fields=["human_friendly_id"])
+
+            log_data = get_log_data()
+            request_id = log_data.get("request_id", "")
+
+            event = NodeUpdatedEvent(
+                kind=node_schema.kind,
+                node_id=target_node.get_id(),
+                changelog=target_node.node_changelog.model_dump(),
+                fields=["human_friendly_id"],
+                meta=EventMeta(
+                    context=graphql_context.get_context(),
+                    initiator_id=WORKER_IDENTITY,
+                    request_id=request_id,
+                    account_id=graphql_context.active_account_session.account_id,
+                    branch=graphql_context.branch,
+                ),
+            )
+            await graphql_context.active_service.event.send(event=event)
+
+        result: dict[str, Any] = {"ok": True}
+
+        return cls(**result)