infrahub-server 1.2.12__py3-none-any.whl → 1.3.0__py3-none-any.whl

infrahub/graphql/analyzer.py

@@ -13,11 +13,27 @@ from graphql import (
     FragmentSpreadNode,
     GraphQLSchema,
     InlineFragmentNode,
+    ListTypeNode,
     NamedTypeNode,
     NonNullTypeNode,
     OperationDefinitionNode,
     OperationType,
     SelectionSetNode,
+    TypeNode,
+)
+from graphql.language.ast import (
+    BooleanValueNode,
+    ConstListValueNode,
+    ConstObjectValueNode,
+    EnumValueNode,
+    FloatValueNode,
+    IntValueNode,
+    ListValueNode,
+    NullValueNode,
+    ObjectValueNode,
+    StringValueNode,
+    ValueNode,
+    VariableNode,
 )
 from infrahub_sdk.analyzer import GraphQLQueryAnalyzer
 from infrahub_sdk.utils import extract_fields
@@ -91,9 +107,24 @@ class GraphQLSelectionSet:
 @dataclass
 class GraphQLArgument:
     name: str
-    value: str
+    value: Any
     kind: str
 
+    @property
+    def is_variable(self) -> bool:
+        return self.kind == "variable"
+
+    @property
+    def as_variable_name(self) -> str:
+        """Return the name without a $ prefix"""
+        return str(self.value).removeprefix("$")
+
+    @property
+    def fields(self) -> list[str]:
+        if self.kind != "object_value" or not isinstance(self.value, dict):
+            return []
+        return sorted(self.value.keys())
+
 
 @dataclass
 class ObjectAccess:
@@ -106,6 +137,9 @@ class GraphQLVariable:
     name: str
     type: str
     required: bool
+    is_list: bool = False
+    inner_required: bool = False
+    default: Any | None = None
 
 
 @dataclass
@@ -266,6 +300,28 @@ class GraphQLQueryReport:
 
         return fields
 
+    @cached_property
+    def variables(self) -> list[GraphQLVariable]:
+        """Return input variables defined on the query document
+
+        All subqueries will use the same document level queries,
+        so only the first entry is required
+        """
+        if self.queries:
+            return self.queries[0].variables
+        return []
+
+    def required_argument(self, argument: GraphQLArgument) -> bool:
+        if not argument.is_variable:
+            # If the argument isn't a variable it would have been
+            # statically defined in the input and as such required
+            return True
+        for variable in self.variables:
+            if variable.name == argument.as_variable_name and variable.required:
+                return True
+
+        return False
+
     @cached_property
     def top_level_kinds(self) -> list[str]:
         return [query.infrahub_model.kind for query in self.queries if query.infrahub_model]
@@ -298,6 +354,22 @@ class GraphQLQueryReport:
 
         return access
 
+    @property
+    def only_has_unique_targets(self) -> bool:
+        """Indicate if the query document is defined so that it will return a single root level object"""
+        for query in self.queries:
+            targets_single_query = False
+            if query.infrahub_model and query.infrahub_model.uniqueness_constraints:
+                for argument in query.arguments:
+                    if [[argument.name]] == query.infrahub_model.uniqueness_constraints:
+                        if self.required_argument(argument=argument):
+                            targets_single_query = True
+
+            if not targets_single_query:
+                return False
+
+        return True
+
 
 class InfrahubGraphQLQueryAnalyzer(GraphQLQueryAnalyzer):
     def __init__(
@@ -603,31 +675,80 @@ class InfrahubGraphQLQueryAnalyzer(GraphQLQueryAnalyzer):
             ],
         )
 
