infrahub-server 1.5.0b1__py3-none-any.whl → 1.5.1__py3-none-any.whl

infrahub/core/query/diff.py

@@ -301,13 +301,15 @@ WITH p, q, diff_rel, CASE
     ELSE $from_time
 END AS row_from_time
 ORDER BY %(id_func)s(p) DESC
-SKIP $offset
-LIMIT $limit
+SKIP toInteger($offset)
+LIMIT toInteger($limit)
 // -------------------------------------
 // Add flag to indicate if there is more data after this
 // -------------------------------------
 WITH collect([p, q, diff_rel, row_from_time]) AS limited_results
-WITH limited_results, size(limited_results) = $limit AS has_more_data
+// extra NULL row ensures that has_more_data is always returned, even if all results are filtered out below
+WITH limited_results + [[NULL, NULL, NULL, NULL]] AS limited_results
+WITH limited_results, size(limited_results) = ($limit + 1) AS has_more_data
 UNWIND limited_results AS one_result
 WITH one_result[0] AS p, one_result[1] AS q, one_result[2] AS diff_rel, one_result[3] AS row_from_time, has_more_data
 // -------------------------------------
@@ -470,14 +472,16 @@ AND (
 // Limit the number of paths
 // -------------------------------------
 WITH root, r_root, p, diff_rel, q
-ORDER BY r_root.from, p.uuid, q.uuid, diff_rel.branch, diff_rel.from
-SKIP $offset
-LIMIT $limit
+ORDER BY r_root.from, p.uuid, q.uuid, q.name, diff_rel.branch, diff_rel.from
+SKIP toInteger($offset)
+LIMIT toInteger($limit)
 // -------------------------------------
 // Add flag to indicate if there is more data after this
 // -------------------------------------
 WITH collect([root, r_root, p, diff_rel, q]) AS limited_results
-WITH limited_results, size(limited_results) = $limit AS has_more_data
+// extra NULL row ensures that has_more_data is always returned, even if all results are filtered out below
+WITH limited_results + [[NULL, NULL, NULL, NULL, NULL]] AS limited_results
+WITH limited_results, size(limited_results) = ($limit + 1) AS has_more_data
 UNWIND limited_results AS one_result
 WITH one_result[0] AS root, one_result[1] AS r_root, one_result[2] AS p, one_result[3] AS diff_rel, one_result[4] AS q, has_more_data
 // -------------------------------------
@@ -641,8 +645,28 @@ AND (
         )
         // skip paths where nodes/attrs/rels are updated after $from_time, those are handled in other queries
         AND (
-            r_root.from <= $from_time AND (r_root.to IS NULL OR r_root.branch <> diff_rel.branch OR r_root.to <= $from_time)
-            AND r_node.from <= $from_time AND (r_node.to IS NULL OR r_node.branch <> diff_rel.branch OR r_node.to <= $from_time)
+            (
+                r_root.branch = diff_rel.branch
+                AND r_root.from <= $from_time
+                AND (r_root.to IS NULL OR r_root.to >= $to_time)
+            )
+            OR (
+                r_root.branch <> diff_rel.branch
+                AND r_root.from <= $from_time
+                AND (r_root.to IS NULL OR r_root.to >= $branch_from_time)
+            )
+        )
+        AND (
+            (
+                r_node.branch = diff_rel.branch
+                AND r_node.from <= $from_time
+                AND (r_node.to IS NULL OR r_node.to >= $to_time)
+            )
+            OR (
+                r_node.branch <> diff_rel.branch
+                AND r_node.from <= $from_time
+                AND (r_node.to IS NULL OR r_node.to >= $branch_from_time)
+            )
         )
     )
     // time-based filters for new nodes
