chore: 纳入本地 Dify 1.19.0 源码及品牌与免登改动

演示目录只保留可重建的源码。运行密钥、数据卷、依赖和带口令的本地配置不进入仓库。

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
wuzilongandCursor committed 2026-11-18 13:59:25 +08:00
1 parent 60158935f4
commit 6519682885
15831 files changed
+3063428

No files matched your search

@@ -0,0 +1 @@
"""Domain-specific dependency composition for application services."""
@@ -0,0 +1,360 @@
"""Compose the account domain using shared account and workspace persistence."""
from dataclasses import dataclass
from functools import partial
from sqlalchemy.orm import Session, sessionmaker
from configs import dify_config
from constants.languages import languages
from enums import DeploymentEdition
from extensions.ext_redis import RedisClientWrapper
from libs.datetime_utils import naive_utc_now, utc_now
from libs.helper import RateLimiter
from libs.oauth import GitHubOAuth, GoogleOAuth
from libs.oauth_bearer import invalidate_oauth_token_cache
from repositories.account.repository import SQLAlchemyAccountRepository
from repositories.account_activation_repository import SQLAlchemyAccountActivationRepository
from repositories.account_integration_repository import SQLAlchemyAccountIntegrationRepository
from repositories.oauth_access_token_repository import SQLAlchemyOAuthAccessTokenRepository
from repositories.workspace.workspace_repository import WorkspaceRepository
from services.account.adapters import (
AccountIdentityGateway,
BillingAccountActivationEligibility,
BillingAccountDeletionFeedbackGateway,
BillingAccountEducationGateway,
BillingAccountEmailPolicyGateway,
BillingWorkspaceMembershipCache,
CeleryAccountDeletionScheduler,
CeleryAccountDeletionVerificationNotifier,
CeleryChangeEmailNotificationGateway,
DeploymentAccountLifecyclePolicy,
DeploymentWorkspaceInvitePolicy,
EnterpriseAccountDeletionSyncGateway,
RateLimiterChangeEmailSendLimiter,
RBACWorkspaceMemberAccessSync,
RedisChangeEmailSecurityGateway,
RedisInvitationTokenStore,
SecureChangeEmailCodeGenerator,
TokenManagerAccountDeletionVerificationGateway,
TokenManagerChangeEmailTokenGateway,
)
from services.account.email_registration_adapters import (
AccountLifecycleRegistrationGateway,
BillingAccountRegistrationPolicyGateway,
CeleryEmailRegistrationNotificationGateway,
RateLimiterEmailRegistrationSendLimiter,
RedisEmailRegistrationSecurityGateway,
SecureEmailRegistrationCodeGenerator,
TokenManagerEmailRegistrationTokenGateway,
)
from services.account.email_registration_service import AccountEmailRegistrationService
from services.account.forgot_password_adapters import (
CeleryForgotPasswordNotificationGateway,
RateLimiterForgotPasswordSendLimiter,
RedisForgotPasswordSecurityGateway,
RedisForgotPasswordTokenGateway,
SecureForgotPasswordCodeGenerator,
SystemFeatureServiceForgotPasswordRegistrationPolicy,
)
from services.account.forgot_password_service import AccountForgotPasswordService
from services.account.login_adapters import (
AccountActivationConsoleAuthInvitationGateway,
DeploymentConsoleAuthPolicyGateway,
LoggingConsoleAuthAuditGateway,
RedisAccountSessionGateway,
RedisConsoleAuthSecurityGateway,
RedisEmailCodeGateway,
RedisResetPasswordEmailGateway,
SQLAlchemyAccountRefreshPreparationGateway,
TurnstileHumanVerificationGateway,
)
from services.account.login_service import ConsoleAuthenticationService
from services.account.oauth_adapters import (
AccountActivationOAuthInvitationGateway,
AccountLifecycleOAuthRegistrationGateway,
AccountLifecycleOAuthSessionGateway,
DeploymentOAuthPolicyGateway,
DifyOAuthProviderGateway,
RedisOAuthAccountClaimLock,
WorkspaceProvisioningOAuthGateway,
)
from services.account.oauth_service import AccountOAuthService, OAuthProviderGateway
from services.account.service import AccountService
from services.account_access_service import AccountAccessService
from services.account_activation_service import (
AccountActivationRepository,
AccountActivationService,
InvitationTokenStore,
)
from services.account_avatar_file_gateway import SQLAlchemyAccountAvatarFileGateway
from services.account_avatar_service import AccountAvatarService
from services.account_change_email_service import AccountChangeEmailService
from services.account_deletion_feedback_service import AccountDeletionFeedbackService
from services.account_deletion_service import AccountDeletionService
from services.account_education_service import AccountEducationService
from services.account_initialization_service import AccountInitializationService
from services.account_integration_service import AccountIntegrationService
from services.account_password_hasher import DefaultAccountPasswordHasher
from services.account_password_service import AccountPasswordService
from services.account_profile_service import AccountProfileService
from services.workspace.provisioning_service import WorkspaceProvisioningService
@dataclass(frozen=True, slots=True)
class AccountServices:
access: AccountAccessService
activation: AccountActivationService
authentication: ConsoleAuthenticationService
avatar: AccountAvatarService
change_email: AccountChangeEmailService
email_registration: AccountEmailRegistrationService
deletion: AccountDeletionService
deletion_feedback: AccountDeletionFeedbackService
education: AccountEducationService
forgot_password: AccountForgotPasswordService
initialization: AccountInitializationService
integrations: AccountIntegrationService
oauth: AccountOAuthService
password: AccountPasswordService
profile: AccountProfileService
lifecycle: AccountService
identity: AccountIdentityGateway
def _build_account_oauth_service(
*,
deployment_edition: DeploymentEdition,
redis: RedisClientWrapper,
accounts: SQLAlchemyAccountRepository,
integrations: SQLAlchemyAccountIntegrationRepository,
memberships: WorkspaceRepository,
lifecycle: AccountService,
workspace_provisioning: WorkspaceProvisioningService,
invitation_tokens: InvitationTokenStore,
activation_accounts: AccountActivationRepository,
) -> AccountOAuthService:
providers: dict[str, OAuthProviderGateway] = {}
if dify_config.GITHUB_CLIENT_ID and dify_config.GITHUB_CLIENT_SECRET:
providers["github"] = DifyOAuthProviderGateway(
provider_name="github",
client=GitHubOAuth(
client_id=dify_config.GITHUB_CLIENT_ID,
client_secret=dify_config.GITHUB_CLIENT_SECRET,
redirect_uri=dify_config.CONSOLE_API_URL + "/console/api/oauth/authorize/github",
),
)
if dify_config.GOOGLE_CLIENT_ID and dify_config.GOOGLE_CLIENT_SECRET:
providers["google"] = DifyOAuthProviderGateway(
provider_name="google",
client=GoogleOAuth(
client_id=dify_config.GOOGLE_CLIENT_ID,
client_secret=dify_config.GOOGLE_CLIENT_SECRET,
redirect_uri=dify_config.CONSOLE_API_URL + "/console/api/oauth/authorize/google",
),
)
policy = DeploymentOAuthPolicyGateway(
billing_enabled=deployment_edition == DeploymentEdition.CLOUD,
)
return AccountOAuthService(
providers=providers,
accounts=accounts,
integrations=integrations,
memberships=memberships,
invitations=AccountActivationOAuthInvitationGateway(tokens=invitation_tokens, accounts=activation_accounts),
account_claims=RedisOAuthAccountClaimLock(client=redis),
registration=AccountLifecycleOAuthRegistrationGateway(accounts=lifecycle),
workspaces=WorkspaceProvisioningOAuthGateway(workspaces=workspace_provisioning),
sessions=AccountLifecycleOAuthSessionGateway(accounts=lifecycle),
registration_policy=policy,
workspace_policy=policy,
supported_languages=languages,
now=naive_utc_now,
)
def build_account_services(
*,
database_client: sessionmaker[Session],
deployment_edition: DeploymentEdition,
redis: RedisClientWrapper,
accounts: SQLAlchemyAccountRepository,
integrations: SQLAlchemyAccountIntegrationRepository,
workspace_repository: WorkspaceRepository,
workspace_provisioning: WorkspaceProvisioningService,
passwords: DefaultAccountPasswordHasher,
invitation_tokens: RedisInvitationTokenStore,
activation_accounts: SQLAlchemyAccountActivationRepository,
) -> AccountServices:
lifecycle = AccountService(
security=RedisConsoleAuthSecurityGateway(redis=redis),
accounts=accounts,
policies=DeploymentAccountLifecyclePolicy(),
passwords=passwords,
workspaces=workspace_provisioning,
sessions=RedisAccountSessionGateway(redis=redis),
now=naive_utc_now,
)
activation = AccountActivationService(
tokens=invitation_tokens,
accounts=activation_accounts,
workspace_policy=DeploymentWorkspaceInvitePolicy(),
eligibility=BillingAccountActivationEligibility(
enabled=deployment_edition == DeploymentEdition.CLOUD,
),
membership_cache=BillingWorkspaceMembershipCache(
enabled=deployment_edition == DeploymentEdition.CLOUD,
),
member_access_sync=RBACWorkspaceMemberAccessSync(
enabled=dify_config.RBAC_ENABLED,
),
)
return AccountServices(
lifecycle=lifecycle,
activation=activation,
identity=AccountIdentityGateway(accounts=accounts, redis=redis),
access=AccountAccessService(
accounts=accounts,
workspaces=workspace_repository,
sessions=SQLAlchemyOAuthAccessTokenRepository(session_factory=database_client),
invalidate_token_cache=partial(invalidate_oauth_token_cache, redis),
now=utc_now,
),
authentication=ConsoleAuthenticationService(
accounts=accounts,
workspaces=workspace_repository,
invitations=AccountActivationConsoleAuthInvitationGateway(
tokens=invitation_tokens,
accounts=activation_accounts,
activation=activation,
),
policies=DeploymentConsoleAuthPolicyGateway(
billing_enabled=deployment_edition == DeploymentEdition.CLOUD,
),
security=RedisConsoleAuthSecurityGateway(redis=redis),
passwords=passwords,
human_verification=TurnstileHumanVerificationGateway(),
sessions=RedisAccountSessionGateway(redis=redis),
refresh_preparation=SQLAlchemyAccountRefreshPreparationGateway(accounts=accounts),
account_provisioning=workspace_provisioning,
workspace_provisioning=workspace_provisioning,
email_codes=RedisEmailCodeGateway(redis=redis),
reset_password_emails=RedisResetPasswordEmailGateway(redis=redis),
audit=LoggingConsoleAuthAuditGateway(),
now=naive_utc_now,
turnstile_enabled=deployment_edition == DeploymentEdition.CLOUD,
turnstile_verify_required=(
deployment_edition == DeploymentEdition.CLOUD and dify_config.TURNSTILE_EMAIL_CODE_VERIFY_REQUIRED
),
),
avatar=AccountAvatarService(
files=SQLAlchemyAccountAvatarFileGateway(session_factory=database_client),
),
change_email=AccountChangeEmailService(
accounts=accounts,
tokens=TokenManagerChangeEmailTokenGateway(),
codes=SecureChangeEmailCodeGenerator(),
notifications=CeleryChangeEmailNotificationGateway(),
send_limits=RateLimiterChangeEmailSendLimiter(redis=redis),
security=RedisChangeEmailSecurityGateway(
redis=redis,
email_send_ip_limit_per_minute=dify_config.EMAIL_SEND_IP_LIMIT_PER_MINUTE,
verification_failure_limit=5,
verification_lockout_duration=dify_config.CHANGE_EMAIL_LOCKOUT_DURATION,
),
email_policy=BillingAccountEmailPolicyGateway(
billing_enabled=deployment_edition == DeploymentEdition.CLOUD,
),
),
email_registration=AccountEmailRegistrationService(
accounts=accounts,
tokens=TokenManagerEmailRegistrationTokenGateway(),
codes=SecureEmailRegistrationCodeGenerator(),
notifications=CeleryEmailRegistrationNotificationGateway(),
send_limits=RateLimiterEmailRegistrationSendLimiter(
rate_limiter=RateLimiter(
prefix="email_register_rate_limit",
max_attempts=1,
time_window=60,
redis_client=redis,
)
),
security=RedisEmailRegistrationSecurityGateway(
redis=redis,
login_security=RedisConsoleAuthSecurityGateway(redis=redis),
verification_failure_limit=5,
verification_lockout_duration=dify_config.EMAIL_REGISTER_LOCKOUT_DURATION,
),
account_policy=BillingAccountRegistrationPolicyGateway(
enabled=deployment_edition == DeploymentEdition.CLOUD,
),
registration=AccountLifecycleRegistrationGateway(accounts=lifecycle),
),
deletion=AccountDeletionService(
accounts=accounts,
memberships=workspace_repository,
verification=TokenManagerAccountDeletionVerificationGateway(),
notifications=CeleryAccountDeletionVerificationNotifier(redis=redis),
synchronization=EnterpriseAccountDeletionSyncGateway(),
scheduler=CeleryAccountDeletionScheduler(),
),
deletion_feedback=AccountDeletionFeedbackService(
feedback=BillingAccountDeletionFeedbackGateway(),
),
education=AccountEducationService(
accounts=accounts,
education=BillingAccountEducationGateway(),
verification_rate_limiter=RateLimiter(
prefix="edu_verification_rate_limit",
max_attempts=10,
time_window=60,
redis_client=redis,
),
activation_rate_limiter=RateLimiter(
prefix="edu_activation_rate_limit",
max_attempts=10,
time_window=60,
redis_client=redis,
),
),
forgot_password=AccountForgotPasswordService(
accounts=accounts,
passwords=passwords,
tokens=RedisForgotPasswordTokenGateway(
redis=redis,
expiry_seconds=dify_config.RESET_PASSWORD_TOKEN_EXPIRY_MINUTES * 60,
),
codes=SecureForgotPasswordCodeGenerator(),
notifications=CeleryForgotPasswordNotificationGateway(),
send_limits=RateLimiterForgotPasswordSendLimiter(redis=redis),
security=RedisForgotPasswordSecurityGateway(
redis=redis,
email_send_ip_limit_per_minute=dify_config.EMAIL_SEND_IP_LIMIT_PER_MINUTE,
verification_lockout_duration=dify_config.FORGOT_PASSWORD_LOCKOUT_DURATION,
),
registration=SystemFeatureServiceForgotPasswordRegistrationPolicy(),
),
initialization=AccountInitializationService(
accounts=accounts,
invitation_required=deployment_edition == DeploymentEdition.CLOUD,
now=naive_utc_now,
),
integrations=AccountIntegrationService(integrations=integrations),
oauth=_build_account_oauth_service(
deployment_edition=deployment_edition,
redis=redis,
accounts=accounts,
integrations=integrations,
memberships=workspace_repository,
lifecycle=lifecycle,
workspace_provisioning=workspace_provisioning,
invitation_tokens=invitation_tokens,
activation_accounts=activation_accounts,
),
password=AccountPasswordService(
accounts=accounts,
passwords=passwords,
),
profile=AccountProfileService(accounts=accounts),
)
@@ -0,0 +1,37 @@
"""Composition of the Agent App console use cases."""
from dataclasses import dataclass
from sqlalchemy.orm import Session, sessionmaker
from configs import dify_config
from repositories.app.agent_app_repository import AgentAppRepository
from repositories.app.agent_sandbox_repository import AgentSandboxRepository
from services.app.agent_app_feature_gateway import AgentAppFeatureValidator
from services.app.agent_app_sandbox_service import AgentAppSandboxService
from services.app.agent_app_service import AgentAppAccessService, AgentAppFeatureConfigService
from services.app.agent_sandbox_file_gateway import AgentSandboxFileGateway, create_sandbox_client
from services.file_request_service import FileRequestService
@dataclass(frozen=True, slots=True)
class AgentAppServices:
access: AgentAppAccessService
features: AgentAppFeatureConfigService
sandbox: AgentAppSandboxService
def build_agent_app_services(*, database_client: sessionmaker[Session]) -> AgentAppServices:
apps = AgentAppRepository(session_factory=database_client)
return AgentAppServices(
access=AgentAppAccessService(references=apps),
features=AgentAppFeatureConfigService(features=apps, validator=AgentAppFeatureValidator()),
sandbox=AgentAppSandboxService(
bindings=AgentSandboxRepository(session_factory=database_client, apps=apps),
files=AgentSandboxFileGateway(
client_factory=create_sandbox_client,
file_requests=FileRequestService(),
files_url=dify_config.FILES_URL,
),
),
)
@@ -0,0 +1,104 @@
"""Composition of App use cases."""
from dataclasses import dataclass
from sqlalchemy.orm import Session, sessionmaker
from configs import dify_config
from libs.datetime_utils import naive_utc_now
from repositories.account.repository import SQLAlchemyAccountRepository
from repositories.app.api_key_repository import AppApiKeyRepository
from repositories.app.console_repository import ConsoleAppRepository
from repositories.app.dsl_import_repository import DslImportRepository
from repositories.app.enterprise_app_repository import EnterpriseAppRepository
from repositories.app.export_repository import AppExportRepository
from repositories.factory import DifyAPIRepositoryFactory
from repositories.trigger.app_repository import SQLAlchemyAppTriggerRepository
from repositories.workspace.workspace_repository import WorkspaceRepository
from services.agent.roster_package_exporter import RosterAgentPackageExporter
from services.agent.roster_package_importer import RosterAgentPackageImporter
from services.api_token_service import ApiTokenCache
from services.app.api_key_service import AppApiKeyService
from services.app.console_gateway import AppLifecycleGateway, AppTransferGateway, EnterpriseConsoleAppAccess
from services.app.console_service import ConsoleAppService
from services.app.creators_platform_gateway import CreatorsPlatformGateway
from services.app.discovery_gateway import EnterpriseAppDiscoveryAccess
from services.app.enterprise_app_service import EnterpriseAppService
from services.app.export_service import AppExportService
from services.app.import_service import AppImportService
from services.app.query_service import AppDiscoveryService
from services.app_dsl_service import AppDslService
from services.app_package_service import AppPackageService
from services.app_tracing_config_service import AppTracingConfigService
from services.oauth_server_service import OAuthServerService
from services.rbac.members import MemberService
from services.recommended_app_package_service import RecommendedAppPackageService
from services.trigger.app_trigger_store import AppTriggerStore
from services.workflow.dsl_import import DslImportService
@dataclass(frozen=True, slots=True)
class AppServices:
imports: AppImportService
exports: AppExportService
dsl_imports: DslImportService
discovery: AppDiscoveryService
console: ConsoleAppService
enterprise: EnterpriseAppService
triggers: AppTriggerStore
def build_app_services(
*,
database_client: sessionmaker[Session],
oauth: OAuthServerService,
recommended_packages: RecommendedAppPackageService,
repository: ConsoleAppRepository,
rbac_members: MemberService,
tracing_configs: AppTracingConfigService,
) -> AppServices:
transfers = AppTransferGateway(
session_factory=database_client,
dsl_factory=AppDslService,
packages=AppPackageService(),
agent_packages=RosterAgentPackageExporter(),
agent_importer=RosterAgentPackageImporter(),
recommended_packages=recommended_packages,
)
return AppServices(
imports=AppImportService(accounts=SQLAlchemyAccountRepository(database_client), definitions=transfers),
exports=AppExportService(
apps=AppExportRepository(session_factory=database_client), serialize=AppDslService.serialize_export_data
),
dsl_imports=DslImportService(store=DslImportRepository(session_factory=database_client)),
discovery=AppDiscoveryService(
apps=repository,
workspaces=WorkspaceRepository(database_client),
access=EnterpriseAppDiscoveryAccess(),
),
console=ConsoleAppService(
apps=repository,
access=EnterpriseConsoleAppAccess(members=rbac_members),
transfers=transfers,
creators=CreatorsPlatformGateway(oauth=oauth),
tracing=tracing_configs,
lifecycle=AppLifecycleGateway(session_factory=database_client),
),
enterprise=EnterpriseAppService(
apps=EnterpriseAppRepository(
session_factory=database_client,
app_web_url=dify_config.APP_WEB_URL,
service_api_url=dify_config.SERVICE_API_URL,
),
workflow_runs=DifyAPIRepositoryFactory.create_api_workflow_run_repository(session_maker=database_client),
now=naive_utc_now,
),
triggers=SQLAlchemyAppTriggerRepository(session_factory=database_client),
)
def build_app_api_key_service(*, database_client: sessionmaker[Session]) -> AppApiKeyService:
return AppApiKeyService(
keys=AppApiKeyRepository(session_factory=database_client),
cache=ApiTokenCache,
)
@@ -0,0 +1,137 @@
"""Composition root for data-source services and shared credential gateways."""
from collections.abc import Mapping
from dataclasses import dataclass
from sqlalchemy.orm import Session, sessionmaker
from configs import dify_config
from core.datasource.datasource_manager import DatasourceManager
from core.helper.ssrf_proxy import ssrf_proxy
from core.plugin.impl.datasource import PluginDatasourceManager
from core.plugin.impl.oauth import OAuthHandler
from extensions.ext_redis import redis_client
from repositories.data_source.api_key_auth_repository import SQLAlchemyDataSourceApiKeyAuthBindingRepository
from repositories.data_source.credential_repository import SQLAlchemyDatasourceCredentialRepository
from repositories.data_source.oauth_binding_repository import SQLAlchemyDataSourceOAuthBindingRepository
from repositories.knowledge.dataset_repository import SQLAlchemyDatasetRepository
from repositories.knowledge.document_repository import SQLAlchemyDocumentRepository
from services.credentials.redis_refresh_lock import RedisCredentialRefreshLock
from services.data_source.auth.api_key_gateways import (
ProviderApiKeyAuthCredentialValidator,
TenantApiKeyAuthCredentialEncryptor,
)
from services.data_source.auth.api_key_service import DataSourceApiKeyAuthService
from services.data_source.binding_application_service import DataSourceBindingApplicationService
from services.data_source.credential_adapters import (
OAuthDatasourceCredentialRefresher,
PluginDatasourceCredentialCodec,
PluginDatasourceOAuthClientResolver,
)
from services.data_source.credential_gateway import (
ActorAwareDatasourceCredentialGateway,
TrustedStoredDatasourceCredentialGateway,
)
from services.data_source.notion_import_adapters import PluginNotionSourceGateway
from services.data_source.notion_import_application_service import NotionImportApplicationService
from services.data_source.notion_oauth_gateway import NotionDataSourceGateway
from services.data_source.oauth_service import DataSourceOAuthService, InvalidDataSourceOAuthProviderError
from services.data_source.provider_service import DatasourceProviderService
from services.data_source.website_service import WebsiteService
from services.knowledge.dataset_access import DatasetAccessService
@dataclass(frozen=True, slots=True)
class DataSourceServices:
providers: DatasourceProviderService
api_key_auth: DataSourceApiKeyAuthService
oauth: Mapping[str, DataSourceOAuthService]
bindings: DataSourceBindingApplicationService
notion_imports: NotionImportApplicationService
def resolve_oauth(self, provider: str) -> DataSourceOAuthService:
service = self.oauth.get(provider)
if service is None:
raise InvalidDataSourceOAuthProviderError("Invalid provider")
return service
@dataclass(frozen=True, slots=True)
class DataSourceCredentials:
providers: DatasourceProviderService
actor: ActorAwareDatasourceCredentialGateway
stored: TrustedStoredDatasourceCredentialGateway
def build_data_source_credentials(*, database_client: sessionmaker[Session]) -> DataSourceCredentials:
credentials = SQLAlchemyDatasourceCredentialRepository(session_factory=database_client)
provider_manager = PluginDatasourceManager()
codec = PluginDatasourceCredentialCodec(provider_manager=provider_manager)
refresher = OAuthDatasourceCredentialRefresher(
oauth_clients=PluginDatasourceOAuthClientResolver(configs=credentials, provider_manager=provider_manager),
oauth_handler=OAuthHandler(),
)
refresh_lock = RedisCredentialRefreshLock(client=redis_client)
return DataSourceCredentials(
providers=DatasourceProviderService(
credentials=credentials,
codec=codec,
refresher=refresher,
refresh_lock=refresh_lock,
provider_manager=provider_manager,
),
actor=ActorAwareDatasourceCredentialGateway(
credentials=credentials, codec=codec, refresher=refresher, refresh_lock=refresh_lock
),
stored=TrustedStoredDatasourceCredentialGateway(
credentials=credentials, codec=codec, refresher=refresher, refresh_lock=refresh_lock
),
)
def build_data_source_services(
*,
database_client: sessionmaker[Session],
dataset_access: DatasetAccessService,
datasets: SQLAlchemyDatasetRepository,
documents: SQLAlchemyDocumentRepository,
actor_credentials: ActorAwareDatasourceCredentialGateway,
providers: DatasourceProviderService,
) -> DataSourceServices:
oauth_bindings = SQLAlchemyDataSourceOAuthBindingRepository(session_factory=database_client)
notion_gateway = NotionDataSourceGateway(
client_id=dify_config.NOTION_CLIENT_ID or "",
client_secret=dify_config.NOTION_CLIENT_SECRET or "",
redirect_uri=dify_config.CONSOLE_API_URL + "/console/api/oauth/data-source/callback/notion",
http_client=ssrf_proxy,
)
return DataSourceServices(
providers=providers,
api_key_auth=DataSourceApiKeyAuthService(
bindings=SQLAlchemyDataSourceApiKeyAuthBindingRepository(session_factory=database_client),
validator=ProviderApiKeyAuthCredentialValidator(),
encryptor=TenantApiKeyAuthCredentialEncryptor(),
),
oauth={
"notion": DataSourceOAuthService(
provider_name="notion",
provider_gateway=notion_gateway,
bindings=oauth_bindings,
is_internal_provider=dify_config.NOTION_INTEGRATION_TYPE == "internal",
internal_access_token=dify_config.NOTION_INTERNAL_SECRET,
)
},
bindings=DataSourceBindingApplicationService(bindings=oauth_bindings),
notion_imports=NotionImportApplicationService(
dataset_access=dataset_access,
datasets=datasets,
documents=documents,
source=PluginNotionSourceGateway(
credentials=actor_credentials, runtime_loader=DatasourceManager.get_datasource_runtime
),
),
)
def build_website_service(*, database_client: sessionmaker[Session]) -> WebsiteService:
return WebsiteService(providers=build_data_source_credentials(database_client=database_client).providers)
@@ -0,0 +1,32 @@
"""Shared dataset dependencies for knowledge and data-source use cases."""
from dataclasses import dataclass
from sqlalchemy.orm import Session, sessionmaker
from configs import dify_config
from repositories.knowledge.dataset_repository import SQLAlchemyDatasetRepository
from repositories.knowledge.document_repository import SQLAlchemyDocumentRepository
from services.knowledge.dataset_access import DatasetAccessService, WorkspaceRoleReader
@dataclass(frozen=True, slots=True)
class DatasetDependencies:
datasets: SQLAlchemyDatasetRepository
documents: SQLAlchemyDocumentRepository
access: DatasetAccessService
def build_dataset_dependencies(
*, database_client: sessionmaker[Session], workspace_roles: WorkspaceRoleReader
) -> DatasetDependencies:
datasets = SQLAlchemyDatasetRepository(session_factory=database_client)
return DatasetDependencies(
datasets=datasets,
documents=SQLAlchemyDocumentRepository(session_factory=database_client),
access=DatasetAccessService(
datasets=datasets,
workspace_roles=workspace_roles,
legacy_permissions_enabled=not dify_config.RBAC_ENABLED,
),
)
@@ -0,0 +1,60 @@
"""Composition of Installed App use cases."""
from dataclasses import dataclass
from sqlalchemy.orm import Session, sessionmaker
from repositories.installed_app_repository import SQLAlchemyInstalledAppRepository
from services.conversation_command_service import ConversationCommandService
from services.conversation_name_service import ConversationNameService
from services.conversation_query_service import ConversationQueryService
from services.installed_app_access_service import InstalledAppAccessService
from services.installed_app_conversation_service import InstalledAppConversationService
from services.installed_app_generation_adapters import AppGenerateServiceRuntime
from services.installed_app_generation_service import InstalledAppGenerationService
from services.installed_app_service import InstalledAppService, WorkspaceRoleLookup
from services.webapp_access_query_service import WebAppAccessQueryService
@dataclass(frozen=True, slots=True)
class InstalledAppServices:
access: InstalledAppAccessService
management: InstalledAppService
generation: InstalledAppGenerationService
conversations: InstalledAppConversationService
def build_installed_app_services(
*,
database_client: sessionmaker[Session],
conversation_queries: ConversationQueryService,
conversation_names: ConversationNameService,
conversation_commands: ConversationCommandService,
webapp_access: WebAppAccessQueryService,
get_workspace_role: WorkspaceRoleLookup,
webapp_auth_enabled: bool,
) -> InstalledAppServices:
installed_apps = SQLAlchemyInstalledAppRepository(session_factory=database_client)
access = InstalledAppAccessService(
installed_apps=installed_apps,
is_user_allowed=webapp_access.is_user_allowed,
get_access_modes=webapp_access.batch_get_access_modes,
get_user_permissions=webapp_access.batch_get_user_permissions,
)
return InstalledAppServices(
access=access,
management=InstalledAppService(
installed_apps=installed_apps,
get_workspace_role=get_workspace_role,
get_visible_app_ids=access.get_visible_app_ids if webapp_auth_enabled else None,
),
generation=InstalledAppGenerationService(
usage=installed_apps,
runtime=AppGenerateServiceRuntime(session_factory=database_client),
),
conversations=InstalledAppConversationService(
queries=conversation_queries,
names=conversation_names,
commands=conversation_commands,
),
)
@@ -0,0 +1,195 @@
"""Composition root for dataset-controller application services."""
from dataclasses import dataclass
from uuid import uuid4
from sqlalchemy.orm import Session, sessionmaker
from configs import dify_config
from core.app.apps.pipeline.pipeline_generator import PipelineGenerator
from core.rag.extractor.entity.datasource_type import DatasourceType
from libs.helper import generate_text_hash
from repositories.app.console_repository import ConsoleAppRepository
from repositories.knowledge.dataset_api_key_repository import DatasetApiKeyRepository
from repositories.knowledge.dataset_repository import SQLAlchemyDatasetRepository
from repositories.knowledge.document_repository import SQLAlchemyDocumentRepository
from repositories.knowledge.metadata_repository import SQLAlchemyMetadataRepository
from repositories.knowledge.segment_repository import SQLAlchemySegmentRepository
from repositories.knowledge.upload_file_repository import SQLAlchemyKnowledgeUploadRepository
from services.api_token_service import ApiTokenCache, get_effective_token_last_used_at
from services.data_source.credential_gateway import (
ActorAwareDatasourceCredentialGateway,
TrustedStoredDatasourceCredentialGateway,
)
from services.data_source.provider_service import DatasourceProviderService
from services.knowledge.api_key_service import DatasetApiKeyService
from services.knowledge.dataset_access import DatasetAccessService
from services.knowledge.dataset_service import DocumentService
from services.knowledge.datasets.adapters import SQLAlchemyDatasetOperations
from services.knowledge.datasets.application import DatasetApplicationService
from services.knowledge.datasets.upgrades import KnowledgeUpgradeApplicationService
from services.knowledge.document_sync import DocumentSyncApplicationService
from services.knowledge.document_sync_adapters import CeleryDocumentSyncDispatcher
from services.knowledge.documents.adapters import SQLAlchemyDocumentOperations
from services.knowledge.documents.application import DatasetDocumentApplicationService
from services.knowledge.external.adapters import SQLAlchemyExternalKnowledgeOperations
from services.knowledge.external.application import ExternalKnowledgeApplicationService
from services.knowledge.indexing.adapters.estimate import IndexingEstimateAdapter, SQLAlchemyProcessRuleReader
from services.knowledge.indexing.adapters.sources import (
CompositeStoredSourceResolver,
FileSourceAdapter,
NotionSourceResolver,
WebsiteSourceAdapter,
)
from services.knowledge.indexing.estimate import IndexingEstimateApplicationService
from services.knowledge.metadata.application import MetadataService
from services.knowledge.segments.adapters import (
CelerySegmentBatchImportDispatcher,
ModelManagerSegmentGuard,
RedisSegmentClient,
RedisSegmentIndexingState,
)
from services.knowledge.segments.application import DatasetSegmentApplicationService
from services.knowledge.segments.indexing import SegmentIndexingGateway
from services.knowledge_fs.feature_service import get_knowledge_fs_features
from services.rbac.members import MemberService
from services.tag_application_service import TagTargetQuery
from services.workflow_run_agg import WorkflowRunAgg
from tasks.batch_create_segment_to_index_task import batch_create_segment_to_index_task
from tasks.delete_segment_from_index_task import delete_segment_from_index_task
from tasks.disable_segments_from_index_task import disable_segments_from_index_task
from tasks.document_indexing_sync_task import document_indexing_sync_task
from tasks.enable_segments_to_index_task import enable_segments_to_index_task
@dataclass(frozen=True, slots=True)
class KnowledgeServices:
metadata: MetadataService
datasets: DatasetApplicationService
external: ExternalKnowledgeApplicationService
documents: DatasetDocumentApplicationService
document_sync: DocumentSyncApplicationService
indexing_estimates: IndexingEstimateApplicationService
segments: DatasetSegmentApplicationService
pipeline_generator: PipelineGenerator
upgrades: KnowledgeUpgradeApplicationService
def build_dataset_api_key_service(
*, database_client: sessionmaker[Session], dataset_access: DatasetAccessService
) -> DatasetApiKeyService:
return DatasetApiKeyService(
keys=DatasetApiKeyRepository(session_factory=database_client),
cache=ApiTokenCache,
access=dataset_access,
last_used_at=get_effective_token_last_used_at,
rbac_enabled=lambda: dify_config.RBAC_ENABLED,
)
def build_knowledge_services(
*,
database_client: sessionmaker[Session],
dataset_access: DatasetAccessService,
datasets: SQLAlchemyDatasetRepository,
documents: SQLAlchemyDocumentRepository,
actor_credentials: ActorAwareDatasourceCredentialGateway,
stored_credentials: TrustedStoredDatasourceCredentialGateway,
providers: DatasourceProviderService,
redis: RedisSegmentClient,
tags: TagTargetQuery,
rbac_members: MemberService,
) -> KnowledgeServices:
"""Build the dataset-controller knowledge use cases."""
uploads = SQLAlchemyKnowledgeUploadRepository(session_factory=database_client)
notion_sources = NotionSourceResolver(
actor_credentials=actor_credentials,
stored_credentials=stored_credentials,
)
file_sources = FileSourceAdapter(uploads=uploads)
website_sources = WebsiteSourceAdapter()
stored_sources = CompositeStoredSourceResolver(
adapters={
DatasourceType.FILE.value: file_sources,
DatasourceType.NOTION.value: notion_sources,
DatasourceType.WEBSITE.value: website_sources,
}
)
segments = SQLAlchemySegmentRepository(session_factory=database_client)
segment_index = SegmentIndexingGateway(
segments=segments,
uploads=uploads,
redis=redis,
new_session=database_client,
delete_task=delete_segment_from_index_task.delay,
enable_task=enable_segments_to_index_task.delay,
disable_task=disable_segments_from_index_task.delay,
)
dataset_operations = SQLAlchemyDatasetOperations(
session_factory=database_client,
tags=tags,
app_queries=ConsoleAppRepository(session_factory=database_client),
members=rbac_members,
)
return KnowledgeServices(
metadata=MetadataService(
store=SQLAlchemyMetadataRepository(session_factory=database_client), dataset_access=dataset_access
),
datasets=DatasetApplicationService(
dataset_access=dataset_access,
operations=dataset_operations,
rbac_enabled=dify_config.RBAC_ENABLED,
service_api_url=dify_config.SERVICE_API_URL,
vector_store=dify_config.VECTOR_STORE,
tidb_fulltext=dify_config.TIDB_VECTOR_ENABLE_FULLTEXT_SEARCH,
),
external=ExternalKnowledgeApplicationService(
dataset_access=dataset_access,
operations=SQLAlchemyExternalKnowledgeOperations(session_factory=database_client, members=rbac_members),
),
documents=DatasetDocumentApplicationService(
dataset_access=dataset_access,
operations=SQLAlchemyDocumentOperations(session_factory=database_client),
metadata_schema=DocumentService.DOCUMENT_METADATA_SCHEMA,
),
pipeline_generator=PipelineGenerator(
execution_driver=WorkflowRunAgg.run, documents=documents, datasource_providers=providers
),
upgrades=KnowledgeUpgradeApplicationService(
session_factory=database_client,
dataset_access=dataset_access,
datasets=dataset_operations,
rbac_enabled=dify_config.RBAC_ENABLED,
feature_enabled=lambda: get_knowledge_fs_features().enabled,
),
document_sync=DocumentSyncApplicationService(
dataset_access=dataset_access,
documents=documents,
dispatcher=CeleryDocumentSyncDispatcher(delay=document_indexing_sync_task.delay),
),
indexing_estimates=IndexingEstimateApplicationService(
dataset_access=dataset_access,
datasets=datasets,
documents=documents,
files=file_sources,
websites=website_sources,
stored_sources=stored_sources,
notion=notion_sources,
process_rules=SQLAlchemyProcessRuleReader(session_factory=database_client),
runner=IndexingEstimateAdapter(session_factory=database_client),
),
segments=DatasetSegmentApplicationService(
dataset_access=dataset_access,
scopes=datasets,
store=segments,
index=segment_index,
limits=dify_config,
text_hash=generate_text_hash,
uploads=uploads,
model_guard=ModelManagerSegmentGuard(),
indexing_state=RedisSegmentIndexingState(redis),
batch_dispatcher=CelerySegmentBatchImportDispatcher(delay=batch_create_segment_to_index_task.delay),
job_id_factory=lambda: str(uuid4()),
),
)
@@ -0,0 +1,71 @@
"""Compose RBAC use cases with the existing workspace, app and dataset repositories."""
from dataclasses import dataclass
from repositories.app.console_repository import ConsoleAppRepository
from repositories.knowledge.dataset_repository import SQLAlchemyDatasetRepository
from repositories.workspace.workspace_repository import WorkspaceRepository
from services.enterprise import rbac_service as enterprise
from services.rbac.gateways import (
CeleryAccessInitializer,
DeploymentRBACSettings,
EnterpriseResourceAccessClients,
)
from services.rbac.members import MemberService
from services.rbac.policies import PolicyService
from services.rbac.resource_queries import ResourceQueryService
from services.rbac.resources import ResourceAccessService
from services.rbac.roles import RoleService
from services.workspace.member_service import WorkspaceMemberService
@dataclass(frozen=True, slots=True)
class RBACServices:
roles: RoleService
policies: PolicyService
members: MemberService
resources: ResourceAccessService
queries: ResourceQueryService
def build_rbac_services(
*,
workspaces: WorkspaceRepository,
workspace_members: WorkspaceMemberService,
apps: ConsoleAppRepository,
datasets: SQLAlchemyDatasetRepository,
) -> RBACServices:
settings = DeploymentRBACSettings()
return RBACServices(
queries=ResourceQueryService(apps=apps, datasets=datasets),
roles=RoleService(
roles=enterprise.RBACService.KnowledgeFSRoles, catalog=enterprise.RBACService.Catalog, settings=settings
),
policies=PolicyService(
policies=enterprise.RBACService.AccessPolicies, bindings=enterprise.RBACService.AccessPolicyBindings
),
members=MemberService(
members=workspaces,
workspace_roles=workspace_members,
roles=enterprise.RBACService.KnowledgeFSMemberRoles,
permissions=enterprise.RBACService.MyPermissions,
apps=enterprise.RBACService.AppPermissions,
datasets=enterprise.RBACService.DatasetPermissions,
settings=settings,
),
resources=ResourceAccessService(
clients=EnterpriseResourceAccessClients(
apps=enterprise._APP_ACCESS,
datasets=enterprise._DATASET_ACCESS,
agents=enterprise._AGENT_ACCESS,
workspace_apps=enterprise._WORKSPACE_APP_ACCESS,
workspace_datasets=enterprise._WORKSPACE_DATASET_ACCESS,
workspace_agents=enterprise._WORKSPACE_AGENT_ACCESS,
catalogs=enterprise.RBACService.Catalog,
),
members=workspaces,
apps=apps,
datasets=datasets,
initializer=CeleryAccessInitializer(),
),
)
@@ -0,0 +1,18 @@
"""Compose the resource access token service at the application boundary."""
from sqlalchemy.orm import Session, sessionmaker
from repositories.resource_access_token_repository import (
ResourceAccessTokenCleanupRepository,
ResourceAccessTokenRepository,
)
from services.resource_access_token_service import ResourceAccessTokenCleanupService, ResourceAccessTokenService
def build_resource_access_token_service(*, database_client: sessionmaker[Session]) -> ResourceAccessTokenService:
return ResourceAccessTokenService(tokens=ResourceAccessTokenRepository(session_factory=database_client))
def build_resource_access_token_cleanup_service(*, session: Session) -> ResourceAccessTokenCleanupService:
"""Bind cleanup to an existing transaction without taking ownership of its lifetime."""
return ResourceAccessTokenCleanupService(tokens=ResourceAccessTokenCleanupRepository(session=session))
@@ -0,0 +1,35 @@
"""Compose provider-scoped tool credential resolution for workflow execution."""
from collections.abc import Mapping
from configs import dify_config
from core.db.session_factory import get_session_maker
from core.plugin.entities.plugin_daemon import CredentialType
from core.tools.builtin_tool.provider import BuiltinToolProviderController
from core.tools.plugin_tool.provider import PluginToolProviderController
from extensions.ext_redis import redis_client
from models.provider_ids import ToolProviderID
from repositories.credentials.query_repository import CredentialQueryRepository
from services.credentials.redis_refresh_lock import RedisCredentialRefreshLock
from services.credentials.tool_runtime import ToolCredentialService
from services.credentials.tool_runtime_adapters import ProviderToolCredentialRuntime
def resolve_tool_credentials(
*, controller: BuiltinToolProviderController, provider_id: str, workspace_id: str, credential_id: str | None
) -> tuple[Mapping[str, object], CredentialType]:
if isinstance(controller, PluginToolProviderController):
provider = ToolProviderID(provider_id)
providers = (str(provider), provider.provider_name)
else:
providers = (provider_id,)
runtime = ProviderToolCredentialRuntime(
controller=controller, provider_id=provider_id, console_api_url=dify_config.CONSOLE_API_URL
)
service = ToolCredentialService(
credentials=CredentialQueryRepository(session_factory=get_session_maker()),
runtime=runtime,
refresh_lock=RedisCredentialRefreshLock(client=redis_client),
providers=providers,
)
return runtime.resolve(service=service, workspace_id=workspace_id, credential_id=credential_id)
@@ -0,0 +1,109 @@
"""Composition of the trace pipeline, Agent trace collection, and tracing provider configurations."""
from dataclasses import dataclass
from sqlalchemy.orm import Session, sessionmaker
from configs import dify_config
from enterprise.telemetry.exporter import is_enterprise_telemetry_enabled
from repositories.app.tracing_config_repository import SQLAlchemyAppTracingConfigRepository
from repositories.application_trace_repository import ApplicationTraceRepository
from repositories.factory import DifyAPIRepositoryFactory
from repositories.trace_record_repository import TraceRecordRepository
from services.tracing.adapters import (
CeleryExportRetryQueue,
CeleryTraceEmitter,
WorkspaceTracingSecretCipher,
schedule_agent_trace_export,
send_to_enterprise_telemetry,
)
from services.tracing.canonical import CanonicalTraceBuilder
from services.tracing.collection import AgentTraceSettings
from services.tracing.delivery import TraceDeliveryService
from services.tracing.egress import SSRFEgress
from services.tracing.provider_configs import ProviderConfigGateway, TraceProviderCapabilitiesQuery
from services.tracing.providers import ProviderConfigCodec
from services.tracing.registry import EntryPointTraceProviderCatalog
from services.tracing.runtime_bridge import RuntimeApplicationTracingHooks
from services.tracing.scopes import TraceScopes
from services.tracing.service import ApplicationTracingService
@dataclass(frozen=True, slots=True)
class TracingServices:
scopes: TraceScopes
delivery: TraceDeliveryService
agent_traces: ApplicationTracingService
hooks: RuntimeApplicationTracingHooks | None
"""``None`` when the deployment does not collect Agent traces."""
provider_configs: ProviderConfigGateway
provider_capabilities: TraceProviderCapabilitiesQuery
def build_tracing_services(*, database_client: sessionmaker[Session]) -> TracingServices:
egress = SSRFEgress()
providers = EntryPointTraceProviderCatalog()
codec = ProviderConfigCodec(WorkspaceTracingSecretCipher())
builder = CanonicalTraceBuilder()
configs = SQLAlchemyAppTracingConfigRepository(session_factory=database_client)
enterprise_telemetry = is_enterprise_telemetry_enabled()
workflow_runs = DifyAPIRepositoryFactory.create_api_workflow_run_repository(database_client)
node_executions = DifyAPIRepositoryFactory.create_api_workflow_node_execution_repository(database_client)
agent_settings = AgentTraceSettings(
enabled=dify_config.OPS_AGENT_TRACE_ENABLED,
max_spans=dify_config.OPS_AGENT_TRACE_MAX_SPANS,
max_bytes=dify_config.OPS_AGENT_TRACE_MAX_BYTES,
collection_timeout_seconds=dify_config.OPS_AGENT_TRACE_COLLECTION_TIMEOUT,
export_lease_seconds=dify_config.OPS_AGENT_TRACE_EXPORT_LEASE_SECONDS,
max_export_attempts=dify_config.OPS_AGENT_TRACE_MAX_ATTEMPTS,
retention_days=dify_config.OPS_AGENT_TRACE_RETENTION_DAYS,
)
agent_trace_runs = ApplicationTraceRepository(database_client)
agent_traces = ApplicationTracingService(
runs=agent_trace_runs,
run_query=agent_trace_runs,
sources=agent_trace_runs,
# App, workspace, and credential names are enterprise telemetry dimensions only.
records=TraceRecordRepository(
database_client,
workflow_runs=workflow_runs,
node_executions=node_executions,
files_url=dify_config.FILES_URL,
enterprise_details=False,
),
builder=builder,
providers=providers,
codec=codec,
egress=egress,
schedule_export=schedule_agent_trace_export,
settings=agent_settings,
)
return TracingServices(
scopes=TraceScopes(
emitter=CeleryTraceEmitter(), policies=configs, enterprise_enabled=is_enterprise_telemetry_enabled
),
delivery=TraceDeliveryService(
records=TraceRecordRepository(
database_client,
workflow_runs=workflow_runs,
node_executions=node_executions,
files_url=dify_config.FILES_URL,
enterprise_details=enterprise_telemetry,
),
destinations=configs,
providers=providers,
codec=codec,
builder=builder,
egress=egress,
retries=CeleryExportRetryQueue(),
enterprise_sink=send_to_enterprise_telemetry if enterprise_telemetry else None,
collector=agent_traces if agent_settings.enabled else None,
max_export_attempts=dify_config.OPS_TRACE_EXPORT_MAX_ATTEMPTS,
),
agent_traces=agent_traces,
hooks=RuntimeApplicationTracingHooks(agent_traces) if agent_settings.enabled else None,
provider_configs=ProviderConfigGateway(providers=providers, codec=codec, egress=egress),
provider_capabilities=TraceProviderCapabilitiesQuery(
providers=providers, api_collection_enabled=agent_settings.enabled
),
)
@@ -0,0 +1,30 @@
"""Composition of Trial App use cases."""
from dataclasses import dataclass
from sqlalchemy.orm import Session, sessionmaker
from repositories.trial_app_repository import TrialAppRepository
from services.trial_app_access_service import TrialAppAccessService
from services.trial_app_generation_adapters import AppGenerateServiceRuntime
from services.trial_app_generation_service import TrialAppGenerationService
from services.trial_app_usage import TrialAppUsageRecorder
@dataclass(frozen=True, slots=True)
class TrialAppServices:
access: TrialAppAccessService
generation: TrialAppGenerationService
usage: TrialAppUsageRecorder
def build_trial_app_services(
*, database_client: sessionmaker[Session], trial_apps: TrialAppRepository
) -> TrialAppServices:
return TrialAppServices(
access=TrialAppAccessService(apps=trial_apps),
generation=TrialAppGenerationService(
runtime=AppGenerateServiceRuntime(session_factory=database_client), usage=trial_apps
),
usage=trial_apps,
)
@@ -0,0 +1,118 @@
"""Compose workspace use cases with the shared account and workspace repositories."""
from dataclasses import dataclass
from sqlalchemy.orm import Session, sessionmaker
from extensions.ext_redis import RedisClientWrapper
from repositories.account.repository import SQLAlchemyAccountRepository
from repositories.app.console_repository import ConsoleAppRepository
from repositories.knowledge.dataset_repository import SQLAlchemyDatasetRepository
from repositories.workspace.resource_cleanup_repository import WorkspaceResourceCleanupRepository
from repositories.workspace.workspace_repository import WorkspaceRepository
from services.account.adapters import RedisInvitationTokenStore
from services.file_service import FileService
from services.workspace.gateways import (
DeploymentWorkspaceCreationPolicy,
DeploymentWorkspaceFeatureGateway,
DeploymentWorkspaceMemberAccessGateway,
DeploymentWorkspaceMemberRoleResolver,
DeploymentWorkspacePlanGateway,
WorkspaceFileGateway,
WorkspaceIdentityGateway,
WorkspaceInvitationGateway,
WorkspaceOwnerTransferGateway,
WorkspaceProvisioningEffectsGateway,
)
from services.workspace.member_service import (
InvitedAccountRegistration,
WorkspaceInvitationService,
WorkspaceMemberQueryService,
WorkspaceMemberService,
WorkspaceOwnerTransferService,
)
from services.workspace.provisioning_service import WorkspaceProvisioningService
from services.workspace.resource_cleanup_service import WorkspaceResourceCleanupService
from services.workspace.service import WorkspaceQueryService, WorkspaceService
@dataclass(frozen=True, slots=True)
class WorkspaceServices:
queries: WorkspaceQueryService
management: WorkspaceService
provisioning: WorkspaceProvisioningService
members: WorkspaceMemberService
member_queries: WorkspaceMemberQueryService
owner_transfer: WorkspaceOwnerTransferService
invitations: WorkspaceInvitationService
identity: WorkspaceIdentityGateway
resource_cleanup: WorkspaceResourceCleanupService
def build_workspace_membership_services(
*,
workspaces: WorkspaceRepository,
accounts: SQLAlchemyAccountRepository,
) -> tuple[WorkspaceMemberService, WorkspaceProvisioningService]:
"""Build the workspace prerequisites shared by account registration and invitations."""
members = WorkspaceMemberService(
workspaces=workspaces,
accounts=accounts,
access=DeploymentWorkspaceMemberAccessGateway(),
)
provisioning = WorkspaceProvisioningService(
owners=accounts,
provisioning=workspaces,
effects=WorkspaceProvisioningEffectsGateway(),
policies=DeploymentWorkspaceCreationPolicy(),
memberships=workspaces,
members=members,
)
return members, provisioning
def build_workspace_services(
*,
database_client: sessionmaker[Session],
workspaces: WorkspaceRepository,
accounts: SQLAlchemyAccountRepository,
files: FileService,
redis: RedisClientWrapper,
members: WorkspaceMemberService,
provisioning: WorkspaceProvisioningService,
registration: InvitedAccountRegistration,
invitation_tokens: RedisInvitationTokenStore,
) -> WorkspaceServices:
return WorkspaceServices(
queries=WorkspaceQueryService(workspaces=workspaces, plans=DeploymentWorkspacePlanGateway()),
management=WorkspaceService(
workspaces=workspaces,
features=DeploymentWorkspaceFeatureGateway(),
logos=WorkspaceFileGateway(files=files),
),
provisioning=provisioning,
members=members,
member_queries=WorkspaceMemberQueryService(
members=workspaces,
roles=DeploymentWorkspaceMemberRoleResolver(),
),
owner_transfer=WorkspaceOwnerTransferService(
accounts=accounts,
workspaces=workspaces,
members=members,
challenges=WorkspaceOwnerTransferGateway(redis=redis),
),
invitations=WorkspaceInvitationService(
accounts=registration,
workspaces=workspaces,
members=members,
invitations=WorkspaceInvitationGateway(tokens=invitation_tokens, redis=redis),
),
identity=WorkspaceIdentityGateway(workspaces=workspaces),
resource_cleanup=WorkspaceResourceCleanupService(
session_factory=database_client,
apps=ConsoleAppRepository(session_factory=database_client),
datasets=SQLAlchemyDatasetRepository(session_factory=database_client),
agent_resources=WorkspaceResourceCleanupRepository(session_factory=database_client),
),
)