infrahub-server 1.6.3__py3-none-any.whl → 1.7.0b0__py3-none-any.whl

infrahub/graphql/types/branch.py

@@ -2,13 +2,14 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
-from graphene import Boolean, Field, Int, List, NonNull, String
+from graphene import Boolean, Field, Int, List, NonNull, ObjectType, String
 
 from infrahub.core.branch import Branch
-from infrahub.core.constants import GLOBAL_BRANCH_NAME
+from infrahub.core.node.standard import StandardNodeQueryFields
 
 from ...exceptions import BranchNotFoundError
 from .enums import InfrahubBranchStatus
+from .metadata import InfrahubStandardNodeMetaData
 from .standard_node import InfrahubObjectType
 
 if TYPE_CHECKING:
@@ -34,56 +35,35 @@ class BranchType(InfrahubObjectType):
         name = "Branch"
         model = Branch
 
-    @staticmethod
-    async def _map_fields_to_graphql(objs: list[Branch], fields: dict) -> list[dict[str, Any]]:
-        return [await obj.to_graphql(fields=fields) for obj in objs]
-
     @classmethod
     async def get_list(
         cls,
-        fields: dict,
+        fields: StandardNodeQueryFields,
         graphql_context: GraphqlContext,
         **kwargs: Any,
     ) -> list[dict[str, Any]]:
         async with graphql_context.db.start_session(read_only=True) as db:
             objs = await Branch.get_list(db=db, **kwargs)
+            return [await obj.to_graphql_flat(fields=fields.node) for obj in objs]
 
-            if not objs:
-                return []
-
-            return await cls._map_fields_to_graphql(objs=objs, fields=fields)
 
-    @classmethod
-    async def get_by_name(
-        cls,
-        fields: dict,
-        graphql_context: GraphqlContext,
-        name: str,
-    ) -> dict[str, Any]:
-        branch_responses = await cls.get_list(fields=fields, graphql_context=graphql_context, name=name)
-
-        if branch_responses:
-            return branch_responses[0]
-        raise BranchNotFoundError(f"Branch with name '{name}' not found")
-
-
-class RequiredStringValueField(InfrahubObjectType):
+class RequiredStringValueField(ObjectType):
     value = String(required=True)
 
 
-class NonRequiredStringValueField(InfrahubObjectType):
+class NonRequiredStringValueField(ObjectType):
     value = String(required=False)
 
 
-class NonRequiredIntValueField(InfrahubObjectType):
+class NonRequiredIntValueField(ObjectType):
     value = Int(required=False)
 
 
-class NonRequiredBooleanValueField(InfrahubObjectType):
+class NonRequiredBooleanValueField(ObjectType):
     value = Boolean(required=False)
 
 
-class StatusField(InfrahubObjectType):
+class StatusField(ObjectType):
     value = InfrahubBranchStatus(required=True)
 
 
@@ -101,36 +81,43 @@ class InfrahubBranch(BranchType):
     )
     has_schema_changes = Field(NonRequiredBooleanValueField, required=False)
 
+    @classmethod
+    async def get_list(
+        cls,
+        fields: StandardNodeQueryFields,
+        graphql_context: GraphqlContext,
+        **kwargs: Any,
+    ) -> list[dict[str, Any]]:
+        async with graphql_context.db.start_session(read_only=True) as db:
+            objs = await Branch.get_list(db=db, **kwargs)
+            return [await obj.to_graphql(fields=fields) for obj in objs]
+
+    @classmethod
+    async def get_by_name(
+        cls,
+        fields: dict,
+        graphql_context: GraphqlContext,
+        name: str,
+    ) -> dict[str, Any]:
+        branch_responses = await cls.get_list(
+            fields=StandardNodeQueryFields(node=fields), graphql_context=graphql_context, name=name
+        )
+
+        if branch_responses:
+            return branch_responses[0]
+        raise BranchNotFoundError(f"Branch with name '{name}' not found")
+
     class Meta:
         description = "InfrahubBranch"
         name = "InfrahubBranch"
 
