Skip to content

armgit / dify

Public Imported from GitHub
0

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.

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.py
index 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 Resource
from werkzeug.exceptions import Forbidden
from 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_models
from controllers.console.app.error import AppNotFoundError
from controllers.console.explore.error import RecommendedAppNotFoundError as RecommendedAppNotFoundHttpError
from 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.py
index 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_response
from libs.login import login_required
from models.account import Account
from models.dataset import Pipeline
+from services.enterprise import rbac_service as enterprise_rbac_service
from services.entities.dsl_entities import ImportStatus
from services.rag_pipeline.rag_pipeline_dsl_service import RagPipelineDslService
+from services.rbac import contracts as rbac_contracts
class 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 result
status = result.status
match 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 result
if result.status == ImportStatus.FAILED:
return dump_response(RagPipelineImportResponse, result), 400
diff --git a/api/services/app/console_gateway.py b/api/services/app/console_gateway.py
index 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 AppDefinitionImports
from 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_access
from services.app_import_source import download_app_import_source, try_read_yaml
from services.app_package_service import AppPackageService
from 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
@override
def 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 None
result = self.confirm_definition(context, import_id)
- return result, pending is not None and pending.app_id is None
+ return result, result.app_created
@override
def 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
@override
diff --git a/api/services/app/console_service.py b/api/services/app/console_service.py
index 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 result
diff --git a/api/services/app_dsl_service.py b/api/services/app_dsl_service.py
index 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 WorkflowAgentRetirementService
from services.agent.workflow_publish_service import WorkflowAgentPublishService
from services.dsl_content import DSL_MAX_SIZE, dsl_content_size
from services.dsl_version import check_version_compatibility
+from services.enterprise import rbac_service
from services.enterprise.rbac_service import RBACService
from services.entities.dsl_entities import (
AppDslExportData,
@@ -94,6 +95,26 @@ IMPORT_INFO_REDIS_EXPIRY = 10 * 60 # 10 minutes
CURRENT_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 None
app = 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 None
app = 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.py
index 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:
return
try:
- 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.py
index 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: ImportStatus
app_id: str | None = None
app_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_VERSION
imported_dsl_version: str = ""
diff --git a/api/services/knowledge/dataset_service.py b/api/services/knowledge/dataset_service.py
index 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.id
session.commit()
+ enterprise_rbac_service.try_sync_creator_access_policy_member_bindings(
+ tenant_id,
+ creator_id,
+ rbac_contracts.RBACResourceType.DATASET,
+ dataset_id,
+ )
return dataset
@staticmethod
diff --git a/api/services/rag_pipeline/rag_pipeline_dsl_service.py b/api/services/rag_pipeline/rag_pipeline_dsl_service.py
index 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: ignore
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
from flask_login import current_user
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
from sqlalchemy import select
from 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 = False
for 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 = True
datasets = 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 = False
for 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 = True
dataset = 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.py
index 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.py
index 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, Iterator
from inspect import unwrap
from unittest.mock import MagicMock, patch
import pytest
from flask import Flask
+from sqlalchemy.orm import Session
+from controllers.common.schema import JsonResponseWithStatus
from controllers.console import console_ns
from controllers.console.datasets.rag_pipeline.rag_pipeline_import import (
IncludeSecretQuery,
@@ -22,9 +24,10 @@ from core.plugin.entities.plugin import PluginDependency, PluginDependencyType
from models.account import Account
from models.dataset import Pipeline
from models.engine import db
+from services.enterprise import rbac_service
from services.entities.dsl_entities import CheckDependenciesResult, ImportStatus
from 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_tenant
def _account() -> Account:
@@ -299,3 +302,101 @@ class TestRagPipelineExportApi:
assert status == 200
assert 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.py
index 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 == status
assert len(archives) == 1
assert 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 expected
diff --git a/api/tests/unit_tests/services/enterprise/test_rbac_service.py b/api/tests/unit_tests/services/enterprise/test_rbac_service.py
index 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 annotations
from collections.abc import Callable
+from unittest.mock import MagicMock
import 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.py
index 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 annotations
import json
-from collections.abc import Generator
+from collections.abc import Generator, Sequence
from contextlib import contextmanager
from types import SimpleNamespace
from typing import Any
@@ -669,6 +669,7 @@ def test_import_pending_version_stores_redis(monkeypatch: pytest.MonkeyPatch, se
account=_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 False
assert 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 False
diff --git a/api/tests/unit_tests/services/test_app_dsl_service.py b/api/tests/unit_tests/services/test_app_dsl_service.py
index 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.py
index 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_service
from 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()