@@ -658,8 +682,27 @@ AND (
         )
         // skip paths where nodes/attrs/rels are updated after $branch_from_time, those are handled in other queries
         AND (
-            r_root.from <= $branch_from_time AND (r_root.to IS NULL OR r_root.branch <> diff_rel.branch OR r_root.to <= $branch_from_time)
-            AND r_node.from <= $branch_from_time AND (r_node.to IS NULL OR r_node.branch <> diff_rel.branch OR r_node.to <= $branch_from_time)
+            (
+                r_root.branch = diff_rel.branch
+                AND (r_root.to IS NULL OR r_root.to >= $to_time)
+            )
+            OR (
+                r_root.branch <> diff_rel.branch
+                AND r_root.from <= $branch_from_time
+                AND (r_root.to IS NULL OR r_root.to >= $branch_from_time)
+            )
+        )
+        AND (
+            (
+                r_node.branch = diff_rel.branch
+                AND r_node.from <= $branch_from_time
+                AND (r_node.to IS NULL OR r_node.to >= $to_time)
+            )
+            OR (
+                r_node.branch <> diff_rel.branch
+                AND r_node.from <= $branch_from_time
+                AND (r_node.to IS NULL OR r_node.to >= $branch_from_time)
+            )
         )
     )
 )
@@ -701,13 +744,15 @@ AND [%(id_func)s(n), type(r_node)] <> [%(id_func)s(q), type(diff_rel)]
 // -------------------------------------
 WITH diff_rel_path, r_root, n, r_node, p, diff_rel
 ORDER BY r_root.from, n.uuid, p.uuid, type(diff_rel), diff_rel.branch, diff_rel.from
-SKIP $offset
-LIMIT $limit
+SKIP toInteger($offset)
+LIMIT toInteger($limit)
 // -------------------------------------
 // Add flag to indicate if there is more data after this
 // -------------------------------------
 WITH collect([diff_rel_path, r_root, n, r_node, p, diff_rel]) AS limited_results
-WITH limited_results, size(limited_results) = $limit AS has_more_data
+// extra NULL row ensures that has_more_data is always returned, even if all results are filtered out below
+WITH limited_results + [[NULL, NULL, NULL, NULL, NULL, NULL]] AS limited_results
+WITH limited_results, size(limited_results) = ($limit + 1) AS has_more_data
 UNWIND limited_results AS one_result
 WITH one_result[0] AS diff_rel_path, one_result[1] AS r_root, one_result[2] AS n,
     one_result[3] AS r_node, one_result[4] AS p, one_result[5] AS diff_rel, has_more_data
@@ -803,8 +848,8 @@ WHERE num_nodes_with_uuid > 1
 // -------------------------------------
 WITH node_uuid
 ORDER BY node_uuid
-SKIP $offset
-LIMIT $limit
+SKIP toInteger($offset)
+LIMIT toInteger($limit)
 WITH collect(node_uuid) AS node_uuids
 WITH node_uuids, size(node_uuids) = $limit AS has_more_data
 MATCH (:Root)<-[diff_rel:IS_PART_OF {branch: $branch_name}]-(n:Node)

infrahub/core/query/ipam.py

@@ -450,12 +450,23 @@ class IPPrefixReconcileQuery(Query):
         // ------------------
         CALL (ip_node) {
             OPTIONAL MATCH parent_prefix_path = (ip_node)-[r1:IS_RELATED]->(:Relationship {name: "parent__child"})-[r2:IS_RELATED]->(current_parent:%(ip_prefix_kind)s)
-            WHERE all(r IN relationships(parent_prefix_path) WHERE (%(branch_filter)s))
+            WHERE $is_prefix = TRUE
+            AND all(r IN relationships(parent_prefix_path) WHERE (%(branch_filter)s))
             RETURN current_parent, (r1.status = "active" AND r2.status = "active") AS parent_is_active
             ORDER BY r1.branch_level DESC, r1.from DESC, r1.status ASC, r2.branch_level DESC, r2.from DESC, r2.status ASC
             LIMIT 1
         }
