infrahub-server 1.2.10__py3-none-any.whl → 1.3.0a0__py3-none-any.whl

infrahub/core/validators/determiner.py

@@ -1,14 +1,20 @@
+from typing import TYPE_CHECKING, Any
+
 from infrahub.core.constants import RelationshipKind, SchemaPathType
 from infrahub.core.constants.schema import UpdateSupport
 from infrahub.core.diff.model.path import NodeDiffFieldSummary
 from infrahub.core.models import SchemaUpdateConstraintInfo
 from infrahub.core.path import SchemaPath
 from infrahub.core.schema import AttributeSchema, MainSchemaTypes
+from infrahub.core.schema.attribute_parameters import AttributeParameters
 from infrahub.core.schema.relationship_schema import RelationshipSchema
 from infrahub.core.schema.schema_branch import SchemaBranch
 from infrahub.core.validators import CONSTRAINT_VALIDATOR_MAP
 from infrahub.log import get_logger
 
+if TYPE_CHECKING:
+    from pydantic.fields import FieldInfo
+
 LOG = get_logger(__name__)
 
 
@@ -133,7 +139,17 @@ class ConstraintValidatorDeterminer:
         self, schema: MainSchemaTypes, field: AttributeSchema | RelationshipSchema
     ) -> list[SchemaUpdateConstraintInfo]:
         constraints: list[SchemaUpdateConstraintInfo] = []
-        for prop_name, prop_field_info in field.model_fields.items():
+        prop_details_list: list[tuple[str, FieldInfo, Any]] = []
+        for p_name, p_info in field.model_fields.items():
+            p_value = getattr(field, p_name)
+            if isinstance(p_value, AttributeParameters):
+                for parameter_name, parameter_field_info in p_value.model_fields.items():
+                    parameter_value = getattr(p_value, parameter_name)
+                    prop_details_list.append((f"{p_name}.{parameter_name}", parameter_field_info, parameter_value))
+            else:
+                prop_details_list.append((p_name, p_info, p_value))
+
+        for prop_name, prop_field_info, prop_value in prop_details_list:
             if not prop_field_info.json_schema_extra or not isinstance(prop_field_info.json_schema_extra, dict):
                 continue
 
@@ -141,7 +157,7 @@ class ConstraintValidatorDeterminer:
             if prop_field_update != UpdateSupport.VALIDATE_CONSTRAINT.value:
                 continue
 
-            if getattr(field, prop_name) is None:
+            if prop_value is None:
                 continue
 
             path_type = SchemaPathType.ATTRIBUTE

infrahub/core/validators/enum.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class ConstraintIdentifier(str, Enum):
+    ATTRIBUTE_PARAMETERS_REGEX_UPDATE = "attribute.parameters.regex.update"
+    ATTRIBUTE_PARAMETERS_MIN_LENGTH_UPDATE = "attribute.parameters.min_length.update"
+    ATTRIBUTE_PARAMETERS_MAX_LENGTH_UPDATE = "attribute.parameters.max_length.update"

infrahub/core/validators/node/hierarchy.py

@@ -59,8 +59,7 @@ class NodeHierarchyUpdateValidatorQuery(SchemaValidatorQuery):
         # ruff: noqa: E501
         query = """
         MATCH (n:%(node_kind)s)
-        CALL {
-            WITH n
+        CALL (n) {
             MATCH path = (root:Root)<-[rroot:IS_PART_OF]-(n)
             WHERE all(r in relationships(path) WHERE %(branch_filter)s)
             RETURN path as full_path, n as active_node
@@ -70,8 +69,7 @@ class NodeHierarchyUpdateValidatorQuery(SchemaValidatorQuery):
         WITH full_path, active_node
         WITH full_path, active_node
         WHERE all(r in relationships(full_path) WHERE r.status = "active")
-        CALL {
-            WITH active_node
+        CALL (active_node) {
             MATCH path = (active_node)%(to_children)s-[hrel1:IS_RELATED]-%(to_parent)s(:Relationship {name: "parent__child"})%(to_children)s-[hrel2:IS_RELATED]-%(to_parent)s(peer:Node)
             WHERE all(
                 r in relationships(path)
@@ -91,8 +89,7 @@ class NodeHierarchyUpdateValidatorQuery(SchemaValidatorQuery):
             collect([branch_level_sum, from_times, active_relationship_count, hierarchy_path, deepest_branch_name]) as enriched_paths,
             start_node,
             peer_node
-        CALL {
-            WITH enriched_paths, peer_node
+        CALL (enriched_paths, peer_node) {
             UNWIND enriched_paths as path_to_check
             RETURN path_to_check[3] as current_path, path_to_check[4] as branch_name, peer_node as current_peer
             ORDER BY

infrahub/core/validators/query.py

@@ -20,8 +20,7 @@ class NodeNotPresentValidatorQuery(SchemaValidatorQuery):
 
         query = """
         MATCH (n:%(node_kind)s)
-        CALL {
-            WITH n
+        CALL (n) {
             MATCH path = (root:Root)<-[rr:IS_PART_OF]-(n)
             WHERE all(
                 r in relationships(path)
@@ -32,7 +31,6 @@ class NodeNotPresentValidatorQuery(SchemaValidatorQuery):
             LIMIT 1
         }
         WITH full_path, node, root_relationship
-        WITH full_path, node, root_relationship
         WHERE all(r in relationships(full_path) WHERE r.status = "active")
         """ % {"branch_filter": branch_filter, "node_kind": self.node_schema.kind}
 

infrahub/core/validators/relationship/count.py

@@ -50,8 +50,7 @@ class RelationshipCountUpdateValidatorQuery(RelationshipSchemaValidatorQuery):
         query = """
         // get the nodes on these branches nodes
         MATCH (n:%(node_kind)s)
-        CALL {
-            WITH n
+        CALL (n) {
             MATCH path = (root:Root)<-[rroot:IS_PART_OF]-(n)
             WHERE all(r in relationships(path) WHERE %(branch_filter)s)
             RETURN path as full_path, n as active_node
@@ -60,11 +59,9 @@ class RelationshipCountUpdateValidatorQuery(RelationshipSchemaValidatorQuery):
         }
         // filter to only the active nodes
         WITH full_path, active_node
-        WITH full_path, active_node
         WHERE all(r in relationships(full_path) WHERE r.status = "active")
         // get the relationships using the given identifier for each node
-        CALL {
-            WITH active_node
+        CALL (active_node) {
             MATCH path = (active_node)-[rrel1:IS_RELATED]-(rel:Relationship { name: $relationship_id })-[rrel2:IS_RELATED]-(peer:Node)
             WHERE ($relationship_direction <> "outbound" OR (startNode(rrel1) = active_node AND startNode(rrel2) = rel))
             AND ($relationship_direction <> "inbound" OR (startNode(rrel1) = rel AND startNode(rrel2) = peer))
@@ -87,8 +84,7 @@ class RelationshipCountUpdateValidatorQuery(RelationshipSchemaValidatorQuery):
             start_node,
             peer_node
         // make sure to only use the latest version of this particular path
-        CALL {
-            WITH enriched_paths, peer_node
+        CALL (enriched_paths, peer_node) {
             UNWIND enriched_paths as path_to_check
             RETURN path_to_check[3] as current_path, path_to_check[4] as branch_name, peer_node as current_peer
             ORDER BY
@@ -100,8 +96,7 @@ class RelationshipCountUpdateValidatorQuery(RelationshipSchemaValidatorQuery):
         }
         // filter to only the current active paths
         WITH collect([current_peer, current_path]) as peers_and_paths, start_node, branch_name
-        CALL {
-            WITH peers_and_paths
+        CALL (peers_and_paths) {
             UNWIND peers_and_paths AS peer_and_path
             WITH peer_and_path
             WHERE all(r in relationships(peer_and_path[1]) WHERE r.status = "active")
@@ -109,9 +104,8 @@ class RelationshipCountUpdateValidatorQuery(RelationshipSchemaValidatorQuery):
         }
         // sum all the relationships across branches and identify the violators
         WITH collect([branch_name, num_relationships_on_branch]) as branches_and_counts, start_node
-        CALL {
-            WITH start_node, branches_and_counts
-            WITH start_node, branches_and_counts, reduce(rel_total = 0, bnc in branches_and_counts | rel_total + bnc[1]) AS total_relationships_count
+        CALL (start_node, branches_and_counts) {
+            WITH reduce(rel_total = 0, bnc in branches_and_counts | rel_total + bnc[1]) AS total_relationships_count
             WHERE
                 (toInteger($min_count) IS NOT NULL AND total_relationships_count < toInteger($min_count))
                 OR (toInteger($max_count) IS NOT NULL AND total_relationships_count > toInteger($max_count))

infrahub/core/validators/relationship/optional.py

@@ -30,8 +30,7 @@ class RelationshipOptionalUpdateValidatorQuery(RelationshipSchemaValidatorQuery)
         // Query all Active Nodes of type
         // and store their UUID in uuids_active_node
         MATCH (n:%(node_kind)s)
-        CALL {
-            WITH n
+        CALL (n) {
             MATCH (root:Root)<-[r:IS_PART_OF]-(n)
             WHERE %(branch_filter)s
             RETURN n as n1, r as r1
@@ -44,8 +43,7 @@ class RelationshipOptionalUpdateValidatorQuery(RelationshipSchemaValidatorQuery)
         // identifier all nodes with at least one active member for this relationship
         // and store their UUID in uuids_with_rel
         MATCH (n:%(node_kind)s)
-        CALL {
-            WITH n, uuids_active_node
+        CALL (n, uuids_active_node) {
             MATCH path = (n)-[r:IS_RELATED]-(:Relationship { name: $relationship_id })
             WHERE %(branch_filter)s
             RETURN n as n1, r as r1

infrahub/core/validators/relationship/peer.py

@@ -36,8 +36,7 @@ class RelationshipPeerUpdateValidatorQuery(RelationshipSchemaValidatorQuery):
         # ruff: noqa: E501
         query = """
         MATCH (n:%(node_kind)s)
-        CALL {
-            WITH n
+        CALL (n) {
             MATCH path = (root:Root)<-[rroot:IS_PART_OF]-(n)
             WHERE all(r in relationships(path) WHERE %(branch_filter)s)
             RETURN path as full_path, n as active_node
@@ -45,10 +44,8 @@ class RelationshipPeerUpdateValidatorQuery(RelationshipSchemaValidatorQuery):
             LIMIT 1
         }
         WITH full_path, active_node
-        WITH full_path, active_node
         WHERE all(r in relationships(full_path) WHERE r.status = "active")
-        CALL {
-            WITH active_node
+        CALL (active_node) {
             MATCH path = (active_node)-[rrel1:IS_RELATED]-(rel:Relationship { name: $relationship_id })-[rrel2:IS_RELATED]-(peer:Node)
             WHERE all(
                 r in relationships(path)
@@ -68,8 +65,7 @@ class RelationshipPeerUpdateValidatorQuery(RelationshipSchemaValidatorQuery):
             collect([branch_level_sum, from_times, active_relationship_count, relationship_path, deepest_branch_name]) as enriched_paths,
             start_node,
             peer_node
-        CALL {
-            WITH enriched_paths, peer_node
+        CALL (enriched_paths, peer_node) {
             UNWIND enriched_paths as path_to_check
             RETURN path_to_check[3] as current_path, path_to_check[4] as branch_name, peer_node as current_peer
             ORDER BY
@@ -80,7 +76,6 @@ class RelationshipPeerUpdateValidatorQuery(RelationshipSchemaValidatorQuery):
             LIMIT 1
         }
         WITH start_node, current_peer, branch_name, current_path
-        WITH start_node, current_peer, branch_name, current_path
         WHERE all(r in relationships(current_path) WHERE r.status = "active")
         AND NOT any(label IN LABELS(current_peer) WHERE label IN $allowed_peer_kinds)
         """ % {"branch_filter": branch_filter, "node_kind": self.node_schema.kind}

infrahub/core/validators/tasks.py

@@ -71,7 +71,7 @@ async def schema_path_validate(
     schema_branch: SchemaBranch,
     service: InfrahubServices,
 ) -> SchemaValidatorPathResponseData:
-    async with service.database.start_session() as db:
+    async with service.database.start_session(read_only=True) as db:
         constraint_request = SchemaConstraintValidatorRequest(
             branch=branch,
             constraint_name=constraint_name,

infrahub/core/validators/uniqueness/query.py

@@ -158,12 +158,11 @@ class NodeUniqueAttributeConstraintQuery(Query):
         # ruff: noqa: E501
         query = """
         // get attributes for node and its relationships
-        CALL {
+        CALL () {
             %(select_subqueries_str)s
         }
-        CALL {
+        CALL (potential_path) {
             WITH potential_path
-            WITH potential_path  // workaround for neo4j not allowing WHERE in a WITH of a subquery
             // only the branches and times we care about
             WHERE all(
                 r IN relationships(potential_path) WHERE (
@@ -183,8 +182,7 @@ class NodeUniqueAttributeConstraintQuery(Query):
             start_node,
             rel_identifier,
             potential_attr
-        CALL {
-            WITH enriched_paths
+        CALL (enriched_paths) {
             UNWIND enriched_paths as path_to_check
             RETURN path_to_check[0] as current_path, path_to_check[4] as latest_value
             ORDER BY
@@ -194,16 +192,14 @@ class NodeUniqueAttributeConstraintQuery(Query):
                 path_to_check[3] DESC
             LIMIT 1
         }
-        CALL {
+        CALL (current_path) {
             // only active paths
             WITH current_path
-            WITH current_path  // workaround for neo4j not allowing WHERE in a WITH of a subquery
             WHERE all(r IN relationships(current_path) WHERE r.status = "active")
             RETURN current_path as active_path
         }
-        CALL {
+        CALL (active_path) {
             // get deepest branch name
-            WITH active_path
             UNWIND %(branch_name_and_level)s as branch_name_and_level
             RETURN branch_name_and_level[0] as branch_name
             ORDER BY branch_name_and_level[1] DESC

infrahub/database/__init__.py

@@ -476,8 +476,6 @@ async def validate_database(
 
 
 async def get_db(retry: int = 0) -> AsyncDriver:
-    URI = f"{config.SETTINGS.database.protocol}://{config.SETTINGS.database.address}:{config.SETTINGS.database.port}"
-
     trusted_certificates = TrustSystemCAs()
     if config.SETTINGS.database.tls_insecure:
         trusted_certificates = TrustAll()
@@ -485,7 +483,7 @@ async def get_db(retry: int = 0) -> AsyncDriver:
         trusted_certificates = TrustCustomCAs(config.SETTINGS.database.tls_ca_file)
 
     driver = AsyncGraphDatabase.driver(
-        URI,
+        config.SETTINGS.database.database_uri,
         auth=(config.SETTINGS.database.username, config.SETTINGS.database.password),
         encrypted=config.SETTINGS.database.tls_enabled,
         trusted_certificates=trusted_certificates,

infrahub/events/group_action.py

@@ -89,6 +89,7 @@ class GroupMutatedEvent(InfrahubEvent):
             "infrahub.node.id": self.node_id,
             "infrahub.node.action": self.action.value,
             "infrahub.node.root_id": self.node_id,
+            "infrahub.branch.name": self.meta.context.branch.name,
         }
 
 

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/app.py

@@ -155,7 +155,7 @@ class InfrahubGraphQLApp:
 
             db = websocket.app.state.db
 
-            async with db.start_session() as db:
+            async with db.start_session(read_only=True) as db:
                 branch_name = websocket.path_params.get("branch_name", registry.default_branch)
                 branch = await registry.get_branch(db=db, branch=branch_name)
 

infrahub/graphql/loaders/node.py

@@ -53,7 +53,7 @@ class NodeDataLoader(DataLoader[str, Node | None]):
         self.db = db
 
     async def batch_load_fn(self, keys: list[Any]) -> list[Node | None]:
-        async with self.db.start_session() as db:
+        async with self.db.start_session(read_only=True) as db:
             nodes_by_id = await NodeManager.get_many(
                 db=db,
                 ids=keys,

infrahub/graphql/loaders/peers.py

@@ -51,7 +51,7 @@ class PeerRelationshipsDataLoader(DataLoader[str, list[Relationship]]):
         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:
+        async with self.db.start_session(read_only=True) as db:
             peer_rels = await NodeManager.query_peers(
                 db=db,
                 ids=keys,

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():