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

infrahub/computed_attribute/tasks.py

@@ -19,10 +19,11 @@ from prefect.events.schemas.automations import EventTrigger, Posture
 from prefect.events.schemas.events import ResourceSpecification
 from prefect.logging import get_run_logger
 
+from infrahub.context import InfrahubContext  # noqa: TC001  needed for prefect flow
 from infrahub.core.constants import ComputedAttributeKind, InfrahubKind
 from infrahub.core.registry import registry
 from infrahub.git.repository import get_initialized_repo
-from infrahub.services import services
+from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
 from infrahub.support.macro import MacroDefinition
 from infrahub.workflows.catalogue import (
     PROCESS_COMPUTED_MACRO,
@@ -46,7 +47,6 @@ if TYPE_CHECKING:
     import logging
 
     from infrahub.core.schema.computed_attribute import ComputedAttribute
-    from infrahub.services import InfrahubServices
 
 UPDATE_ATTRIBUTE = """
 mutation UpdateAttribute(
@@ -72,13 +72,14 @@ async def process_transform(
     branch_name: str,
     node_kind: str,
     object_id: str,
-    computed_attribute_name: str,  # pylint: disable=unused-argument
-    computed_attribute_kind: str,  # pylint: disable=unused-argument
-    updated_fields: list[str] | None = None,  # pylint: disable=unused-argument
+    computed_attribute_name: str,  # noqa: ARG001
+    computed_attribute_kind: str,  # noqa: ARG001
+    context: InfrahubContext,  # noqa: ARG001
+    service: InfrahubServices,
+    updated_fields: list[str] | None = None,  # noqa: ARG001
 ) -> None:
     await add_tags(branches=[branch_name], nodes=[object_id])
 
-    service = services.service
     schema_branch = registry.schema.get_schema_branch(name=branch_name)
     node_schema = schema_branch.get_node(name=node_kind, duplicate=False)
     transform_attributes: dict[str, ComputedAttribute] = {}
@@ -152,8 +153,9 @@ async def trigger_update_python_computed_attributes(
     branch_name: str,
     computed_attribute_name: str,
     computed_attribute_kind: str,
+    context: InfrahubContext,
+    service: InfrahubServices,
 ) -> None:
-    service = services.service
     await add_tags(branches=[branch_name])
 
     nodes = await service.client.all(kind=computed_attribute_kind, branch=branch_name)
@@ -161,12 +163,14 @@ async def trigger_update_python_computed_attributes(
     for node in nodes:
         await service.workflow.submit_workflow(
             workflow=UPDATE_COMPUTED_ATTRIBUTE_TRANSFORM,
+            context=context,
             parameters={
                 "branch_name": branch_name,
                 "node_kind": computed_attribute_kind,
                 "object_id": node.id,
                 "computed_attribute_name": computed_attribute_name,
                 "computed_attribute_kind": computed_attribute_kind,
+                "context": context,
             },
         )
 
@@ -176,10 +180,9 @@ async def trigger_update_python_computed_attributes(
     flow_run_name="Update value for computed attribute {attribute_name}",
 )
 async def update_computed_attribute_value_jinja2(
-    branch_name: str, obj: CoreNode, attribute_name: str, template_value: str
+    branch_name: str, obj: CoreNode, attribute_name: str, template_value: str, service: InfrahubServices
 ) -> None:
     log = get_run_logger()
-    service = services.service
 
     await add_tags(branches=[branch_name], nodes=[obj.id], db_change=True)
 
@@ -232,10 +235,11 @@ async def process_jinja2(
     object_id: str,
     computed_attribute_name: str,
     computed_attribute_kind: str,
+    context: InfrahubContext,  # noqa: ARG001
+    service: InfrahubServices,
     updated_fields: str | None = None,
 ) -> None:
     log = get_run_logger()
-    service = services.service
 
     await add_tags(branches=[branch_name])
     updates: list[str] = []
@@ -281,6 +285,7 @@ async def process_jinja2(
                 obj=node,
                 attribute_name=computed_macro.attribute.name,
                 template_value=template_string,
+                service=service,
             )
 
         _ = [response async for _, response in batch.execute()]
@@ -294,8 +299,9 @@ async def trigger_update_jinja2_computed_attributes(
     branch_name: str,
     computed_attribute_name: str,
     computed_attribute_kind: str,
+    context: InfrahubContext,
+    service: InfrahubServices,
 ) -> None:
-    service = services.service
     await add_tags(branches=[branch_name])
 
     nodes = await service.client.all(kind=computed_attribute_kind, branch=branch_name)
@@ -303,19 +309,22 @@ async def trigger_update_jinja2_computed_attributes(
     for node in nodes:
         await service.workflow.submit_workflow(
             workflow=PROCESS_COMPUTED_MACRO,
+            context=context,
             parameters={
                 "branch_name": branch_name,
                 "computed_attribute_name": computed_attribute_name,
                 "computed_attribute_kind": computed_attribute_kind,
                 "node_kind": computed_attribute_kind,
                 "object_id": node.id,
+                "context": context,
             },
         )
 
 
 @flow(name="computed-attribute-setup", flow_run_name="Setup computed attributes in task-manager")
-async def computed_attribute_setup(branch_name: str | None = None) -> None:  # pylint: disable=too-many-statements
-    service = services.service
+async def computed_attribute_setup(
+    service: InfrahubServices, context: InfrahubContext, branch_name: str | None = None
+) -> None:
     branch_name = branch_name or registry.default_branch
 
     await add_tags(branches=[branch_name])
@@ -376,6 +385,13 @@ async def computed_attribute_setup(branch_name: str | None = None) -> None:  # p
                             "computed_attribute_name": computed_attribute.attribute.name,
                             "computed_attribute_kind": computed_attribute.kind,
                             "updated_fields": "{{ event.payload['fields'] | tojson }}",
+                            "context": {
+                                "__prefect_kind": "json",
+                                "value": {
+                                    "__prefect_kind": "jinja",
+                                    "template": "{{ event.payload['context'] | tojson }}",
+                                },
+                            },
                         },
                         job_variables={},
                     )
@@ -395,10 +411,12 @@ async def computed_attribute_setup(branch_name: str | None = None) -> None:  # p
             if branch_name == registry.default_branch:
                 await service.workflow.submit_workflow(
                     workflow=TRIGGER_UPDATE_JINJA_COMPUTED_ATTRIBUTES,
+                    context=context,
                     parameters={
                         "branch_name": registry.default_branch,
                         "computed_attribute_name": computed_attribute.attribute.name,
                         "computed_attribute_kind": computed_attribute.kind,
+                        "context": context,
                     },
                 )
 
@@ -440,6 +458,13 @@ async def computed_attribute_setup(branch_name: str | None = None) -> None:  # p
                                 "computed_attribute_name": computed_attribute.attribute.name,
                                 "computed_attribute_kind": computed_attribute.kind,
                                 "updated_fields": "{{ event.payload['fields'] | tojson }}",
+                                "context": {
+                                    "__prefect_kind": "json",
+                                    "value": {
+                                        "__prefect_kind": "jinja",
+                                        "template": "{{ event.payload['context'] | tojson }}",
+                                    },
+                                },
                             },
                             job_variables={},
                         )
@@ -461,10 +486,12 @@ async def computed_attribute_setup(branch_name: str | None = None) -> None:  # p
                 if branch_name == diff_branch:
                     await service.workflow.submit_workflow(
                         workflow=TRIGGER_UPDATE_JINJA_COMPUTED_ATTRIBUTES,
+                        context=context,
                         parameters={
                             "branch_name": branch_name,
                             "computed_attribute_name": computed_attribute.attribute.name,
                             "computed_attribute_kind": computed_attribute.kind,
+                            "context": context,
                         },
                     )
 
@@ -478,12 +505,13 @@ async def computed_attribute_setup(branch_name: str | None = None) -> None:  # p
     flow_run_name="Setup computed attributes for Python transforms in task-manager",
 )
 async def computed_attribute_setup_python(
+    service: InfrahubServices,
+    context: InfrahubContext,
     branch_name: str | None = None,
-    commit: str | None = None,  # pylint: disable=unused-argument
+    commit: str | None = None,  # noqa: ARG001
     trigger_updates: bool = True,
 ) -> None:
     log = get_run_logger()
-    service = services.service
 
     branch_name = branch_name or registry.default_branch
 
@@ -555,6 +583,13 @@ async def computed_attribute_setup_python(
                             "object_id": "{{ event.resource['infrahub.node.id'] }}",
                             "computed_attribute_name": computed_attribute.computed_attribute.attribute.name,
                             "computed_attribute_kind": computed_attribute.computed_attribute.kind,
+                            "context": {
+                                "__prefect_kind": "json",
+                                "value": {
+                                    "__prefect_kind": "jinja",
+                                    "template": "{{ event.payload['context'] | tojson }}",
+                                },
+                            },
                         },
                         job_variables={},
                     )
@@ -603,6 +638,13 @@ async def computed_attribute_setup_python(
                             "branch_name": "{{ event.resource['infrahub.branch.name'] }}",
                             "node_kind": "{{ event.resource['infrahub.node.kind'] }}",
                             "object_id": "{{ event.resource['infrahub.node.id'] }}",
+                            "context": {
+                                "__prefect_kind": "json",
+                                "value": {
+                                    "__prefect_kind": "jinja",
+                                    "template": "{{ event.payload['context'] | tojson }}",
+                                },
+                            },
                         },
                         job_variables={},
                     )
@@ -626,10 +668,12 @@ async def computed_attribute_setup_python(
             if trigger_updates:
                 await service.workflow.submit_workflow(
                     workflow=TRIGGER_UPDATE_PYTHON_COMPUTED_ATTRIBUTES,
+                    context=context,
                     parameters={
                         "branch_name": branch_name,
                         "computed_attribute_name": computed_attribute.computed_attribute.attribute.name,
                         "computed_attribute_kind": computed_attribute.computed_attribute.kind,
+                        "context": context,
                     },
                 )
 
@@ -671,11 +715,12 @@ async def computed_attribute_remove_python(
 )
 async def query_transform_targets(
     branch_name: str,
-    node_kind: str,  # pylint: disable=unused-argument
+    node_kind: str,  # noqa: ARG001
     object_id: str,
+    context: InfrahubContext,
+    service: InfrahubServices,
 ) -> None:
     await add_tags(branches=[branch_name])
-    service = services.service
     schema_branch = registry.schema.get_schema_branch(name=branch_name)
     targets = await service.client.execute_graphql(
         query=GATHER_GRAPHQL_QUERY_SUBSCRIBERS, variables={"members": [object_id]}, branch_name=branch_name
@@ -695,6 +740,7 @@ async def query_transform_targets(
             for computed_attribute in nodes_with_computed_attributes[subscriber.kind]:
                 await service.workflow.submit_workflow(
                     workflow=UPDATE_COMPUTED_ATTRIBUTE_TRANSFORM,
+                    context=context,
                     parameters={
                         "branch_name": branch_name,
                         "node_kind": subscriber.kind,

infrahub/computed_attribute/triggers.py

@@ -0,0 +1,90 @@
+from infrahub.trigger.models import BuiltinTriggerDefinition, EventTrigger, ExecuteWorkflow
+from infrahub.workflows.catalogue import (
+    COMPUTED_ATTRIBUTE_REMOVE_PYTHON,
+    COMPUTED_ATTRIBUTE_SETUP,
+    COMPUTED_ATTRIBUTE_SETUP_PYTHON,
+)
+
+TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_SETUP_BRANCH = BuiltinTriggerDefinition(
+    name="computed-attribute-python-setup-on-branch-creation",
+    previous_names={"Trigger-schema-update-event"},
+    description="Trigger actions on branch create event",
+    trigger=EventTrigger(events={"infrahub.branch.created"}),
+    actions=[
+        ExecuteWorkflow(
+            name=COMPUTED_ATTRIBUTE_SETUP_PYTHON.name,
+            parameters={
+                "branch_name": "{{ event.resource['infrahub.branch.name'] }}",
+                "trigger_updates": False,
+                "context": {
+                    "__prefect_kind": "json",
+                    "value": {"__prefect_kind": "jinja", "template": "{{ event.payload['context'] | tojson }}"},
+                },
+            },
+        )
+    ],
+)
+
+TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_SETUP_COMMIT = BuiltinTriggerDefinition(
+    name="computed-attribute-python-setup-on-commit",
+    description="Trigger actions on branch create event",
+    trigger=EventTrigger(events={"infrahub.repository.update_commit"}),
+    actions=[
+        ExecuteWorkflow(
+            name=COMPUTED_ATTRIBUTE_SETUP_PYTHON.name,
+            parameters={
+                "branch_name": "{{ event.resource['infrahub.branch.name'] }}",
+                "commit": "{{ event.payload['commit'] }}",
+                "context": {
+                    "__prefect_kind": "json",
+                    "value": {"__prefect_kind": "jinja", "template": "{{ event.payload['context'] | tojson }}"},
+                },
+            },
+        )
+    ],
+)
+
+TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_CLEAN_BRANCH = BuiltinTriggerDefinition(
+    name="computed-attribute-python-cleanup-on-branch-deletion",
+    description="Trigger actions on branch delete event",
+    trigger=EventTrigger(events={"infrahub.branch.deleted"}),
+    actions=[
+        ExecuteWorkflow(
+            name=COMPUTED_ATTRIBUTE_REMOVE_PYTHON.name,
+            parameters={
+                "branch_name": "{{ event.resource['infrahub.branch.name'] }}",
+                "context": {
+                    "__prefect_kind": "json",
+                    "value": {"__prefect_kind": "jinja", "template": "{{ event.payload['context'] | tojson }}"},
+                },
+            },
+        )
+    ],
+)
+
+TRIGGER_COMPUTED_ATTRIBUTE_ALL_SCHEMA = BuiltinTriggerDefinition(
+    name="computed-attribute-all-setup-on-schema-update",
+    trigger=EventTrigger(events={"infrahub.schema.update"}),
+    actions=[
+        ExecuteWorkflow(
+            name=COMPUTED_ATTRIBUTE_SETUP.name,
+            parameters={
+                "branch_name": "{{ event.resource['infrahub.branch.name'] }}",
+                "context": {
+                    "__prefect_kind": "json",
+                    "value": {"__prefect_kind": "jinja", "template": "{{ event.payload['context'] | tojson }}"},
+                },
+            },
+        ),
+        ExecuteWorkflow(
+            name=COMPUTED_ATTRIBUTE_SETUP_PYTHON.name,
+            parameters={
+                "branch_name": "{{ event.resource['infrahub.branch.name'] }}",
+                "context": {
+                    "__prefect_kind": "json",
+                    "value": {"__prefect_kind": "jinja", "template": "{{ event.payload['context'] | tojson }}"},
+                },
+            },
+        ),
+    ],
+)

infrahub/config.py

@@ -718,7 +718,7 @@ class Override:
 
 
 @dataclass
-class ConfiguredSettings:  # pylint: disable=too-many-public-methods
+class ConfiguredSettings:
     settings: Optional[Settings] = None
 
     def initialize(self, config_file: Path | str | None = None) -> None:

infrahub/context.py

@@ -0,0 +1,39 @@
+from pydantic import BaseModel, Field
+from typing_extensions import Self
+
+from infrahub.auth import AccountSession
+from infrahub.core.branch import Branch
+
+
+class ParentEvent(BaseModel):
+    id: str
+    name: str
+
+
+class EventContext(BaseModel):
+    name: str = Field(..., description="The name of the event")
+    id: str = Field(..., description="The ID of the event")
+    parent_id: str | None = Field(default=None)
+    ancestors: list[ParentEvent] = Field(default_factory=list)
+
+
+class BranchContext(BaseModel):
+    name: str
+    id: str | None = None
+
+
+class InfrahubContext(BaseModel):
+    branch: BranchContext
+    account: AccountSession
+    event: EventContext | None = Field(default=None)
+
+    @classmethod
+    def init(cls, branch: Branch, account: AccountSession) -> Self:
+        return cls(branch=BranchContext(name=branch.name, id=str(branch.uuid)), account=account)
+
+    def set_event(self, name: str, id: str) -> None:
+        if self.event:
+            self.event.name = name
+            self.event.id = id
+        else:
+            self.event = EventContext(name=name, id=id)

infrahub/core/account.py

@@ -15,9 +15,6 @@ if TYPE_CHECKING:
     from infrahub.permissions import AssignedPermissions
 
 
-# pylint: disable=redefined-builtin
-
-
 @dataclass
 class GlobalPermission:
     action: str
@@ -60,7 +57,7 @@ class AccountGlobalPermissionQuery(Query):
         self.account_id = account_id
         super().__init__(**kwargs)
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params["account_id"] = self.account_id
 
         branch_filter, branch_params = self.branch.get_query_filter_path(
@@ -175,7 +172,7 @@ class AccountObjectPermissionQuery(Query):
         self.account_id = account_id
         super().__init__(**kwargs)
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params["account_id"] = self.account_id
 
         branch_filter, branch_params = self.branch.get_query_filter_path(
@@ -327,7 +324,7 @@ class AccountRoleGlobalPermissionQuery(Query):
         self.role_id = role_id
         super().__init__(**kwargs)
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params["role_id"] = self.role_id
 
         branch_filter, branch_params = self.branch.get_query_filter_path(
@@ -417,7 +414,7 @@ class AccountRoleObjectPermissionQuery(Query):
         self.role_id = role_id
         super().__init__(**kwargs)
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params["role_id"] = self.role_id
 
         branch_filter, branch_params = self.branch.get_query_filter_path(
@@ -544,7 +541,7 @@ class AccountTokenValidateQuery(Query):
         self.token = token
         super().__init__(**kwargs)
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         token_filter_perms, token_params = self.branch.get_query_filter_relationships(
             rel_labels=["r1", "r2"], at=self.at, include_outside_parentheses=True
         )

infrahub/core/attribute.py

@@ -14,6 +14,7 @@ from pydantic import BaseModel, Field
 
 from infrahub import config
 from infrahub.core import registry
+from infrahub.core.changelog.models import AttributeChangelog
 from infrahub.core.constants import NULL_VALUE, AttributeDBNodeType, BranchSupportType, RelationshipStatus
 from infrahub.core.property import FlagPropertyMixin, NodePropertyData, NodePropertyMixin
 from infrahub.core.query.attribute import (
@@ -37,8 +38,6 @@ if TYPE_CHECKING:
     from infrahub.core.schema import AttributeSchema
     from infrahub.database import InfrahubDatabase
 
-# pylint: disable=redefined-builtin,c-extension-no-member,too-many-lines,too-many-public-methods
-
 
 # Use a more user-friendly threshold than Neo4j one (8167 bytes).
 MAX_STRING_LENGTH = 4096
@@ -81,7 +80,7 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
     _rel_to_node_label: str = RELATIONSHIP_TO_NODE_LABEL
     _rel_to_value_label: str = RELATIONSHIP_TO_VALUE_LABEL
 
-    def __init__(  # pylint: disable=too-many-branches
+    def __init__(
         self,
         name: str,
         schema: AttributeSchema,
@@ -218,7 +217,7 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         value_to_check = value
         if schema.enum and isinstance(value, Enum):
             value_to_check = value.value
-        if not isinstance(value_to_check, cls.type):  # pylint: disable=isinstance-second-argument-not-valid-type
+        if not isinstance(value_to_check, cls.type):
             raise ValidationError({name: f"{value} is not a valid {schema.kind}"})
 
     @classmethod
@@ -267,7 +266,7 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
     @classmethod
     def deserialize_from_string(cls, value_as_string: str) -> Any:
         """Return a value corresponding to the attribute type given it formatted as a string."""
-        return cls.type(value_as_string)  # pylint: disable=not-callable
+        return cls.type(value_as_string)
 
     def to_db(self) -> dict[str, Any]:
         """Return the properties of the AttributeValue node in Dict format."""
@@ -318,19 +317,19 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         """Deserialize the value coming from the database."""
         return data.value
 
-    async def save(self, db: InfrahubDatabase, at: Optional[Timestamp] = None) -> bool:
+    async def save(self, db: InfrahubDatabase, at: Optional[Timestamp] = None) -> AttributeChangelog | None:
         """Create or Update the Attribute in the database."""
 
         save_at = Timestamp(at)
 
         if not self.id or self.is_from_profile:
-            return False
+            return None
 
         return await self._update(at=save_at, db=db)
 
-    async def delete(self, db: InfrahubDatabase, at: Optional[Timestamp] = None) -> bool:
+    async def delete(self, db: InfrahubDatabase, at: Optional[Timestamp] = None) -> AttributeChangelog | None:
         if not self.db_id:
-            return False
+            return None
 
         delete_at = Timestamp(at)
 
@@ -339,7 +338,14 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         results = query.get_results()
 
         if not results:
-            return False
+            return None
+
+        changelog = AttributeChangelog(
+            name=self.name,
+            value=None,
+            value_previous=None,
+            kind=self.schema.kind,
+        )
 
         properties_to_delete = []
         branch = self.get_branch_based_on_support_type()
@@ -347,6 +353,8 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         # Check all the relationship and update the one that are in the same branch
         rel_ids_to_update = set()
         for result in results:
+            if result.get_rel("r2").type == "HAS_VALUE":
+                changelog.value_previous = result.get_node("ap").get("value")
             properties_to_delete.append((result.get_rel("r2").type, result.get_node("ap").element_id))
 
             await add_relationship(
@@ -378,9 +386,9 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
             db=db,
         )
 
-        return True
+        return changelog
 
-    async def _update(self, db: InfrahubDatabase, at: Optional[Timestamp] = None) -> bool:
+    async def _update(self, db: InfrahubDatabase, at: Optional[Timestamp] = None) -> AttributeChangelog | None:
         """Update the attribute in the database.
 
         Get the current value
@@ -420,6 +428,13 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
 
         branch = self.get_branch_based_on_support_type()
 
+        changelog = AttributeChangelog(
+            name=self.name,
+            value=self.to_db().get("value"),
+            value_previous=current_attr_data.value,
+            kind=self.schema.kind,
+        )
+
         # ---------- Update the Value ----------
         if current_attr_data.content != self.to_db():
             # Create the new AttributeValue and update the existing relationship
@@ -439,6 +454,11 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
 
         for flag_name, _, rel_name in SUPPORTED_FLAGS:
             if current_attr_data.flag_properties[flag_name] != getattr(self, flag_name):
+                changelog.add_property(
+                    name=flag_name,
+                    value_current=getattr(self, flag_name),
+                    value_previous=current_attr_data.flag_properties[flag_name],
+                )
                 query = await AttributeUpdateFlagQuery.init(db=db, attr=self, at=update_at, flag_name=flag_name)
                 await query.execute(db=db)
 
@@ -452,6 +472,16 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
                 prop_name in current_attr_data.node_properties
                 and current_attr_data.node_properties[prop_name].uuid == getattr(self, f"{prop_name}_id")
             ):
