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

infrahub/actions/tasks.py

@@ -211,8 +211,10 @@ async def configure_action_rules(
     service: InfrahubServices,
 ) -> None:
     await setup_triggers_specific(
-        gatherer=gather_trigger_action_rules, trigger_type=TriggerType.ACTION_TRIGGER_RULE, db=service.database
-    )  # type: ignore[misc]
+        gatherer=gather_trigger_action_rules,  # type: ignore[arg-type]
+        trigger_type=TriggerType.ACTION_TRIGGER_RULE,
+        db=service.database,
+    )
 
 
 async def _get_targets(

infrahub/api/schema.py

@@ -366,6 +366,7 @@ async def load_schema(
                 diff=result.diff,
                 limit=result.diff.all,
                 update_db=True,
+                user_id=account_session.account_id,
             )
             branch.update_schema_hash()
             log.info("Schema has been updated", branch=branch.name, hash=branch.active_schema_hash.main)
@@ -375,7 +376,7 @@ async def load_schema(
                 branch.is_isolated = True
                 log.info("Branch converted to isolated mode because the schema has changed", branch=branch.name)
 
-            await branch.save(db=dbt)
+            await branch.save(db=dbt, user_id=account_session.account_id)
             updated_branch = registry.schema.get_schema_branch(name=branch.name)
             updated_hash = updated_branch.get_hash()
 
@@ -387,6 +388,7 @@ async def load_schema(
             new_schema=candidate_schema,
             previous_schema=origin_schema,
             migrations=result.migrations,
+            user_id=account_session.account_id,
         )
         migration_error_msgs = await service.workflow.execute_workflow(
             workflow=SCHEMA_APPLY_MIGRATION,

infrahub/artifacts/tasks.py

@@ -14,6 +14,7 @@ async def create(model: CheckArtifactCreate) -> ValidatorConclusion:
     await add_tags(branches=[model.branch_name], nodes=[model.target_id])
 
     client = get_client()
+    client.request_context = model.context.to_request_context()
 
     validator = await client.get(kind=InfrahubKind.ARTIFACTVALIDATOR, id=model.validator_id, include=["checks"])
 

infrahub/auth.py

@@ -73,8 +73,8 @@ async def authenticate_with_password(
 ) -> models.UserToken:
     selected_branch = await registry.get_branch(db=db, branch=branch)
 
-    response: list[CoreGenericAccount] = await NodeManager.query(
-        schema=InfrahubKind.GENERICACCOUNT,
+    response = await NodeManager.query(
+        schema=CoreGenericAccount,
         db=db,
         branch=selected_branch,
         filters={"name__value": credentials.username},

infrahub/cli/db.py

@@ -603,17 +603,17 @@ RETURN vertices, edges
     edge_path = export_dir / Path("edges.csv")
     edge_path.touch(exist_ok=True)
 
-    graph_node_schemas = [GraphNodeProperties, GraphRelationshipProperties, GraphAttributeProperties]
+    graph_node_schemas = (GraphNodeProperties, GraphRelationshipProperties, GraphAttributeProperties)
     graph_vertex_properties = set()
-    for graph_schema in graph_node_schemas:
-        for field_name, field_info in graph_schema.model_fields.items():
+    for graph_node_schema in graph_node_schemas:
+        for field_name, field_info in graph_node_schema.model_fields.items():
             property_name = field_info.alias or field_name
             graph_vertex_properties.add(property_name)
 
-    graph_edge_schemas = [GraphRelationshipIsPartOf, GraphRelationshipDefault]
+    graph_edge_schemas = (GraphRelationshipIsPartOf, GraphRelationshipDefault)
     graph_edge_properties = set()
-    for graph_schema in graph_edge_schemas:
-        for field_name, field_info in graph_schema.model_fields.items():
+    for graph_edge_schema in graph_edge_schemas:
+        for field_name, field_info in graph_edge_schema.model_fields.items():
             property_name = field_info.alias or field_name
             graph_edge_properties.add(property_name)
 

infrahub/computed_attribute/gather.py

@@ -7,9 +7,9 @@ from prefect import task
 from prefect.cache_policies import NONE
 from prefect.logging import get_run_logger
 
-from infrahub.core.constants import InfrahubKind
 from infrahub.core.manager import NodeManager
 from infrahub.core.protocols import CoreGenericRepository, CoreGraphQLQuery
+from infrahub.core.protocols import CoreTransformPython as CoreTransformPythonNode
 from infrahub.core.registry import registry
 from infrahub.database import InfrahubDatabase  # noqa: TC001  needed for prefect flow
 from infrahub.git.utils import get_repositories_commit_per_branch
@@ -24,7 +24,6 @@ from .models import (
 )
 
 if TYPE_CHECKING:
-    from infrahub.core.protocols import CoreTransformPython as CoreTransformPythonNode
     from infrahub.git.models import RepositoryData
 
 
@@ -48,9 +47,9 @@ async def gather_python_transform_attributes(
     if not transform_names:
         return []
 
-    transforms: list[CoreTransformPythonNode] = await NodeManager.query(
+    transforms = await NodeManager.query(
         db=db,
-        schema=InfrahubKind.TRANSFORMPYTHON,
+        schema=CoreTransformPythonNode,
         branch=branch_name,
         fields={"id": None, "name": None, "repository": None, "query": None},
         filters={"name__values": transform_names},

infrahub/computed_attribute/tasks.py

@@ -42,8 +42,10 @@ mutation UpdateAttribute(
     $kind: String!,
     $attribute: String!,
     $value: String!
+    $context_account_id: String!
   ) {
   InfrahubUpdateComputedAttribute(
+    context: {account: {id: $context_account_id}},
     data: {id: $id, attribute: $attribute, value: $value, kind: $kind}
   ) {
     ok
@@ -62,7 +64,7 @@ async def process_transform(
     object_id: str,
     computed_attribute_name: str,  # noqa: ARG001
     computed_attribute_kind: str,  # noqa: ARG001
-    context: InfrahubContext,  # noqa: ARG001
+    context: InfrahubContext,
     updated_fields: list[str] | None = None,  # noqa: ARG001
 ) -> None:
     await add_tags(branches=[branch_name], nodes=[object_id])
@@ -103,7 +105,7 @@ async def process_transform(
             name=transform.repository.peer.name.value,
             repository_kind=str(transform.repository.peer.typename),
             commit=repo_node.commit.value,
-        )  # type: ignore[misc]
+        )
 
         data = await client.query_gql_query(
             name=transform.query.id,
@@ -120,11 +122,17 @@ async def process_transform(
             location=f"{transform.file_path.value}::{transform.class_name.value}",
             data=data,
             convert_query_response=transform.convert_query_response.value,
-        )  # type: ignore[misc]
+        )  # type: ignore[call-overload]
 
         await client.execute_graphql(
             query=UPDATE_ATTRIBUTE,
-            variables={"id": object_id, "kind": node_kind, "attribute": attribute_name, "value": transformed_data},
+            variables={
+                "id": object_id,
+                "kind": node_kind,
+                "attribute": attribute_name,
+                "value": transformed_data,
+                "context_account_id": context.account.account_id,
+            },
             branch_name=branch_name,
         )
 
@@ -168,6 +176,7 @@ async def computed_attribute_jinja2_update_value(
     node_kind: str,
     attribute_name: str,
     template: Jinja2Template,
+    context: InfrahubContext,
 ) -> None:
     log = get_run_logger()
     client = get_client()
@@ -182,7 +191,13 @@ async def computed_attribute_jinja2_update_value(
     try:
         await client.execute_graphql(
             query=UPDATE_ATTRIBUTE,
-            variables={"id": obj.node_id, "kind": node_kind, "attribute": attribute_name, "value": value},
+            variables={
+                "id": obj.node_id,
+                "kind": node_kind,
+                "attribute": attribute_name,
+                "value": value,
+                "context_account_id": context.account.account_id,
+            },
             branch_name=branch_name,
         )
         log.info(f"Updating computed attribute {node_kind}.{attribute_name}='{value}' ({obj.node_id})")
@@ -202,7 +217,7 @@ async def process_jinja2(
     object_id: str,
     computed_attribute_name: str,
     computed_attribute_kind: str,
-    context: InfrahubContext,  # noqa: ARG001
+    context: InfrahubContext,
     updated_fields: list[str] | None = None,
 ) -> None:
     log = get_run_logger()
@@ -258,6 +273,7 @@ async def process_jinja2(
                 node_kind=node_schema.kind,
                 attribute_name=computed_macro.attribute.name,
                 template=jinja_template,
+                context=context,
             )
 
         _ = [response async for _, response in batch.execute()]
@@ -462,6 +478,7 @@ async def query_transform_targets(
                         "object_id": subscriber.object_id,
                         "computed_attribute_name": computed_attribute.name,
                         "computed_attribute_kind": subscriber.kind,
+                        "context": context,
                     },
                 )
 

infrahub/config.py

@@ -207,6 +207,14 @@ class MainSettings(BaseSettings):
     def convert_to_path(cls, value: Path | str) -> Path:
         return Path(value) if isinstance(value, str) else value
 
+    @property
+    def infrahub_address(self) -> str:
+        """This is the address that the Prefect worker will use to connect to Infrahub API."""
+        if self.internal_address:
+            return self.internal_address
+
+        raise InitializationError()
+
 
 class FileSystemStorageSettings(BaseSettings):
     # Make variable lookup case-sensitive to avoid fetching $PATH value

infrahub/constants/enums.py

@@ -0,0 +1,12 @@
+from enum import StrEnum
+
+
+class OrderDirection(StrEnum):
+    ASC = "ASC"
+    DESC = "DESC"
+
+
+class OrderByField(StrEnum):
+    ID = "id"
+    CREATED_AT = "created_at"
+    UPDATED_AT = "updated_at"

infrahub/core/account.py

@@ -54,15 +54,11 @@ class AccountGlobalPermissionQuery(Query):
     name: str = "account_global_permissions"
     type: QueryType = QueryType.READ
 
-    def __init__(
-        self,
-        account_id: str,
-        branch: Branch | None = None,
-        branch_agnostic: bool = False,
-    ) -> None:
-        super().__init__(branch=branch, branch_agnostic=branch_agnostic)
+    def __init__(self, account_id: str, **kwargs: Any):
         self.account_id = account_id
+        super().__init__(**kwargs)
 
+    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(
@@ -70,6 +66,7 @@ class AccountGlobalPermissionQuery(Query):
         )
         self.params.update(branch_params)
 
+        # ruff: noqa: E501
         query = """
         MATCH (account:%(generic_account_node)s)
         WHERE account.uuid = $account_id
@@ -296,7 +293,7 @@ class AccountObjectPermissionQuery(Query):
 
 
 async def fetch_permissions(account_id: str, db: InfrahubDatabase, branch: Branch) -> AssignedPermissions:
-    query1 = AccountGlobalPermissionQuery(branch=branch, account_id=account_id, branch_agnostic=True)
+    query1 = await AccountGlobalPermissionQuery.init(db=db, branch=branch, account_id=account_id, branch_agnostic=True)
     await query1.execute(db=db)
     global_permissions = query1.get_permissions()
 

infrahub/core/attribute.py

@@ -15,18 +15,27 @@ 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.constants import (
+    NULL_VALUE,
+    SYSTEM_USER_ID,
+    AttributeDBNodeType,
+    BranchSupportType,
+    InfrahubKind,
+    MetadataOptions,
+)
+from infrahub.core.metadata.interface import MetadataInterface
+from infrahub.core.metadata.model import MetadataInfo
 from infrahub.core.property import FlagPropertyMixin, NodePropertyData, NodePropertyMixin
 from infrahub.core.query.attribute import (
     AttributeClearNodePropertyQuery,
-    AttributeGetQuery,
+    AttributeDeleteQuery,
     AttributeUpdateFlagQuery,
     AttributeUpdateNodePropertyQuery,
     AttributeUpdateValueQuery,
 )
 from infrahub.core.query.node import AttributeFromDB, NodeListGetAttributeQuery
 from infrahub.core.timestamp import Timestamp
-from infrahub.core.utils import add_relationship, convert_ip_to_binary_str, update_relationships_to
+from infrahub.core.utils import convert_ip_to_binary_str
 from infrahub.exceptions import ValidationError
 from infrahub.helpers import hash_password
 
@@ -70,12 +79,11 @@ class AttributeCreateData(BaseModel):
     content: dict[str, Any]
     is_default: bool
     is_protected: bool
-    is_visible: bool
     source_prop: list[NodePropertyData] = Field(default_factory=list)
     owner_prop: list[NodePropertyData] = Field(default_factory=list)
 
 
-class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
+class BaseAttribute(FlagPropertyMixin, NodePropertyMixin, MetadataInterface):
     type: type | tuple[type] | None = None
 
     _rel_to_node_label: str = RELATIONSHIP_TO_NODE_LABEL
@@ -91,7 +99,6 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         id: str | None = None,
         db_id: str | None = None,
         data: dict | str | AttributeFromDB | None = None,
-        updated_at: Timestamp | str | None = None,
         is_default: bool = False,
         is_from_profile: bool = False,
         **kwargs: dict[str, Any],
@@ -99,7 +106,6 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         self.id = id
         self.db_id = db_id
 
-        self.updated_at = updated_at
         self.name = name
         self.node = node
         self.schema = schema
@@ -112,6 +118,13 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         self._init_node_property_mixin(kwargs)
         self._init_flag_property_mixin(kwargs)
 
+        self._metadata = MetadataInfo(
+            created_at=kwargs.get("created_at"),
+            created_by=kwargs.get("created_by"),
+            updated_at=kwargs.get("updated_at"),
+            updated_by=kwargs.get("updated_by"),
+        )
+
         self.value = None
 
         if isinstance(data, AttributeFromDB):
@@ -130,8 +143,6 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
             for field_name in fields_to_extract_from_data:
                 setattr(self, field_name, data.get(field_name, None))
 
-            if not self.updated_at and "updated_at" in data:
-                self.updated_at = Timestamp(data.get("updated_at"))
         elif data is None:
             self.is_default = True
         else:
@@ -151,9 +162,6 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         if self.is_protected is None:
             self.is_protected = False
 
-        if self.is_visible is None:
-            self.is_visible = True
-
     @property
     def is_enum(self) -> bool:
         return bool(self.schema.enum)
@@ -187,6 +195,30 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         if self.is_enum and self.value:
             self.value = self.schema.convert_value_to_enum(self.value)
 
+    def _set_created_at(self, value: Timestamp | None) -> None:
+        self._metadata.created_at = value
+
+    def _set_created_by(self, value: str | None) -> None:
+        self._metadata.created_by = value
+
+    def _set_updated_at(self, value: Timestamp | None) -> None:
+        self._metadata.updated_at = value
+
+    def _set_updated_by(self, value: str | None) -> None:
+        self._metadata.updated_by = value
+
+    def _get_created_at(self) -> Timestamp | None:
+        return self._metadata.created_at
+
+    def _get_created_by(self) -> str | None:
+        return self._metadata.created_by
+
+    def _get_updated_at(self) -> Timestamp | None:
+        return self._metadata.updated_at
+
+    def _get_updated_by(self) -> str | None:
+        return self._metadata.updated_by
+
     @staticmethod
     def get_allowed_property_in_path() -> list[str]:
         return ["value"]
@@ -302,8 +334,10 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
             if prop_name in data.node_properties:
                 setattr(self, prop_name, data.node_properties[prop_name].uuid)
 
-        if not self.updated_at and data.updated_at:
-            self.updated_at = Timestamp(data.updated_at)
+        self._set_created_at(data.created_at)
+        self._set_created_by(data.created_by)
+        self._set_updated_at(data.updated_at)
+        self._set_updated_by(data.updated_by)
 
     def value_from_db(self, data: AttributeFromDB) -> Any:
         if data.value == NULL_VALUE:
@@ -320,7 +354,9 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         """Deserialize the value coming from the database."""
         return data.value
 
-    async def save(self, db: InfrahubDatabase, at: Timestamp | None = None) -> AttributeChangelog | None:
+    async def save(
+        self, db: InfrahubDatabase, user_id: str = SYSTEM_USER_ID, at: Timestamp | None = None
+    ) -> AttributeChangelog | None:
         """Create or Update the Attribute in the database."""
 
         save_at = Timestamp(at)
@@ -328,70 +364,34 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         if not self.id:
             return None
 
-        return await self._update(at=save_at, db=db)
+        return await self._update(db=db, user_id=user_id, at=save_at)
 
-    async def delete(self, db: InfrahubDatabase, at: Timestamp | None = None) -> AttributeChangelog | None:
+    async def delete(
+        self, db: InfrahubDatabase, user_id: str = SYSTEM_USER_ID, at: Timestamp | None = None
+    ) -> AttributeChangelog | None:
         if not self.db_id:
             return None
 
         delete_at = Timestamp(at)
+        branch = self.get_branch_based_on_support_type()
 
-        query = await AttributeGetQuery.init(db=db, attr=self, at=delete_at)
+        query = await AttributeDeleteQuery.init(db=db, branch=branch, attr=self, user_id=user_id, at=delete_at)
         await query.execute(db=db)
-        results = query.get_results()
+        previous_value = query.get_previous_property_value()
 
-        if not results:
+        if not previous_value:
             return None
 
-        changelog = AttributeChangelog(
+        return AttributeChangelog(
             name=self.name,
             value=None,
-            value_previous=None,
+            value_previous=previous_value,
             kind=self.schema.kind,
         )
 
-        properties_to_delete = []
-        branch = self.get_branch_based_on_support_type()
-
-        # 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(
-                src_node_id=self.db_id,
-                dst_node_id=result.get_node("ap").element_id,
-                rel_type=result.get_rel("r2").type,
-                branch_name=branch.name,
-                branch_level=branch.hierarchy_level,
-                at=delete_at,
-                status=RelationshipStatus.DELETED,
-                db=db,
-            )
-
-            for rel in result.get_rels():
-                if rel.get("branch") == branch.name:
-                    rel_ids_to_update.add(rel.element_id)
-
-        if rel_ids_to_update:
-            await update_relationships_to(ids=list(rel_ids_to_update), to=delete_at, db=db)
-
-        await add_relationship(
-            src_node_id=self.node.db_id,
-            dst_node_id=self.db_id,
-            rel_type="HAS_ATTRIBUTE",
-            branch_name=branch.name,
-            branch_level=branch.hierarchy_level,
-            at=delete_at,
-            status=RelationshipStatus.DELETED,
-            db=db,
-        )
-
-        return changelog
-
-    async def _update(self, db: InfrahubDatabase, at: Timestamp | None = None) -> AttributeChangelog | None:
+    async def _update(
+        self, db: InfrahubDatabase, user_id: str, at: Timestamp | None = None
+    ) -> AttributeChangelog | None:
         """Update the attribute in the database.
 
         Get the current value
@@ -422,13 +422,10 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
             fields={self.name: True},
             branch=self.branch,
             at=update_at,
-            include_source=True,
-            include_owner=True,
+            include_metadata=MetadataOptions.LINKED_NODES,
         )
         await query.execute(db=db)
-        current_attr_data, current_attr_result = query.get_result_by_id_and_name(self.node.id, self.name)
-
-        branch = self.get_branch_based_on_support_type()
+        current_attr_data, _ = query.get_result_by_id_and_name(self.node.id, self.name)
 
         changelog = AttributeChangelog(
             name=self.name,
@@ -437,36 +434,26 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
             kind=self.schema.kind,
         )
 
+        branch = self.get_branch_based_on_support_type()
+
         # ---------- Update the Value ----------
         if current_attr_data.content != self.to_db():
             # Create the new AttributeValue and update the existing relationship
-            query = await AttributeUpdateValueQuery.init(db=db, attr=self, at=update_at)
+            query = await AttributeUpdateValueQuery.init(db=db, branch=branch, attr=self, user_id=user_id, at=update_at)
             await query.execute(db=db)
 
-            # TODO check that everything went well
-            rel = current_attr_result.get_rel("r2")
-            if rel.get("branch") == branch.name:
-                await update_relationships_to([rel.element_id], to=update_at, db=db)
-
         # ---------- Update the Flags ----------
-        SUPPORTED_FLAGS = (
-            ("is_visible", "isv", "rel_isv"),
-            ("is_protected", "isp", "rel_isp"),
-        )
-
-        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)
-
-                rel = current_attr_result.get(rel_name)
-                if rel.get("branch") == branch.name:
-                    await update_relationships_to([rel.element_id], to=update_at, db=db)
+        flag_name = "is_protected"
+        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, branch=branch, attr=self, user_id=user_id, at=update_at, flag_name=flag_name
+            )
+            await query.execute(db=db)
 
         # ---------- Update the Node Properties ----------
         for prop_name in self._node_properties:
@@ -488,21 +475,27 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
 
             if needs_update:
                 query = await AttributeUpdateNodePropertyQuery.init(
-                    db=db, attr=self, at=update_at, prop_name=prop_name, prop_id=current_prop_id
+                    db=db,
+                    branch=branch,
+                    attr=self,
+                    user_id=user_id,
+                    at=update_at,
+                    prop_name=prop_name,
+                    prop_id=current_prop_id,
                 )
                 await query.execute(db=db)
 
             if needs_clear:
                 query = await AttributeClearNodePropertyQuery.init(
-                    db=db, attr=self, at=update_at, prop_name=prop_name, prop_id=database_prop_id
+                    db=db,
+                    branch=branch,
+                    attr=self,
+                    user_id=user_id,
+                    at=update_at,
+                    prop_name=prop_name,
                 )
                 await query.execute(db=db)
 
-            # set the to time on the previously active edge
-            rel = current_attr_result.get(f"rel_{prop_name}")
-            if rel and rel.get("branch") == branch.name:
-                await update_relationships_to([rel.element_id], to=update_at, db=db)
-
         if changelog.has_updates:
             return changelog
 
@@ -531,10 +524,19 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
 
         for field_name in field_names:
             if field_name == "updated_at":
-                if self.updated_at:
-                    response[field_name] = await self.updated_at.to_graphql()
-                else:
-                    response[field_name] = None
+                updated_at = self._get_updated_at()
+                response[field_name] = await updated_at.to_graphql() if updated_at else None
+                continue
+
+            if field_name == "updated_by":
+                response[field_name] = (
+                    {
+                        "id": self._get_updated_by(),
+                        "__kind__": InfrahubKind.ACCOUNT,
+                    }
+                    if self._get_updated_by()
+                    else None
+                )
                 continue
 
             if field_name == "__typename":
@@ -620,9 +622,6 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         if "is_protected" in data and data["is_protected"] != self.is_protected:
             self.is_protected = data["is_protected"]
             changed = True
-        if "is_visible" in data and data["is_visible"] != self.is_visible:
-            self.is_visible = data["is_visible"]
-            changed = True
 
         if "source" in data and data["source"] != self.source_id:
             self.source = data["source"]
@@ -657,7 +656,6 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
             content=self.to_db(),
             is_default=self.is_default,
             is_protected=self.is_protected,
-            is_visible=self.is_visible,
         )
         if self.source_id:
             data.source_prop.append(NodePropertyData(name="source", peer_id=self.source_id))