infrahub-server 1.2.11__py3-none-any.whl → 1.3.0__py3-none-any.whl

infrahub/message_bus/messages/__init__.py

@@ -1,28 +1,18 @@
 from infrahub.message_bus import InfrahubMessage, InfrahubResponse
 
-from .check_generator_run import CheckGeneratorRun
-from .finalize_validator_execution import FinalizeValidatorExecution
 from .git_file_get import GitFileGet, GitFileGetResponse
 from .git_repository_connectivity import GitRepositoryConnectivity
-from .proposed_change.request_proposedchange_refreshartifacts import RequestProposedChangeRefreshArtifacts
 from .refresh_git_fetch import RefreshGitFetch
 from .refresh_registry_branches import RefreshRegistryBranches
 from .refresh_registry_rebasedbranch import RefreshRegistryRebasedBranch
-from .request_generatordefinition_check import RequestGeneratorDefinitionCheck
-from .request_proposedchange_pipeline import RequestProposedChangePipeline
 from .send_echo_request import SendEchoRequest, SendEchoRequestResponse
 
 MESSAGE_MAP: dict[str, type[InfrahubMessage]] = {
-    "check.generator.run": CheckGeneratorRun,
-    "finalize.validator.execution": FinalizeValidatorExecution,
     "git.file.get": GitFileGet,
     "git.repository.connectivity": GitRepositoryConnectivity,
     "refresh.git.fetch": RefreshGitFetch,
     "refresh.registry.branches": RefreshRegistryBranches,
     "refresh.registry.rebased_branch": RefreshRegistryRebasedBranch,
-    "request.generator_definition.check": RequestGeneratorDefinitionCheck,
-    "request.proposed_change.pipeline": RequestProposedChangePipeline,
-    "request.proposed_change.refresh_artifacts": RequestProposedChangeRefreshArtifacts,
     "send.echo.request": SendEchoRequest,
 }
 

infrahub/message_bus/operations/__init__.py

@@ -3,11 +3,8 @@ from prefect import Flow
 
 from infrahub.message_bus import RPCErrorResponse, messages
 from infrahub.message_bus.operations import (
-    check,
-    finalize,
     git,
     refresh,
-    requests,
     send,
 )
 from infrahub.message_bus.types import MessageTTL
@@ -15,16 +12,11 @@ from infrahub.services import InfrahubServices
 from infrahub.tasks.check import set_check_status
 
 COMMAND_MAP = {
-    "check.generator.run": check.generator.run,
-    "finalize.validator.execution": finalize.validator.execution,
     "git.file.get": git.file.get,
     "git.repository.connectivity": git.repository.connectivity,
     "refresh.git.fetch": git.repository.fetch,
     "refresh.registry.branches": refresh.registry.branches,
     "refresh.registry.rebased_branch": refresh.registry.rebased_branch,
-    "request.generator_definition.check": requests.generator_definition.check,
-    "request.proposed_change.pipeline": requests.proposed_change.pipeline,
-    "request.proposed_change.refresh_artifacts": requests.proposed_change.refresh_artifacts,
     "send.echo.request": send.echo.request,
 }
 

infrahub/message_bus/operations/refresh/registry.py

@@ -1,5 +1,3 @@
-from infrahub import lock
-from infrahub.core.registry import registry
 from infrahub.message_bus import messages
 from infrahub.services import InfrahubServices
 from infrahub.tasks.registry import refresh_branches
@@ -24,8 +22,7 @@ async def rebased_branch(message: messages.RefreshRegistryRebasedBranch, service
         )
         return
 
-    async with lock.registry.local_schema_lock():
-        service.log.info("Refreshing rebased branch")
-        registry.branch[message.branch] = await registry.branch_object.get_by_name(
-            name=message.branch, db=service.database
-        )
+    async with service.database.start_session(read_only=True) as db:
+        await refresh_branches(db=db)
+
+    await service.component.refresh_schema_hash()

infrahub/patch/queries/delete_duplicated_edges.py

@@ -4,7 +4,7 @@ from .base import PatchQuery
 
 class DeleteDuplicatedEdgesPatchQuery(PatchQuery):
     """
-    Find duplicated or overlapping edges of the same status, type, and branch to update and delete
+    For all Node vertices, find duplicated or overlapping edges of the same status, type, and branch to update and delete
     - one edge will be kept for each pair of nodes and a given status, type, and branch. it will be
         updated to have the earliest "from" and "to" times in this group
     - all the other duplicate/overlapping edges will be deleted
@@ -17,99 +17,105 @@ class DeleteDuplicatedEdgesPatchQuery(PatchQuery):
     async def plan(self) -> PatchPlan:
         query = """
 // ------------
