infrahub-server 1.6.2__py3-none-any.whl → 1.7.0__py3-none-any.whl

infrahub/core/query/attribute.py

@@ -31,7 +31,7 @@ class AttributeQuery(Query):
         at: Timestamp | str | None = None,
         branch: Branch | None = None,
         **kwargs: Any,
-    ):
+    ) -> None:
         self.attr = attr
         self.attr_id = attr_id or attr.db_id
 
@@ -48,13 +48,14 @@ class AttributeQuery(Query):
 class AttributeUpdateValueQuery(AttributeQuery):
     name = "attribute_update_value"
     type: QueryType = QueryType.WRITE
-
-    raise_error_if_empty: bool = True
+    insert_return: bool = False
+    raise_error_if_empty: bool = False
 
     async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
         at = self.at or self.attr.at
 
         self.params["attr_uuid"] = self.attr.id
+        self.params["user_id"] = self.user_id
         self.params["branch"] = self.branch.name
         self.params["branch_level"] = self.branch.hierarchy_level
         self.params["at"] = at.to_string()
@@ -73,29 +74,46 @@ class AttributeUpdateValueQuery(AttributeQuery):
             labels.append(GraphAttributeIPNetworkNode.get_default_label())
 
         query = """
-        MATCH (a:Attribute { uuid: $attr_uuid })
-        MERGE (av:%(labels)s { %(props)s } )
-        WITH av, a
-        LIMIT 1
-        CREATE (a)-[r:%(rel_label)s { branch: $branch, branch_level: $branch_level, status: "active", from: $at }]->(av)
+MATCH (a:Attribute { uuid: $attr_uuid })
+MERGE (av:%(labels)s { %(props)s } )
+WITH av, a
+LIMIT 1
+// ----------
+// find the existing HAS_VALUE edge, if it exists, and set the to time and user_id
+// ---------
+OPTIONAL MATCH (a)-[existing_active_r:%(rel_label)s { branch: $branch, status: "active" }]->()
+WHERE existing_active_r.to IS NULL
+SET existing_active_r.to = $at, existing_active_r.to_user_id = $user_id
+WITH av, a
+LIMIT 1
+// ----------
+// create the new HAS_VALUE edge
+// ---------
+CREATE (a)-[r:%(rel_label)s { branch: $branch, branch_level: $branch_level, status: "active", from: $at, from_user_id: $user_id }]->(av)
+// ----------
+// update the Attribute node with the new timestamp and user id if we are on the default or global branch
+// ---------
+WITH a
+WHERE $branch_level = 1
+LIMIT 1
+SET a.updated_at = $at, a.updated_by = $user_id
         """ % {"rel_label": self.attr._rel_to_value_label, "labels": ":".join(labels), "props": ", ".join(prop_list)}
 
         self.add_to_query(query)
-        self.return_labels = ["a", "av", "r"]
 
 
 class AttributeUpdateFlagQuery(AttributeQuery):
     name = "attribute_update_flag"
     type: QueryType = QueryType.WRITE
-
-    raise_error_if_empty: bool = True
+    insert_return: bool = False
+    raise_error_if_empty: bool = False
 
     def __init__(
         self,
         flag_name: str,
         **kwargs: Any,
     ) -> None:
-        SUPPORTED_FLAGS = ["is_visible", "is_protected"]
+        SUPPORTED_FLAGS = ["is_protected"]
 
         if flag_name not in SUPPORTED_FLAGS:
             raise ValueError(f"Only {SUPPORTED_FLAGS} are supported for now.")
@@ -108,6 +126,7 @@ class AttributeUpdateFlagQuery(AttributeQuery):
         at = self.at or self.attr.at
 
         self.params["attr_uuid"] = self.attr.id
+        self.params["user_id"] = self.user_id
         self.params["branch"] = self.branch.name
         self.params["branch_level"] = self.branch.hierarchy_level
         self.params["at"] = at.to_string()