+                previous_attribute_node_property = current_attr_data.node_properties.get(prop_name)
+                previous_value = None
+                if previous_attribute_node_property:
+                    previous_value = previous_attribute_node_property.uuid
+
+                changelog.add_property(
+                    name=prop_name,
+                    value_current=getattr(self, f"{prop_name}_id"),
+                    value_previous=previous_value,
+                )
                 query = await AttributeUpdateNodePropertyQuery.init(
                     db=db, attr=self, at=update_at, prop_name=prop_name, prop_id=getattr(self, f"{prop_name}_id")
                 )
@@ -461,7 +491,8 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
                 if rel and rel.get("branch") == branch.name:
                     await update_relationships_to([rel.element_id], to=update_at, db=db)
 
-        return True
+        if changelog.has_updates:
+            return changelog
 
     async def to_graphql(
         self,
@@ -470,9 +501,9 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         related_node_ids: Optional[set] = None,
         filter_sensitive: bool = False,
         permissions: Optional[dict] = None,
+        include_properties: bool = True,
     ) -> dict:
         """Generate GraphQL Payload for this attribute."""
-        # pylint: disable=too-many-branches
 
         response: dict[str, Any] = {"id": self.id}
 
@@ -480,7 +511,9 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
             field_names = fields.keys()
         else:
             # REMOVED updated_at for now, need to investigate further how it's being used today
-            field_names = ["__typename", "value"] + self._node_properties + self._flag_properties
+            field_names = ["__typename", "value"]
+            if include_properties:
+                field_names += self._node_properties + self._flag_properties
 
         for field_name in field_names:
             if field_name == "updated_at":
@@ -527,11 +560,11 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
                     field = field.value
             if isinstance(field, str):
                 response[field_name] = self._filter_sensitive(value=field, filter_sensitive=filter_sensitive)
-            elif isinstance(field, (int, bool, dict, list)):
+            elif isinstance(field, int | bool | dict | list):
                 response[field_name] = field
 
-            if related_node_ids and self.is_from_profile and getattr(self, "source_id"):
-                related_node_ids.add(getattr(self, "source_id"))
+            if related_node_ids and self.is_from_profile and self.source_id:
+                related_node_ids.add(self.source_id)
 
         return response
 
@@ -589,7 +622,6 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         return AttributeDBNodeType.DEFAULT
 
     def get_create_data(self) -> AttributeCreateData:
-        # pylint: disable=no-member
         branch = self.branch
         hierarchy_level = branch.hierarchy_level
         if self.schema.branch == BranchSupportType.AGNOSTIC:
@@ -1159,7 +1191,7 @@ class ListAttribute(BaseAttribute):
 
     def deserialize_value(self, data: AttributeFromDB) -> Any:
         """Deserialize the value (potentially) coming from the database."""
-        if isinstance(data.value, (str, bytes)):
+        if isinstance(data.value, str | bytes):
             return ujson.loads(data.value)
         return data.value
 
@@ -1195,7 +1227,7 @@ class JSONAttribute(BaseAttribute):
 
     def deserialize_value(self, data: AttributeFromDB) -> Any:
         """Deserialize the value (potentially) coming from the database."""
-        if data.value and isinstance(data.value, (str, bytes)):
+        if data.value and isinstance(data.value, str | bytes):
             return ujson.loads(data.value)
         return data.value