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.

8.2 KB
Raw Blame
"""Plugin and persistence adapters for datasource credential application ports."""

from collections.abc import Callable, Mapping, Sequence
from typing import Protocol

from configs import dify_config
from core.helper import encrypter
from core.helper.provider_cache import NoOpProviderCredentialCache
from core.plugin.entities.plugin_daemon import CredentialType, PluginDatasourceProviderEntity
from core.plugin.impl.datasource import PluginDatasourceManager
from core.plugin.impl.oauth import OAuthHandler
from core.plugin.plugin_service import PluginService
from core.tools.utils.encryption import create_provider_encrypter
from graphon.model_runtime.entities.provider_entities import FormType
from models.provider_ids import DatasourceProviderID
from services.data_source.credential_gateway import (
    DatasourceCredentialError,
    DatasourceCredentialRefreshError,
    RefreshedDatasourceCredential,
)
from services.data_source.entities.credential import DatasourceCredentialRecord, DatasourceOAuthClientConfigRecord
from services.plugin.dispatch_identity import PluginOAuthClientConfig


class DatasourceOAuthClientConfigReader(Protocol):
    def get_oauth_client_config(
        self,
        *,
        workspace_id: str,
        provider: str,
        plugin_id: str,
    ) -> DatasourceOAuthClientConfigRecord: ...


class DatasourceOAuthClientResolver(Protocol):
    def resolve(self, *, workspace_id: str, provider_id: DatasourceProviderID) -> PluginOAuthClientConfig: ...


class PluginDatasourceCredentialCodec:
    def __init__(self, provider_manager: PluginDatasourceManager) -> None:
        self._provider_manager = provider_manager

    def decrypt(self, record: DatasourceCredentialRecord) -> dict[str, object]:
        return transform_secret_fields(
            record.workspace_id, record.encrypted_credentials, self._secret_variables(record), encrypter.decrypt_token
        )

    def encrypt(self, record: DatasourceCredentialRecord, credentials: Mapping[str, object]) -> dict[str, object]:
        return transform_secret_fields(
            record.workspace_id, credentials, self._secret_variables(record), encrypter.encrypt_token
        )

    def _secret_variables(self, record: DatasourceCredentialRecord) -> tuple[str, ...]:
        return datasource_secret_variables(
            self._provider_manager,
            record.workspace_id,
            f"{record.plugin_id}/{record.provider}",
            CredentialType.of(record.auth_type),
        )


def transform_secret_fields(
    workspace_id: str,
    credentials: Mapping[str, object],
    secret_variables: Sequence[str],
    transform: Callable[[str, str], str],
) -> dict[str, object]:
    """Apply the shared token codec only to declared string secrets."""
    result = dict(credentials)
    for name in secret_variables:
        value = result.get(name)
        if isinstance(value, str):
            result[name] = transform(workspace_id, value)
    return result


def datasource_secret_variables(
    manager: PluginDatasourceManager,
    workspace_id: str,
    provider_id: str,
    credential_type: CredentialType,
    *,
    provider_declaration: PluginDatasourceProviderEntity | None = None,
) -> tuple[str, ...]:
    provider = provider_declaration or manager.fetch_datasource_provider(
        tenant_id=workspace_id, provider_id=provider_id
    )
    if credential_type == CredentialType.API_KEY:
        schemas = provider.declaration.credentials_schema
    elif credential_type == CredentialType.OAUTH2:
        if provider.declaration.oauth_schema is None:
            raise DatasourceCredentialError("Datasource provider oauth schema not found")
        schemas = provider.declaration.oauth_schema.credentials_schema
    else:
        raise DatasourceCredentialError(f"Unsupported credential type: {credential_type}")
    return tuple(schema.name for schema in schemas if schema.type.value == FormType.SECRET_INPUT)


