infrahub-server 1.4.9__py3-none-any.whl → 1.5.0b0__py3-none-any.whl

infrahub/graphql/mutations/computed_attribute.py

@@ -2,20 +2,28 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
-from graphene import Boolean, InputObjectType, Mutation, String
+from graphene import Boolean, InputObjectType, List, Mutation, NonNull, String
 
 from infrahub.core.account import ObjectPermission
 from infrahub.core.constants import ComputedAttributeKind, PermissionAction, PermissionDecision
 from infrahub.core.manager import NodeManager
+from infrahub.core.protocols import CoreTransformPython
 from infrahub.core.registry import registry
 from infrahub.database import retry_db_transaction
 from infrahub.events import EventMeta
 from infrahub.events.node_action import NodeUpdatedEvent
-from infrahub.exceptions import NodeNotFoundError, ValidationError
+from infrahub.exceptions import NodeNotFoundError, ProcessingError, ValidationError
 from infrahub.graphql.context import apply_external_context
 from infrahub.graphql.types.context import ContextInput
 from infrahub.log import get_log_data
 from infrahub.worker import WORKER_IDENTITY
+from infrahub.workers.dependencies import get_workflow
+from infrahub.workflows.catalogue import (
+    COMPUTED_ATTRIBUTE_PROCESS_JINJA2,
+    COMPUTED_ATTRIBUTE_PROCESS_TRANSFORM,
+    TRIGGER_UPDATE_JINJA_COMPUTED_ATTRIBUTES,
+    TRIGGER_UPDATE_PYTHON_COMPUTED_ATTRIBUTES,
+)
 
 if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
@@ -89,7 +97,7 @@ class UpdateComputedAttribute(Mutation):
             raise NodeNotFoundError(
                 node_type="target_node",
                 identifier=str(data.id),
-                message="The indicated not does not have the specified attribute_name",
+                message="The indicated node does not have the specified attribute_name",
             )
         if attribute_field.value != str(data.value):
             attribute_field.value = str(data.value)
@@ -117,3 +125,102 @@ class UpdateComputedAttribute(Mutation):
         result: dict[str, Any] = {"ok": True}
 
         return cls(**result)
+
+
+class InfrahubComputedAttributeRecomputeInput(InputObjectType):
+    kind = String(required=True, description="Kind of the node to update")
+    attribute = String(required=True, description="Name of the computed attribute that must be recomputed")
+    node_ids = List(NonNull(String), description="ID of the nodes for which the attribute must be recomputed")
+
+
+class RecomputeComputedAttribute(Mutation):
+    class Arguments:
+        data = InfrahubComputedAttributeRecomputeInput(required=True)
+        context = ContextInput(required=False)
+
+    ok = Boolean()
+
+    @classmethod
+    @retry_db_transaction(name="update_computed_attribute")
+    async def mutate(
+        cls,
+        _: dict,
+        info: GraphQLResolveInfo,
+        data: InfrahubComputedAttributeRecomputeInput,
+        context: ContextInput | None = None,
+    ) -> RecomputeComputedAttribute:
+        graphql_context: GraphqlContext = info.context
+        node_schema = registry.schema.get_node_schema(
+            name=str(data.kind), branch=graphql_context.branch.name, duplicate=False
+        )
+
+        graphql_context.active_permissions.raise_for_permission(
+            permission=ObjectPermission(
+                namespace=node_schema.namespace,
+                name=node_schema.name,
+                action=PermissionAction.UPDATE.value,
+                decision=PermissionDecision.ALLOW_DEFAULT.value
+                if graphql_context.branch.name == registry.default_branch
+                else PermissionDecision.ALLOW_OTHER.value,
+            )
+        )
+        await apply_external_context(graphql_context=graphql_context, context_input=context)
+
+        attribute = node_schema.get_attribute(name=str(data.attribute))
+
+        if not attribute:
+            raise ProcessingError(
+                message=f"The indicated node does not have the specified attribute '{data.attribute}'"
+            )
+        if not attribute.computed_attribute:
+            raise ProcessingError(
+                message=f"The indicated node does not use a computed attribute for the specified attribute '{data.attribute}'"
+            )
+
+        recalculate_single_workflow = COMPUTED_ATTRIBUTE_PROCESS_JINJA2
+        recalculate_all_workflow = TRIGGER_UPDATE_JINJA_COMPUTED_ATTRIBUTES
+        if attribute.computed_attribute.kind == ComputedAttributeKind.TRANSFORM_PYTHON:
+            if not await NodeManager.query(
+                db=graphql_context.db,
+                branch=graphql_context.branch,
+                schema=CoreTransformPython,
+                filters={"name__value": attribute.computed_attribute.transform},
+            ):
+                raise ProcessingError(
+                    message=f"The transform for the indicated node computed attribute for the specified attribute '{data.attribute}' does not exist"
+                )
+
+            recalculate_single_workflow = COMPUTED_ATTRIBUTE_PROCESS_TRANSFORM
+            recalculate_all_workflow = TRIGGER_UPDATE_PYTHON_COMPUTED_ATTRIBUTES
+
+        if data.node_ids:
+            nodes = await NodeManager.get_many(
+                db=graphql_context.db, branch=graphql_context.branch, ids=list(data.node_ids)
+            )
+            for node in nodes.values():
+                await get_workflow().submit_workflow(
+                    workflow=recalculate_single_workflow,
+                    context=graphql_context.get_context(),
+                    parameters={
+                        "branch_name": graphql_context.branch.name,
+                        "computed_attribute_name": str(data.attribute),
+                        "computed_attribute_kind": node_schema.kind,
+                        "node_kind": node_schema.kind,
+                        "object_id": node.id,
+                        "context": context,
+                    },
+                )
+        else:
+            await get_workflow().submit_workflow(
+                workflow=recalculate_all_workflow,
+                context=graphql_context.get_context(),
+                parameters={
+                    "branch_name": graphql_context.branch.name,
+                    "computed_attribute_name": str(data.attribute),
+                    "computed_attribute_kind": node_schema.kind,
+                    "context": context,
+                },
+            )
+
+        result: dict[str, Any] = {"ok": True}
+        return cls(**result)

infrahub/graphql/mutations/convert_object_type.py

@@ -5,9 +5,12 @@ from graphene.types.generic import GenericScalar
 from graphql import GraphQLResolveInfo
 
 from infrahub.core import registry
-from infrahub.core.convert_object_type.conversion import InputForDestField, convert_object_type
+from infrahub.core.constants.infrahubkind import READONLYREPOSITORY, REPOSITORY
+from infrahub.core.convert_object_type.object_conversion import ConversionFieldInput, convert_and_validate_object_type
+from infrahub.core.convert_object_type.repository_conversion import convert_repository_type
 from infrahub.core.convert_object_type.schema_mapping import get_schema_mapping
 from infrahub.core.manager import NodeManager
+from infrahub.repositories.create_repository import RepositoryFinalizer
 
 if TYPE_CHECKING:
     from infrahub.graphql.initialization import GraphqlContext
@@ -44,26 +47,44 @@ class ConvertObjectType(Mutation):
         source_schema = registry.get_node_schema(name=node_to_convert.get_kind(), branch=graphql_context.branch)
         target_schema = registry.get_node_schema(name=str(data.target_kind), branch=graphql_context.branch)
 
-        fields_mapping: dict[str, InputForDestField] = {}
+        fields_mapping: dict[str, ConversionFieldInput] = {}
         if not isinstance(data.fields_mapping, dict):
-            raise ValueError(f"Expected `fields_mapping` to be a `dict`, got {type(fields_mapping)}")
+            raise ValueError(f"Expected `fields_mapping` to be a `dict`, got {type(data.fields_mapping)}")
 
         for field_name, input_for_dest_field_str in data.fields_mapping.items():
-            fields_mapping[field_name] = InputForDestField(**input_for_dest_field_str)
+            fields_mapping[field_name] = ConversionFieldInput(**input_for_dest_field_str)
+
+        node_to_convert = await NodeManager.get_one(
+            id=str(data.node_id), db=graphql_context.db, branch=graphql_context.branch
+        )
 
         # Complete fields mapping with auto-mapping.
         mapping = get_schema_mapping(source_schema=source_schema, target_schema=target_schema)
         for field_name, mapping_value in mapping.items():
             if mapping_value.source_field_name is not None and field_name not in fields_mapping:
-                fields_mapping[field_name] = InputForDestField(source_field=mapping_value.source_field_name)
-
-        new_node = await convert_object_type(
-            node=node_to_convert,
-            target_schema=target_schema,
-            mapping=fields_mapping,
-            branch=graphql_context.branch,
-            db=graphql_context.db,
-        )
+                fields_mapping[field_name] = ConversionFieldInput(source_field=mapping_value.source_field_name)
+
+        if target_schema.kind in [REPOSITORY, READONLYREPOSITORY]:
+            new_node = await convert_repository_type(
+                repository=node_to_convert,
+                target_schema=target_schema,
+                mapping=fields_mapping,
+                branch=graphql_context.branch,
+                db=graphql_context.db,
+                repository_post_creator=RepositoryFinalizer(
+                    account_session=graphql_context.active_account_session,
+                    services=graphql_context.active_service,
+                    context=graphql_context.get_context(),
+                ),
+            )
+        else:
+            new_node = await convert_and_validate_object_type(
+                node=node_to_convert,
+                target_schema=target_schema,
+                mapping=fields_mapping,
+                branch=graphql_context.branch,
+                db=graphql_context.db,
+            )
 
         dict_node = await new_node.to_graphql(db=graphql_context.db, fields={})
         result: dict[str, Any] = {"ok": True, "node": dict_node}

infrahub/graphql/mutations/ipam.py

@@ -16,10 +16,12 @@ from infrahub.core.node import Node
 from infrahub.core.schema import NodeSchema
 from infrahub.database import InfrahubDatabase, retry_db_transaction
 from infrahub.exceptions import NodeNotFoundError, ValidationError
-from infrahub.lock import InfrahubMultiLock, build_object_lock_name
+from infrahub.lock import InfrahubMultiLock
 from infrahub.log import get_logger
 
-from .main import DeleteResult, InfrahubMutationMixin, InfrahubMutationOptions
+from ...core.node.create import create_node
+from ...core.node.lock_utils import build_object_lock_name
+from .main import DeleteResult, InfrahubMutationMixin, InfrahubMutationOptions, build_graphql_response
 from .node_getter.by_default_filter import MutationNodeGetterByDefaultFilter
 
 if TYPE_CHECKING:
@@ -121,7 +123,13 @@ class InfrahubIPAddressMutation(InfrahubMutationMixin, Mutation):
         ip_address: IPv4Interface | ipaddress.IPv6Interface,
         namespace_id: str,
     ) -> Node:
-        address = await cls.mutate_create_object(data=data, db=db, branch=branch)
+        address = await create_node(
+            data=dict(data),
+            db=db,
+            branch=branch,
+            schema=cls._meta.active_schema,
+        )
+
         reconciler = IpamReconciler(db=db, branch=branch)
         reconciled_address = await reconciler.reconcile(
             ip_value=ip_address, namespace=namespace_id, node_uuid=address.get_id()
@@ -152,9 +160,9 @@ class InfrahubIPAddressMutation(InfrahubMutationMixin, Mutation):
                 reconciled_address = await cls._mutate_create_object_and_reconcile(
                     data=data, branch=branch, db=dbt, ip_address=ip_address, namespace_id=namespace_id
                 )
-            result = await cls.mutate_create_to_graphql(info=info, db=dbt, obj=reconciled_address)
+            graphql_response = await build_graphql_response(info=info, db=dbt, obj=reconciled_address)
 
-        return reconciled_address, result
+        return reconciled_address, cls(**graphql_response)
 
     @classmethod
     async def _mutate_update_object_and_reconcile(
@@ -275,7 +283,12 @@ class InfrahubIPPrefixMutation(InfrahubMutationMixin, Mutation):
         db: InfrahubDatabase,
         namespace_id: str,
     ) -> Node:
-        prefix = await cls.mutate_create_object(data=data, db=db, branch=branch)
+        prefix = await create_node(
+            data=dict(data),
+            db=db,
+            branch=branch,
+            schema=cls._meta.active_schema,
+        )
         return await cls._reconcile_prefix(
             branch=branch, db=db, prefix=prefix, namespace_id=namespace_id, is_delete=False
         )
@@ -300,9 +313,9 @@ class InfrahubIPPrefixMutation(InfrahubMutationMixin, Mutation):
                     data=data, branch=branch, db=dbt, namespace_id=namespace_id
                 )
 
-            result = await cls.mutate_create_to_graphql(info=info, db=dbt, obj=reconciled_prefix)
+            graphql_response = await build_graphql_response(info=info, db=dbt, obj=reconciled_prefix)
 
-        return reconciled_prefix, result
+        return reconciled_prefix, cls(**graphql_response)
 
     @classmethod
     async def _mutate_update_object_and_reconcile(

infrahub/graphql/mutations/main.py

@@ -1,22 +1,18 @@
 from __future__ import annotations
 
-import hashlib
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any
 
 from graphene import InputObjectType, Mutation
 from graphene.types.mutation import MutationOptions
+from infrahub_sdk.utils import extract_fields_first_node
 from typing_extensions import Self
 
 from infrahub import config, lock
-from infrahub.core.constants import InfrahubKind, MutationAction
+from infrahub.core.constants import MutationAction
 from infrahub.core.constraint.node.runner import NodeConstraintRunner
 from infrahub.core.manager import NodeManager
-from infrahub.core.node.create import (
-    create_node,
-    get_profile_ids,
-    refresh_for_profile_update,
-)
+from infrahub.core.node.create import create_node, get_profile_ids
 from infrahub.core.schema import MainSchemaTypes, NodeSchema
 from infrahub.core.schema.generic_schema import GenericSchema
 from infrahub.core.schema.profile_schema import ProfileSchema
@@ -28,9 +24,11 @@ from infrahub.events.generator import generate_node_mutation_events
 from infrahub.exceptions import HFIDViolatedError, InitializationError, NodeNotFoundError
 from infrahub.graphql.context import apply_external_context
 from infrahub.graphql.field_extractor import extract_graphql_fields
-from infrahub.lock import InfrahubMultiLock, build_object_lock_name
+from infrahub.lock import InfrahubMultiLock
 from infrahub.log import get_log_data, get_logger
+from infrahub.profiles.node_applier import NodeProfilesApplier
 
+from ...core.node.lock_utils import get_kind_lock_names_on_object_mutation
 from .node_getter.by_default_filter import MutationNodeGetterByDefaultFilter
 
 if TYPE_CHECKING:
@@ -38,7 +36,6 @@ if TYPE_CHECKING:
 
     from infrahub.core.branch import Branch
     from infrahub.core.node import Node
-    from infrahub.core.schema.schema_branch import SchemaBranch
     from infrahub.database import InfrahubDatabase
     from infrahub.graphql.types.context import ContextInput
 
@@ -47,8 +44,6 @@ if TYPE_CHECKING:
 
 log = get_logger()
 
-KINDS_CONCURRENT_MUTATIONS_NOT_ALLOWED = [InfrahubKind.GENERICGROUP]
-
 
 @dataclass
 class DeleteResult:
@@ -146,23 +141,6 @@ class InfrahubMutationMixin:
 
         return mutation
 
-    @classmethod
-    async def _call_mutate_create_object(
-        cls, data: InputObjectType, db: InfrahubDatabase, branch: Branch, override_data: dict[str, Any] | None = None
-    ) -> Node:
-        """
-        Wrapper around mutate_create_object to potentially activate locking.
-        """
-        schema_branch = db.schema.get_schema_branch(name=branch.name)
-        lock_names = _get_kind_lock_names_on_object_mutation(
-            kind=cls._meta.active_schema.kind, branch=branch, schema_branch=schema_branch, data=data
-        )
-        if lock_names:
-            async with InfrahubMultiLock(lock_registry=lock.registry, locks=lock_names):
-                return await cls.mutate_create_object(data=data, db=db, branch=branch, override_data=override_data)
-
-        return await cls.mutate_create_object(data=data, db=db, branch=branch, override_data=override_data)
-
     @classmethod
     async def mutate_create(
         cls,
@@ -172,40 +150,21 @@ class InfrahubMutationMixin:
         database: InfrahubDatabase | None = None,
         override_data: dict[str, Any] | None = None,
     ) -> tuple[Node, Self]:
-        graphql_context: GraphqlContext = info.context
-        db = database or graphql_context.db
-        obj = await cls._call_mutate_create_object(data=data, db=db, branch=branch, override_data=override_data)
-        result = await cls.mutate_create_to_graphql(info=info, db=db, obj=obj)
-        return obj, result
-
-    @classmethod
-    @retry_db_transaction(name="object_create")
-    async def mutate_create_object(
-        cls,
-        data: InputObjectType,
-        db: InfrahubDatabase,
-        branch: Branch,
-        override_data: dict[str, Any] | None = None,
-    ) -> Node:
+        db = database or info.context.db
         schema = cls._meta.active_schema
-        if isinstance(schema, GenericSchema):
-            raise ValueError(f"Node of generic schema `{schema.name=}` can not be instantiated.")
+
         create_data = dict(data)
         create_data.update(override_data or {})
-        return await create_node(
+
+        obj = await create_node(
             data=create_data,
             db=db,
             branch=branch,
             schema=schema,
         )
 
-    @classmethod
-    async def mutate_create_to_graphql(cls, info: GraphQLResolveInfo, db: InfrahubDatabase, obj: Node) -> Self:
-        fields = extract_graphql_fields(info=info)
-        result: dict[str, Any] = {"ok": True}
-        if "object" in fields:
-            result["object"] = await obj.to_graphql(db=db, fields=fields.get("object", {}))
-        return cls(**result)
+        graphql_response = await build_graphql_response(info=info, db=db, obj=obj)
+        return obj, cls(**graphql_response)
 
     @classmethod
     async def _call_mutate_update(
@@ -222,8 +181,8 @@ class InfrahubMutationMixin:
         """
 
         schema_branch = db.schema.get_schema_branch(name=branch.name)
-        lock_names = _get_kind_lock_names_on_object_mutation(
-            kind=cls._meta.active_schema.kind, branch=branch, schema_branch=schema_branch, data=data
+        lock_names = get_kind_lock_names_on_object_mutation(
+            kind=cls._meta.active_schema.kind, branch=branch, schema_branch=schema_branch, data=dict(data)
         )
 
         if db.is_transaction:
@@ -290,7 +249,6 @@ class InfrahubMutationMixin:
         component_registry = get_component_registry()
         node_constraint_runner = await component_registry.get_component(NodeConstraintRunner, db=db, branch=branch)
 
-        before_mutate_profile_ids = await get_profile_ids(db=db, obj=obj)
         await obj.from_graphql(db=db, data=data)
         fields_to_validate = list(data)
         await node_constraint_runner.check(
@@ -302,15 +260,13 @@ class InfrahubMutationMixin:
             if field_to_remove in fields:
                 fields.remove(field_to_remove)
 
+        after_mutate_profile_ids = await get_profile_ids(db=db, obj=obj)
+        if after_mutate_profile_ids or (not after_mutate_profile_ids and obj.uses_profiles()):
+            node_profiles_applier = NodeProfilesApplier(db=db, branch=branch)
+            updated_field_names = await node_profiles_applier.apply_profiles(node=obj)
+            fields += updated_field_names
         await obj.save(db=db, fields=fields)
 
-        obj = await refresh_for_profile_update(
-            db=db,
-            branch=branch,
-            obj=obj,
-            previous_profile_ids=before_mutate_profile_ids,
-            schema=cls._meta.active_schema,
-        )
         return obj
 
     @classmethod
@@ -422,6 +378,15 @@ class InfrahubMutationMixin:
             )
             return updated_obj, mutation, False
 
+    @classmethod
+    async def _delete_obj(cls, graphql_context: GraphqlContext, branch: Branch, obj: Node) -> list[Node]:
+        db = graphql_context.db
+        async with db.start_transaction() as dbt:
+            deleted = await NodeManager.delete(db=dbt, branch=branch, nodes=[obj])
+        deleted_str = ", ".join([f"{d.get_kind()}({d.get_id()})" for d in deleted])
+        log.info(f"nodes deleted: {deleted_str}")
+        return deleted
+
     @classmethod
     @retry_db_transaction(name="object_delete")
     async def mutate_delete(
@@ -440,11 +405,7 @@ class InfrahubMutationMixin:
             branch=branch,
         )
 
-        async with graphql_context.db.start_transaction() as db:
-            deleted = await NodeManager.delete(db=db, branch=branch, nodes=[obj])
-
-        deleted_str = ", ".join([f"{d.get_kind()}({d.get_id()})" for d in deleted])
-        log.info(f"nodes deleted: {deleted_str}")
+        deleted = await cls._delete_obj(graphql_context=graphql_context, branch=branch, obj=obj)
 
         ok = True
 
@@ -471,90 +432,13 @@ class InfrahubMutation(InfrahubMutationMixin, Mutation):
         super().__init_subclass_with_meta__(_meta=_meta, **options)
 
 
-def _get_kinds_to_lock_on_object_mutation(kind: str, schema_branch: SchemaBranch) -> list[str]:
-    """
-    Return kinds for which we want to lock during creating / updating an object of a given schema node.
-    Lock should be performed on schema kind and its generics having a uniqueness_constraint defined.
-    If a generic uniqueness constraint is the same as the node schema one,
-    it means node schema overrided this constraint, in which case we only need to lock on the generic.
-    """
-
-    node_schema = schema_branch.get(name=kind)
-
-    schema_uc = None
-    kinds = []
-    if node_schema.uniqueness_constraints:
-        kinds.append(node_schema.kind)
-        schema_uc = node_schema.uniqueness_constraints
-
-    if node_schema.is_generic_schema:
-        return kinds
-
-    generics_kinds = node_schema.inherit_from
-
-    node_schema_kind_removed = False
-    for generic_kind in generics_kinds:
-        generic_uc = schema_branch.get(name=generic_kind).uniqueness_constraints
-        if generic_uc:
-            kinds.append(generic_kind)
-            if not node_schema_kind_removed and generic_uc == schema_uc:
-                # Check whether we should remove original schema kind as it simply overrides uniqueness_constraint
-                # of a generic
-                kinds.pop(0)
-                node_schema_kind_removed = True
-    return kinds
-
-
-def _should_kind_be_locked_on_any_branch(kind: str, schema_branch: SchemaBranch) -> bool:
-    """
-    Check whether kind or any kind generic is in KINDS_TO_LOCK_ON_ANY_BRANCH.
-    """
-
-    if kind in KINDS_CONCURRENT_MUTATIONS_NOT_ALLOWED:
-        return True
-
-    node_schema = schema_branch.get(name=kind)
-    if node_schema.is_generic_schema:
-        return False
-
-    for generic_kind in node_schema.inherit_from:
-        if generic_kind in KINDS_CONCURRENT_MUTATIONS_NOT_ALLOWED:
-            return True
-    return False
-
-
-def _hash(value: str) -> str:
-    # Do not use builtin `hash` for lock names as due to randomization results would differ between
-    # different processes.
-    return hashlib.sha256(value.encode()).hexdigest()
-
-
-def _get_kind_lock_names_on_object_mutation(
-    kind: str, branch: Branch, schema_branch: SchemaBranch, data: InputObjectType
-) -> list[str]:
-    """
-    Return objects kind for which we want to avoid concurrent mutation (create/update). Except for some specific kinds,
-    concurrent mutations are only allowed on non-main branch as objects validations will be performed at least when merging in main branch.
-    """
-
-    if not branch.is_default and not _should_kind_be_locked_on_any_branch(kind=kind, schema_branch=schema_branch):
-        return []
-
-    if kind == InfrahubKind.GRAPHQLQUERYGROUP:
-        # Lock on name as well to improve performances
-        try:
-            name = data.name.value
-            return [build_object_lock_name(kind + "." + _hash(name))]
-        except AttributeError:
-            # We might reach here if we are updating a CoreGraphQLQueryGroup without updating the name,
-            # in which case we would not need to lock. This is not supposed to happen as current `update`
-            # logic first fetches the node with its name.
-            return []
-
-    lock_kinds = _get_kinds_to_lock_on_object_mutation(kind, schema_branch)
-    lock_names = [build_object_lock_name(kind) for kind in lock_kinds]
-    return lock_names
-
-
 def _get_data_fields(data: InputObjectType) -> list[str]:
     return [field for field in data.keys() if field not in ["id", "hfid"]]
+
+
+async def build_graphql_response(info: GraphQLResolveInfo, db: InfrahubDatabase, obj: Node) -> dict:
+    fields = await extract_fields_first_node(info)
+    result: dict[str, Any] = {"ok": True}
+    if "object" in fields:
+        result["object"] = await obj.to_graphql(db=db, fields=fields.get("object", {}))
+    return result