infrahub-server 1.7.3__tar.gz → 1.7.4__tar.gz

{infrahub_server-1.7.3 → infrahub_server-1.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: infrahub-server
-Version: 1.7.3
+Version: 1.7.4
 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.
 Project-URL: Homepage, https://opsmill.com
 Project-URL: Repository, https://github.com/opsmill/infrahub

{infrahub_server-1.7.3 → infrahub_server-1.7.4}/backend/infrahub/computed_attribute/gather.py

@@ -166,7 +166,9 @@ async def gather_trigger_computed_attribute_python(
             branches_with_diff_from_main = list(branches.keys())
 
         branches_to_process: list[tuple[str, list[str]]] = [(branch, []) for branch in branches_with_diff_from_main]
-        branches_to_process.append((registry.default_branch, branches_with_diff_from_main))
+
+        if registry.default_branch in branches.keys():
+            branches_to_process.append((registry.default_branch, branches_with_diff_from_main))
 
         for branch_scope, branches_out_of_scope in branches_to_process:
             trigger_python = ComputedAttrPythonTriggerDefinition.from_object(

{infrahub_server-1.7.3 → infrahub_server-1.7.4}/backend/infrahub/core/diff/query/merge.py

@@ -39,6 +39,7 @@ class DiffMergeQuery(Query):
             "branch_level": self.target_branch.hierarchy_level,
             "target_branch": self.target_branch.name,
             "source_branch": self.source_branch_name,
+            "global_branch": GLOBAL_BRANCH_NAME,
             "migrated_kinds_id_map": self.migrated_kinds_id_map,
             "migrated_kinds_uuids": list(self.migrated_kinds_id_map.keys()),
         }
@@ -270,7 +271,7 @@ CALL (n, node_diff_map, is_node_kind_migration) {
             CALL (rel_peer_id, rel_peer_db_id) {
                 MATCH (rel_peer:Node {uuid: rel_peer_id})-[target_is_part_of:IS_PART_OF]->(:Root)
                 WHERE (rel_peer_db_id IS NULL OR elementId(rel_peer) = rel_peer_db_id)
-                AND target_is_part_of.branch IN [$source_branch, $target_branch]
+                AND target_is_part_of.branch IN [$source_branch, $target_branch, $global_branch]
                 RETURN rel_peer
                 ORDER BY target_is_part_of.branch_level DESC, target_is_part_of.from DESC, target_is_part_of.status ASC
                 LIMIT 1

infrahub_server-1.7.4/backend/infrahub/core/graph/__init__.py

@@ -0,0 +1 @@
+GRAPH_VERSION = 56

{infrahub_server-1.7.3 → infrahub_server-1.7.4}/backend/infrahub/core/migrations/graph/__init__.py

@@ -57,6 +57,7 @@ from .m052_fix_global_branch_level import Migration052
 from .m053_fix_branch_level_zero import Migration053
 from .m054_cleanup_orphaned_nodes import Migration054
 from .m055_remove_webhook_validate_certificates_default import Migration055
+from .m056_update_schema_node_generic_constraints import Migration056
 
 if TYPE_CHECKING:
     from ..shared import MigrationTypes
@@ -118,6 +119,7 @@ MIGRATIONS: list[type[MigrationTypes]] = [
     Migration053,
     Migration054,
     Migration055,
+    Migration056,
 ]
 
 

infrahub_server-1.7.4/backend/infrahub/core/migrations/graph/m056_update_schema_node_generic_constraints.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from infrahub.core import registry
+from infrahub.core.branch import Branch
+from infrahub.core.migrations.shared import MigrationInput, MigrationResult, get_migration_console
+from infrahub.core.schema import SchemaRoot, internal_schema
+from infrahub.core.schema.definitions.internal import (
+    generic_schema as internal_generic_schema,
+)
+from infrahub.core.schema.definitions.internal import (
+    node_schema as internal_node_schema,
+)
+from infrahub.core.schema.manager import SchemaManager
+from infrahub.log import get_logger
+
+from ..shared import ArbitraryMigration
+
+if TYPE_CHECKING:
+    from infrahub.core.timestamp import Timestamp
+    from infrahub.database import InfrahubDatabase
+
+log = get_logger()
+console = get_migration_console()
+
+
+async def update_schema_on_branch(db: InfrahubDatabase, branch: Branch, at: Timestamp, user_id: str) -> None:
+    """Update SchemaNode and SchemaGeneric on a specific branch."""
+    # Load schema for this branch
+    manager = SchemaManager()
+    registry.schema = manager
+    internal_schema_root = SchemaRoot(**internal_schema)
+    manager.register_schema(schema=internal_schema_root)
+    schema_branch = await manager.load_schema_from_db(db=db, branch=branch)
+
+    node_kind = "SchemaNode"
+    node_schema = schema_branch.get_node(name=node_kind, duplicate=False)
+    node_schema_node = await manager.get_one(db=db, branch=branch, id=node_schema.get_id(), prefetch_relationships=True)
+    current_node_schema = await manager.convert_node_schema_to_schema(db=db, schema_node=node_schema_node)
+
+    generic_kind = "SchemaGeneric"
+    generic_schema = schema_branch.get_node(name=generic_kind, duplicate=False)
+    generic_schema_node = await manager.get_one(
+        db=db, branch=branch, id=generic_schema.get_id(), prefetch_relationships=True
+    )
+    current_generic_schema = await manager.convert_node_schema_to_schema(db=db, schema_node=generic_schema_node)
+
+    for current_schema, internal_schema_spec in [
+        (current_node_schema, internal_node_schema),
+        (current_generic_schema, internal_generic_schema),
+    ]:
+        # Update SchemaNode
+        changed = False
+        if current_schema.human_friendly_id != internal_schema_spec.human_friendly_id:
+            current_schema.human_friendly_id = internal_schema_spec.human_friendly_id
+            changed = True
+        if current_schema.uniqueness_constraints != internal_schema_spec.uniqueness_constraints:
+            current_schema.uniqueness_constraints = internal_schema_spec.uniqueness_constraints
+            changed = True
+
+        # Update the name attribute to be unique = False
+        name_attr = current_schema.get_attribute(name="name")
+        if name_attr.unique:
+            name_attr.unique = False
+            changed = True
+
+        if changed:
+            # Save SchemaNode back to DB
+            await manager.update_node_in_db(
+                db=db,
+                node=current_schema,
+                user_id=user_id,
+                at=at,
+                branch=branch,
+            )
+
+
+class Migration056(ArbitraryMigration):
+    name: str = "056_update_schema_node_generic_constraints"
+    minimum_version: int = 55
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        return MigrationResult()
+
+    async def execute(self, migration_input: MigrationInput) -> MigrationResult:
+        db = migration_input.db
+        at = migration_input.at
+        user_id = migration_input.user_id
+
+        console.log("[bold]Updating SchemaNode and SchemaGeneric constraints[/bold]")
+
+        # Get default branch
+        default_branch = registry.get_branch_from_registry()
+        console.log(f"Updating on default branch: {default_branch.name}")
+        await update_schema_on_branch(db=db, branch=default_branch, at=at, user_id=user_id)
+
+        branches = await Branch.get_list(db=db)
+        branches = [b for b in branches if not b.is_default and not b.is_global]
+        console.log(f"Found {len(branches)} branches to update")
+        for branch in branches:
+            console.log(f"Updating on branch: {branch.name}")
+            await update_schema_on_branch(db=db, branch=branch, at=at, user_id=user_id)
+
+        console.log("[bold green]Migration completed successfully[/bold green]")
+        return MigrationResult()

{infrahub_server-1.7.3 → infrahub_server-1.7.4}/backend/infrahub/core/query/relationship.py

@@ -31,7 +31,6 @@ if TYPE_CHECKING:
     from infrahub.core.schema import NodeSchema, RelationshipSchema
     from infrahub.database import InfrahubDatabase
 
-# pylint: disable=redefined-builtin,too-many-lines
 
 log = get_logger()
 

{infrahub_server-1.7.3 → infrahub_server-1.7.4}/backend/infrahub/core/schema/basenode_schema.py

@@ -6,10 +6,10 @@ import os
 from collections import defaultdict
 from dataclasses import asdict, dataclass
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Callable, Iterable, Literal, overload
+from typing import TYPE_CHECKING, Any, Callable, Iterable, Literal, NoReturn, overload
 
 from infrahub_sdk.utils import compare_lists, intersection
-from pydantic import ConfigDict, field_validator
+from pydantic import ConfigDict, ValidationError, field_validator
 
 from infrahub.core.constants import HashableModelState, RelationshipCardinality, RelationshipKind
 from infrahub.core.models import HashableModel, HashableModelDiff
@@ -73,6 +73,19 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
 
     model_config = ConfigDict(extra="forbid", json_schema_extra=_json_schema_extra)
 
+    @staticmethod
+    def _enhance_attribute_validation_error(exc: ValidationError, attr_name: str, idx: int) -> NoReturn:
+        """Enhance validation error with attribute name and correct index in location path."""
+        errors = []
+        for error in exc.errors():
+            error_copy = error.copy()
+            # Insert the correct list index at the start of the location path
+            error_copy["loc"] = (idx,) + error["loc"]
+            nested_path = ".".join(str(item) for item in error["loc"])
+            error_copy["input"] = f"[{attr_name}.{nested_path}]: {error.get('input', 'N/A')}"
+            errors.append(error_copy)
+        raise ValidationError.from_exception_data(title=exc.title, line_errors=errors) from exc
+
     @property
     def is_schema_node(self) -> bool:
         """Tell if this node represent a part of the schema. Not to confuse this with `is_node_schema`."""
@@ -124,19 +137,27 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
         if not isinstance(raw_attributes, list):
             return raw_attributes
         attribute_schemas_with_types: list[Any] = []
-        for raw_attr in raw_attributes:
+        for idx, raw_attr in enumerate(raw_attributes):
             if not isinstance(raw_attr, (dict, AttributeSchema)):
                 attribute_schemas_with_types.append(raw_attr)
                 continue
             if isinstance(raw_attr, dict):
-                kind = raw_attr.get("kind")
+                kind = raw_attr["kind"]
+                attr_name = raw_attr["name"]
                 attribute_type_class = get_attribute_schema_class_for_kind(kind=kind)
-                attribute_schemas_with_types.append(attribute_type_class(**raw_attr))
+                try:
+                    attribute_schemas_with_types.append(attribute_type_class(**raw_attr))
+                except ValidationError as exc:
+                    cls._enhance_attribute_validation_error(exc, attr_name, idx)
                 continue
 
+            attr_name = raw_attr.name
             expected_attr_schema_class = get_attribute_schema_class_for_kind(kind=raw_attr.kind)
             if not isinstance(raw_attr, expected_attr_schema_class):
-                final_attr = expected_attr_schema_class(**raw_attr.model_dump())
+                try:
+                    final_attr = expected_attr_schema_class(**raw_attr.model_dump())
+                except ValidationError as exc:
+                    cls._enhance_attribute_validation_error(exc, attr_name, idx)
             else:
                 final_attr = raw_attr
             attribute_schemas_with_types.append(final_attr)

{infrahub_server-1.7.3 → infrahub_server-1.7.4}/backend/infrahub/core/schema/manager.py

@@ -378,7 +378,8 @@ class SchemaManager(NodeManager):
 
         schema_dict = node.model_dump(exclude=IGNORE_FOR_NODE)
         for key, value in schema_dict.items():
-            getattr(obj, key).value = value
+            if obj_attr := getattr(obj, key, None):
+                obj_attr.value = value
 
         attribute_schema = self.get_node_schema(name="SchemaAttribute", branch=branch)
         relationship_schema = self.get_node_schema(name="SchemaRelationship", branch=branch)

{infrahub_server-1.7.3 → infrahub_server-1.7.4}/backend/infrahub/generators/tasks.py

@@ -90,7 +90,7 @@ async def run_generator(model: RequestGeneratorRun) -> None:
         )
         await generator.run(identifier=generator_definition.name)
         generator_instance.status.value = GeneratorInstanceStatus.READY.value
-    except (ModuleImportError, Exception):  # pylint: disable=broad-exception-caught
+    except (ModuleImportError, Exception):
         generator_instance.status.value = GeneratorInstanceStatus.ERROR.value
         await generator_instance.update(do_full_update=True)
         raise

{infrahub_server-1.7.3 → infrahub_server-1.7.4}/backend/infrahub/graphql/loaders/peers.py

@@ -53,7 +53,7 @@ class PeerRelationshipsDataLoader(DataLoader[str, list[Relationship]]):
         self.query_params = query_params
         self.db = db
 
-    async def batch_load_fn(self, keys: list[Any]) -> list[list[Relationship]]:  # pylint: disable=method-hidden
+    async def batch_load_fn(self, keys: list[Any]) -> list[list[Relationship]]:
         async with self.db.start_session(read_only=True) as db:
             peer_rels = await NodeManager.query_peers(
                 db=db,

{infrahub_server-1.7.3 → infrahub_server-1.7.4}/backend/infrahub/workers/utils.py

@@ -20,7 +20,7 @@ def inject_service_parameter(func: Flow, parameters: dict[str, Any], service: In
     """
 
     # avoid circular imports
-    from infrahub.services import InfrahubServices  # pylint: disable=C0415
+    from infrahub.services import InfrahubServices
 
     if service_parameter_name := get_parameter_name(func=func, types=[InfrahubServices.__name__, InfrahubServices]):
         if any(isinstance(param_value, InfrahubServices) for param_value in parameters):

{infrahub_server-1.7.3 → infrahub_server-1.7.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "infrahub-server"
-version = "1.7.3"
+version = "1.7.4"
 description = "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."
 authors = [{ name = "OpsMill", email = "info@opsmill.com" }]
 requires-python = ">=3.12,<3.14"
@@ -87,7 +87,6 @@ dev = [
     "pytest-cov==7.0.0",
     "pytest-xdist>=3.4,<3.5",
     "types-python-slugify>=8.0.0.3,<9",
-    "pre-commit>=2.20.0,<3",
     "types-ujson",
     "types-pyyaml",
     "types-cachetools==6.2.0.20250827",
@@ -109,6 +108,7 @@ dev = [
     "psutil==6.1.0",
     "jwcrypto==1.5.6",
     "ty==0.0.8",
+    "prek>=0.3.0",
 ]
 
 # test-scale = [

infrahub_server-1.7.3/backend/infrahub/core/graph/__init__.py

@@ -1 +0,0 @@
-GRAPH_VERSION = 55