infrahub-server 1.3.6__py3-none-any.whl → 1.4.0b1__py3-none-any.whl

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."""

infrahub/core/schema/schema_branch.py

@@ -119,7 +119,7 @@ class SchemaBranch:
     def template_names(self) -> list[str]:
         return list(self.templates.keys())
 
-    def get_all_kind_id_map(self, nodes_and_generics_only: bool = False) -> dict[str, str]:
+    def get_all_kind_id_map(self, nodes_and_generics_only: bool = False) -> dict[str, str | None]:
         kind_id_map = {}
         if nodes_and_generics_only:
             names = self.node_names + self.generic_names_without_templates
@@ -441,7 +441,7 @@ class SchemaBranch:
         return list(all_schemas.values())
 
     def get_schemas_by_rel_identifier(self, identifier: str) -> list[MainSchemaTypes]:
-        nodes: list[RelationshipSchema] = []
+        nodes: list[MainSchemaTypes] = []
         for node_name in list(self.nodes.keys()) + list(self.generics.keys()):
             node = self.get(name=node_name, duplicate=False)
             rel = node.get_relationship_by_identifier(id=identifier, raise_on_error=False)
@@ -660,7 +660,7 @@ class SchemaBranch:
                     and not (
                         schema_attribute_path.relationship_schema.name == "ip_namespace"
                         and isinstance(node_schema, NodeSchema)
-                        and (node_schema.is_ip_address() or node_schema.is_ip_prefix())
+                        and (node_schema.is_ip_address or node_schema.is_ip_prefix)
                     )
                 ):
                     raise ValueError(
@@ -1447,7 +1447,8 @@ class SchemaBranch:
                 node.validate_inheritance(interface=generic_kind_schema)
 
                 # Store the list of node referencing a specific generics
-                generics_used_by[generic_kind].append(node.kind)
+                if node.namespace != "Internal":
+                    generics_used_by[generic_kind].append(node.kind)
                 node.inherit_from_interface(interface=generic_kind_schema)
 
             if len(generic_with_hierarchical_support) > 1:
@@ -1925,7 +1926,10 @@ class SchemaBranch:
         for node_name in self.node_names + self.generic_names:
             node = self.get(name=node_name, duplicate=False)
 
-            if node.namespace in RESTRICTED_NAMESPACES:
+            if node.namespace in RESTRICTED_NAMESPACES and node.kind not in (
+                InfrahubKind.IPRANGEAVAILABLE,
+                InfrahubKind.IPPREFIXAVAILABLE,
+            ):
                 continue
 
             profiles_rel_settings: dict[str, Any] = {

infrahub/core/schema/template_schema.py

@@ -27,6 +27,14 @@ class TemplateSchema(BaseNodeSchema):
     def is_template_schema(self) -> bool:
         return True
 
+    @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."""
 

infrahub/core/validators/checks_runner.py

@@ -6,7 +6,7 @@ from infrahub_sdk.protocols import CoreValidator
 from infrahub.context import InfrahubContext
 from infrahub.core.constants import ValidatorConclusion, ValidatorState
 from infrahub.core.timestamp import Timestamp
-from infrahub.services import InfrahubServices
+from infrahub.services.adapters.event import InfrahubEventService
 from infrahub.validators.events import send_failed_validator, send_passed_validator
 
 
