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

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"

infrahub/events/generator.py

@@ -1,14 +1,16 @@
 from infrahub.context import InfrahubContext
 from infrahub.core.branch import Branch
 from infrahub.core.changelog.models import RelationshipChangelogGetter
-from infrahub.core.constants import MutationAction
+from infrahub.core.constants import InfrahubKind, MutationAction
 from infrahub.core.node import Node
+from infrahub.core.protocols import CoreProposedChange
 from infrahub.database import InfrahubDatabase
 from infrahub.events.node_action import NodeDeletedEvent, NodeMutatedEvent, NodeUpdatedEvent, get_node_event
 from infrahub.groups.parsers import GroupNodeMutationParser
 from infrahub.worker import WORKER_IDENTITY
 
 from .models import EventMeta, InfrahubEvent
+from .proposed_change_action import ProposedChangeThreadCreatedEvent, ProposedChangeThreadUpdatedEvent
 
 
 async def generate_node_mutation_events(
@@ -68,4 +70,29 @@ async def generate_node_mutation_events(
 
     group_parser = GroupNodeMutationParser(db=db, branch=branch)
     group_events = await group_parser.group_events_from_node_actions(events=events)
-    return events + group_events
+
+    specific_events: list[InfrahubEvent] = []
+    if (kind := node.get_kind()) in [
+        InfrahubKind.CHANGETHREAD,
+        InfrahubKind.OBJECTTHREAD,
+        InfrahubKind.ARTIFACTTHREAD,
+        InfrahubKind.FILETHREAD,
+    ]:
+        proposed_change: CoreProposedChange = await node.change.get_peer(db=db, peer_type=CoreProposedChange)  # type: ignore[attr-defined]
+        action_to_event_map = {
+            MutationAction.CREATED: ProposedChangeThreadCreatedEvent,
+            MutationAction.UPDATED: ProposedChangeThreadUpdatedEvent,
+        }
+        if action in action_to_event_map:
+            specific_events.append(
+                action_to_event_map[action](
+                    proposed_change_id=proposed_change.id,
+                    proposed_change_name=proposed_change.name.value,
+                    proposed_change_state=proposed_change.state.value,
+                    thread_id=node.id,
+                    thread_kind=kind,
+                    meta=EventMeta.from_context(context=context),
+                )
+            )
+
+    return events + group_events + specific_events

infrahub/events/proposed_change_action.py

@@ -0,0 +1,181 @@
+from typing import ClassVar
+
+from pydantic import Field
+
+from infrahub.core.constants import InfrahubKind, MutationAction
+
+from .constants import EVENT_NAMESPACE
+from .models import InfrahubEvent
+
+
+class ProposedChangeEvent(InfrahubEvent):
+    proposed_change_id: str = Field(..., description="The ID of the proposed change")
+    proposed_change_name: str = Field(..., description="The name of the proposed change")
+    proposed_change_state: str = Field(..., description="The state of the proposed change")
+
+    def get_resource(self) -> dict[str, str]:
+        return {
+            "prefect.resource.id": f"infrahub.proposed_change.{self.proposed_change_id}",
+            "infrahub.node.kind": InfrahubKind.PROPOSEDCHANGE,
+            "infrahub.node.id": self.proposed_change_id,
+            "infrahub.proposed_change.name": self.proposed_change_name,
+            "infrahub.proposed_change.state": self.proposed_change_state,
+            "infrahub.branch.name": self.meta.context.branch.name,
+        }
+
+
+class ProposedChangeReviewEvent(ProposedChangeEvent):
+    reviewer_account_id: str = Field(..., description="The ID of the user who reviewed the proposed change")
+    reviewer_account_name: str = Field(..., description="The name of the user who reviewed the proposed change")
+    reviewer_decision: str = Field(..., description="The decision made by the reviewer")
+
+    def get_related(self) -> list[dict[str, str]]:
+        related = super().get_related()
+        related.append(
+            {
+                "prefect.resource.id": self.reviewer_account_id,
+                "prefect.resource.role": "infrahub.related.node",
+                "infrahub.node.kind": InfrahubKind.GENERICACCOUNT,
+                "infrahub.node.id": self.reviewer_account_id,
+                "infrahub.reviewer.account.name": self.reviewer_account_name,
+            }
+        )
+        return related
+
+    def get_resource(self) -> dict[str, str]:
+        return {**super().get_resource(), "infrahub.proposed_change.reviewer_decision": self.reviewer_decision}
+
+
+class ProposedChangeReviewRevokedEvent(ProposedChangeEvent):
+    reviewer_account_id: str = Field(..., description="The ID of the user who reviewed the proposed change")
+    reviewer_account_name: str = Field(..., description="The name of the user who reviewed the proposed change")
+    reviewer_former_decision: str = Field(..., description="The former decision made by the reviewer")
+
+    def get_related(self) -> list[dict[str, str]]:
+        related = super().get_related()
+        related.append(
+            {
+                "prefect.resource.id": self.reviewer_account_id,
+                "prefect.resource.role": "infrahub.related.node",
+                "infrahub.node.kind": InfrahubKind.GENERICACCOUNT,
+                "infrahub.node.id": self.reviewer_account_id,
+                "infrahub.reviewer.account.name": self.reviewer_account_name,
+            }
+        )
+        return related
+
+    def get_resource(self) -> dict[str, str]:
+        return {
+            **super().get_resource(),
+            "infrahub.proposed_change.reviewer_former_decision": self.reviewer_former_decision,
+        }
+
+
+class ProposedChangeMergedEvent(ProposedChangeEvent):
+    """Event generated when a proposed change has been merged"""
+
+    event_name: ClassVar[str] = f"{EVENT_NAMESPACE}.proposed_change.merged"
+
+    merged_by_account_id: str = Field(..., description="The ID of the user who merged the proposed change")
+    merged_by_account_name: str = Field(..., description="The name of the user who merged the proposed change")
+
+    def get_related(self) -> list[dict[str, str]]:
+        related = super().get_related()
+        related.append(
+            {
+                "prefect.resource.id": self.merged_by_account_id,
+                "prefect.resource.role": "infrahub.related.node",
+                "infrahub.node.kind": InfrahubKind.GENERICACCOUNT,
+                "infrahub.node.id": self.merged_by_account_id,
+                "infrahub.merged_by.account.name": self.merged_by_account_name,
+            }
+        )
+        return related
+
+    def get_resource(self) -> dict[str, str]:
+        return {
+            **super().get_resource(),
+            "infrahub.proposed_change.merged_by_account_id": self.merged_by_account_id,
+            "infrahub.proposed_change.merged_by_account_name": self.merged_by_account_name,
+        }
+
+
+class ProposedChangeReviewRequestedEvent(ProposedChangeEvent):
+    """Event generated when a proposed change has been flagged for review"""
+
+    event_name: ClassVar[str] = f"{EVENT_NAMESPACE}.proposed_change.review_requested"
+
+    requested_by_account_id: str = Field(
+        ..., description="The ID of the user who requested the proposed change to be reviewed"
+    )
+    requested_by_account_name: str = Field(
+        ..., description="The name of the user who requested the proposed change to be reviewed"
+    )
+
+    def get_related(self) -> list[dict[str, str]]:
+        related = super().get_related()
+        related.append(
+            {
+                "prefect.resource.id": self.requested_by_account_id,
+                "prefect.resource.role": "infrahub.related.node",
+                "infrahub.node.kind": InfrahubKind.GENERICACCOUNT,
+                "infrahub.node.id": self.requested_by_account_id,
+                "infrahub.requested_by.account.name": self.requested_by_account_name,
+            }
+        )
+        return related
+
+
+class ProposedChangeApprovedEvent(ProposedChangeReviewEvent):
+    """Event generated when a proposed change has been approved"""
+
+    event_name: ClassVar[str] = f"{EVENT_NAMESPACE}.proposed_change.approved"
+
+
+class ProposedChangeRejectedEvent(ProposedChangeReviewEvent):
+    """Event generated when a proposed change has been rejected"""
+
+    event_name: ClassVar[str] = f"{EVENT_NAMESPACE}.proposed_change.rejected"
+
+
+class ProposedChangeApprovalRevokedEvent(ProposedChangeReviewRevokedEvent):
+    """Event generated when a proposed change approval has been revoked"""
+
+    event_name: ClassVar[str] = f"{EVENT_NAMESPACE}.proposed_change.approval_revoked"
+
+
+class ProposedChangeRejectionRevokedEvent(ProposedChangeReviewRevokedEvent):
+    """Event generated when a proposed change rejection has been revoked"""
+
+    event_name: ClassVar[str] = f"{EVENT_NAMESPACE}.proposed_change.rejection_revoked"
+
+
+class ProposedChangeThreadEvent(ProposedChangeEvent):
+    thread_id: str = Field(..., description="The ID of the thread that was created or updated")
+    thread_kind: str = Field(..., description="The name of the thread that was created or updated")
+
+    def get_related(self) -> list[dict[str, str]]:
+        related = super().get_related()
+        related.append(
+            {
+                "prefect.resource.id": self.thread_id,
+                "prefect.resource.role": "infrahub.related.node",
+                "infrahub.node.kind": self.thread_kind,
+                "infrahub.node.id": self.thread_id,
+            }
+        )
+        return related
+
+
+class ProposedChangeThreadCreatedEvent(ProposedChangeThreadEvent):
+    """Event generated when a thread has been created in a proposed change"""
+
+    event_name: ClassVar[str] = f"{EVENT_NAMESPACE}.proposed_change_thread.created"
+    action: MutationAction = MutationAction.CREATED
+
+
+class ProposedChangeThreadUpdatedEvent(ProposedChangeThreadEvent):
+    """Event generated when a thread has been updated in a proposed change"""
+
+    event_name: ClassVar[str] = f"{EVENT_NAMESPACE}.proposed_change_thread.updated"
+    action: MutationAction = MutationAction.UPDATED