infrahub-server 1.1.6__py3-none-any.whl → 1.2.0rc0__py3-none-any.whl

infrahub/message_bus/operations/git/repository.py

@@ -28,7 +28,7 @@ async def connectivity(message: messages.GitRepositoryConnectivity, service: Inf
         response = GitRepositoryConnectivityResponse(
             data=response_data,
         )
-        await service.reply(message=response, initiator=message)
+        await service.message_bus.reply_if_initiator_meta(message=response, initiator=message)
 
 
 @flow(name="refresh-git-fetch", flow_run_name="Fetch git repository {message.repository_name} on " + WORKER_IDENTITY)

infrahub/message_bus/operations/requests/__init__.py

@@ -1,12 +1,10 @@
 from . import (
-    artifact_definition,
     generator_definition,
     proposed_change,
     repository,
 )
 
 __all__ = [
-    "artifact_definition",
     "generator_definition",
     "proposed_change",
     "repository",

infrahub/message_bus/operations/requests/generator_definition.py

@@ -125,7 +125,7 @@ async def check(message: messages.RequestGeneratorDefinitionCheck, service: Infr
     )
     for event in events:
         event.assign_meta(parent=message)
-        await service.send(message=event)
+        await service.message_bus.send(message=event)
 
 
 def _run_generator(instance_id: Optional[str], managed_branch: bool, impacted_instances: list[str]) -> bool:

infrahub/message_bus/operations/requests/proposed_change.py

@@ -20,6 +20,7 @@ from infrahub.message_bus.types import (
     ProposedChangeSubscriber,
 )
 from infrahub.proposed_change.models import (
+    RequestArtifactDefinitionCheck,
     RequestProposedChangeDataIntegrity,
     RequestProposedChangeRepositoryChecks,
     RequestProposedChangeRunGenerators,
@@ -28,6 +29,7 @@ from infrahub.proposed_change.models import (
 )
 from infrahub.services import InfrahubServices  # noqa: TC001
 from infrahub.workflows.catalogue import (
+    REQUEST_ARTIFACT_DEFINITION_CHECK,
     REQUEST_PROPOSED_CHANGE_DATA_INTEGRITY,
     REQUEST_PROPOSED_CHANGE_REPOSITORY_CHECKS,
     REQUEST_PROPOSED_CHANGE_RUN_GENERATORS,
@@ -84,7 +86,7 @@ async def pipeline(message: messages.RequestProposedChangePipeline, service: Inf
                 )
         for event in events:
             event.assign_meta(parent=message)
-            await service.send(message=event)
+            await service.message_bus.send(message=event)
         return
 
     await _gather_repository_repository_diffs(repositories=repositories, service=service)
@@ -122,7 +124,9 @@ async def pipeline(message: messages.RequestProposedChangePipeline, service: Inf
             do_repository_checks=message.check_type is CheckType.ALL,
         )
         await service.workflow.submit_workflow(
-            workflow=REQUEST_PROPOSED_CHANGE_RUN_GENERATORS, parameters={"model": model_proposed_change_run_generator}
+            workflow=REQUEST_PROPOSED_CHANGE_RUN_GENERATORS,
+            context=message.context,
+            parameters={"model": model_proposed_change_run_generator},
         )
 
     if message.check_type in [CheckType.ALL, CheckType.DATA] and branch_diff.has_node_changes(
@@ -136,7 +140,9 @@ async def pipeline(message: messages.RequestProposedChangePipeline, service: Inf
             branch_diff=branch_diff,
         )
         await service.workflow.submit_workflow(
-            workflow=REQUEST_PROPOSED_CHANGE_DATA_INTEGRITY, parameters={"model": model_proposed_change_data_integrity}
+            workflow=REQUEST_PROPOSED_CHANGE_DATA_INTEGRITY,
+            context=message.context,
+            parameters={"model": model_proposed_change_data_integrity},
         )
 
     if message.check_type in [CheckType.REPOSITORY, CheckType.USER]:
@@ -148,7 +154,9 @@ async def pipeline(message: messages.RequestProposedChangePipeline, service: Inf
             branch_diff=branch_diff,
         )
         await service.workflow.submit_workflow(
-            workflow=REQUEST_PROPOSED_CHANGE_REPOSITORY_CHECKS, parameters={"model": model_proposed_change_repo_checks}
+            workflow=REQUEST_PROPOSED_CHANGE_REPOSITORY_CHECKS,
+            context=message.context,
+            parameters={"model": model_proposed_change_repo_checks},
         )
 
     if message.check_type in [CheckType.ALL, CheckType.SCHEMA] and branch_diff.has_data_changes(
@@ -156,6 +164,7 @@ async def pipeline(message: messages.RequestProposedChangePipeline, service: Inf
     ):
         await service.workflow.submit_workflow(
             workflow=REQUEST_PROPOSED_CHANGE_SCHEMA_INTEGRITY,
+            context=message.context,
             parameters={
                 "model": RequestProposedChangeSchemaIntegrity(
                     proposed_change=message.proposed_change,
@@ -170,6 +179,7 @@ async def pipeline(message: messages.RequestProposedChangePipeline, service: Inf
     if message.check_type in [CheckType.ALL, CheckType.TEST]:
         await service.workflow.submit_workflow(
             workflow=REQUEST_PROPOSED_CHANGE_USER_TESTS,
+            context=message.context,
             parameters={
                 "model": RequestProposedChangeUserTests(
                     proposed_change=message.proposed_change,
@@ -183,7 +193,7 @@ async def pipeline(message: messages.RequestProposedChangePipeline, service: Inf
 
     for event in events:
         event.assign_meta(parent=message)
-        await service.send(message=event)
+        await service.message_bus.send(message=event)
 
 
 @flow(
@@ -232,7 +242,7 @@ async def refresh_artifacts(message: messages.RequestProposedChangeRefreshArtifa
 
         if select:
             log.info(f"Trigger processing of {artifact_definition.definition_name}")
-            msg = messages.RequestArtifactDefinitionCheck(
+            model = RequestArtifactDefinitionCheck(
                 artifact_definition=artifact_definition,
                 branch_diff=message.branch_diff,
                 proposed_change=message.proposed_change,
@@ -241,8 +251,7 @@ async def refresh_artifacts(message: messages.RequestProposedChangeRefreshArtifa
                 destination_branch=message.destination_branch,
             )
 
-            msg.assign_meta(parent=message)
-            await service.send(message=msg)
+            await service.workflow.submit_workflow(REQUEST_ARTIFACT_DEFINITION_CHECK, parameters={"model": model})
 
 
 GATHER_ARTIFACT_DEFINITIONS = """
@@ -520,7 +529,7 @@ async def _get_proposed_change_repositories(
     return _parse_proposed_change_repositories(message=message, source=source_all, destination=destination_all)
 
 
-@task(name="proposed-change-validate-repository-conflicts", task_run_name="Validate conflicts on repository")
+@task(name="proposed-change-validate-repository-conflicts", task_run_name="Validate conflicts on repository")  # type: ignore[arg-type]
 async def _validate_repository_merge_conflicts(
     repositories: list[ProposedChangeRepository], service: InfrahubServices
 ) -> bool:
@@ -529,7 +538,10 @@ async def _validate_repository_merge_conflicts(
     for repo in repositories:
         if repo.has_diff and not repo.is_staging:
             git_repo = await InfrahubRepository.init(
-                id=repo.repository_id, name=repo.repository_name, client=service.client
+                id=repo.repository_id,
+                name=repo.repository_name,
+                client=service.client,
+                service=service,
             )
             async with lock.registry.get(name=repo.repository_name, namespace="repository"):
                 repo.conflicts = await git_repo.get_conflicts(
@@ -551,7 +563,10 @@ async def _gather_repository_repository_diffs(
         if repo.has_diff and repo.source_commit and repo.destination_commit:
             # TODO we need to find a way to return all files in the repo if the repo is new
             git_repo = await InfrahubRepository.init(
-                id=repo.repository_id, name=repo.repository_name, client=service.client
+                id=repo.repository_id,
+                name=repo.repository_name,
+                client=service.client,
+                service=service,
             )
 
             files_changed: list[str] = []

infrahub/message_bus/operations/requests/repository.py

@@ -91,7 +91,7 @@ async def checks(message: messages.RequestRepositoryChecks, service: InfrahubSer
 
     for event in events:
         event.assign_meta(parent=message)
-        await service.send(message=event)
+        await service.message_bus.send(message=event)
 
 
 @flow(
@@ -130,4 +130,4 @@ async def user_checks(message: messages.RequestRepositoryUserChecks, service: In
 
     for event in events:
         event.assign_meta(parent=message)
-        await service.send(message=event)
+        await service.message_bus.send(message=event)

infrahub/message_bus/operations/send/echo.py

@@ -10,4 +10,4 @@ async def request(message: messages.SendEchoRequest, service: InfrahubServices)
     service.log.info(f"Received message: {message.message}")
     if message.reply_requested:
         response = SendEchoRequestResponse(data=SendEchoRequestResponseData(response=f"Reply to: {message.message}"))
-        await service.reply(message=response, initiator=message)
+        await service.message_bus.reply_if_initiator_meta(message=response, initiator=message)

infrahub/message_bus/types.py

@@ -9,7 +9,7 @@ from pydantic import BaseModel, Field
 from infrahub.core.constants import InfrahubKind, RepositoryInternalStatus
 from infrahub.exceptions import NodeNotFoundError
 
-SCHEMA_CHANGE = re.compile("^Schema[A-Z]")
+SCHEMA_CHANGE = re.compile(r"^Schema[A-Z]")
 
 
 class MessageTTL(int, Enum):

infrahub/permissions/__init__.py

@@ -2,12 +2,13 @@ from infrahub.permissions.backend import PermissionBackend
 from infrahub.permissions.local_backend import LocalPermissionBackend
 from infrahub.permissions.manager import PermissionManager
 from infrahub.permissions.report import report_schema_permissions
-from infrahub.permissions.types import AssignedPermissions
+from infrahub.permissions.types import AssignedPermissions, get_global_permission_for_kind
 
 __all__ = [
     "AssignedPermissions",
     "LocalPermissionBackend",
     "PermissionBackend",
     "PermissionManager",
+    "get_global_permission_for_kind",
     "report_schema_permissions",
 ]

infrahub/permissions/types.py

@@ -2,8 +2,12 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, TypedDict
 
+from infrahub.core.constants import GlobalPermissions, InfrahubKind
+from infrahub.core.schema import NodeSchema
+
 if TYPE_CHECKING:
     from infrahub.core.account import GlobalPermission, ObjectPermission
+    from infrahub.core.schema import MainSchemaTypes
     from infrahub.permissions.constants import BranchRelativePermissionDecision
 
 
@@ -18,3 +22,25 @@ class KindPermissions(TypedDict):
     delete: BranchRelativePermissionDecision
     update: BranchRelativePermissionDecision
     view: BranchRelativePermissionDecision
+
+
+def get_global_permission_for_kind(schema: MainSchemaTypes) -> GlobalPermissions | None:
+    kind_permission_map = {
+        InfrahubKind.GENERICACCOUNT: GlobalPermissions.MANAGE_ACCOUNTS,
+        InfrahubKind.ACCOUNTGROUP: GlobalPermissions.MANAGE_ACCOUNTS,
+        InfrahubKind.ACCOUNTROLE: GlobalPermissions.MANAGE_ACCOUNTS,
+        InfrahubKind.BASEPERMISSION: GlobalPermissions.MANAGE_PERMISSIONS,
+        InfrahubKind.GENERICREPOSITORY: GlobalPermissions.MANAGE_REPOSITORIES,
+    }
+
+    if schema.kind in kind_permission_map:
+        return kind_permission_map[schema.kind]
+
+    if isinstance(schema, NodeSchema):
+        for base in schema.inherit_from:
+            try:
+                return kind_permission_map[base]
+            except KeyError:
+                continue
+
+    return None

infrahub/pools/prefix.py

@@ -1,174 +1,38 @@
 from __future__ import annotations
 
 import ipaddress
-from collections import OrderedDict, defaultdict
-from ipaddress import IPv4Network, IPv6Network
-from typing import Optional, Union
+from typing import TYPE_CHECKING, Literal
 
+from netaddr import IPSet
 
-class PrefixPool:
-    """
-    Class to automatically manage Prefixes and help to carve out sub-prefixes
-    """
-
-    def __init__(self, network: str) -> None:
-        self.network = ipaddress.ip_network(network)
-
-        # Define biggest and smallest possible masks
-        self.mask_biggest = self.network.prefixlen + 1
-        if self.network.version == 4:
-            self.mask_smallest = 32
-        else:
-            self.mask_smallest = 128
-
-        self.available_subnets = defaultdict(list)
-        self.sub_by_key: dict[str, Optional[str]] = OrderedDict()
-        self.sub_by_id: dict[str, str] = OrderedDict()
-
-        # Save the top level available subnet
-        for subnet in list(self.network.subnets(new_prefix=self.mask_biggest)):
-            self.available_subnets[self.mask_biggest].append(str(subnet))
-
-    def reserve(self, subnet: str, identifier: Optional[str] = None) -> bool:
-        """
-        Indicate that a specific subnet is already reserved/used
-        """
-
-        # TODO Add check to make sure the subnet provided has the right size
-        sub = ipaddress.ip_network(subnet)
-
-        if int(sub.prefixlen) <= int(self.network.prefixlen):
-            raise ValueError(f"{subnet} do not have the right size ({sub.prefixlen},{self.network.prefixlen})")
-
-        if sub.supernet(new_prefix=self.network.prefixlen) != self.network:
-            raise ValueError(f"{subnet} is not part of this network")
-
-        # Check first if this ID as already done a reservation
-        if identifier and identifier in self.sub_by_id.keys():
-            if self.sub_by_id[identifier] == str(sub):
-                return True
-            raise ValueError(
-                f"this identifier ({identifier}) is already used but for a different resource ({self.sub_by_id[identifier]})"
-            )
-
-        if identifier and str(sub) in self.sub_by_key.keys():
-            raise ValueError(f"this subnet is already reserved but not with this identifier ({identifier})")
-
-        if str(sub) in self.sub_by_key.keys():
-            self.remove_subnet_from_available_list(sub)
-            return True
-
-        # Check if the subnet itself is available
-        # if available reserve and return
-        if subnet in self.available_subnets[sub.prefixlen]:
-            if identifier:
-                self.sub_by_id[identifier] = subnet
-                self.sub_by_key[subnet] = identifier
-            else:
-                self.sub_by_key[subnet] = None
-
-            self.remove_subnet_from_available_list(sub)
-            return True
-
-        # If not reserved already, check if the subnet is available
-        # start at sublen and check all available subnet
-        # increase 1 by 1 until we find the closer supernet available
-        # break it down and keep track of the other available subnets
+if TYPE_CHECKING:
+    from infrahub.core.ipam.constants import IPNetworkType
 
-        for sublen in range(sub.prefixlen - 1, self.network.prefixlen, -1):
-            supernet = sub.supernet(new_prefix=sublen)
-            if str(supernet) in self.available_subnets[sublen]:
-                self.split_supernet(supernet=supernet, subnet=sub)
-                return self.reserve(subnet=subnet, identifier=identifier)
 
-        return False
+def get_next_available_prefix(pool: IPSet, prefix_length: int, prefix_ver: Literal[4, 6] = 4) -> IPNetworkType:
+    """Get the next available prefix of a given prefix length from an IPSet.
 
-    def get(self, prefixlen: int, identifier: Optional[str] = None) -> Union[IPv4Network, IPv6Network]:
-        """Return the next available Subnet."""
+    Args:
+        pool: netaddr IPSet object with available subnets
+        prefix_length: length of the desired prefix
+        prefix_ver: IPSet can contain a mix of IPv4 and IPv6 subnets. This parameter specifies the IP version of prefix to acquire.
 
-        clean_prefixlen = int(prefixlen)
-
-        if identifier and identifier in self.sub_by_id.keys():
-            net = ipaddress.ip_network(self.sub_by_id[identifier])
-            if net.prefixlen == clean_prefixlen:
-                return net
-            raise ValueError()
-
-        if len(self.available_subnets[clean_prefixlen]) != 0:
-            sub = self.available_subnets[clean_prefixlen][0]
-            self.reserve(subnet=sub, identifier=identifier)
-            return ipaddress.ip_network(sub)
-
-        # if a subnet of this size is not available
-        # we need to find the closest subnet available and split it
-        for i in range(clean_prefixlen - 1, self.mask_biggest - 1, -1):
-            if len(self.available_subnets[i]) != 0:
-                supernet = ipaddress.ip_network(self.available_subnets[i][0])
-                # supernet available, will split it
-                subs = supernet.subnets(new_prefix=clean_prefixlen)
-                next_sub: Union[IPv4Network, IPv6Network] = next(subs)  # type: ignore[assignment]
-                self.split_supernet(supernet=supernet, subnet=next_sub)
-                self.reserve(subnet=str(next_sub), identifier=identifier)
-                return next_sub
-
-        raise IndexError("No More subnet available")
-
-    def get_nbr_available_subnets(self) -> dict[int, int]:
-        tmp = {}
-        for i in range(self.mask_biggest, self.mask_smallest + 1):
-            tmp[i] = len(self.available_subnets[i])
-
-        return tmp
-
-    def check_if_already_allocated(self, identifier: str) -> bool:
-        """
-        Check if a subnet has already been allocated based on an identifier
-
-        Need to add the same capability based on Network address
-        If both identifier and subnet are provided, identifier take precedence
-        """
-        if identifier in self.sub_by_id.keys():
-            return True
-        return False
-
-    def split_supernet(
-        self, supernet: Union[IPv4Network, IPv6Network], subnet: Union[IPv4Network, IPv6Network]
-    ) -> None:
-        """Split a supernet into smaller networks"""
-
-        # TODO ensure subnet is small than supernet
-        # TODO ensure that subnet is part of supernet
-        parent_net = supernet
-        for i in range(supernet.prefixlen + 1, subnet.prefixlen + 1):
-            tmp_net: list[Union[IPv4Network, IPv6Network]] = list(parent_net.subnets(new_prefix=i))
-
-            if i == subnet.prefixlen:
-                for net in tmp_net:
-                    self.available_subnets[i].append(str(net))
-            else:
-                if subnet.subnet_of(other=tmp_net[0]):  # type: ignore[arg-type]
-                    parent = 0
-                    other = 1
-                else:
-                    parent = 1
-                    other = 0
-
-                parent_net = tmp_net[parent]
-                self.available_subnets[i].append(str(tmp_net[other]))
-
-        self.remove_subnet_from_available_list(supernet)
-
-    def remove_subnet_from_available_list(self, subnet: Union[IPv4Network, IPv6Network]) -> None:
-        """Remove a subnet from the list of available Subnet."""
-        try:
-            idx = self.available_subnets[subnet.prefixlen].index(str(subnet))
-            del self.available_subnets[subnet.prefixlen][idx]
-        except ValueError:
-            # Already removed
-            pass
-
-        # if idx:
-        #     return True
-        # except:
-        #     log.warn("Unable to remove %s from list of available subnets" % str(subnet))
-        #     return False
+    Raises:
+        ValueError: If there are no available subnets in the pool
+    """
+    prefix_ver_map = {
+        4: ipaddress.IPv4Network,
+        6: ipaddress.IPv6Network,
+    }
+
+    filtered_pool = IPSet([])
+    for subnet in pool.iter_cidrs():
+        if isinstance(ipaddress.ip_network(str(subnet)), prefix_ver_map[prefix_ver]):
+            filtered_pool.add(subnet)
+
+    for cidr in filtered_pool.iter_cidrs():
+        if cidr.prefixlen <= prefix_length:
+            next_available = ipaddress.ip_network(f"{cidr.network}/{prefix_length}")
+            return next_available
+
+    raise ValueError("No available subnets in pool")

infrahub/prefect_server/app.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, FastAPI
+from prefect.server.api.server import create_app
+
+from . import events
+
+router = APIRouter(prefix="/infrahub")
+
+router.include_router(events.router)
+
+
+def create_infrahub_prefect() -> FastAPI:
+    app = create_app()
+    api_app: FastAPI = app.__dict__["api_app"]
+    api_app.include_router(router=router)
+
+    return app

infrahub/prefect_server/database.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from prefect.server.events.schemas.events import ReceivedEvent
+from prefect.server.events.storage import INTERACTIVE_PAGE_SIZE
+from prefect.server.events.storage.database import raw_count_events, read_events
+
+if TYPE_CHECKING:
+    from prefect.server.events.filters import EventFilter
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+
+async def query_events(
+    session: AsyncSession, filter: EventFilter, page_size: int = INTERACTIVE_PAGE_SIZE, offset: int | None = None
+) -> tuple[list[ReceivedEvent], int]:
+    count = await raw_count_events(session, filter)  # type: ignore[attr-defined]
+    page = await read_events(session, filter, limit=page_size, offset=offset)  # type: ignore[attr-defined]
+    events = [ReceivedEvent.model_validate(e, from_attributes=True) for e in page]
+    return events, count

infrahub/prefect_server/events.py

@@ -0,0 +1,28 @@
+from fastapi import APIRouter
+from fastapi.param_functions import Depends
+from prefect.server.database import PrefectDBInterface, provide_database_interface
+
+from .database import query_events
+from .models import InfrahubEventfilterInput, InfrahubEventPage
+
+router = APIRouter(prefix="/events", tags=["Infrahub"])
+
+
+@router.post(
+    "/filter",
+)
+async def read_events(
+    event_filter: InfrahubEventfilterInput,
+    db: PrefectDBInterface = Depends(provide_database_interface),  # noqa: B008
+) -> InfrahubEventPage:
+    event_filter.filter.set_prefix()
+
+    async with db.session_context() as session:
+        events, total = await query_events(
+            session=session, filter=event_filter.filter, page_size=event_filter.limit, offset=event_filter.offset
+        )
+
+        return InfrahubEventPage(
+            events=events,
+            total=total,
+        )

infrahub/prefect_server/models.py

@@ -0,0 +1,46 @@
+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.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:
+                self.event.prefix.append("infrahub.")
+        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)
+
+
+class InfrahubEventPage(PrefectBaseModel):
+    events: list[ReceivedEvent] = Field(..., description="The Events matching the query")
+    total: int = Field(..., description="The total number of matching Events")
+
+
+class InfrahubEventfilterInput(BaseModel):
+    limit: int = Field(default=50)
+    filter: InfrahubEventFilter = Field(default_factory=InfrahubEventFilter.default)
+    offset: int | None = Field(default=None)

infrahub/proposed_change/models.py

@@ -1,6 +1,7 @@
-from pydantic import Field
+from pydantic import BaseModel, ConfigDict, Field
 
 from infrahub.message_bus.messages.proposed_change.base_with_diff import BaseProposedChangeWithDiffMessage
+from infrahub.message_bus.types import ProposedChangeArtifactDefinition, ProposedChangeBranchDiff
 
 
 class RequestProposedChangeDataIntegrity(BaseProposedChangeWithDiffMessage):
@@ -26,3 +27,16 @@ class RequestProposedChangeSchemaIntegrity(BaseProposedChangeWithDiffMessage):
 
 class RequestProposedChangeUserTests(BaseProposedChangeWithDiffMessage):
     """Sent trigger to run tests (smoke, units, integrations) for a proposed change."""
+
+
+class RequestArtifactDefinitionCheck(BaseModel):
+    """Sent to validate the generation of artifacts in relation to a proposed change."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    artifact_definition: ProposedChangeArtifactDefinition = Field(..., description="The Artifact 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")