-        WITH ip_namespace, ip_node, CASE WHEN parent_is_active THEN current_parent ELSE NULL END as current_parent
+        WITH ip_namespace, ip_node, CASE WHEN parent_is_active THEN current_parent ELSE NULL END as prefix_parent
+        CALL (ip_node) {
+            OPTIONAL MATCH parent_prefix_path = (ip_node)-[r1:IS_RELATED]->(:Relationship {name: "ip_prefix__ip_address"})<-[r2:IS_RELATED]-(current_parent:%(ip_prefix_kind)s)
+            WHERE $is_prefix = FALSE
+            AND all(r IN relationships(parent_prefix_path) WHERE (%(branch_filter)s))
+            RETURN current_parent, (r1.status = "active" AND r2.status = "active") AS parent_is_active
+            ORDER BY r1.branch_level DESC, r1.from DESC, r1.status ASC, r2.branch_level DESC, r2.from DESC, r2.status ASC
+            LIMIT 1
+        }
+        WITH ip_namespace, ip_node, prefix_parent, CASE WHEN parent_is_active THEN current_parent ELSE NULL END as address_parent
+        WITH ip_namespace, ip_node, COALESCE(prefix_parent, address_parent) AS current_parent
         """ % {
             "branch_filter": branch_filter,
             "ip_prefix_kind": InfrahubKind.IPPREFIX,
@@ -467,7 +478,7 @@ class IPPrefixReconcileQuery(Query):
         // Get prefix node's current prefix children, if any exist
         // ------------------
         CALL (ip_node) {
-            OPTIONAL MATCH child_prefix_path = (ip_node)<-[r1:IS_RELATED]-(:Relationship {name: "parent__child"})<-[r2:IS_RELATED]-(current_prefix_child:%(ip_prefix_kind)s)
+            OPTIONAL MATCH child_prefix_path = (ip_node:%(ip_prefix_kind)s)<-[r1:IS_RELATED]-(:Relationship {name: "parent__child"})<-[r2:IS_RELATED]-(current_prefix_child:%(ip_prefix_kind)s)
             WHERE all(r IN relationships(child_prefix_path) WHERE (%(branch_filter)s))
             WITH current_prefix_child, (r1.status = "active" AND r2.status = "active") AS is_active
             ORDER BY current_prefix_child.uuid, r1.branch_level DESC, r1.from DESC, r2.branch_level DESC, r2.from DESC
@@ -479,7 +490,7 @@ class IPPrefixReconcileQuery(Query):
         // Get prefix node's current address children, if any exist
         // ------------------
         CALL (ip_node) {
-            OPTIONAL MATCH child_address_path = (ip_node)-[r1:IS_RELATED]-(:Relationship {name: "ip_prefix__ip_address"})-[r2:IS_RELATED]-(current_address_child:%(ip_address_kind)s)
+            OPTIONAL MATCH child_address_path = (ip_node:%(ip_prefix_kind)s)-[r1:IS_RELATED]->(:Relationship {name: "ip_prefix__ip_address"})<-[r2:IS_RELATED]-(current_address_child:%(ip_address_kind)s)
             WHERE all(r IN relationships(child_address_path) WHERE (%(branch_filter)s))
             WITH current_address_child, (r1.status = "active" AND r2.status = "active") AS is_active
             ORDER BY current_address_child.uuid, r1.branch_level DESC, r1.from DESC, r2.branch_level DESC, r2.from DESC
@@ -688,6 +699,7 @@ class IPPrefixReconcileQuery(Query):
             "ip_address_attribute_kind": ADDRESS_ATTRIBUTE_LABEL,
         }
         self.add_to_query(get_new_children_query)
+        self.order_by = ["ip_node.uuid"]
         self.return_labels = ["ip_node", "current_parent", "current_children", "new_parent", "new_children"]
 
     def _get_uuid_from_query(self, node_name: str) -> str | None:

infrahub/core/query/node.py

@@ -246,11 +246,15 @@ class NodeCreateAllQuery(NodeQuery):
         ipnetwork_prop_list = [f"{key}: {value}" for key, value in ipnetwork_prop.items()]
 
         attrs_nonindexed_query = """
-        WITH distinct n
+        WITH DISTINCT n
         UNWIND $attrs AS attr
         // Try to find a matching vertex
