Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

9.9 KB
Raw Blame
import { Channel, invoke } from "@tauri-apps/api/core";
import type {
  NacosBatchPreview,
  NacosBatchReport,
  NacosConfigSelector,
  NacosConfigTransferRequest,
  NacosConflictPolicy,
  NacosContentSearchRequest,
  NacosContentSearchResult,
  NacosConfigHistoryKey,
  NacosConfigHistoryList,
  NacosConfigHistoryQuery,
  NacosConfigItem,
  NacosConfigKey,
  NacosConfigList,
  NacosConfigQuery,
  NacosConfigRollbackRequest,
  NacosConfigUpsert,
  NacosConnectionInfo,
  NacosDashboardQuery,
  NacosDashboardSnapshot,
  NacosRNacosConsoleCaptcha,
  NacosUserQuery,
  NacosUserList,
  NacosUserCreate,
  NacosUserUpdate,
  NacosRoleQuery,
  NacosRoleList,
  NacosRoleBinding,
  NacosAccessControlSnapshot,
  NacosAccessOperationRequest,
  NacosAccessOperationResult,
  NacosAccessOperationRetry,
  NacosInstanceInfo,
  NacosInstanceRef,
  NacosInstanceRegistration,
  NacosInstanceQuery,
  NacosInstanceUpdateRequest,
  NacosNamespaceCreate,
  NacosNamespaceInfo,
  NacosNamespaceSidebarSnapshot,
  NacosNamespaceUpdate,
  NacosRawRequest,
  NacosRawResponse,
  NacosServiceList,
  NacosServiceDetail,
  NacosServiceQuery,
  NacosServiceUpsert,
  NacosSearchProgress,
} from "@/types/nacos";

export async function nacosTestConnection(connectionId: string, forceRefresh = false): Promise<NacosConnectionInfo> {
  return invoke("nacos_test_connection", { connectionId, forceRefresh });
}

export async function nacosListNamespaces(connectionId: string): Promise<NacosNamespaceInfo[]> {
  return invoke("nacos_list_namespaces", { connectionId });
}

export async function nacosSidebarSnapshot(connectionId: string): Promise<NacosNamespaceSidebarSnapshot> {
  return invoke("nacos_sidebar_snapshot", { connectionId });
}

export async function nacosCreateNamespace(connectionId: string, req: NacosNamespaceCreate): Promise<void> {
  return invoke("nacos_create_namespace", { connectionId, req });
}

export async function nacosUpdateNamespace(connectionId: string, req: NacosNamespaceUpdate): Promise<void> {
  return invoke("nacos_update_namespace", { connectionId, req });
}

export async function nacosDeleteNamespace(connectionId: string, namespaceId: string): Promise<void> {
  return invoke("nacos_delete_namespace", { connectionId, namespaceId });
}

export async function nacosListConfigs(connectionId: string, query: NacosConfigQuery): Promise<NacosConfigList> {
  return invoke("nacos_list_configs", { connectionId, query });
}

export async function nacosGetConfig(connectionId: string, key: NacosConfigKey): Promise<NacosConfigItem> {
  return invoke("nacos_get_config", { connectionId, key });
}

export async function nacosPublishConfig(connectionId: string, req: NacosConfigUpsert): Promise<void> {
  return invoke("nacos_publish_config", { connectionId, req });
}

export async function nacosDeleteConfig(connectionId: string, key: NacosConfigKey): Promise<void> {
  return invoke("nacos_delete_config", { connectionId, key });
}

export async function nacosSearchConfigContent(connectionId: string, req: NacosContentSearchRequest, onProgress?: (progress: NacosSearchProgress) => void): Promise<NacosContentSearchResult> {
  const channel = new Channel<NacosSearchProgress>();
  channel.onmessage = (progress) => onProgress?.(progress);
  return invoke("nacos_search_config_content", { connectionId, req, onProgress: channel });
}

export async function nacosCancelConfigContentSearch(operationId: string): Promise<boolean> {
  return invoke("nacos_cancel_operation", { operationId });
}

export async function nacosExportConfigs(connectionId: string, selector: NacosConfigSelector, destination: string, _fileName?: string): Promise<void> {
  return invoke("nacos_export_configs", { connectionId, selector, destination });
}

export async function nacosPreviewConfigImport(connectionId: string, targetNamespace: string, archivePath: string | File): Promise<NacosBatchPreview> {
  if (typeof archivePath !== "string") throw new Error("Desktop Nacos ZIP import requires a local file path");
  return invoke("nacos_preview_config_import", { connectionId, targetNamespace, archivePath });
}

export async function nacosApplyConfigImport(connectionId: string, operationId: string, targetNamespace: string, archivePath: string | File, planHash: string, conflictPolicy: NacosConflictPolicy, _archiveToken?: string): Promise<NacosBatchReport> {
  if (typeof archivePath !== "string") throw new Error("Desktop Nacos ZIP import requires a local file path");
  return invoke("nacos_apply_config_import", { connectionId, operationId, targetNamespace, archivePath, planHash, conflictPolicy });
}

export async function nacosPreviewConfigTransfer(req: NacosConfigTransferRequest): Promise<NacosBatchPreview> {
  return invoke("nacos_preview_config_transfer", { req });
}

