infrahub-server 1.3.0a0__py3-none-any.whl → 1.3.0b1__py3-none-any.whl

infrahub/core/schema/schema_branch.py

@@ -5,6 +5,7 @@ import hashlib
 from collections import defaultdict
 from itertools import chain, combinations
 from typing import Any
+from uuid import uuid4
 
 from infrahub_sdk.template import Jinja2Template
 from infrahub_sdk.template.exceptions import JinjaTemplateError, JinjaTemplateOperationViolationError
@@ -49,6 +50,7 @@ from infrahub.core.schema import (
     SchemaRoot,
     TemplateSchema,
 )
+from infrahub.core.schema.attribute_parameters import NumberPoolParameters
 from infrahub.core.schema.attribute_schema import get_attribute_schema_class_for_kind
 from infrahub.core.schema.definitions.core import core_profile_schema_definition
 from infrahub.core.validators import CONSTRAINT_VALIDATOR_MAP
@@ -518,6 +520,7 @@ class SchemaBranch:
         self.validate_names()
         self.validate_kinds()
         self.validate_computed_attributes()
+        self.validate_attribute_parameters()
         self.validate_default_values()
         self.validate_count_against_cardinality()
         self.validate_identifiers()
@@ -995,6 +998,58 @@ class SchemaBranch:
                         f"{node.kind}: Relationship {rel.name!r} is referring an invalid peer {rel.peer!r}"
                     ) from None
 
+    def validate_attribute_parameters(self) -> None:
+        for name in self.generics.keys():
+            generic_schema = self.get_generic(name=name, duplicate=False)
+            for attribute in generic_schema.attributes:
+                if (
+                    attribute.kind == "NumberPool"
+                    and isinstance(attribute.parameters, NumberPoolParameters)
+                    and not attribute.parameters.number_pool_id
+                ):
+                    attribute.parameters.number_pool_id = str(uuid4())
+
+        for name in self.nodes.keys():
+            node_schema = self.get_node(name=name, duplicate=False)
+            for attribute in node_schema.attributes:
+                if (
+                    attribute.kind == "NumberPool"
+                    and isinstance(attribute.parameters, NumberPoolParameters)
+                    and not attribute.parameters.number_pool_id
+                ):
+                    self._validate_number_pool_parameters(
+                        node_schema=node_schema, attribute=attribute, number_pool_parameters=attribute.parameters
+                    )
+
+    def _validate_number_pool_parameters(
+        self, node_schema: NodeSchema, attribute: AttributeSchema, number_pool_parameters: NumberPoolParameters
+    ) -> None:
+        if attribute.optional:
+            raise ValidationError(f"{node_schema.kind}.{attribute.name} is a NumberPool it can't be optional")
+
+        if not attribute.read_only:
+            raise ValidationError(
+                f"{node_schema.kind}.{attribute.name} is a NumberPool it has to be a read_only attribute"
+            )
+
+        if attribute.inherited:
+            generics_with_attribute = []
+            for generic_name in node_schema.inherit_from:
+                generic_schema = self.get_generic(name=generic_name, duplicate=False)
+                if attribute.name in generic_schema.attribute_names:
+                    generic_attribute = generic_schema.get_attribute(name=attribute.name)
+                    generics_with_attribute.append(generic_schema)
+                    if isinstance(generic_attribute.parameters, NumberPoolParameters):
+                        number_pool_parameters.number_pool_id = generic_attribute.parameters.number_pool_id
+
+            if len(generics_with_attribute) > 1:
+                raise ValidationError(
+                    f"{node_schema.kind}.{attribute.name} is a NumberPool inherited from more than one generic"
+                )
+
+        else:
+            number_pool_parameters.number_pool_id = str(uuid4())
+
     def validate_computed_attributes(self) -> None:
         self.computed_attributes = ComputedAttributes()
         for name in self.nodes.keys():

infrahub/core/validators/__init__.py

@@ -1,7 +1,10 @@
+from infrahub.core.validators.attribute.min_max import AttributeNumberChecker
+
 from .attribute.choices import AttributeChoicesChecker
 from .attribute.enum import AttributeEnumChecker
 from .attribute.kind import AttributeKindChecker
 from .attribute.length import AttributeLengthChecker
+from .attribute.number_pool import AttributeNumberPoolChecker
 from .attribute.optional import AttributeOptionalChecker
 from .attribute.regex import AttributeRegexChecker
 from .attribute.unique import AttributeUniquenessChecker
@@ -26,6 +29,11 @@ CONSTRAINT_VALIDATOR_MAP: dict[str, type[ConstraintCheckerInterface] | None] = {
     "attribute.max_length.update": AttributeLengthChecker,
     ConstraintIdentifier.ATTRIBUTE_PARAMETERS_MIN_LENGTH_UPDATE.value: AttributeLengthChecker,
     ConstraintIdentifier.ATTRIBUTE_PARAMETERS_MAX_LENGTH_UPDATE.value: AttributeLengthChecker,
+    ConstraintIdentifier.ATTRIBUTE_PARAMETERS_MIN_VALUE_UPDATE.value: AttributeNumberChecker,
+    ConstraintIdentifier.ATTRIBUTE_PARAMETERS_MAX_VALUE_UPDATE.value: AttributeNumberChecker,
+    ConstraintIdentifier.ATTRIBUTE_PARAMETERS_EXCLUDED_VALUES_UPDATE.value: AttributeNumberChecker,
+    ConstraintIdentifier.ATTRIBUTE_PARAMETERS_START_RANGE_UPDATE: AttributeNumberPoolChecker,
+    ConstraintIdentifier.ATTRIBUTE_PARAMETERS_END_RANGE_UPDATE: AttributeNumberPoolChecker,
     "attribute.unique.update": AttributeUniquenessChecker,
     "attribute.optional.update": AttributeOptionalChecker,
     "attribute.choices.update": AttributeChoicesChecker,

infrahub/core/validators/attribute/choices.py

@@ -42,7 +42,6 @@ class AttributeChoicesUpdateValidatorQuery(AttributeSchemaValidatorQuery):
             LIMIT 1
         }
         WITH full_path, node, attribute_value, value_relationship
-        WITH full_path, node, attribute_value, value_relationship
         WHERE all(r in relationships(full_path) WHERE r.status = "active")
         AND attribute_value IS NOT NULL
         AND attribute_value <> $null_value

infrahub/core/validators/attribute/enum.py

@@ -41,7 +41,6 @@ class AttributeEnumUpdateValidatorQuery(AttributeSchemaValidatorQuery):
             LIMIT 1
         }
         WITH full_path, node, attribute_value, value_relationship
-        WITH full_path, node, attribute_value, value_relationship
         WHERE all(r in relationships(full_path) WHERE r.status = "active")
         AND attribute_value IS NOT NULL
         AND attribute_value <> $null_value

infrahub/core/validators/attribute/kind.py

@@ -48,7 +48,6 @@ class AttributeKindUpdateValidatorQuery(AttributeSchemaValidatorQuery):
             LIMIT 1
         }
         WITH full_path, node, attribute_value, value_relationship
-        WITH full_path, node, attribute_value, value_relationship
         WHERE all(r in relationships(full_path) WHERE r.status = "active")
         AND attribute_value IS NOT NULL
         AND attribute_value <> $null_value

infrahub/core/validators/attribute/length.py

@@ -40,7 +40,6 @@ class AttributeLengthUpdateValidatorQuery(AttributeSchemaValidatorQuery):
             LIMIT 1
         }
         WITH full_path, node, attribute_value, value_relationship
-        WITH full_path, node, attribute_value, value_relationship
         WHERE all(r in relationships(full_path) WHERE r.status = "active")
         AND (
             (toInteger($min_length) IS NOT NULL AND size(attribute_value) < toInteger($min_length))

infrahub/core/validators/attribute/min_max.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from infrahub.core.constants import PathType
+from infrahub.core.path import DataPath, GroupedDataPaths
+from infrahub.core.schema.attribute_parameters import NumberAttributeParameters
+from infrahub.core.validators.enum import ConstraintIdentifier
+
+from ..interface import ConstraintCheckerInterface
+from ..shared import AttributeSchemaValidatorQuery
+
+if TYPE_CHECKING:
+    from infrahub.core.branch import Branch
+    from infrahub.database import InfrahubDatabase
+
+    from ..model import SchemaConstraintValidatorRequest
+
+
+class AttributeNumberUpdateValidatorQuery(AttributeSchemaValidatorQuery):
+    name: str = "attribute_constraints_number_validator"
+
+    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())
+        self.params.update(branch_params)
+
+        if not isinstance(self.attribute_schema.parameters, NumberAttributeParameters):
+            raise ValueError("attribute parameters are not a NumberAttributeParameters")
+
+        self.params["attr_name"] = self.attribute_schema.name
+        self.params["min_value"] = self.attribute_schema.parameters.min_value
+        self.params["max_value"] = self.attribute_schema.parameters.max_value
+        self.params["excluded_values"] = self.attribute_schema.parameters.get_excluded_single_values()
+        self.params["excluded_ranges"] = self.attribute_schema.parameters.get_excluded_ranges()
+
+        query = """
+        MATCH (n:%(node_kind)s)
+        CALL (n) {
+            MATCH path = (root:Root)<-[rr:IS_PART_OF]-(n)-[ra:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name } )-[rv:HAS_VALUE]-(av:AttributeValue)
+            WHERE all(
+                r in relationships(path)
+                WHERE %(branch_filter)s
+            )
+            RETURN path as full_path, n as node, rv as value_relationship, av.value as attribute_value
+            ORDER BY rv.branch_level DESC, ra.branch_level DESC, rr.branch_level DESC, rv.from DESC, ra.from DESC, rr.from DESC
+            LIMIT 1
+        }
+        WITH full_path, node, attribute_value, value_relationship
+        WHERE all(r in relationships(full_path) WHERE r.status = "active")
+        AND (
+            (toInteger($min_value) IS NOT NULL AND attribute_value < toInteger($min_value))
+            OR (toInteger($max_value) IS NOT NULL AND attribute_value > toInteger($max_value))
+            OR (size($excluded_values) > 0 AND attribute_value IN $excluded_values)
+            OR (size($excluded_ranges) > 0 AND any(range in $excluded_ranges WHERE attribute_value >= range[0] AND attribute_value <= range[1]))
+        )
+        """ % {"branch_filter": branch_filter, "node_kind": self.node_schema.kind}
+
+        self.add_to_query(query)
+        self.return_labels = ["node.uuid", "value_relationship", "attribute_value"]
+
+    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("value_relationship").get("branch")),
+                    path_type=PathType.ATTRIBUTE,
+                    node_id=str(result.get("node.uuid")),
+                    field_name=self.attribute_schema.name,
+                    kind=self.node_schema.kind,
+                    value=result.get("attribute_value"),
+                ),
+            )
+
+        return grouped_data_paths
+
+
+class AttributeNumberChecker(ConstraintCheckerInterface):
+    query_classes = [AttributeNumberUpdateValidatorQuery]
+
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
+        self.db = db
+        self.branch = branch
+
+    @property
+    def name(self) -> str:
+        return "attribute.number.update"
+
+    def supports(self, request: SchemaConstraintValidatorRequest) -> bool:
+        return request.constraint_name in (
+            ConstraintIdentifier.ATTRIBUTE_PARAMETERS_MIN_VALUE_UPDATE.value,
+            ConstraintIdentifier.ATTRIBUTE_PARAMETERS_MAX_VALUE_UPDATE.value,
+            ConstraintIdentifier.ATTRIBUTE_PARAMETERS_EXCLUDED_VALUES_UPDATE.value,
+        )
+
+    async def check(self, request: SchemaConstraintValidatorRequest) -> list[GroupedDataPaths]:
+        grouped_data_paths_list: list[GroupedDataPaths] = []
+        if not request.schema_path.field_name:
+            raise ValueError("field_name is not defined")
+        attribute_schema = request.node_schema.get_attribute(name=request.schema_path.field_name)
+        if not isinstance(attribute_schema.parameters, NumberAttributeParameters):
+            raise ValueError("attribute parameters are not a NumberAttributeParameters")
+
+        if (
+            attribute_schema.parameters.min_value is None
+            and attribute_schema.parameters.max_value is None
+            and attribute_schema.parameters.excluded_values is None
+        ):
+            return grouped_data_paths_list
+
+        for query_class in self.query_classes:
+            # TODO add exception handling
+            query = await query_class.init(
+                db=self.db, branch=self.branch, node_schema=request.node_schema, schema_path=request.schema_path
+            )
+            await query.execute(db=self.db)
+            grouped_data_paths_list.append(await query.get_paths())
+        return grouped_data_paths_list

infrahub/core/validators/attribute/number_pool.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from infrahub.core.constants import PathType
+from infrahub.core.path import DataPath, GroupedDataPaths
+from infrahub.core.schema.attribute_parameters import NumberPoolParameters
+from infrahub.core.validators.enum import ConstraintIdentifier
+
+from ..interface import ConstraintCheckerInterface
+from ..shared import AttributeSchemaValidatorQuery
+
+if TYPE_CHECKING:
+    from infrahub.core.branch import Branch
+    from infrahub.database import InfrahubDatabase
+
+    from ..model import SchemaConstraintValidatorRequest
+
+
+class AttributeNumberPoolUpdateValidatorQuery(AttributeSchemaValidatorQuery):
+    name: str = "attribute_constraints_numberpool_validator"
+
+    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())
+        self.params.update(branch_params)
+
+        if not isinstance(self.attribute_schema.parameters, NumberPoolParameters):
+            raise ValueError("attribute parameters are not a NumberPoolParameters")
+
+        self.params["attr_name"] = self.attribute_schema.name
+        self.params["start_range"] = self.attribute_schema.parameters.start_range
+        self.params["end_range"] = self.attribute_schema.parameters.end_range
+
+        query = """
+        MATCH (n:%(node_kind)s)
+        CALL (n) {
+            MATCH path = (root:Root)<-[rr:IS_PART_OF]-(n)-[ra:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name } )-[rv:HAS_VALUE]-(av:AttributeValue)
+            WHERE all(
+                r in relationships(path)
+                WHERE %(branch_filter)s
+            )
+            RETURN path as full_path, n as node, rv as value_relationship, av.value as attribute_value
+            ORDER BY rv.branch_level DESC, ra.branch_level DESC, rr.branch_level DESC, rv.from DESC, ra.from DESC, rr.from DESC
+            LIMIT 1
+        }
+        WITH full_path, node, attribute_value, value_relationship
+        WHERE all(r in relationships(full_path) WHERE r.status = "active")
+        AND (
+            (toInteger($start_range) IS NOT NULL AND attribute_value < toInteger($start_range))
+            OR (toInteger($end_range) IS NOT NULL AND attribute_value > toInteger($end_range))
+        )
+        """ % {"branch_filter": branch_filter, "node_kind": self.node_schema.kind}
+
+        self.add_to_query(query)
+        self.return_labels = ["node.uuid", "value_relationship", "attribute_value"]
+
+    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("value_relationship").get("branch")),
+                    path_type=PathType.ATTRIBUTE,
+                    node_id=str(result.get("node.uuid")),
+                    field_name=self.attribute_schema.name,
+                    kind=self.node_schema.kind,
+                    value=result.get("attribute_value"),
+                ),
+            )
+
+        return grouped_data_paths
+
+
+class AttributeNumberPoolChecker(ConstraintCheckerInterface):
+    query_classes = [AttributeNumberPoolUpdateValidatorQuery]
+
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
+        self.db = db
+        self.branch = branch
+
+    @property
+    def name(self) -> str:
+        return "attribute.number.update"
+
+    def supports(self, request: SchemaConstraintValidatorRequest) -> bool:
+        return request.constraint_name in (
+            ConstraintIdentifier.ATTRIBUTE_PARAMETERS_START_RANGE_UPDATE.value,
+            ConstraintIdentifier.ATTRIBUTE_PARAMETERS_END_RANGE_UPDATE.value,
+        )
+
+    async def check(self, request: SchemaConstraintValidatorRequest) -> list[GroupedDataPaths]:
+        grouped_data_paths_list: list[GroupedDataPaths] = []
+        if not request.schema_path.field_name:
+            raise ValueError("field_name is not defined")
+        attribute_schema = request.node_schema.get_attribute(name=request.schema_path.field_name)
+        if not isinstance(attribute_schema.parameters, NumberPoolParameters):
+            raise ValueError("attribute parameters are not a NumberPoolParameters")
+
+        for query_class in self.query_classes:
+            # TODO add exception handling
+            query = await query_class.init(
+                db=self.db, branch=self.branch, node_schema=request.node_schema, schema_path=request.schema_path
+            )
+            await query.execute(db=self.db)
+            grouped_data_paths_list.append(await query.get_paths())
+        return grouped_data_paths_list