@@ -14,7 +14,7 @@ async def run_checks_and_update_validator(
     checks: list[Coroutine[Any, None, ValidatorConclusion]],
     validator: CoreValidator,
     context: InfrahubContext,
-    service: InfrahubServices,
+    event_service: InfrahubEventService,
     proposed_change_id: str,
 ) -> None:
     """
@@ -38,7 +38,7 @@ async def run_checks_and_update_validator(
             failed_early = True
             await validator.save()
             await send_failed_validator(
-                service=service, validator=validator, proposed_change_id=proposed_change_id, context=context
+                event_service=event_service, validator=validator, proposed_change_id=proposed_change_id, context=context
             )
             # Continue to iterate to wait for the end of all checks
 
@@ -52,9 +52,9 @@ async def run_checks_and_update_validator(
     if not failed_early:
         if validator.conclusion.value == ValidatorConclusion.SUCCESS.value:
             await send_passed_validator(
-                service=service, validator=validator, proposed_change_id=proposed_change_id, context=context
+                event_service=event_service, validator=validator, proposed_change_id=proposed_change_id, context=context
             )
         else:
             await send_failed_validator(
-                service=service, validator=validator, proposed_change_id=proposed_change_id, context=context
+                event_service=event_service, validator=validator, proposed_change_id=proposed_change_id, context=context
             )

infrahub/core/validators/tasks.py

@@ -13,19 +13,18 @@ from infrahub.core.schema import GenericSchema, NodeSchema
 from infrahub.core.validators.aggregated_checker import AggregatedConstraintChecker
 from infrahub.core.validators.model import SchemaConstraintValidatorRequest, SchemaViolation
 from infrahub.dependencies.registry import get_component_registry
-from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
+from infrahub.workers.dependencies import get_database
 from infrahub.workflows.utils import add_tags
 
 from .models.validate_migration import SchemaValidateMigrationData, SchemaValidatorPathResponseData
 
 if TYPE_CHECKING:
     from infrahub.core.schema.schema_branch import SchemaBranch
+    from infrahub.database import InfrahubDatabase
 
 
 @flow(name="schema_validate_migrations", flow_run_name="Validate schema migrations", persist_result=True)
-async def schema_validate_migrations(
-    message: SchemaValidateMigrationData, service: InfrahubServices
-) -> list[SchemaValidatorPathResponseData]:
+async def schema_validate_migrations(message: SchemaValidateMigrationData) -> list[SchemaValidatorPathResponseData]:
     batch = InfrahubBatch(return_exceptions=True)
     log = get_run_logger()
     await add_tags(branches=[message.branch.name])
@@ -47,7 +46,7 @@ async def schema_validate_migrations(
             node_schema=schema,
             schema_path=constraint.path,
             schema_branch=message.schema_branch,
-            service=service,
+            database=await get_database(),
         )
 
     results = [result async for _, result in batch.execute()]
@@ -67,9 +66,9 @@ async def schema_path_validate(
     node_schema: NodeSchema | GenericSchema,
     schema_path: SchemaPath,
     schema_branch: SchemaBranch,
-    service: InfrahubServices,
+    database: InfrahubDatabase,
 ) -> SchemaValidatorPathResponseData:
-    async with service.database.start_session(read_only=True) as db:
+    async with database.start_session(read_only=True) as db:
         constraint_request = SchemaConstraintValidatorRequest(
             branch=branch,
             constraint_name=constraint_name,

infrahub/core/validators/uniqueness/checker.py

@@ -75,7 +75,7 @@ class UniquenessChecker(ConstraintCheckerInterface):
 
     async def build_query_request(self, schema: MainSchemaTypes) -> NodeUniquenessQueryRequest:
         unique_attr_paths = {
-            QueryAttributePath(attribute_name=attr_schema.name, property_name="value")
+            QueryAttributePath(attribute_name=attr_schema.name, attribute_kind=attr_schema.kind, property_name="value")
             for attr_schema in schema.unique_attributes
         }
         relationship_attr_paths = set()
@@ -92,7 +92,9 @@ class UniquenessChecker(ConstraintCheckerInterface):
                 sub_schema, property_name = get_attribute_path_from_string(path, schema)
                 if isinstance(sub_schema, AttributeSchema):
                     unique_attr_paths.add(
-                        QueryAttributePath(attribute_name=sub_schema.name, property_name=property_name)
+                        QueryAttributePath(
+                            attribute_name=sub_schema.name, attribute_kind=sub_schema.kind, property_name=property_name
+                        )
                     )
                 elif isinstance(sub_schema, RelationshipSchema):
                     relationship_attr_paths.add(

infrahub/core/validators/uniqueness/model.py

@@ -22,6 +22,7 @@ class QueryRelationshipAttributePath(BaseModel):
 
 class QueryAttributePath(BaseModel):
     attribute_name: str
+    attribute_kind: str
     property_name: str | None = Field(default=None)
     value: Any | None = Field(default=None)
 

infrahub/core/validators/uniqueness/query.py

@@ -3,7 +3,9 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any
 
 from infrahub.core.constants.relationship_label import RELATIONSHIP_TO_VALUE_LABEL
+from infrahub.core.graph.schema import GraphAttributeValueIndexedNode, GraphAttributeValueNode
 from infrahub.core.query import Query, QueryType
+from infrahub.types import is_large_attribute_type
 
 from .model import QueryAttributePathValued, QueryRelationshipPathValued
 
@@ -40,6 +42,7 @@ class NodeUniqueAttributeConstraintQuery(Query):
             items="relationships(active_path)", item_names=["branch", "branch_level"]
         )
 
+        attrs_include_large_type = False
         attribute_names = set()
         attr_paths, attr_paths_with_value, attr_values = [], [], []
         for attr_path in self.query_request.unique_attribute_paths:
@@ -49,12 +52,19 @@ class NodeUniqueAttributeConstraintQuery(Query):
                 raise ValueError(
                     f"{attr_path.property_name} is not a valid property for a uniqueness constraint"
                 ) from exc
+            if is_large_attribute_type(attr_path.attribute_kind):
+                attrs_include_large_type = True
             attribute_names.add(attr_path.attribute_name)
             if attr_path.value:
                 attr_paths_with_value.append((attr_path.attribute_name, property_rel_name, attr_path.value))
                 attr_values.append(attr_path.value)
             else:
                 attr_paths.append((attr_path.attribute_name, property_rel_name))
+        attr_value_label = (
+            GraphAttributeValueNode.get_default_label()
+            if attrs_include_large_type
+            else GraphAttributeValueIndexedNode.get_default_label()
+        )
 
         relationship_names = set()
         relationship_attr_paths = []
@@ -112,11 +122,11 @@ class NodeUniqueAttributeConstraintQuery(Query):
         """ % {"node_kind": self.query_request.kind}
 
         attr_paths_with_value_subquery = """
-        MATCH attr_path = (start_node:%(node_kind)s)-[:HAS_ATTRIBUTE]->(attr:Attribute)-[r:HAS_VALUE]->(attr_value:AttributeValue)
+        MATCH attr_path = (start_node:%(node_kind)s)-[:HAS_ATTRIBUTE]->(attr:Attribute)-[r:HAS_VALUE]->(attr_value:%(attr_value_label)s)
         WHERE attr.name in $attribute_names AND attr_value.value in $attr_values
             AND [attr.name, type(r), attr_value.value] in $attr_paths_with_value
         RETURN start_node, attr_path as potential_path, NULL as rel_identifier, attr.name as potential_attr, attr_value.value as potential_attr_value
-        """ % {"node_kind": self.query_request.kind}
+        """ % {"node_kind": self.query_request.kind, "attr_value_label": attr_value_label}
 
         relationship_attr_paths_subquery = """
         MATCH rel_path = (start_node:%(node_kind)s)-[:IS_RELATED]-(relationship_node:Relationship)-[:IS_RELATED]-(related_n:Node)-[:HAS_ATTRIBUTE]->(rel_attr:Attribute)-[:HAS_VALUE]->(rel_attr_value:AttributeValue)
