infrahub-server 1.6.1__tar.gz → 1.6.3__tar.gz

{infrahub_server-1.6.1 → infrahub_server-1.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: infrahub-server
-Version: 1.6.1
+Version: 1.6.3
 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.6.1 → infrahub_server-1.6.3}/backend/infrahub/core/account.py

@@ -54,11 +54,15 @@ class AccountGlobalPermissionQuery(Query):
     name: str = "account_global_permissions"
     type: QueryType = QueryType.READ
 
-    def __init__(self, account_id: str, **kwargs: Any):
+    def __init__(
+        self,
+        account_id: str,
+        branch: Branch | None = None,
+        branch_agnostic: bool = False,
+    ) -> None:
+        super().__init__(branch=branch, branch_agnostic=branch_agnostic)
         self.account_id = account_id
-        super().__init__(**kwargs)
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params["account_id"] = self.account_id
 
         branch_filter, branch_params = self.branch.get_query_filter_path(
@@ -66,7 +70,6 @@ class AccountGlobalPermissionQuery(Query):
         )
         self.params.update(branch_params)
 
-        # ruff: noqa: E501
         query = """
         MATCH (account:%(generic_account_node)s)
         WHERE account.uuid = $account_id
@@ -293,7 +296,7 @@ class AccountObjectPermissionQuery(Query):
 
 
 async def fetch_permissions(account_id: str, db: InfrahubDatabase, branch: Branch) -> AssignedPermissions:
-    query1 = await AccountGlobalPermissionQuery.init(db=db, branch=branch, account_id=account_id, branch_agnostic=True)
+    query1 = AccountGlobalPermissionQuery(branch=branch, account_id=account_id, branch_agnostic=True)
     await query1.execute(db=db)
     global_permissions = query1.get_permissions()
 

{infrahub_server-1.6.1 → infrahub_server-1.6.3}/backend/infrahub/core/branch/tasks.py

@@ -157,7 +157,12 @@ async def rebase_branch(branch: str, context: InfrahubContext, send_events: bool
             responses = await schema_validate_migrations(
                 message=SchemaValidateMigrationData(branch=obj, schema_branch=candidate_schema, constraints=constraints)
             )
-            error_messages = [violation.message for response in responses for violation in response.violations]
+            error_messages = [
+                f"{violation.message} for constraint {response.constraint_name} {response.schema_path.field_name} {response.schema_path.property_name} and node {violation.node_id} {violation.node_kind}"  # noqa: E501
+                for response in responses
+                for violation in response.violations
+            ]
+
             if error_messages:
                 raise ValidationError(",\n".join(error_messages))
 

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

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

{infrahub_server-1.6.1 → infrahub_server-1.6.3}/backend/infrahub/core/migrations/graph/__init__.py

@@ -49,6 +49,7 @@ from .m044_backfill_hfid_display_label_in_db import Migration044
 from .m045_backfill_hfid_display_label_in_db_profile_template import Migration045
 from .m046_fill_agnostic_hfid_display_labels import Migration046
 from .m047_backfill_or_null_display_label import Migration047
+from .m048_undelete_rel_props import Migration048
 
 if TYPE_CHECKING:
     from ..shared import MigrationTypes
@@ -102,6 +103,7 @@ MIGRATIONS: list[type[MigrationTypes]] = [
     Migration045,
     Migration046,
     Migration047,
+    Migration048,
 ]
 
 

{infrahub_server-1.6.1 → infrahub_server-1.6.3}/backend/infrahub/core/migrations/graph/m041_deleted_dup_edges.py

@@ -68,33 +68,49 @@ DELETE added_e
         self.add_to_query(query)
 
 
-class DeleteDuplicateEdgesForMigratedKindNodes(Query):
-    name = "delete_duplicate_edges_for_migrated_kind_nodes_query"
+class DeleteDuplicatedRelationshipEdges(Query):
+    name = "delete_duplicated_relationship_edges_query"
     type = QueryType.WRITE
     insert_return = False
 
+    def __init__(self, migrated_kind_nodes_only: bool = True, **kwargs: Any):
+        self.migrated_kind_nodes_only = migrated_kind_nodes_only
+        super().__init__(**kwargs)
+
     async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
-        query = """
+        if not self.migrated_kind_nodes_only:
+            relationship_filter_query = """
+MATCH (rel:Relationship)
+            """
+
+        else:
+            relationship_filter_query = """
 // ------------
 // get UUIDs for migrated kind/inheritance nodes
 // ------------
 MATCH (n:Node)
 WITH n.uuid AS node_uuid, count(*) AS num_nodes_with_uuid
 WHERE num_nodes_with_uuid > 1
-CALL (node_uuid) {
-    // ------------
-    // find any Relationships for these nodes
-    // ------------
-    MATCH (n:Node {uuid: node_uuid})-[:IS_RELATED]-(rel:Relationship)
-    WITH DISTINCT rel
-    MATCH (rel)-[e]->(peer)
+// ------------
+// find any Relationships for these nodes
+// ------------
+MATCH (n:Node {uuid: node_uuid})-[:IS_RELATED]-(rel:Relationship)
+WITH DISTINCT rel
+
+            """
+        self.add_to_query(relationship_filter_query)
+
+        query = """
+CALL (rel) {
+    MATCH (rel)-[e]-(peer)
     WITH
+        elementId(rel) AS rel_element_id,
         type(e) AS e_type,
         e.branch AS e_branch,
         e.from AS e_from,
         e.to AS e_to,
         e.status AS e_status,
-        e.peer AS e_peer,
+        elementId(peer) AS peer_element_id,
         CASE
             WHEN startNode(e) = rel THEN "out" ELSE "in"
         END AS direction,
@@ -142,7 +158,9 @@ class Migration041(ArbitraryMigration):
         rprint("done")
 
         rprint("Deleting duplicate edges for migrated kind/inheritance nodes", end="...")
-        delete_duplicate_edges_query = await DeleteDuplicateEdgesForMigratedKindNodes.init(db=db)
+        delete_duplicate_edges_query = await DeleteDuplicatedRelationshipEdges.init(
+            db=db, migrated_kind_nodes_only=True
+        )
         await delete_duplicate_edges_query.execute(db=db)
         rprint("done")
 

infrahub_server-1.6.3/backend/infrahub/core/migrations/graph/m048_undelete_rel_props.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from infrahub.core.migrations.graph.m041_deleted_dup_edges import DeleteDuplicatedRelationshipEdges
+from infrahub.core.migrations.shared import ArbitraryMigration, MigrationResult, get_migration_console
+from infrahub.core.query import Query, QueryType
+
+if TYPE_CHECKING:
+    from infrahub.database import InfrahubDatabase
+
+
+class UndeleteRelationshipProperties(Query):
+    """
+    Find Relationship vertices that are missing IS_VISIBLE and/or IS_PROTECTED edges linking them to Boolean vertices
+
+    Use the existing IS_RELATED edges to determine when the IS_VISIBLE/IS_PROTECTED edges should exist on each branch
+    and add the missing edges
+
+    Sets IS_VISIBLE to TRUE and IS_PROTECTED to FALSE
+    """
+
+    name = "undelete_relationship_properties"
+    type = QueryType.WRITE
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
+        query = """
+// --------------
+// find all Relationships that are missing IS_VISIBLE/IS_PROTECTED edges
+// --------------
+MATCH (rel:Relationship)-[:IS_RELATED]-()
+WHERE NOT exists((rel)-[:IS_VISIBLE]->())
+OR NOT exists((rel)-[:IS_PROTECTED]->())
+WITH DISTINCT rel
+WITH rel, exists((rel)-[:IS_VISIBLE]->()) AS has_visible, exists((rel)-[:IS_PROTECTED]->()) AS has_protected
+WHERE has_visible = FALSE OR has_protected = FALSE
+
+// --------------
+// one row for each branch the Relationship has changes on
+// --------------
+CALL (rel) {
+    MATCH (rel)-[e:IS_RELATED]-()
+    RETURN DISTINCT e.branch AS branch
+}
+
+// --------------
+// get the earliest from edge on this branch, if any
+// --------------
+CALL (rel, branch) {
+    OPTIONAL MATCH (rel)-[e:IS_RELATED {status: "active", branch: branch}]-()
+    // ignore schema kind/inheritance migration edges
+    WHERE NOT exists((rel)-[:IS_RELATED {status: "deleted", branch: branch, from: e.from}]-())
+    RETURN e AS earliest_from_edge
+    ORDER BY e.from ASC
+    LIMIT 1
+}
+
+// --------------
+// get the latest to time on this branch, if any
+// --------------
+CALL (rel, branch) {
+    OPTIONAL MATCH (rel)-[e:IS_RELATED {status: "active", branch: branch}]-()
+    // ignore schema kind/inheritance migration edges
+    WHERE NOT exists((rel)-[:IS_RELATED {status: "active", branch: branch, from: e.to}]-())
+    RETURN e.to AS latest_to_time
+    ORDER BY e.to DESC
+    LIMIT 1
+}
+
+// --------------
+// get the latest deleted edge on this branch, if any
+// --------------
+CALL (rel, branch) {
+    OPTIONAL MATCH (rel)-[deleted_e:IS_RELATED {status: "deleted", branch: branch}]-()
+    // ignore schema kind/inheritance migration edges
+    WHERE NOT exists((rel)-[:IS_RELATED {status: "active", branch: branch, from: deleted_e.from}]-())
+    RETURN deleted_e AS latest_deleted_edge
+    ORDER BY deleted_e.from DESC
+    LIMIT 1
+}
+
+// --------------
+// add active IS_VISIBLE edge on the branch, if necessary
+// --------------
+CALL (rel, earliest_from_edge, latest_to_time, has_visible) {
+    WITH *, has_visible
+    WHERE has_visible = FALSE
+    AND earliest_from_edge IS NOT NULL
+    MERGE (bool:Boolean {value: TRUE})
+    CREATE (rel)-[new_edge:IS_VISIBLE]->(bool)
+    SET new_edge = properties(earliest_from_edge)
+    SET new_edge.to = latest_to_time
+}
+// --------------
+// add deleted IS_VISIBLE edge on the branch, if necessary
+// --------------
+CALL (rel, latest_deleted_edge, has_visible) {
+    WITH *, has_visible
+    WHERE has_visible = FALSE
+    AND latest_deleted_edge IS NOT NULL
+    MERGE (bool:Boolean {value: TRUE})
+    CREATE (rel)-[new_edge:IS_VISIBLE]->(bool)
+    SET new_edge = properties(latest_deleted_edge)
+}
+// --------------
+// add active IS_PROTECTED edge on the branch, if necessary
+// --------------
+CALL (rel, earliest_from_edge, latest_to_time, has_protected) {
+    WITH *, has_protected
+    WHERE has_protected = FALSE
+    AND earliest_from_edge IS NOT NULL
+    MERGE (bool:Boolean {value: FALSE})
+    CREATE (rel)-[new_edge:IS_PROTECTED]->(bool)
+    SET new_edge = properties(earliest_from_edge)
+    SET new_edge.to = latest_to_time
+}
+// --------------
+// add deleted IS_PROTECTED edge on the branch, if necessary
+// --------------
+CALL (rel, latest_deleted_edge, has_protected) {
+    WITH *, has_protected
+    WHERE has_protected = FALSE
+    AND latest_deleted_edge IS NOT NULL
+    MERGE (bool:Boolean {value: FALSE})
+    CREATE (rel)-[new_edge:IS_PROTECTED]->(bool)
+    SET new_edge = properties(latest_deleted_edge)
+}
+        """
+        self.add_to_query(query)
+
+
+class Migration048(ArbitraryMigration):
+    """
+    Fix Relationship vertices that are missing IS_VISIBLE and/or IS_PROTECTED edges.
+
+    This can happen due to a bug in Migration041 that deleted these edges incorrectly.
+    """
+
+    name: str = "048_undelete_rel_props"
+    minimum_version: int = 47
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        return MigrationResult()
+
+    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+        console = get_migration_console()
+
+        console.log("Deleting duplicate edges for all Relationships", end="...")
+        delete_duplicate_edges_query = await DeleteDuplicatedRelationshipEdges.init(
+            db=db, migrated_kind_nodes_only=False
+        )
+        await delete_duplicate_edges_query.execute(db=db)
+        console.log("done")
+
+        console.log("Undeleting Relationship properties", end="...")
+        undelete_rel_props_query = await UndeleteRelationshipProperties.init(db=db)
+        await undelete_rel_props_query.execute(db=db)
+        console.log("done")
+
+        return MigrationResult()

{infrahub_server-1.6.1 → infrahub_server-1.6.3}/backend/infrahub/core/migrations/schema/attribute_kind_update.py

@@ -34,7 +34,7 @@ class AttributeKindUpdateMigrationQuery(AttributeMigrationQuery):
 // ------------
 // start with all the Attribute vertices we might care about
 // ------------
-MATCH (n:%(schema_kind)s)-[:HAS_ATTRIBUTE]->(attr:Attribute)
+MATCH (n:%(schema_kinds)s)-[:HAS_ATTRIBUTE]->(attr:Attribute)
 WHERE attr.name = $attr_name
 WITH DISTINCT n, attr
 
@@ -70,7 +70,7 @@ CALL (av_is_default, av_value) {
 // ------------
 WITH 1 AS one
 LIMIT 1
-MATCH (n:%(schema_kind)s)-[:HAS_ATTRIBUTE]->(attr:Attribute)
+MATCH (n:%(schema_kinds)s)-[:HAS_ATTRIBUTE]->(attr:Attribute)
 WHERE attr.name = $attr_name
 WITH DISTINCT n, attr
 
@@ -88,7 +88,6 @@ CALL (n, attr) {
     RETURN has_value_e, av
 }
 
-
 // ------------
 // create and update the HAS_VALUE edges
 // ------------
@@ -136,7 +135,9 @@ CALL (has_value_e) {
     SET has_value_e.to = $at
 }
         """ % {
-            "schema_kind": self.migration.previous_schema.kind,
+            "schema_kinds": (
+                f"{self.migration.previous_schema.kind}|Profile{self.migration.previous_schema.kind}|Template{self.migration.previous_schema.kind}"
+            ),
             "branch_filter": branch_filter,
             "new_attr_value_labels": new_attr_value_labels,
         }

