infrahub-server 1.6.2__py3-none-any.whl → 1.7.0__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/order.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from typing import Self
+
+from pydantic import BaseModel, model_validator
+
+from infrahub.constants.enums import OrderDirection  # noqa: TC001
+from infrahub.exceptions import ValidationError
+
+# Metadata field name constants
+METADATA_CREATED_AT = "created_at"
+METADATA_CREATED_BY = "created_by"
+METADATA_UPDATED_AT = "updated_at"
+METADATA_UPDATED_BY = "updated_by"
+
+
+class NodeMetaOrder(BaseModel):
+    created_at: OrderDirection | None = None
+    updated_at: OrderDirection | None = None
+
+
+class OrderModel(BaseModel):
+    disable: bool | None = None
+    node_metadata: NodeMetaOrder | None = None
+
+    @model_validator(mode="after")
+    def validate_metadata(self) -> Self:
+        if self.node_metadata and self.node_metadata.created_at and self.node_metadata.updated_at:
+            raise ValidationError("Cannot order by both created_at and updated_at simultaneously.")
+        return self

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

@@ -221,6 +221,7 @@ class CoreValidator(CoreNode):
 class CoreWebhook(CoreNode):
     name: String
     event_type: Enum
+    active: Boolean
     branch_scope: Dropdown
     node_kind: StringOptional
     description: StringOptional

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,
@@ -102,3 +106,7 @@ class CoreNode(Protocol):
     ) -> dict: ...
     async def render_display_label(self, db: InfrahubDatabase | None = None) -> str: ...
     async def from_graphql(self, data: dict, db: InfrahubDatabase) -> bool: ...
+    def _get_created_at(self) -> Timestamp | None: ...
+    def _get_created_by(self) -> str | None: ...
+    def _get_updated_at(self) -> Timestamp | None: ...
+    def _get_updated_by(self) -> str | None: ...

infrahub/core/query/__init__.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from abc import ABC, abstractmethod
 from collections import defaultdict
 from dataclasses import dataclass, field
 from enum import Enum
@@ -13,7 +12,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
 
@@ -160,7 +159,7 @@ def cleanup_return_labels(labels: list[str]) -> list[str]:
 
 
 class QueryResult:
-    def __init__(self, data: list[Neo4jNode | Neo4jRelationship | list[Neo4jNode]], labels: list[str]):
+    def __init__(self, data: list[Neo4jNode | Neo4jRelationship | list[Neo4jNode]], labels: list[str]) -> None:
         self.data = data
         self.labels = labels
         self.branch_score: int = 0
@@ -336,7 +335,7 @@ class QueryStat:
         return cls(**data)
 
 
-class Query(ABC):
+class Query:
     name: str = "base-query"
     type: QueryType
 
@@ -352,7 +351,8 @@ class Query(ABC):
         offset: int | None = None,
         order_by: list[str] | None = None,
         branch_agnostic: bool = False,
-    ):
+        user_id: str = SYSTEM_USER_ID,
+    ) -> None:
         if branch:
             self.branch = branch
 
@@ -367,6 +367,7 @@ class Query(ABC):
         self.limit = limit
         self.offset = offset
         self.order_by = order_by
+        self.user_id = user_id
 
         # Initialize internal variables
         self.params: dict = {}
@@ -403,8 +404,12 @@ class Query(ABC):
 
         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]: