infrahub-server 1.4.10__tar.gz → 1.5.0b0__tar.gz

{infrahub_server-1.4.10 → infrahub_server-1.5.0b0}/PKG-INFO

@@ -1,16 +1,14 @@
 Metadata-Version: 2.3
 Name: infrahub-server
-Version: 1.4.10
+Version: 1.5.0b0
 Summary: Infrahub is taking a new approach to Infrastructure Management by providing a new generation of datastore to organize and control all the data that defines how an infrastructure should run.
 License: Apache-2.0
 Author: OpsMill
 Author-email: info@opsmill.com
-Requires-Python: >=3.10,<3.13
+Requires-Python: >=3.12,<3.13
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: Jinja2 (>=3,<4)
 Requires-Dist: aio-pika (>=9.4,<9.5)
@@ -34,15 +32,14 @@ Requires-Dist: neo4j (>=5.28,<5.29)
 Requires-Dist: neo4j-rust-ext (>=5.28,<5.29)
 Requires-Dist: netaddr (==1.3.0)
 Requires-Dist: netutils (==1.12.0)
-Requires-Dist: numpy (>=1.24.2,<2.0.0) ; python_version >= "3.9" and python_version < "3.12"
-Requires-Dist: numpy (>=1.26.2,<2.0.0) ; python_version >= "3.12"
+Requires-Dist: numpy (>=1.26.2,<2.0.0)
 Requires-Dist: opentelemetry-exporter-otlp-proto-grpc (==1.28.1)
 Requires-Dist: opentelemetry-exporter-otlp-proto-http (==1.28.1)
 Requires-Dist: opentelemetry-instrumentation-aio-pika (==0.49b1)
 Requires-Dist: opentelemetry-instrumentation-fastapi (==0.49b1)
-Requires-Dist: prefect (==3.4.13)
+Requires-Dist: prefect (==3.4.22)
 Requires-Dist: prefect-redis (==0.2.4)
-Requires-Dist: pyarrow (>=14,<15)
+Requires-Dist: pyarrow (>=14)
 Requires-Dist: pydantic (>=2.10,<2.11)
 Requires-Dist: pydantic-settings (>=2.8,<2.9)
 Requires-Dist: pyjwt (>=2.8,<2.9)
@@ -53,7 +50,7 @@ Requires-Dist: redis[hiredis] (>=6.0.0,<7.0.0)
 Requires-Dist: rich (>=13,<14)
 Requires-Dist: starlette-exporter (>=0.23,<0.24)
 Requires-Dist: structlog (==24.1.0)
-Requires-Dist: toml (>=0.10,<0.11)
+Requires-Dist: tomli (>=1.1.0) ; python_version < "3.11"
 Requires-Dist: typer (==0.12.5)
 Requires-Dist: ujson (>=5,<6)
 Requires-Dist: uvicorn[standard] (>=0.32,<0.33)

infrahub_server-1.5.0b0/backend/infrahub/actions/tasks.py

@@ -0,0 +1,303 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import TYPE_CHECKING, Any
+
+from infrahub_sdk.graphql import Mutation, Query
+from infrahub_sdk.types import Order
+from prefect import flow
+
+from infrahub.context import InfrahubContext  # noqa: TC001  needed for prefect flow
+from infrahub.core.constants import InfrahubKind
+from infrahub.generators.models import (
+    GeneratorDefinitionModel,
+    RequestGeneratorRun,
+)
+from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
+from infrahub.trigger.models import TriggerType
+from infrahub.trigger.setup import setup_triggers_specific
+from infrahub.workers.dependencies import get_client, get_workflow
+from infrahub.workflows.catalogue import REQUEST_GENERATOR_RUN
+from infrahub.workflows.utils import add_tags
+
+from .gather import gather_trigger_action_rules
+from .models import EventGroupMember  # noqa: TC001  needed for prefect flow
+
+if TYPE_CHECKING:
+    from infrahub_sdk.client import InfrahubClient
+    from infrahub_sdk.node import InfrahubNode
+
+
+def get_generator_run_query(definition_id: str, target_ids: list[str]) -> Query:
+    return Query(
+        name=InfrahubKind.GENERATORDEFINITION,
+        query={
+            InfrahubKind.GENERATORDEFINITION: {
+                "@filters": {
+                    "ids": [definition_id],
+                },
+                "edges": {
+                    "node": {
+                        "id": None,
+                        "name": {
+                            "value": None,
+                        },
+                        "class_name": {
+                            "value": None,
+                        },
+                        "file_path": {
+                            "value": None,
+                        },
+                        "query": {
+                            "node": {
+                                "name": {
+                                    "value": None,
+                                },
+                            },
+                        },
+                        "convert_query_response": {
+                            "value": None,
+                        },
+                        "parameters": {
+                            "value": None,
+                        },
+                        "targets": {
+                            "node": {
+                                "id": None,
+                                "members": {
+                                    "@filters": {
+                                        "ids": target_ids,
+                                    },
+                                    "edges": {
+                                        "node": {
+                                            "__typename": None,
+                                            "id": None,
+                                            "display_label": None,
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                        "repository": {
+                            "node": {
+                                "__typename": None,
+                                "id": None,
+                                "name": {
+                                    "value": None,
+                                },
+                                f"... on {InfrahubKind.REPOSITORY}": {
+                                    "commit": {
+                                        "value": None,
+                                    },
+                                },
+                                f"... on {InfrahubKind.READONLYREPOSITORY}": {
+                                    "commit": {
+                                        "value": None,
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    )
+
+
+@flow(
+    name="action-add-node-to-group",
+    flow_run_name="Adding node={node_id} to group={group_id}",
+)
+async def add_node_to_group(
+    branch_name: str,
+    node_id: str,
+    group_id: str,
+    context: InfrahubContext,  # noqa: ARG001
+    service: InfrahubServices,
+) -> None:
+    await add_tags(branches=[branch_name], nodes=[node_id, group_id])
+
+    mutation = Mutation(
+        mutation="RelationshipAdd",
+        input_data={"data": {"id": group_id, "name": "members", "nodes": [{"id": node_id}]}},
+        query={"ok": None},
+    )
+
+    await service.client.execute_graphql(query=mutation.render(), branch_name=branch_name)
+
+
+@flow(
+    name="action-remove-node-from-group",
+    flow_run_name="Removing node={node_id} from group={group_id}",
+)
+async def remove_node_from_group(
+    branch_name: str,
+    node_id: str,
+    group_id: str,
+    context: InfrahubContext,  # noqa: ARG001
+    service: InfrahubServices,
+) -> None:
+    await add_tags(branches=[branch_name], nodes=[node_id, group_id])
+
+    mutation = Mutation(
+        mutation="RelationshipRemove",
+        input_data={"data": {"id": group_id, "name": "members", "nodes": [{"id": node_id}]}},
+        query={"ok": None},
+    )
+
+    await service.client.execute_graphql(query=mutation.render(), branch_name=branch_name)
+
+
+@flow(
+    name="action-run-generator",
+    flow_run_name="Running generator generator_definition_id={generator_definition_id} for nodes={node_ids}",
+)
+async def run_generator(
+    branch_name: str,
+    node_ids: list[str],
+    generator_definition_id: str,
+    context: InfrahubContext,
+    service: InfrahubServices,  # noqa: ARG001
+) -> None:
+    await add_tags(branches=[branch_name], nodes=node_ids + [generator_definition_id])
+
+    client = get_client()
+
+    await _run_generators(
+        branch_name=branch_name,
+        node_ids=node_ids,
+        generator_definition_id=generator_definition_id,
+        client=client,
+        context=context,
+    )
+
+
+@flow(
+    name="action-run-generator-group-event",
+    flow_run_name="Running generator",
+)
+async def run_generator_group_event(
+    branch_name: str,
+    members: list[EventGroupMember],
+    generator_definition_id: str,
+    context: InfrahubContext,
+    service: InfrahubServices,  # noqa: ARG001
+) -> None:
+    node_ids = [node.id for node in members]
+    await add_tags(branches=[branch_name], nodes=node_ids + [generator_definition_id])
+
+    client = get_client()
+
+    await _run_generators(
+        branch_name=branch_name,
+        node_ids=node_ids,
+        generator_definition_id=generator_definition_id,
+        client=client,
+        context=context,
+    )
+
+
+@flow(
+    name="configure-action-rules",
+    flow_run_name="Configure updated action rules and triggers",
+)
+async def configure_action_rules(
+    service: InfrahubServices,
+) -> None:
+    await setup_triggers_specific(
+        gatherer=gather_trigger_action_rules, trigger_type=TriggerType.ACTION_TRIGGER_RULE, db=service.database
+    )  # type: ignore[misc]
+
+
+async def _get_targets(
+    branch_name: str,
+    targets: list[dict[str, Any]],
+    client: InfrahubClient,
+) -> dict[str, dict[str, InfrahubNode]]:
+    """Get the targets per kind in order to extract the variables."""
+
+    targets_per_kind: dict[str, dict[str, InfrahubNode]] = defaultdict(dict)
+
+    for target in targets:
+        targets_per_kind[target["node"]["__typename"]][target["node"]["id"]] = None
+
+    for kind, values in targets_per_kind.items():
+        nodes = await client.filters(
+            kind=kind, branch=branch_name, ids=list(values.keys()), populate_store=False, order=Order(disable=True)
+        )
+        for node in nodes:
+            targets_per_kind[kind][node.id] = node
+
+    return targets_per_kind
+
+
+async def _run_generators(
+    branch_name: str,
+    node_ids: list[str],
+    generator_definition_id: str,
+    client: InfrahubClient,
+    context: InfrahubContext | None = None,
+) -> None:
+    """Fetch generator metadata and submit per-target runs.
+
+    Args:
+        branch_name: Branch on which to execute.
+        node_ids: Node IDs to run against (restricts selection if provided).
+        generator_definition_id: Generator definition to execute.
+        client: InfrahubClient to query additional data.
+        context: Execution context passed to downstream workflow submissions.
+
+    Returns:
+        None
+
+    Raises:
+        ValueError: If the generator definition is not found or none of the requested
+            targets are members of the target group.
+    """
+    response = await client.execute_graphql(
+        query=get_generator_run_query(definition_id=generator_definition_id, target_ids=node_ids).render(),
+        branch_name=branch_name,
+    )
+    if not response[InfrahubKind.GENERATORDEFINITION]["edges"]:
+        raise ValueError(f"Generator definition {generator_definition_id} not found")
+
+    data = response[InfrahubKind.GENERATORDEFINITION]["edges"][0]["node"]
+
+    if not data["targets"]["node"]["members"]["edges"]:
+        raise ValueError(f"Target {node_ids[0]} is not part of the group {data['targets']['node']['id']}")
+
+    targets = data["targets"]["node"]["members"]["edges"]
+
+    targets_per_kind = await _get_targets(branch_name=branch_name, targets=targets, client=client)
+
+    workflow = get_workflow()
+
+    for target in targets:
+        node: InfrahubNode | None = None
+        if data["parameters"]["value"]:
+            node = targets_per_kind[target["node"]["__typename"]][target["node"]["id"]]
+
+        request_generator_run_model = RequestGeneratorRun(
+            generator_definition=GeneratorDefinitionModel(
+                definition_id=generator_definition_id,
+                definition_name=data["name"]["value"],
+                class_name=data["class_name"]["value"],
+                file_path=data["file_path"]["value"],
+                query_name=data["query"]["node"]["name"]["value"],
+                convert_query_response=data["convert_query_response"]["value"],
+                group_id=data["targets"]["node"]["id"],
+                parameters=data["parameters"]["value"],
+            ),
+            commit=data["repository"]["node"]["commit"]["value"],
+            repository_id=data["repository"]["node"]["id"],
+            repository_name=data["repository"]["node"]["name"]["value"],
+            repository_kind=data["repository"]["node"]["__typename"],
+            branch_name=branch_name,
+            query=data["query"]["node"]["name"]["value"],
+            variables=await node.extract(params=data["parameters"]["value"]) if node else {},
+            target_id=target["node"]["id"],
+            target_name=target["node"]["display_label"],
+        )
+        await workflow.submit_workflow(
+            workflow=REQUEST_GENERATOR_RUN, context=context, parameters={"model": request_generator_run_model}
+        )

{infrahub_server-1.4.10 → infrahub_server-1.5.0b0}/backend/infrahub/api/artifact.py

@@ -15,6 +15,7 @@ from infrahub.api.dependencies import (
 )
 from infrahub.core import registry
 from infrahub.core.account import ObjectPermission
+from infrahub.core.branch.needs_rebase_status import check_need_rebase_status
 from infrahub.core.constants import GLOBAL_BRANCH_NAME, InfrahubKind, PermissionAction
 from infrahub.core.protocols import CoreArtifactDefinition
 from infrahub.database import InfrahubDatabase  # noqa: TC001
@@ -74,6 +75,8 @@ async def generate_artifact(
     permission_manager: PermissionManager = Depends(get_permission_manager),
     context: InfrahubContext = Depends(get_context),
 ) -> None:
+    check_need_rebase_status(branch_params.branch)
+
     permission_decision = (
         PermissionDecisionFlag.ALLOW_DEFAULT
         if branch_params.branch.name in (GLOBAL_BRANCH_NAME, registry.default_branch)

{infrahub_server-1.4.10 → infrahub_server-1.5.0b0}/backend/infrahub/api/query.py

@@ -24,6 +24,7 @@ from infrahub.graphql.metrics import (
     GRAPHQL_RESPONSE_SIZE_METRICS,
     GRAPHQL_TOP_LEVEL_QUERIES_METRICS,
 )
+from infrahub.graphql.middleware import raise_on_mutation_on_branch_needing_rebase
 from infrahub.graphql.utils import extract_data
 from infrahub.groups.models import RequestGraphQLQueryGroupUpdate
 from infrahub.log import get_logger
@@ -98,6 +99,7 @@ async def execute_query(
             context_value=gql_params.context,
             root_value=None,
             variable_values=params,
+            middleware=[raise_on_mutation_on_branch_needing_rebase],
         )
 
     data = extract_data(query_name=gql_query.name.value, result=result)

{infrahub_server-1.4.10 → infrahub_server-1.5.0b0}/backend/infrahub/api/schema.py

@@ -18,6 +18,7 @@ from infrahub.api.exceptions import SchemaNotValidError
 from infrahub.core import registry
 from infrahub.core.account import GlobalPermission
 from infrahub.core.branch import Branch  # noqa: TC001
+from infrahub.core.branch.needs_rebase_status import check_need_rebase_status
 from infrahub.core.constants import GLOBAL_BRANCH_NAME, GlobalPermissions, PermissionDecision
 from infrahub.core.migrations.schema.models import SchemaApplyMigrationData
 from infrahub.core.models import (  # noqa: TC001
@@ -287,6 +288,8 @@ async def load_schema(
     permission_manager: PermissionManager = Depends(get_permission_manager),
     context: InfrahubContext = Depends(get_context),
 ) -> SchemaUpdate:
+    check_need_rebase_status(branch)
+
     permission_manager.raise_for_permission(
         permission=define_global_permission_from_branch(
             permission=GlobalPermissions.MANAGE_SCHEMA, branch_name=branch.name

{infrahub_server-1.4.10 → infrahub_server-1.5.0b0}/backend/infrahub/auth.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import uuid
-from datetime import datetime, timedelta, timezone
+from datetime import UTC, datetime, timedelta
 from enum import Enum
 from typing import TYPE_CHECKING
 
@@ -78,7 +78,7 @@ async def authenticate_with_password(
     if not valid_credentials:
         raise AuthorizationError("Incorrect password")
 
-    now = datetime.now(tz=timezone.utc)
+    now = datetime.now(tz=UTC)
     refresh_expires = now + timedelta(seconds=config.SETTINGS.security.refresh_token_lifetime)
 
     session_id = await create_db_refresh_token(db=db, account_id=account.id, expiration=refresh_expires)
@@ -139,7 +139,7 @@ async def signin_sso_account(db: InfrahubDatabase, account_name: str, sso_groups
                 await group.members.add(db=db, data=account)
                 await group.members.save(db=db)
 
-    now = datetime.now(tz=timezone.utc)
+    now = datetime.now(tz=UTC)
     refresh_expires = now + timedelta(seconds=config.SETTINGS.security.refresh_token_lifetime)
     session_id = await create_db_refresh_token(db=db, account_id=account.id, expiration=refresh_expires)
     access_token = generate_access_token(account_id=account.id, session_id=session_id)
@@ -148,7 +148,7 @@ async def signin_sso_account(db: InfrahubDatabase, account_name: str, sso_groups
 
 
 def generate_access_token(account_id: str, session_id: uuid.UUID) -> str:
-    now = datetime.now(tz=timezone.utc)
+    now = datetime.now(tz=UTC)
 
     access_expires = now + timedelta(seconds=config.SETTINGS.security.access_token_lifetime)
     access_data = {
@@ -165,7 +165,7 @@ def generate_access_token(account_id: str, session_id: uuid.UUID) -> str:
 
 
 def generate_refresh_token(account_id: str, session_id: uuid.UUID, expiration: datetime) -> str:
-    now = datetime.now(tz=timezone.utc)
+    now = datetime.now(tz=UTC)
 
     refresh_data = {
         "sub": account_id,

{infrahub_server-1.4.10 → infrahub_server-1.5.0b0}/backend/infrahub/cli/db.py

@@ -5,7 +5,7 @@ import logging
 import os
 from collections import defaultdict
 from csv import DictReader, DictWriter
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from enum import Enum
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Sequence
@@ -59,7 +59,7 @@ from .patch import patch_app
 
 def get_timestamp_string() -> str:
     """Generate a timestamp string in the format YYYYMMDD-HHMMSS."""
-    return datetime.now(tz=timezone.utc).strftime("%Y%m%d-%H%M%S")
+    return datetime.now(tz=UTC).strftime("%Y%m%d-%H%M%S")
 
 
 if TYPE_CHECKING:

{infrahub_server-1.4.10 → infrahub_server-1.5.0b0}/backend/infrahub/config.py

@@ -8,7 +8,7 @@ from enum import Enum
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
-import toml
+import tomllib
 from infrahub_sdk.utils import generate_uuid
 from pydantic import (
     AliasChoices,
@@ -371,6 +371,11 @@ class CacheSettings(BaseSettings):
     tls_enabled: bool = Field(default=False, description="Indicates if TLS is enabled for the connection")
     tls_insecure: bool = Field(default=False, description="Indicates if TLS certificates are verified")
     tls_ca_file: str | None = Field(default=None, description="File path to CA cert or bundle in PEM format")
+    clean_up_deadlocks_interval_mins: int = Field(
+        default=15,
+        ge=1,
+        description="Age threshold in minutes: locks older than this and owned by inactive workers are deleted by the cleanup task.",
+    )
 
     @property
     def service_port(self) -> int:
@@ -975,7 +980,7 @@ def load(config_file_name: Path | str = "infrahub.toml", config_data: dict[str,
 
     if config_file.exists():
         config_string = config_file.read_text(encoding="utf-8")
-        config_tmp = toml.loads(config_string)
+        config_tmp = tomllib.loads(config_string)
 
         return Settings(**config_tmp)
 

{infrahub_server-1.4.10 → infrahub_server-1.5.0b0}/backend/infrahub/core/attribute.py

@@ -324,7 +324,7 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
 
         save_at = Timestamp(at)
 
-        if not self.id or self.is_from_profile:
+        if not self.id:
             return None
 
         return await self._update(at=save_at, db=db)
@@ -395,7 +395,6 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
 
         Get the current value
          - If the value is the same, do nothing
-         - If the value is inherited and is different, raise error (for now just ignore)
          - If the value is different, create new node and update relationship
 
         """
@@ -470,28 +469,32 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
 
         # ---------- Update the Node Properties ----------
         for prop_name in self._node_properties:
-            if getattr(self, f"{prop_name}_id") and not (
-                prop_name in current_attr_data.node_properties
-                and current_attr_data.node_properties[prop_name].uuid == getattr(self, f"{prop_name}_id")
-            ):
-                previous_attribute_node_property = current_attr_data.node_properties.get(prop_name)
-                previous_value = None
-                if previous_attribute_node_property:
-                    previous_value = previous_attribute_node_property.uuid
+            current_prop_id = getattr(self, f"{prop_name}_id")
+            database_prop_id: str | None = None
+            if prop_name in current_attr_data.node_properties:
+                database_prop_id = current_attr_data.node_properties[prop_name].uuid
+            needs_update = current_prop_id is not None and current_prop_id != database_prop_id
+            needs_clear = self.is_clear(prop_name) and database_prop_id
+
+            if not needs_update and not needs_clear:
+                continue
 
-                changelog.add_property(
-                    name=prop_name,
-                    value_current=getattr(self, f"{prop_name}_id"),
-                    value_previous=previous_value,
-                )
+            changelog.add_property(
+                name=prop_name,
+                value_current=current_prop_id,
+                value_previous=database_prop_id,
+            )
+
+            if needs_update:
                 query = await AttributeUpdateNodePropertyQuery.init(
-                    db=db, attr=self, at=update_at, prop_name=prop_name, prop_id=getattr(self, f"{prop_name}_id")
+                    db=db, attr=self, at=update_at, prop_name=prop_name, prop_id=current_prop_id
                 )
                 await query.execute(db=db)
 
-                rel = current_attr_result.get(f"rel_{prop_name}")
-                if rel and rel.get("branch") == branch.name:
-                    await update_relationships_to([rel.element_id], to=update_at, db=db)
+            # set the to time on the previously active edge
+            rel = current_attr_result.get(f"rel_{prop_name}")
+            if rel and rel.get("branch") == branch.name:
+                await update_relationships_to([rel.element_id], to=update_at, db=db)
 
         if changelog.has_updates:
             return changelog

{infrahub_server-1.4.10 → infrahub_server-1.5.0b0}/backend/infrahub/core/branch/models.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Any, Optional, Self, Union
 
 from pydantic import Field, field_validator
 
+from infrahub.core.branch.enums import BranchStatus
 from infrahub.core.constants import (
     GLOBAL_BRANCH_NAME,
 )
@@ -21,8 +22,6 @@ from infrahub.core.registry import registry
 from infrahub.core.timestamp import Timestamp
 from infrahub.exceptions import BranchNotFoundError, InitializationError, ValidationError
 
-from .enums import BranchStatus
-
 if TYPE_CHECKING:
     from infrahub.database import InfrahubDatabase
 
@@ -485,6 +484,7 @@ class Branch(StandardNode):
         # FIXME, we must ensure that there is no conflict before rebasing a branch
         #   Otherwise we could endup with a complicated situation
         self.branched_from = at.to_string()
+        self.status = BranchStatus.OPEN
         await self.save(db=db)
 
         # Update the branch in the registry after the rebase

infrahub_server-1.5.0b0/backend/infrahub/core/branch/needs_rebase_status.py

@@ -0,0 +1,11 @@
+from infrahub.core.branch import Branch
+from infrahub.core.branch.enums import BranchStatus
+
+
+def raise_needs_rebase_error(branch_name: str) -> None:
+    raise ValueError(f"Branch {branch_name} must be rebased before any updates can be made")
+
+
+def check_need_rebase_status(branch: Branch) -> None:
+    if branch.status == BranchStatus.NEED_REBASE:
+        raise_needs_rebase_error(branch_name=branch.name)

{infrahub_server-1.4.10 → infrahub_server-1.5.0b0}/backend/infrahub/core/branch/tasks.py

@@ -345,7 +345,7 @@ async def create_branch(model: BranchCreateModel, context: InfrahubContext) -> N
     async with database.start_session() as db:
         try:
             await Branch.get_by_name(db=db, name=model.name)
-            raise ValueError(f"The branch {model.name}, already exist")
+            raise ValidationError(f"The branch {model.name} already exists")
         except BranchNotFoundError:
             pass
 
@@ -356,7 +356,7 @@ async def create_branch(model: BranchCreateModel, context: InfrahubContext) -> N
             obj = Branch(**data_dict)
         except pydantic.ValidationError as exc:
             error_msgs = [f"invalid field {error['loc'][0]}: {error['msg']}" for error in exc.errors()]
-            raise ValueError("\n".join(error_msgs)) from exc
+            raise ValidationError("\n".join(error_msgs)) from exc
 
         async with lock.registry.local_schema_lock():
             # Copy the schema from the origin branch and set the hash and the schema_changed_at value

{infrahub_server-1.4.10 → infrahub_server-1.5.0b0}/backend/infrahub/core/constants/__init__.py

@@ -387,3 +387,4 @@ DEFAULT_REL_IDENTIFIER_LENGTH = 128
 
 OBJECT_TEMPLATE_RELATIONSHIP_NAME = "object_template"
 OBJECT_TEMPLATE_NAME_ATTR = "template_name"
+PROFILE_NODE_RELATIONSHIP_IDENTIFIER = "node__profile"