Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
fix(api): preserve creator RBAC access across app and RAG pipeline creation (#43941)
XiaoBa51a8dba933f3
diff --git a/api/controllers/console/app/app_import.py b/api/controllers/console/app/app_import.pyindex 78cb85c5470..12f6ac1ff26 100644--- a/api/controllers/console/app/app_import.py+++ b/api/controllers/console/app/app_import.py@@ -6,7 +6,7 @@ from flask_restx import Resourcefrom werkzeug.exceptions import Forbiddenfrom controllers.common.rbac import PlainApp, RBACCheck, Workspace-from controllers.common.schema import register_enum_models, register_schema_models+from controllers.common.schema import register_enum_models, register_response_schema_models, register_schema_modelsfrom controllers.console.app.error import AppNotFoundErrorfrom controllers.console.explore.error import RecommendedAppNotFoundError as RecommendedAppNotFoundHttpErrorfrom controllers.console.flask_admission import console_account_admission@@ -28,7 +28,8 @@ class AppImportPayload(AppImportParams):register_enum_models(console_ns, ImportStatus)-register_schema_models(console_ns, AppImportPayload, Import, CheckDependenciesResult)+register_schema_models(console_ns, AppImportPayload, CheckDependenciesResult)+register_response_schema_models(console_ns, Import)_EDIT_ROLES = frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR})diff --git a/api/controllers/console/datasets/rag_pipeline/rag_pipeline_import.py b/api/controllers/console/datasets/rag_pipeline/rag_pipeline_import.pyindex 5af74390ab1..56f2fbc883d 100644--- a/api/controllers/console/datasets/rag_pipeline/rag_pipeline_import.py+++ b/api/controllers/console/datasets/rag_pipeline/rag_pipeline_import.py@@ -28,8 +28,10 @@ from libs.helper import dump_responsefrom libs.login import login_requiredfrom models.account import Accountfrom models.dataset import Pipeline+from services.enterprise import rbac_service as enterprise_rbac_servicefrom services.entities.dsl_entities import ImportStatusfrom services.rag_pipeline.rag_pipeline_dsl_service import RagPipelineDslService+from services.rbac import contracts as rbac_contractsclass RagPipelineImportPayload(BaseModel):@@ -107,6 +109,19 @@ class RagPipelineImportApi(Resource):else:session.commit()+ if (+ result.status in {ImportStatus.COMPLETED, ImportStatus.COMPLETED_WITH_WARNINGS}+ and result.dataset_created+ and result.dataset_id+ ):+ assert current_user.current_tenant_id is not None+ enterprise_rbac_service.try_sync_creator_access_policy_member_bindings(+ current_user.current_tenant_id,+ current_user.id,+ rbac_contracts.RBACResourceType.DATASET,+ result.dataset_id,+ )+# Return appropriate status code based on resultstatus = result.statusmatch status:@@ -138,6 +153,19 @@ class RagPipelineImportConfirmApi(Resource):else:session.commit()+ if (+ result.status in {ImportStatus.COMPLETED, ImportStatus.COMPLETED_WITH_WARNINGS}+ and result.dataset_created+ and result.dataset_id+ ):+ assert current_user.current_tenant_id is not None+ enterprise_rbac_service.try_sync_creator_access_policy_member_bindings(+ current_user.current_tenant_id,+ current_user.id,+ rbac_contracts.RBACResourceType.DATASET,+ result.dataset_id,+ )+# Return appropriate status code based on resultif result.status == ImportStatus.FAILED:return dump_response(RagPipelineImportResponse, result), 400diff --git a/api/services/app/console_gateway.py b/api/services/app/console_gateway.pyindex 8e54756880d..72b26aea5b7 100644--- a/api/services/app/console_gateway.py+++ b/api/services/app/console_gateway.py@@ -38,7 +38,7 @@ from services.app.console_service import ()from services.app.import_service import AppDefinitionImportsfrom services.app.response_gateway import AppResponseGateway-from services.app_dsl_service import IMPORT_INFO_REDIS_KEY_PREFIX, AppDslService, PendingData+from services.app_dsl_service import AppDslService, initialize_imported_app_creator_accessfrom services.app_import_source import download_app_import_source, try_read_yamlfrom services.app_package_service import AppPackageServicefrom services.app_service import AppService@@ -251,16 +251,15 @@ class AppTransferGateway(AppTransfers, AppDefinitionImports):session.rollback()else:session.commit()+ initialize_imported_app_creator_access(+ result, tenant_id=context.active_workspace_id, account_id=context.account_id+ )return result@overridedef confirm_import(self, context: RequestContext, import_id: str) -> tuple[Import, bool]:- from extensions.ext_redis import redis_client-- raw = redis_client.get(f"{IMPORT_INFO_REDIS_KEY_PREFIX}{import_id}")- pending = PendingData.model_validate_json(raw) if raw else Noneresult = self.confirm_definition(context, import_id)- return result, pending is not None and pending.app_id is None+ return result, result.app_created@overridedef confirm_definition(self, context: RequestContext, import_id: str) -> Import:@@ -271,6 +270,9 @@ class AppTransferGateway(AppTransfers, AppDefinitionImports):session.rollback()else:session.commit()+ initialize_imported_app_creator_access(+ result, tenant_id=context.active_workspace_id, account_id=context.account_id+ )return result@overridediff --git a/api/services/app/console_service.py b/api/services/app/console_service.pyindex 25bc6a3b3e9..4e2f39e78d1 100644--- a/api/services/app/console_service.py+++ b/api/services/app/console_service.py@@ -269,7 +269,7 @@ class ConsoleAppService:) -> Import:self._access.require_import(context, "dsl")result = self._transfers.import_dsl(context, params, package=package)- self._set_import_permissions(context, result, created=params.app_id is None)+ self._set_import_permissions(context, result, created=result.app_created)if result.app_id:self._access.initialize_import_access(result.app_id)return resultdiff --git a/api/services/app_dsl_service.py b/api/services/app_dsl_service.pyindex 77c26ff710e..076343c3258 100644--- a/api/services/app_dsl_service.py+++ b/api/services/app_dsl_service.py@@ -61,6 +61,7 @@ from services.agent.retirement_service import WorkflowAgentRetirementServicefrom services.agent.workflow_publish_service import WorkflowAgentPublishServicefrom services.dsl_content import DSL_MAX_SIZE, dsl_content_sizefrom services.dsl_version import check_version_compatibility+from services.enterprise import rbac_servicefrom services.enterprise.rbac_service import RBACServicefrom services.entities.dsl_entities import (AppDslExportData,@@ -94,6 +95,26 @@ IMPORT_INFO_REDIS_EXPIRY = 10 * 60 # 10 minutesCURRENT_DSL_VERSION = CURRENT_APP_DSL_VERSION+def initialize_imported_app_creator_access(result: Import, *, tenant_id: str, account_id: str) -> None:+ """Initialize ordinary App creator access only after the caller commits the import."""+ if (+ result.status in (ImportStatus.COMPLETED, ImportStatus.COMPLETED_WITH_WARNINGS)+ and result.app_created+ and result.app_id+ and result.app_mode+ in (+ AppMode.CHAT,+ AppMode.ADVANCED_CHAT,+ AppMode.COMPLETION,+ AppMode.WORKFLOW,+ AppMode.AGENT_CHAT,+ )+ ):+ rbac_service.try_sync_creator_access_policy_member_bindings(+ tenant_id, account_id, rbac_service.RBACResourceType.APP, result.app_id+ )++def missing_app_section_error(top_level_keys: list[str]) -> str:"""Explain a YAML that has no top-level ``app`` mapping.@@ -347,6 +368,7 @@ class AppDslService:)# Create or update app+ app_created = app is Noneapp = self._create_or_update_app(app=app,data=data,@@ -369,6 +391,7 @@ class AppDslService:id=import_id,status=result_status,app_id=app.id,+ app_created=app_created,app_mode=app.mode,imported_dsl_version=imported_version,warnings=self._warnings,@@ -448,6 +471,7 @@ class AppDslService:self._validate_workflow_overwrite(app, data)# Create or update app+ app_created = app is Noneapp = self._create_or_update_app(app=app,data=data,@@ -467,6 +491,7 @@ class AppDslService:id=import_id,status=self._status_with_warnings(ImportStatus.COMPLETED),app_id=app.id,+ app_created=app_created,app_mode=app.mode,current_dsl_version=CURRENT_DSL_VERSION,imported_dsl_version=data.get("version", "0.1.0"),diff --git a/api/services/enterprise/rbac_service.py b/api/services/enterprise/rbac_service.pyindex 818f825ce29..243b3e44020 100644--- a/api/services/enterprise/rbac_service.py+++ b/api/services/enterprise/rbac_service.py@@ -93,15 +93,54 @@ def try_sync_creator_access_policy_member_bindings(resource_type: RBACResourceType | str,resource_id: str,) -> None:+ """Best-effort creator bindings, including app and dataset whitelist visibility gates."""if not dify_config.RBAC_ENABLED:returntry:- RBACService.AccessPolicies.sync_creator_access_policy_member_bindings(+ bindings = RBACService.AccessPolicies.sync_creator_access_policy_member_bindings(tenant_id,account_id,resource_type=resource_type,resource_id=resource_id,)+ if resource_type in (RBACResourceType.APP, RBACResourceType.DATASET):+ policy_ids = sorted(+ {+ binding.access_policy_id+ for binding in bindings+ if binding.tenant_id == tenant_id+ and binding.resource_type == resource_type+ and binding.resource_id == resource_id+ and binding.account_id == account_id+ and binding.access_policy_id+ }+ )+ if not policy_ids:+ raise ValueError("Creator sync returned no matching resource policy binding")+ # Policy bindings alone do not satisfy the resource whitelist gate.+ # Append the returned creator policies without replacing other members or policies.+ if resource_type == RBACResourceType.APP:+ RBACService.AppAccess.append_whitelist_members_batch(+ tenant_id,+ account_id,+ [+ AppendAppWhitelistMembersBatchItem(+ app_id=resource_id, account_ids=[account_id], policy_id=policy_id+ )+ for policy_id in policy_ids+ ],+ )+ else:+ RBACService.DatasetAccess.append_whitelist_members_batch(+ tenant_id,+ account_id,+ [+ AppendDatasetWhitelistMembersBatchItem(+ dataset_id=resource_id, account_ids=[account_id], policy_id=policy_id+ )+ for policy_id in policy_ids+ ],+ )except Exception:logger.warning("Failed to sync creator access policy member binding for "diff --git a/api/services/entities/dsl_entities.py b/api/services/entities/dsl_entities.pyindex 768f0fba244..bd8a8959121 100644--- a/api/services/entities/dsl_entities.py+++ b/api/services/entities/dsl_entities.py@@ -87,6 +87,7 @@ class Import(BaseModel):status: ImportStatusapp_id: str | None = Noneapp_mode: AppMode | None = None+ app_created: bool = Field(default=False, exclude=True)permission_keys: list[str] = Field(default_factory=list)current_dsl_version: str = CURRENT_APP_DSL_VERSIONimported_dsl_version: str = ""diff --git a/api/services/knowledge/dataset_service.py b/api/services/knowledge/dataset_service.pyindex 3923bd789d9..bc4ab0bc671 100644--- a/api/services/knowledge/dataset_service.py+++ b/api/services/knowledge/dataset_service.py@@ -436,7 +436,16 @@ class DatasetService:pipeline_id=pipeline.id,)session.add(dataset)+ session.flush()+ dataset_id = dataset.id+ creator_id = current_user.idsession.commit()+ enterprise_rbac_service.try_sync_creator_access_policy_member_bindings(+ tenant_id,+ creator_id,+ rbac_contracts.RBACResourceType.DATASET,+ dataset_id,+ )return dataset@staticmethoddiff --git a/api/services/rag_pipeline/rag_pipeline_dsl_service.py b/api/services/rag_pipeline/rag_pipeline_dsl_service.pyindex 5090b89aca5..d149346b0a7 100644--- a/api/services/rag_pipeline/rag_pipeline_dsl_service.py+++ b/api/services/rag_pipeline/rag_pipeline_dsl_service.py@@ -13,7 +13,7 @@ import yaml # type: ignorefrom Crypto.Cipher import AESfrom Crypto.Util.Padding import pad, unpadfrom flask_login import current_user-from pydantic import BaseModel+from pydantic import BaseModel, Fieldfrom sqlalchemy import selectfrom sqlalchemy.orm import Session@@ -69,6 +69,8 @@ class RagPipelineImportInfo(BaseModel):imported_dsl_version: str = ""error: str = ""dataset_id: str | None = None+ # Internal creation outcome for post-commit authorization; never part of the DSL response.+ dataset_created: bool = Field(default=False, exclude=True)class RagPipelinePendingData(PendingImportOwner):@@ -275,6 +277,7 @@ class RagPipelineDslService:graph = workflow.get("graph", {})nodes = graph.get("nodes", [])dataset_id = None+ dataset_created = Falsefor node in nodes:if node.get("data", {}).get("type") == KNOWLEDGE_INDEX_NODE_TYPE:knowledge_configuration = KnowledgeConfiguration.model_validate(node.get("data", {}))@@ -285,6 +288,7 @@ class RagPipelineDslService:):raise ValueError("Chunk structure is not compatible with the published pipeline")if not dataset:+ dataset_created = Truedatasets = self._session.scalars(select(Dataset).where(Dataset.tenant_id == account.current_tenant_id)).all()@@ -350,6 +354,7 @@ class RagPipelineDslService:status=status,pipeline_id=pipeline.id,dataset_id=dataset_id,+ dataset_created=dataset_created,imported_dsl_version=imported_version,)@@ -428,10 +433,12 @@ class RagPipelineDslService:graph = workflow.get("graph", {})nodes = graph.get("nodes", [])dataset_id = None+ dataset_created = Falsefor node in nodes:if node.get("data", {}).get("type") == KNOWLEDGE_INDEX_NODE_TYPE:knowledge_configuration = KnowledgeConfiguration.model_validate(node.get("data", {}))if not dataset:+ dataset_created = Truedataset = Dataset(tenant_id=account.current_tenant_id,name=name,@@ -500,6 +507,7 @@ class RagPipelineDslService:status=ImportStatus.COMPLETED,pipeline_id=pipeline.id,dataset_id=dataset_id,+ dataset_created=dataset_created,current_dsl_version=CURRENT_DSL_VERSION,imported_dsl_version=data.get("version", "0.1.0"),)diff --git a/api/tests/unit_tests/controllers/console/app/test_app_import_api.py b/api/tests/unit_tests/controllers/console/app/test_app_import_api.pyindex 0ce78d204ad..64803e4cf1a 100644--- a/api/tests/unit_tests/controllers/console/app/test_app_import_api.py+++ b/api/tests/unit_tests/controllers/console/app/test_app_import_api.py@@ -81,7 +81,7 @@ def test_import_transaction_and_response_contract(config_overrides(RBAC_ENABLED=True, DEPLOYMENT_EDITION="COMMUNITY")monkeypatch.setattr("services.app.console_gateway.rbac_service.RBACService.CheckAccess.check", lambda *a, **k: True)app_id = str(uuid4())- result = Import(id="import-1", status=status, app_id=app_id)+ result = Import(id="import-1", status=status, app_id=app_id, app_created=not overwrite)pending = PendingData(tenant_id=import_context.active_workspace_id,account_id=import_context.account_id,@@ -216,3 +216,7 @@ def test_permission_errors_are_mapped_at_http_boundary(api = controller.AppImportApi()with pytest.raises(Forbidden, match="Import denied"):unwrap(api.post)(api, context)+++def test_import_response_schema_hides_creation_marker() -> None:+ assert "app_created" not in controller.console_ns.models[Import.__name__].__schema__["properties"]diff --git a/api/tests/unit_tests/controllers/console/datasets/rag_pipeline/test_rag_pipeline_import.py b/api/tests/unit_tests/controllers/console/datasets/rag_pipeline/test_rag_pipeline_import.pyindex 9875ef27c1b..0e576120c46 100644--- a/api/tests/unit_tests/controllers/console/datasets/rag_pipeline/test_rag_pipeline_import.py+++ b/api/tests/unit_tests/controllers/console/datasets/rag_pipeline/test_rag_pipeline_import.py@@ -2,13 +2,15 @@from __future__ import annotations-from collections.abc import Iterator+from collections.abc import Callable, Iteratorfrom inspect import unwrapfrom unittest.mock import MagicMock, patchimport pytestfrom flask import Flask+from sqlalchemy.orm import Session+from controllers.common.schema import JsonResponseWithStatusfrom controllers.console import console_nsfrom controllers.console.datasets.rag_pipeline.rag_pipeline_import import (IncludeSecretQuery,@@ -22,9 +24,10 @@ from core.plugin.entities.plugin import PluginDependency, PluginDependencyTypefrom models.account import Accountfrom models.dataset import Pipelinefrom models.engine import db+from services.enterprise import rbac_servicefrom services.entities.dsl_entities import CheckDependenciesResult, ImportStatusfrom services.rag_pipeline.rag_pipeline_dsl_service import RagPipelineImportInfo-from tests.unit_tests.model_factories import make_account+from tests.unit_tests.model_factories import make_account, make_tenantdef _account() -> Account:@@ -299,3 +302,101 @@ class TestRagPipelineExportApi:assert status == 200assert response == {"data": "yaml: data"}++[email protected]("confirm", [False, True])+ ("import_status", "created", "dataset_id", "rbac_enabled", "commit_fails", "expected_calls"),+ [+ (ImportStatus.COMPLETED, True, "dataset-1", True, False, 1),+ (ImportStatus.COMPLETED_WITH_WARNINGS, True, "dataset-1", True, False, 1),+ (ImportStatus.COMPLETED, False, "dataset-1", True, False, 0),+ (ImportStatus.PENDING, True, "dataset-1", True, False, 0),+ (ImportStatus.FAILED, True, "dataset-1", True, False, 0),+ (ImportStatus.COMPLETED, True, None, True, False, 0),+ (ImportStatus.COMPLETED, True, "dataset-1", False, False, 0),+ (ImportStatus.COMPLETED, True, "dataset-1", True, True, 0),+ ],+)+def test_creator_binding_only_after_successful_new_dataset_commit(+ app: Flask,+ config_overrides: Callable[..., None],+ confirm: bool,+ import_status: ImportStatus,+ created: bool,+ dataset_id: str | None,+ rbac_enabled: bool,+ commit_fails: bool,+ expected_calls: int,+) -> None:+ config_overrides(RBAC_ENABLED=rbac_enabled)+ user = make_account(account_id="creator-1", tenant=make_tenant(tenant_id="tenant-1"))+ result = RagPipelineImportInfo.model_validate(+ {+ "id": "import-1",+ "status": import_status,+ "dataset_id": dataset_id,+ "dataset_created": created,+ }+ )+ service = MagicMock()+ service.import_rag_pipeline.return_value = result+ service.confirm_import.return_value = result+ events: list[str] = []+ session = Session(db.engine, expire_on_commit=False)+ commit = session.commit+ close = session.close++ def commit_session() -> None:+ if commit_fails:+ raise RuntimeError("commit failed")+ commit()+ events.append("commit")++ def close_session() -> None:+ close()+ events.append("close")++ def sync_binding(*_args: object, **_kwargs: object) -> list[object]:+ events.append("sync")+ return []++ with (+ app.test_request_context("/"),+ patch("controllers.console.datasets.rag_pipeline.rag_pipeline_import.Session", return_value=session),+ patch(+ "controllers.console.datasets.rag_pipeline.rag_pipeline_import.RagPipelineDslService", return_value=service+ ),+ patch.object(session, "commit", side_effect=commit_session),+ patch.object(session, "close", side_effect=close_session),+ patch.object(+ rbac_service.RBACService.AccessPolicies,+ "sync_creator_access_policy_member_bindings",+ side_effect=sync_binding,+ ) as sync,+ patch.object(rbac_service.RBACService.DatasetAccess, "replace_whitelist") as replace,+ ):++ def invoke() -> JsonResponseWithStatus:+ if confirm:+ api = RagPipelineImportConfirmApi()+ return unwrap(api.post)(api, user, "import-1")+ api = RagPipelineImportApi()+ return unwrap(api.post)(api, RagPipelineImportPayload(mode="yaml-content"), user)++ if commit_fails:+ with pytest.raises(RuntimeError, match="commit failed"):+ invoke()+ else:+ response, _ = invoke()+ assert "dataset_created" not in response+ assert sync.call_count == expected_calls+ if expected_calls:+ assert events == ["commit", "close", "sync"]+ sync.assert_called_once_with(+ "tenant-1",+ "creator-1",+ resource_type=rbac_service.RBACResourceType.DATASET,+ resource_id="dataset-1",+ )+ replace.assert_not_called()diff --git a/api/tests/unit_tests/services/app/test_console_gateway.py b/api/tests/unit_tests/services/app/test_console_gateway.pyindex f3c085c919a..7563389a6a4 100644--- a/api/tests/unit_tests/services/app/test_console_gateway.py+++ b/api/tests/unit_tests/services/app/test_console_gateway.py@@ -710,3 +710,77 @@ def test_console_package_import_forwards_archive_and_closes_it(assert result.status == statusassert len(archives) == 1assert archives[0].archive.closed++[email protected]("commit_fails", [False, True])[email protected]("entry", ["import", "confirm", "copy"])[email protected]("status", list(ImportStatus))[email protected]("created", [False, True])+def test_import_creator_access_runs_after_successful_commit(+ sqlite_session_factory: sessionmaker[Session],+ copy_source: tuple[RequestContext, str],+ copy_connections: set[object],+ monkeypatch: pytest.MonkeyPatch,+ entry: str,+ status: ImportStatus,+ created: bool,+ commit_fails: bool,+) -> None:+ context, app_id = copy_source+ result = Import(id="import", status=status, app_id=app_id, app_mode=AppMode.WORKFLOW, app_created=created)+ events: list[str] = []++ class Dsl:+ def __init__(self, session: Session) -> None:+ if commit_fails:++ def fail_commit(_: Session) -> None:+ raise RuntimeError("commit failed")++ event.listen(session, "before_commit", fail_commit)+ event.listen(session, "after_commit", lambda _: events.append("commit"))+ event.listen(session, "after_rollback", lambda _: events.append("rollback"))++ def import_app(self, **_kwargs: object) -> Import:+ return result++ def confirm_import(self, **_kwargs: object) -> Import:+ return result++ def sync(tenant_id: str, account_id: str, resource_type: str, resource_id: str) -> None:+ assert not copy_connections+ assert events == ["commit"]+ assert (tenant_id, account_id, resource_type, resource_id) == (+ context.active_workspace_id,+ context.account_id,+ "app",+ app_id,+ )+ events.append("sync")++ monkeypatch.setattr("services.enterprise.rbac_service.try_sync_creator_access_policy_member_bindings", sync)+ gateway = AppTransferGateway(+ session_factory=sqlite_session_factory,+ dsl_factory=cast(Callable[[Session], AppDslService], Dsl),+ packages=AppPackageService(),+ agent_packages=RosterAgentPackageExporter(),+ agent_importer=RosterAgentPackageImporter(),+ recommended_packages=RecommendedAppPackageService(sources=Mock(), exporter=Mock()),+ )+ if commit_fails and status != ImportStatus.FAILED and not (entry == "copy" and status == ImportStatus.PENDING):+ if entry == "confirm":+ with pytest.raises(RuntimeError, match="commit failed"):+ gateway.confirm_import(context, "import")+ else:+ with pytest.raises(RuntimeError, match="commit failed"):+ gateway.import_dsl(context, AppImportParams(mode="yaml-content"), as_copy=entry == "copy")+ assert "sync" not in events+ return+ if entry == "confirm":+ returned, was_created = gateway.confirm_import(context, "import")+ assert was_created is created+ else:+ returned = gateway.import_dsl(context, AppImportParams(mode="yaml-content"), as_copy=entry == "copy")+ assert returned is result+ expected = created and status in (ImportStatus.COMPLETED, ImportStatus.COMPLETED_WITH_WARNINGS)+ assert (events.count("sync") == 1) is expecteddiff --git a/api/tests/unit_tests/services/enterprise/test_rbac_service.py b/api/tests/unit_tests/services/enterprise/test_rbac_service.pyindex b38f0e5ae9b..3e05c8c9480 100644--- a/api/tests/unit_tests/services/enterprise/test_rbac_service.py+++ b/api/tests/unit_tests/services/enterprise/test_rbac_service.py@@ -9,6 +9,7 @@ Local membership tests live at the application service boundary.from __future__ import annotationsfrom collections.abc import Callable+from unittest.mock import MagicMockimport pytest@@ -881,3 +882,145 @@ class TestListOption:"page_number": 1,"resource_type": "app",}+++def mock_send(monkeypatch: pytest.MonkeyPatch) -> MagicMock:+ send = MagicMock()+ monkeypatch.setattr(EnterpriseRequest, "send_inner_rbac_request", send)+ return send+++class TestCreatorDatasetAccess:+ @staticmethod+ def binding(**overrides: str) -> dict[str, str]:+ return {+ "id": "binding-1",+ "tenant_id": "tenant-1",+ "access_policy_id": "creator-policy",+ "resource_type": "dataset",+ "resource_id": "dataset-1",+ "account_id": "creator-1",+ **overrides,+ }++ def test_dataset_creator_is_appended_with_returned_policy(+ self, mock_send: MagicMock, config_overrides: Callable[..., None]+ ) -> None:+ config_overrides(RBAC_ENABLED=True)+ mock_send.side_effect = [{"data": [self.binding()]}, dict[str, str]()]++ svc.try_sync_creator_access_policy_member_bindings("tenant-1", "creator-1", "dataset", "dataset-1")++ assert mock_send.call_count == 2+ sync, append = mock_send.call_args_list+ assert sync.args == ("PUT", "/rbac/access-policies/creator-member-bindings")+ assert append.args == ("POST", "/rbac/datasets/whitelist/members/batch")+ assert append.kwargs["tenant_id"] == "tenant-1"+ assert append.kwargs["account_id"] == "creator-1"+ assert append.kwargs["json"] == {+ "data": [{"dataset_id": "dataset-1", "account_ids": ["creator-1"], "policy_id": "creator-policy"}]+ }++ @pytest.mark.parametrize(+ "overrides",+ [+ {"tenant_id": "other"},+ {"resource_id": "other"},+ {"account_id": "other"},+ {"resource_type": "app"},+ {"access_policy_id": ""},+ ],+ )+ def test_mismatched_binding_does_not_grant_access(+ self,+ mock_send: MagicMock,+ config_overrides: Callable[..., None],+ overrides: dict[str, str],+ caplog: pytest.LogCaptureFixture,+ ) -> None:+ config_overrides(RBAC_ENABLED=True)+ mock_send.return_value = {"data": [self.binding(**overrides)]}+ svc.try_sync_creator_access_policy_member_bindings("tenant-1", "creator-1", "dataset", "dataset-1")+ mock_send.assert_called_once()+ assert "Failed to sync creator access" in caplog.text++ def test_empty_response_does_not_guess_a_policy(+ self, mock_send: MagicMock, config_overrides: Callable[..., None], caplog: pytest.LogCaptureFixture+ ) -> None:+ config_overrides(RBAC_ENABLED=True)+ mock_send.return_value = {"data": list[dict[str, str]]()}+ svc.try_sync_creator_access_policy_member_bindings("tenant-1", "creator-1", "dataset", "dataset-1")+ mock_send.assert_called_once()+ assert "Failed to sync creator access" in caplog.text++ @pytest.mark.parametrize("resource_type", ["agent"])+ def test_other_resource_types_keep_existing_behavior(+ self, mock_send: MagicMock, config_overrides: Callable[..., None], resource_type: str+ ) -> None:+ config_overrides(RBAC_ENABLED=True)+ mock_send.return_value = {"data": list[dict[str, str]]()}+ svc.try_sync_creator_access_policy_member_bindings("tenant-1", "creator-1", resource_type, "resource-1")+ mock_send.assert_called_once()++ def test_disabled_rbac_makes_no_request(self, mock_send: MagicMock, config_overrides: Callable[..., None]) -> None:+ config_overrides(RBAC_ENABLED=False)+ svc.try_sync_creator_access_policy_member_bindings("tenant-1", "creator-1", "dataset", "dataset-1")+ mock_send.assert_not_called()++ @pytest.mark.parametrize("failure_stage", ["sync", "append"])+ def test_remote_failures_are_logged(+ self,+ mock_send: MagicMock,+ config_overrides: Callable[..., None],+ caplog: pytest.LogCaptureFixture,+ failure_stage: str,+ ) -> None:+ config_overrides(RBAC_ENABLED=True)+ error = RuntimeError("RBAC unavailable")+ mock_send.side_effect = [error] if failure_stage == "sync" else [{"data": [self.binding()]}, error]+ svc.try_sync_creator_access_policy_member_bindings("tenant-1", "creator-1", "dataset", "dataset-1")+ assert mock_send.call_count == (1 if failure_stage == "sync" else 2)+ assert "Failed to sync creator access" in caplog.text++ def test_only_matching_policies_are_appended_once(+ self, mock_send: MagicMock, config_overrides: Callable[..., None]+ ) -> None:+ config_overrides(RBAC_ENABLED=True)+ mock_send.side_effect = [+ {+ "data": [+ self.binding(),+ self.binding(),+ self.binding(access_policy_id="another-creator-policy"),+ self.binding(account_id="another-account", access_policy_id="unrelated-policy"),+ ]+ },+ dict[str, str](),+ ]+ svc.try_sync_creator_access_policy_member_bindings(+ "tenant-1", "creator-1", svc.RBACResourceType.DATASET, "dataset-1"+ )+ assert mock_send.call_count == 2+ assert mock_send.call_args.kwargs["json"] == {+ "data": [+ {"dataset_id": "dataset-1", "account_ids": ["creator-1"], "policy_id": policy}+ for policy in ["another-creator-policy", "creator-policy"]+ ]+ }+++class TestCreatorAppAccess:+ binding = staticmethod(TestCreatorDatasetAccess.binding)++ def test_app_creator_is_appended_with_returned_policy(+ self, mock_send: MagicMock, config_overrides: Callable[..., None]+ ) -> None:+ config_overrides(RBAC_ENABLED=True)+ mock_send.side_effect = [{"data": [self.binding(resource_type="app", resource_id="app-1")]}, dict[str, str]()]+ svc.try_sync_creator_access_policy_member_bindings("tenant-1", "creator-1", "app", "app-1")+ assert mock_send.call_count == 2+ assert mock_send.call_args.args == ("POST", "/rbac/apps/whitelist/members/batch")+ assert mock_send.call_args.kwargs["json"] == {+ "data": [{"app_id": "app-1", "account_ids": ["creator-1"], "policy_id": "creator-policy"}]+ }diff --git a/api/tests/unit_tests/services/rag_pipeline/test_rag_pipeline_dsl_service.py b/api/tests/unit_tests/services/rag_pipeline/test_rag_pipeline_dsl_service.pyindex 6b33ff358c1..060568c5f02 100644--- a/api/tests/unit_tests/services/rag_pipeline/test_rag_pipeline_dsl_service.py+++ b/api/tests/unit_tests/services/rag_pipeline/test_rag_pipeline_dsl_service.py@@ -8,7 +8,7 @@ service branch that owns the behavior under test.from __future__ import annotationsimport json-from collections.abc import Generator+from collections.abc import Generator, Sequencefrom contextlib import contextmanagerfrom types import SimpleNamespacefrom typing import Any@@ -669,6 +669,7 @@ def test_import_pending_version_stores_redis(monkeypatch: pytest.MonkeyPatch, seaccount=_account(), import_mode=ImportMode.YAML_CONTENT.value, yaml_content=_valid_dsl(version="1.0.0"))assert result.status == ImportStatus.PENDING+ assert result.dataset_created is Falseassert setex.call_args.args[0] == f"app_import_info:{result.id}"pending = RagPipelinePendingData.model_validate_json(setex.call_args.args[2])assert pending.tenant_id == "tenant-1"@@ -1048,3 +1049,83 @@ def test_create_dataset_name_is_tenant_scoped_and_ignores_template_rows(permission="only_me",),)++[email protected]("confirm", [False, True])[email protected]("existing", ["none", "pipeline", "dataset"])+def test_import_reports_actual_dataset_creation(+ monkeypatch: pytest.MonkeyPatch,+ service: RagPipelineDslService,+ sqlite_session: Session,+ confirm: bool,+ existing: str,+) -> None:+ pipeline_id = None+ if existing != "none":+ pipeline = _pipeline(sqlite_session)+ if existing == "dataset":+ _dataset(sqlite_session, pipeline)+ _workflow(sqlite_session, pipeline)+ pipeline_id = pipeline.id+ monkeypatch.setattr(module.KnowledgeConfiguration, "model_validate", Mock(return_value=_knowledge_configuration()))+ if confirm:+ pending = RagPipelinePendingData(+ tenant_id="tenant-1",+ account_id="account-1",+ import_mode=ImportMode.YAML_CONTENT.value,+ yaml_content=_valid_dsl(),+ pipeline_id=pipeline_id,+ )+ monkeypatch.setattr(module.redis_client, "get", Mock(return_value=pending.model_dump_json()))+ monkeypatch.setattr(module.redis_client, "delete", Mock())+ result = service.confirm_import(import_id="import-1", account=_account())+ else:+ result = service.import_rag_pipeline(+ account=_account(),+ import_mode=ImportMode.YAML_CONTENT.value,+ yaml_content=_valid_dsl(),+ pipeline_id=pipeline_id,+ )+ assert result.status == ImportStatus.COMPLETED+ assert result.dataset_created is (existing != "dataset")+ assert "dataset_created" not in result.model_dump()+ assert "dataset_created" not in json.loads(result.model_dump_json())+ assert sqlite_session.in_transaction()++[email protected]("confirm", [False, True])+def test_failed_import_does_not_report_created_dataset(+ monkeypatch: pytest.MonkeyPatch,+ service: RagPipelineDslService,+ sqlite_session: Session,+ confirm: bool,+) -> None:+ monkeypatch.setattr(module.KnowledgeConfiguration, "model_validate", Mock(return_value=_knowledge_configuration()))+ flush = sqlite_session.flush++ def fail_after_dataset_flush(objects: Sequence[object] | None = None) -> None:+ created_dataset = any(isinstance(obj, Dataset) for obj in sqlite_session.new)+ flush(objects)+ if created_dataset:+ raise RuntimeError("dataset flush failed")++ monkeypatch.setattr(sqlite_session, "flush", fail_after_dataset_flush)+ if confirm:+ pending = RagPipelinePendingData(+ tenant_id="tenant-1",+ account_id="account-1",+ import_mode=ImportMode.YAML_CONTENT.value,+ yaml_content=_valid_dsl(),+ pipeline_id=None,+ )+ monkeypatch.setattr(module.redis_client, "get", Mock(return_value=pending.model_dump_json()))+ result = service.confirm_import(import_id="import-1", account=_account())+ else:+ result = service.import_rag_pipeline(+ account=_account(),+ import_mode=ImportMode.YAML_CONTENT.value,+ yaml_content=_valid_dsl(),+ )+ assert result.status == ImportStatus.FAILED+ assert result.error == "dataset flush failed"+ assert result.dataset_created is Falsediff --git a/api/tests/unit_tests/services/test_app_dsl_service.py b/api/tests/unit_tests/services/test_app_dsl_service.pyindex 99ba986aa54..561dd8602b2 100644--- a/api/tests/unit_tests/services/test_app_dsl_service.py+++ b/api/tests/unit_tests/services/test_app_dsl_service.py@@ -1055,3 +1055,93 @@ def test_missing_app_section_names_the_keys_that_were_present(assert result.error.startswith("Missing app data in YAML content.")assert result.error.endswith(f"(found: {found}).")assert not unbound_session.in_transaction()++[email protected]("confirmed", [False, True])[email protected]("overwrite", [False, True])+def test_import_creation_marker_tracks_persisted_app(+ sqlite_session: Session, monkeypatch: pytest.MonkeyPatch, confirmed: bool, overwrite: bool+) -> None:+ account = _account(account_id=_CALLER_ID, tenant_id=_TENANT_ID)+ target = _persist_overwrite_target(sqlite_session) if overwrite else None+ data = yaml.safe_dump(+ {+ "version": CURRENT_APP_DSL_VERSION,+ "kind": "app",+ "app": {"name": "Imported", "mode": "workflow"},+ "workflow": {"graph": {"nodes": [], "edges": []}, "features": {}},+ }+ )+ monkeypatch.setattr("services.app_dsl_service.WorkflowService", Mock())+ service = AppDslService(sqlite_session)+ if confirmed:+ pending = PendingData(+ tenant_id=_TENANT_ID,+ account_id=_CALLER_ID,+ import_mode="yaml-content",+ yaml_content=data,+ app_id=_OVERWRITE_APP_ID if overwrite else None,+ )+ monkeypatch.setattr("services.app_dsl_service.redis_client.get", lambda _: pending.model_dump_json())+ result = service.confirm_import(import_id="pending", account=account)+ else:+ result = service.import_app(+ account=account,+ import_mode="yaml-content",+ yaml_content=data,+ app_id=_OVERWRITE_APP_ID if overwrite else None,+ )+ assert result.status == ImportStatus.COMPLETED, result.error+ assert result.app_created is (not overwrite)+ assert sqlite_session.get(App, result.app_id) is not None+ assert "app_created" not in result.model_dump()+ assert "app_created" not in result.model_json_schema(mode="serialization")["properties"]++[email protected]("mode", list(AppMode) + [None])+def test_import_creator_access_only_initializes_ordinary_apps(+ mode: AppMode | None, monkeypatch: pytest.MonkeyPatch+) -> None:+ from services.app_dsl_service import initialize_imported_app_creator_access+ from services.entities.dsl_entities import Import++ sync = Mock()+ monkeypatch.setattr("services.enterprise.rbac_service.try_sync_creator_access_policy_member_bindings", sync)+ result = Import(id="import", status=ImportStatus.COMPLETED, app_id="app", app_mode=mode, app_created=True)+ initialize_imported_app_creator_access(result, tenant_id="tenant", account_id="creator")+ assert sync.call_count == (+ 1+ if mode in {AppMode.CHAT, AppMode.COMPLETION, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.WORKFLOW}+ else 0+ )++[email protected]("confirmed", [False, True])+def test_failed_import_does_not_report_creation(+ sqlite_session: Session, monkeypatch: pytest.MonkeyPatch, confirmed: bool+) -> None:+ data = "version: " + CURRENT_APP_DSL_VERSION + "\nkind: app\napp: {name: Broken, mode: chat}\n"+ service = AppDslService(sqlite_session)+ if confirmed:+ pending = PendingData(+ tenant_id="tenant-1", account_id="account-1", import_mode="yaml-content", yaml_content=data+ )+ monkeypatch.setattr("services.app_dsl_service.redis_client.get", lambda _: pending.model_dump_json())+ result = service.confirm_import(import_id="pending", account=_account())+ else:+ result = service.import_app(account=_account(), import_mode="yaml-content", yaml_content=data)+ assert result.status == ImportStatus.FAILED+ assert not result.app_created+++def test_pending_import_does_not_report_creation_or_cache_marker(+ unbound_session: Session, monkeypatch: pytest.MonkeyPatch+) -> None:+ cache = Mock()+ monkeypatch.setattr("services.app_dsl_service.redis_client.setex", cache)+ result = AppDslService(unbound_session).import_app(+ account=_account(), import_mode="yaml-content", yaml_content=_PENDING_WORKFLOW_DSL+ )+ assert result.status == ImportStatus.PENDING+ assert not result.app_created+ assert "app_created" not in cache.call_args.args[2]diff --git a/api/tests/unit_tests/services/test_dataset_service_dataset.py b/api/tests/unit_tests/services/test_dataset_service_dataset.pyindex 8ae38e09757..5bcc94a550f 100644--- a/api/tests/unit_tests/services/test_dataset_service_dataset.py+++ b/api/tests/unit_tests/services/test_dataset_service_dataset.py@@ -28,6 +28,7 @@ from models.dataset import (ExternalKnowledgeBindings,Pipeline,)+from services.enterprise import rbac_servicefrom services.entities.knowledge_entities.rag_pipeline_entities import (IconInfo,RagPipelineDatasetCreateEntity,@@ -1167,3 +1168,67 @@ class TestDatasetPermissions:event.remove(sqlite_session, "do_orm_execute", fail_execute)assert transaction_events == []++[email protected]("rbac_enabled", [False, True])[email protected]("commit_fails", [False, True])[email protected]("expire_on_commit", [False, True])+def test_empty_pipeline_syncs_creator_after_commit(+ sqlite_session: Session,+ sqlite_session_factory: sessionmaker[Session],+ config_overrides: Callable[..., None],+ rbac_enabled: bool,+ commit_fails: bool,+ expire_on_commit: bool,+) -> None:+ config_overrides(RBAC_ENABLED=rbac_enabled)+ sqlite_session.expire_on_commit = expire_on_commit+ account = _account()+ entity = RagPipelineDatasetCreateEntity(+ name="New pipeline",+ description="",+ permission=DatasetPermissionEnum.ONLY_ME,+ icon_info=IconInfo(icon_type="emoji", icon="📚", icon_background="#FFFFFF", icon_url=None),+ )+ commit = sqlite_session.commit+ observed: list[tuple[str, str, object]] = []+ transactions_at_sync: list[bool] = []++ def commit_session() -> None:+ if commit_fails:+ raise RuntimeError("commit failed")+ commit()++ def sync_binding(_tenant_id: str, _account_id: str, *, resource_type: object, resource_id: str) -> list[object]:+ transactions_at_sync.append(sqlite_session.in_transaction())+ with sqlite_session_factory() as observer:+ stored = observer.get(Dataset, resource_id)+ if stored is not None:+ observed.append((stored.tenant_id, stored.created_by, resource_type))+ return []++ with (+ patch("services.knowledge.dataset_service.current_user", account),+ patch.object(sqlite_session, "commit", side_effect=commit_session),+ patch.object(+ rbac_service.RBACService.AccessPolicies,+ "sync_creator_access_policy_member_bindings",+ side_effect=sync_binding,+ ) as sync,+ ):+ if commit_fails:+ with pytest.raises(RuntimeError, match="commit failed"):+ DatasetService.create_empty_rag_pipeline_dataset("tenant-1", entity, sqlite_session)+ else:+ dataset = DatasetService.create_empty_rag_pipeline_dataset("tenant-1", entity, sqlite_session)+ if rbac_enabled:+ assert transactions_at_sync == [False]+ assert observed == [("tenant-1", account.id, rbac_service.RBACResourceType.DATASET)]+ sync.assert_called_once_with(+ "tenant-1",+ account.id,+ resource_type=rbac_service.RBACResourceType.DATASET,+ resource_id=dataset.id,+ )+ if commit_fails or not rbac_enabled:+ sync.assert_not_called()