-        OPTIONAL MATCH (existing_av:AttributeValue {value: attr.content.value, is_default: attr.content.is_default})
-        WHERE NOT existing_av:AttributeValueIndexed
+        CALL (attr) {
+            OPTIONAL MATCH (existing_av:AttributeValue {value: attr.content.value, is_default: attr.content.is_default})
+            WHERE NOT existing_av:AttributeValueIndexed
+            RETURN existing_av
+            LIMIT 1
+        }
         CALL (attr, existing_av) {
             // If none found, create a new one
             WITH existing_av
@@ -638,53 +642,55 @@ class NodeListGetAttributeQuery(Query):
         self.add_to_query(query)
 
         query = """
-        CALL (n, a) {
-            MATCH (n)-[r:HAS_ATTRIBUTE]-(a:Attribute)
-            WHERE %(branch_filter)s
-            RETURN r AS r1
-            ORDER BY r.branch_level DESC, r.from DESC
-            LIMIT 1
-        }
-        WITH n, r1, a, might_use_profile
-        WHERE r1.status = "active"
-        WITH n, r1, a, might_use_profile
-        MATCH (a)-[r:HAS_VALUE]-(av:AttributeValue)
-        WHERE %(branch_filter)s
-        CALL (a, might_use_profile) {
-            OPTIONAL MATCH (a)-[r:HAS_SOURCE]->(:CoreProfile)
-            WHERE might_use_profile = TRUE AND %(branch_filter)s
-            RETURN r.status = "active" AS has_active_profile
-            ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
-            LIMIT 1
-        }
-        WITH *, has_active_profile = TRUE AS is_from_profile
-        CALL (a, av) {
-            MATCH (a)-[r:HAS_VALUE]-(av:AttributeValue)
-            WHERE %(branch_filter)s
-            RETURN a as a1, r as r2, av as av1
-            ORDER BY r.branch_level DESC, r.from DESC
-            LIMIT 1
-        }
-        WITH n, r1, a1 as a, r2, av1 as av, is_from_profile
-        WHERE r2.status = "active"
-        WITH n, a, av, r1, r2, is_from_profile
+CALL (n, a) {
+    MATCH (n)-[r:HAS_ATTRIBUTE]-(a:Attribute)
+    WHERE %(branch_filter)s
+    RETURN r AS r1
+    ORDER BY r.branch_level DESC, r.from DESC
+    LIMIT 1
+}
+WITH n, r1, a, might_use_profile
+WHERE r1.status = "active"
+WITH n, r1, a, might_use_profile
+CALL (a, might_use_profile) {
+    OPTIONAL MATCH (a)-[r:HAS_SOURCE]->(:CoreProfile)
+    WHERE might_use_profile = TRUE AND %(branch_filter)s
+    RETURN r.status = "active" AS has_active_profile
+    ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+    LIMIT 1
+}
+WITH *, has_active_profile = TRUE AS is_from_profile
+CALL (a) {
+    MATCH (a)-[r:HAS_VALUE]-(av:AttributeValue)
+    WHERE %(branch_filter)s
+    RETURN r as r2, av
+    ORDER BY r.branch_level DESC, r.from DESC
+    LIMIT 1
+}
+WITH n, r1, a, r2, av, is_from_profile
+WHERE r2.status = "active"
         """ % {"branch_filter": branch_filter}
         self.add_to_query(query)
 
         self.return_labels = ["n", "a", "av", "r1", "r2", "is_from_profile"]
 
         # Add Is_Protected and Is_visible
-        rel_isv_branch_filter, _ = self.branch.get_query_filter_path(
-            at=self.at, branch_agnostic=self.branch_agnostic, variable_name="rel_isv"
-        )
-        rel_isp_branch_filter, _ = self.branch.get_query_filter_path(
-            at=self.at, branch_agnostic=self.branch_agnostic, variable_name="rel_isp"
-        )
         query = """
-        MATCH (a)-[rel_isv:IS_VISIBLE]-(isv:Boolean)
-        MATCH (a)-[rel_isp:IS_PROTECTED]-(isp:Boolean)
-        WHERE (%(rel_isv_branch_filter)s) AND (%(rel_isp_branch_filter)s)
-        """ % {"rel_isv_branch_filter": rel_isv_branch_filter, "rel_isp_branch_filter": rel_isp_branch_filter}
+CALL (a) {
+    MATCH (a)-[r:IS_VISIBLE]-(isv:Boolean)
+    WHERE (%(branch_filter)s)
+    RETURN r AS rel_isv, isv
+    ORDER BY rel_isv.branch_level DESC, rel_isv.from DESC, rel_isv.status ASC
+    LIMIT 1
+}
+CALL (a) {
+    MATCH (a)-[r:IS_PROTECTED]-(isp:Boolean)
+    WHERE (%(branch_filter)s)
+    RETURN r AS rel_isp, isp
+    ORDER BY rel_isp.branch_level DESC, rel_isp.from DESC, rel_isp.status ASC
+    LIMIT 1
+}
+        """ % {"branch_filter": branch_filter}
         self.add_to_query(query)
 
         self.return_labels.extend(["isv", "isp", "rel_isv", "rel_isp"])
@@ -915,6 +921,7 @@ class NodeListGetRelationshipsQuery(Query):
         RETURN DISTINCT n_uuid, rel_name, peer_uuid, direction
         """ % {"filters": rels_filter}
         self.add_to_query(query)
+        self.order_by = ["n_uuid", "rel_name", "peer_uuid", "direction"]
         self.return_labels = ["n_uuid", "rel_name", "peer_uuid", "direction"]
 
     def get_peers_group_by_node(self) -> GroupedPeerNodes:
@@ -984,6 +991,7 @@ class NodeListGetInfoQuery(Query):
         )
         self.params.update(branch_params)
         self.params["ids"] = self.ids