class PluginDatasourceOAuthClientResolver:
    """Turn detached OAuth client rows into plugin-ready credentials."""

    def __init__(
        self,
        *,
        configs: DatasourceOAuthClientConfigReader,
        provider_manager: PluginDatasourceManager,
    ) -> None:
        self._configs = configs
        self._provider_manager = provider_manager

    def resolve(self, *, workspace_id: str, provider_id: DatasourceProviderID) -> PluginOAuthClientConfig:
        config = self._configs.get_oauth_client_config(
            workspace_id=workspace_id,
            provider=provider_id.provider_name,
            plugin_id=provider_id.plugin_id,
        )
        return resolve_datasource_oauth_client(
            config, workspace_id=workspace_id, provider_id=provider_id, provider_manager=self._provider_manager
        )


def resolve_datasource_oauth_client(
    config: DatasourceOAuthClientConfigRecord,
    *,
    workspace_id: str,
    provider_id: DatasourceProviderID,
    provider_manager: PluginDatasourceManager,
    provider_declaration: PluginDatasourceProviderEntity | None = None,
) -> PluginOAuthClientConfig:
    provider = provider_declaration or provider_manager.fetch_datasource_provider(
        tenant_id=workspace_id,
        provider_id=str(provider_id),
    )
    plugin_unique_identifier = provider.plugin_unique_identifier
    if config.encrypted_tenant_params is not None:
        oauth_schema = provider.declaration.oauth_schema
        if oauth_schema is None:
            raise DatasourceCredentialError("Datasource provider oauth schema not found")
        credential_encrypter, _ = create_provider_encrypter(
            tenant_id=workspace_id,
            config=[item.to_basic_provider_config() for item in oauth_schema.client_schema],
            cache=NoOpProviderCredentialCache(),
        )
        return PluginOAuthClientConfig(
            plugin_unique_identifier, dict(credential_encrypter.decrypt(dict(config.encrypted_tenant_params)))
        )

    if config.system_credentials is not None and PluginService.is_plugin_verified(
        workspace_id, plugin_unique_identifier
    ):
        return PluginOAuthClientConfig(plugin_unique_identifier, dict(config.system_credentials))
    raise DatasourceCredentialError(f"OAuth client is not configured for {provider_id}")


class OAuthDatasourceCredentialRefresher:
    """Refresh datasource credentials through an injected OAuth-client resolver."""

    def __init__(
        self,
        *,
        oauth_clients: DatasourceOAuthClientResolver,
        oauth_handler: OAuthHandler,
    ) -> None:
        self._oauth_clients = oauth_clients
        self._oauth_handler = oauth_handler

    def refresh(
        self,
        *,
        workspace_id: str,
        actor_id: str,
        record: DatasourceCredentialRecord,
        credentials: Mapping[str, object],
    ) -> RefreshedDatasourceCredential:
        provider_id = DatasourceProviderID(f"{record.plugin_id}/{record.provider}")
        try:
            return refresh_datasource_credential(
                self._oauth_handler,
                workspace_id=workspace_id,
                actor_id=actor_id,
                provider_id=provider_id,
                system_credentials=self._oauth_clients.resolve(workspace_id=workspace_id, provider_id=provider_id),
                credentials=credentials,
            )
        except DatasourceCredentialError:
            raise
        except Exception as error:
            raise DatasourceCredentialRefreshError(record.id) from error


def refresh_datasource_credential(
    handler: OAuthHandler,
    *,
    workspace_id: str,
    actor_id: str,
    provider_id: DatasourceProviderID,
    system_credentials: PluginOAuthClientConfig,
    credentials: Mapping[str, object],
) -> RefreshedDatasourceCredential:
    refreshed = handler.refresh_credentials(
        tenant_id=workspace_id,
        user_id=actor_id,
        plugin_id=provider_id.plugin_id,
        provider=provider_id.provider_name,
        redirect_uri=f"{dify_config.CONSOLE_API_URL}/console/api/oauth/plugin/{provider_id}/datasource/callback",
        system_credentials=dict(system_credentials.credentials),
        plugin_unique_identifier=system_credentials.plugin_unique_identifier,
        credentials=dict(credentials),
    )
    return RefreshedDatasourceCredential(credentials=dict(refreshed.credentials), expires_at=refreshed.expires_at)