-    @staticmethod
-    async def _map_fields_to_graphql(objs: list[Branch], fields: dict) -> list[dict[str, Any]]:
-        field_keys = fields.keys()
-        result: list[dict[str, Any]] = []
-        for obj in objs:
-            if obj.name == GLOBAL_BRANCH_NAME:
-                continue
-            data: dict[str, Any] = {}
-            for field in field_keys:
-                if field == "id":
-                    data["id"] = obj.uuid
-                    continue
-                value = getattr(obj, field, None)
-                if isinstance(fields.get(field), dict):
-                    data[field] = {"value": value}
-                else:
-                    data[field] = value
-            result.append(data)
-        return result
-
-
-class InfrahubBranchEdge(InfrahubObjectType):
+
+class InfrahubBranchEdge(ObjectType):
     node = Field(InfrahubBranch, required=True)
+    node_metadata = Field(InfrahubStandardNodeMetaData, required=True)
 
 
-class InfrahubBranchType(InfrahubObjectType):
+class InfrahubBranchType(ObjectType):
     count = Field(Int, description="Total number of items")
     edges = Field(NonNull(List(of_type=NonNull(InfrahubBranchEdge))))
     default_branch = Field(

infrahub/graphql/types/enums.py

@@ -1,5 +1,6 @@
 from graphene import Enum
 
+from infrahub.constants.enums import OrderDirection
 from infrahub.core import constants
 from infrahub.core.branch.enums import BranchStatus
 from infrahub.permissions import constants as permission_constants
@@ -13,3 +14,5 @@ Severity = Enum.from_enum(constants.Severity)
 BranchRelativePermissionDecision = Enum.from_enum(permission_constants.BranchRelativePermissionDecision)
 
 InfrahubBranchStatus = Enum.from_enum(BranchStatus)
+
+InfrahubOrderDirection = Enum.from_enum(OrderDirection)

infrahub/graphql/types/metadata.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from graphene import Boolean, DateTime, Field, InputObjectType, ObjectType
+
+from infrahub.graphql.types.enums import InfrahubOrderDirection
+
+
+class InfrahubNodeMetadataOrder(InputObjectType):
+    created_at = Field(InfrahubOrderDirection, required=False, description="Order by creation timestamp")
+    updated_at = Field(InfrahubOrderDirection, required=False, description="Order by updated timestamp")
+
+
+class OrderInput(InputObjectType):
+    disable = Boolean(required=False)
+    node_metadata = Field(InfrahubNodeMetadataOrder, required=False, description="Order settings for branch metadata")
+
+
+class InfrahubStandardNodeMetaData(ObjectType):
+    """Base metadata type for standard nodes.
+
+    Note: created_by and updated_by fields are added dynamically by
+    GraphQLSchemaManager._patch_static_types() to use the GenericAccount interface.
+    """
+
+    created_at = DateTime(required=False, description="Date/Time the object has been created")
+    updated_at = DateTime(
+        required=False, description="Date/Time when the object was last modified by a user or a system task"
+    )

infrahub/graphql/types/node.py

@@ -5,7 +5,7 @@ from typing import Any
 from graphene import ObjectType
 from graphene.types.objecttype import ObjectTypeOptions
 
-from infrahub.core.schema import GenericSchema, MainSchemaTypes, NodeSchema, ProfileSchema, TemplateSchema
+from infrahub.core.schema import MainSchemaTypes
 
 
 class InfrahubObjectOptions(ObjectTypeOptions):
@@ -21,7 +21,27 @@ class InfrahubObject(ObjectType):
         _meta: InfrahubObjectOptions | None = None,
         **options: Any,
     ) -> None:
-        if not isinstance(schema, NodeSchema | GenericSchema | ProfileSchema | TemplateSchema):
+        if not isinstance(schema, MainSchemaTypes):
+            raise ValueError(f"You need to pass a valid NodeSchema in '{cls.__name__}.Meta', received '{schema}'")
+
+        if not _meta:
+            _meta = InfrahubObjectOptions(cls)
+
+        _meta.schema = schema
+
+        super().__init_subclass_with_meta__(_meta=_meta, interfaces=interfaces, **options)
+
+
+class InfrahubObjectWithoutMeta(ObjectType):
+    @classmethod
+    def __init_subclass_with_meta__(
+        cls,
+        schema: MainSchemaTypes | None = None,
+        interfaces: tuple = (),
+        _meta: InfrahubObjectOptions | None = None,
+        **options: Any,
+    ) -> None:
+        if not isinstance(schema, MainSchemaTypes):
             raise ValueError(f"You need to pass a valid NodeSchema in '{cls.__name__}.Meta', received '{schema}'")
 
         if not _meta:

infrahub/graphql/types/relationship.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from graphene import Field, List, NonNull, ObjectType, String
+from graphene import DateTime, Field, List, NonNull, ObjectType, String
 
 
 class RelationshipPeer(ObjectType):