+        self.order_by = ["n.uuid"]
 
         query = """
         MATCH p = (root:Root)<-[:IS_PART_OF]-(n:Node)

infrahub/core/query/relationship.py

@@ -1036,6 +1036,7 @@ class RelationshipCountPerNodeQuery(Query):
         """ % {"branch_filter": branch_filter, "path": path}
 
         self.add_to_query(query)
+        self.order_by = ["peer_node.uuid"]
         self.return_labels = ["peer_node.uuid", "COUNT(peer_node.uuid) as nbr_peers"]
 
     async def get_count_per_peer(self) -> dict[str, int]:

infrahub/core/relationship/model.py

@@ -445,15 +445,20 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
         )
         await delete_query.execute(db=db)
 
-    async def resolve(self, db: InfrahubDatabase, at: Timestamp | None = None) -> None:
+    async def resolve(self, db: InfrahubDatabase, at: Timestamp | None = None, fields: list[str] | None = None) -> None:
         """Resolve the peer of the relationship."""
 
+        fields = fields or []
+        query_fields = dict.fromkeys(fields)
+        if "display_label" not in query_fields:
+            query_fields["display_label"] = None
+
         if self._peer is not None:
             return
 
         if self.peer_id and not is_valid_uuid(self.peer_id):
             peer = await registry.manager.get_one_by_default_filter(
-                db=db, id=self.peer_id, branch=self.branch, kind=self.schema.peer, fields={"display_label": None}
+                db=db, id=self.peer_id, branch=self.branch, kind=self.schema.peer, fields=query_fields
             )
             if peer:
                 self.set_peer(value=peer)
@@ -470,7 +475,7 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
                 hfid=self.peer_hfid,
                 branch=self.branch,
                 kind=kind,
-                fields={"display_label": None},
+                fields=query_fields,
                 raise_on_error=True,
             )
             self.set_peer(value=peer)
@@ -1142,9 +1147,9 @@ class RelationshipManager:
 
         return True
 
-    async def resolve(self, db: InfrahubDatabase) -> None:
+    async def resolve(self, db: InfrahubDatabase, fields: list[str] | None = None) -> None:
         for rel in self._relationships:
