infrahub-server 1.3.5__py3-none-any.whl → 1.4.0b0__py3-none-any.whl

infrahub/core/query/attribute.py

@@ -5,9 +5,16 @@ from typing import TYPE_CHECKING, Any
 from infrahub.core.constants import AttributeDBNodeType
 from infrahub.core.constants.relationship_label import RELATIONSHIP_TO_NODE_LABEL, RELATIONSHIP_TO_VALUE_LABEL
 from infrahub.core.constants.schema import FlagProperty, NodeProperty
+from infrahub.core.graph.schema import (
+    GraphAttributeIPHostNode,
+    GraphAttributeIPNetworkNode,
+    GraphAttributeValueIndexedNode,
+    GraphAttributeValueNode,
+)
 from infrahub.core.query import Query, QueryNode, QueryRel, QueryType
 from infrahub.core.timestamp import Timestamp
 from infrahub.core.utils import build_regex_attrs
+from infrahub.types import is_large_attribute_type
 
 if TYPE_CHECKING:
     from infrahub.core.attribute import BaseAttribute
@@ -56,12 +63,14 @@ class AttributeUpdateValueQuery(AttributeQuery):
 
         prop_list = [f"{key}: ${key}" for key in content.keys()]
 
-        labels = ["AttributeValue"]
+        labels = [GraphAttributeValueNode.get_default_label()]
         node_type = self.attr.get_db_node_type()
