infrahub-server 1.5.5__py3-none-any.whl → 1.6.0__py3-none-any.whl

infrahub/core/node/ipam.py

@@ -40,8 +40,8 @@ class BuiltinIPPrefix(Node):
                     retrieved = await NodeManager.get_one(
                         db=db, branch=self._branch, id=self.id, fields={"member_type": None, "prefix": None}
                     )
-                    self.member_type = retrieved.member_type  # type: ignore[union-attr]
-                    self.prefix = retrieved.prefix  # type: ignore[union-attr]
+                    self.member_type = retrieved.member_type  # type: ignore[attr-defined,union-attr]
+                    self.prefix = retrieved.prefix  # type: ignore[attr-defined,union-attr]
                 utilization_getter = PrefixUtilizationGetter(db=db, ip_prefixes=[self])
                 utilization = await utilization_getter.get_use_percentage(
                     ip_prefixes=[self], branch_names=[self._branch.name]
@@ -57,6 +57,6 @@ class BuiltinIPPrefix(Node):
             retrieved = await NodeManager.get_one(
                 db=db, branch=self._branch, id=self.id, fields={"member_type": None, "prefix": None}
             )
-            self.member_type = retrieved.member_type  # type: ignore[union-attr]
-            self.prefix = retrieved.prefix  # type: ignore[union-attr]
+            self.member_type = retrieved.member_type  # type: ignore[attr-defined,union-attr]
+            self.prefix = retrieved.prefix  # type: ignore[attr-defined,union-attr]
         return get_prefix_space(self)

infrahub/core/node/node_property_attribute.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from abc import abstractmethod
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Generic, TypeVar
+from typing import TYPE_CHECKING, Any, TypeVar
 
 from infrahub_sdk.template import Jinja2Template
 
@@ -21,7 +21,7 @@ if TYPE_CHECKING:
 T = TypeVar("T")
 
 
-class NodePropertyAttribute(Generic[T]):
+class NodePropertyAttribute[T]:
     """A node property attribute is a construct that seats between a property and an attribute.
 
     View it as a property, set at the node level but stored in the database as an attribute. It usually is something computed from other components of

infrahub/core/node/standard.py

@@ -72,7 +72,7 @@ class StandardNode(BaseModel):
         response: dict[str, Any] = {"id": self.uuid}
 
         for field_name in fields.keys():
-            if field_name in ["id"]:
+            if field_name == "id":
                 continue
             if field_name == "__typename":
                 response[field_name] = self.get_type()

infrahub/core/query/attribute.py

@@ -373,7 +373,7 @@ async def default_attribute_query_filter(
         if property_name not in [v.value for v in NodeProperty]:
             raise ValueError(f"filter {filter_name}: {filter_value}, {property_name} is not a valid property")
 
-        if property_attr not in ["id"]:
+        if property_attr != "id":
             raise ValueError(f"filter {filter_name}: {filter_value}, {property_attr} is supported")
 
         clean_filter_name = f"{property_name}_{property_attr}"

infrahub/core/query/branch.py

@@ -3,8 +3,10 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any
 
 from infrahub import config
+from infrahub.core.branch.enums import BranchStatus
 from infrahub.core.constants import GLOBAL_BRANCH_NAME
 from infrahub.core.query import Query, QueryType
+from infrahub.core.query.standard_node import StandardNodeGetListQuery
 
 if TYPE_CHECKING:
     from infrahub.database import InfrahubDatabase
@@ -146,3 +148,12 @@ class RebaseBranchDeleteRelationshipQuery(Query):
         self.add_to_query(query=query)
 
         self.params["ids"] = [db.to_database_id(id) for id in self.ids]
+
+
+class BranchNodeGetListQuery(StandardNodeGetListQuery):
+    def __init__(self, exclude_global: bool = False, **kwargs: Any) -> None:
+        self.raw_filter = f"n.status <> '{BranchStatus.DELETING.value}'"
+        if exclude_global:
+            self.raw_filter += f" AND n.name <> '{GLOBAL_BRANCH_NAME}'"
+
+        super().__init__(**kwargs)

infrahub/core/query/node.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import contextlib
 from collections import defaultdict
 from copy import copy
 from dataclasses import dataclass
@@ -12,6 +13,7 @@ from infrahub.core import registry
 from infrahub.core.constants import (
     GLOBAL_BRANCH_NAME,
     PROFILE_NODE_RELATIONSHIP_IDENTIFIER,
+    PROFILE_TEMPLATE_RELATIONSHIP_IDENTIFIER,
     AttributeDBNodeType,
     RelationshipDirection,
     RelationshipHierarchyDirection,
@@ -623,7 +625,8 @@ class NodeListGetAttributeQuery(Query):
 
     async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:  # noqa: ARG002
         self.params["ids"] = self.ids
-        self.params["profile_relationship_name"] = PROFILE_NODE_RELATIONSHIP_IDENTIFIER
+        self.params["profile_node_relationship_name"] = PROFILE_NODE_RELATIONSHIP_IDENTIFIER
+        self.params["profile_template_relationship_name"] = PROFILE_TEMPLATE_RELATIONSHIP_IDENTIFIER
 
         branch_filter, branch_params = self.branch.get_query_filter_path(
             at=self.at, branch_agnostic=self.branch_agnostic
@@ -632,7 +635,10 @@ class NodeListGetAttributeQuery(Query):
 
         query = """
         MATCH (n:Node) WHERE n.uuid IN $ids
-        WITH n, exists((n)-[:IS_RELATED]-(:Relationship {name: $profile_relationship_name})) AS might_use_profile
+        WITH n, (
+            exists((n)-[:IS_RELATED]-(:Relationship {name: $profile_node_relationship_name})) OR
+            exists((n)-[:IS_RELATED]-(:Relationship {name: $profile_template_relationship_name}))
+        ) AS might_use_profile
         MATCH (n)-[:HAS_ATTRIBUTE]-(a:Attribute)
         """
         if self.fields:
@@ -1134,10 +1140,8 @@ class NodeGetListQuery(Query):
             self._variables_to_track.append(variable)
 
     def _untrack_variable(self, variable: str) -> None:
-        try:
+        with contextlib.suppress(ValueError):
             self._variables_to_track.remove(variable)
-        except ValueError:
-            ...
 
     def _get_tracked_variables(self) -> list[str]:
         return self._variables_to_track

infrahub/core/query/standard_node.py

@@ -132,6 +132,7 @@ class StandardNodeGetItemQuery(Query):
 class StandardNodeGetListQuery(Query):
     name = "standard_node_list"
     type = QueryType.READ
+    raw_filter: str | None = None
 
     def __init__(
         self, node_class: StandardNode, ids: list[str] | None = None, node_name: str | None = None, **kwargs: Any
@@ -150,6 +151,8 @@ class StandardNodeGetListQuery(Query):
         if self.node_name:
             filters.append("n.name = $name")
             self.params["name"] = self.node_name
+        if self.raw_filter:
+            filters.append(self.raw_filter)
 
         where = ""
         if filters:

infrahub/core/relationship/model.py

@@ -912,6 +912,8 @@ class RelationshipManager:
         db: InfrahubDatabase,
         peer_type: type[PeerType],
         branch_agnostic: bool = ...,
+        include_source: bool = ...,
+        include_owner: bool = ...,
     ) -> Mapping[str, PeerType]: ...
 
     @overload
@@ -920,6 +922,8 @@ class RelationshipManager:
         db: InfrahubDatabase,
         peer_type: None = None,
         branch_agnostic: bool = ...,
+        include_source: bool = ...,
+        include_owner: bool = ...,
     ) -> Mapping[str, Node]: ...
 
     async def get_peers(
@@ -927,11 +931,18 @@ class RelationshipManager:
         db: InfrahubDatabase,
         peer_type: type[PeerType] | None = None,  # noqa: ARG002
         branch_agnostic: bool = False,
+        include_source: bool = False,
+        include_owner: bool = False,
     ) -> Mapping[str, Node | PeerType]:
         rels = await self.get_relationships(db=db, branch_agnostic=branch_agnostic)
         peer_ids = [rel.peer_id for rel in rels if rel.peer_id]
         nodes = await registry.manager.get_many(
-            db=db, ids=peer_ids, branch=self.branch, branch_agnostic=branch_agnostic
+            db=db,
+            ids=peer_ids,
+            branch=self.branch,
+            branch_agnostic=branch_agnostic,
+            include_source=include_source,
+            include_owner=include_owner,
         )
         return nodes
 
@@ -1061,12 +1072,7 @@ class RelationshipManager:
 
         return self._relationships.as_list()
 
-    async def update(
-        self,
-        data: list[str | Node] | dict[str, Any] | str | Node | None,
-        db: InfrahubDatabase,
-        process_delete: bool = True,
-    ) -> bool:
+    async def update(self, data: list[str | Node] | dict[str, Any] | str | Node | None, db: InfrahubDatabase) -> bool:
         """Replace and Update the list of relationships with this one."""
         if not isinstance(data, list):
             list_data: Sequence[str | Node | dict[str, Any] | None] = [data]
@@ -1092,9 +1098,8 @@ class RelationshipManager:
 
             if item is None:
                 if previous_relationships:
-                    if process_delete:
-                        for rel in previous_relationships.values():
-                            await rel.delete(db=db)
+                    for rel in previous_relationships.values():
+                        await rel.delete(db=db)
                     changed = True
                 continue
 

infrahub/core/schema/__init__.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import uuid
 from enum import Enum
-from typing import Any, TypeAlias
+from typing import Any
 
 from infrahub_sdk.utils import deep_merge_dict
 from pydantic import BaseModel, ConfigDict, Field
@@ -22,8 +22,8 @@ from .profile_schema import ProfileSchema
 from .relationship_schema import RelationshipSchema
 from .template_schema import TemplateSchema
 
-NonGenericSchemaTypes: TypeAlias = NodeSchema | ProfileSchema | TemplateSchema
-MainSchemaTypes: TypeAlias = NonGenericSchemaTypes | GenericSchema
+NonGenericSchemaTypes = NodeSchema | ProfileSchema | TemplateSchema
+MainSchemaTypes = NonGenericSchemaTypes | GenericSchema
 
 
 # -----------------------------------------------------

infrahub/core/schema/generic_schema.py

@@ -51,4 +51,4 @@ class GenericSchema(GeneratedGenericSchema):
     def _get_field_names_for_diff(self) -> list[str]:
         """Exclude used_by from the diff for generic nodes"""
         fields = super()._get_field_names_for_diff()
-        return [field for field in fields if field not in ["used_by"]]
+        return [field for field in fields if field != "used_by"]

infrahub/core/schema/schema_branch.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import contextlib
 import copy
 import hashlib
 import keyword
@@ -19,6 +20,7 @@ from infrahub.core.constants import (
     OBJECT_TEMPLATE_NAME_ATTR,
     OBJECT_TEMPLATE_RELATIONSHIP_NAME,
     PROFILE_NODE_RELATIONSHIP_IDENTIFIER,
+    PROFILE_TEMPLATE_RELATIONSHIP_IDENTIFIER,
     RESERVED_ATTR_GEN_NAMES,
     RESERVED_ATTR_REL_NAMES,
     RESTRICTED_NAMESPACES,
@@ -72,6 +74,16 @@ from .schema_branch_hfid import HFIDs
 log = get_logger()
 
 
+profiles_rel_settings: dict[str, Any] = {
+    "name": "profiles",
+    "identifier": PROFILE_NODE_RELATIONSHIP_IDENTIFIER,
+    "peer": InfrahubKind.PROFILE,
+    "kind": RelationshipKind.PROFILE,
+    "cardinality": RelationshipCardinality.MANY,
+    "branch": BranchSupportType.AWARE,
+}
+
+
 class SchemaBranch:
     def __init__(
         self,
@@ -334,10 +346,8 @@ class SchemaBranch:
             )
 
         schema: MainSchemaTypes | None = None
-        try:
+        with contextlib.suppress(KeyError):
             schema = self._cache[key]
-        except KeyError:
-            pass
 
         if not schema:
             raise ValueError(f"Schema {name!r} on branch {self.name} has incorrect hash: {key!r}")
@@ -1116,7 +1126,7 @@ class SchemaBranch:
                     ) from None
 
             for rel in node.relationships:
-                if rel.peer in [InfrahubKind.GENERICGROUP]:
+                if rel.peer == InfrahubKind.GENERICGROUP:
                     continue
                 if not self.has(rel.peer) or self.get(rel.peer, duplicate=False).state == HashableModelState.ABSENT:
                     raise ValueError(
@@ -2163,10 +2173,8 @@ class SchemaBranch:
                 or not node.generate_profile
                 or node.state == HashableModelState.ABSENT
             ):
-                try:
+                with contextlib.suppress(SchemaNotFoundError):
                     self.delete(name=self._get_profile_kind(node_kind=node.kind))
-                except SchemaNotFoundError:
-                    ...
                 continue
 
             profile = self.generate_profile_from_node(node=node)
@@ -2212,15 +2220,6 @@ class SchemaBranch:
             ):
                 continue
 
-            profiles_rel_settings: dict[str, Any] = {
-                "name": "profiles",
-                "identifier": PROFILE_NODE_RELATIONSHIP_IDENTIFIER,
-                "peer": InfrahubKind.PROFILE,
-                "kind": RelationshipKind.PROFILE,
-                "cardinality": RelationshipCardinality.MANY,
-                "branch": BranchSupportType.AWARE,
-            }
-
             # Add relationship between node and profile
             if "profiles" not in node.relationship_names:
                 node_schema = self.get(name=node_name, duplicate=True)
@@ -2285,6 +2284,18 @@ class SchemaBranch:
                 )
             ],
         )
+        if f"Template{node.kind}" in self.all_names:
+            template = self.get(name=f"Template{node.kind}", duplicate=False)
+            profile.relationships.append(
+                RelationshipSchema(
+                    name="related_templates",
+                    identifier=PROFILE_TEMPLATE_RELATIONSHIP_IDENTIFIER,
+                    peer=template.kind,
+                    kind=RelationshipKind.PROFILE,
+                    cardinality=RelationshipCardinality.MANY,
+                    branch=BranchSupportType.AWARE,
+                )
+            )
 
         for node_attr in node.attributes:
             if not node_attr.support_profiles:
@@ -2415,6 +2426,14 @@ class SchemaBranch:
                 template_schema.human_friendly_id = [parent_hfid] + template_schema.human_friendly_id
                 template_schema.uniqueness_constraints[0].append(relationship.name)
 
+        if getattr(node, "generate_profile", False):
+            if "profiles" not in [r.name for r in template_schema.relationships]:
+                settings = dict(profiles_rel_settings)
+                settings["identifier"] = PROFILE_TEMPLATE_RELATIONSHIP_IDENTIFIER
+                template_schema.relationships.append(RelationshipSchema(**settings))
+
+        self.set(name=template_schema.kind, schema=template_schema)
+
     def generate_object_template_from_node(
         self, node: NodeSchema | GenericSchema, need_templates: set[NodeSchema | GenericSchema]
     ) -> TemplateSchema | GenericSchema:

infrahub/core/task/user_task.py

@@ -6,6 +6,7 @@ from typing_extensions import Self
 
 from infrahub.core import registry
 from infrahub.core.constants import Severity, TaskConclusion
+from infrahub.core.protocols import CoreGenericAccount
 from infrahub.log import get_logger
 
 from .task import Task
@@ -16,7 +17,6 @@ if TYPE_CHECKING:
 
     from structlog.stdlib import BoundLogger
 
-    from infrahub.core.protocols import CoreGenericAccount
     from infrahub.database import InfrahubDatabase
     from infrahub.graphql.initialization import GraphqlContext
     from infrahub.services.protocols import InfrahubLogger
@@ -67,7 +67,7 @@ class UserTask:
         if self._account:
             return False
 
-        account: CoreGenericAccount | None = await registry.manager.get_one(id=self.account_id, db=self.db)
+        account = await registry.manager.get_one(id=self.account_id, db=self.db, kind=CoreGenericAccount)
         if not account:
             raise ValueError(f"Unable to find the account associated with {self.account_id}")
         self._account = account

infrahub/core/validators/determiner.py

@@ -1,3 +1,4 @@
+import contextlib
 from typing import TYPE_CHECKING, Any
 
 from infrahub.core.constants import RelationshipKind, SchemaPathType
@@ -84,14 +85,10 @@ class ConstraintValidatorDeterminer:
         constraints: list[SchemaUpdateConstraintInfo] = []
         schemas = list(self.schema_branch.get_all(duplicate=False).values())
         # added here to check their uniqueness constraints
-        try:
+        with contextlib.suppress(SchemaNotFoundError):
             schemas.append(self.schema_branch.get_node(name="SchemaAttribute", duplicate=False))
-        except SchemaNotFoundError:
-            pass
-        try:
+        with contextlib.suppress(SchemaNotFoundError):
             schemas.append(self.schema_branch.get_node(name="SchemaRelationship", duplicate=False))
-        except SchemaNotFoundError:
-            pass
         for schema in schemas:
             constraints.extend(await self._get_property_constraints_for_one_schema(schema=schema))
         return constraints

infrahub/core/validators/enum.py

@@ -1,7 +1,7 @@
-from enum import Enum
+from enum import StrEnum
 
 
-class ConstraintIdentifier(str, Enum):
+class ConstraintIdentifier(StrEnum):
     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"

infrahub/database/__init__.py

@@ -356,7 +356,7 @@ class InfrahubDatabase:
                     type
                     and type == QueryType.READ
                     and runtime not in [Neo4jRuntime.DEFAULT, Neo4jRuntime.UNDEFINED]
-                    and not (self.is_transaction and runtime in [Neo4jRuntime.PARALLEL])
+                    and not (self.is_transaction and runtime == Neo4jRuntime.PARALLEL)
                 ):
                     query = f"CYPHER runtime = {runtime.value}\n" + query
                 else:

infrahub/dependencies/interface.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from typing import Generic, TypeVar
+from typing import TypeVar
 
 from infrahub.core.branch import Branch
 from infrahub.database import InfrahubDatabase
@@ -14,7 +14,7 @@ class DependencyBuilderContext:
     branch: Branch
 
 
-class DependencyBuilder(ABC, Generic[T]):
+class DependencyBuilder[T](ABC):
     @classmethod
     @abstractmethod
     def build(cls, context: DependencyBuilderContext) -> T: ...

infrahub/events/constants.py

@@ -1,8 +1,8 @@
-from enum import Enum
+from enum import StrEnum
 
 EVENT_NAMESPACE = "infrahub"
 
 
-class EventSortOrder(str, Enum):
+class EventSortOrder(StrEnum):
     ASC = "asc"
     DESC = "desc"

infrahub/git/base.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import contextlib
 import shutil
 from abc import ABC, abstractmethod
 from pathlib import Path
@@ -16,10 +17,12 @@ from prefect.logging import get_run_logger
 from pydantic import BaseModel, ConfigDict, Field
 from pydantic import ValidationError as PydanticValidationError
 
+from infrahub import config
 from infrahub.core.branch import Branch
 from infrahub.core.constants import InfrahubKind, RepositoryOperationalStatus, RepositorySyncStatus
 from infrahub.core.registry import registry
 from infrahub.exceptions import (
+    BranchNotFoundError,
     CommitNotFoundError,
     FileOutOfRepositoryError,
     RepositoryConnectionError,
@@ -31,6 +34,7 @@ from infrahub.exceptions import (
 )
 from infrahub.git.constants import BRANCHES_DIRECTORY_NAME, COMMITS_DIRECTORY_NAME, TEMPORARY_DIRECTORY_NAME
 from infrahub.git.directory import get_repositories_directory, initialize_repositories_directory
+from infrahub.git.utils import branch_name_in_import_sync_branches
 from infrahub.git.worktree import Worktree
 from infrahub.log import get_logger
 from infrahub.workers.dependencies import get_client
@@ -733,6 +737,43 @@ class InfrahubRepositoryBase(BaseModel, ABC):
 
         return True
 
+    async def get_filtered_remote_branches(self) -> dict[str, BranchInRemote]:
+        branches = self.get_branches_from_remote()
+
+        if not config.SETTINGS.git.import_sync_branch_names:
+            return branches
+
+        filtered_branches = {}
+        skipped_branch_names = []
+
+        for short_name, branch_data in branches.items():
+            branch = None
+
+            with contextlib.suppress(BranchNotFoundError):
+                branch = registry.get_branch_from_registry(branch=short_name)
+
+            branch_exists_import_sync_condition = branch and (
+                branch.name not in {registry.default_branch, self.default_branch}
+                and not branch.sync_with_git
+                and not branch_name_in_import_sync_branches(branch_short_name=short_name)
+            )
+            branch_does_not_exist_import_sync_condition = not branch and not branch_name_in_import_sync_branches(
+                branch_short_name=short_name
+            )
+
+            if branch_exists_import_sync_condition or branch_does_not_exist_import_sync_condition:
+                skipped_branch_names.append(short_name)
+                continue
+
+            filtered_branches[short_name] = branch_data
+
+        if skipped_branch_names:
+            log.debug(
+                f"Skipped the following branches {skipped_branch_names} "
+                f"because no match was found in import_sync_branch_names {config.SETTINGS.git.import_sync_branch_names}"
+            )
+        return filtered_branches
+
     async def compare_local_remote(self) -> tuple[list[str], list[str]]:
         """
         Returns:
@@ -745,7 +786,7 @@ class InfrahubRepositoryBase(BaseModel, ABC):
         # TODO move this section into a dedicated function to compare and bring in sync the remote repo with the local one.
         # It can be useful just after a clone etc ...
         local_branches = self.get_branches_from_local()
-        remote_branches = self.get_branches_from_remote()
+        remote_branches = await self.get_filtered_remote_branches()
 
         new_branches = set(remote_branches.keys()) - set(local_branches.keys())
         existing_branches = set(local_branches.keys()) - new_branches

infrahub/git/models.py

@@ -92,7 +92,8 @@ class GitRepositoryMerge(BaseModel):
     source_branch: str = Field(..., description="The source branch")
     destination_branch: str = Field(..., description="The destination branch")
     destination_branch_id: str = Field(..., description="The ID of the destination branch")
-    default_branch: str = Field(..., description="The default branch in Git")
+    default_branch: str | None = Field(default=None, description="The default branch in Git")
+    repository_kind: str = Field(..., description="The kind of the repository.")
 
 
 class GitRepositoryImportObjects(BaseModel):

infrahub/git/repository.py

@@ -11,6 +11,7 @@ from prefect import task
 from prefect.cache_policies import NONE
 from pydantic import Field
 
+from infrahub import config
 from infrahub.core.constants import InfrahubKind, RepositoryInternalStatus
 from infrahub.exceptions import RepositoryError
 from infrahub.git.integrator import InfrahubRepositoryIntegrator
@@ -170,7 +171,10 @@ class InfrahubRepository(InfrahubRepositoryIntegrator):
         commit = self.get_commit_value(branch_name=source_branch, remote=False)
 
         try:
-            repo.git.merge(commit)
+            if config.SETTINGS.git.use_explicit_merge_commit:
+                repo.git.merge(commit, "--no-ff", m="Merged by Infrahub")
+            else:
+                repo.git.merge(commit)
         except GitCommandError as exc:
             repo.git.merge("--abort")
             raise RepositoryError(identifier=self.name, message=exc.stderr) from exc

infrahub/git/tasks.py

@@ -502,6 +502,7 @@ async def pull_read_only(model: GitRepositoryPullReadOnly) -> None:
     flow_run_name="Merge {model.source_branch} > {model.destination_branch} in git repository",
 )
 async def merge_git_repository(model: GitRepositoryMerge) -> None:
+    log = get_run_logger()
     await add_tags(branches=[model.source_branch, model.destination_branch], nodes=[model.repository_id])
 
     client = get_client()
@@ -510,7 +511,11 @@ async def merge_git_repository(model: GitRepositoryMerge) -> None:
         id=model.repository_id, name=model.repository_name, client=client, default_branch_name=model.default_branch
     )
 
-    if model.internal_status == RepositoryInternalStatus.STAGING.value:
+    if (
+        model.internal_status == RepositoryInternalStatus.STAGING.value
+        and model.repository_kind == InfrahubKind.REPOSITORY
+    ):
+        log.info(f"Merging {model.repository_kind}")
         repo_source = await client.get(
             kind=InfrahubKind.GENERICREPOSITORY, id=model.repository_id, branch=model.source_branch
         )
@@ -522,6 +527,28 @@ async def merge_git_repository(model: GitRepositoryMerge) -> None:
         repo_main.commit.value = commit
 
         await repo_main.save()
+        log.info(f"Finished merging {model.repository_kind}")
+
+    elif model.repository_kind == InfrahubKind.READONLYREPOSITORY:
+        repo_source = await client.get(
+            kind=InfrahubKind.READONLYREPOSITORY, id=model.repository_id, branch=model.source_branch
+        )
+        repo_destination = await client.get(
+            kind=InfrahubKind.READONLYREPOSITORY, id=model.repository_id, branch=model.destination_branch
+        )
+
+        if (
+            repo_destination.ref.value != repo_source.ref.value
+            or repo_destination.commit.value != repo_source.commit.value
+        ):
+            log.info(f"Merging {model.repository_kind}")
+
+            repo_destination.ref.value = repo_source.ref.value
+            repo_destination.commit.value = repo_source.commit.value
+            await repo_destination.save()
+
+            log.info(f"Finished merging {model.repository_kind}")
+
     else:
         async with lock.registry.get(name=model.repository_name, namespace="repository"):
             await repo.merge(source_branch=model.source_branch, dest_branch=model.destination_branch)

infrahub/git/utils.py

@@ -1,3 +1,4 @@
+import re
 from collections import defaultdict
 from typing import TYPE_CHECKING, Any
 
@@ -12,6 +13,7 @@ from infrahub.core.manager import NodeManager
 from infrahub.database import InfrahubDatabase
 from infrahub.generators.models import ProposedChangeGeneratorDefinition
 
+from .. import config
 from .models import RepositoryBranchInfo, RepositoryData
 
 if TYPE_CHECKING:
@@ -168,3 +170,10 @@ async def fetch_proposed_change_generator_definition_targets(
     return await _fetch_definition_targets(
         client=client, branch=branch, group_id=definition.group_id, parameters=definition.parameters
     )
+
+
+def branch_name_in_import_sync_branches(branch_short_name: str) -> bool:
+    for branch_filter in config.SETTINGS.git.import_sync_branch_names:
+        if re.fullmatch(branch_filter, branch_short_name) or branch_filter == branch_short_name:
+            return True
+    return False