infrahub-server 1.3.5__py3-none-any.whl → 1.4.0b0__py3-none-any.whl

infrahub/api/internal.py

@@ -18,6 +18,7 @@ from infrahub.config import (  # noqa: TC001
 )
 from infrahub.core import registry
 from infrahub.exceptions import NodeNotFoundError
+from infrahub.workers.dependencies import get_installation_type
 
 if TYPE_CHECKING:
     from infrahub.auth import AccountSession
@@ -31,6 +32,8 @@ class ConfigAPI(BaseModel):
     analytics: AnalyticsSettings
     experimental_features: ExperimentalFeaturesSettings
     sso: config.SSOInfo
+    installation_type: str
+    policy: config.PolicySettings
 
 
 class InfoAPI(BaseModel):
@@ -46,6 +49,8 @@ async def get_config() -> ConfigAPI:
         analytics=config.SETTINGS.analytics,
         experimental_features=config.SETTINGS.experimental_features,
         sso=config.SETTINGS.security.public_sso_config,
+        installation_type=get_installation_type(),
+        policy=config.SETTINGS.policy,
     )
 
 

infrahub/artifacts/tasks.py

@@ -3,34 +3,29 @@ from prefect import flow
 from infrahub.artifacts.models import CheckArtifactCreate
 from infrahub.core.constants import InfrahubKind, ValidatorConclusion
 from infrahub.core.timestamp import Timestamp
-from infrahub.git import InfrahubReadOnlyRepository, InfrahubRepository
-from infrahub.services import InfrahubServices
+from infrahub.git.repository import get_initialized_repo
 from infrahub.tasks.artifact import define_artifact
+from infrahub.workers.dependencies import get_client
 from infrahub.workflows.utils import add_tags
 
 
 @flow(name="git-repository-check-artifact-create", flow_run_name="Check artifact creation")
-async def create(model: CheckArtifactCreate, service: InfrahubServices) -> ValidatorConclusion:
+async def create(model: CheckArtifactCreate) -> ValidatorConclusion:
     await add_tags(branches=[model.branch_name], nodes=[model.target_id])
-    validator = await service.client.get(kind=InfrahubKind.ARTIFACTVALIDATOR, id=model.validator_id, include=["checks"])
 
-    repo: InfrahubReadOnlyRepository | InfrahubRepository
-    if InfrahubKind.READONLYREPOSITORY:
-        repo = await InfrahubReadOnlyRepository.init(
-            id=model.repository_id,
-            name=model.repository_name,
-            client=service.client,
-            service=service,
-        )
-    else:
-        repo = await InfrahubRepository.init(
-            id=model.repository_id,
-            name=model.repository_name,
-            client=service.client,
-            service=service,
-        )
+    client = get_client()
+
+    validator = await client.get(kind=InfrahubKind.ARTIFACTVALIDATOR, id=model.validator_id, include=["checks"])
+
+    repo = await get_initialized_repo(
+        client=client,
+        repository_id=model.repository_id,
+        name=model.repository_name,
+        repository_kind=model.repository_kind,
+        commit=model.commit,
+    )
 
-    artifact, artifact_created = await define_artifact(model=model, service=service)
+    artifact, artifact_created = await define_artifact(model=model)
 
     severity = "info"
     artifact_result: dict[str, str | bool | None] = {
@@ -59,7 +54,7 @@ async def create(model: CheckArtifactCreate, service: InfrahubServices) -> Valid
 
     check = None
     check_name = f"{model.artifact_name}: {model.target_name}"
-    existing_check = await service.client.filters(
+    existing_check = await client.filters(
         kind=InfrahubKind.ARTIFACTCHECK, validator__ids=validator.id, name__value=check_name
     )
     if existing_check:
@@ -75,7 +70,7 @@ async def create(model: CheckArtifactCreate, service: InfrahubServices) -> Valid
         check.storage_id.value = artifact_result["storage_id"]
         await check.save()
     else:
-        check = await service.client.create(
+        check = await client.create(
             kind=InfrahubKind.ARTIFACTCHECK,
             data={
                 "name": check_name,

infrahub/branch/merge_mutation_checker.py

@@ -0,0 +1,38 @@
+from abc import ABC, abstractmethod
+
+from fast_depends import Depends, inject
+
+from infrahub.auth import AccountSession
+from infrahub.database import InfrahubDatabase
+
+
+class BranchMergeMutationChecker(ABC):
+    @abstractmethod
+    async def verify_branch_merge_mutation_allowed(
+        self,
+        db: InfrahubDatabase,
+        account_session: AccountSession,
+    ) -> None:
+        raise NotImplementedError()
+
+
+class BranchMergeMutationCheckerCommunity(BranchMergeMutationChecker):
+    async def verify_branch_merge_mutation_allowed(
+        self,
+        db: InfrahubDatabase,
+        account_session: AccountSession,
+    ) -> None:
+        pass
+
+
+def get_branch_merge_mutation_checker() -> BranchMergeMutationChecker:
+    return BranchMergeMutationCheckerCommunity()
+
+
+@inject
+async def verify_branch_merge_mutation_allowed(
+    db: InfrahubDatabase,
+    account_session: AccountSession,
+    branch_merge_mutation_checker: BranchMergeMutationChecker = Depends(get_branch_merge_mutation_checker),  # noqa: B008
+) -> None:
+    await branch_merge_mutation_checker.verify_branch_merge_mutation_allowed(db=db, account_session=account_session)

infrahub/cli/__init__.py

@@ -5,8 +5,8 @@ from infrahub_sdk.async_typer import AsyncTyper
 
 from infrahub import config
 from infrahub.core.initialization import initialization
-from infrahub.database import InfrahubDatabase, get_db
 
+from ..workers.dependencies import get_database
 from .context import CliContext
 from .db import app as db_app
 from .events import app as events_app
@@ -36,7 +36,7 @@ async def _init_shell(config_file: str) -> None:
     """Launch a Python Interactive shell."""
     config.load_and_exit(config_file_name=config_file)
 
-    db = InfrahubDatabase(driver=await get_db(retry=1))
+    db = await get_database()
 
     async with db.start_session() as db:
         await initialization(db=db)

infrahub/cli/context.py

@@ -1,8 +1,12 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from typing import TYPE_CHECKING
 
-from infrahub.database import InfrahubDatabase, get_db
+from infrahub.workers.dependencies import get_database
+
+if TYPE_CHECKING:
+    from infrahub.database import InfrahubDatabase
 
 
 @dataclass
@@ -11,5 +15,5 @@ class CliContext:
 
     # This method is inherited for Infrahub Enterprise.
     @staticmethod
-    async def init_db(retry: int) -> InfrahubDatabase:
-        return InfrahubDatabase(driver=await get_db(retry=retry))
+    async def init_db(retry: int) -> InfrahubDatabase:  # type:ignore  # noqa
+        return await get_database()

infrahub/cli/db.py

@@ -23,7 +23,7 @@ from infrahub import config
 from infrahub.core import registry
 from infrahub.core.graph import GRAPH_VERSION
 from infrahub.core.graph.constraints import ConstraintManagerBase, ConstraintManagerMemgraph, ConstraintManagerNeo4j
-from infrahub.core.graph.index import attr_value_index, node_indexes, rel_indexes
+from infrahub.core.graph.index import node_indexes, rel_indexes
 from infrahub.core.graph.schema import (
     GRAPH_SCHEMA,
     GraphAttributeProperties,
@@ -51,9 +51,6 @@ from infrahub.database import DatabaseType
 from infrahub.database.memgraph import IndexManagerMemgraph
 from infrahub.database.neo4j import IndexManagerNeo4j
 from infrahub.log import get_logger
-from infrahub.services import InfrahubServices
-from infrahub.services.adapters.message_bus.local import BusSimulator
-from infrahub.services.adapters.workflow.local import WorkflowLocalExecution
 
 from .constants import ERROR_BADGE, FAILED_BADGE, SUCCESS_BADGE
 from .patch import patch_app
@@ -195,12 +192,8 @@ async def update_core_schema_cmd(
     context: CliContext = ctx.obj
     dbdriver = await context.init_db(retry=1)
 
-    service = await InfrahubServices.new(
-        database=dbdriver, message_bus=BusSimulator(), workflow=WorkflowLocalExecution()
-    )
-
     with prefect_test_harness():
-        await update_core_schema(db=dbdriver, service=service, initialize=True, debug=debug)
+        await update_core_schema(db=dbdriver, initialize=True, debug=debug)
 
     await dbdriver.close()
 
@@ -264,8 +257,6 @@ async def index(
         index_manager: IndexManagerBase = IndexManagerMemgraph(db=dbdriver)
     index_manager = IndexManagerNeo4j(db=dbdriver)
 
-    if config.SETTINGS.experimental_features.value_db_index:
-        node_indexes.append(attr_value_index)
     index_manager.init(nodes=node_indexes, rels=rel_indexes)
 
     if action == IndexAction.ADD:
@@ -368,9 +359,7 @@ async def initialize_internal_schema() -> None:
     registry.schema.register_schema(schema=schema)
 
 
-async def update_core_schema(
-    db: InfrahubDatabase, service: InfrahubServices, initialize: bool = True, debug: bool = False
-) -> None:
+async def update_core_schema(db: InfrahubDatabase, initialize: bool = True, debug: bool = False) -> None:
     """Update the core schema of Infrahub to the latest version"""
     # ----------------------------------------------------------
     # Initialize Schema and Registry
@@ -419,7 +408,7 @@ async def update_core_schema(
         schema_branch=candidate_schema,
         constraints=result.constraints,
     )
-    responses = await schema_validate_migrations(message=validate_migration_data, service=service)
+    responses = await schema_validate_migrations(message=validate_migration_data)
     error_messages = [violation.message for response in responses for violation in response.violations]
     if error_messages:
         rprint(f"{ERROR_BADGE} | Unable to update the schema, due to failed validations")
@@ -461,7 +450,7 @@ async def update_core_schema(
         previous_schema=origin_schema,
         migrations=result.migrations,
     )
-    migration_error_msgs = await schema_apply_migrations(message=apply_migration_data, service=service)
+    migration_error_msgs = await schema_apply_migrations(message=apply_migration_data)
 
     if migration_error_msgs:
         rprint(f"{ERROR_BADGE} | Some error(s) happened while running the schema migrations")

infrahub/cli/upgrade.py

@@ -11,22 +11,13 @@ from prefect.client.orchestration import get_client
 from rich import print as rprint
 
 from infrahub import config
-from infrahub.core.constants import InfrahubKind
-from infrahub.core.initialization import (
-    create_anonymous_role,
-    create_default_roles,
-    create_super_administrator_role,
-    create_super_administrators_group,
-    initialize_registry,
-)
+from infrahub.core.initialization import create_anonymous_role, create_default_account_groups, initialize_registry
 from infrahub.core.manager import NodeManager
+from infrahub.core.protocols import CoreAccount, CoreObjectPermission
 from infrahub.menu.menu import default_menu
 from infrahub.menu.models import MenuDict
 from infrahub.menu.repository import MenuRepository
 from infrahub.menu.utils import create_default_menu
-from infrahub.services import InfrahubServices
-from infrahub.services.adapters.message_bus.local import BusSimulator
-from infrahub.services.adapters.workflow.local import WorkflowLocalExecution
 from infrahub.trigger.tasks import trigger_configure_all
 from infrahub.workflows.initialization import (
     setup_blocks,
@@ -61,9 +52,6 @@ async def upgrade_cmd(
     context: CliContext = ctx.obj
     dbdriver = await context.init_db(retry=1)
 
-    service = await InfrahubServices.new(
-        database=dbdriver, message_bus=BusSimulator(), workflow=WorkflowLocalExecution()
-    )
     await initialize_registry(db=dbdriver)
 
     # NOTE add step to validate if the database and the task manager are reachable
@@ -83,7 +71,7 @@ async def upgrade_cmd(
         return
 
     await initialize_internal_schema()
-    await update_core_schema(db=dbdriver, service=service, initialize=False)
+    await update_core_schema(db=dbdriver, initialize=False)
 
     # -------------------------------------------
     # Upgrade Internal Objects, generated and managed by Infrahub
@@ -98,7 +86,7 @@ async def upgrade_cmd(
         await setup_blocks()
         await setup_worker_pools(client=client)
         await setup_deployments(client=client)
-        await trigger_configure_all(service=service)
+        await trigger_configure_all()
 
     await dbdriver.close()
 
@@ -124,11 +112,7 @@ async def upgrade_menu(db: InfrahubDatabase) -> None:
 
 
 async def upgrade_permissions(db: InfrahubDatabase) -> None:
-    existing_permissions = await NodeManager.query(
-        schema=InfrahubKind.OBJECTPERMISSION,
-        db=db,
-        limit=1,
-    )
+    existing_permissions = await NodeManager.query(schema=CoreObjectPermission, db=db, limit=1)
     if existing_permissions:
         rprint("Permissions Up to date, nothing to update")
         return
@@ -138,14 +122,8 @@ async def upgrade_permissions(db: InfrahubDatabase) -> None:
 
 
 async def setup_permissions(db: InfrahubDatabase) -> None:
-    existing_accounts = await NodeManager.query(
-        schema=InfrahubKind.ACCOUNT,
-        db=db,
-        limit=1,
-    )
-    administrator_role = await create_super_administrator_role(db=db)
-    await create_super_administrators_group(db=db, role=administrator_role, admin_accounts=existing_accounts)
-    await create_default_roles(db=db)
+    existing_accounts = await NodeManager.query(schema=CoreAccount, db=db, limit=1)
+    await create_default_account_groups(db=db, admin_accounts=existing_accounts)
 
     if config.SETTINGS.main.allow_anonymous_access:
         await create_anonymous_role(db=db)

infrahub/computed_attribute/tasks.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING
 from infrahub_sdk.protocols import CoreTransformPython
 from infrahub_sdk.template import Jinja2Template
 from prefect import flow
-from prefect.client.orchestration import get_client
+from prefect.client.orchestration import get_client as get_prefect_client
 from prefect.logging import get_run_logger
 
 from infrahub.context import InfrahubContext  # noqa: TC001  needed for prefect flow
@@ -13,9 +13,9 @@ from infrahub.core.constants import ComputedAttributeKind, InfrahubKind
 from infrahub.core.registry import registry
 from infrahub.events import BranchDeletedEvent
 from infrahub.git.repository import get_initialized_repo
-from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
 from infrahub.trigger.models import TriggerSetupReport, TriggerType
 from infrahub.trigger.setup import setup_triggers, setup_triggers_specific
+from infrahub.workers.dependencies import get_client, get_component, get_database, get_workflow
 from infrahub.workflows.catalogue import (
     COMPUTED_ATTRIBUTE_PROCESS_JINJA2,
     COMPUTED_ATTRIBUTE_PROCESS_TRANSFORM,
@@ -61,10 +61,10 @@ async def process_transform(
     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])
+    client = get_client()
 
     schema_branch = registry.schema.get_schema_branch(name=branch_name)
     node_schema = schema_branch.get_node(name=node_kind, duplicate=False)
@@ -77,7 +77,7 @@ async def process_transform(
         return
 
     for attribute_name, transform_attribute in transform_attributes.items():
-        transform = await service.client.get(
+        transform = await client.get(
             kind=CoreTransformPython,
             branch=branch_name,
             id=transform_attribute.transform,
@@ -88,7 +88,7 @@ async def process_transform(
         if not transform:
             continue
 
-        repo_node = await service.client.get(
+        repo_node = await client.get(
             kind=str(transform.repository.peer.typename),
             branch=branch_name,
             id=transform.repository.peer.id,
@@ -96,14 +96,14 @@ async def process_transform(
         )
 
         repo = await get_initialized_repo(
+            client=client,
             repository_id=transform.repository.peer.id,
             name=transform.repository.peer.name.value,
-            service=service,
             repository_kind=str(transform.repository.peer.typename),
             commit=repo_node.commit.value,
         )  # type: ignore[misc]
 
-        data = await service.client.query_gql_query(
+        data = await client.query_gql_query(
             name=transform.query.peer.name.value,
             branch_name=branch_name,
             variables={"id": object_id},
@@ -112,22 +112,17 @@ async def process_transform(
         )
 
         transformed_data = await repo.execute_python_transform.with_options(timeout_seconds=transform.timeout.value)(
+            client=client,
             branch_name=branch_name,
             commit=repo_node.commit.value,
             location=f"{transform.file_path.value}::{transform.class_name.value}",
             data=data,
-            client=service.client,
             convert_query_response=transform.convert_query_response.value,
         )  # type: ignore[misc]
 
-        await service.client.execute_graphql(
+        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},
             branch_name=branch_name,
         )
 
@@ -141,14 +136,13 @@ async def trigger_update_python_computed_attributes(
     computed_attribute_name: str,
     computed_attribute_kind: str,
     context: InfrahubContext,
-    service: InfrahubServices,
 ) -> None:
     await add_tags(branches=[branch_name])
 
-    nodes = await service.client.all(kind=computed_attribute_kind, branch=branch_name)
+    nodes = await get_client().all(kind=computed_attribute_kind, branch=branch_name)
 
     for node in nodes:
-        await service.workflow.submit_workflow(
+        await get_workflow().submit_workflow(
             workflow=COMPUTED_ATTRIBUTE_PROCESS_TRANSFORM,
             context=context,
             parameters={
@@ -172,9 +166,9 @@ async def computed_attribute_jinja2_update_value(
     node_kind: str,
     attribute_name: str,
     template: Jinja2Template,
-    service: InfrahubServices,
 ) -> None:
     log = get_run_logger()
+    client = get_client()
 
     await add_tags(branches=[branch_name], nodes=[obj.node_id], db_change=True)
 
@@ -183,14 +177,9 @@ async def computed_attribute_jinja2_update_value(
         log.debug(f"Ignoring to update {obj} with existing value on {attribute_name}={value}")
         return
 
-    await service.client.execute_graphql(
+    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},
         branch_name=branch_name,
     )
     log.info(f"Updating computed attribute {node_kind}.{attribute_name}='{value}' ({obj.node_id})")
@@ -207,10 +196,10 @@ async def process_jinja2(
     computed_attribute_name: str,
     computed_attribute_kind: str,
     context: InfrahubContext,  # noqa: ARG001
-    service: InfrahubServices,
     updated_fields: list[str] | None = None,
 ) -> None:
     log = get_run_logger()
+    client = get_client()
 
     await add_tags(branches=[branch_name])
     updates: list[str] = updated_fields or []
@@ -240,14 +229,14 @@ async def process_jinja2(
 
         for id_filter in computed_macro.node_filters:
             query = attribute_graphql.render_graphql_query(query_filter=id_filter, filter_id=object_id)
-            response = await service.client.execute_graphql(query=query, branch_name=branch_name)
+            response = await client.execute_graphql(query=query, branch_name=branch_name)
             output = attribute_graphql.parse_response(response=response)
             found.extend(output)
 
         if not found:
             log.debug("No nodes found that requires updates")
 
-        batch = await service.client.create_batch()
+        batch = await client.create_batch()
         for node in found:
             batch.add(
                 task=computed_attribute_jinja2_update_value,
@@ -256,7 +245,6 @@ async def process_jinja2(
                 node_kind=node_schema.kind,
                 attribute_name=computed_macro.attribute.name,
                 template=jinja_template,
-                service=service,
             )
 
         _ = [response async for _, response in batch.execute()]
@@ -271,15 +259,16 @@ async def trigger_update_jinja2_computed_attributes(
     computed_attribute_name: str,
     computed_attribute_kind: str,
     context: InfrahubContext,
-    service: InfrahubServices,
 ) -> None:
     await add_tags(branches=[branch_name])
 
+    client = get_client()
+
     # NOTE we only need the id of the nodes, we need to ooptimize the query here
-    nodes = await service.client.all(kind=computed_attribute_kind, branch=branch_name)
+    nodes = await client.all(kind=computed_attribute_kind, branch=branch_name)
 
     for node in nodes:
-        await service.workflow.submit_workflow(
+        await get_workflow().submit_workflow(
             workflow=COMPUTED_ATTRIBUTE_PROCESS_JINJA2,
             context=context,
             parameters={
@@ -295,14 +284,16 @@ async def trigger_update_jinja2_computed_attributes(
 
 @flow(name="computed-attribute-setup-jinja2", flow_run_name="Setup computed attributes in task-manager")
 async def computed_attribute_setup_jinja2(
-    service: InfrahubServices, context: InfrahubContext, branch_name: str | None = None, event_name: str | None = None
+    context: InfrahubContext, branch_name: str | None = None, event_name: str | None = None
 ) -> None:
-    async with service.database.start_session() as db:
+    database = await get_database()
+    async with database.start_session() as db:
         log = get_run_logger()
 
         if branch_name:
             await add_tags(branches=[branch_name])
-            await wait_for_schema_to_converge(branch_name=branch_name, component=service.component, db=db, log=log)
+            component = await get_component()
+            await wait_for_schema_to_converge(branch_name=branch_name, component=component, db=db, log=log)
 
         report: TriggerSetupReport = await setup_triggers_specific(
             gatherer=gather_trigger_computed_attribute_jinja2, trigger_type=TriggerType.COMPUTED_ATTR_JINJA2
@@ -317,7 +308,7 @@ async def computed_attribute_setup_jinja2(
         }
         for branch, kind, attribute_name in unique_nodes:
             if event_name != BranchDeletedEvent.event_name and branch == branch_name:
-                await service.workflow.submit_workflow(
+                await get_workflow().submit_workflow(
                     workflow=TRIGGER_UPDATE_JINJA_COMPUTED_ATTRIBUTES,
                     context=context,
                     parameters={
@@ -335,20 +326,20 @@ async def computed_attribute_setup_jinja2(
     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,
     event_name: str | None = None,
     commit: str | None = None,  # noqa: ARG001
 ) -> None:
-    async with service.database.start_session() as db:
+    database = await get_database()
+    async with database.start_session() as db:
         log = get_run_logger()
 
         branch_name = branch_name or registry.default_branch
-
         if branch_name:
             await add_tags(branches=[branch_name])
-            await wait_for_schema_to_converge(branch_name=branch_name, component=service.component, db=db, log=log)
+            component = await get_component()
+            await wait_for_schema_to_converge(branch_name=branch_name, component=component, db=db, log=log)
 
         triggers_python, triggers_python_query = await gather_trigger_computed_attribute_python(db=db)
 
@@ -368,7 +359,7 @@ async def computed_attribute_setup_python(
         for branch, kind, attribute_name in unique_nodes:
             if event_name != BranchDeletedEvent.event_name and branch == branch_name:
                 log.info(f"Triggering update for {kind}.{attribute_name} on {branch}")
-                await service.workflow.submit_workflow(
+                await get_workflow().submit_workflow(
                     workflow=TRIGGER_UPDATE_PYTHON_COMPUTED_ATTRIBUTES,
                     context=context,
                     parameters={
@@ -378,7 +369,7 @@ async def computed_attribute_setup_python(
                     },
                 )
 
-        async with get_client(sync_client=False) as prefect_client:
+        async with get_prefect_client(sync_client=False) as prefect_client:
             await setup_triggers(
                 client=prefect_client,
                 triggers=triggers_python,
@@ -405,11 +396,10 @@ async def query_transform_targets(
     node_kind: str,  # noqa: ARG001
     object_id: str,
     context: InfrahubContext,
-    service: InfrahubServices,
 ) -> None:
     await add_tags(branches=[branch_name])
     schema_branch = registry.schema.get_schema_branch(name=branch_name)
-    targets = await service.client.execute_graphql(
+    targets = await get_client().execute_graphql(
         query=GATHER_GRAPHQL_QUERY_SUBSCRIBERS, variables={"members": [object_id]}, branch_name=branch_name
     )
 
@@ -425,7 +415,7 @@ async def query_transform_targets(
     for subscriber in subscribers:
         if subscriber.kind in nodes_with_computed_attributes:
             for computed_attribute in nodes_with_computed_attributes[subscriber.kind]:
-                await service.workflow.submit_workflow(
+                await get_workflow().submit_workflow(
                     workflow=COMPUTED_ATTRIBUTE_PROCESS_TRANSFORM,
                     context=context,
                     parameters={