infrahub-server 1.5.0b0__py3-none-any.whl → 1.5.0b1__py3-none-any.whl

infrahub/core/schema/basenode_schema.py

@@ -9,7 +9,7 @@ from enum import Enum
 from typing import TYPE_CHECKING, Any, Callable, Iterable, Literal, overload
 
 from infrahub_sdk.utils import compare_lists, intersection
-from pydantic import field_validator
+from pydantic import ConfigDict, field_validator
 
 from infrahub.core.constants import HashableModelState, RelationshipCardinality, RelationshipKind
 from infrahub.core.models import HashableModel, HashableModelDiff
@@ -19,6 +19,7 @@ from .generated.base_node_schema import GeneratedBaseNodeSchema
 from .relationship_schema import RelationshipSchema
 
 if TYPE_CHECKING:
+    from pydantic.config import JsonDict
     from typing_extensions import Self
 
     from infrahub.core.schema import GenericSchema, NodeSchema
@@ -26,6 +27,7 @@ if TYPE_CHECKING:
 
 
 NODE_METADATA_ATTRIBUTES = ["_source", "_owner"]
+NODE_PROPERTY_ATTRIBUTES = ["display_label", "human_friendly_id"]
 INHERITED = "INHERITED"
 
 OPTIONAL_TEXT_FIELDS = [
@@ -39,10 +41,43 @@ OPTIONAL_TEXT_FIELDS = [
 ]
 
 
+def _json_schema_extra(schema: JsonDict) -> None:
+    """
+    Mutate the generated JSON Schema in place to:
+      - allow `null` for `display_labels`
+      - mark the non-null branch as deprecated
+    """
+    props = schema.get("properties")
+    if not isinstance(props, dict):
+        return
+    dl = props.get("display_labels")
+    if not isinstance(dl, dict):
+        return
+
+    if "anyOf" in dl:
+        dl["anyOf"] = [
+            {
+                "type": "array",
+                "items": {
+                    "type": "string",
+                    "deprecationMessage": "display_labels are deprecated use display_label instead",
+                },
+            },
+            {"type": "null"},
+        ]
+
+
 class BaseNodeSchema(GeneratedBaseNodeSchema):
     _exclude_from_hash: list[str] = ["attributes", "relationships"]
     _sort_by: list[str] = ["namespace", "name"]
 
+    model_config = ConfigDict(extra="forbid", json_schema_extra=_json_schema_extra)
+
+    @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`."""
+        return self.namespace == "Schema"
+
     @property
     def is_node_schema(self) -> bool:
         return False
@@ -240,6 +275,11 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
         return None
 
     def get_attribute(self, name: str) -> AttributeSchema:
+        if name == "human_friendly_id":
+            return AttributeSchema(name="human_friendly_id", kind="List", optional=True, branch=self.branch)
+        if name == "display_label":
+            return AttributeSchema(name="display_label", kind="Text", optional=True, branch=self.branch)
+
         for item in self.attributes:
             if item.name == name:
                 return item
@@ -329,7 +369,7 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
 
     @property
     def valid_input_names(self) -> list[str]:
-        return self.attribute_names + self.relationship_names + NODE_METADATA_ATTRIBUTES
+        return self.attribute_names + self.relationship_names + NODE_METADATA_ATTRIBUTES + NODE_PROPERTY_ATTRIBUTES
 
     @property
     def valid_local_names(self) -> list[str]:

infrahub/core/schema/definitions/core/__init__.py

@@ -29,6 +29,7 @@ from .core import core_node, core_task_target
 from .generator import core_generator_definition, core_generator_instance
 from .graphql_query import core_graphql_query
 from .group import (
+    core_generator_aware_group,
     core_generator_group,
     core_graphql_query_group,
     core_group,
@@ -128,6 +129,7 @@ core_models_mixed: dict[str, list] = {
         core_group_action,
         core_standard_group,
         core_generator_group,
+        core_generator_aware_group,
         core_graphql_query_group,
         core_repository_group,
         builtin_tag,

infrahub/core/schema/definitions/core/generator.py

@@ -33,6 +33,8 @@ core_generator_definition = NodeSchema(
         Attr(name="file_path", kind="Text"),
         Attr(name="class_name", kind="Text"),
         Attr(name="convert_query_response", kind="Boolean", optional=True, default_value=False),
+        Attr(name="execute_in_proposed_change", kind="Boolean", optional=True, default_value=True),
+        Attr(name="execute_after_merge", kind="Boolean", optional=True, default_value=True),
     ],
     relationships=[
         Rel(

infrahub/core/schema/definitions/core/group.py

@@ -70,10 +70,10 @@ core_standard_group = NodeSchema(
 core_generator_group = NodeSchema(
     name="GeneratorGroup",
     namespace="Core",
-    description="Group of nodes that are created by a generator.",
+    description="Group of nodes that are created by a generator. (local)",
     include_in_menu=False,
     icon="mdi:state-machine",
-    label="Generator Group",
+    label="Generator Group (local)",
     default_filter="name__value",
     order_by=["name__value"],
     display_labels=["name__value"],
@@ -82,6 +82,20 @@ core_generator_group = NodeSchema(
     generate_profile=False,
 )
 
+core_generator_aware_group = NodeSchema(
+    name="GeneratorAwareGroup",
+    namespace="Core",
+    description="Group of nodes that are created by a generator. (Aware)",
+    include_in_menu=False,
+    icon="mdi:state-machine",
+    label="Generator Group (aware)",
+    default_filter="name__value",
+    order_by=["name__value"],
+    display_labels=["name__value"],
+    branch=BranchSupportType.AWARE,
+    inherit_from=[InfrahubKind.GENERICGROUP],
+    generate_profile=False,
+)
 
 core_graphql_query_group = NodeSchema(
     name="GraphQLQueryGroup",

infrahub/core/schema/definitions/internal.py

@@ -179,7 +179,9 @@ class SchemaNode(BaseModel):
     default_filter: str | None = None
     attributes: list[SchemaAttribute]
     relationships: list[SchemaRelationship]
+    display_label: str | None = None
     display_labels: list[str]
+    uniqueness_constraints: list[list[str]] | None = None
 
     def to_dict(self) -> dict[str, Any]:
         return {
@@ -194,7 +196,9 @@ class SchemaNode(BaseModel):
                 if attribute.name not in ["id", "attributes", "relationships"]
             ],
             "relationships": [relationship.to_dict() for relationship in self.relationships],
+            "display_label": self.display_label,
             "display_labels": self.display_labels,
+            "uniqueness_constraints": self.uniqueness_constraints,
         }
 
     def without_duplicates(self, other: SchemaNode) -> SchemaNode:
@@ -292,11 +296,18 @@ base_node_schema = SchemaNode(
             optional=True,
             extra={"update": UpdateSupport.ALLOWED},
         ),
+        SchemaAttribute(
+            name="display_label",
+            kind="Text",
+            description="Attribute or Jinja2 template to use to generate the display label",
+            optional=True,
+            extra={"update": UpdateSupport.ALLOWED},
+        ),
         SchemaAttribute(
             name="display_labels",
             kind="List",
             internal_kind=str,
-            description="List of attributes to use to generate the display label",
+            description="List of attributes to use to generate the display label (deprecated)",
             optional=True,
             extra={"update": UpdateSupport.ALLOWED},
         ),
@@ -465,6 +476,7 @@ attribute_schema = SchemaNode(
     include_in_menu=False,
     default_filter=None,
     display_labels=["name__value"],
+    uniqueness_constraints=[["name__value", "node"]],
     attributes=[
         SchemaAttribute(
             name="id",
@@ -669,6 +681,7 @@ relationship_schema = SchemaNode(
     include_in_menu=False,
     default_filter=None,
     display_labels=["name__value"],
+    uniqueness_constraints=[["name__value", "node"]],
     attributes=[
         SchemaAttribute(
             name="id",

infrahub/core/schema/generated/base_node_schema.py

@@ -58,9 +58,14 @@ class GeneratedBaseNodeSchema(HashableModel):
         description="Human friendly and unique identifier for the object.",
         json_schema_extra={"update": "allowed"},
     )
+    display_label: str | None = Field(
+        default=None,
+        description="Attribute or Jinja2 template to use to generate the display label",
+        json_schema_extra={"update": "allowed"},
+    )
     display_labels: list[str] | None = Field(
         default=None,
-        description="List of attributes to use to generate the display label",
+        description="List of attributes to use to generate the display label (deprecated)",
         json_schema_extra={"update": "allowed"},
     )
     include_in_menu: bool | None = Field(

infrahub/core/schema/node_schema.py

@@ -90,6 +90,7 @@ class NodeSchema(GeneratedNodeSchema):
 
         properties_to_inherit = [
             "human_friendly_id",
+            "display_label",
             "display_labels",
             "default_filter",
             "menu_placement",
@@ -129,10 +130,12 @@ class NodeSchema(GeneratedNodeSchema):
                 item_idx = existing_inherited_relationships[relationship.name]
                 self.relationships[item_idx].update_from_generic(other=new_relationship)
 
-    def get_hierarchy_schema(self, db: InfrahubDatabase, branch: Branch | str | None = None) -> GenericSchema:
+    def get_hierarchy_schema(
+        self, db: InfrahubDatabase, branch: Branch | str | None = None, duplicate: bool = False
+    ) -> GenericSchema:
         if not self.hierarchy:
             raise ValueError("The node is not part of a hierarchy")
-        schema = db.schema.get(name=self.hierarchy, branch=branch)
+        schema = db.schema.get(name=self.hierarchy, branch=branch, duplicate=duplicate)
         if not isinstance(schema, GenericSchema):
             raise TypeError
         return schema

infrahub/core/schema/schema_branch.py

@@ -66,6 +66,8 @@ from ... import config
 from ..constants.schema import PARENT_CHILD_IDENTIFIER
 from .constants import INTERNAL_SCHEMA_NODE_KINDS, SchemaNamespace
 from .schema_branch_computed import ComputedAttributes
+from .schema_branch_display import DisplayLabels
+from .schema_branch_hfid import HFIDs
 
 log = get_logger()
 
@@ -77,6 +79,8 @@ class SchemaBranch:
         name: str | None = None,
         data: dict[str, dict[str, str]] | None = None,
         computed_attributes: ComputedAttributes | None = None,
+        display_labels: DisplayLabels | None = None,
+        hfids: HFIDs | None = None,
     ):
         self._cache: dict[str, NodeSchema | GenericSchema] = cache
         self.name: str | None = name
@@ -85,6 +89,8 @@ class SchemaBranch:
         self.profiles: dict[str, str] = {}
         self.templates: dict[str, str] = {}
         self.computed_attributes = computed_attributes or ComputedAttributes()
+        self.display_labels = display_labels or DisplayLabels()
+        self.hfids = hfids or HFIDs()
 
         if data:
             self.nodes = data.get("nodes", {})
@@ -270,6 +276,8 @@ class SchemaBranch:
             data=copy.deepcopy(self.to_dict()),
             cache=self._cache,
             computed_attributes=self.computed_attributes.duplicate(),
+            display_labels=self.display_labels.duplicate(),
+            hfids=self.hfids.duplicate(),
         )
 
     def set(self, name: str, schema: MainSchemaTypes) -> str:
@@ -504,6 +512,9 @@ class SchemaBranch:
         self.process_post_validation()
 
     def process_pre_validation(self) -> None:
+        self.process_nodes_state()
+        self.process_attributes_state()
+        self.process_relationships_state()
         self.generate_identifiers()
         self.process_default_values()
         self.process_deprecations()
@@ -529,6 +540,7 @@ class SchemaBranch:
         self.validate_identifiers()
         self.sync_uniqueness_constraints_and_unique_attributes()
         self.validate_uniqueness_constraints()
+        self.validate_display_label()
         self.validate_display_labels()
         self.validate_order_by()
         self.validate_default_filters()
@@ -752,6 +764,35 @@ class SchemaBranch:
                         element_name=element_name,
                     )
 
+    def validate_display_label(self) -> None:
+        self.display_labels = DisplayLabels()
+        for name in self.all_names:
+            node_schema = self.get(name=name, duplicate=False)
+
+            if node_schema.display_label is None and node_schema.display_labels:
+                update_candidate = self.get(name=name, duplicate=True)
+                if len(node_schema.display_labels) == 1:
+                    # If the previous display_labels consist of a single attribute convert
+                    # it to an attribute based display label
+                    converted_display_label = node_schema.display_labels[0]
+                    if "__" not in converted_display_label:
+                        # Previously we allowed defining a raw attribute name as a component of a
+                        # display_label, if this is the case we need to append '__value'
+                        converted_display_label = f"{converted_display_label}__value"
+                    update_candidate.display_label = converted_display_label
+                else:
+                    # If the previous display label consists of multiple attributes
+                    # convert it to a Jinja2 based display label
+                    update_candidate.display_label = " ".join(
+                        [f"{{{{ {display_label} }}}}" for display_label in node_schema.display_labels]
+                    )
+                self.set(name=name, schema=update_candidate)
+
+            if not node_schema.display_label:
+                continue
+
+            self._validate_display_label(node=node_schema)
+
     def validate_display_labels(self) -> None:
         for name in self.all_names:
             node_schema = self.get(name=name, duplicate=False)
@@ -849,6 +890,7 @@ class SchemaBranch:
         return False
 
     def validate_human_friendly_id(self) -> None:
+        self.hfids = HFIDs()
         for name in self.generic_names_without_templates + self.node_names:
             node_schema = self.get(name=name, duplicate=False)
 
@@ -860,7 +902,14 @@ class SchemaBranch:
             # Mapping relationship identifiers -> list of attributes paths
             rel_schemas_to_paths: dict[str, tuple[MainSchemaTypes, list[str]]] = {}
 
+            visited_paths: list[str] = []
             for hfid_path in node_schema.human_friendly_id:
+                if config.SETTINGS.main.schema_strict_mode and hfid_path in visited_paths:
+                    raise ValidationError(
+                        f"HFID of {node_schema.kind} cannot use the same path more than once: {hfid_path}"
+                    )
+
+                visited_paths.append(hfid_path)
                 schema_path = self.validate_schema_path(
                     node_schema=node_schema,
                     path=hfid_path,
@@ -875,6 +924,11 @@ class SchemaBranch:
                         rel_schemas_to_paths[rel_identifier] = (schema_path.related_schema, [])
                     rel_schemas_to_paths[rel_identifier][1].append(schema_path.attribute_path_as_str)
 
+                if node_schema.is_node_schema and node_schema.namespace not in ["Schema", "Internal"]:
+                    self.hfids.register_hfid_schema_path(
+                        kind=node_schema.kind, schema_path=schema_path, hfid=node_schema.human_friendly_id
+                    )
+
             if config.SETTINGS.main.schema_strict_mode:
                 # For every relationship referred within hfid, check whether the combination of attributes is unique is the peer schema node
                 for related_schema, attrs_paths in rel_schemas_to_paths.values():
@@ -1137,6 +1191,50 @@ class SchemaBranch:
                             node=node_schema, attribute=attribute, generic=generic_schema
                         )
 
+    def _validate_display_label(self, node: MainSchemaTypes) -> None:
+        if not node.display_label:
+            return
+
+        if not any(c in node.display_label for c in "{}"):
+            schema_path = self.validate_schema_path(
+                node_schema=node,
+                path=node.display_label,
+                allowed_path_types=SchemaElementPathType.ATTR_WITH_PROP,
+                element_name="display_label - non Jinja2",
+            )
+            if schema_path.attribute_schema and node.is_node_schema and node.namespace not in ["Internal", "Schema"]:
+                self.display_labels.register_attribute_based_display_label(
+                    kind=node.kind, attribute_name=schema_path.attribute_schema.name
+                )
+            return
+
+        jinja_template = Jinja2Template(template=node.display_label)
+        try:
+            variables = jinja_template.get_variables()
+            jinja_template.validate(restricted=config.SETTINGS.security.restrict_untrusted_jinja2_filters)
+        except (JinjaTemplateOperationViolationError, JinjaTemplateError) as exc:
+            raise ValueError(
+                f"{node.kind}: display_label is set to a jinja2 template, but has an invalid template: {exc.message}"
+            ) from exc
+
+        allowed_path_types = (
+            SchemaElementPathType.ATTR_WITH_PROP
+            | SchemaElementPathType.REL_ONE_MANDATORY_ATTR_WITH_PROP
+            | SchemaElementPathType.REL_ONE_ATTR_WITH_PROP
+        )
+        for variable in variables:
+            schema_path = self.validate_schema_path(
+                node_schema=node, path=variable, allowed_path_types=allowed_path_types, element_name="display_label"
+            )
+
+            if schema_path.is_type_attribute and schema_path.active_attribute_schema.name == "display_label":
+                raise ValueError(f"{node.kind}: display_label the '{variable}' variable is a reference to itself")
+
+            if node.is_node_schema and node.namespace not in ["Internal", "Schema"]:
+                self.display_labels.register_template_schema_path(
+                    kind=node.kind, schema_path=schema_path, template=node.display_label
+                )
+
     def _validate_computed_attribute(self, node: NodeSchema, attribute: AttributeSchema) -> None:
         if not attribute.computed_attribute or attribute.computed_attribute.kind == ComputedAttributeKind.USER:
             return
@@ -1612,6 +1710,42 @@ class SchemaBranch:
 
             self.set(name=name, schema=node)
 
+    def process_relationships_state(self) -> None:
+        for name in self.node_names + self.generic_names_without_templates:
+            node = self.get(name=name, duplicate=False)
+            if node.id or (not node.id and not node.relationships):
+                continue
+
+            filtered_relationships = [
+                relationship for relationship in node.relationships if relationship.state != HashableModelState.ABSENT
+            ]
+            if len(filtered_relationships) == len(node.relationships):
+                continue
+            updated_node = node.duplicate()
+            updated_node.relationships = filtered_relationships
+            self.set(name=name, schema=updated_node)
+
+    def process_attributes_state(self) -> None:
+        for name in self.node_names + self.generic_names_without_templates:
+            node = self.get(name=name, duplicate=False)
+            if not node.attributes:
+                continue
+
+            filtered_attributes = [
+                attribute for attribute in node.attributes if attribute.state != HashableModelState.ABSENT
+            ]
+            if len(filtered_attributes) == len(node.attributes):
+                continue
+            updated_node = node.duplicate()
+            updated_node.attributes = filtered_attributes
+            self.set(name=name, schema=updated_node)
+
+    def process_nodes_state(self) -> None:
+        for name in self.node_names + self.generic_names_without_templates:
+            node = self.get(name=name, duplicate=False)
+            if not node.id and node.state == HashableModelState.ABSENT:
+                self.delete(name=name)
+
     def _generate_weight_generics(self) -> None:
         """Generate order_weight for all generic schemas."""
         for name in self.generic_names:

infrahub/core/schema/schema_branch_display.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import hashlib
+from copy import deepcopy
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from infrahub.core.schema import SchemaAttributePath
+
+
+@dataclass
+class TemplateLabel:
+    template: str
+    attributes: set[str] = field(default_factory=set)
+    relationships: set[str] = field(default_factory=set)
+    filter_key: str = "ids"
+
+    @property
+    def fields(self) -> list[str]:
+        return sorted(list(self.attributes) + list(self.relationships))
+
+    @property
+    def has_related_components(self) -> bool:
+        """Indicate if the associated template use variables from relationships"""
+        return len(self.relationships) > 0
+
+    def get_hash(self) -> str:
+        return hashlib.md5(self.template.encode(), usedforsecurity=False).hexdigest()
+
+
+@dataclass
+class RelationshipIdentifier:
+    kind: str
+    filter_key: str
+    template: str
+
+    def __hash__(self) -> int:
+        return hash(f"{self.kind}::{self.filter_key}::{self.template}")
+
+
+@dataclass
+class RelationshipTriggers:
+    attributes: dict[str, set[RelationshipIdentifier]] = field(default_factory=dict)
+
+
+class DisplayLabels:
+    def __init__(
+        self,
+        template_based_display_labels: dict[str, TemplateLabel] | None = None,
+        template_relationship_triggers: dict[str, RelationshipTriggers] | None = None,
+    ) -> None:
+        self._template_based_display_labels: dict[str, TemplateLabel] = template_based_display_labels or {}
+        self._template_relationship_triggers: dict[str, RelationshipTriggers] = template_relationship_triggers or {}
+
+    def duplicate(self) -> DisplayLabels:
+        """Clone the current object."""
+        return self.__class__(
+            template_based_display_labels=deepcopy(self._template_based_display_labels),
+            template_relationship_triggers=deepcopy(self._template_relationship_triggers),
+        )
+
+    def register_attribute_based_display_label(self, kind: str, attribute_name: str) -> None:
+        """Register nodes where the display label consists of a single defined attribute name."""
+        self._template_based_display_labels[kind] = TemplateLabel(
+            template=f"{{{{ {attribute_name}__value }}}}", attributes={attribute_name}
+        )
+
+    def register_template_schema_path(self, kind: str, schema_path: SchemaAttributePath, template: str) -> None:
+        """Register Jinja2 template based display labels using the schema path of each impacted variable in the node."""
+
+        if kind not in self._template_based_display_labels:
+            self._template_based_display_labels[kind] = TemplateLabel(template=template)
+
+        if schema_path.is_type_attribute:
+            self._template_based_display_labels[kind].attributes.add(schema_path.active_attribute_schema.name)
+        elif schema_path.is_type_relationship and schema_path.related_schema:
+            self._template_based_display_labels[kind].relationships.add(schema_path.active_relationship_schema.name)
+            if schema_path.related_schema.kind not in self._template_relationship_triggers:
+                self._template_relationship_triggers[schema_path.related_schema.kind] = RelationshipTriggers()
+            if (
+                schema_path.active_attribute_schema.name
+                not in self._template_relationship_triggers[schema_path.related_schema.kind].attributes
+            ):
+                self._template_relationship_triggers[schema_path.related_schema.kind].attributes[
+                    schema_path.active_attribute_schema.name
+                ] = set()
+            self._template_relationship_triggers[schema_path.related_schema.kind].attributes[
+                schema_path.active_attribute_schema.name
+            ].add(
+                RelationshipIdentifier(
+                    kind=kind, filter_key=f"{schema_path.active_relationship_schema.name}__ids", template=template
+                )
+            )
+
+    def targets_node(self, kind: str) -> bool:
+        """Indicates if there is a display_label defined for the targeted node"""
+        return kind in self._template_based_display_labels
+
+    def get_template_node(self, kind: str) -> TemplateLabel:
+        """Return node kinds together with their template definitions."""
+        return self._template_based_display_labels[kind]
+
+    def get_template_nodes(self) -> dict[str, TemplateLabel]:
+        """Return node kinds together with their template definitions."""
+        return self._template_based_display_labels
+
+    def get_related_trigger_nodes(self) -> dict[str, RelationshipTriggers]:
+        """Return node kinds that other nodes use within their templates for display_labels."""
+        return self._template_relationship_triggers
+
+    def get_related_template(self, related_kind: str, target_kind: str) -> TemplateLabel:
+        relationship_trigger = self._template_relationship_triggers[related_kind]
+        for applicable_kinds in relationship_trigger.attributes.values():
+            for relationship_identifier in applicable_kinds:
+                if target_kind == relationship_identifier.kind:
+                    template_label = self.get_template_node(kind=target_kind)
+                    template_label.filter_key = relationship_identifier.filter_key
+                    return template_label
+
+        raise ValueError(
+            f"Unable to find registered template for {target_kind} registered on related node {related_kind}"
+        )