@@ -262,8 +272,20 @@ class UniquenessValidationQuery(Query):
         self.node_ids_to_exclude = node_ids_to_exclude
         super().__init__(**kwargs)
 
+    def _is_attribute_large_type(self, db: InfrahubDatabase, node_kind: str, attribute_name: str) -> bool:
+        """Determine if an attribute is a large type that should use AttributeValue instead of AttributeValueIndexed."""
+        node_schema = db.schema.get(node_kind, branch=self.branch, duplicate=False)
+        attr_schema = node_schema.get_attribute(attribute_name)
+        return is_large_attribute_type(attr_schema.kind)
+
     def _build_attr_subquery(
-        self, node_kind: str, attr_path: QueryAttributePathValued, index: int, branch_filter: str, is_first_query: bool
+        self,
+        node_kind: str,
+        attr_path: QueryAttributePathValued,
+        index: int,
+        branch_filter: str,
+        is_first_query: bool,
+        is_large_type: bool,
     ) -> tuple[str, dict[str, str | int | float | bool]]:
         attr_name_var = f"attr_name_{index}"
         attr_value_var = f"attr_value_{index}"
@@ -271,8 +293,16 @@ class UniquenessValidationQuery(Query):
             first_query_filter = "WHERE $node_ids_to_exclude IS NULL OR NOT node.uuid IN $node_ids_to_exclude"
         else:
             first_query_filter = ""