-        if node_type == AttributeDBNodeType.IPHOST:
-            labels.append("AttributeIPHost")
-        elif node_type == AttributeDBNodeType.IPNETWORK:
-            labels.append("AttributeIPNetwork")
+        if AttributeDBNodeType.INDEXED in node_type:
+            labels.append(GraphAttributeValueIndexedNode.get_default_label())
+        if AttributeDBNodeType.IPHOST in node_type:
+            labels.append(GraphAttributeIPHostNode.get_default_label())
+        if AttributeDBNodeType.IPNETWORK in node_type:
+            labels.append(GraphAttributeIPNetworkNode.get_default_label())
 
         query = """
         MATCH (a:Attribute { uuid: $attr_uuid })
@@ -198,6 +207,9 @@ async def default_attribute_query_filter(
     support_profiles: bool = False,
 ) -> tuple[list[QueryElement], dict[str, Any], list[str]]:
     """Generate Query String Snippet to filter the right node."""
+    attribute_value_label = GraphAttributeValueNode.get_default_label()
+    if attribute_kind and not is_large_attribute_type(attribute_kind):
+        attribute_value_label = GraphAttributeValueIndexedNode.get_default_label()
 
     query_filter: list[QueryElement] = []
     query_params: dict[str, Any] = {}
@@ -226,33 +238,35 @@ async def default_attribute_query_filter(
         query_filter.append(QueryRel(labels=[RELATIONSHIP_TO_VALUE_LABEL]))
 
         if filter_value is None:
-            query_filter.append(QueryNode(name="av", labels=["AttributeValue"]))
+            query_filter.append(QueryNode(name="av", labels=[attribute_value_label]))
         else:
             if partial_match:
-                query_filter.append(QueryNode(name="av", labels=["AttributeValue"]))
+                query_filter.append(QueryNode(name="av", labels=[attribute_value_label]))
                 query_where.append(
                     f"toLower(toString(av.{filter_name})) CONTAINS toLower(toString(${param_prefix}_{filter_name}))"
                 )
             elif attribute_kind and attribute_kind == "List" and not isinstance(filter_value, list):
-                query_filter.append(QueryNode(name="av", labels=["AttributeValue"]))
+                query_filter.append(QueryNode(name="av", labels=[attribute_value_label]))
                 filter_value = build_regex_attrs(values=[filter_value])
                 query_where.append(f"toString(av.{filter_name}) =~ ${param_prefix}_{filter_name}")
             elif filter_name == "isnull":
-                query_filter.append(QueryNode(name="av", labels=["AttributeValue"]))
+                query_filter.append(QueryNode(name="av", labels=[attribute_value_label]))
             elif support_profiles:
-                query_filter.append(QueryNode(name="av", labels=["AttributeValue"]))
+                query_filter.append(QueryNode(name="av", labels=[attribute_value_label]))
                 query_where.append(f"(av.{filter_name} = ${param_prefix}_{filter_name} OR av.is_default)")
             else:
                 query_filter.append(
                     QueryNode(
-                        name="av", labels=["AttributeValue"], params={filter_name: f"${param_prefix}_{filter_name}"}
+                        name="av",
+                        labels=[attribute_value_label],
+                        params={filter_name: f"${param_prefix}_{filter_name}"},
                     )
                 )
             query_params[f"{param_prefix}_{filter_name}"] = filter_value
 
     elif filter_name == "values" and isinstance(filter_value, list):
         query_filter.extend(
-            (QueryRel(labels=[RELATIONSHIP_TO_VALUE_LABEL]), QueryNode(name="av", labels=["AttributeValue"]))
+            (QueryRel(labels=[RELATIONSHIP_TO_VALUE_LABEL]), QueryNode(name="av", labels=[attribute_value_label]))
         )
         if attribute_kind and attribute_kind == "List":
             query_params[f"{param_prefix}_{filter_name}"] = build_regex_attrs(values=filter_value)
@@ -267,10 +281,14 @@ async def default_attribute_query_filter(
         query_filter.append(QueryRel(labels=[RELATIONSHIP_TO_VALUE_LABEL]))
 
         if filter_value is None:
-            query_filter.append(QueryNode(name="av", labels=["AttributeValue"]))
+            query_filter.append(QueryNode(name="av", labels=[GraphAttributeValueNode.get_default_label()]))
         else:
             query_filter.append(
-                QueryNode(name="av", labels=["AttributeValue"], params={filter_name: f"${param_prefix}_{filter_name}"})
+                QueryNode(
+                    name="av",
+                    labels=[GraphAttributeValueNode.get_default_label()],
+                    params={filter_name: f"${param_prefix}_{filter_name}"},
+                )
             )
             query_params[f"{param_prefix}_{filter_name}"] = filter_value
 

infrahub/core/query/diff.py

@@ -100,6 +100,17 @@ class DiffCountChanges(Query):
         return branch_count_map
 
 
+async def get_num_changes_in_time_range_by_branch(
+    branch_names: list[str],
+    from_time: Timestamp,
+    to_time: Timestamp,
+    db: InfrahubDatabase,
+) -> dict[str, int]:
+    query = await DiffCountChanges.init(db=db, branch_names=branch_names, diff_from=from_time, diff_to=to_time)
+    await query.execute(db=db)
+    return query.get_num_changes_by_branch()
+
+
 class DiffCalculationQuery(DiffQuery):
     type = QueryType.READ
     insert_limit = False

infrahub/core/query/ipam.py

@@ -5,6 +5,7 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Iterable
 
 from infrahub.core.constants import InfrahubKind
+from infrahub.core.graph.schema import GraphAttributeIPHostNode, GraphAttributeIPNetworkNode
 from infrahub.core.ipam.constants import AllIPTypes, IPAddressType, IPNetworkType
 from infrahub.core.query import QueryType
 from infrahub.core.registry import registry
@@ -21,8 +22,8 @@ if TYPE_CHECKING:
     from infrahub.database import InfrahubDatabase
 
 
-PREFIX_ATTRIBUTE_LABEL = "AttributeIPNetwork"
-ADDRESS_ATTRIBUTE_LABEL = "AttributeIPHost"
+PREFIX_ATTRIBUTE_LABEL = GraphAttributeIPNetworkNode.get_default_label()
+ADDRESS_ATTRIBUTE_LABEL = GraphAttributeIPHostNode.get_default_label()
 
 
 @dataclass
@@ -280,14 +281,13 @@ class IPPrefixUtilization(Query):
         MATCH path = (
             (pfx)-[r_1:IS_RELATED]-(rl:Relationship)-[r_2:IS_RELATED]-(child:Node)
             -[r_attr:HAS_ATTRIBUTE]->(attr:Attribute)
-            -[r_attr_val:HAS_VALUE]->(av:AttributeValue)
+            -[r_attr_val:HAS_VALUE]->(av:{PREFIX_ATTRIBUTE_LABEL}|{ADDRESS_ATTRIBUTE_LABEL})
         )
         WHERE %(id_func)s(r_1) = %(id_func)s(r_rel1)
         AND %(id_func)s(r_2) = %(id_func)s(r_rel2)
         AND ({rel_filter("r_attr")})
         AND ({rel_filter("r_attr_val")})
         AND attr.name IN ["prefix", "address"]
-        AND any(l in labels(av) WHERE l in ["{PREFIX_ATTRIBUTE_LABEL}", "{ADDRESS_ATTRIBUTE_LABEL}"])
         WITH
             path,
             pfx,
@@ -478,6 +478,7 @@ class IPPrefixReconcileQuery(Query):
             -[pr2:IS_RELATED {status: "active"}]-(maybe_new_parent:%(ip_prefix_kind)s)
             -[har:HAS_ATTRIBUTE]->(:Attribute {name: "prefix"})
             -[hvr:HAS_VALUE]->(av:%(ip_prefix_attribute_kind)s)
+            USING INDEX av:%(ip_prefix_attribute_kind)s(binary_address)
             WHERE all(r IN relationships(parent_path) WHERE (%(branch_filter)s))
             AND av.version = $ip_version
             AND av.binary_address IN $possible_prefix_list
@@ -514,15 +515,16 @@ class IPPrefixReconcileQuery(Query):
             OPTIONAL MATCH child_path = (
                  (ip_namespace)-[r1:IS_RELATED]
                  -(ns_rel:Relationship)-[r2:IS_RELATED]
-                 -(maybe_new_child:Node)-[har:HAS_ATTRIBUTE]
+                 -(maybe_new_child:%(ip_prefix_kind)s|%(ip_address_kind)s)-[har:HAS_ATTRIBUTE]
                  ->(a:Attribute)-[hvr:HAS_VALUE]
-                 ->(av:AttributeValue)
+                 ->(av:%(ip_prefix_attribute_kind)s|%(ip_address_attribute_kind)s)
             )
+            USING INDEX av:%(ip_prefix_attribute_kind)s(binary_address)
+            USING INDEX av:%(ip_address_attribute_kind)s(binary_address)
             WHERE $is_prefix  // only prefix nodes can have children
             AND ns_rel.name IN ["ip_namespace__ip_prefix", "ip_namespace__ip_address"]
             AND any(child_kind IN [$ip_prefix_kind, $ip_address_kind] WHERE child_kind IN labels(maybe_new_child))
             AND a.name in ["prefix", "address"]
-            AND any(attr_kind IN [$ip_prefix_attribute_kind, $ip_address_attribute_kind] WHERE attr_kind IN labels(av))
             AND (ip_node IS NULL OR maybe_new_child.uuid <> ip_node.uuid)
             AND (
                 ($ip_prefix_kind IN labels(maybe_new_child) AND av.prefixlen > $prefixlen)
@@ -580,6 +582,10 @@ class IPPrefixReconcileQuery(Query):
             collect(new_child) as new_children
         """ % {
             "branch_filter": branch_filter,
+            "ip_prefix_kind": InfrahubKind.IPPREFIX,
+            "ip_address_kind": InfrahubKind.IPADDRESS,
+            "ip_prefix_attribute_kind": PREFIX_ATTRIBUTE_LABEL,
+            "ip_address_attribute_kind": ADDRESS_ATTRIBUTE_LABEL,
         }
         self.add_to_query(get_new_children_query)
         self.return_labels = ["ip_node", "current_parent", "current_children", "new_parent", "new_children"]