{infrahub_server-1.6.1 → infrahub_server-1.6.3}/backend/infrahub/core/query/__init__.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from abc import ABC, abstractmethod
 from collections import defaultdict
 from dataclasses import dataclass, field
 from enum import Enum
@@ -336,7 +335,7 @@ class QueryStat:
         return cls(**data)
 
 
-class Query(ABC):
+class Query:
     name: str = "base-query"
     type: QueryType
 
@@ -403,8 +402,12 @@ class Query(ABC):
 
         return query
 
-    @abstractmethod
     async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+        # Avoid using this method for new queries and look at migrating older queries. The
+        # problem here is that we loose so much information with the `**kwargs` we should instead
+        # populate this information via the constructor and anything done within the existing query_init methods
+        # could either be handled within __init__ or via dedicated methods within each Query class where appropriate,
+        # i.e. things might need to happend in a certain order or we just want to separate the logic better.
         raise NotImplementedError
 
     def get_context(self) -> dict[str, str]:

{infrahub_server-1.6.1 → infrahub_server-1.6.3}/backend/infrahub/core/schema/attribute_parameters.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import sys
-from typing import Self
+from typing import Any, Self
 
 from pydantic import ConfigDict, Field, model_validator
 
@@ -24,6 +24,33 @@ def get_attribute_parameters_class_for_kind(kind: str) -> type[AttributeParamete
 class AttributeParameters(HashableModel):
     model_config = ConfigDict(extra="forbid")
 
+    @classmethod
+    def convert_from(cls, source: AttributeParameters) -> Self:
+        """Convert from another AttributeParameters subclass.
+
+        Args:
+            source: The source AttributeParameters instance to convert from
+
+        Returns:
+            A new instance of the target class with compatible fields populated
+        """
+        source_data = source.model_dump()
+        return cls.convert_from_dict(source_data=source_data)
+
+    @classmethod
+    def convert_from_dict(cls, source_data: dict[str, Any]) -> Self:
+        """Convert from a dictionary to the target class.
+
+        Args:
+            source_data: The source dictionary to convert from
+
+        Returns:
+            A new instance of the target class with compatible fields populated
+        """
+        target_fields = set(cls.model_fields.keys())
+        filtered_data = {k: v for k, v in source_data.items() if k in target_fields}
+        return cls(**filtered_data)
+
 
 class TextAttributeParameters(AttributeParameters):
     regex: str | None = Field(

{infrahub_server-1.6.1 → infrahub_server-1.6.3}/backend/infrahub/core/schema/attribute_schema.py

@@ -114,13 +114,20 @@ class AttributeSchema(GeneratedAttributeSchema):
     @field_validator("parameters", mode="before")
     @classmethod
     def set_parameters_type(cls, value: Any, info: ValidationInfo) -> Any:
-        """Override parameters class if using base AttributeParameters class and should be using a subclass"""
+        """Override parameters class if using base AttributeParameters class and should be using a subclass.
+
+        This validator handles parameter type conversion when an attribute's kind changes.
+        Fields from the source that don't exist in the target are silently dropped.
+        Fields with the same name in both classes are preserved.
+        """
         kind = info.data["kind"]
         expected_parameters_class = get_attribute_parameters_class_for_kind(kind=kind)
         if value is None:
             return expected_parameters_class()
         if not isinstance(value, expected_parameters_class) and isinstance(value, AttributeParameters):
-            return expected_parameters_class(**value.model_dump())
+            return expected_parameters_class.convert_from(value)
+        if isinstance(value, dict):
+            return expected_parameters_class.convert_from_dict(source_data=value)
         return value
 
     @model_validator(mode="after")
@@ -238,19 +245,6 @@ class TextAttributeSchema(AttributeSchema):
         json_schema_extra={"update": UpdateSupport.VALIDATE_CONSTRAINT.value},
     )
 
-    @model_validator(mode="after")
-    def reconcile_parameters(self) -> Self:
-        if self.regex != self.parameters.regex:
-            final_regex = self.parameters.regex if self.parameters.regex is not None else self.regex
-            self.regex = self.parameters.regex = final_regex
-        if self.min_length != self.parameters.min_length:
-            final_min_length = self.parameters.min_length if self.parameters.min_length is not None else self.min_length
-            self.min_length = self.parameters.min_length = final_min_length
-        if self.max_length != self.parameters.max_length:
-            final_max_length = self.parameters.max_length if self.parameters.max_length is not None else self.max_length
-            self.max_length = self.parameters.max_length = final_max_length
-        return self
-
     def get_regex(self) -> str | None:
         return self.parameters.regex
 

{infrahub_server-1.6.1 → infrahub_server-1.6.3}/backend/infrahub/core/schema/schema_branch.py

@@ -54,7 +54,7 @@ from infrahub.core.schema import (
     SchemaRoot,
     TemplateSchema,
 )
-from infrahub.core.schema.attribute_parameters import NumberPoolParameters
+from infrahub.core.schema.attribute_parameters import NumberPoolParameters, TextAttributeParameters
 from infrahub.core.schema.attribute_schema import get_attribute_schema_class_for_kind
 from infrahub.core.schema.definitions.core import core_profile_schema_definition
 from infrahub.core.validators import CONSTRAINT_VALIDATOR_MAP
@@ -501,11 +501,76 @@ class SchemaBranch:
 
         return fields or None
 
+    def _text_attr_needs_reconciliation(self, attr: AttributeSchema) -> bool:
+        """Check if a Text attribute needs reconciliation between deprecated fields and parameters."""
+        if not isinstance(attr.parameters, TextAttributeParameters):
+            return False
+        return (
+            attr.regex != attr.parameters.regex
+            or attr.min_length != attr.parameters.min_length
+            or attr.max_length != attr.parameters.max_length
+        )
+
+    def _reconcile_text_attr(self, attr: AttributeSchema) -> None:
+        """Reconcile a single Text attribute's deprecated fields with parameters.
+
+        Parameters take precedence over deprecated top-level fields when both are set.
+        """
+        if not isinstance(attr.parameters, TextAttributeParameters):
+            return
+
+        # Sync regex: parameters takes precedence
+        if attr.parameters.regex is not None:
+            attr.regex = attr.parameters.regex
+        elif attr.regex is not None:
+            attr.parameters.regex = attr.regex
+
+        # Sync min_length: parameters takes precedence
+        if attr.parameters.min_length is not None:
+            attr.min_length = attr.parameters.min_length
+        elif attr.min_length is not None:
+            attr.parameters.min_length = attr.min_length
+
+        # Sync max_length: parameters takes precedence
+        if attr.parameters.max_length is not None:
+            attr.max_length = attr.parameters.max_length
+        elif attr.max_length is not None:
+            attr.parameters.max_length = attr.max_length
+
+    def _reconcile_text_attribute_parameters(self, schema: SchemaRoot | None = None) -> None:
+        """Reconcile regex, min_length, max_length between deprecated fields and parameters for Text attributes.
+
+        Args:
+            schema: If provided, reconcile incoming schema data before merging.
+                   If None, reconcile already-loaded schemas (e.g., from database).
+        """
+        if schema:
+            # Incoming schema: modify in place
+            for item in schema.nodes + schema.generics:
+                for attr in item.attributes:
+                    self._reconcile_text_attr(attr)
+            return
+
+        # Loaded schemas: need to duplicate before modifying
+        for name in self.all_names:
+            node = self.get(name=name, duplicate=False)
+
+            if not any(self._text_attr_needs_reconciliation(attr) for attr in node.attributes):
+                continue
+
+            node = node.duplicate()
+            for attr in node.attributes:
+                self._reconcile_text_attr(attr)
+            self.set(name=name, schema=node)
+
     def load_schema(self, schema: SchemaRoot) -> None:
         """Load a SchemaRoot object and store all NodeSchema or GenericSchema.
 
         In the current implementation, if a schema object present in the SchemaRoot already exist, it will be overwritten.
         """
+        # Reconcile deprecated text attribute parameters before merging
+        self._reconcile_text_attribute_parameters(schema)
+
         for item in schema.nodes + schema.generics:
             try:
                 if item.id:
@@ -545,6 +610,7 @@ class SchemaBranch:
         self.generate_identifiers()
         self.process_default_values()
         self.process_deprecations()
+        self._reconcile_text_attribute_parameters()
         self.process_cardinality_counts()
         self.process_inheritance()
         self.process_hierarchy()

{infrahub_server-1.6.1 → infrahub_server-1.6.3}/backend/infrahub/core/validators/attribute/kind.py

@@ -36,7 +36,7 @@ class AttributeKindUpdateValidatorQuery(AttributeSchemaValidatorQuery):
         self.params["null_value"] = NULL_VALUE
 
         query = """
-        MATCH p = (n:%(node_kind)s)
+        MATCH (n:%(node_kinds)s)
         CALL (n) {
             MATCH path = (root:Root)<-[rr:IS_PART_OF]-(n)-[ra:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name } )-[rv:HAS_VALUE]-(av:AttributeValue)
             WHERE all(
@@ -51,7 +51,10 @@ class AttributeKindUpdateValidatorQuery(AttributeSchemaValidatorQuery):
         WHERE all(r in relationships(full_path) WHERE r.status = "active")
         AND attribute_value IS NOT NULL
         AND attribute_value <> $null_value
-        """ % {"branch_filter": branch_filter, "node_kind": self.node_schema.kind}
+        """ % {
+            "branch_filter": branch_filter,
+            "node_kinds": f"{self.node_schema.kind}|Profile{self.node_schema.kind}|Template{self.node_schema.kind}",
+        }
 
         self.add_to_query(query)
         self.return_labels = ["node.uuid", "attribute_value", "value_relationship.branch as value_branch"]

{infrahub_server-1.6.1 → infrahub_server-1.6.3}/backend/infrahub/graphql/app.py

@@ -172,9 +172,9 @@ class InfrahubGraphQLApp:
 
         response = handler(request)
         if isawaitable(response):
-            return await cast("Awaitable[Response]", response)
+            return await response
 
-        return cast("Response", response)
+        return response
 
     async def _handle_http_request(
         self, request: Request, db: InfrahubDatabase, branch: Branch, account_session: AccountSession

{infrahub_server-1.6.1 → infrahub_server-1.6.3}/backend/infrahub/graphql/queries/diff/tree.py

@@ -60,10 +60,10 @@ class ConflictDetails(ObjectType):
 
 
 class DiffSummaryCounts(ObjectType):
-    num_added = Int(required=False)
-    num_updated = Int(required=False)
-    num_removed = Int(required=False)
-    num_conflicts = Int(required=False)
+    num_added = Int(required=True)
+    num_updated = Int(required=True)
+    num_removed = Int(required=True)
+    num_conflicts = Int(required=True)
 
 
 class DiffProperty(ObjectType):
@@ -146,7 +146,7 @@ class DiffTreeSummary(DiffSummaryCounts):
     diff_branch = String(required=True)
     from_time = DateTime(required=True)
     to_time = DateTime(required=True)
-    num_unchanged = Int(required=False)
+    num_unchanged = Int(required=True)
     num_untracked_base_changes = Int(required=False)
     num_untracked_diff_changes = Int(required=False)