@@ -8,7 +8,15 @@ class RelationshipPeer(ObjectType):
     kind = String(required=False)
 
 
-class Relationship(ObjectType):
+class InfrahubRelationshipMetaObject(ObjectType):
+    updated_by = String(required=False, description="User that last modified the relationship")
+    updated_at = DateTime(
+        required=False,
+        description="Date/Time when the relationship was last modified by a user or a system task",
+    )
+
+
+class Relationship(InfrahubRelationshipMetaObject):
     id = String(required=False)
     identifier = String(required=False)
     peers = List(NonNull(RelationshipPeer))

infrahub/graphql/types/standard_node.py

@@ -8,6 +8,7 @@ from graphene.types.objecttype import ObjectTypeOptions
 from infrahub import config
 
 if TYPE_CHECKING:
+    from infrahub.core.node.standard import StandardNodeQueryFields
     from infrahub.graphql.initialization import GraphqlContext
 
 
@@ -26,7 +27,9 @@ class InfrahubObjectType(ObjectType):
         super().__init_subclass_with_meta__(_meta=_meta, interfaces=interfaces, **options)
 
     @classmethod
-    async def get_list(cls, fields: dict[str, Any], graphql_context: GraphqlContext, **kwargs) -> list[dict[str, Any]]:
+    async def get_list(
+        cls, fields: StandardNodeQueryFields, graphql_context: GraphqlContext, **kwargs
+    ) -> list[dict[str, Any]]:
         async with graphql_context.db.session(database=config.SETTINGS.database.database_name) as db:
             filters = {key: value for key, value in kwargs.items() if "__" in key and value}
 
@@ -36,7 +39,6 @@ class InfrahubObjectType(ObjectType):
                     at=graphql_context.at,
                     branch=graphql_context.branch,
                     account=graphql_context.account_session,
-                    include_source=True,
                     db=db,
                 )
             else:
@@ -44,7 +46,6 @@ class InfrahubObjectType(ObjectType):
                     at=graphql_context.at,
                     branch=graphql_context.branch,
                     account=graphql_context.account_session,
-                    include_source=True,
                     db=db,
                 )
 

infrahub/hfid/tasks.py