infrahub/core/query/node.py

@@ -140,15 +140,19 @@ class NodeCreateAllQuery(NodeQuery):
         attributes: list[AttributeCreateData] = []
         attributes_iphost: list[AttributeCreateData] = []
         attributes_ipnetwork: list[AttributeCreateData] = []
+        attributes_indexed: list[AttributeCreateData] = []
 
         for attr_name in self.node._attributes:
             attr: BaseAttribute = getattr(self.node, attr_name)
             attr_data = attr.get_create_data()
+            node_type = attr.get_db_node_type()
 
-            if attr_data.node_type == AttributeDBNodeType.IPHOST:
+            if AttributeDBNodeType.IPHOST in node_type:
                 attributes_iphost.append(attr_data)
-            elif attr_data.node_type == AttributeDBNodeType.IPNETWORK:
+            elif AttributeDBNodeType.IPNETWORK in node_type:
                 attributes_ipnetwork.append(attr_data)
+            elif AttributeDBNodeType.INDEXED in node_type:
+                attributes_indexed.append(attr_data)
             else:
                 attributes.append(attr_data)
 
@@ -167,6 +171,7 @@ class NodeCreateAllQuery(NodeQuery):
                 relationships.append(rel_create_data)
 
         self.params["attrs"] = [attr.model_dump() for attr in attributes]
