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

infrahub/core/migrations/query/node_duplicate.py

@@ -133,8 +133,7 @@ class NodeDuplicateQuery(Query):
 
         # ruff: noqa: E501
         query = """
-        CALL {
-            WITH node
+        CALL (node) {
             MATCH (root:Root)<-[r:IS_PART_OF]-(node)
             WHERE %(branch_filter)s
             RETURN node as n1, r as r1
@@ -147,8 +146,7 @@ class NodeDuplicateQuery(Query):
         WITH active_node, new_node
         // Process Outbound Relationship
         MATCH (active_node)-[]->(peer)
-        CALL {
-            WITH active_node, peer
+        CALL (active_node, peer) {
             MATCH (active_node)-[r]->(peer)
             WHERE %(branch_filter)s
             RETURN active_node as n1, r as rel_outband1, peer as p1
@@ -167,8 +165,7 @@ class NodeDuplicateQuery(Query):
         WITH DISTINCT active_node, new_node
         // Process Inbound Relationship
         MATCH (active_node)<-[]-(peer)
-        CALL {
-            WITH active_node, peer
+        CALL (active_node, peer) {
             MATCH (active_node)<-[r]-(peer)
             WHERE %(branch_filter)s
             RETURN active_node as n1, r as rel_inband1, peer as p1

infrahub/core/migrations/query/relationship_duplicate.py

@@ -116,8 +116,7 @@ class RelationshipDuplicateQuery(Query):
 
         # ruff: noqa: E501
         query = """