infrahub/core/validators/attribute/optional.py

@@ -38,7 +38,6 @@ class AttributeOptionalUpdateValidatorQuery(AttributeSchemaValidatorQuery):
             LIMIT 1
         }
         WITH full_path, node, attribute_value, value_relationship
-        WITH full_path, node, attribute_value, value_relationship
         WHERE all(r in relationships(full_path) WHERE r.status = "active")
         AND (attribute_value IS NULL OR attribute_value = $null_value)
         """ % {"branch_filter": branch_filter, "node_kind": self.node_schema.kind}
@@ -85,7 +84,6 @@ class AttributeOptionalChecker(ConstraintCheckerInterface):
             return grouped_data_paths_list
 
         for query_class in self.query_classes:
-            # TODO add exception handling
             query = await query_class.init(
                 db=self.db, branch=self.branch, node_schema=request.node_schema, schema_path=request.schema_path
             )

infrahub/core/validators/attribute/regex.py

@@ -39,7 +39,6 @@ class AttributeRegexUpdateValidatorQuery(AttributeSchemaValidatorQuery):
             LIMIT 1
         }
         WITH full_path, node, attribute_value, value_relationship
-        WITH full_path, node, attribute_value, value_relationship
         WHERE all(r in relationships(full_path) WHERE r.status = "active")
         AND attribute_value <> $null_value
         AND NOT attribute_value =~ $attr_value_regex

infrahub/core/validators/enum.py

@@ -5,3 +5,8 @@ class ConstraintIdentifier(str, Enum):
     ATTRIBUTE_PARAMETERS_REGEX_UPDATE = "attribute.parameters.regex.update"
     ATTRIBUTE_PARAMETERS_MIN_LENGTH_UPDATE = "attribute.parameters.min_length.update"
     ATTRIBUTE_PARAMETERS_MAX_LENGTH_UPDATE = "attribute.parameters.max_length.update"
+    ATTRIBUTE_PARAMETERS_MIN_VALUE_UPDATE = "attribute.parameters.min_value.update"
+    ATTRIBUTE_PARAMETERS_MAX_VALUE_UPDATE = "attribute.parameters.max_value.update"
+    ATTRIBUTE_PARAMETERS_EXCLUDED_VALUES_UPDATE = "attribute.parameters.excluded_values.update"
+    ATTRIBUTE_PARAMETERS_END_RANGE_UPDATE = "attribute.parameters.end_range.update"
+    ATTRIBUTE_PARAMETERS_START_RANGE_UPDATE = "attribute.parameters.start_range.update"

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()
 
@@ -487,7 +496,10 @@ async def get_db(retry: int = 0) -> AsyncDriver:
         auth=(config.SETTINGS.database.username, config.SETTINGS.database.password),
         encrypted=config.SETTINGS.database.tls_enabled,
         trusted_certificates=trusted_certificates,
-        notifications_disabled_categories=[NotificationDisabledCategory.UNRECOGNIZED],
+        notifications_disabled_categories=[
+            NotificationDisabledCategory.UNRECOGNIZED,
+            NotificationDisabledCategory.DEPRECATION,  # TODO: Remove me with 1.3
+        ],
         notifications_min_severity=NotificationMinimumSeverity.WARNING,
     )
 

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,6 +182,7 @@ 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:
@@ -189,6 +193,17 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
                     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_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 +830,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 +1431,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}")