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

infrahub/graphql/resolvers/single_relationship.py

@@ -4,12 +4,16 @@ from graphql import GraphQLResolveInfo
 from graphql.type.definition import GraphQLNonNull
 
 from infrahub.core.branch.models import Branch
-from infrahub.core.constants import BranchSupportType
+from infrahub.core.constants import BranchSupportType, MetadataOptions
 from infrahub.core.manager import NodeManager
+from infrahub.core.metadata.model import MetadataQueryOptions
+from infrahub.core.node import Node
+from infrahub.core.relationship import Relationship
 from infrahub.core.schema.relationship_schema import RelationshipSchema
 from infrahub.core.timestamp import Timestamp
 from infrahub.database import InfrahubDatabase
 from infrahub.graphql.field_extractor import extract_graphql_fields
+from infrahub.graphql.metadata import build_metadata_query_options, get_metadata_options_from_fields
 
 from ..loaders.node import GetManyParams, NodeDataLoader
 from ..types import RELATIONS_PROPERTY_MAP, RELATIONS_PROPERTY_MAP_REVERSED
@@ -24,6 +28,25 @@ class SingleRelationshipResolver:
     def __init__(self) -> None:
         self._data_loader_instances: dict[GetManyParams, NodeDataLoader] = {}
 
+    def _build_relationship_meta_response(
+        self, relationship: Relationship, metadata_fields: dict[str, Any]
+    ) -> dict[str, Any]:
+        data: dict[str, Any] = {}
+        for meta_field in metadata_fields.keys():
+            if meta_field == "created_at":
+                created_at = relationship._get_created_at()
+                data["created_at"] = created_at.to_datetime() if created_at else None
+            elif meta_field == "created_by":
+                account_id = relationship._get_created_by()
+                data["created_by"] = {"id": account_id} if account_id else None
+            elif meta_field == "updated_at":
+                updated_at = relationship._get_updated_at()
+                data["updated_at"] = updated_at.to_datetime() if updated_at else None
+            elif meta_field == "updated_by":
+                account_id = relationship._get_updated_by()
+                data["updated_by"] = {"id": account_id} if account_id else None
+        return data
+
     async def resolve(self, parent: dict, info: GraphQLResolveInfo, **kwargs: Any) -> dict[str, Any]:
         """Resolver for relationships of cardinality=one for Edged responses
 
@@ -45,50 +68,92 @@ class SingleRelationshipResolver:
         fields = extract_graphql_fields(info=info)
         node_fields = fields.get("node", {})
         property_fields = fields.get("properties", {})
+        metadata_fields = {
+            "node_metadata": fields.get("node_metadata", {}),
+            "relationship_metadata": fields.get("relationship_metadata", {}),
+        }
         for key, value in property_fields.items():
             mapped_name = RELATIONS_PROPERTY_MAP[key]
             node_fields[mapped_name] = value
 
         metadata_field_names = {prop_name for prop_name in RELATIONS_PROPERTY_MAP if prop_name != "__typename"}
-        requires_relationship_metadata = bool(set(property_fields.keys()) & metadata_field_names)
+        requires_relationship_properties = bool(set(property_fields.keys()) & metadata_field_names)
+        requires_relationship_metadata = bool(metadata_fields["relationship_metadata"])
 
         # Extract the schema of the node on the other end of the relationship from the GQL Schema
         node_rel = node_schema.get_relationship(info.field_name)
 
         response: dict[str, Any] = {"node": None, "properties": {}}
 
-        if requires_relationship_metadata:
-            node_graph = await self._get_entities_simple(
+        relationship: Relationship | None = None
+        peer_node: Node | None = None
+
+        if requires_relationship_properties or requires_relationship_metadata:
+            include_metadata = build_metadata_query_options(
+                node_metadata_fields=metadata_fields.get("node_metadata"),
+                relationship_metadata_fields=metadata_fields.get("relationship_metadata"),
+                node_fields=node_fields,
+            )
+            # Add relationship properties metadata to relationship_level
+            include_metadata |= MetadataQueryOptions(
+                relationship_level=get_metadata_options_from_fields(property_fields)
+            )
+            relationship = await self._get_entities_simple(
                 db=graphql_context.db,
                 branch=graphql_context.branch,
                 at=graphql_context.at,
-                related_node_ids=graphql_context.related_node_ids,
                 field_name=info.field_name,
                 parent_id=parent["id"],
                 source_kind=node_schema.kind,
                 rel_schema=node_rel,
                 node_fields=node_fields,
+                include_metadata=include_metadata,
                 **kwargs,
             )
         else:
-            node_graph = await self._get_entities_with_data_loader(
+            include_metadata = build_metadata_query_options(
+                node_metadata_fields=metadata_fields.get("node_metadata"),
+                node_fields=node_fields,
+            )
+            peer_node = await self._get_entities_with_data_loader(
                 db=graphql_context.db,
                 branch=graphql_context.branch,
                 at=graphql_context.at,
-                related_node_ids=graphql_context.related_node_ids,
                 rel_schema=node_rel,
                 parent=parent,
                 node_fields=node_fields,
+                include_metadata=include_metadata,
             )
 
-        if not node_graph:
+        if not relationship and not peer_node:
             return response
-        response["node"] = node_graph
 
-        for key, mapped in RELATIONS_PROPERTY_MAP_REVERSED.items():
-            value = node_graph.pop(key, None)
-            if value:
-                response["properties"][mapped] = value
+        async with graphql_context.db.start_session(read_only=True) as db:
+            if relationship:
+                node_graph = await relationship.to_graphql(
+                    db=db, fields=node_fields, related_node_ids=graphql_context.related_node_ids
+                )
+                peer_node = await relationship.get_peer(db=db)
+            elif peer_node:
+                node_graph = await peer_node.to_graphql(
+                    db=db, fields=node_fields, related_node_ids=graphql_context.related_node_ids
+                )
+
+            response["node"] = node_graph
+
+            for key, mapped in RELATIONS_PROPERTY_MAP_REVERSED.items():
+                value = node_graph.pop(key, None)
+                if value:
+                    response["properties"][mapped] = value
+
+            if metadata_fields.get("node_metadata") and peer_node:
+                response["node_metadata"] = await peer_node._build_meta_response("node_metadata", fields)
+
+            if metadata_fields.get("relationship_metadata") and relationship:
+                response["relationship_metadata"] = self._build_relationship_meta_response(
+                    relationship=relationship, metadata_fields=metadata_fields["relationship_metadata"]
+                )
+
         return response
 
     async def _get_entities_simple(
@@ -96,14 +161,14 @@ class SingleRelationshipResolver:
         db: InfrahubDatabase,
         branch: Branch,
         at: Timestamp | None,
-        related_node_ids: set[str] | None,
         field_name: str,
         parent_id: str,
         source_kind: str,
         rel_schema: RelationshipSchema,
         node_fields: dict[str, Any],
+        include_metadata: MetadataQueryOptions,
         **kwargs: Any,
-    ) -> dict[str, Any] | None:
+    ) -> Relationship | None:
         filters = {
             f"{field_name}__{key}": value
             for key, value in kwargs.items()
@@ -121,21 +186,22 @@ class SingleRelationshipResolver:
                 branch=branch,
                 branch_agnostic=rel_schema.branch is BranchSupportType.AGNOSTIC,
                 fetch_peers=True,
+                include_metadata=include_metadata,
             )
             if not objs:
                 return None
-            return await objs[0].to_graphql(db=dbs, fields=node_fields, related_node_ids=related_node_ids)
+            return objs[0]
 
     async def _get_entities_with_data_loader(
         self,
         db: InfrahubDatabase,
         branch: Branch,
         at: Timestamp | None,
-        related_node_ids: set[str] | None,
         rel_schema: RelationshipSchema,
         parent: dict[str, Any],
         node_fields: dict[str, Any],
-    ) -> dict[str, Any] | None:
+        include_metadata: MetadataQueryOptions,
+    ) -> Node | None:
         try:
             peer_id: str = parent[rel_schema.name][0]["node"]["id"]
         except (KeyError, IndexError):
@@ -144,14 +210,13 @@ class SingleRelationshipResolver:
         if node_fields and "hfid" in node_fields:
             node_fields["human_friendly_id"] = None
 
+        include_metadata |= MetadataQueryOptions(attribute_level=MetadataOptions.LINKED_NODES)
         query_params = GetManyParams(
             fields=node_fields,
             at=at,
             branch=branch,
-            include_source=True,
-            include_owner=True,
+            include_metadata=include_metadata,
             prefetch_relationships=False,
-            account=None,
             branch_agnostic=rel_schema.branch is BranchSupportType.AGNOSTIC,
         )
         if query_params in self._data_loader_instances:
@@ -162,5 +227,4 @@ class SingleRelationshipResolver:
         node = await loader.load(key=peer_id)
         if not node:
             return None
-        async with db.start_session(read_only=True) as dbs:
-            return await node.to_graphql(db=dbs, fields=node_fields, related_node_ids=related_node_ids)
+        return node

infrahub/graphql/subscription/graphql_query.py

@@ -8,6 +8,7 @@ from infrahub.core.constants import InfrahubKind
 from infrahub.core.manager import NodeManager
 from infrahub.core.protocols import CoreGraphQLQuery
 from infrahub.core.timestamp import Timestamp
+from infrahub.graphql.resolvers.account_metadata import AccountMetadataResolver
 from infrahub.graphql.resolvers.many_relationship import ManyRelationshipResolver
 from infrahub.graphql.resolvers.single_relationship import SingleRelationshipResolver
 from infrahub.log import get_logger
@@ -50,6 +51,7 @@ async def resolver_graphql_query(
                     types=graphql_context.types,
                     single_relationship_resolver=SingleRelationshipResolver(),
                     many_relationship_resolver=ManyRelationshipResolver(),
+                    account_metadata_resolver=AccountMetadataResolver(),
                 ),
                 root_value=None,
                 variable_values=params or {},

infrahub/graphql/types/__init__.py

@@ -66,7 +66,6 @@ __all__ = [
 
 
 RELATIONS_PROPERTY_MAP: dict[str, str] = {
-    "is_visible": "_relation__is_visible",
     "is_protected": "_relation__is_protected",
     "owner": "_relation__owner",
     "source": "_relation__source",

infrahub/graphql/types/attribute.py

@@ -22,7 +22,6 @@ class RelatedNodeInput(InputObjectType):
     hfid = Field(List(of_type=String), required=False)
     kind = String(required=False)  # Only used to resolve hfid of a related node on a generic relationship, see #4649
     from_pool = Field(GenericPoolInput, required=False)
-    _relation__is_visible = Boolean(required=False)
     _relation__is_protected = Boolean(required=False)
     _relation__owner = String(required=False)
     _relation__source = String(required=False)
@@ -41,7 +40,6 @@ class IPPrefixPoolInput(GenericPoolInput):
 class RelatedIPAddressNodeInput(InputObjectType):
     id = String(required=False)
     from_pool = Field(IPAddressPoolInput, required=False)
-    _relation__is_visible = Boolean(required=False)
     _relation__is_protected = Boolean(required=False)
     _relation__owner = String(required=False)
     _relation__source = String(required=False)
@@ -51,7 +49,6 @@ class RelatedIPPrefixNodeInput(InputObjectType):
     id = String(required=False)
     hfid = Field(List(of_type=String), required=False)
     from_pool = Field(IPPrefixPoolInput, required=False)
-    _relation__is_visible = Boolean(required=False)
     _relation__is_protected = Boolean(required=False)
     _relation__owner = String(required=False)
     _relation__source = String(required=False)
@@ -65,7 +62,6 @@ class AttributeInterface(InfrahubInterface):
     is_default = Field(Boolean)
     is_inherited = Field(Boolean)
     is_protected = Field(Boolean)
-    is_visible = Field(Boolean)
     updated_at = Field(DateTime)
     # Since source and owner are using a Type that is generated dynamically
     # these 2 fields will be dynamically inserted when we generate the GraphQL Schema
@@ -73,7 +69,16 @@ class AttributeInterface(InfrahubInterface):
     # owner = Field("DataOwner")
 
 
-class BaseAttribute(ObjectType):
+class InfrahubAttributeMetaObject(ObjectType):
+    # updated_by is dynamically added in GraphQLSchemaManager.generate_object_types()
+    # to use the account_type (CoreGenericAccount) instead of a plain String
+    updated_at = DateTime(
+        required=False,
+        description="Date/Time when the attribute was last modified by a user or a system task",
+    )
+
+
+class BaseAttribute(InfrahubAttributeMetaObject):
     id = Field(String)
     is_from_profile = Field(Boolean)
     permissions = Field(PermissionType, required=False)

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,16 +8,23 @@ 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
 
 
 class InfrahubObjectTypeOptions(ObjectTypeOptions):
-    model = None
+    model: type | None = None
 
 
 class InfrahubObjectType(ObjectType):
     @classmethod
-    def __init_subclass_with_meta__(cls, model=None, interfaces=(), _meta=None, **options) -> None:
+    def __init_subclass_with_meta__(
+        cls,
+        model: type | None = None,
+        interfaces: tuple[type, ...] = (),
+        _meta: InfrahubObjectTypeOptions | None = None,
+        **options: Any,
+    ) -> None:
         if not _meta:
             _meta = InfrahubObjectTypeOptions(cls)
 
@@ -26,7 +33,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}
 
@@ -35,16 +44,12 @@ class InfrahubObjectType(ObjectType):
                     filters=filters,
                     at=graphql_context.at,
                     branch=graphql_context.branch,
-                    account=graphql_context.account_session,
-                    include_source=True,
                     db=db,
                 )
             else:
                 objs = await cls._meta.model.get_list(
                     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/lock.py

@@ -10,6 +10,7 @@ from typing import TYPE_CHECKING
 
 import redis.asyncio as redis
 from prometheus_client import Histogram
+from redis import UsernamePasswordCredentialProvider
 from redis.asyncio.lock import Lock as GlobalLock
 
 from infrahub import config
@@ -275,10 +276,16 @@ class InfrahubLockRegistry:
     ) -> None:
         if config.SETTINGS.cache.enable and not local_only:
             if config.SETTINGS.cache.driver == config.CacheDriver.Redis:
+                credential_provider: UsernamePasswordCredentialProvider | None = None
+                if config.SETTINGS.cache.username and config.SETTINGS.cache.password:
+                    credential_provider = UsernamePasswordCredentialProvider(
+                        username=config.SETTINGS.cache.username, password=config.SETTINGS.cache.password
+                    )
                 self.connection = redis.Redis(
                     host=config.SETTINGS.cache.address,
                     port=config.SETTINGS.cache.service_port,
                     db=config.SETTINGS.cache.database,
+                    credential_provider=credential_provider,
                     ssl=config.SETTINGS.cache.tls_enabled,
                     ssl_cert_reqs="optional" if not config.SETTINGS.cache.tls_insecure else "none",
                     ssl_check_hostname=not config.SETTINGS.cache.tls_insecure,