+
+        # Determine the appropriate label based on attribute type
+        attr_value_label = (
+            GraphAttributeValueNode.get_default_label()
+            if is_large_type
+            else GraphAttributeValueIndexedNode.get_default_label()
+        )
+
         attribute_query = """
-MATCH (node:%(node_kind)s)-[:HAS_ATTRIBUTE]->(attr:Attribute {name: $%(attr_name_var)s})-[:HAS_VALUE]->(:AttributeValue {value: $%(attr_value_var)s})
+MATCH (node:%(node_kind)s)-[:HAS_ATTRIBUTE]->(attr:Attribute {name: $%(attr_name_var)s})-[:HAS_VALUE]->(:%(attr_value_label)s {value: $%(attr_value_var)s})
 %(first_query_filter)s
 WITH DISTINCT node
 CALL (node) {
@@ -300,6 +330,7 @@ CALL (node) {
             "attr_value_var": attr_value_var,
             "branch_filter": branch_filter,
             "index": index,
+            "attr_value_label": attr_value_label,
         }
         params: dict[str, str | int | float | bool] = {
             attr_name_var: attr_path.attribute_name,
@@ -314,6 +345,7 @@ CALL (node) {
         index: int,
         branch_filter: str,
         is_first_query: bool,
+        is_large_type: bool = False,
     ) -> tuple[str, dict[str, str | int | float | bool]]:
         params: dict[str, str | int | float | bool] = {}
         rel_attr_query = ""
@@ -321,6 +353,14 @@ CALL (node) {
         if rel_path.attribute_name and rel_path.attribute_value:
             attr_name_var = f"attr_name_{index}"
             attr_value_var = f"attr_value_{index}"
+
+            # Determine the appropriate label based on relationship attribute type
+            rel_attr_value_label = (
+                GraphAttributeValueNode.get_default_label()
+                if is_large_type
+                else GraphAttributeValueIndexedNode.get_default_label()
+            )
+
             rel_attr_query = """
     MATCH (peer)-[r:HAS_ATTRIBUTE]->(attr:Attribute {name: $%(attr_name_var)s})
     WHERE %(branch_filter)s