-// Find node pairs that have duplicate edges
+// Find vertex pairs that have duplicate edges
 // ------------
-MATCH (node_with_dup_edges:Node)-[edge]->(peer)
+MATCH (node_with_dup_edges:Node)-[edge]-(peer)
 WITH node_with_dup_edges, type(edge) AS edge_type, edge.status AS edge_status, edge.branch AS edge_branch, peer, count(*) AS num_dup_edges
 WHERE num_dup_edges > 1
 WITH DISTINCT node_with_dup_edges, edge_type, edge_branch, peer
-CALL {
+CALL (node_with_dup_edges, edge_type, edge_branch, peer) {
     // ------------
     // Get the earliest active and deleted edges for this branch
     // ------------
-    WITH node_with_dup_edges, edge_type, edge_branch, peer
-    MATCH (node_with_dup_edges)-[active_edge {branch: edge_branch, status: "active"}]->(peer)
+    OPTIONAL MATCH (node_with_dup_edges)-[active_edge {branch: edge_branch, status: "active"}]->(peer)
     WHERE type(active_edge) = edge_type
     WITH node_with_dup_edges, edge_type, edge_branch, peer, active_edge
     ORDER BY active_edge.from ASC
     WITH node_with_dup_edges, edge_type, edge_branch, peer, head(collect(active_edge.from)) AS active_from
-    OPTIONAL MATCH (node_with_dup_edges)-[deleted_edge {branch: edge_branch, status: "deleted"}]->(peer)
+    OPTIONAL MATCH (node_with_dup_edges)-[deleted_edge {branch: edge_branch, status: "deleted"}]-(peer)
     WITH node_with_dup_edges, edge_type, edge_branch, peer, active_from, deleted_edge
     ORDER BY deleted_edge.from ASC
     WITH node_with_dup_edges, edge_type, edge_branch, peer, active_from, head(collect(deleted_edge.from)) AS deleted_from
     // ------------
     // Plan one active edge update with correct from and to times
     // ------------
-    CALL {
-        WITH node_with_dup_edges, edge_type, edge_branch, peer, active_from, deleted_from
-        MATCH (node_with_dup_edges)-[active_e {branch: edge_branch, status: "active"}]->(peer)
+    CALL (node_with_dup_edges, edge_type, edge_branch, peer, active_from, deleted_from) {
+        OPTIONAL MATCH (node_with_dup_edges)-[active_e {branch: edge_branch, status: "active"}]->(peer)
         WHERE type(active_e) = edge_type
         WITH node_with_dup_edges, edge_type, edge_branch, peer, active_from, deleted_from, active_e
         ORDER BY %(id_func_name)s(active_e)
         LIMIT 1
         WITH active_e, properties(active_e) AS before_props, {from: active_from, to: deleted_from} AS prop_updates
-        RETURN [
-            {
-                db_id: %(id_func_name)s(active_e), before_props: before_props, prop_updates: prop_updates
-            }
-        ] AS active_edges_to_update
+        RETURN CASE
+            WHEN active_e IS NOT NULL THEN [
+                {
+                    db_id: %(id_func_name)s(active_e), before_props: before_props, prop_updates: prop_updates
+                }
+            ]
+            ELSE []
+        END AS active_edges_to_update
     }
     // ------------
     // Plan deletes for all the other active edges of this type on this branch
     // ------------
-    CALL {
-        WITH node_with_dup_edges, edge_type, edge_branch, peer
-        MATCH (node_with_dup_edges)-[active_e {branch: edge_branch, status: "active"}]->(peer)
+    CALL (node_with_dup_edges, edge_type, edge_branch, peer) {
+        OPTIONAL MATCH (node_with_dup_edges)-[active_e {branch: edge_branch, status: "active"}]->(peer)
         WHERE type(active_e) = edge_type
         WITH node_with_dup_edges, peer, active_e
         ORDER BY %(id_func_name)s(active_e)
         SKIP 1
-        RETURN collect(
-            {
+        WITH CASE
+            WHEN active_e IS NOT NULL THEN {
                 db_id: %(id_func_name)s(active_e),
-                from_id: %(id_func_name)s(node_with_dup_edges),
-                to_id: %(id_func_name)s(peer),
+                from_id: %(id_func_name)s(startNode(active_e)),
+                to_id: %(id_func_name)s(endNode(active_e)),
                 edge_type: type(active_e),
                 before_props: properties(active_e)
             }
-        ) AS active_edges_to_delete
+            ELSE NULL
+        END AS serialized_edge
+        RETURN collect(serialized_edge) AS active_edges_to_delete
     }
     // ------------
     // Plan one deleted edge update with correct from time
     // ------------
-    CALL {
-        WITH node_with_dup_edges, edge_type, edge_branch, peer, deleted_from
-        MATCH (node_with_dup_edges)-[deleted_e {branch: edge_branch, status: "deleted"}]->(peer)
+    CALL (node_with_dup_edges, edge_type, edge_branch, peer, deleted_from) {
+        OPTIONAL MATCH (node_with_dup_edges)-[deleted_e {branch: edge_branch, status: "deleted"}]->(peer)
         WHERE type(deleted_e) = edge_type
         WITH node_with_dup_edges, edge_type, edge_branch, peer, deleted_from, deleted_e
         ORDER BY %(id_func_name)s(deleted_e)
         LIMIT 1
         WITH deleted_e, properties(deleted_e) AS before_props, {from: deleted_from} AS prop_updates
-        RETURN [
-            {
-                db_id: %(id_func_name)s(deleted_e), before_props: before_props, prop_updates: prop_updates
-            }
-        ] AS deleted_edges_to_update
+        RETURN CASE
+            WHEN deleted_e IS NOT NULL THEN [
+                {
+                    db_id: %(id_func_name)s(deleted_e), before_props: before_props, prop_updates: prop_updates
+                }
+            ]
+            ELSE []
+        END AS deleted_edges_to_update
     }
     // ------------
     // Plan deletes for all the other deleted edges of this type on this branch
     // ------------
-    CALL {
-        WITH node_with_dup_edges, edge_type, edge_branch, peer
-        MATCH (node_with_dup_edges)-[deleted_e {branch: edge_branch, status: "deleted"}]->(peer)
+    CALL (node_with_dup_edges, edge_type, edge_branch, peer) {
+        OPTIONAL MATCH (node_with_dup_edges)-[deleted_e {branch: edge_branch, status: "deleted"}]->(peer)
         WHERE type(deleted_e) = edge_type
         WITH node_with_dup_edges, peer, deleted_e
         ORDER BY %(id_func_name)s(deleted_e)
         SKIP 1
-        RETURN collect(
-            {
+        WITH CASE
+            WHEN deleted_e IS NOT NULL THEN {
                 db_id: %(id_func_name)s(deleted_e),
-                from_id: %(id_func_name)s(node_with_dup_edges),
-                to_id: %(id_func_name)s(peer),
+                from_id: %(id_func_name)s(startNode(deleted_e)),
+                to_id: %(id_func_name)s(endNode(deleted_e)),
                 edge_type: type(deleted_e),
                 before_props: properties(deleted_e)
             }
-        ) AS deleted_edges_to_delete
+            ELSE NULL
+        END AS serialized_edge
+
+        RETURN collect(serialized_edge) AS deleted_edges_to_delete
     }
     RETURN
         active_edges_to_update + deleted_edges_to_update AS edges_to_update,

infrahub/pools/models.py

@@ -0,0 +1,14 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class NumberPoolLockDefinition:
+    pool_id: str
+
+    @property
+    def lock_name(self) -> str:
+        return f"number-pool-creation-{self.pool_id}"
+
+    @property
+    def namespace_name(self) -> str:
+        return "number-pool"

infrahub/pools/number.py

@@ -8,7 +8,7 @@ from infrahub.core.registry import registry
 
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
-    from infrahub.core.protocols import CoreNode
+    from infrahub.core.node.resource_manager.number_pool import CoreNumberPool
     from infrahub.core.timestamp import Timestamp
     from infrahub.database import InfrahubDatabase
 
@@ -20,7 +20,9 @@ class UsedNumber:
 
 
 class NumberUtilizationGetter:
-    def __init__(self, db: InfrahubDatabase, pool: CoreNode, branch: Branch, at: Timestamp | str | None = None) -> None:
+    def __init__(
+        self, db: InfrahubDatabase, pool: CoreNumberPool, branch: Branch, at: Timestamp | str | None = None
+    ) -> None:
         self.db = db
         self.at = at
         self.pool = pool
@@ -62,4 +64,4 @@ class NumberUtilizationGetter:
 
     @property
     def total_pool_size(self) -> int:
-        return self.end_range - self.start_range + 1
+        return self.end_range - self.start_range + 1 - self.pool.get_attribute_nb_excluded_values()

infrahub/pools/registration.py

@@ -0,0 +1,22 @@
+from infrahub.core.registry import registry
+from infrahub.exceptions import SchemaNotFoundError
+
+
+def get_branches_with_schema_number_pool(kind: str, attribute_name: str) -> list[str]:
+    """Return branches where schema defined NumberPool exists"""
+
+    registered_branches = []
+    active_branches = registry.schema.get_branches()
+
+    for active_branch in active_branches:
+        try:
+            schema = registry.schema.get(name=kind, branch=active_branch)
+        except SchemaNotFoundError:
+            continue
+
+        if attribute_name in schema.attribute_names:
+            attribute = schema.get_attribute(name=attribute_name)
+            if attribute.kind == "NumberPool":
+                registered_branches.append(active_branch)
+
+    return registered_branches

infrahub/pools/tasks.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+from prefect import flow
+from prefect.logging import get_run_logger
+
+from infrahub import lock
+from infrahub.context import InfrahubContext  # noqa: TC001  needed for prefect flow
+from infrahub.core.constants import InfrahubKind, NumberPoolType
+from infrahub.core.manager import NodeManager
+from infrahub.core.node import Node
+from infrahub.core.protocols import CoreNumberPool
+from infrahub.core.registry import registry
+from infrahub.core.schema.attribute_parameters import NumberPoolParameters
+from infrahub.exceptions import NodeNotFoundError
+from infrahub.pools.models import NumberPoolLockDefinition
+from infrahub.pools.registration import get_branches_with_schema_number_pool
+from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
+
+
+@flow(
+    name="validate-schema-number-pools",
+    flow_run_name="Validate schema number pools on {branch_name}",
+)
+async def validate_schema_number_pools(
+    branch_name: str,  # noqa: ARG001
+    context: InfrahubContext,  # noqa: ARG001
+    service: InfrahubServices,
+) -> None:
+    log = get_run_logger()
+
+    async with service.database.start_session() as dbs:
+        schema_number_pools = await NodeManager.query(
+            db=dbs, schema=CoreNumberPool, filters={"pool_type__value": NumberPoolType.SCHEMA.value}
+        )
+
+    for schema_number_pool in list(schema_number_pools):
+        defined_on_branches = get_branches_with_schema_number_pool(
+            kind=schema_number_pool.node.value, attribute_name=schema_number_pool.node_attribute.value
+        )
+        if registry.default_branch in defined_on_branches:
+            schema = registry.schema.get(name=schema_number_pool.node.value, branch=registry.default_branch)
+            attribute = schema.get_attribute(name=schema_number_pool.node_attribute.value)
+            number_pool_updated = False
+            if isinstance(attribute.parameters, NumberPoolParameters):
+                if schema_number_pool.start_range.value != attribute.parameters.start_range:
+                    schema_number_pool.start_range.value = attribute.parameters.start_range
+                    number_pool_updated = True
+                if schema_number_pool.end_range.value != attribute.parameters.end_range:
+                    schema_number_pool.end_range.value = attribute.parameters.end_range
+                    number_pool_updated = True
+
+            if number_pool_updated:
+                log.info(
+                    f"Updating NumberPool={schema_number_pool.id} based on changes in the schema on {registry.default_branch}"
+                )
+                await schema_number_pool.save(db=service.database)
+
+        elif not defined_on_branches:
+            log.info(f"Deleting number pool (id={schema_number_pool.id}) as it is no longer defined in the schema")
+            await schema_number_pool.delete(db=service.database)
+
+    existing_pool_ids = [pool.id for pool in schema_number_pools]
+    for registry_branch in registry.schema.get_branches():
+        schema_branch = service.database.schema.get_schema_branch(name=registry_branch)
+
+        for generic_name in schema_branch.generic_names:
+            generic_node = schema_branch.get_generic(name=generic_name, duplicate=False)
+            for attribute_name in generic_node.attribute_names:
+                attribute = generic_node.get_attribute(name=attribute_name)
+                if isinstance(attribute.parameters, NumberPoolParameters) and attribute.parameters.number_pool_id:
+                    if attribute.parameters.number_pool_id not in existing_pool_ids:
+                        await _create_number_pool(
+                            service=service,
+                            number_pool_id=attribute.parameters.number_pool_id,
+                            pool_node=generic_node.kind,
+                            pool_attribute=attribute_name,
+                            start_range=attribute.parameters.start_range,
+                            end_range=attribute.parameters.end_range,
+                        )
+                        existing_pool_ids.append(attribute.parameters.number_pool_id)
+
+        for node_name in schema_branch.node_names:
+            node = schema_branch.get_node(name=node_name, duplicate=False)
+            for attribute_name in node.attribute_names:
+                attribute = node.get_attribute(name=attribute_name)
+                if isinstance(attribute.parameters, NumberPoolParameters) and attribute.parameters.number_pool_id:
+                    if attribute.parameters.number_pool_id not in existing_pool_ids:
+                        await _create_number_pool(
+                            service=service,
+                            number_pool_id=attribute.parameters.number_pool_id,
+                            pool_node=node.kind,
+                            pool_attribute=attribute_name,
+                            start_range=attribute.parameters.start_range,
+                            end_range=attribute.parameters.end_range,
+                        )
+                        existing_pool_ids.append(attribute.parameters.number_pool_id)
+
+
+async def _create_number_pool(
+    service: InfrahubServices,
+    number_pool_id: str,
+    pool_node: str,
+    pool_attribute: str,
+    start_range: int,
+    end_range: int,
+) -> None:
+    lock_definition = NumberPoolLockDefinition(pool_id=number_pool_id)
+    async with lock.registry.get(name=lock_definition.lock_name, namespace=lock_definition.namespace_name, local=False):
+        async with service.database.start_session() as dbs:
+            try:
+                await registry.manager.get_one_by_id_or_default_filter(
+                    db=dbs, id=str(number_pool_id), kind=CoreNumberPool
+                )
+            except NodeNotFoundError:
+                number_pool = await Node.init(db=dbs, schema=InfrahubKind.NUMBERPOOL, branch=registry.default_branch)
+                await number_pool.new(
+                    db=dbs,
+                    id=number_pool_id,
+                    name=f"{pool_node}.{pool_attribute} [{number_pool_id}]",
+                    node=pool_node,
+                    node_attribute=pool_attribute,
+                    start_range=start_range,
+                    end_range=end_range,
+                    pool_type=NumberPoolType.SCHEMA.value,
+                )
+                await number_pool.save(db=dbs)

infrahub/prefect_server/models.py

@@ -1,18 +1,10 @@
-from typing import TYPE_CHECKING, Sequence, cast
-
-from prefect.server.database import PrefectDBInterface, db_injector
-from prefect.server.events.filters import EventFilter, EventNameFilter, EventOrder, EventRelatedFilter
+from prefect.server.events.filters import EventFilter, EventNameFilter, EventOrder
 from prefect.server.events.schemas.events import ReceivedEvent
 from prefect.server.utilities.schemas import PrefectBaseModel
 from pydantic import BaseModel, Field
 
-if TYPE_CHECKING:
-    from sqlalchemy.sql.expression import ColumnExpressionArgument
-
 
 class InfrahubEventFilter(EventFilter):
-    matching_related: list[EventRelatedFilter] = Field(default_factory=list)
-
     def set_prefix(self) -> None:
         if self.event:
             if self.event.prefix is not None and "infrahub." not in self.event.prefix:
@@ -20,16 +12,6 @@ class InfrahubEventFilter(EventFilter):
         else:
             self.event = EventNameFilter(prefix=["infrahub."], name=[], exclude_prefix=None, exclude_name=None)
 
-    @db_injector
-    def build_where_clauses(self, db: PrefectDBInterface) -> Sequence["ColumnExpressionArgument[bool]"]:
-        result = cast(list["ColumnExpressionArgument[bool]"], super().build_where_clauses())
-        top_level_filter = self._scoped_event_resources(db)
-        for matching_related in self.matching_related:
-            matching_related._top_level_filter = top_level_filter
-            result.extend(matching_related.build_where_clauses())
-
-        return result
-
     @classmethod
     def default(cls) -> "InfrahubEventFilter":
         return cls(event=None, any_resource=None, resource=None, related=None, order=EventOrder.DESC)

infrahub/proposed_change/models.py

@@ -1,10 +1,25 @@
+import uuid
+
 from pydantic import BaseModel, ConfigDict, Field
 
-from infrahub.context import InfrahubContext
-from infrahub.message_bus.messages.proposed_change.base_with_diff import BaseProposedChangeWithDiffMessage
+from infrahub.core.constants import CheckType
+from infrahub.generators.models import ProposedChangeGeneratorDefinition
+from infrahub.message_bus import InfrahubMessage
 from infrahub.message_bus.types import ProposedChangeArtifactDefinition, ProposedChangeBranchDiff
 
 
+class BaseProposedChangeWithDiffMessage(InfrahubMessage):
+    """Sent trigger the refresh of artifacts that are impacted by the proposed change."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    proposed_change: str = Field(..., description="The unique ID of the Proposed Change")
+    source_branch: str = Field(..., description="The source branch of the proposed change")
+    source_branch_sync_with_git: bool = Field(..., description="Indicates if the source branch should sync with git")
+    destination_branch: str = Field(..., description="The destination branch of the proposed change")
+    branch_diff: ProposedChangeBranchDiff = Field(..., description="The calculated diff between the two branches")
+
+
 class RequestProposedChangeDataIntegrity(BaseProposedChangeWithDiffMessage):
     """Sent trigger data integrity checks for a proposed change"""
 
@@ -42,4 +57,54 @@ class RequestArtifactDefinitionCheck(BaseModel):
     source_branch_sync_with_git: bool = Field(..., description="Indicates if the source branch should sync with git")
     destination_branch: str = Field(..., description="The target branch")
 
-    context: InfrahubContext = Field(..., description="The context of the task")
+
+class RunGeneratorAsCheckModel(BaseModel):
+    """A check that runs a generator."""
+
+    generator_definition: ProposedChangeGeneratorDefinition = Field(..., description="The Generator definition")
+    generator_instance: str | None = Field(
+        default=None, description="The id of the generator instance if it previously existed"
+    )
+    commit: str = Field(..., description="The commit to target")
+    repository_id: str = Field(..., description="The unique ID of the Repository")
+    repository_name: str = Field(..., description="The name of the Repository")
+    repository_kind: str = Field(..., description="The kind of the Repository")
+    branch_name: str = Field(..., description="The branch where the check is run")
+    target_id: str = Field(..., description="The ID of the target object for this generator")
+    target_name: str = Field(..., description="Name of the generator target")
+    query: str = Field(..., description="The name of the query to use when collecting data")
+    variables: dict = Field(..., description="Input variables when running the generator")
+    validator_id: str = Field(..., description="The ID of the validator")
+    proposed_change: str = Field(..., description="The unique ID of the Proposed Change")
+
+
+class RequestGeneratorDefinitionCheck(BaseModel):
+    """Sent to trigger Generators to run for a proposed change."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    generator_definition: ProposedChangeGeneratorDefinition = Field(..., description="The Generator Definition")
+    branch_diff: ProposedChangeBranchDiff = Field(..., description="The calculated diff between the two branches")
+    proposed_change: str = Field(..., description="The unique ID of the Proposed Change")
+    source_branch: str = Field(..., description="The source branch")
+    source_branch_sync_with_git: bool = Field(..., description="Indicates if the source branch should sync with git")
+    destination_branch: str = Field(..., description="The target branch")
+
+
+class RequestProposedChangePipeline(BaseModel):
+    """Sent request the start of a pipeline connected to a proposed change."""
+
+    proposed_change: str = Field(..., description="The unique ID of the proposed change")
+    source_branch: str = Field(..., description="The source branch of the proposed change")
+    source_branch_sync_with_git: bool = Field(..., description="Indicates if the source branch should sync with git")
+    destination_branch: str = Field(..., description="The destination branch of the proposed change")
+    check_type: CheckType = Field(
+        default=CheckType.ALL, description="Can be used to restrict the pipeline to a specific type of job"
+    )
+    pipeline_id: uuid.UUID = Field(
+        default_factory=uuid.uuid4, description="The unique ID of the execution of this pipeline"
+    )
+
+
+class RequestProposedChangeRefreshArtifacts(BaseProposedChangeWithDiffMessage):
+    """Sent trigger the refresh of artifacts that are impacted by the proposed change."""