-            await rel.resolve(db=db)
+            await rel.resolve(db=db, fields=fields)
 
     async def remove_locally(
         self,

infrahub/core/schema/__init__.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import uuid
+from enum import Enum
 from typing import Any, TypeAlias
 
 from infrahub_sdk.utils import deep_merge_dict
@@ -44,6 +45,21 @@ class SchemaExtension(HashableModel):
     nodes: list[NodeExtensionSchema] = Field(default_factory=list)
 
 
+class SchemaWarningType(Enum):
+    DEPRECATION = "deprecation"
+
+
+class SchemaWarningKind(BaseModel):
+    kind: str = Field(..., description="The kind impacted by the warning")
+    field: str | None = Field(default=None, description="The attribute or relationship impacted by the warning")
+
+
+class SchemaWarning(BaseModel):
+    type: SchemaWarningType = Field(..., description="The type of warning")
+    kinds: list[SchemaWarningKind] = Field(default_factory=list, description="The kinds impacted by the warning")
+    message: str = Field(..., description="The message that describes the warning")
+
+
 class SchemaRoot(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
@@ -80,6 +96,46 @@ class SchemaRoot(BaseModel):
 
         return errors
 
+    def gather_warnings(self) -> list[SchemaWarning]:
+        models = self.nodes + self.generics
+        warnings: list[SchemaWarning] = []
+        for model in models:
+            if model.display_labels is not None:
+                warnings.append(
+                    SchemaWarning(
+                        type=SchemaWarningType.DEPRECATION,
+                        kinds=[SchemaWarningKind(kind=model.kind)],
+                        message="display_labels are deprecated, use display_label instead",
+                    )
+                )
+            if model.default_filter is not None:
+                warnings.append(
+                    SchemaWarning(
+                        type=SchemaWarningType.DEPRECATION,
+                        kinds=[SchemaWarningKind(kind=model.kind)],
+                        message="default_filter is deprecated",
+                    )
+                )
+            for attribute in model.attributes:
+                if attribute.max_length is not None:
+                    warnings.append(
+                        SchemaWarning(
+                            type=SchemaWarningType.DEPRECATION,
+                            kinds=[SchemaWarningKind(kind=model.kind, field=attribute.name)],
+                            message="Use of 'max_length' on attributes is deprecated, use parameters instead",
+                        )
+                    )
+                if attribute.min_length is not None:
+                    warnings.append(
+                        SchemaWarning(
+                            type=SchemaWarningType.DEPRECATION,
+                            kinds=[SchemaWarningKind(kind=model.kind, field=attribute.name)],
+                            message="Use of 'min_length' on attributes is deprecated, use parameters instead",
+                        )
+                    )
+
+        return warnings
+
     def generate_uuid(self) -> None:
         """Generate UUID for all nodes, attributes & relationships
         Mainly useful during unit tests."""

infrahub/core/schema/attribute_schema.py

@@ -68,6 +68,10 @@ class AttributeSchema(GeneratedAttributeSchema):
     def is_deprecated(self) -> bool:
         return bool(self.deprecation)
 
+    @property
+    def support_profiles(self) -> bool:
+        return self.read_only is False and self.optional is True
+
     def get_id(self) -> str:
         if self.id is None:
             raise InitializationError("The attribute schema has not been saved yet and doesn't have an id")

infrahub/core/schema/definitions/core/check.py

@@ -29,7 +29,7 @@ core_check_definition = NodeSchema(
         Attr(name="description", kind="Text", optional=True),
         Attr(name="file_path", kind="Text"),
         Attr(name="class_name", kind="Text"),
-        Attr(name="timeout", kind="Number", default_value=10),
+        Attr(name="timeout", kind="Number", default_value=60),
         Attr(name="parameters", kind="JSON", optional=True),
     ],
     relationships=[

infrahub/core/schema/definitions/core/transform.py

@@ -29,7 +29,7 @@ core_transform = GenericSchema(
         Attr(name="name", kind="Text", unique=True),
         Attr(name="label", kind="Text", optional=True),
         Attr(name="description", kind="Text", optional=True),
-        Attr(name="timeout", kind="Number", default_value=10),
+        Attr(name="timeout", kind="Number", default_value=60),
     ],
     relationships=[
         Rel(

infrahub/core/schema/definitions/internal.py

@@ -568,7 +568,7 @@ attribute_schema = SchemaNode(
             "Mainly relevant for internal object.",
             default_value=False,
             optional=True,
-            extra={"update": UpdateSupport.ALLOWED},
+            extra={"update": UpdateSupport.MIGRATION_REQUIRED},
         ),
         SchemaAttribute(
             name="unique",
@@ -585,7 +585,7 @@ attribute_schema = SchemaNode(
             default_value=False,
             override_default_value=False,
             optional=True,
-            extra={"update": UpdateSupport.VALIDATE_CONSTRAINT},
+            extra={"update": UpdateSupport.MIGRATION_REQUIRED},
         ),
         SchemaAttribute(
             name="branch",

infrahub/core/schema/generated/attribute_schema.py

@@ -78,7 +78,7 @@ class GeneratedAttributeSchema(HashableModel):
     read_only: bool = Field(
         default=False,
         description="Set the attribute as Read-Only, users won't be able to change its value. Mainly relevant for internal object.",
-        json_schema_extra={"update": "allowed"},
+        json_schema_extra={"update": "migration_required"},
     )
     unique: bool = Field(
         default=False,
@@ -88,7 +88,7 @@ class GeneratedAttributeSchema(HashableModel):
     optional: bool = Field(
         default=False,
         description="Indicate if this attribute is mandatory or optional.",
-        json_schema_extra={"update": "validate_constraint"},
+        json_schema_extra={"update": "migration_required"},
     )
     branch: BranchSupportType | None = Field(
         default=None,

infrahub/core/schema/manager.py

@@ -2,6 +2,9 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
+from cachetools import LRUCache
+from infrahub_sdk.schema import BranchSchema as SDKBranchSchema
+
 from infrahub import lock
 from infrahub.core.manager import NodeManager
 from infrahub.core.models import (
@@ -40,6 +43,8 @@ class SchemaManager(NodeManager):
     def __init__(self) -> None:
         self._cache: dict[int, Any] = {}
         self._branches: dict[str, SchemaBranch] = {}
+        self._branch_hash_by_name: dict[str, str] = {}
+        self._sdk_branches: LRUCache[str, SDKBranchSchema] = LRUCache(maxsize=10)
 
     def _get_from_cache(self, key: int) -> Any:
         return self._cache[key]
@@ -140,12 +145,26 @@ class SchemaManager(NodeManager):
         if name in self._branches:
             return self._branches[name]
 
-        self._branches[name] = SchemaBranch(cache=self._cache, name=name)
+        self.set_schema_branch(name, schema=SchemaBranch(cache=self._cache, name=name))
         return self._branches[name]
 
+    def get_sdk_schema_branch(self, name: str) -> SDKBranchSchema:
+        schema_hash = self._branch_hash_by_name[name]
+        branch_schema = self._sdk_branches.get(schema_hash)
+        if not branch_schema:
+            self._sdk_branches[schema_hash] = SDKBranchSchema.from_api_response(
+                data=self._branches[name].to_dict_api_schema_object()
+            )
+
+        return self._sdk_branches[schema_hash]
+
     def set_schema_branch(self, name: str, schema: SchemaBranch) -> None:
         schema.name = name
         self._branches[name] = schema
+        self._branch_hash_by_name[name] = schema.get_hash()
+
+    def has_schema_branch(self, name: str) -> bool:
+        return name in self._branches
 
     def process_schema_branch(self, name: str) -> None:
         schema_branch = self.get_schema_branch(name=name)
@@ -764,6 +783,8 @@ class SchemaManager(NodeManager):
         for branch_name in list(self._branches.keys()):
             if branch_name not in active_branches:
                 del self._branches[branch_name]
+                if branch_name in self._branch_hash_by_name:
+                    del self._branch_hash_by_name[branch_name]
                 removed_branches.append(branch_name)
 
         for hash_key in list(self._cache.keys()):