+        self.params["attrs_indexed"] = [attr.model_dump() for attr in attributes_indexed]
         self.params["attrs_iphost"] = [attr.model_dump() for attr in attributes_iphost]
         self.params["attrs_ipnetwork"] = [attr.model_dump() for attr in attributes_ipnetwork]
         self.params["rels_bidir"] = [
@@ -209,24 +214,59 @@ class NodeCreateAllQuery(NodeQuery):
             "binary_address": "attr.content.binary_address",
             "version": "attr.content.version",
             "prefixlen": "attr.content.prefixlen",
-            # "num_addresses": "attr.content.num_addresses",
         }
         ipnetwork_prop_list = [f"{key}: {value}" for key, value in ipnetwork_prop.items()]
 
-        attrs_query = """
+        attrs_nonindexed_query = """
         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, existing_av) {
+            // If none found, create a new one
+            WITH existing_av
+            WHERE existing_av IS NULL
+            CREATE (:AttributeValue {value: attr.content.value, is_default: attr.content.is_default})
+        }
+        CALL (attr) {
+            MATCH (av:AttributeValue {value: attr.content.value, is_default: attr.content.is_default})
+            WHERE NOT av:AttributeValueIndexed
+            RETURN av
+            LIMIT 1
+        }
+        CALL (n, attr, av) {
+            CREATE (a:Attribute { uuid: attr.uuid, name: attr.name, branch_support: attr.branch_support })
+            CREATE (n)-[:HAS_ATTRIBUTE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(a)
+            CREATE (a)-[:HAS_VALUE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(av)
+            MERGE (ip:Boolean { value: attr.is_protected })
+            MERGE (iv:Boolean { value: attr.is_visible })
+            WITH a, ip, iv
+            LIMIT 1
+            CREATE (a)-[:IS_PROTECTED { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(ip)
+            CREATE (a)-[:IS_VISIBLE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(iv)
+            FOREACH ( prop IN attr.source_prop |
+                MERGE (peer:Node { uuid: prop.peer_id })
+                CREATE (a)-[:HAS_SOURCE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(peer)
+            )
+            FOREACH ( prop IN attr.owner_prop |
+                MERGE (peer:Node { uuid: prop.peer_id })
+                CREATE (a)-[:HAS_OWNER { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(peer)
+            )
+        }"""
+
+        attrs_indexed_query = """
+        WITH distinct n
+        UNWIND $attrs_indexed AS attr
         CALL (n, attr) {
             CREATE (a:Attribute { uuid: attr.uuid, name: attr.name, branch_support: attr.branch_support })
             CREATE (n)-[:HAS_ATTRIBUTE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(a)
-            MERGE (av:AttributeValue { value: attr.content.value, is_default: attr.content.is_default })
+            MERGE (av:AttributeValue:AttributeValueIndexed { value: attr.content.value, is_default: attr.content.is_default })
             WITH av, a
             LIMIT 1
             CREATE (a)-[:HAS_VALUE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(av)
             MERGE (ip:Boolean { value: attr.is_protected })
             MERGE (iv:Boolean { value: attr.is_visible })
-            WITH a, ip, iv
-            LIMIT 1
             CREATE (a)-[:IS_PROTECTED { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(ip)
             CREATE (a)-[:IS_VISIBLE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(iv)
             FOREACH ( prop IN attr.source_prop |
@@ -245,7 +285,7 @@ class NodeCreateAllQuery(NodeQuery):
         CALL (n, attr) {
             CREATE (a:Attribute { uuid: attr.uuid, name: attr.name, branch_support: attr.branch_support })
             CREATE (n)-[:HAS_ATTRIBUTE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(a)
-            MERGE (av:AttributeValue:AttributeIPHost { %(iphost_prop)s })
+            MERGE (av:AttributeValue:AttributeValueIndexed:AttributeIPHost { %(iphost_prop)s })
             WITH attr, av, a
             LIMIT 1
             CREATE (a)-[:HAS_VALUE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(av)
@@ -272,7 +312,7 @@ class NodeCreateAllQuery(NodeQuery):
         CALL (n, attr) {
             CREATE (a:Attribute { uuid: attr.uuid, name: attr.name, branch_support: attr.branch_support })
             CREATE (n)-[:HAS_ATTRIBUTE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(a)
-            MERGE (av:AttributeValue:AttributeIPNetwork { %(ipnetwork_prop)s })
+            MERGE (av:AttributeValue:AttributeValueIndexed:AttributeIPNetwork { %(ipnetwork_prop)s })
             WITH attr, av, a
             LIMIT 1
             CREATE (a)-[:HAS_VALUE { branch: attr.branch, branch_level: attr.branch_level, status: attr.status, from: $at }]->(av)
@@ -409,7 +449,8 @@ class NodeCreateAllQuery(NodeQuery):
         MATCH (root:Root)
         CREATE (n:Node:%(labels)s $node_prop )
         CREATE (n)-[r:IS_PART_OF $node_branch_prop ]->(root)
-        {attrs_query if self.params["attrs"] else ""}
+        {attrs_nonindexed_query if self.params["attrs"] else ""}
+        {attrs_indexed_query if self.params["attrs_indexed"] else ""}
         {attrs_iphost_query if self.params["attrs_iphost"] else ""}
         {attrs_ipnetwork_query if self.params["attrs_ipnetwork"] else ""}
         {rels_bidir_query if self.params["rels_bidir"] else ""}

infrahub/core/query/resource_manager.py

@@ -140,7 +140,7 @@ class NumberPoolGetAllocated(Query):
         self.params.update(branch_params)
 
         query = """
-        MATCH (n:%(node)s)-[ha:HAS_ATTRIBUTE]-(a:Attribute {name: $node_attribute})-[hv:HAS_VALUE]-(av:AttributeValue)
+        MATCH (n:%(node)s)-[ha:HAS_ATTRIBUTE]-(a:Attribute {name: $node_attribute})-[hv:HAS_VALUE]-(av:AttributeValueIndexed)
         MATCH (a)-[hs:HAS_SOURCE]-(pool:%(number_pool_kind)s)
         WHERE
             pool.uuid = $pool_id
@@ -306,7 +306,7 @@ class NumberPoolGetUsed(Query):
         self.params["attribute_name"] = self.pool.node_attribute.value
 
         query = """
-        MATCH (pool:%(number_pool)s { uuid: $pool_id })-[res:IS_RESERVED]->(av:AttributeValue)
+        MATCH (pool:%(number_pool)s { uuid: $pool_id })-[res:IS_RESERVED]->(av:AttributeValueIndexed)
         WHERE toInteger(av.value) >= $start_range and toInteger(av.value) <= $end_range
         CALL (pool, res, av) {
             MATCH (pool)-[res]->(av)<-[hv:HAS_VALUE]-(attr:Attribute)<-[ha:HAS_ATTRIBUTE]-(n:%(node)s)
@@ -371,7 +371,7 @@ class NumberPoolSetReserved(Query):
 
         query = """
         MATCH (pool:%(number_pool)s { uuid: $pool_id })
-        MERGE (value:AttributeValue { value: $reserved, is_default: false })
+        MERGE (value:AttributeValue:AttributeValueIndexed { value: $reserved, is_default: false })
         WITH value, pool
         LIMIT 1
         CREATE (pool)-[rel:IS_RESERVED $rel_prop]->(value)

infrahub/core/schema/basenode_schema.py

@@ -55,6 +55,14 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
     def is_profile_schema(self) -> bool:
         return False
 
+    @property
+    def is_ip_prefix(self) -> bool:
+        return False
+
+    @property
+    def is_ip_address(self) -> bool:
+        return False
+
     @property
     def kind(self) -> str:
         if self.namespace == "Attribute":

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

@@ -35,7 +35,14 @@ from .group import (
     core_repository_group,
     core_standard_group,
 )
-from .ipam import builtin_ip_address, builtin_ip_prefix, builtin_ipam, core_ipam_namespace
+from .ipam import (
+    builtin_ip_address,
+    builtin_ip_prefix,
+    builtin_ipam,
+    core_ipam_namespace,
+    internal_ipam_ip_prefix_available,
+    internal_ipam_ip_range_available,
+)
 from .lineage import lineage_owner, lineage_source
 from .menu import generic_menu_item, menu_item
 from .permission import (
@@ -172,6 +179,8 @@ core_models_mixed: dict[str, list] = {
         core_object_permission,
         core_account_role,
         core_account_group,
+        internal_ipam_ip_prefix_available,
+        internal_ipam_ip_range_available,
     ],
 }
 

infrahub/core/schema/definitions/core/ipam.py

@@ -59,7 +59,7 @@ builtin_ip_prefix = GenericSchema(
     name="IPPrefix",
     label="IP Prefix",
     namespace="Builtin",
-    description="IPv6 or IPv4 prefix also referred as network",
+    description="IPv4 or IPv6 prefix also referred as network",
     include_in_menu=False,
     default_filter="prefix__value",
     order_by=["prefix__version", "prefix__binary_address", "prefix__prefixlen"],
@@ -142,7 +142,7 @@ builtin_ip_address = GenericSchema(
     name="IPAddress",
     label="IP Address",
     namespace="Builtin",
-    description="IPv6 or IPv4 address",
+    description="IPv4 or IPv6 address",
     include_in_menu=False,
     default_filter="address__value",
     order_by=["address__version", "address__binary_address"],
@@ -176,6 +176,32 @@ builtin_ip_address = GenericSchema(
     ],
 )
 
+internal_ipam_ip_range_available = NodeSchema(
+    name="IPRangeAvailable",
+    label="Available IP Range",
+    namespace="Internal",
+    description="Range of IPv4 or IPv6 addresses which has not been allocated yet",
+    include_in_menu=False,
+    display_labels=["address__value", "last_address__value"],
+    branch=BranchSupportType.AWARE,
+    inherit_from=[InfrahubKind.IPADDRESS],
+    generate_profile=False,
+    attributes=[Attr(name="last_address", kind="IPHost", branch=BranchSupportType.AWARE, order_weight=2000)],
+)
+
+internal_ipam_ip_prefix_available = NodeSchema(
+    name="IPPrefixAvailable",
+    label="Available IP Prefix",
+    namespace="Internal",
+    description="IPv4 or IPv6 prefix also referred as network which has not been allocated yet",
+    include_in_menu=False,
+    display_labels=["prefix__value"],
+    branch=BranchSupportType.AWARE,
+    inherit_from=[InfrahubKind.IPPREFIX],
+    generate_profile=False,
+)
+
+
 core_ipam_namespace = NodeSchema(
     name="Namespace",
     namespace="Ipam",

infrahub/core/schema/definitions/core/propose_change.py

@@ -38,6 +38,9 @@ core_proposed_change = NodeSchema(
             default_value=ProposedChangeState.OPEN.value,
             optional=True,
         ),
+        Attr(name="is_draft", kind="Boolean", optional=False, default_value=False),
+        # Ideally we should support some "runtime-attribute" that could not even be stored in the database.
+        Attr(name="total_comments", kind="Number", optional=True, read_only=True),
     ],
     relationships=[
         Rel(
@@ -48,6 +51,17 @@ core_proposed_change = NodeSchema(
             kind=RelKind.ATTRIBUTE,
             branch=BranchSupportType.AGNOSTIC,
             identifier="coreaccount__proposedchange_approved_by",
+            read_only=True,
+        ),
+        Rel(
+            name="rejected_by",
+            peer=InfrahubKind.GENERICACCOUNT,
+            optional=True,
+            cardinality=Cardinality.MANY,
+            kind=RelKind.ATTRIBUTE,
+            branch=BranchSupportType.AGNOSTIC,
+            identifier="coreaccount__proposedchange_rejected_by",
+            read_only=True,
         ),
         Rel(
             name="reviewers",
@@ -66,6 +80,7 @@ core_proposed_change = NodeSchema(
             kind=RelKind.ATTRIBUTE,
             branch=BranchSupportType.AGNOSTIC,
             identifier="coreaccount__proposedchange_created_by",
+            read_only=True,
         ),
         Rel(
             name="comments",

infrahub/core/schema/definitions/core/webhook.py

@@ -120,6 +120,9 @@ core_custom_webhook = NodeSchema(
     branch=BranchSupportType.AGNOSTIC,
     generate_profile=False,
     inherit_from=[InfrahubKind.WEBHOOK, InfrahubKind.TASKTARGET],
+    attributes=[
+        Attr(name="shared_key", kind="Password", unique=False, optional=True, order_weight=4000),
+    ],
     relationships=[
         Rel(
             name="transformation",

infrahub/core/schema/generic_schema.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from infrahub.core.constants import InfrahubKind
+
 from .generated.genericnode_schema import GeneratedGenericSchema
 
 if TYPE_CHECKING:
@@ -28,6 +30,14 @@ class GenericSchema(GeneratedGenericSchema):
     def is_template_schema(self) -> bool:
         return False
 
+    @property
+    def is_ip_prefix(self) -> bool:
+        return self.kind == InfrahubKind.IPPREFIX
+
+    @property
+    def is_ip_address(self) -> bool:
+        return self.kind == InfrahubKind.IPADDRESS
+
     def get_hierarchy_schema(self, db: InfrahubDatabase, branch: Branch | str | None = None) -> GenericSchema:  # noqa: ARG002
         if self.hierarchical:
             return self

infrahub/core/schema/manager.py

@@ -93,6 +93,15 @@ class SchemaManager(NodeManager):
 
         raise ValueError("The selected node is not of type NodeSchema")
 
+    def get_generic_schema(
+        self, name: str, branch: Branch | str | None = None, duplicate: bool = True
+    ) -> GenericSchema:
+        schema = self.get(name=name, branch=branch, duplicate=duplicate)
+        if isinstance(schema, GenericSchema):
+            return schema
+
+        raise ValueError("The selected node is not of type GenericSchema")
+
     def get_profile_schema(
         self, name: str, branch: Branch | str | None = None, duplicate: bool = True
     ) -> ProfileSchema:
@@ -122,7 +131,7 @@ class SchemaManager(NodeManager):
 
         return self._branches[branch_name].get_all(duplicate=duplicate)
 
-    async def get_full_safe(self, branch: Branch | str | None = None) -> dict[str, NodeSchema | GenericSchema]:
+    async def get_full_safe(self, branch: Branch | str | None = None) -> dict[str, MainSchemaTypes]:
         await lock.registry.local_schema_wait()
 
         return self.get_full(branch=branch)

infrahub/core/schema/node_schema.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from infrahub.core.constants import AllowOverrideType, InfrahubKind
+from infrahub.core.constants import AllowOverrideType, InfrahubKind, RelationshipKind
 
 from .generated.node_schema import GeneratedNodeSchema
 from .generic_schema import GenericSchema
@@ -29,6 +29,16 @@ class NodeSchema(GeneratedNodeSchema):
     def is_template_schema(self) -> bool:
         return False
 
+    @property
+    def is_ip_prefix(self) -> bool:
+        """Return whether a node is a derivative of built-in IP prefixes."""
+        return InfrahubKind.IPPREFIX in self.inherit_from
+
+    @property
+    def is_ip_address(self) -> bool:
+        """Return whether a node is a derivative of built-in IP addreses."""
+        return InfrahubKind.IPADDRESS in self.inherit_from
+
     def validate_inheritance(self, interface: GenericSchema) -> None:
         """Perform checks specific to inheritance from Generics.
 
@@ -60,14 +70,17 @@ class NodeSchema(GeneratedNodeSchema):
                     )
 
         for relationship in self.relationships:
-            if (
-                relationship.name in interface.relationship_names
-                and not relationship.inherited
-                and interface.get_relationship(relationship.name).allow_override == AllowOverrideType.NONE
-            ):
-                raise ValueError(
-                    f"{self.kind}'s relationship {relationship.name} inherited from {interface.kind} cannot be overriden"
-                )
+            if relationship.name in interface.relationship_names and not relationship.inherited:
+                interface_relationship = interface.get_relationship(relationship.name)
+                if interface_relationship.allow_override == AllowOverrideType.NONE:
+                    raise ValueError(
+                        f"{self.kind}'s relationship {relationship.name} inherited from {interface.kind} cannot be overriden"
+                    )
+                if relationship.kind != RelationshipKind.HIERARCHY and relationship.peer != interface_relationship.peer:
+                    raise ValueError(
+                        f"{self.kind}'s relationship {relationship.name} inherited from {interface.kind} must have the same peer "
+                        f"({interface_relationship.peer} != {relationship.peer})"
+                    )
 
     def inherit_from_interface(self, interface: GenericSchema) -> None:
         existing_inherited_attributes: dict[str, int] = {
@@ -137,11 +150,3 @@ class NodeSchema(GeneratedNodeSchema):
         if self.namespace not in ["Schema", "Internal"] and InfrahubKind.GENERICGROUP not in self.inherit_from:
             labels.append(InfrahubKind.NODE)
         return labels
-
-    def is_ip_prefix(self) -> bool:
-        """Return whether a node is a derivative of built-in IP prefixes."""
-        return InfrahubKind.IPPREFIX in self.inherit_from
-
-    def is_ip_address(self) -> bool:
-        """Return whether a node is a derivative of built-in IP addreses."""
-        return InfrahubKind.IPADDRESS in self.inherit_from

infrahub/core/schema/profile_schema.py

@@ -28,6 +28,14 @@ class ProfileSchema(BaseNodeSchema):
     def is_template_schema(self) -> bool:
         return False
 
+    @property
+    def is_ip_prefix(self) -> bool:
+        return False
+
+    @property
+    def is_ip_address(self) -> bool:
+        return False
+
     def get_labels(self) -> list[str]:
         """Return the labels for this object, composed of the kind
         and the list of Generic this object is inheriting from."""