infrahub-server 1.6.3__py3-none-any.whl → 1.7.0b0__py3-none-any.whl

infrahub/core/node/standard.py

@@ -1,15 +1,17 @@
 from __future__ import annotations
 
 import inspect
+from dataclasses import dataclass, field
 from enum import Enum
 from typing import TYPE_CHECKING, Any, Optional, Union, get_args, get_origin
 from uuid import UUID
 
 import ujson
 from infrahub_sdk.uuidt import UUIDT
-from pydantic import BaseModel
+from pydantic import BaseModel, Field, field_validator
 
-from infrahub.core.constants import NULL_VALUE
+from infrahub.constants.enums import OrderByField, OrderDirection
+from infrahub.core.constants import NULL_VALUE, SYSTEM_USER_ID, InfrahubKind
 from infrahub.core.query.standard_node import (
     StandardNodeCreateQuery,
     StandardNodeDeleteQuery,
@@ -18,6 +20,7 @@ from infrahub.core.query.standard_node import (
     StandardNodeQuery,
     StandardNodeUpdateQuery,
 )
+from infrahub.core.timestamp import Timestamp, current_timestamp
 from infrahub.exceptions import Error, InitializationError
 
 if TYPE_CHECKING:
@@ -29,9 +32,25 @@ if TYPE_CHECKING:
     from infrahub.database import InfrahubDatabase
 
 
+@dataclass
+class StandardNodeOrdering:
+    order_by: OrderByField = field(default=OrderByField.ID)
+    direction: OrderDirection = field(default=OrderDirection.ASC)
+
+
+@dataclass(slots=True)
+class StandardNodeQueryFields:
+    node: dict[str, Any] = field(default_factory=dict)
+    node_metadata: dict[str, Any] = field(default_factory=dict)
+
+
 class StandardNode(BaseModel):
     id: Optional[str] = None
     uuid: Optional[UUID] = None
+    created_at: Optional[str] = Field(default=None, validate_default=True)
+    created_by: str = Field(default=SYSTEM_USER_ID)
+    updated_by: Optional[str] = Field(default=None)
+    updated_at: Optional[str] = Field(default=None, validate_default=True)
 
     _query: type[StandardNodeQuery] = StandardNodeCreateQuery
     _exclude_attrs: list[str] = ["id", "uuid", "_query"]
@@ -45,6 +64,11 @@ class StandardNode(BaseModel):
             raise ValueError("id isn't defined yet")
         return self.id
 
+    @field_validator("created_at", mode="before")
+    @classmethod
+    def set_created_at(cls, value: str) -> str:
+        return Timestamp(value).to_string()
+
     @staticmethod
     def guess_field_type(field: FieldInfo) -> Any:
         """Return the type of a Pydantic model field.
@@ -68,7 +92,14 @@ class StandardNode(BaseModel):
 
         raise InitializationError("The root node has not been initialized with a uuid")
 
-    async def to_graphql(self, fields: dict) -> dict:
+    async def to_graphql_flat(self, fields: dict) -> dict:
+        """Returns the GraphQL representation of the object with only top-level fields.
+
+        This method does not handle nested fields and is only used for the old `Branch` query which
+        will be deprecated in the future and replaced by the `InfrahubBranch` query.
+        It's also used for the old style of Branch mutations that will be deprecated in the future,
+        when we introduce InfrahubBranch muations for consistency.
+        """
         response: dict[str, Any] = {"id": self.uuid}
 
         for field_name in fields.keys():
@@ -77,21 +108,71 @@ class StandardNode(BaseModel):
             if field_name == "__typename":
                 response[field_name] = self.get_type()
                 continue
-            field = getattr(self, field_name)
+            field = getattr(self, field_name, None)
             if field is None:
                 response[field_name] = None
                 continue
+            if isinstance(fields.get(field_name), dict):
+                result = {}
+                for nested_field in fields.get(field_name, {}).keys():
+                    if nested_field == "value":
+                        result[nested_field] = field
+                        continue
+                response[field_name] = result
+                continue
+
             response[field_name] = field
 
         return response
 
-    async def save(self, db: InfrahubDatabase) -> bool:
+    async def to_graphql(self, fields: StandardNodeQueryFields) -> dict:
+        node_response: dict[str, Any] = {}
+        meta_response: dict[str, Any] = {}
+
+        for field_name in fields.node.keys():
+            if field_name == "id":
+                node_response["id"] = self.uuid
+                continue
+            if field_name == "__typename":
+                node_response[field_name] = self.get_type()
+                continue
+            field = getattr(self, field_name, None)
+            if field is None:
+                node_response[field_name] = None
+                continue
+            if isinstance(fields.node.get(field_name), dict):
+                result = {}
+                for nested_field in fields.node.get(field_name, {}).keys():
+                    if nested_field == "value":
+                        result[nested_field] = field
+                        continue
+                node_response[field_name] = result
+                continue
+
+            node_response[field_name] = field
+
+        for field_name in fields.node_metadata.keys():
+            match field_name:
+                case "created_at":
+                    meta_response["created_at"] = Timestamp(self.created_at).to_datetime() if self.created_at else None
+                case "updated_at":
+                    meta_response["updated_at"] = Timestamp(self.updated_at).to_datetime() if self.updated_at else None
+                case "created_by":
+                    if self.created_by and self.created_by != SYSTEM_USER_ID:
+                        meta_response["created_by"] = {"id": self.created_by, "__kind__": InfrahubKind.ACCOUNT}
+                case "updated_by":
+                    if self.updated_by and self.updated_by != SYSTEM_USER_ID:
+                        meta_response["updated_by"] = {"id": self.updated_by, "__kind__": InfrahubKind.ACCOUNT}
+
+        return {"node": node_response, "node_metadata": meta_response}
+
+    async def save(self, db: InfrahubDatabase, user_id: str = SYSTEM_USER_ID) -> bool:
         """Create or Update the Node in the database."""
 
         if self.id:
-            return await self.update(db=db)
+            return await self.update(db=db, user_id=user_id)
 
-        return await self.create(db=db)
+        return await self.create(db=db, user_id=user_id)
 
     async def delete(self, db: InfrahubDatabase) -> None:
         """Delete the Node in the database."""
@@ -99,9 +180,11 @@ class StandardNode(BaseModel):
         query: Query = await StandardNodeDeleteQuery.init(db=db, node=self)
         await query.execute(db=db)
 
-    async def create(self, db: InfrahubDatabase) -> bool:
+    async def create(self, db: InfrahubDatabase, user_id: str = SYSTEM_USER_ID) -> bool:
         """Create a new node in the database."""
-
+        self.created_by = user_id
+        self.updated_by = self.created_by
+        self.updated_at = self.created_at
         query: Query = await self._query.init(db=db, node=self)
         await query.execute(db=db)
 
@@ -115,9 +198,10 @@ class StandardNode(BaseModel):
 
         return True
 
-    async def update(self, db: InfrahubDatabase) -> bool:
+    async def update(self, db: InfrahubDatabase, user_id: str = SYSTEM_USER_ID) -> bool:
         """Update the node in the database if needed."""
-
+        self.updated_by = user_id
+        self.updated_at = current_timestamp()
         query: Query = await StandardNodeUpdateQuery.init(db=db, node=self)
         await query.execute(db=db)
         result = query.get_result()
@@ -187,7 +271,7 @@ class StandardNode(BaseModel):
         else:
             data["uuid"] = str(self.uuid)
 
-        for attr_name, field in self.model_fields.items():
+        for attr_name, field_info in self.__class__.model_fields.items():
             if attr_name in self._exclude_attrs:
                 continue
 
@@ -195,7 +279,7 @@ class StandardNode(BaseModel):
             if isinstance(attr_value, Enum):
                 attr_value = attr_value.value
 
-            field_type = self.guess_field_type(field)
+            field_type = self.guess_field_type(field_info)
 
             if attr_value is None:
                 data[attr_name] = NULL_VALUE
@@ -219,10 +303,12 @@ class StandardNode(BaseModel):
         limit: int = 1000,
         ids: list[str] | None = None,
         name: str | None = None,
+        node_ordering: StandardNodeOrdering | None = None,
         **kwargs: dict[str, Any],
     ) -> list[Self]:
+        node_ordering = node_ordering or StandardNodeOrdering()
         query: Query = await StandardNodeGetListQuery.init(
-            db=db, node_class=cls, ids=ids, node_name=name, limit=limit, **kwargs
+            db=db, node_class=cls, ids=ids, node_name=name, limit=limit, node_ordering=node_ordering, **kwargs
         )
         await query.execute(db=db)
 

infrahub/core/property.py

@@ -34,7 +34,6 @@ class ClearValue(Enum):
 class FlagPropertyMixin:
     _flag_properties: list[str] = [v.value for v in FlagProperty]
 
-    is_visible = True
     is_protected = False
 
     def _init_flag_property_mixin(self, kwargs: dict | None = None) -> None:

infrahub/core/protocols_base.py

@@ -4,6 +4,8 @@ from typing import TYPE_CHECKING, Any, Protocol, runtime_checkable
 
 from typing_extensions import Self
 
+from infrahub.core.constants import SYSTEM_USER_ID
+
 if TYPE_CHECKING:
     from neo4j import AsyncResult, AsyncSession, AsyncTransaction, Record
 
@@ -82,8 +84,10 @@ class CoreNode(Protocol):
         at: Timestamp | str | None = None,
     ) -> Self: ...
     async def new(self, db: InfrahubDatabase, id: str | None = None, **kwargs: Any) -> Self: ...
-    async def save(self, db: InfrahubDatabase, at: Timestamp | None = None) -> Self: ...
-    async def delete(self, db: InfrahubDatabase, at: Timestamp | None = None) -> None: ...
+    async def save(self, db: InfrahubDatabase, at: Timestamp | None = None, user_id: str = SYSTEM_USER_ID) -> Self: ...
+    async def delete(
+        self, db: InfrahubDatabase, at: Timestamp | None = None, user_id: str = SYSTEM_USER_ID
+    ) -> None: ...
     async def load(
         self,
         db: InfrahubDatabase,

infrahub/core/query/__init__.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from abc import ABC, abstractmethod
 from collections import defaultdict
 from dataclasses import dataclass, field
 from enum import Enum
@@ -12,7 +13,7 @@ from neo4j.graph import Relationship as Neo4jRelationship
 from opentelemetry import trace
 
 from infrahub import config
-from infrahub.core.constants import PermissionLevel
+from infrahub.core.constants import SYSTEM_USER_ID, PermissionLevel
 from infrahub.core.timestamp import Timestamp
 from infrahub.exceptions import QueryError
 
@@ -335,7 +336,7 @@ class QueryStat:
         return cls(**data)
 
 
-class Query:
+class Query(ABC):
     name: str = "base-query"
     type: QueryType
 
@@ -351,6 +352,7 @@ class Query:
         offset: int | None = None,
         order_by: list[str] | None = None,
         branch_agnostic: bool = False,
+        user_id: str = SYSTEM_USER_ID,
     ):
         if branch:
             self.branch = branch
@@ -366,6 +368,7 @@ class Query:
         self.limit = limit
         self.offset = offset
         self.order_by = order_by
+        self.user_id = user_id
 
         # Initialize internal variables
         self.params: dict = {}
@@ -402,12 +405,8 @@ class Query:
 
         return query
 
+    @abstractmethod
     async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
-        # Avoid using this method for new queries and look at migrating older queries. The
-        # problem here is that we loose so much information with the `**kwargs` we should instead
-        # populate this information via the constructor and anything done within the existing query_init methods
-        # could either be handled within __init__ or via dedicated methods within each Query class where appropriate,
-        # i.e. things might need to happend in a certain order or we just want to separate the logic better.
         raise NotImplementedError
 
     def get_context(self) -> dict[str, str]:

infrahub/core/query/attribute.py

@@ -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,20 +134,37 @@ 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,
@@ -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,
     ):
         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(