export async function nacosApplyConfigTransfer(req: NacosConfigTransferRequest, planHash: string): Promise<NacosBatchReport> {
  return invoke("nacos_apply_config_transfer", { req, planHash });
}

export async function nacosListConfigHistory(connectionId: string, query: NacosConfigHistoryQuery): Promise<NacosConfigHistoryList> {
  return invoke("nacos_list_config_history", { connectionId, query });
}

export async function nacosGetConfigHistory(connectionId: string, key: NacosConfigHistoryKey): Promise<NacosConfigItem> {
  return invoke("nacos_get_config_history", { connectionId, key });
}

export async function nacosRollbackConfig(connectionId: string, req: NacosConfigRollbackRequest): Promise<void> {
  return invoke("nacos_rollback_config", { connectionId, req });
}

export async function nacosGetRNacosConsoleCaptcha(connectionId: string): Promise<NacosRNacosConsoleCaptcha> {
  return invoke("nacos_get_rnacos_console_captcha", { connectionId });
}

export async function nacosLoginRNacosConsole(connectionId: string, captcha?: string): Promise<void> {
  return invoke("nacos_login_rnacos_console", { connectionId, captcha });
}

export async function nacosListUsers(connectionId: string, query: NacosUserQuery): Promise<NacosUserList> {
  return invoke("nacos_list_users", { connectionId, query });
}

export async function nacosCreateUser(connectionId: string, req: NacosUserCreate): Promise<void> {
  return invoke("nacos_create_user", { connectionId, req });
}

export async function nacosUpdateUser(connectionId: string, req: NacosUserUpdate): Promise<void> {
  return invoke("nacos_update_user", { connectionId, req });
}

export async function nacosDeleteUser(connectionId: string, username: string): Promise<void> {
  return invoke("nacos_delete_user", { connectionId, username });
}

export async function nacosListRoleBindings(connectionId: string, query: NacosRoleQuery): Promise<NacosRoleList> {
  return invoke("nacos_list_role_bindings", { connectionId, query });
}

export async function nacosAssignRole(connectionId: string, binding: NacosRoleBinding): Promise<void> {
  return invoke("nacos_assign_role", { connectionId, binding });
}

export async function nacosRemoveRole(connectionId: string, binding: NacosRoleBinding): Promise<void> {
  return invoke("nacos_remove_role", { connectionId, binding });
}

export async function nacosAccessSnapshot(connectionId: string): Promise<NacosAccessControlSnapshot> {
  return invoke("nacos_access_snapshot", { connectionId });
}

export async function nacosStartAccessOperation(connectionId: string, req: NacosAccessOperationRequest): Promise<NacosAccessOperationResult> {
  return invoke("nacos_start_access_operation", { connectionId, req });
}

export async function nacosGetAccessOperation(connectionId: string, operationId: string): Promise<NacosAccessOperationResult> {
  return invoke("nacos_get_access_operation", { connectionId, operationId });
}

export async function nacosRetryAccessOperation(connectionId: string, retry: NacosAccessOperationRetry): Promise<NacosAccessOperationResult> {
  return invoke("nacos_retry_access_operation", { connectionId, retry });
}

export async function nacosUndoAccessOperation(connectionId: string, operationId: string): Promise<NacosAccessOperationResult> {
  return invoke("nacos_undo_access_operation", { connectionId, operationId });
}

export async function nacosListServices(connectionId: string, query: NacosServiceQuery): Promise<NacosServiceList> {
  return invoke("nacos_list_services", { connectionId, query });
}

export async function nacosGetService(connectionId: string, query: NacosServiceQuery): Promise<NacosServiceDetail> {
  return invoke("nacos_get_service", { connectionId, query });
}

export async function nacosCreateService(connectionId: string, req: NacosServiceUpsert): Promise<void> {
  return invoke("nacos_create_service", { connectionId, req });
}

export async function nacosUpdateService(connectionId: string, req: NacosServiceUpsert): Promise<void> {
  return invoke("nacos_update_service", { connectionId, req });
}

export async function nacosDeleteService(connectionId: string, query: NacosServiceQuery): Promise<void> {
  return invoke("nacos_delete_service", { connectionId, query });
}

export async function nacosListInstances(connectionId: string, query: NacosInstanceQuery): Promise<NacosInstanceInfo[]> {
  return invoke("nacos_list_instances", { connectionId, query });
}

export async function nacosUpdateInstance(connectionId: string, req: NacosInstanceUpdateRequest): Promise<void> {
  return invoke("nacos_update_instance", { connectionId, req });
}

export async function nacosRegisterInstance(connectionId: string, req: NacosInstanceRegistration): Promise<void> {
  return invoke("nacos_register_instance", { connectionId, req });
}

export async function nacosDeregisterInstance(connectionId: string, req: NacosInstanceRef): Promise<void> {
  return invoke("nacos_deregister_instance", { connectionId, req });
}

export async function nacosGetDashboard(connectionId: string, query: NacosDashboardQuery): Promise<NacosDashboardSnapshot> {
  return invoke("nacos_get_dashboard", { connectionId, query });
}

export async function nacosRawRequest(connectionId: string, req: NacosRawRequest): Promise<NacosRawResponse> {
  return invoke("nacos_raw_request", { connectionId, req });
}