@@ -115,27 +134,44 @@ class AttributeUpdateFlagQuery(AttributeQuery):
         self.params["flag_type"] = self.attr.get_kind()
 
         query = """
-        MATCH (a:Attribute { uuid: $attr_uuid })
-        MERGE (flag:Boolean { value: $flag_value })
-        CREATE (a)-[r:%s { branch: $branch, branch_level: $branch_level, status: "active", from: $at }]->(flag)
-        """ % self.flag_name.upper()
-
+MATCH (a:Attribute { uuid: $attr_uuid })
+MERGE (flag:Boolean { value: $flag_value })
+WITH flag, a
+LIMIT 1
+// ----------
+// find the existing property edge, if it exists, and set the to time and user_id
+// ---------
+OPTIONAL MATCH (a)-[existing_active_r:%(flag_type)s { branch: $branch, status: "active" }]->()
+WHERE existing_active_r.to IS NULL
+SET existing_active_r.to = $at, existing_active_r.to_user_id = $user_id
+// ----------
+// create the new property edge
+// ---------
+WITH a, flag
+CREATE (a)-[r:%(flag_type)s { branch: $branch, branch_level: $branch_level, status: "active", from: $at, from_user_id: $user_id }]->(flag)
+// ----------
+// update the Attribute node with the new timestamp and user id if we are on the default or global branch
+// ---------
+WITH a
+WHERE $branch_level = 1
+LIMIT 1
+SET a.updated_at = $at, a.updated_by = $user_id
+        """ % {"flag_type": self.flag_name.upper()}
         self.add_to_query(query)
-        self.return_labels = ["a", "flag", "r"]
 
 
 class AttributeUpdateNodePropertyQuery(AttributeQuery):
     name = "attribute_update_node_property"
     type: QueryType = QueryType.WRITE
-
-    raise_error_if_empty: bool = True
+    insert_return: bool = False
+    raise_error_if_empty: bool = False
 
     def __init__(
         self,
         prop_name: str,
         prop_id: str | None = None,
         **kwargs: Any,
-    ):
+    ) -> None:
         self.prop_name = prop_name
         self.prop_id = prop_id
 
@@ -147,6 +183,7 @@ class AttributeUpdateNodePropertyQuery(AttributeQuery):
         branch_filter, branch_params = self.branch.get_query_filter_path(at=at)
         self.params.update(branch_params)
         self.params["attr_uuid"] = self.attr.id
+        self.params["user_id"] = self.user_id
         self.params["branch"] = self.branch.name
         self.params["branch_level"] = self.branch.hierarchy_level
         self.params["at"] = at.to_string()
@@ -176,13 +213,29 @@ class AttributeUpdateNodePropertyQuery(AttributeQuery):
         self.add_to_query(node_query)
 
         attr_query = """
-        MATCH (a:Attribute { uuid: $attr_uuid })
-        CREATE (a)-[r:%(rel_label)s { branch: $branch, branch_level: $branch_level, status: "active", from: $at }]->(np)
+MATCH (a:Attribute { uuid: $attr_uuid })
+// ----------
+// find the existing property edge, if it exists, and set the to time and user_id
+// ---------
+OPTIONAL MATCH (a)-[existing_active_r:%(rel_label)s { branch: $branch, status: "active" }]->()
+WHERE existing_active_r.to IS NULL
+SET existing_active_r.to = $at, existing_active_r.to_user_id = $user_id
+// ----------
+// create the new property edge
+// ---------
+WITH a, np
+LIMIT 1
+CREATE (a)-[r:%(rel_label)s { branch: $branch, branch_level: $branch_level, status: "active", from: $at, from_user_id: $user_id }]->(np)
+// ----------
+// update the Attribute node with the new timestamp and user id if we are on the default or global branch
+// ---------
+WITH a
+WHERE $branch_level = 1
+LIMIT 1
+SET a.updated_at = $at, a.updated_by = $user_id
         """ % {"rel_label": rel_label}
         self.add_to_query(attr_query)
 
-        self.return_labels = ["a", "np", "r"]
-
 
 class AttributeClearNodePropertyQuery(AttributeQuery):
     name = "attribute_clear_node_property"
@@ -192,11 +245,9 @@ class AttributeClearNodePropertyQuery(AttributeQuery):
     def __init__(
         self,
         prop_name: str,
-        prop_id: str | None = None,
         **kwargs: Any,
-    ):
+    ) -> None:
         self.prop_name = prop_name
-        self.prop_id = prop_id
 
         super().__init__(**kwargs)
 
@@ -206,15 +257,14 @@ class AttributeClearNodePropertyQuery(AttributeQuery):
         branch_filter, branch_params = self.branch.get_query_filter_path(at=at)
         self.params.update(branch_params)
         self.params["attr_uuid"] = self.attr.id
+        self.params["user_id"] = self.user_id
         self.params["branch"] = self.branch.name
         self.params["branch_level"] = self.branch.hierarchy_level
         self.params["at"] = at.to_string()
-        self.params["prop_name"] = self.prop_name
-        self.params["prop_id"] = self.prop_id
 
         rel_label = f"HAS_{self.prop_name.upper()}"
         query = """
-MATCH (a:Attribute { uuid: $attr_uuid })-[r:%(rel_label)s]->(np:Node { uuid: $prop_id })
+MATCH (a:Attribute { uuid: $attr_uuid })-[r:%(rel_label)s]->(np:Node)
 WITH DISTINCT a, np
 CALL (a, np) {
     MATCH (a)-[r:%(rel_label)s]->(np)
@@ -228,42 +278,107 @@ WHERE property_edge.status = "active"
 CALL (property_edge) {
     WITH property_edge
     WHERE property_edge.branch = $branch
-    SET property_edge.to = $at
+    SET property_edge.to = $at, property_edge.to_user_id = $user_id
 }
 CALL (a, np, property_edge) {
     WITH property_edge
     WHERE property_edge.branch_level < $branch_level
-    CREATE (a)-[r:%(rel_label)s { branch: $branch, branch_level: $branch_level, status: "deleted", from: $at }]->(np)
+    CREATE (a)-[r:%(rel_label)s { branch: $branch, branch_level: $branch_level, status: "deleted", from: $at, from_user_id: $user_id }]->(np)
+}
+CALL (a) {
+    WITH a
+    WHERE $branch_level = 1
+    LIMIT 1
+    SET a.updated_at = $at, a.updated_by = $user_id
 }
         """ % {"branch_filter": branch_filter, "rel_label": rel_label}
         self.add_to_query(query)
 
 
-class AttributeGetQuery(AttributeQuery):
-    name = "attribute_get"
-    type: QueryType = QueryType.READ
+class AttributeDeleteQuery(AttributeQuery):
+    name = "attribute_delete"
+    type: QueryType = QueryType.WRITE
+    insert_return: bool = False
 
     async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params["attr_uuid"] = self.attr.id
-        self.params["node_uuid"] = self.attr.node.id
-
+        self.params["user_id"] = self.user_id
+        self.params["branch"] = self.branch.name
+        self.params["branch_level"] = self.branch.hierarchy_level
+        self.params["branched_from"] = self.branch.get_branched_from()
         self.params["at"] = self.at.to_string()
 
-        rels_filter, rels_params = self.branch.get_query_filter_path(at=self.at.to_string())
-        self.params.update(rels_params)
+        branch_filter, branch_params = self.branch.get_query_filter_path(at=self.at)
+        self.params.update(branch_params)
 
-        query = (
-            """
-        MATCH (a:Attribute { uuid: $attr_uuid })
-        MATCH p = ((a)-[r2:HAS_VALUE|IS_VISIBLE|IS_PROTECTED|HAS_SOURCE|HAS_OWNER]->(ap))
-        WHERE all(r IN relationships(p) WHERE ( %s ))
-        """
-            % rels_filter
-        )
+        query = """
+MATCH (a:Attribute { uuid: $attr_uuid })
+CALL (a) {
+    WITH a
+    WHERE $branch_level = 1
+    LIMIT 1
+    SET a.updated_at = $at, a.updated_by = $user_id
+}
 
+UNWIND [
+    ["HAS_ATTRIBUTE", "in"],
+    ["HAS_VALUE", "out"],
+    ["IS_PROTECTED", "out"],
+    ["HAS_SOURCE", "out"],
+    ["HAS_OWNER", "out"]
+] AS edge_details
+WITH a, edge_details[0] AS property_type, edge_details[1] AS direction
+CALL (a, property_type, direction) {
+    MATCH (a)-[r]-(attr_peer)
+    WHERE type(r) = property_type
+    AND (
+        (direction = "in" AND startNode(r) = attr_peer)
+        OR (direction = "out" AND startNode(r) = a)
+    )
+    AND %(branch_filter)s
+    RETURN r AS property_edge, attr_peer
+    ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+    LIMIT 1
+}
+CALL (property_edge) {
+    WITH property_edge
+    WHERE property_edge.status = "active"
+    AND property_edge.branch = $branch
+    AND property_edge.to IS NULL
+    SET property_edge.to = $at, property_edge.to_user_id = $user_id
+}
+WITH a, property_edge, property_type, attr_peer, direction
+CALL (a, property_type, attr_peer, direction) {
+    WITH direction
+    WHERE direction = "out"
+    CREATE (a)
+        -[r:$(property_type) { branch: $branch, branch_level: $branch_level, status: "deleted", from: $at, from_user_id: $user_id }]
+        ->(attr_peer)
+}
+CALL (a, property_type, attr_peer, direction) {
+    WITH direction
+    WHERE direction = "in"
+    CREATE (a)
+        <-[r:$(property_type) { branch: $branch, branch_level: $branch_level, status: "deleted", from: $at, from_user_id: $user_id }]
+        -(attr_peer)
+}
+WITH CASE
+    WHEN property_type = "HAS_VALUE" THEN attr_peer.value
+    ELSE NULL
+END AS property_value
+WITH property_value
+RETURN property_value
+ORDER BY property_value ASC
+LIMIT 1
+        """ % {"branch_filter": branch_filter}
         self.add_to_query(query)
+        self.return_labels = ["property_value"]
 
-        self.return_labels = ["a", "ap", "r2"]
+    def get_previous_property_value(self) -> Any:
+        result = self.get_result()
+        if result:
+            return result.get(label="property_value")
+        return None
 
 
 async def default_attribute_query_filter(

infrahub/core/query/branch.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
-from infrahub import config
 from infrahub.core.branch.enums import BranchStatus
 from infrahub.core.constants import GLOBAL_BRANCH_NAME
 from infrahub.core.query import Query, QueryType
@@ -18,7 +17,7 @@ class DeleteBranchRelationshipsQuery(Query):
 
     type: QueryType = QueryType.WRITE
 
-    def __init__(self, branch_name: str, **kwargs: Any):
+    def __init__(self, branch_name: str, **kwargs: Any) -> None:
         self.branch_name = branch_name
         super().__init__(**kwargs)
 
@@ -70,89 +69,78 @@ CALL (vertex_id) {
         self.add_to_query(query)
 
 
-class GetAllBranchInternalRelationshipQuery(Query):
-    name: str = "get_internal_relationship"
+class RebaseBranchQuery(Query):
+    """Rebase a branch onto the default branch by updating edge timestamps
 
-    type: QueryType = QueryType.READ
-    insert_return: bool = False
-
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
-        query = """
-        MATCH p = ()-[r]-()
-        WHERE r.branch = $branch_name
-        RETURN DISTINCT r
-        """
-        self.add_to_query(query=query)
-        self.params["branch_name"] = self.branch.name
-        self.return_labels = ["r"]
-
-
-class RebaseBranchUpdateRelationshipQuery(Query):
-    name: str = "rebase_branch_update"
+    For every edge on this branch
+        if it has a from time before $at and no to time, update it to $at
+        if it has a to time before $at, delete the edge
+        if it has a to time after $at, update the from time to $at
+    Then delete any orphaned vertices
+    """
 
+    name: str = "rebase_branch"
     type: QueryType = QueryType.WRITE
-
-    def __init__(self, ids: list[str], **kwargs: Any) -> None:
-        self.ids = ids
-        super().__init__(**kwargs)
+    insert_return: bool = False
+    raise_error_if_empty: bool = False
 
     async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
-        query = """
-        MATCH ()-[r]->()
-        WHERE %(id_func)s(r) IN $ids
-        SET r.from = $at
-        SET r.conflict = NULL
-        """ % {
-            "id_func": db.get_id_function_name(),
-        }
-
-        self.add_to_query(query=query)
-
+        self.params["branch_name"] = self.branch.name
         self.params["at"] = self.at.to_string()
-        self.params["ids"] = [db.to_database_id(id) for id in self.ids]
-        self.return_labels = [f"{db.get_id_function_name()}(r)"]
-
-
-class RebaseBranchDeleteRelationshipQuery(Query):
-    name: str = "rebase_branch_delete"
 
-    type: QueryType = QueryType.WRITE
-    insert_return: bool = False
-
-    def __init__(self, ids: list[str], **kwargs: Any) -> None:
-        self.ids = ids
-        super().__init__(**kwargs)
+        query = """
+// --------------
+// Get all edges on this branch with their source and destination vertices
+// --------------
+MATCH (s)-[r]-(d)
+WHERE r.branch = $branch_name
+WITH DISTINCT r, s, d
+WITH r, s, d,
+    CASE
+        // No `to` and `from` <= at: update
+        WHEN r.to IS NULL AND r.from <= $at THEN TRUE
+        // Has `to` and `to` < at: delete
+        WHEN r.to IS NOT NULL AND r.to < $at THEN FALSE
+        // Has `to` and `to` >= at: update
+        ELSE TRUE
+    END AS do_update
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
-        if config.SETTINGS.database.db_type == config.DatabaseType.MEMGRAPH:
-            query = """
-            MATCH p = (s)-[r]-(d)
-            WHERE %(id_func)s(r) IN $ids
-            DELETE r
-            """
-        else:
-            query = """
-            MATCH p = (s)-[r]-(d)
-            WHERE %(id_func)s(r) IN $ids
-            DELETE r
-            WITH *
-            UNWIND nodes(p) AS n
-            MATCH (n)
-            WHERE NOT exists((n)--())
-            DELETE n
-            """
-        query %= {
-            "id_func": db.get_id_function_name(),
-        }
+// --------------
+// Process updates: set from = at for relationships we're keeping
+// --------------
+CALL (r, do_update) {
+    WITH r, do_update
+    WHERE do_update = TRUE
+    SET r.from = $at
+}
 
+// --------------
+// Delete the edges
+// --------------
+WITH r, s, d, do_update
+WHERE do_update = FALSE
+CALL (r, s, d) {
+    DELETE r
+}
+// --------------
+// Clean up any orpahned nodes edges
+// --------------
+WITH DISTINCT s, d
+UNWIND [s, d] AS n
+WITH DISTINCT n
+CALL (n) {
+    MATCH (n)
+    WHERE NOT exists((n)--())
+    DELETE n
+}
+        """
         self.add_to_query(query=query)
 
-        self.params["ids"] = [db.to_database_id(id) for id in self.ids]
-
 
 class BranchNodeGetListQuery(StandardNodeGetListQuery):
     def __init__(self, exclude_global: bool = False, **kwargs: Any) -> None:
         self.raw_filter = f"n.status <> '{BranchStatus.DELETING.value}'"
+
         if exclude_global:
             self.raw_filter += f" AND n.name <> '{GLOBAL_BRANCH_NAME}'"
 

infrahub/core/query/delete.py

@@ -11,7 +11,7 @@ class DeleteAfterTimeQuery(Query):
     insert_return: bool = False
     type: QueryType = QueryType.WRITE
 
-    def __init__(self, timestamp: Timestamp, **kwargs: Any):
+    def __init__(self, timestamp: Timestamp, **kwargs: Any) -> None:
         self.timestamp = timestamp
         super().__init__(**kwargs)
 

infrahub/core/query/diff.py

@@ -26,7 +26,7 @@ class DiffQuery(Query):
         diff_from: Timestamp | str = None,
         diff_to: Timestamp | str = None,
         **kwargs,
-    ):
+    ) -> None:
         """A diff is always in the context of a branch"""
 
         if not diff_from and branch.is_default:
@@ -59,7 +59,7 @@ class DiffCountChanges(Query):
         diff_from: Timestamp,
         diff_to: Timestamp,
         **kwargs,
-    ):
+    ) -> None:
         self.branch_names = branch_names
         self.diff_from = diff_from
         self.diff_to = diff_to
@@ -77,7 +77,7 @@ class DiffCountChanges(Query):
         AND diff_rel.branch in $branch_names
         AND (
             (diff_rel.from >= $from_time AND diff_rel.from < $to_time)
-            OR (diff_rel.to >= $to_time AND diff_rel.to < $to_time)
+            OR (diff_rel.to >= $from_time AND diff_rel.to < $to_time)
         )
         AND (p.branch_support = "aware" OR q.branch_support = "aware")
         WITH diff_rel.branch AS branch_name, count(*) AS num_changes
@@ -122,7 +122,7 @@ class DiffCalculationQuery(DiffQuery):
         current_node_field_specifiers: NodeFieldSpecifierMap | None = None,
         new_node_field_specifiers: NodeFieldSpecifierMap | None = None,
         **kwargs: Any,
-    ):
+    ) -> None:
         self.base_branch = base_branch
         self.diff_branch_from_time = diff_branch_from_time
         self.current_node_field_specifiers = current_node_field_specifiers
@@ -335,7 +335,7 @@ CALL (p, q, diff_rel, row_from_time) {
     AND type(r_node) IN ["HAS_ATTRIBUTE", "IS_RELATED"]
     AND any(l in labels(node) WHERE l in ["Attribute", "Relationship"])
     AND node.branch_support IN [$branch_aware, $branch_agnostic]
-    AND type(r_prop) IN ["IS_VISIBLE", "IS_PROTECTED", "HAS_SOURCE", "HAS_OWNER", "HAS_VALUE", "IS_RELATED"]
+    AND type(r_prop) IN ["IS_PROTECTED", "HAS_SOURCE", "HAS_OWNER", "HAS_VALUE", "IS_RELATED"]
     AND any(l in labels(prop) WHERE l in ["Boolean", "Node", "AttributeValue"])
     AND (top_diff_rel.to IS NULL OR top_diff_rel.to >= r_node.from)
     AND (r_node.to IS NULL OR r_node.to >= r_prop.from)
@@ -532,7 +532,7 @@ CALL (root, r_root, p, diff_rel, q) {
     )
     WHERE %(id_func)s(mid_r_root) =  %(id_func)s(r_root)
     AND %(id_func)s(mid_diff_rel) =  %(id_func)s(diff_rel)
-    AND type(r_prop) IN ["IS_VISIBLE", "IS_PROTECTED", "HAS_SOURCE", "HAS_OWNER", "HAS_VALUE", "IS_RELATED"]
+    AND type(r_prop) IN ["IS_PROTECTED", "HAS_SOURCE", "HAS_OWNER", "HAS_VALUE", "IS_RELATED"]
     AND any(l in labels(prop) WHERE l in ["Boolean", "Node", "AttributeValue"])
     AND r_prop.from < $to_time AND r_prop.branch = mid_diff_rel.branch
     AND (mid_diff_rel.to IS NULL OR mid_diff_rel.to >= r_prop.from)
@@ -609,7 +609,7 @@ class DiffPropertyPathsQuery(DiffCalculationQuery):
 MATCH diff_rel_path = (root:Root)<-[r_root:IS_PART_OF]-(n:Node)-[r_node]-(p)-[diff_rel {branch: $branch_name}]->(q)
 WHERE p.branch_support = $branch_aware
 AND any(l in labels(p) WHERE l in ["Attribute", "Relationship"])
-AND type(diff_rel) IN ["IS_VISIBLE", "IS_PROTECTED", "HAS_SOURCE", "HAS_OWNER", "HAS_VALUE"]
+AND type(diff_rel) IN ["IS_PROTECTED", "HAS_SOURCE", "HAS_OWNER", "HAS_VALUE"]
 AND any(l in labels(q) WHERE l in ["Boolean", "Node", "AttributeValue"])
 AND type(r_node) IN ["HAS_ATTRIBUTE", "IS_RELATED"]
 // node ID and field name filtering first pass