-        CALL {
-            WITH source, rel, destination
+        CALL (source, rel, destination) {
             MATCH path = (source)-[r1:IS_RELATED]-(rel)-[r2:IS_RELATED]-(destination)
             WHERE all(r IN relationships(path) WHERE %(branch_filter)s)
             RETURN rel as rel1, r1 as r11, r2 as r12
@@ -130,8 +129,7 @@ class RelationshipDuplicateQuery(Query):
         WITH DISTINCT(active_rel) as active_rel, new_rel
         // Process Inbound Relationship
         MATCH (active_rel)<-[]-(peer)
-        CALL {
-            WITH active_rel, peer
+        CALL (active_rel, peer) {
             MATCH (active_rel)<-[r]-(peer)
             WHERE %(branch_filter)s
             RETURN active_rel as n1, r as rel_inband1, peer as p1
@@ -150,8 +148,7 @@ class RelationshipDuplicateQuery(Query):
         WITH DISTINCT(active_rel) as active_rel, new_rel
         // Process Outbound Relationship
         MATCH (active_rel)-[]->(peer)
-        CALL {
-            WITH active_rel, peer
+        CALL (active_rel, peer) {
             MATCH (active_rel)-[r]->(peer)
             WHERE %(branch_filter)s
             RETURN active_rel as n1, r as rel_outband1, peer as p1

infrahub/core/migrations/schema/node_attribute_remove.py

@@ -75,8 +75,7 @@ class NodeAttributeRemoveMigrationQuery01(AttributeMigrationQuery):
         MATCH (node:%(node_kind)s)
         WHERE (size($kinds_to_ignore) = 0 OR NOT any(l IN labels(node) WHERE l IN $kinds_to_ignore))
         AND exists((node)-[:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name }))
-        CALL {
-            WITH node
+        CALL (node) {
             MATCH (root:Root)<-[r:IS_PART_OF]-(node)
             WHERE %(branch_filter)s
             RETURN node as n1, r as r1
@@ -86,8 +85,7 @@ class NodeAttributeRemoveMigrationQuery01(AttributeMigrationQuery):
         WITH n1 as active_node, r1 as rb
         WHERE rb.status = "active"
         // Find all the attributes that need to be updated
-        CALL {
-            WITH active_node
+        CALL (active_node) {
             MATCH (active_node)-[r:HAS_ATTRIBUTE]-(attr:Attribute { name: $attr_name })
             WHERE %(branch_filter)s
             RETURN active_node as n1, r as r1, attr as attr1
@@ -98,8 +96,7 @@ class NodeAttributeRemoveMigrationQuery01(AttributeMigrationQuery):
         WHERE rb.status = "active"
         WITH active_attr
         MATCH (active_attr)-[]-(peer)
-        CALL {
-            WITH active_attr, peer
+        CALL (active_attr, peer) {
             MATCH (active_attr)-[r]-(peer)
             WHERE %(branch_filter)s
             RETURN active_attr as a1, r as r1, peer as p1

infrahub/core/migrations/schema/node_remove.py

@@ -63,8 +63,7 @@ class NodeRemoveMigrationBaseQuery(MigrationQuery):
         query = """
         // Find all the active nodes
         MATCH (node:%(node_kind)s)
-        CALL {
-            WITH node
+        CALL (node) {
             MATCH (root:Root)<-[r:IS_PART_OF]-(node)
             WHERE %(branch_filter)s
             RETURN node as n1, r as r1
@@ -96,8 +95,7 @@ class NodeRemoveMigrationQueryIn(NodeRemoveMigrationBaseQuery):
         // Process Inbound Relationship
         WITH active_node
         MATCH (active_node)<-[]-(peer)
-        CALL {
-            WITH active_node, peer
+        CALL (active_node, peer) {
             MATCH (active_node)-[r]->(peer)
             WHERE %(branch_filter)s
             RETURN active_node as n1, r as rel_inband1, peer as p1
@@ -142,8 +140,7 @@ class NodeRemoveMigrationQueryOut(NodeRemoveMigrationBaseQuery):
         // Process Outbound Relationship
         WITH active_node
         MATCH (active_node)-[]->(peer)
-        CALL {
-            WITH active_node, peer
+        CALL (active_node, peer) {
             MATCH (active_node)-[r]->(peer)
             WHERE %(branch_filter)s
             RETURN active_node as n1, r as rel_outband1, peer as p1

infrahub/core/models.py

@@ -20,6 +20,7 @@ if TYPE_CHECKING:
     from infrahub.core.schema.schema_branch import SchemaBranch
 
 GENERIC_ATTRIBUTES_TO_IGNORE = ["namespace", "name", "branch"]
+PROPERTY_NAMES_TO_IGNORE = ["regex", "min_length", "max_length"]
 
 
 class NodeKind(BaseModel):
@@ -252,11 +253,37 @@ class SchemaUpdateValidationResult(BaseModel):
             if not sub_field_diff:
                 raise ValueError("sub_field_diff must be defined, unexpected situation")
 
-            for prop_name in sub_field_diff.changed:
+            for prop_name, prop_diff in sub_field_diff.changed.items():
+                if prop_name in PROPERTY_NAMES_TO_IGNORE:
+                    continue
+
                 field_info = field.model_fields[prop_name]
                 field_update = str(field_info.json_schema_extra.get("update"))  # type: ignore[union-attr]
 
-                schema_path = SchemaPath(  # type: ignore[call-arg]
+                if isinstance(prop_diff, HashableModelDiff):
+                    for param_field_name in prop_diff.changed:
+                        # override field_update if this field has its own json_schema_extra.update
+                        try:
+                            prop_field = getattr(field, prop_name)
+                            param_field_info = prop_field.model_fields[param_field_name]
+                            param_field_update = str(param_field_info.json_schema_extra.get("update"))
+                        except (AttributeError, KeyError):
+                            param_field_update = None
+
+                        schema_path = SchemaPath(
+                            schema_kind=schema.kind,
+                            path_type=path_type,
+                            field_name=field_name,
+                            property_name=f"{prop_name}.{param_field_name}",
+                        )
+
+                        self._process_field(
+                            schema_path=schema_path,
+                            field_update=param_field_update or field_update,
+                        )
+                    continue
+
+                schema_path = SchemaPath(
                     schema_kind=schema.kind,
                     path_type=path_type,
                     field_name=field_name,

infrahub/core/node/__init__.py

@@ -22,7 +22,14 @@ from infrahub.core.constants import (
 from infrahub.core.constants.schema import SchemaElementPathType
 from infrahub.core.protocols import CoreNumberPool, CoreObjectTemplate
 from infrahub.core.query.node import NodeCheckIDQuery, NodeCreateAllQuery, NodeDeleteQuery, NodeGetListQuery
-from infrahub.core.schema import AttributeSchema, NodeSchema, ProfileSchema, RelationshipSchema, TemplateSchema
+from infrahub.core.schema import (
+    AttributeSchema,
+    NodeSchema,
+    NonGenericSchemaTypes,
+    ProfileSchema,
+    RelationshipSchema,
+    TemplateSchema,
+)
 from infrahub.core.timestamp import Timestamp
 from infrahub.exceptions import InitializationError, NodeNotFoundError, PoolExhaustedError, ValidationError
 from infrahub.types import ATTRIBUTE_TYPES
@@ -66,7 +73,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         _meta.default_filter = default_filter
         super().__init_subclass_with_meta__(_meta=_meta, **options)
 
-    def get_schema(self) -> NodeSchema | ProfileSchema | TemplateSchema:
+    def get_schema(self) -> NonGenericSchemaTypes:
         return self._schema
 
     def get_kind(self) -> str:
@@ -872,9 +879,11 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
             if relationship.kind == RelationshipKind.PARENT:
                 return relationship.name
 
-    async def get_object_template(self, db: InfrahubDatabase) -> Node | None:
+    async def get_object_template(self, db: InfrahubDatabase) -> CoreObjectTemplate | None:
         object_template: RelationshipManager = getattr(self, OBJECT_TEMPLATE_RELATIONSHIP_NAME, None)
-        return await object_template.get_peer(db=db) if object_template is not None else None
+        return (
+            await object_template.get_peer(db=db, peer_type=CoreObjectTemplate) if object_template is not None else None
+        )
 
     def get_relationships(
         self, kind: RelationshipKind, exclude: Sequence[str] | None = None
@@ -888,3 +897,8 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
             for relationship in self.get_schema().relationships
             if relationship.name not in exclude and relationship.kind == kind
         ]
+
+    def validate_relationships(self) -> None:
+        for name in self._relationships:
+            relm: RelationshipManager = getattr(self, name)
+            relm.validate()

infrahub/core/node/create.py

@@ -0,0 +1,211 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Mapping
+
+from infrahub.core import registry
+from infrahub.core.constants import RelationshipCardinality, RelationshipKind
+from infrahub.core.constraint.node.runner import NodeConstraintRunner
+from infrahub.core.manager import NodeManager
+from infrahub.core.node import Node
+from infrahub.core.protocols import CoreObjectTemplate
+from infrahub.dependencies.registry import get_component_registry
+
+if TYPE_CHECKING:
+    from infrahub.core.branch import Branch
+    from infrahub.core.relationship.model import RelationshipManager
+    from infrahub.core.schema import MainSchemaTypes, NonGenericSchemaTypes, RelationshipSchema
+    from infrahub.database import InfrahubDatabase
+
+
+async def get_template_relationship_peers(
+    db: InfrahubDatabase, template: CoreObjectTemplate, relationship: RelationshipSchema
+) -> Mapping[str, CoreObjectTemplate]:
+    """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, peer_type=CoreObjectTemplate)
+
+    peers: dict[str, CoreObjectTemplate] = {}
+    template_relationship_peer = await template_relationship_manager.get_peer(db=db, peer_type=CoreObjectTemplate)
+    if template_relationship_peer:
+        peers[template_relationship_peer.id] = template_relationship_peer
+    return peers
+
+
+async def extract_peer_data(
+    db: InfrahubDatabase,
+    template_peer: CoreObjectTemplate,
+    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
+
+
+async def handle_template_relationships(
+    db: InfrahubDatabase,
+    branch: Branch,
+    obj: Node,
+    template: CoreObjectTemplate,
+    fields: list,
+    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=fields):
+        template_relationship_peers = await 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 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 handle_template_relationships(
+                db=db,
+                branch=branch,
+                constraint_runner=constraint_runner,
+                obj=obj_peer,
+                template=template_relationship_peer,
+                fields=fields,
+            )
+
+
+async def get_profile_ids(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}
+
+
+async def refresh_for_profile_update(
+    db: InfrahubDatabase,
+    branch: Branch,
+    obj: Node,
+    schema: NonGenericSchemaTypes,
+    previous_profile_ids: set[str] | None = None,
+) -> Node:
+    if not hasattr(obj, "profiles"):
+        return obj
+    current_profile_ids = await 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=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
+
+
+async def _do_create_node(
+    node_class: type[Node],
+    db: InfrahubDatabase,
+    data: dict,
+    schema: NonGenericSchemaTypes,
+    fields_to_validate: list,
+    branch: Branch,
+    node_constraint_runner: NodeConstraintRunner,
+) -> Node:
+    obj = await node_class.init(db=db, schema=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 handle_template_relationships(
+            db=db,
+            branch=branch,
+            template=object_template,
+            obj=obj,
+            fields=fields_to_validate,
+        )
+    return obj
+
+
+async def create_node(
+    data: dict,
+    db: InfrahubDatabase,
+    branch: Branch,
+    schema: NonGenericSchemaTypes,
+) -> Node:
+    """Create a node in the database if constraint checks succeed."""
+
+    component_registry = get_component_registry()
+    node_constraint_runner = await component_registry.get_component(
+        NodeConstraintRunner, db=db.start_session() if not db.is_transaction else db, branch=branch
+    )
+    node_class = Node
+    if schema.kind in registry.node:
+        node_class = registry.node[schema.kind]
+
+    fields_to_validate = list(data)
+    if db.is_transaction:
+        obj = await _do_create_node(
+            node_class=node_class,
+            node_constraint_runner=node_constraint_runner,
+            db=db,
+            schema=schema,
+            branch=branch,
+            fields_to_validate=fields_to_validate,
+            data=data,
+        )
+    else:
+        async with db.start_transaction() as dbt:
+            obj = await _do_create_node(
+                node_class=node_class,
+                node_constraint_runner=node_constraint_runner,
+                db=dbt,
+                schema=schema,
+                branch=branch,
+                fields_to_validate=fields_to_validate,
+                data=data,
+            )
+
+    if await get_profile_ids(db=db, obj=obj):
+        obj = await refresh_for_profile_update(db=db, branch=branch, schema=schema, obj=obj)
+
+    return obj

infrahub/core/protocols.py

@@ -62,6 +62,12 @@ class BuiltinIPPrefix(CoreNode):
     children: RelationshipManager
 
 
+class CoreAction(CoreNode):
+    name: String
+    description: StringOptional
+    triggers: RelationshipManager
+
+
 class CoreArtifactTarget(CoreNode):
     artifacts: RelationshipManager
 
@@ -148,6 +154,10 @@ class CoreMenu(CoreNode):
     children: RelationshipManager
 
 
+class CoreNodeTriggerMatch(CoreNode):
+    trigger: RelationshipManager
+
+
 class CoreObjectComponentTemplate(CoreNode):
     template_name: String
 
@@ -189,6 +199,14 @@ class CoreTransformation(CoreNode):
     tags: RelationshipManager
 
 
+class CoreTriggerRule(CoreNode):
+    name: String
+    description: StringOptional
+    active: Boolean
+    branch_scope: Dropdown
+    action: RelationshipManager
+
+
 class CoreValidator(CoreNode):
     label: StringOptional
     state: Enum
@@ -322,6 +340,10 @@ class CoreFileThread(CoreThread):
     repository: RelationshipManager
 
 
+class CoreGeneratorAction(CoreAction):
+    generator: RelationshipManager
+
+
 class CoreGeneratorCheck(CoreCheck):
     instance: String
 
@@ -376,6 +398,16 @@ class CoreGraphQLQueryGroup(CoreGroup):
     query: RelationshipManager
 
 
+class CoreGroupAction(CoreAction):
+    add_members: Boolean
+    group: RelationshipManager
+
+
+class CoreGroupTriggerRule(CoreTriggerRule):
+    members_added: Boolean
+    group: RelationshipManager
+
+
 class CoreIPAddressPool(CoreResourcePool, LineageSource):
     default_address_type: String
     default_prefix_length: IntegerOptional
@@ -395,6 +427,25 @@ class CoreMenuItem(CoreMenu):
     pass
 
 
+class CoreNodeTriggerAttributeMatch(CoreNodeTriggerMatch):
+    attribute_name: String
+    value: StringOptional
+    value_previous: StringOptional
+    value_match: Dropdown
+
+
+class CoreNodeTriggerRelationshipMatch(CoreNodeTriggerMatch):
+    relationship_name: String
+    added: Boolean
+    peer: StringOptional
+
+
+class CoreNodeTriggerRule(CoreTriggerRule):
+    node_kind: String
+    mutation_action: Enum
+    matches: RelationshipManager
+
+
 class CoreNumberPool(CoreResourcePool, LineageSource):
     node: String
     node_attribute: String

infrahub/core/protocols_base.py

@@ -7,6 +7,7 @@ from typing_extensions import Self
 if TYPE_CHECKING:
     from neo4j import AsyncResult, AsyncSession, AsyncTransaction, Record
 
+    from infrahub.core.schema import NonGenericSchemaTypes
     from infrahub.core.schema.schema_branch import SchemaBranch
 
 
@@ -70,6 +71,8 @@ class CoreNode(Protocol):
 
     def get_id(self) -> str: ...
     def get_kind(self) -> str: ...
+    def get_schema(self) -> NonGenericSchemaTypes: ...
+
     @classmethod
     async def init(
         cls,

infrahub/core/query/__init__.py

@@ -424,8 +424,8 @@ class Query(ABC):
         else:
             self.query_lines.extend([line.strip() for line in query.split("\n") if line.strip()])
 
-    def add_subquery(self, subquery: str, with_clause: str | None = None) -> None:
-        self.add_to_query("CALL {")
+    def add_subquery(self, subquery: str, node_alias: str, with_clause: str | None = None) -> None:
+        self.add_to_query(f"CALL ({node_alias}) {{")
         self.add_to_query(subquery)
         self.add_to_query("}")
         if with_clause: