infrahub-server 1.2.12__py3-none-any.whl → 1.3.0__py3-none-any.whl

infrahub/core/validators/relationship/peer.py

@@ -2,17 +2,17 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
-from infrahub.core.constants import PathType
+from infrahub import config
+from infrahub.core.constants import PathType, RelationshipKind
 from infrahub.core.path import DataPath, GroupedDataPaths
 from infrahub.core.schema import GenericSchema
 
 from ..interface import ConstraintCheckerInterface
-from ..shared import (
-    RelationshipSchemaValidatorQuery,
-)
+from ..shared import RelationshipSchemaValidatorQuery
 
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
+    from infrahub.core.schema.relationship_schema import RelationshipSchema
     from infrahub.database import InfrahubDatabase
 
     from ..model import SchemaConstraintValidatorRequest
@@ -36,8 +36,7 @@ class RelationshipPeerUpdateValidatorQuery(RelationshipSchemaValidatorQuery):
         # ruff: noqa: E501
         query = """
         MATCH (n:%(node_kind)s)
-        CALL {
-            WITH n
+        CALL (n) {
             MATCH path = (root:Root)<-[rroot:IS_PART_OF]-(n)
             WHERE all(r in relationships(path) WHERE %(branch_filter)s)
             RETURN path as full_path, n as active_node
@@ -45,10 +44,8 @@ class RelationshipPeerUpdateValidatorQuery(RelationshipSchemaValidatorQuery):
             LIMIT 1
         }
         WITH full_path, active_node
-        WITH full_path, active_node
         WHERE all(r in relationships(full_path) WHERE r.status = "active")
-        CALL {
-            WITH active_node
+        CALL (active_node) {
             MATCH path = (active_node)-[rrel1:IS_RELATED]-(rel:Relationship { name: $relationship_id })-[rrel2:IS_RELATED]-(peer:Node)
             WHERE all(
                 r in relationships(path)
@@ -68,8 +65,7 @@ class RelationshipPeerUpdateValidatorQuery(RelationshipSchemaValidatorQuery):
             collect([branch_level_sum, from_times, active_relationship_count, relationship_path, deepest_branch_name]) as enriched_paths,
             start_node,
             peer_node
-        CALL {
-            WITH enriched_paths, peer_node
+        CALL (enriched_paths, peer_node) {
             UNWIND enriched_paths as path_to_check
             RETURN path_to_check[3] as current_path, path_to_check[4] as branch_name, peer_node as current_peer
             ORDER BY
@@ -80,7 +76,6 @@ class RelationshipPeerUpdateValidatorQuery(RelationshipSchemaValidatorQuery):
             LIMIT 1
         }
         WITH start_node, current_peer, branch_name, current_path
-        WITH start_node, current_peer, branch_name, current_path
         WHERE all(r in relationships(current_path) WHERE r.status = "active")
         AND NOT any(label IN LABELS(current_peer) WHERE label IN $allowed_peer_kinds)
         """ % {"branch_filter": branch_filter, "node_kind": self.node_schema.kind}
@@ -130,3 +125,173 @@ class RelationshipPeerChecker(ConstraintCheckerInterface):
             await query.execute(db=self.db)
             grouped_data_paths_list.append(await query.get_paths())
         return grouped_data_paths_list
+
+
+class RelationshipPeerParentValidatorQuery(RelationshipSchemaValidatorQuery):
+    name = "relationship_constraints_peer_parent_validator"
+
+    def __init__(
+        self,
+        relationship: RelationshipSchema,
+        parent_relationship: RelationshipSchema,
+        peer_parent_relationship: RelationshipSchema,
+        **kwargs: Any,
+    ):
+        super().__init__(**kwargs)
+
+        self.relationship = relationship
+        self.parent_relationship = parent_relationship
+        self.peer_parent_relationship = peer_parent_relationship
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        branch_filter, branch_params = self.branch.get_query_filter_path(at=self.at.to_string(), is_isolated=False)
+        self.params.update(branch_params)
+        self.params["peer_relationship_id"] = self.relationship.identifier
+        self.params["parent_relationship_id"] = self.parent_relationship.identifier
+        self.params["peer_parent_relationship_id"] = self.peer_parent_relationship.identifier
+
+        parent_arrows = self.parent_relationship.get_query_arrows()
+        parent_match = (
+            "MATCH (active_node)%(lstart)s[r1:IS_RELATED]%(lend)s"
+            "(rel:Relationship { name: $parent_relationship_id })%(rstart)s[r2:IS_RELATED]%(rend)s(parent:Node)"
+        ) % {
+            "lstart": parent_arrows.left.start,
+            "lend": parent_arrows.left.end,
+            "rstart": parent_arrows.right.start,
+            "rend": parent_arrows.right.end,
+        }
+
+        peer_parent_arrows = self.relationship.get_query_arrows()
+        peer_match = (
+            "MATCH (active_node)%(lstart)s[r1:IS_RELATED]%(lend)s"
+            "(r:Relationship {name: $peer_relationship_id })%(rstart)s[r2:IS_RELATED]%(rend)s(peer:Node)"
+        ) % {
+            "lstart": peer_parent_arrows.left.start,
+            "lend": peer_parent_arrows.left.end,
+            "rstart": peer_parent_arrows.right.start,
+            "rend": peer_parent_arrows.right.end,
+        }
+
+        peer_parent_arrows = self.peer_parent_relationship.get_query_arrows()
+        peer_parent_match = (
+            "MATCH (peer:Node)%(lstart)s[r1:IS_RELATED]%(lend)s"
+            "(r:Relationship {name: $peer_parent_relationship_id})%(rstart)s[r2:IS_RELATED]%(rend)s(peer_parent:Node)"
+        ) % {
+            "lstart": peer_parent_arrows.left.start,
+            "lend": peer_parent_arrows.left.end,
+            "rstart": peer_parent_arrows.right.start,
+            "rend": peer_parent_arrows.right.end,
+        }
+
+        query = """
+        MATCH (n:%(node_kind)s)
+        CALL (n) {
+            MATCH path = (root:Root)<-[r:IS_PART_OF]-(n)
+            WHERE %(branch_filter)s
+            RETURN n as active_node, r.status = "active" AS is_active
+            ORDER BY r.branch_level DESC, r.from DESC
+            LIMIT 1
+        }
+        WITH active_node, is_active
+        WHERE is_active = TRUE
+        %(parent_match)s
+        WHERE all(r in [r1, r2] WHERE %(branch_filter)s AND r.status = "active")
+        CALL (active_node) {
+            %(peer_match)s
+            WITH DISTINCT active_node, peer
+            %(peer_match)s
+            WHERE all(r in [r1, r2] WHERE %(branch_filter)s)
+            WITH peer, r1.status = "active" AND r2.status = "active" AS is_active
+            ORDER BY peer.uuid, r1.branch_level DESC, r2.branch_level DESC, r1.from DESC, r2.from DESC, is_active DESC
+            WITH peer, head(collect(is_active)) AS is_active
+            WHERE is_active = TRUE
+            RETURN peer
+        }
+        CALL (peer) {
+            %(peer_parent_match)s
+            WHERE all(r IN [r1, r2] WHERE %(branch_filter)s)
+            WITH peer_parent, r1, r2, r1.status = "active" AND r2.status = "active" AS is_active
+            WITH peer_parent, r1.branch AS branch_name, is_active
+            ORDER BY r1.branch_level DESC, r2.branch_level DESC, r1.from DESC, r2.from DESC, is_active DESC
+            LIMIT 1
+            WITH peer_parent, branch_name
+            WHERE is_active = TRUE
+            RETURN peer_parent, branch_name
+        }
+        WITH DISTINCT active_node, parent, peer, peer_parent, branch_name
+        WHERE parent.uuid <> peer_parent.uuid
+        """ % {
+            "branch_filter": branch_filter,
+            "node_kind": self.node_schema.kind,
+            "parent_match": parent_match,
+            "peer_match": peer_match,
+            "peer_parent_match": peer_parent_match,
+        }
+
+        self.add_to_query(query)
+        self.return_labels = ["active_node.uuid", "parent.uuid", "peer.uuid", "peer_parent.uuid", "branch_name"]
+
+    async def get_paths(self) -> GroupedDataPaths:
+        grouped_data_paths = GroupedDataPaths()
+
+        for result in self.results:
+            grouped_data_paths.add_data_path(
+                DataPath(
+                    branch=str(result.get("branch_name")),
+                    path_type=PathType.RELATIONSHIP_ONE,
+                    node_id=str(result.get("peer.uuid")),
+                    field_name=self.peer_parent_relationship.name,
+                    peer_id=str(result.get("peer_parent.uuid")),
+                    kind=self.relationship.peer,
+                )
+            )
+
+        return grouped_data_paths
+
+
+class RelationshipPeerParentChecker(ConstraintCheckerInterface):
+    query_classes = [RelationshipPeerParentValidatorQuery]
+
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None) -> None:
+        self.db = db
+        self.branch = branch
+
+    @property
+    def name(self) -> str:
+        return "relationship.common_parent.update"
+
+    def supports(self, request: SchemaConstraintValidatorRequest) -> bool:
+        return request.constraint_name == self.name and config.SETTINGS.main.schema_strict_mode
+
+    async def check(self, request: SchemaConstraintValidatorRequest) -> list[GroupedDataPaths]:
+        grouped_data_paths_list: list[GroupedDataPaths] = []
+
+        if not request.schema_path.field_name:
+            return grouped_data_paths_list
+
+        relationship = request.node_schema.get_relationship(name=request.schema_path.field_name)
+        if not relationship.common_parent:
+            # Should not happen if schema validation was done properly
+            return grouped_data_paths_list
+
+        parent_relationship = next(
+            iter(request.node_schema.get_relationships_of_kind(relationship_kinds=[RelationshipKind.PARENT]))
+        )
+        peer_parent_relationship = request.schema_branch.get(name=relationship.peer, duplicate=False).get_relationship(
+            name=relationship.common_parent
+        )
+
+        for query_class in self.query_classes:
+            query = await query_class.init(
+                db=self.db,
+                branch=self.branch,
+                node_schema=request.node_schema,
+                schema_path=request.schema_path,
+                relationship=relationship,
+                parent_relationship=parent_relationship,
+                peer_parent_relationship=peer_parent_relationship,
+            )
+            await query.execute(db=self.db)
+            grouped_data_paths_list.append(await query.get_paths())
+
+        return grouped_data_paths_list

