infrahub-server 1.2.2__py3-none-any.whl → 1.2.4__py3-none-any.whl

infrahub/cli/git_agent.py

@@ -19,10 +19,8 @@ from infrahub.git import initialize_repositories_directory
 from infrahub.lock import initialize_lock
 from infrahub.log import get_logger
 from infrahub.services import InfrahubServices
-from infrahub.services.adapters.cache.nats import NATSCache
-from infrahub.services.adapters.cache.redis import RedisCache
-from infrahub.services.adapters.message_bus.nats import NATSMessageBus
-from infrahub.services.adapters.message_bus.rabbitmq import RabbitMQMessageBus
+from infrahub.services.adapters.cache import InfrahubCache
+from infrahub.services.adapters.message_bus import InfrahubMessageBus
 from infrahub.services.adapters.workflow.local import WorkflowLocalExecution
 from infrahub.services.adapters.workflow.worker import WorkflowWorkerExecution
 from infrahub.trace import configure_trace
@@ -121,13 +119,9 @@ async def start(
 
     component_type = ComponentType.GIT_AGENT
     message_bus = config.OVERRIDE.message_bus or (
-        await NATSMessageBus.new(component_type=component_type)
-        if config.SETTINGS.broker.driver == config.BrokerDriver.NATS
-        else await RabbitMQMessageBus.new(component_type=component_type)
-    )
-    cache = config.OVERRIDE.cache or (
-        await NATSCache.new() if config.SETTINGS.cache.driver == config.CacheDriver.NATS else RedisCache()
+        await InfrahubMessageBus.new_from_driver(component_type=component_type, driver=config.SETTINGS.broker.driver)
     )
+    cache = config.OVERRIDE.cache or (await InfrahubCache.new_from_driver(driver=config.SETTINGS.cache.driver))
 
     service = await InfrahubServices.new(
         cache=cache,

infrahub/computed_attribute/tasks.py

@@ -6,6 +6,7 @@ from infrahub_sdk.protocols import (
     CoreNode,  # noqa: TC002
     CoreTransformPython,
 )
+from infrahub_sdk.template import Jinja2Template
 from prefect import flow
 from prefect.client.orchestration import get_client
 from prefect.logging import get_run_logger
@@ -16,7 +17,6 @@ from infrahub.core.registry import registry
 from infrahub.events import BranchDeletedEvent
 from infrahub.git.repository import get_initialized_repo
 from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
-from infrahub.support.macro import MacroDefinition
 from infrahub.trigger.models import TriggerType
 from infrahub.trigger.setup import setup_triggers
 from infrahub.workflows.catalogue import (
@@ -173,15 +173,15 @@ async def update_computed_attribute_value_jinja2(
 
     await add_tags(branches=[branch_name], nodes=[obj.id], db_change=True)
 
-    macro_definition = MacroDefinition(macro=template_value)
-    my_filter = {}
-    for variable in macro_definition.variables:
+    jinja_template = Jinja2Template(template=template_value)
+    variables = {}
+    for variable in jinja_template.get_variables():
         components = variable.split("__")
         if len(components) == 2:
             property_name = components[0]
             property_value = components[1]
             attribute_property = getattr(obj, property_name)
-            my_filter[variable] = getattr(attribute_property, property_value)
+            variables[variable] = getattr(attribute_property, property_value)
         elif len(components) == 3:
             relationship_name = components[0]
             property_name = components[1]
@@ -189,11 +189,11 @@ async def update_computed_attribute_value_jinja2(
             relationship = getattr(obj, relationship_name)
             try:
                 attribute_property = getattr(relationship.peer, property_name)
-                my_filter[variable] = getattr(attribute_property, property_value)
+                variables[variable] = getattr(attribute_property, property_value)
             except ValueError:
-                my_filter[variable] = ""
+                variables[variable] = ""
 
-    value = macro_definition.render(variables=my_filter)
+    value = await jinja_template.render(variables=variables)
     existing_value = getattr(obj, attribute_name).value
     if value == existing_value:
         log.debug(f"Ignoring to update {obj} with existing value on {attribute_name}={value}")

infrahub/config.py

@@ -115,11 +115,43 @@ class BrokerDriver(str, Enum):
     RabbitMQ = "rabbitmq"
     NATS = "nats"
 
+    @property
+    def driver_module_path(self) -> str:
+        match self:
+            case BrokerDriver.NATS:
+                return "infrahub.services.adapters.message_bus.nats"
+            case BrokerDriver.RabbitMQ:
+                return "infrahub.services.adapters.message_bus.rabbitmq"
+
+    @property
+    def driver_class_name(self) -> str:
+        match self:
+            case BrokerDriver.NATS:
+                return "NATSMessageBus"
+            case BrokerDriver.RabbitMQ:
+                return "RabbitMQMessageBus"
+
 
 class CacheDriver(str, Enum):
     Redis = "redis"
     NATS = "nats"
 
+    @property
+    def driver_module_path(self) -> str:
+        match self:
+            case CacheDriver.NATS:
+                return "infrahub.services.adapters.cache.nats"
+            case CacheDriver.Redis:
+                return "infrahub.services.adapters.cache.redis"
+
+    @property
+    def driver_class_name(self) -> str:
+        match self:
+            case CacheDriver.NATS:
+                return "NATSCache"
+            case CacheDriver.Redis:
+                return "RedisCache"
+
 
 class WorkflowDriver(str, Enum):
     LOCAL = "local"
@@ -612,6 +644,9 @@ class SecuritySettings(BaseSettings):
     oauth2_provider_settings: SecurityOAuth2ProviderSettings = Field(default_factory=SecurityOAuth2ProviderSettings)
     oidc_providers: list[OIDCProvider] = Field(default_factory=list, description="The selected OIDC providers")
     oidc_provider_settings: SecurityOIDCProviderSettings = Field(default_factory=SecurityOIDCProviderSettings)
+    restrict_untrusted_jinja2_filters: bool = Field(
+        default=True, description="Indicates if untrusted Jinja2 filters should be disallowd for computed attributes"
+    )
     _oauth2_settings: dict[str, SecurityOAuth2Settings] = PrivateAttr(default_factory=dict)
     _oidc_settings: dict[str, SecurityOIDCSettings] = PrivateAttr(default_factory=dict)
     sso_user_default_group: str | None = Field(

infrahub/core/constants/__init__.py

@@ -348,6 +348,7 @@ RESTRICTED_NAMESPACES: list[str] = [
 NODE_NAME_REGEX = r"^[A-Z][a-zA-Z0-9]+$"
 DEFAULT_NAME_MIN_LENGTH = 2
 NAME_REGEX = r"^[a-z0-9\_]+$"
+NAME_REGEX_OR_EMPTY = r"^[a-z0-9\_]*$"
 DEFAULT_DESCRIPTION_LENGTH = 128
 
 DEFAULT_NAME_MAX_LENGTH = 32

infrahub/core/constraint/node/runner.py

@@ -23,10 +23,15 @@ class NodeConstraintRunner:
         self.uniqueness_constraint = uniqueness_constraint
         self.relationship_manager_constraints = relationship_manager_constraints
 
-    async def check(self, node: Node, field_filters: list[str] | None = None) -> None:
+    async def check(
+        self, node: Node, field_filters: list[str] | None = None, skip_uniqueness_check: bool = False
+    ) -> None:
         async with self.db.start_session() as db:
             await node.resolve_relationships(db=db)
 
+            if not skip_uniqueness_check:
+                await self.uniqueness_constraint.check(node, filters=field_filters)
+
             for relationship_name in node.get_schema().relationship_names:
                 if field_filters and relationship_name not in field_filters:
                     continue
@@ -34,7 +39,3 @@ class NodeConstraintRunner:
                 await relationship_manager.fetch_relationship_ids(db=db, force_refresh=True)
                 for relationship_constraint in self.relationship_manager_constraints:
                     await relationship_constraint.check(relm=relationship_manager, node_schema=node.get_schema())
-
-            # If HFID constraint is the only constraint violated, all other constraints need to have ran before,
-            # as it means there is an existing node that we might want to update in the case of an upsert
-            await self.uniqueness_constraint.check(node, filters=field_filters)

infrahub/core/graph/__init__.py

@@ -1 +1 @@
-GRAPH_VERSION = 22
+GRAPH_VERSION = 25

infrahub/core/migrations/graph/__init__.py

@@ -24,6 +24,9 @@ from .m019_restore_rels_to_time import Migration019
 from .m020_duplicate_edges import Migration020
 from .m021_missing_hierarchy_merge import Migration021
 from .m022_add_generate_template_attr import Migration022
+from .m023_deduplicate_cardinality_one_relationships import Migration023
+from .m024_missing_hierarchy_backfill import Migration024
+from .m025_uniqueness_nulls import Migration025
 
 if TYPE_CHECKING:
     from infrahub.core.root import Root
@@ -53,7 +56,9 @@ MIGRATIONS: list[type[GraphMigration | InternalSchemaMigration | ArbitraryMigrat
     Migration020,
     Migration021,
     Migration022,
-    # Migration023,  Enable this migration once it has been tested on bigger databases
+    Migration023,
+    Migration024,
+    Migration025,
 ]
 
 

infrahub/core/migrations/graph/m018_uniqueness_nulls.py

@@ -21,81 +21,79 @@ if TYPE_CHECKING:
 log = get_logger()
 
 
+async def validate_nulls_in_uniqueness_constraints(db: InfrahubDatabase) -> MigrationResult:
+    """
+    Validate any schema that include optional attributes in the uniqueness constraints
+
+    An update to uniqueness constraint validation now handles NULL values as unique instead of ignoring them
+    """
+
+    default_branch = registry.get_branch_from_registry()
+    build_component_registry()
+    component_registry = get_component_registry()
+    uniqueness_checker = await component_registry.get_component(UniquenessChecker, db=db, branch=default_branch)
+    non_unique_nodes_by_kind: dict[str, list[NonUniqueNode]] = defaultdict(list)
+
+    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=default_branch)
+    manager.set_schema_branch(name=default_branch.name, schema=schema_branch)
+
+    for schema_kind in schema_branch.node_names + schema_branch.generic_names_without_templates:
+        schema = schema_branch.get(name=schema_kind, duplicate=False)
+        if not isinstance(schema, NodeSchema | GenericSchema):
+            continue
+
+        uniqueness_constraint_paths = schema.get_unique_constraint_schema_attribute_paths(schema_branch=schema_branch)
+        includes_optional_attr: bool = False
+
+        for uniqueness_constraint_path in uniqueness_constraint_paths:
+            for schema_attribute_path in uniqueness_constraint_path.attributes_paths:
+                if schema_attribute_path.attribute_schema and schema_attribute_path.attribute_schema.optional is True:
+                    includes_optional_attr = True
+                    break
+
+        if not includes_optional_attr:
+            continue
+
+        non_unique_nodes = await uniqueness_checker.check_one_schema(schema=schema)
+        if non_unique_nodes:
+            non_unique_nodes_by_kind[schema_kind] = non_unique_nodes
+
+    if not non_unique_nodes_by_kind:
+        return MigrationResult()
+
+    error_strings = []
+    for schema_kind, non_unique_nodes in non_unique_nodes_by_kind.items():
+        display_label_map = await get_display_labels_per_kind(
+            db=db, kind=schema_kind, branch_name=default_branch.name, ids=[nun.node_id for nun in non_unique_nodes]
+        )
+        for non_unique_node in non_unique_nodes:
+            display_label = display_label_map.get(non_unique_node.node_id)
+            error_str = f"{display_label or ''}({non_unique_node.node_schema.kind} / {non_unique_node.node_id})"
+            error_str += " violates uniqueness constraints for the following attributes: "
+            attr_values = [
+                f"{attr.attribute_name}={attr.attribute_value}" for attr in non_unique_node.non_unique_attributes
+            ]
+            error_str += ", ".join(attr_values)
+            error_strings.append(error_str)
+    if error_strings:
+        error_str = "For the following nodes, you must update the uniqueness_constraints on the schema of the node"
+        error_str += " to remove the attribute(s) with NULL values or update the data on the nodes to be unique"
+        error_str += " now that NULL values are considered during uniqueness validation"
+        return MigrationResult(errors=[error_str] + error_strings)
+    return MigrationResult()
+
+
 class Migration018(InternalSchemaMigration):
     name: str = "018_validate_nulls_in_uniqueness_constraints"
     minimum_version: int = 17
     migrations: Sequence[SchemaMigration] = []
 
     async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
-        result = MigrationResult()
-
-        return result
+        return MigrationResult()
 
     async def execute(self, db: InfrahubDatabase) -> MigrationResult:
-        """
-        Validate any schema that include optional attributes in the uniqueness constraints
-
-        An update to uniqueness constraint validation now handles NULL values as unique instead of ignoring them
-        """
-        default_branch = registry.get_branch_from_registry()
-        build_component_registry()
-        component_registry = get_component_registry()
-        uniqueness_checker = await component_registry.get_component(UniquenessChecker, db=db, branch=default_branch)
-        non_unique_nodes_by_kind: dict[str, list[NonUniqueNode]] = defaultdict(list)
-
-        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=default_branch)
-        manager.set_schema_branch(name=default_branch.name, schema=schema_branch)
-
-        for schema_kind in schema_branch.node_names + schema_branch.generic_names_without_templates:
-            schema = schema_branch.get(name=schema_kind, duplicate=False)
-            if not isinstance(schema, NodeSchema | GenericSchema):
-                continue
-
-            uniqueness_constraint_paths = schema.get_unique_constraint_schema_attribute_paths(
-                schema_branch=schema_branch
-            )
-            includes_optional_attr: bool = False
-
-            for uniqueness_constraint_path in uniqueness_constraint_paths:
-                for schema_attribute_path in uniqueness_constraint_path.attributes_paths:
-                    if (
-                        schema_attribute_path.attribute_schema
-                        and schema_attribute_path.attribute_schema.optional is True
-                    ):
-                        includes_optional_attr = True
-                        break
-
-            if not includes_optional_attr:
-                continue
-
-            non_unique_nodes = await uniqueness_checker.check_one_schema(schema=schema)
-            if non_unique_nodes:
-                non_unique_nodes_by_kind[schema_kind] = non_unique_nodes
-
-        if not non_unique_nodes_by_kind:
-            return MigrationResult()
-
-        error_strings = []
-        for schema_kind, non_unique_nodes in non_unique_nodes_by_kind.items():
-            display_label_map = await get_display_labels_per_kind(
-                db=db, kind=schema_kind, branch_name=default_branch.name, ids=[nun.node_id for nun in non_unique_nodes]
-            )
-            for non_unique_node in non_unique_nodes:
-                display_label = display_label_map.get(non_unique_node.node_id)
-                error_str = f"{display_label or ''}({non_unique_node.node_schema.kind} / {non_unique_node.node_id})"
-                error_str += " violates uniqueness constraints for the following attributes: "
-                attr_values = [
-                    f"{attr.attribute_name}={attr.attribute_value}" for attr in non_unique_node.non_unique_attributes
-                ]
-                error_str += ", ".join(attr_values)
-                error_strings.append(error_str)
-        if error_strings:
-            error_str = "For the following nodes, you must update the uniqueness_constraints on the schema of the node"
-            error_str += " to remove the attribute(s) with NULL values or update the data on the nodes to be unique"
-            error_str += " now that NULL values are considered during uniqueness validation"
-            return MigrationResult(errors=[error_str] + error_strings)
-        return MigrationResult()
+        return await validate_nulls_in_uniqueness_constraints(db=db)

infrahub/core/migrations/graph/m024_missing_hierarchy_backfill.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Sequence
+
+from infrahub.core import registry
+from infrahub.core.initialization import initialization
+from infrahub.core.migrations.shared import GraphMigration, MigrationResult
+from infrahub.lock import initialize_lock
+from infrahub.log import get_logger
+
+from ...query import Query, QueryType
+
+if TYPE_CHECKING:
+    from infrahub.database import InfrahubDatabase
+
+log = get_logger()
+
+
+class BackfillMissingHierarchyQuery(Query):
+    name = "backfill_missing_hierarchy"
+    type = QueryType.WRITE
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        # load schemas from database into registry
+        initialize_lock()
+        await initialization(db=db)
+        kind_hierarchy_map: dict[str, str] = {}
+        schema_branch = await registry.schema.load_schema_from_db(db=db)
+        for node_schema_kind in schema_branch.node_names:
+            node_schema = schema_branch.get_node(name=node_schema_kind, duplicate=False)
+            if node_schema.hierarchy:
+                kind_hierarchy_map[node_schema.kind] = node_schema.hierarchy
+
+        self.params = {"hierarchy_map": kind_hierarchy_map}
+        query = """
+        MATCH (r:Root)
+        WITH r.default_branch AS default_branch
+        MATCH (rel:Relationship {name: "parent__child"})-[e:IS_RELATED]-(n:Node)
+        WHERE e.hierarchy IS NULL
+        WITH DISTINCT rel, n, default_branch
+        CALL {
+            WITH rel, n, default_branch
+            MATCH (rel)-[e:IS_RELATED {branch: default_branch}]-(n)
+            RETURN e
+            ORDER BY e.from DESC
+            LIMIT 1
+        }
+        WITH rel, n, e
+        WHERE e.status = "active" AND e.hierarchy IS NULL
+        SET e.hierarchy = $hierarchy_map[n.kind]
+        """
+        self.add_to_query(query)
+
+
+class Migration024(GraphMigration):
+    """
+    A bug in diff merge logic caused the hierarchy information on IS_RELATED edges to be lost when merged into
+    main. This migration backfills the missing hierarchy data and accounts for the case when the branch that
+    created the data has been deleted.
+    """
+
+    name: str = "024_backfill_hierarchy"
+    minimum_version: int = 23
+    queries: Sequence[type[Query]] = [BackfillMissingHierarchyQuery]
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        result = MigrationResult()
+        return result

infrahub/core/migrations/graph/m025_uniqueness_nulls.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Sequence
+
+from infrahub.core.migrations.shared import MigrationResult
+from infrahub.log import get_logger
+
+from ..shared import InternalSchemaMigration, SchemaMigration
+from .m018_uniqueness_nulls import validate_nulls_in_uniqueness_constraints
+
+if TYPE_CHECKING:
+    from infrahub.database import InfrahubDatabase
+
+log = get_logger()
+
+
+class Migration025(InternalSchemaMigration):
+    name: str = "025_validate_nulls_in_uniqueness_constraints"
+    minimum_version: int = 24
+    migrations: Sequence[SchemaMigration] = []
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        return MigrationResult()
+
+    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+        return await validate_nulls_in_uniqueness_constraints(db=db)

infrahub/core/migrations/schema/node_attribute_remove.py

@@ -4,6 +4,7 @@ from typing import TYPE_CHECKING, Any, Sequence
 
 from infrahub.core.constants import RelationshipStatus
 from infrahub.core.graph.schema import GraphAttributeRelationships
+from infrahub.core.schema.generic_schema import GenericSchema
 
 from ..query import AttributeMigrationQuery
 from ..shared import AttributeSchemaMigration
@@ -22,8 +23,20 @@ class NodeAttributeRemoveMigrationQuery01(AttributeMigrationQuery):
         branch_filter, branch_params = self.branch.get_query_filter_path(at=self.at.to_string())
         self.params.update(branch_params)
 
+        attr_name = self.migration.schema_path.field_name
+        kinds_to_ignore = []
+        if isinstance(self.migration.new_node_schema, GenericSchema) and attr_name is not None:
+            for inheriting_schema_kind in self.migration.new_node_schema.used_by:
+                node_schema = db.schema.get_node_schema(
+                    name=inheriting_schema_kind, branch=self.branch, duplicate=False
+                )
+                attr_schema = node_schema.get_attribute_or_none(name=attr_name)
+                if attr_schema and not attr_schema.inherited:
+                    kinds_to_ignore.append(inheriting_schema_kind)
+
         self.params["node_kind"] = self.migration.new_schema.kind
-        self.params["attr_name"] = self.migration.schema_path.field_name
+        self.params["kinds_to_ignore"] = kinds_to_ignore
+        self.params["attr_name"] = attr_name
         self.params["current_time"] = self.at.to_string()
         self.params["branch_name"] = self.branch.name
         self.params["branch_support"] = self.migration.previous_attribute_schema.get_branch().value
@@ -60,7 +73,8 @@ class NodeAttributeRemoveMigrationQuery01(AttributeMigrationQuery):
         query = """
         // Find all the active nodes
         MATCH (node:%(node_kind)s)
-        WHERE exists((node)-[:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name }))
+        WHERE (size($kinds_to_ignore) = 0 OR NOT any(l IN labels(node) WHERE l IN $kinds_to_ignore))
+        AND exists((node)-[:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name }))
         CALL {
             WITH node
             MATCH (root:Root)<-[r:IS_PART_OF]-(node)

infrahub/core/models.py

@@ -19,6 +19,8 @@ if TYPE_CHECKING:
     from infrahub.core.schema import MainSchemaTypes
     from infrahub.core.schema.schema_branch import SchemaBranch
 
+GENERIC_ATTRIBUTES_TO_IGNORE = ["namespace", "name", "branch"]
+
 
 class NodeKind(BaseModel):
     namespace: str
@@ -270,6 +272,10 @@ class SchemaUpdateValidationResult(BaseModel):
         field_info = schema.model_fields[node_field_name]
         field_update = str(field_info.json_schema_extra.get("update"))  # type: ignore[union-attr]
 
+        # No need to execute a migration for generic nodes attributes because they are not stored in the database
+        if schema.is_generic_schema and node_field_name in GENERIC_ATTRIBUTES_TO_IGNORE:
+            return
+
         schema_path = SchemaPath(  # type: ignore[call-arg]
             schema_kind=schema.kind,
             path_type=SchemaPathType.NODE,
@@ -523,7 +529,7 @@ class HashableModel(BaseModel):
 
         return new_list
 
-    def update(self, other: Self) -> Self:
+    def update(self, other: HashableModel) -> Self:
         """Update the current object with the new value from the new one if they are defined.
 
         Currently this method works for the following type of fields

infrahub/core/node/__init__.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from enum import Enum
 from typing import TYPE_CHECKING, Any, Sequence, TypeVar, overload
 
+from infrahub_sdk.template import Jinja2Template
 from infrahub_sdk.utils import is_valid_uuid
 from infrahub_sdk.uuidt import UUIDT
 
@@ -24,7 +25,6 @@ from infrahub.core.query.node import NodeCheckIDQuery, NodeCreateAllQuery, NodeD
 from infrahub.core.schema import AttributeSchema, NodeSchema, ProfileSchema, RelationshipSchema, TemplateSchema
 from infrahub.core.timestamp import Timestamp
 from infrahub.exceptions import InitializationError, NodeNotFoundError, PoolExhaustedError, ValidationError
-from infrahub.support.macro import MacroDefinition
 from infrahub.types import ATTRIBUTE_TYPES
 
 from ...graphql.constants import KIND_GRAPHQL_FIELD_NAME
@@ -458,9 +458,9 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                     ValidationError({macro: f"{macro} is missing computational_logic for macro ({attr_schema.kind})"})
                 )
                 continue
-            macro_definition = MacroDefinition(macro=attr_schema.computed_attribute.jinja2_template)
 
-            for variable in macro_definition.variables:
+            jinja_template = Jinja2Template(template=attr_schema.computed_attribute.jinja2_template)
+            for variable in jinja_template.get_variables():
                 attribute_path = schema_branch.validate_schema_path(
                     node_schema=self._schema, path=variable, allowed_path_types=allowed_path_types
                 )
@@ -487,7 +487,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                     )
                     variables[variable] = attribute
 
-            content = macro_definition.render(variables=variables)
+            content = await jinja_template.render(variables=variables)
 
             generator_method_name = "_generate_attribute_default"
             if hasattr(self, f"generate_{attr_schema.name}"):

infrahub/core/node/constraints/grouped_uniqueness.py

@@ -220,21 +220,41 @@ class NodeGroupedUniquenessConstraint(NodeConstraintInterface):
 
         violations = []
         for schema in schemas_to_check:
+            schema_filters = list(filters) if filters is not None else []
+            for attr_schema in schema.attributes:
+                if attr_schema.optional and attr_schema.unique and attr_schema.name not in schema_filters:
+                    schema_filters.append(attr_schema.name)
+
             schema_violations = await self._get_single_schema_violations(
-                node=node, node_schema=schema, at=at, filters=filters
+                node=node, node_schema=schema, at=at, filters=schema_filters
             )
             violations.extend(schema_violations)
 
-        is_hfid_violated = any(violation.typ == UniquenessConstraintType.HFID for violation in violations)
+        hfid_violations = [violation for violation in violations if violation.typ == UniquenessConstraintType.HFID]
+        hfid_violation = hfid_violations[0] if len(hfid_violations) > 0 else None
 
-        for violation in violations:
-            if violation.typ == UniquenessConstraintType.STANDARD or (
-                violation.typ == UniquenessConstraintType.SUBSET_OF_HFID and not is_hfid_violated
-            ):
-                error_msg = f"Violates uniqueness constraint '{'-'.join(violation.fields)}'"
-                raise ValidationError(error_msg)
+        # If there are both a hfid violation and another one, in case of an upsert, we still want to update the node in case other violations are:
+        # - either on subset fields of hfid, which would be necessarily violated too
+        # - or on uniqueness constraints with a matching node id being the id of the hfid violation
 
         for violation in violations:
             if violation.typ == UniquenessConstraintType.HFID:
-                error_msg = f"Violates uniqueness constraint '{'-'.join(violation.fields)}'"
-                raise HFIDViolatedError(error_msg, matching_nodes_ids=violation.nodes_ids)
+                continue
+
+            if hfid_violation:
+                if violation.typ == UniquenessConstraintType.SUBSET_OF_HFID:
+                    continue
+
+                if (
+                    violation.typ == UniquenessConstraintType.STANDARD
+                    and len(violation.nodes_ids) == 1
+                    and next(iter(violation.nodes_ids)) == next(iter(hfid_violation.nodes_ids))
+                ):
+                    continue
+
+            error_msg = f"Violates uniqueness constraint '{'-'.join(violation.fields)}'"
+            raise ValidationError(error_msg)
+
+        if hfid_violation:
+            error_msg = f"Violates uniqueness constraint '{'-'.join(hfid_violation.fields)}'"
+            raise HFIDViolatedError(error_msg, matching_nodes_ids=hfid_violation.nodes_ids)

infrahub/core/query/ipam.py

@@ -362,7 +362,7 @@ class IPPrefixReconcileQuery(Query):
         # possible prefix: highest possible prefix length for a match
         possible_prefix_map: dict[str, int] = {}
         start_prefixlen = prefixlen if is_address else prefixlen - 1
-        for max_prefix_len in range(start_prefixlen, 0, -1):
+        for max_prefix_len in range(start_prefixlen, -1, -1):
             tmp_prefix = prefix_bin_host[:max_prefix_len]
             possible_prefix = tmp_prefix.ljust(self.ip_value.max_prefixlen, "0")
             if possible_prefix not in possible_prefix_map:

infrahub/core/registry.py

@@ -220,5 +220,23 @@ class Registry:
             and branch.active_schema_hash.main != default_branch.active_schema_hash.main
         ]
 
+    async def purge_inactive_branches(
+        self, db: InfrahubDatabase, active_branches: list[Branch] | None = None
+    ) -> list[str]:
+        """Return a list of branches that were purged from the registry."""
+        active_branches = active_branches or await self.branch_object.get_list(db=db)
+        active_branch_names = [branch.name for branch in active_branches]
+        purged_branches: set[str] = set()
+
+        for branch_name in list(registry.branch.keys()):
+            if branch_name not in active_branch_names:
+                del registry.branch[branch_name]
+                purged_branches.add(branch_name)
+
+        purged_branches.update(self.schema.purge_inactive_branches(active_branches=active_branch_names))
+        purged_branches.update(db.purge_inactive_schemas(active_branches=active_branch_names))
+
+        return sorted(purged_branches)
+
 
 registry = Registry()