-    @staticmethod
-    def _get_variables(operation: OperationDefinitionNode) -> list[GraphQLVariable]:
-        variables = []
-        for variable in operation.variable_definitions:
-            if isinstance(variable.type, NamedTypeNode):
-                variables.append(
-                    GraphQLVariable(name=variable.variable.name.value, type=variable.type.name.value, required=False)
+    def _get_variables(self, operation: OperationDefinitionNode) -> list[GraphQLVariable]:
+        variables: list[GraphQLVariable] = []
+
+        for variable in operation.variable_definitions or []:
+            type_node: TypeNode = variable.type
+            required = False
+            is_list = False
+            inner_required = False
+
+            if isinstance(type_node, NonNullTypeNode):
+                required = True
+                type_node = type_node.type
+
+            if isinstance(type_node, ListTypeNode):
+                is_list = True
+                inner_type = type_node.type
+
+                if isinstance(inner_type, NonNullTypeNode):
+                    inner_required = True
+                    inner_type = inner_type.type
+
+                if isinstance(inner_type, NamedTypeNode):
+                    type_name = inner_type.name.value
+                else:
+                    raise TypeError(f"Unsupported inner type node: {inner_type}")
+            elif isinstance(type_node, NamedTypeNode):
+                type_name = type_node.name.value
+            else:
+                raise TypeError(f"Unsupported type node: {type_node}")
+
+            variables.append(
+                GraphQLVariable(
+                    name=variable.variable.name.value,
+                    type=type_name,
+                    required=required,
+                    is_list=is_list,
+                    inner_required=inner_required,
+                    default=self._parse_value(variable.default_value) if variable.default_value else None,
                 )
-            elif isinstance(variable.type, NonNullTypeNode):
-                if isinstance(variable.type.type, NamedTypeNode):
-                    variables.append(
-                        GraphQLVariable(
-                            name=variable.variable.name.value, type=variable.type.type.name.value, required=True
-                        )
-                    )
+            )
 
         return variables
 
-    @staticmethod
-    def _parse_arguments(field_node: FieldNode) -> list[GraphQLArgument]:
+    def _parse_arguments(self, field_node: FieldNode) -> list[GraphQLArgument]:
         return [
             GraphQLArgument(
                 name=argument.name.value,
-                value=getattr(argument.value, "value", ""),
+                value=self._parse_value(argument.value),
                 kind=argument.value.kind,
             )
             for argument in field_node.arguments
         ]
+
+    def _parse_value(self, node: ValueNode) -> Any:
+        match node:
+            case VariableNode():
+                value: Any = f"${node.name.value}"
+            case IntValueNode():
+                value = int(node.value)
+            case FloatValueNode():
+                value = float(node.value)
+            case StringValueNode():
+                value = node.value
+            case BooleanValueNode():
+                value = node.value
+            case NullValueNode():
+                value = None
+            case EnumValueNode():
+                value = node.value
+            case ListValueNode() | ConstListValueNode():
+                value = [self._parse_value(item) for item in node.values]
+            case ObjectValueNode() | ConstObjectValueNode():
+                value = {field.name.value: self._parse_value(field.value) for field in node.fields}
+            case _:
+                raise TypeError(f"Unsupported value node: {node}")
+
+        return value

infrahub/graphql/manager.py

@@ -25,6 +25,7 @@ from infrahub.types import ATTRIBUTE_TYPES, InfrahubDataType, get_attribute_type
 from .directives import DIRECTIVES
 from .enums import generate_graphql_enum, get_enum_attribute_type_name
 from .metrics import SCHEMA_GENERATE_GRAPHQL_METRICS
+from .mutations.action import InfrahubTriggerRuleMatchMutation, InfrahubTriggerRuleMutation
 from .mutations.artifact_definition import InfrahubArtifactDefinitionMutation
 from .mutations.ipam import (
     InfrahubIPAddressMutation,
@@ -524,6 +525,9 @@ class GraphQLSchemaManager:
                 InfrahubKind.MENUITEM: InfrahubCoreMenuMutation,
                 InfrahubKind.STANDARDWEBHOOK: InfrahubWebhookMutation,
                 InfrahubKind.CUSTOMWEBHOOK: InfrahubWebhookMutation,
+                InfrahubKind.NODETRIGGERRULE: InfrahubTriggerRuleMutation,
+                InfrahubKind.NODETRIGGERATTRIBUTEMATCH: InfrahubTriggerRuleMatchMutation,
+                InfrahubKind.NODETRIGGERRELATIONSHIPMATCH: InfrahubTriggerRuleMatchMutation,
             }
 
             if isinstance(node_schema, NodeSchema) and node_schema.is_ip_prefix():

infrahub/graphql/mutations/action.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, cast
+
+from graphene import InputObjectType, Mutation
+from typing_extensions import Self
+
+from infrahub.core.protocols import CoreNodeTriggerAttributeMatch, CoreNodeTriggerRelationshipMatch, CoreNodeTriggerRule
+from infrahub.exceptions import SchemaNotFoundError, ValidationError
+from infrahub.log import get_logger
+
+from .main import InfrahubMutationMixin, InfrahubMutationOptions
+
+if TYPE_CHECKING:
+    from graphql import GraphQLResolveInfo
+
+    from infrahub.core.branch import Branch
+    from infrahub.core.node import Node
+    from infrahub.core.schema import NodeSchema
+    from infrahub.database import InfrahubDatabase
+
+    from ..initialization import GraphqlContext
+
+log = get_logger()
+
+
+class InfrahubTriggerRuleMutation(InfrahubMutationMixin, Mutation):
+    @classmethod
+    def __init_subclass_with_meta__(
+        cls,
+        schema: NodeSchema,
+        _meta: Any | None = None,
+        **options: dict[str, Any],
+    ) -> None:
+        if not _meta:
+            _meta = InfrahubMutationOptions(cls)
+
+        _meta.schema = schema
+
+        super().__init_subclass_with_meta__(_meta=_meta, **options)
+
+    @classmethod
+    async def mutate_create(
+        cls,
+        info: GraphQLResolveInfo,
+        data: InputObjectType,
+        branch: Branch,
+        database: InfrahubDatabase | None = None,
+    ) -> tuple[Node, Self]:
+        graphql_context: GraphqlContext = info.context
+        db = database or graphql_context.db
+        _validate_node_kind(data=data, db=db)
+        trigger_rule_definition, result = await super().mutate_create(info=info, data=data, branch=branch, database=db)
+
+        return trigger_rule_definition, result
+
+    @classmethod
+    async def mutate_update(
+        cls,
+        info: GraphQLResolveInfo,
+        data: InputObjectType,
+        branch: Branch,
+        database: InfrahubDatabase | None = None,
+        node: Node | None = None,  # noqa: ARG003
+    ) -> tuple[Node, Self]:
+        graphql_context: GraphqlContext = info.context
+        db = database or graphql_context.db
+        _validate_node_kind(data=data, db=db)
+        trigger_rule_definition, result = await super().mutate_update(info=info, data=data, branch=branch, database=db)
+
+        return trigger_rule_definition, result
+
+
+class InfrahubTriggerRuleMatchMutation(InfrahubMutationMixin, Mutation):
+    @classmethod
+    def __init_subclass_with_meta__(
+        cls,
+        schema: NodeSchema,
+        _meta: Any | None = None,
+        **options: dict[str, Any],
+    ) -> None:
+        if not _meta:
+            _meta = InfrahubMutationOptions(cls)
+
+        _meta.schema = schema
+
+        super().__init_subclass_with_meta__(_meta=_meta, **options)
+
+    @classmethod
+    async def mutate_create(
+        cls,
+        info: GraphQLResolveInfo,
+        data: InputObjectType,
+        branch: Branch,
+        database: InfrahubDatabase | None = None,  # noqa: ARG003
+    ) -> tuple[Node, Self]:
+        graphql_context: GraphqlContext = info.context
+
+        async with graphql_context.db.start_transaction() as dbt:
+            trigger_match, result = await super().mutate_create(info=info, data=data, branch=branch, database=dbt)
+            trigger_match_model = cast(CoreNodeTriggerAttributeMatch | CoreNodeTriggerRelationshipMatch, trigger_match)
+            node_trigger_rule = await trigger_match_model.trigger.get_peer(db=dbt, raise_on_error=True)
+            node_trigger_rule_model = cast(CoreNodeTriggerRule, node_trigger_rule)
+            node_schema = dbt.schema.get_node_schema(name=node_trigger_rule_model.node_kind.value, duplicate=False)
+            _validate_node_kind_field(data=data, node_schema=node_schema)
+
+        return trigger_match, result
+
+    @classmethod
+    async def mutate_update(
+        cls,
+        info: GraphQLResolveInfo,
+        data: InputObjectType,
+        branch: Branch,
+        database: InfrahubDatabase | None = None,  # noqa: ARG003
+        node: Node | None = None,  # noqa: ARG003
+    ) -> tuple[Node, Self]:
+        graphql_context: GraphqlContext = info.context
+        async with graphql_context.db.start_transaction() as dbt:
+            trigger_match, result = await super().mutate_update(info=info, data=data, branch=branch, database=dbt)
+            trigger_match_model = cast(CoreNodeTriggerAttributeMatch | CoreNodeTriggerRelationshipMatch, trigger_match)
+            node_trigger_rule = await trigger_match_model.trigger.get_peer(db=dbt, raise_on_error=True)
+            node_trigger_rule_model = cast(CoreNodeTriggerRule, node_trigger_rule)
+            node_schema = dbt.schema.get_node_schema(name=node_trigger_rule_model.node_kind.value, duplicate=False)
+            _validate_node_kind_field(data=data, node_schema=node_schema)
+
+        return trigger_match, result
+
+
+def _validate_node_kind(data: InputObjectType, db: InfrahubDatabase) -> None:
+    input_data = cast(dict[str, dict[str, Any]], data)
+    if node_kind := input_data.get("node_kind"):
+        value = node_kind.get("value")
+        if isinstance(value, str):
+            try:
+                db.schema.get_node_schema(name=value, duplicate=False)
+            except SchemaNotFoundError as exc:
+                raise ValidationError(
+                    input_value={"node_kind": "The requested node_kind schema was not found"}
+                ) from exc
+            except ValueError as exc:
+                raise ValidationError(input_value={"node_kind": "The requested node_kind is not a valid node"}) from exc
+
+
+def _validate_node_kind_field(data: InputObjectType, node_schema: NodeSchema) -> None:
+    input_data = cast(dict[str, dict[str, Any]], data)
+    if attribute_name := input_data.get("attribute_name"):
+        value = attribute_name.get("value")
+        if isinstance(value, str):
+            if value not in node_schema.attribute_names:
+                raise ValidationError(
+                    input_value={
+                        "attribute_name": f"The attribute {value} doesn't exist on related node trigger using {node_schema.kind}"
+                    }
+                )
+    if relationship_name := input_data.get("relationship_name"):
+        value = relationship_name.get("value")
+        if isinstance(value, str):
+            if value not in node_schema.relationship_names:
+                raise ValidationError(
+                    input_value={
+                        "relationship_name": f"The relationship {value} doesn't exist on related node trigger using {node_schema.kind}"
+                    }
+                )

infrahub/graphql/mutations/convert_object_type.py

@@ -0,0 +1,71 @@
+from typing import TYPE_CHECKING, Any, Self
+
+from graphene import Boolean, InputObjectType, Mutation, String
+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.convert_object_type.schema_mapping import get_schema_mapping
+from infrahub.core.manager import NodeManager
+
+if TYPE_CHECKING:
+    from infrahub.graphql.initialization import GraphqlContext
+
+
+class ConvertObjectTypeInput(InputObjectType):
+    node_id = String(required=True)
+    target_kind = String(required=True)
+    fields_mapping = GenericScalar(required=True)  # keys are destination attributes/relationships names.
+
+
+class ConvertObjectType(Mutation):
+    class Arguments:
+        data = ConvertObjectTypeInput(required=True)
+
+    ok = Boolean()
+    node = GenericScalar()
+
+    @classmethod
+    async def mutate(
+        cls,
+        root: dict,  # noqa: ARG003
+        info: GraphQLResolveInfo,
+        data: ConvertObjectTypeInput,
+    ) -> Self:
+        """Convert an input node to a given compatible kind."""
+
+        graphql_context: GraphqlContext = info.context
+
+        node_to_convert = await NodeManager.get_one(
+            id=str(data.node_id), db=graphql_context.db, branch=graphql_context.branch
+        )
+
+        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] = {}
+        if not isinstance(data.fields_mapping, dict):
+            raise ValueError(f"Expected `fields_mapping` to be a `dict`, got {type(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)
+
+        # 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,
+        )
+
+        dict_node = await new_node.to_graphql(db=graphql_context.db, fields={})
+        result: dict[str, Any] = {"ok": True, "node": dict_node}
+
+        return cls(**result)