infrahub-server 1.1.6__py3-none-any.whl → 1.2.0b1__py3-none-any.whl

infrahub/core/relationship/model.py

@@ -23,7 +23,8 @@ from infrahub_sdk.uuidt import UUIDT
 from pydantic import BaseModel, Field
 
 from infrahub.core import registry
-from infrahub.core.constants import BranchSupportType, InfrahubKind
+from infrahub.core.changelog.models import ChangelogRelationshipMapper
+from infrahub.core.constants import BranchSupportType, InfrahubKind, RelationshipKind
 from infrahub.core.property import (
     FlagPropertyMixin,
     NodePropertyData,
@@ -48,11 +49,11 @@ if TYPE_CHECKING:
     from typing_extensions import Self
 
     from infrahub.core.branch import Branch
+    from infrahub.core.changelog.models import RelationshipCardinalityManyChangelog, RelationshipCardinalityOneChangelog
     from infrahub.core.node import Node
     from infrahub.core.schema import MainSchemaTypes, RelationshipSchema
     from infrahub.database import InfrahubDatabase
 
-# pylint: disable=redefined-builtin,too-many-lines
 
 PeerType = TypeVar("PeerType")
 
@@ -140,6 +141,12 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
 
         return self.peer_id
 
+    def get_peer_kind(self) -> str:
+        if not self._peer or isinstance(self._peer, str):
+            return self.schema.peer
+
+        return self._peer.get_kind()
+
     @property
     def node_id(self) -> str:
         if self._node_id:
@@ -159,7 +166,7 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
             return registry.get_global_branch()
         return self.branch
 
-    async def _process_data(self, data: Union[dict, RelationshipPeerData, str]) -> None:  # pylint: disable=too-many-branches
+    async def _process_data(self, data: Union[dict, RelationshipPeerData, str]) -> None:
         self.data = data
 
         if isinstance(data, RelationshipPeerData):
@@ -193,16 +200,19 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
         else:
             await self.set_peer(value=data)
 
-    async def new(  # pylint: disable=unused-argument
-        self, db: InfrahubDatabase, data: Union[dict, RelationshipPeerData, Any] = None, **kwargs: Any
+    async def new(
+        self,
+        db: InfrahubDatabase,  # noqa: ARG002
+        data: Union[dict, RelationshipPeerData, Any] = None,
+        **kwargs: Any,  # noqa: ARG002
     ) -> Relationship:
         await self._process_data(data=data)
 
         return self
 
-    async def load(  # pylint: disable=unused-argument
+    async def load(
         self,
-        db: InfrahubDatabase,
+        db: InfrahubDatabase,  # noqa: ARG002
         id: Optional[UUID] = None,
         db_id: Optional[str] = None,
         updated_at: Optional[Union[Timestamp, str]] = None,
@@ -253,9 +263,9 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
     async def get_peer(self, db: InfrahubDatabase, peer_type: type[PeerType]) -> PeerType: ...
 
     @overload
-    async def get_peer(self, db: InfrahubDatabase, peer_type: Literal[None] = ...) -> Node: ...
+    async def get_peer(self, db: InfrahubDatabase, peer_type: None = ...) -> Node: ...
 
-    async def get_peer(self, db: InfrahubDatabase, peer_type: type[PeerType] | None = None) -> Any:  # pylint: disable=unused-argument
+    async def get_peer(self, db: InfrahubDatabase, peer_type: type[PeerType] | None = None) -> Any:  # noqa: ARG002
         """Return the peer of the relationship."""
         if self._peer is None:
             await self._get_peer(db=db)
@@ -521,8 +531,6 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
         return response
 
     async def get_create_data(self, db: InfrahubDatabase) -> RelationshipCreateData:
-        # pylint: disable=no-member
-
         branch = self.get_branch_based_on_support_type()
 
         await self.resolve(db=db)
@@ -749,7 +757,7 @@ class RelationshipManager:
         await rm._validate_hierarchy()
 
         for item in data:
-            if not isinstance(item, (rm.rel_class, str, dict)) and not hasattr(item, "_schema"):
+            if not isinstance(item, rm.rel_class | str | dict) and not hasattr(item, "_schema"):
                 raise ValidationError({rm.name: f"Invalid data provided to form a relationship {item}"})
 
             rel = rm.rel_class(schema=rm.schema, branch=rm.branch, at=rm.at, node=rm.node)
@@ -813,7 +821,7 @@ class RelationshipManager:
     async def get_peer(
         self,
         db: InfrahubDatabase,
-        peer_type: Literal[None] = ...,
+        peer_type: None = ...,
         raise_on_error: Literal[False] = ...,
     ) -> Node | None: ...
 
@@ -821,7 +829,7 @@ class RelationshipManager:
     async def get_peer(
         self,
         db: InfrahubDatabase,
-        peer_type: Literal[None] = ...,
+        peer_type: None = ...,
         raise_on_error: Literal[True] = ...,
     ) -> Node: ...
 
@@ -829,14 +837,14 @@ class RelationshipManager:
     async def get_peer(
         self,
         db: InfrahubDatabase,
-        peer_type: Literal[None] = ...,
+        peer_type: None = ...,
         raise_on_error: bool = ...,
     ) -> Node: ...
 
     async def get_peer(
         self,
         db: InfrahubDatabase,
-        peer_type: type[PeerType] | None = None,  # pylint: disable=unused-argument
+        peer_type: type[PeerType] | None = None,  # noqa: ARG002
         raise_on_error: bool = False,
     ) -> Node | PeerType | None:
         if self.schema.cardinality == "many":
@@ -863,14 +871,14 @@ class RelationshipManager:
     async def get_peers(
         self,
         db: InfrahubDatabase,
-        peer_type: Literal[None] = None,
+        peer_type: None = None,
         branch_agnostic: bool = ...,
     ) -> Mapping[str, Node]: ...
 
     async def get_peers(
         self,
         db: InfrahubDatabase,
-        peer_type: type[PeerType] | None = None,  # pylint: disable=unused-argument
+        peer_type: type[PeerType] | None = None,  # noqa: ARG002
         branch_agnostic: bool = False,
     ) -> Mapping[str, Node | PeerType]:
         rels = await self.get_relationships(db=db, branch_agnostic=branch_agnostic)
@@ -884,6 +892,8 @@ class RelationshipManager:
         """If the attribute is branch aware, return the Branch object associated with this attribute
         If the attribute is branch agnostic return the Global Branch
 
+        Note that if this relationship is Aware and source node is Agnostic, it will return -global- branch.
+
         Returns:
             Branch:
         """
@@ -959,7 +969,7 @@ class RelationshipManager:
         self.has_fetched_relationships = True
 
         for peer_id in details.peer_ids_present_local_only:
-            await self.remove(peer_id=peer_id, db=db)
+            await self.remove_locally(peer_id=peer_id, db=db)
 
     async def get(self, db: InfrahubDatabase) -> Relationship | list[Relationship] | None:
         rels = await self.get_relationships(db=db)
@@ -971,6 +981,19 @@ class RelationshipManager:
 
         return rels
 
+    async def get_parent(
+        self, db: InfrahubDatabase, branch_agnostic: bool = False, force_refresh: bool = False
+    ) -> Relationship | None:
+        if self.schema.kind == RelationshipKind.PARENT:
+            for relationship in await self.get_relationships(
+                db=db, branch_agnostic=branch_agnostic, force_refresh=force_refresh
+            ):
+                # As parent relationships requires cardinality=one there will always only be one relationship
+                # here even though it's within a loop
+                return relationship
+
+        return None
+
     async def get_relationships(
         self, db: InfrahubDatabase, branch_agnostic: bool = False, force_refresh: bool = False
     ) -> list[Relationship]:
@@ -985,7 +1008,7 @@ class RelationshipManager:
 
         return self._relationships.as_list()
 
-    async def update(  # pylint: disable=too-many-branches
+    async def update(
         self, data: Union[list[Union[str, Node]], dict[str, Any], str, Node, None], db: InfrahubDatabase
     ) -> bool:
         """Replace and Update the list of relationships with this one."""
@@ -1002,7 +1025,7 @@ class RelationshipManager:
         changed = False
 
         for item in list_data:
-            if not isinstance(item, (self.rel_class, str, dict, type(None))) and not hasattr(item, "_schema"):
+            if not isinstance(item, self.rel_class | str | dict | type(None)) and not hasattr(item, "_schema"):
                 raise ValidationError({self.name: f"Invalid data provided to form a relationship {item}"})
 
             if hasattr(item, "_schema"):
@@ -1040,7 +1063,7 @@ class RelationshipManager:
             changed = True
 
         # Check if some relationship got removed by checking if the previous list of relationship is a subset of the current list of not
-        if set(list(previous_relationships.keys())) <= {rel.peer_id for rel in await self.get_relationships(db=db)}:
+        if set(previous_relationships.keys()) <= {rel.peer_id for rel in await self.get_relationships(db=db)}:
             changed = True
 
         if changed:
@@ -1050,7 +1073,7 @@ class RelationshipManager:
 
     async def add(self, data: Union[dict[str, Any], Node], db: InfrahubDatabase) -> bool:
         """Add a new relationship to the list of existing ones, avoid duplication."""
-        if not isinstance(data, (self.rel_class, dict)) and not hasattr(data, "_schema"):
+        if not isinstance(data, self.rel_class | dict) and not hasattr(data, "_schema"):
             raise ValidationError({self.name: f"Invalid data provided to form a relationship {data}"})
 
         await self._validate_hierarchy()
@@ -1077,22 +1100,17 @@ class RelationshipManager:
         for rel in self._relationships:
             await rel.resolve(db=db)
 
-    async def remove(
+    async def remove_locally(
         self,
         peer_id: Union[str, UUID],
         db: InfrahubDatabase,
-        update_db: bool = False,
     ) -> bool:
-        """Remove a peer id from the local relationships list,
-        need to investigate if and when we should update the relationship in the database."""
+        """Remove a peer id from the local relationships list"""
 
         for idx, rel in enumerate(await self.get_relationships(db=db)):
             if str(rel.peer_id) != str(peer_id):
                 continue
 
-            if update_db:
-                await rel.delete(db=db)
-
             self._relationships.pop(idx)
             return True
 
@@ -1109,14 +1127,13 @@ class RelationshipManager:
 
         # - Update the existing relationship if we are on the same branch
         rel_ids_per_branch = peer_data.rel_ids_per_branch()
+
+        # In which cases do we end up here and do not want to set `to` time?
         if branch.name in rel_ids_per_branch:
             await update_relationships_to([str(ri) for ri in rel_ids_per_branch[branch.name]], to=remove_at, db=db)
 
         # - Create a new rel of type DELETED if the existing relationship is on a different branch
-        rel_branches: set[str] = set()
-        if peer_data.rels:
-            rel_branches = {r.branch for r in peer_data.rels}
-        if rel_branches == {peer_data.branch}:
+        if peer_data.rels and {r.branch for r in peer_data.rels} == {peer_data.branch}:
             return
 
         query = await RelationshipDataDeleteQuery.init(
@@ -1130,18 +1147,22 @@ class RelationshipManager:
         )
         await query.execute(db=db)
 
-    async def save(self, db: InfrahubDatabase, at: Optional[Timestamp] = None) -> Self:
+    async def save(
+        self, db: InfrahubDatabase, at: Optional[Timestamp] = None
+    ) -> RelationshipCardinalityManyChangelog | RelationshipCardinalityOneChangelog:
         """Create or Update the Relationship in the database."""
 
         await self.resolve(db=db)
 
         save_at = Timestamp(at)
         details = await self.fetch_relationship_ids(db=db, force_refresh=True)
+        relationship_mapper = ChangelogRelationshipMapper(schema=self.schema)
 
         # If we have previously fetched the relationships from the database
         # Update the one in the database that shouldn't be here.
         if self.has_fetched_relationships:
             for peer_id in details.peer_ids_present_database_only:
+                relationship_mapper.remove_peer(peer_data=details.peers_database[peer_id])
                 await self.remove_in_db(peer_data=details.peers_database[peer_id], at=save_at, db=db)
 
         # Create the new relationship that are not present in the database
@@ -1150,6 +1171,8 @@ class RelationshipManager:
             if rel.peer_id in details.peer_ids_present_local_only:
                 await rel.save(at=save_at, db=db)
 
+                relationship_mapper.add_peer_from_relationship(relationship=rel)
+
             elif rel.peer_id in details.peer_ids_present_both:
                 if properties_not_matching := rel.compare_properties_with_data(
                     data=details.peers_database[rel.peer_id]
@@ -1160,19 +1183,34 @@ class RelationshipManager:
                         data=details.peers_database[rel.peer_id],
                         db=db,
                     )
+                    relationship_mapper.add_updated_relationship(
+                        relationship=rel,
+                        old_data=details.peers_database[rel.peer_id],
+                        properties_to_update=properties_not_matching,
+                    )
+            elif rel.schema.kind == RelationshipKind.PARENT:
+                relationship_mapper.add_parent_from_relationship(relationship=rel)
 
-        return self
+        return relationship_mapper.changelog
 
-    async def delete(self, db: InfrahubDatabase, at: Optional[Timestamp] = None) -> None:
+    async def delete(
+        self, db: InfrahubDatabase, at: Optional[Timestamp] = None
+    ) -> RelationshipCardinalityManyChangelog | RelationshipCardinalityOneChangelog:
         """Delete all the relationships."""
 
         delete_at = Timestamp(at)
+        relationship_mapper = ChangelogRelationshipMapper(schema=self.schema)
 
         await self._fetch_relationships(at=delete_at, db=db, force_refresh=True)
 
         for rel in await self.get_relationships(db=db):
+            relationship_mapper.delete_relationship(
+                peer_kind=rel.get_peer_kind(), peer_id=rel.get_peer_id(), rel_schema=rel.schema
+            )
             await rel.delete(at=delete_at, db=db)
 
+        return relationship_mapper.changelog
+
     async def to_graphql(
         self, db: InfrahubDatabase, fields: Optional[dict] = None, related_node_ids: Optional[set] = None
     ) -> Union[dict, None]:
@@ -1188,7 +1226,7 @@ class RelationshipManager:
 
     async def _validate_hierarchy(self) -> None:
         schema = self.node.get_schema()
-        if schema.is_profile_schema or not schema.hierarchy:  # type: ignore[union-attr]
+        if schema.is_profile_schema or schema.is_template_schema or not schema.hierarchy:  # type: ignore[union-attr]
             return
 
         if self.name == "parent" and not schema.parent:  # type: ignore[union-attr]

infrahub/core/schema/__init__.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import uuid
-from typing import Any, Optional, TypeAlias, Union
+from typing import Any, TypeAlias
 
 from infrahub_sdk.utils import deep_merge_dict
 from pydantic import BaseModel, ConfigDict, Field
@@ -19,8 +19,9 @@ from .generic_schema import GenericSchema
 from .node_schema import NodeSchema
 from .profile_schema import ProfileSchema
 from .relationship_schema import RelationshipSchema
+from .template_schema import TemplateSchema
 
-MainSchemaTypes: TypeAlias = Union[NodeSchema, GenericSchema, ProfileSchema]
+MainSchemaTypes: TypeAlias = NodeSchema | GenericSchema | ProfileSchema | TemplateSchema
 
 
 # -----------------------------------------------------
@@ -44,7 +45,7 @@ class SchemaExtension(HashableModel):
 
 class SchemaRoot(BaseModel):
     model_config = ConfigDict(extra="forbid")
-    version: Optional[str] = Field(default=None)
+    version: str | None = Field(default=None)
     generics: list[GenericSchema] = Field(default_factory=list)
     nodes: list[NodeSchema] = Field(default_factory=list)
     extensions: SchemaExtension = SchemaExtension()
@@ -59,7 +60,7 @@ class SchemaRoot(BaseModel):
 
         return True
 
-    def get(self, name: str) -> Union[NodeSchema, GenericSchema]:
+    def get(self, name: str) -> NodeSchema | GenericSchema:
         """Check if a schema exist locally as a node or as a generic."""
 
         for item in self.nodes + self.generics:
@@ -107,6 +108,7 @@ __all__ = [
     "SchemaAttributePath",
     "SchemaAttributePathValue",
     "SchemaRoot",
+    "TemplateSchema",
     "core_models",
     "internal_schema",
 ]

infrahub/core/schema/attribute_schema.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import enum
+from enum import Enum
 from typing import TYPE_CHECKING, Any, Optional, Union
 
 from pydantic import field_validator, model_validator
@@ -36,6 +37,13 @@ class AttributeSchema(GeneratedAttributeSchema):
     def is_deprecated(self) -> bool:
         return bool(self.deprecation)
 
+    def to_dict(self) -> dict:
+        data = self.model_dump(exclude_unset=True, exclude_none=True, exclude_defaults=True)
+        for field_name, value in data.items():
+            if isinstance(value, Enum):
+                data[field_name] = value.value
+        return data
+
     @field_validator("kind")
     @classmethod
     def kind_options(cls, v: str) -> str:

infrahub/core/schema/basenode_schema.py

@@ -4,6 +4,7 @@ import hashlib
 import keyword
 import os
 from dataclasses import asdict, dataclass
+from enum import Enum
 from typing import TYPE_CHECKING, Any, Callable, Iterable, Literal, Optional, Union, overload
 
 from infrahub_sdk.utils import compare_lists, intersection
@@ -22,13 +23,11 @@ if TYPE_CHECKING:
     from infrahub.core.schema import GenericSchema, NodeSchema
     from infrahub.core.schema.schema_branch import SchemaBranch
 
-# pylint: disable=redefined-builtin
-
 
 NODE_METADATA_ATTRIBUTES = ["_source", "_owner"]
 
 
-class BaseNodeSchema(GeneratedBaseNodeSchema):  # pylint: disable=too-many-public-methods
+class BaseNodeSchema(GeneratedBaseNodeSchema):
     _exclude_from_hash: list[str] = ["attributes", "relationships"]
     _sort_by: list[str] = ["namespace", "name"]
 
@@ -64,6 +63,17 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):  # pylint: disable=too-many-publi
         Be careful hash generated from hash() have a salt by default and they will not be the same across run"""
         return hash(self.get_hash())
 
+    def to_dict(self) -> dict:
+        data = self.model_dump(
+            exclude_unset=True, exclude_none=True, exclude_defaults=True, exclude={"attributes", "relationships"}
+        )
+        for field_name, value in data.items():
+            if isinstance(value, Enum):
+                data[field_name] = value.value
+        data["attributes"] = [attr.to_dict() for attr in self.attributes]
+        data["relationships"] = [rel.to_dict() for rel in self.relationships]
+        return data
+
     def get_hash(self, display_values: bool = False) -> str:
         """Extend the Hash Calculation to account for attributes and relationships."""
 

infrahub/core/schema/definitions/core/__init__.py

@@ -0,0 +1,153 @@
+from typing import Any
+
+from .account import (
+    core_account,
+    core_account_token,
+    core_credential,
+    core_generic_account,
+    core_password_credential,
+    core_refresh_token,
+)
+from .artifact import core_artifact, core_artifact_definition, core_artifact_target
+from .builtin import builtin_tag
+from .check import core_check_definition
+from .generator import core_generator_definition, core_generator_instance
+from .graphql_query import core_graphql_query
+from .group import core_generator_group, core_graphql_query_group, core_group, core_standard_group
+from .ipam import builtin_ip_address, builtin_ip_prefix, builtin_ipam, core_ipam_namespace
+from .lineage import lineage_owner, lineage_source
+from .menu import generic_menu_item, menu_item
+from .permission import (
+    core_account_group,
+    core_account_role,
+    core_base_permission,
+    core_global_permission,
+    core_object_permission,
+)
+from .profile import core_profile_schema_definition
+from .propose_change import core_proposed_change
+from .propose_change_comment import (
+    core_artifact_thread,
+    core_change_comment,
+    core_change_thread,
+    core_file_thread,
+    core_object_thread,
+    core_propose_change_comment,
+    core_thread,
+    core_thread_comment,
+)
+from .propose_change_validator import (
+    core_artifact_check,
+    core_artifact_validator,
+    core_check,
+    core_data_check,
+    core_data_validator,
+    core_file_check,
+    core_generator_check,
+    core_generator_validator,
+    core_propose_change_validator,
+    core_repository_validator,
+    core_schema_check,
+    core_schema_validator,
+    core_standard_check,
+    core_user_validator,
+)
+from .repository import core_generic_repository, core_read_only_repository, core_repository
+from .resource_pool import core_ip_address_pool, core_ip_prefix_pool, core_number_pool, core_resource_pool
+from .template import core_object_template
+from .transform import core_transform, core_transform_jinja2, core_transform_python
+from .webhook import core_custom_webhook, core_standard_webhook, core_webhook
+
+core_node = {
+    "name": "Node",
+    "namespace": "Core",
+    "include_in_menu": False,
+    "description": "Base Node in Infrahub.",
+    "label": "Node",
+}
+
+core_task_target = {
+    "name": "TaskTarget",
+    "include_in_menu": False,
+    "namespace": "Core",
+    "description": "Extend a node to be associated with tasks",
+    "label": "Task Target",
+}
+
+core_models: dict[str, Any] = {
+    "generics": [
+        core_node,
+        lineage_owner,
+        core_profile_schema_definition,
+        lineage_source,
+        core_propose_change_comment,
+        core_thread,
+        core_group,
+        core_propose_change_validator,
+        core_check,
+        core_transform,
+        core_artifact_target,
+        core_task_target,
+        core_webhook,
+        core_generic_repository,
+        builtin_ipam,
+        builtin_ip_prefix,
+        builtin_ip_address,
+        core_resource_pool,
+        core_generic_account,
+        core_base_permission,
+        core_credential,
+        core_object_template,
+        generic_menu_item,
+    ],
+    "nodes": [
+        menu_item,
+        core_standard_group,
+        core_generator_group,
+        core_graphql_query_group,
+        builtin_tag,
+        core_account,
+        core_account_token,
+        core_password_credential,
+        core_refresh_token,
+        core_proposed_change,
+        core_change_thread,
+        core_file_thread,
+        core_artifact_thread,
+        core_object_thread,
+        core_change_comment,
+        core_thread_comment,
+        core_repository.to_dict(),
+        core_read_only_repository,
+        core_transform_jinja2,
+        core_data_check,
+        core_standard_check,
+        core_schema_check,
+        core_file_check,
+        core_artifact_check,
+        core_generator_check,
+        core_data_validator,
+        core_repository_validator,
+        core_user_validator,
+        core_schema_validator,
+        core_artifact_validator,
+        core_generator_validator,
+        core_check_definition,
+        core_transform_python,
+        core_graphql_query,
+        core_artifact,
+        core_artifact_definition,
+        core_generator_definition,
+        core_generator_instance,
+        core_standard_webhook,
+        core_custom_webhook,
+        core_ipam_namespace,
+        core_ip_prefix_pool,
+        core_ip_address_pool,
+        core_number_pool,
+        core_global_permission,
+        core_object_permission,
+        core_account_role,
+        core_account_group,
+    ],
+}