@@ -330,19 +370,25 @@ CALL (node) {
     LIMIT 1
     WITH attr, is_active
     WHERE is_active = TRUE
-    MATCH (attr)-[r:HAS_VALUE]->(:AttributeValue {value: $%(attr_value_var)s})
+    MATCH (attr)-[r:HAS_VALUE]->(:%(rel_attr_value_label)s {value: $%(attr_value_var)s})
     WHERE %(branch_filter)s
     WITH r
     ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
     LIMIT 1
     WITH r
     WHERE r.status = "active"
-            """ % {"attr_name_var": attr_name_var, "attr_value_var": attr_value_var, "branch_filter": branch_filter}
+            """ % {
+                "attr_name_var": attr_name_var,
+                "attr_value_var": attr_value_var,
+                "branch_filter": branch_filter,
+                "rel_attr_value_label": rel_attr_value_label,
+            }
             rel_attr_match = (
-                "-[r:HAS_ATTRIBUTE]->(attr:Attribute {name: $%(attr_name_var)s})-[:HAS_VALUE]->(:AttributeValue {value: $%(attr_value_var)s})"
+                "-[r:HAS_ATTRIBUTE]->(attr:Attribute {name: $%(attr_name_var)s})-[:HAS_VALUE]->(:%(rel_attr_value_label)s {value: $%(attr_value_var)s})"
                 % {
                     "attr_name_var": attr_name_var,
                     "attr_value_var": attr_value_var,
+                    "rel_attr_value_label": rel_attr_value_label,
                 }
             )
             params[attr_name_var] = rel_path.attribute_name
@@ -426,12 +472,16 @@ CALL (node) {
         for index, schema_path in enumerate(self.query_request.unique_valued_paths):
             is_first_query = index == 0
             if isinstance(schema_path, QueryAttributePathValued):
+                is_large_type = self._is_attribute_large_type(
+                    db=db, node_kind=self.query_request.kind, attribute_name=schema_path.attribute_name
+                )
                 subquery, params = self._build_attr_subquery(
                     node_kind=self.query_request.kind,
                     attr_path=schema_path,
                     index=index,
                     branch_filter=branch_filter,
                     is_first_query=is_first_query,
+                    is_large_type=is_large_type,
                 )
             else:
                 subquery, params = self._build_rel_subquery(

infrahub/database/__init__.py

@@ -295,7 +295,8 @@ class InfrahubDatabase:
         traceback: TracebackType | None,
     ) -> None:
         if self._mode == InfrahubDatabaseMode.SESSION:
-            return await self._session.close()
+            await self._session.close()
+            return
 
         if self._mode == InfrahubDatabaseMode.TRANSACTION:
             if exc_type is not None:

infrahub/events/__init__.py

@@ -3,6 +3,16 @@ from .branch_action import BranchCreatedEvent, BranchDeletedEvent, BranchMergedE
 from .group_action import GroupMemberAddedEvent, GroupMemberRemovedEvent
 from .models import EventMeta, InfrahubEvent
 from .node_action import NodeCreatedEvent, NodeDeletedEvent, NodeUpdatedEvent
+from .proposed_change_action import (
+    ProposedChangeApprovalRevokedEvent,
+    ProposedChangeApprovedEvent,
+    ProposedChangeMergedEvent,
+    ProposedChangeRejectedEvent,
+    ProposedChangeRejectionRevokedEvent,
+    ProposedChangeReviewRequestedEvent,
+    ProposedChangeThreadCreatedEvent,
+    ProposedChangeThreadUpdatedEvent,
+)
 from .repository_action import CommitUpdatedEvent
 from .validator_action import ValidatorFailedEvent, ValidatorPassedEvent, ValidatorStartedEvent
 
@@ -21,6 +31,14 @@ __all__ = [
     "NodeCreatedEvent",
     "NodeDeletedEvent",
     "NodeUpdatedEvent",
+    "ProposedChangeApprovalRevokedEvent",
+    "ProposedChangeApprovedEvent",
+    "ProposedChangeMergedEvent",
+    "ProposedChangeRejectedEvent",
+    "ProposedChangeRejectionRevokedEvent",
+    "ProposedChangeReviewRequestedEvent",
+    "ProposedChangeThreadCreatedEvent",
+    "ProposedChangeThreadUpdatedEvent",
     "ValidatorFailedEvent",
     "ValidatorPassedEvent",
     "ValidatorStartedEvent",

infrahub/events/constants.py

@@ -1 +1,8 @@
+from enum import Enum
+
 EVENT_NAMESPACE = "infrahub"
+
+
+class EventSortOrder(str, Enum):
+    ASC = "asc"
+    DESC = "desc"