@@ -20,9 +20,11 @@ UPDATE_HFID = """
 mutation UpdateHFID(
     $id: String!,
     $kind: String!,
-    $value: [String!]!
+    $value: [String!]!,
+    $context_account_id: String!
   ) {
   InfrahubUpdateHFID(
+    context: {account: {id: $context_account_id}},
     data: {id: $id, value: $value, kind: $kind}
   ) {
     ok
@@ -40,6 +42,7 @@ async def hfid_update_value(
     obj: HFIDGraphQLResponse,
     node_kind: str,
     hfid_definition: list[str],
+    context: InfrahubContext,
 ) -> None:
     log = get_run_logger()
     client = get_client()
@@ -58,7 +61,12 @@ async def hfid_update_value(
     try:
         await client.execute_graphql(
             query=UPDATE_HFID,
-            variables={"id": obj.node_id, "kind": node_kind, "value": rendered_hfid},
+            variables={
+                "id": obj.node_id,
+                "kind": node_kind,
+                "value": rendered_hfid,
+                "context_account_id": context.account.account_id,
+            },
             branch_name=branch_name,
         )
         log.info(f"Updating {node_kind}.human_friendly_id='{rendered_hfid}' ({obj.node_id})")
@@ -77,7 +85,7 @@ async def process_hfid(
     node_kind: str,
     object_id: str,
     target_kind: str,
-    context: InfrahubContext,  # noqa: ARG001
+    context: InfrahubContext,
 ) -> None:
     log = get_run_logger()
     client = get_client()
@@ -115,6 +123,7 @@ async def process_hfid(
             obj=node,
             node_kind=node_schema.kind,
             hfid_definition=hfid_definition.hfid,
+            context=context,
         )
 
     _ = [response async for _, response in batch.execute()]

infrahub/profiles/gather.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from prefect import task
+from prefect.cache_policies import NONE
+
+from infrahub.core.constants import RelationshipKind
+from infrahub.core.registry import registry
+from infrahub.database import InfrahubDatabase  # noqa: TC001  needed for prefect flow
+from infrahub.workflows.catalogue import PROFILE_REFRESH_PROCESS
+
+from .models import ProfileRefreshTriggerDefinition
+
+
+@task(name="gather-trigger-profile-refresh", cache_policy=NONE)
+async def gather_trigger_profile_refresh(
+    db: InfrahubDatabase | None = None,  # noqa: ARG001 Needed to have a common function signature for gathering functions
+) -> list[ProfileRefreshTriggerDefinition]:
+    """Gather profile refresh triggers for all profile schemas.
+
+    This function creates trigger definitions for each profile schema that will
+    listen for `NodeUpdatedEvent` on profiles. When a profile's attributes or
+    relationships change, the trigger will fire and execute the profile refresh
+    workflow to re-apply profiles to all related nodes.
+    """
+    branches_with_diff_from_main = registry.get_altered_schema_branches()
+    branches_to_process: list[tuple[str, list[str]]] = [(branch, []) for branch in branches_with_diff_from_main]
+    branches_to_process.append((registry.default_branch, branches_with_diff_from_main))
+
+    triggers: list[ProfileRefreshTriggerDefinition] = []
+
+    for branch_scope, branches_out_of_scope in branches_to_process:
+        schema_branch = registry.schema.get_schema_branch(name=branch_scope)
+
+        for profile_name in schema_branch.profile_names:
+            profile_schema = schema_branch.get_profile(name=profile_name, duplicate=False)
+
+            trigger_attr = [attr.name for attr in profile_schema.attributes if attr.name != "profile_name"]
+            trigger_rels = [
+                rel.name
+                for rel in profile_schema.relationships
+                if rel.kind in {RelationshipKind.GENERIC, RelationshipKind.ATTRIBUTE} and rel.name != "related_nodes"
+            ]
+            trigger_fields = sorted(trigger_attr + trigger_rels)
+
+            if trigger_fields:
+                triggers.append(
+                    ProfileRefreshTriggerDefinition.from_profile_schema(
+                        branch=branch_scope,
+                        profile_kind=profile_schema.kind,
+                        trigger_fields=trigger_fields,
+                        workflow=PROFILE_REFRESH_PROCESS,
+                        branches_out_of_scope=branches_out_of_scope,
+                    )
+                )
+
+    return triggers

infrahub/profiles/mandatory_fields_checker.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from infrahub.core.query.node import NodeGetByHFIDQuery
+
+from .queries.get_profile_data import GetProfileDataQuery, RelationshipFilter
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from infrahub.core.branch import Branch
+    from infrahub.core.schema import NodeSchema
+    from infrahub.database import InfrahubDatabase
+
+
+@dataclass
+class ProfileIdentifiers:
+    ids: list[str]
+    hfids: list[list[str]]
+
+
+def _extract_profile_identifiers_from_input(profiles_data: Sequence[Any] | None) -> ProfileIdentifiers:
+    """Extract profile IDs and HFIDs from input data."""
+    if not profiles_data:
+        return ProfileIdentifiers(ids=[], hfids=[])
+
+    ids: list[str] = []
+    hfids: list[list[str]] = []
+    for item in profiles_data:
+        if isinstance(item, str):
+            # IDs
+            ids.append(item)
+        elif isinstance(item, dict):
+            # Dicts with `id` or `hfid` keys
+            if profile_id := item.get("id"):
+                ids.append(profile_id)
+            elif profile_hfid := item.get("hfid"):
+                hfids.append(profile_hfid)
+        elif hasattr(item, "id"):
+            # Avoid circular import by not importing Node directly
+            ids.append(item.id)
+
+    return ProfileIdentifiers(ids=ids, hfids=hfids)
+
+
+async def _resolve_hfids_to_ids(
+    db: InfrahubDatabase, branch: Branch, profile_kind: str, hfids: list[list[str]]
+) -> list[str]:
+    query = await NodeGetByHFIDQuery.init(db=db, branch=branch, node_kind=profile_kind, hfids=hfids)
+    await query.execute(db=db)
+    return query.get_node_uuids()
+
+
+class ProfilesMandatoryFieldGetter:
+    def __init__(self, db: InfrahubDatabase, branch: Branch) -> None:
+        self.db = db
+        self.branch = branch
+
+    async def get_mandatory_fields_from_profiles(
+        self,
+        schema: NodeSchema,
+        profiles_data: Sequence[Any] | None,
+        mandatory_attr_names: list[str],
+        mandatory_rel_names: list[str],
+    ) -> tuple[set[str], set[str]]:
+        """Get mandatory attributes and relationships that are provided by profiles."""
+        identifiers = _extract_profile_identifiers_from_input(profiles_data=profiles_data)
+
+        profile_ids = list(identifiers.ids)
+        if identifiers.hfids:
+            resolved_ids = await _resolve_hfids_to_ids(
+                db=self.db, branch=self.branch, profile_kind=f"Profile{schema.kind}", hfids=identifiers.hfids
+            )
+            profile_ids.extend(resolved_ids)
+
+        if not profile_ids:
+            return set(), set()
+
+        rel_filters: list[RelationshipFilter] = []
+        rel_name_to_filter: dict[str, RelationshipFilter] = {}
+        for rel_name in mandatory_rel_names:
+            rel_schema = schema.get_relationship(name=rel_name)
+            if not rel_schema.support_profiles:
+                continue
+
+            rel_filter = RelationshipFilter(
+                relationship_identifier=f"profile_{rel_schema.get_identifier()}", direction=rel_schema.direction
+            )
+            rel_filters.append(rel_filter)
+            rel_name_to_filter[rel_name] = rel_filter
+
+        query = await GetProfileDataQuery.init(
+            db=self.db,
+            branch=self.branch,
+            profile_ids=profile_ids,
+            attr_names=mandatory_attr_names,
+            relationship_filters=rel_filters,
+        )
+        await query.execute(db=self.db)
+        profile_data_list = query.get_profile_data()
+
+        provided_attrs: set[str] = set()
+        provided_rels: set[str] = set()
+
+        for profile_data in profile_data_list:
+            for attr_name in mandatory_attr_names:
+                if profile_data.attribute_values.get(attr_name) is not None:
+                    provided_attrs.add(attr_name)
+
+            for rel_name, rel_filter in rel_name_to_filter.items():
+                if profile_data.relationship_peers.get(rel_filter):
+                    provided_rels.add(rel_name)
+
+        return provided_attrs, provided_rels

infrahub/profiles/models.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Self
+
+from infrahub.core.registry import registry
+from infrahub.events import NodeUpdatedEvent
+from infrahub.trigger.constants import NAME_SEPARATOR
+from infrahub.trigger.models import EventTrigger, ExecuteWorkflow, TriggerBranchDefinition, TriggerType
+
+if TYPE_CHECKING:
+    from infrahub.workflows.models import WorkflowDefinition
+
+
+class ProfileRefreshTriggerDefinition(TriggerBranchDefinition):
+    """Trigger definition for profile refresh when profile attributes/relationships change."""
+
+    type: TriggerType = TriggerType.PROFILE
+    profile_kind: str
+
+    @classmethod
+    def from_profile_schema(
+        cls,
+        branch: str,
+        profile_kind: str,
+        trigger_fields: list[str],
+        workflow: WorkflowDefinition,
+        branches_out_of_scope: list[str] | None = None,
+    ) -> Self:
+        """Create a trigger definition for profile refresh when profile attributes/relationships change."""
+        event_trigger = EventTrigger()
+        event_trigger.events.add(NodeUpdatedEvent.event_name)
+        event_trigger.match = {"infrahub.node.kind": profile_kind}
+
+        if branches_out_of_scope:
+            event_trigger.match["infrahub.branch.name"] = [f"!{b}" for b in branches_out_of_scope]
+        elif branch != registry.default_branch:
+            event_trigger.match["infrahub.branch.name"] = branch
+
+        event_trigger.match_related = {
+            "prefect.resource.role": ["infrahub.node.attribute_update", "infrahub.node.relationship_update"],
+            "infrahub.field.name": trigger_fields,
+        }
+
+        workflow_action = ExecuteWorkflow(
+            workflow=workflow,
+            parameters={
+                "branch_name": "{{ event.resource['infrahub.branch.name'] }}",
+                "profile_kind": profile_kind,
+                "profile_id": "{{ event.resource['infrahub.node.id'] }}",
+                "context": {
+                    "__prefect_kind": "json",
+                    "value": {
+                        "__prefect_kind": "jinja",
+                        "template": "{{ event.payload['context'] | tojson }}",
+                    },
+                },
+            },
+        )
+
+        return cls(
+            name=f"{profile_kind}{NAME_SEPARATOR}refresh",
+            branch=branch,
+            profile_kind=profile_kind,
+            trigger=event_trigger,
+            actions=[workflow_action],
+        )