infrahub/core/validators/tasks.py

@@ -9,7 +9,7 @@ from prefect.logging import get_run_logger
 
 from infrahub.core.branch import Branch  # noqa: TC001
 from infrahub.core.path import SchemaPath  # noqa: TC001
-from infrahub.core.schema import GenericSchema, NodeSchema  # noqa: TC001
+from infrahub.core.schema import GenericSchema, NodeSchema
 from infrahub.core.validators.aggregated_checker import AggregatedConstraintChecker
 from infrahub.core.validators.model import (
     SchemaConstraintValidatorRequest,

infrahub/core/validators/uniqueness/query.py

@@ -158,12 +158,11 @@ class NodeUniqueAttributeConstraintQuery(Query):
         # ruff: noqa: E501
         query = """
         // get attributes for node and its relationships
-        CALL {
+        CALL () {
             %(select_subqueries_str)s
         }
-        CALL {
+        CALL (potential_path) {
             WITH potential_path
-            WITH potential_path  // workaround for neo4j not allowing WHERE in a WITH of a subquery
             // only the branches and times we care about
             WHERE all(
                 r IN relationships(potential_path) WHERE (
@@ -183,8 +182,7 @@ class NodeUniqueAttributeConstraintQuery(Query):
             start_node,
             rel_identifier,
             potential_attr
-        CALL {
-            WITH enriched_paths
+        CALL (enriched_paths) {
             UNWIND enriched_paths as path_to_check
             RETURN path_to_check[0] as current_path, path_to_check[4] as latest_value
             ORDER BY
@@ -194,16 +192,14 @@ class NodeUniqueAttributeConstraintQuery(Query):
                 path_to_check[3] DESC
             LIMIT 1
         }
-        CALL {
+        CALL (current_path) {
             // only active paths
             WITH current_path
-            WITH current_path  // workaround for neo4j not allowing WHERE in a WITH of a subquery
             WHERE all(r IN relationships(current_path) WHERE r.status = "active")
             RETURN current_path as active_path
         }
-        CALL {
+        CALL (active_path) {
             // get deepest branch name
-            WITH active_path
             UNWIND %(branch_name_and_level)s as branch_name_and_level
             RETURN branch_name_and_level[0] as branch_name
             ORDER BY branch_name_and_level[1] DESC

infrahub/database/__init__.py

@@ -39,7 +39,7 @@ if TYPE_CHECKING:
     from types import TracebackType
 
     from infrahub.core.branch import Branch
-    from infrahub.core.schema import MainSchemaTypes, NodeSchema
+    from infrahub.core.schema import GenericSchema, MainSchemaTypes, NodeSchema
     from infrahub.core.schema.schema_branch import SchemaBranch
 
 validated_database = {}
@@ -91,6 +91,15 @@ class DatabaseSchemaManager:
 
         raise ValueError("The selected node is not of type NodeSchema")
 
+    def get_generic_schema(
+        self, name: str, branch: Branch | str | None = None, duplicate: bool = True
+    ) -> GenericSchema:
+        schema = self.get(name=name, branch=branch, duplicate=duplicate)
+        if schema.is_generic_schema:
+            return schema
+
+        raise ValueError("The selected node is not of type GenericSchema")
+
     def set(self, name: str, schema: MainSchemaTypes, branch: str | None = None) -> int:
         branch_name = get_branch_name(branch=branch)
         if branch_name not in self._db._schemas:
@@ -284,7 +293,7 @@ class InfrahubDatabase:
         exc_type: type[BaseException] | None,
         exc_value: BaseException | None,
         traceback: TracebackType | None,
-    ):
+    ) -> None:
         if self._mode == InfrahubDatabaseMode.SESSION:
             return await self._session.close()
 
@@ -330,7 +339,7 @@ class InfrahubDatabase:
         CONNECTION_POOL_USAGE.labels(self._driver._pool.address).set(float(connpool_usage))
 
         if config.SETTINGS.database.max_concurrent_queries:
-            while connpool_usage > config.SETTINGS.database.max_concurrent_queries:  # noqa: ASYNC110
+            while connpool_usage > config.SETTINGS.database.max_concurrent_queries:
                 await asyncio.sleep(config.SETTINGS.database.max_concurrent_queries_delay)
                 connpool_usage = self._driver._pool.in_use_connection_count(self._driver._pool.address)
 
@@ -489,7 +498,6 @@ async def get_db(retry: int = 0) -> AsyncDriver:
         trusted_certificates=trusted_certificates,
         notifications_disabled_categories=[
             NotificationDisabledCategory.UNRECOGNIZED,
-            NotificationDisabledCategory.DEPRECATION,  # TODO: Remove me with 1.3
         ],
         notifications_min_severity=NotificationMinimumSeverity.WARNING,
     )

infrahub/database/validation.py

@@ -65,8 +65,7 @@ WITH DISTINCT n, delete_branch, delete_time, added_e, peer AS added_peer
 // ------------
 // get the branched_from for the branch on which the node was deleted
 // ------------
-CALL {
-    WITH added_e
+CALL (added_e) {
     MATCH (b:Branch {name: added_e.branch})
     RETURN b.branched_from AS added_e_branched_from
 }

infrahub/dependencies/builder/constraint/grouped/node_runner.py

@@ -4,6 +4,8 @@ from infrahub.dependencies.interface import DependencyBuilder, DependencyBuilder
 from ..node.grouped_uniqueness import NodeGroupedUniquenessConstraintDependency
 from ..relationship_manager.count import RelationshipCountConstraintDependency
 from ..relationship_manager.peer_kind import RelationshipPeerKindConstraintDependency
+from ..relationship_manager.peer_parent import RelationshipPeerParentConstraintDependency
+from ..relationship_manager.peer_relatives import RelationshipPeerRelativesConstraintDependency
 from ..relationship_manager.profiles_kind import RelationshipProfilesKindConstraintDependency
 
 
@@ -18,5 +20,7 @@ class NodeConstraintRunnerDependency(DependencyBuilder[NodeConstraintRunner]):
                 RelationshipPeerKindConstraintDependency.build(context=context),
                 RelationshipCountConstraintDependency.build(context=context),
                 RelationshipProfilesKindConstraintDependency.build(context=context),
+                RelationshipPeerParentConstraintDependency.build(context=context),
+                RelationshipPeerRelativesConstraintDependency.build(context=context),
             ],
         )

infrahub/dependencies/builder/constraint/relationship_manager/peer_parent.py

@@ -0,0 +1,8 @@
+from infrahub.core.relationship.constraints.peer_parent import RelationshipPeerParentConstraint
+from infrahub.dependencies.interface import DependencyBuilder, DependencyBuilderContext
+
+
+class RelationshipPeerParentConstraintDependency(DependencyBuilder[RelationshipPeerParentConstraint]):
+    @classmethod
+    def build(cls, context: DependencyBuilderContext) -> RelationshipPeerParentConstraint:
+        return RelationshipPeerParentConstraint(db=context.db, branch=context.branch)

infrahub/dependencies/builder/constraint/relationship_manager/peer_relatives.py

@@ -0,0 +1,8 @@
+from infrahub.core.relationship.constraints.peer_relatives import RelationshipPeerRelativesConstraint
+from infrahub.dependencies.interface import DependencyBuilder, DependencyBuilderContext
+
+
+class RelationshipPeerRelativesConstraintDependency(DependencyBuilder[RelationshipPeerRelativesConstraint]):
+    @classmethod
+    def build(cls, context: DependencyBuilderContext) -> RelationshipPeerRelativesConstraint:
+        return RelationshipPeerRelativesConstraint(db=context.db, branch=context.branch)

infrahub/dependencies/builder/constraint/schema/aggregated.py

@@ -14,6 +14,7 @@ from .node_attribute import SchemaNodeAttributeAddConstraintDependency
 from .node_relationship import SchemaNodeRelationshipAddConstraintDependency
 from .relationship_count import SchemaRelationshipCountConstraintDependency
 from .relationship_optional import SchemaRelationshipOptionalConstraintDependency
+from .relationship_peer import SchemaRelationshipPeerParentConstraintDependency
 from .uniqueness import SchemaUniquenessConstraintDependency
 
 
@@ -36,6 +37,7 @@ class AggregatedSchemaConstraintsDependency(DependencyBuilder[AggregatedConstrai
                 SchemaAttributeKindConstraintDependency.build(context=context),
                 SchemaNodeAttributeAddConstraintDependency.build(context=context),
                 SchemaNodeRelationshipAddConstraintDependency.build(context=context),
+                SchemaRelationshipPeerParentConstraintDependency.build(context=context),
             ],
             db=context.db,
             branch=context.branch,

infrahub/dependencies/builder/constraint/schema/relationship_peer.py

@@ -0,0 +1,8 @@
+from infrahub.core.validators.relationship.peer import RelationshipPeerParentChecker
+from infrahub.dependencies.interface import DependencyBuilder, DependencyBuilderContext
+
+
+class SchemaRelationshipPeerParentConstraintDependency(DependencyBuilder[RelationshipPeerParentChecker]):
+    @classmethod
+    def build(cls, context: DependencyBuilderContext) -> RelationshipPeerParentChecker:
+        return RelationshipPeerParentChecker(db=context.db, branch=context.branch)

infrahub/dependencies/builder/diff/deserializer.py

@@ -6,5 +6,5 @@ from .parent_node_adder import DiffParentNodeAdderDependency
 
 class DiffDeserializerDependency(DependencyBuilder[EnrichedDiffDeserializer]):
     @classmethod
-    def build(cls, context: DependencyBuilderContext) -> EnrichedDiffDeserializer:  # noqa: ARG003
+    def build(cls, context: DependencyBuilderContext) -> EnrichedDiffDeserializer:
         return EnrichedDiffDeserializer(parent_adder=DiffParentNodeAdderDependency.build(context=context))

infrahub/dependencies/registry.py

@@ -3,6 +3,8 @@ from .builder.constraint.node.grouped_uniqueness import NodeGroupedUniquenessCon
 from .builder.constraint.node.uniqueness import NodeAttributeUniquenessConstraintDependency
 from .builder.constraint.relationship_manager.count import RelationshipCountConstraintDependency
 from .builder.constraint.relationship_manager.peer_kind import RelationshipPeerKindConstraintDependency
+from .builder.constraint.relationship_manager.peer_parent import RelationshipPeerParentConstraintDependency
+from .builder.constraint.relationship_manager.peer_relatives import RelationshipPeerRelativesConstraintDependency
 from .builder.constraint.relationship_manager.profiles_kind import RelationshipProfilesKindConstraintDependency
 from .builder.constraint.schema.aggregated import AggregatedSchemaConstraintsDependency
 from .builder.constraint.schema.attribute_regex import SchemaAttributeRegexConstraintDependency
@@ -37,6 +39,8 @@ def build_component_registry() -> ComponentDependencyRegistry:
     component_registry.track_dependency(RelationshipCountConstraintDependency)
     component_registry.track_dependency(RelationshipProfilesKindConstraintDependency)
     component_registry.track_dependency(RelationshipPeerKindConstraintDependency)
+    component_registry.track_dependency(RelationshipPeerParentConstraintDependency)
+    component_registry.track_dependency(RelationshipPeerRelativesConstraintDependency)
     component_registry.track_dependency(NodeConstraintRunnerDependency)
     component_registry.track_dependency(NodeDeleteValidatorDependency)
     component_registry.track_dependency(IpamKindsGetterDependency)

infrahub/events/group_action.py

@@ -89,6 +89,7 @@ class GroupMutatedEvent(InfrahubEvent):
             "infrahub.node.id": self.node_id,
             "infrahub.node.action": self.action.value,
             "infrahub.node.root_id": self.node_id,
+            "infrahub.branch.name": self.meta.context.branch.name,
         }
 
 

infrahub/events/models.py

@@ -8,7 +8,7 @@ from pydantic import BaseModel, Field, PrivateAttr, model_validator
 
 from infrahub import __version__
 from infrahub.auth import AccountSession, AuthType
-from infrahub.context import InfrahubContext  # noqa: TC001
+from infrahub.context import InfrahubContext
 from infrahub.core.branch import Branch  # noqa: TC001
 from infrahub.message_bus import InfrahubMessage, Meta
 from infrahub.worker import WORKER_IDENTITY

infrahub/git/base.py

@@ -162,6 +162,11 @@ class InfrahubRepositoryBase(BaseModel, ABC):
     infrahub_branch_name: str | None = Field(None, description="Infrahub branch on which to sync the remote repository")
     model_config = ConfigDict(arbitrary_types_allowed=True, ignored_types=(Flow, Task))
 
+    def get_client(self) -> InfrahubClient:
+        if self.client is None:
+            raise ValueError("Client is not set")
+        return self.client
+
     @property
     def sdk(self) -> InfrahubClient:
         if self.client:
@@ -445,9 +450,6 @@ class InfrahubRepositoryBase(BaseModel, ABC):
 
         return [Worktree.init(response) for response in responses]
 
-    def get_client(self) -> InfrahubClient:
-        return self.sdk
-
     def get_location(self) -> str:
         if self.location:
             return self.location

infrahub/git/integrator.py

@@ -29,10 +29,12 @@ from infrahub_sdk.schema.repository import (
     InfrahubPythonTransformConfig,
     InfrahubRepositoryConfig,
 )
+from infrahub_sdk.spec.menu import MenuFile
+from infrahub_sdk.spec.object import ObjectFile
 from infrahub_sdk.template import Jinja2Template
 from infrahub_sdk.template.exceptions import JinjaTemplateError
 from infrahub_sdk.utils import compare_lists
-from infrahub_sdk.yaml import SchemaFile
+from infrahub_sdk.yaml import InfrahubFile, SchemaFile
 from prefect import flow, task
 from prefect.cache_policies import NONE
 from prefect.logging import get_run_logger
@@ -40,7 +42,7 @@ from pydantic import BaseModel, Field
 from pydantic import ValidationError as PydanticValidationError
 from typing_extensions import Self
 
-from infrahub.core.constants import ArtifactStatus, ContentType, InfrahubKind, RepositorySyncStatus
+from infrahub.core.constants import ArtifactStatus, ContentType, InfrahubKind, RepositoryObjects, RepositorySyncStatus
 from infrahub.core.registry import registry
 from infrahub.events.artifact_action import ArtifactCreatedEvent, ArtifactUpdatedEvent
 from infrahub.events.models import EventMeta
@@ -54,6 +56,7 @@ if TYPE_CHECKING:
     import types
 
     from infrahub_sdk.checks import InfrahubCheck
+    from infrahub_sdk.ctl.utils import YamlFileVar
     from infrahub_sdk.schema.repository import InfrahubRepositoryArtifactDefinitionConfig
     from infrahub_sdk.transforms import InfrahubTransform
 
@@ -159,7 +162,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
     async def ensure_location_is_defined(self) -> None:
         if self.location:
             return
-        client = self.get_client()
+        client = self.sdk
         repo = await client.get(
             kind=CoreGenericRepository, name__value=self.name, exclude=["tags", "credential"], raise_when_missing=True
         )
@@ -179,16 +182,20 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
 
         config_file = await self.get_repository_config(branch_name=infrahub_branch_name, commit=commit)  # type: ignore[misc]
         sync_status = RepositorySyncStatus.IN_SYNC if config_file else RepositorySyncStatus.ERROR_IMPORT
+
         error: Exception | None = None
 
         try:
             if config_file:
                 await self.import_schema_files(branch_name=infrahub_branch_name, commit=commit, config_file=config_file)  # type: ignore[misc]
-
                 await self.import_all_graphql_query(
                     branch_name=infrahub_branch_name, commit=commit, config_file=config_file
                 )  # type: ignore[misc]
-
+                await self.import_objects(
+                    branch_name=infrahub_branch_name,
+                    commit=commit,
+                    config_file=config_file,
+                )  # type: ignore[misc]
                 await self.import_all_python_files(  # type: ignore[call-overload]
                     branch_name=infrahub_branch_name, commit=commit, config_file=config_file
                 )  # type: ignore[misc]
@@ -815,6 +822,80 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
             log.info(f"TransformPython {transform_name!r} not found locally, deleting")
             await transform_definition_in_graph[transform_name].delete()
 
+    async def _load_yamlfile_from_disk(self, paths: list[Path], file_type: type[YamlFileVar]) -> list[YamlFileVar]:
+        data_files = file_type.load_from_disk(paths=paths)
+
+        for data_file in data_files:
+            if not data_file.valid or not data_file.content:
+                raise ValueError(f"{data_file.error_message} ({data_file.location})")
+
+        return data_files
+
+    async def _load_objects(
+        self,
+        paths: list[Path],
+        branch: str,
+        file_type: type[InfrahubFile],
+    ) -> None:
+        """Load one or multiple objects files into Infrahub."""
+
+        log = get_run_logger()
+        files = await self._load_yamlfile_from_disk(paths=paths, file_type=file_type)
+
+        for file in files:
+            await file.validate_format(client=self.sdk, branch=branch)
+            schema = await self.sdk.schema.get(kind=file.spec.kind, branch=branch)
+            if not schema.human_friendly_id and not schema.default_filter:
+                raise ValueError(
+                    f"Schemas of objects or menus defined within {file.location} "
+                    "should have a `human_friendly_id` defined to avoid creating duplicated objects."
+                )
+
+        for file in files:
+            log.info(f"Loading objects defined in {file.location}")
+            await file.process(client=self.sdk, branch=branch)
+
+    async def _import_file_paths(
+        self, branch_name: str, commit: str, files_pathes: list[Path], object_type: RepositoryObjects
+    ) -> None:
+        branch_wt = self.get_worktree(identifier=commit or branch_name)
+        file_pathes = [branch_wt.directory / file_path for file_path in files_pathes]
+
+        # We currently assume there can't be concurrent imports, but if so, we might need to clone the client before tracking here.
+        async with self.sdk.start_tracking(
+            identifier=f"group-repo-{object_type.value}-{self.id}",
+            delete_unused_nodes=True,
+            branch=branch_name,
+            group_type="CoreRepositoryGroup",
+            group_params={"content": object_type.value, "repository": str(self.id)},
+        ):
+            file_type = repo_object_type_to_file_type(object_type)
+            await self._load_objects(
+                paths=file_pathes,
+                branch=branch_name,
+                file_type=file_type,
+            )
+
+    @task(name="import-objects", task_run_name="Import Objects", cache_policy=NONE)  # type: ignore[arg-type]
+    async def import_objects(
+        self,
+        branch_name: str,
+        commit: str,
+        config_file: InfrahubRepositoryConfig,
+    ) -> None:
+        await self._import_file_paths(
+            branch_name=branch_name,
+            commit=commit,
+            files_pathes=config_file.objects,
+            object_type=RepositoryObjects.OBJECT,
+        )
+        await self._import_file_paths(
+            branch_name=branch_name,
+            commit=commit,
+            files_pathes=config_file.menus,
+            object_type=RepositoryObjects.MENU,
+        )
+
     @task(name="check-definition-get", task_run_name="Get Check Definition", cache_policy=NONE)  # type: ignore[arg-type]
     async def get_check_definition(
         self,
@@ -1342,3 +1423,13 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
 
         await self.service.event.send(event=event)
         return ArtifactGenerateResult(changed=True, checksum=checksum, storage_id=storage_id, artifact_id=artifact.id)
+
+
+def repo_object_type_to_file_type(repo_object: RepositoryObjects) -> type[InfrahubFile]:
+    match repo_object:
+        case RepositoryObjects.OBJECT:
+            return ObjectFile
+        case RepositoryObjects.MENU:
+            return MenuFile
+        case _:
+            raise ValueError(f"Unknown repository object type: {repo_object}")

infrahub/git/tasks.py

@@ -696,6 +696,7 @@ async def trigger_internal_checks(
         if (
             existing_validator.typename == InfrahubKind.REPOSITORYVALIDATOR
             and existing_validator.repository.id == model.repository
+            and existing_validator.label.value == validator_name
         ):
             previous_validator = existing_validator