refactor(desktop): organize lib modules by domain

This commit is contained in:
t8y2 committed 2026-07-04 13:53:52 +08:00
1 parent 90f0594e93
commit 7e7c4944e9
700 files changed
+1292 -1264

No files matched your search

+504
View File
@@ -0,0 +1,504 @@
import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
import type * as TauriModule from "@/lib/backend/tauri";
import { appendDebugLog } from "@/lib/backend/debugLog";
// ---------------------------------------------------------------------------
// Lazy backend resolution (avoids top-level await)
// ---------------------------------------------------------------------------
type Backend = typeof TauriModule;
let _backend: Backend | null = null;
async function getBackend(): Promise<Backend> {
if (_backend) return _backend;
_backend = isTauriRuntime(globalThis) ? await import("@/lib/backend/tauri") : await import("@/lib/backend/http");
return _backend;
}
// ---------------------------------------------------------------------------
// Helper: create a forwarding function that lazily resolves the backend
// ---------------------------------------------------------------------------
function forward<K extends keyof Backend>(name: K): Backend[K] {
return (async (...args: unknown[]) => {
const startedAt = performance.now();
const operation = String(name);
appendDebugLog("debug", "[DBX][api:start]", operation);
const b = await getBackend();
try {
const result = await (b[name] as (...a: unknown[]) => unknown)(...args);
appendDebugLog("debug", "[DBX][api:success]", {
operation,
elapsedMs: Math.round(performance.now() - startedAt),
});
return result;
} catch (error) {
appendDebugLog("error", "[DBX][api:error]", {
operation,
elapsedMs: Math.round(performance.now() - startedAt),
error,
});
throw error;
}
}) as unknown as Backend[K];
}
// ---------------------------------------------------------------------------
// Re-export all functions via lazy forwarding
// ---------------------------------------------------------------------------
// Connection
export const testConnection = forward("testConnection");
export const connectDb = forward("connectDb");
export const connectionFinalProxyPort = forward("connectionFinalProxyPort");
export const disconnectDb = forward("disconnectDb");
export const checkConnectionHealth = forward("checkConnectionHealth");
export const closeDatabaseConnection = forward("closeDatabaseConnection");
export const refreshConnections = forward("refreshConnections");
export const saveConnections = forward("saveConnections");
export const loadConnections = forward("loadConnections");
export const readKeychainPassword = forward("readKeychainPassword");
export const readKeychainPasswords = forward("readKeychainPasswords");
export const decryptConfig = forward("decryptConfig");
export const listPlugins = forward("listPlugins");
export const listJdbcDrivers = forward("listJdbcDrivers");
export const listJdbcMavenBundles = forward("listJdbcMavenBundles");
export const importJdbcDrivers = forward("importJdbcDrivers");
export const installJdbcDriverFromMaven = forward("installJdbcDriverFromMaven");
export const installPrestoSqlJdbcDriver = forward("installPrestoSqlJdbcDriver");
export const deleteJdbcDriver = forward("deleteJdbcDriver");
export const deleteJdbcMavenBundle = forward("deleteJdbcMavenBundle");
export const jdbcPluginStatus = forward("jdbcPluginStatus");
export const installJdbcPlugin = forward("installJdbcPlugin");
export const installJdbcPluginLocal = forward("installJdbcPluginLocal");
export const uninstallJdbcPlugin = forward("uninstallJdbcPlugin");
export const listInstalledAgentsLocal = forward("listInstalledAgentsLocal");
export const listInstalledAgents = forward("listInstalledAgents");
export const getDriverStoreUsage = forward("getDriverStoreUsage");
export const getDriverRuntimeSummary = forward("getDriverRuntimeSummary");
export const stopDriverRuntime = forward("stopDriverRuntime");
export const restartDriverRuntime = forward("restartDriverRuntime");
export const installAgent = forward("installAgent");
export const upgradeAllAgents = forward("upgradeAllAgents");
export const checkAgentUpdateBlockers = forward("checkAgentUpdateBlockers");
export const uninstallAgent = forward("uninstallAgent");
export const getAgentJavaRuntimeConfig = forward("getAgentJavaRuntimeConfig");
export const setAgentJavaRuntimeConfig = forward("setAgentJavaRuntimeConfig");
export const invalidateAgentRegistryCache = forward("invalidateAgentRegistryCache");
export const importAgentsFromZip = forward("importAgentsFromZip");
export const importAgentJar = forward("importAgentJar");
export const reinstallJre = forward("reinstallJre");
export const uninstallJre = forward("uninstallJre");
export const listenAgentInstallProgress = forward("listenAgentInstallProgress");
export const loadSavedSqlLibrary = forward("loadSavedSqlLibrary");
export const loadSavedSqlFile = forward("loadSavedSqlFile");
export const saveSavedSqlFolder = forward("saveSavedSqlFolder");
export const deleteSavedSqlFolder = forward("deleteSavedSqlFolder");
export const saveSavedSqlFile = forward("saveSavedSqlFile");
export const deleteSavedSqlFile = forward("deleteSavedSqlFile");
export const savedSqlStorageDir = forward("savedSqlStorageDir");
export const openSavedSqlStorageDir = forward("openSavedSqlStorageDir");
export const revealPathInFileManager = forward("revealPathInFileManager");
export const isSqliteDatabaseFile = forward("isSqliteDatabaseFile");
export const backupSqliteDatabase = forward("backupSqliteDatabase");
export const syncSavedSqlDirectory = forward("syncSavedSqlDirectory");
// Schema
export const listDatabases = forward("listDatabases");
export const listSqlServerLinkedServers = forward("listSqlServerLinkedServers");
export const listSqlServerLinkedServerCatalogs = forward("listSqlServerLinkedServerCatalogs");
export const listSqlServerLinkedServerSchemas = forward("listSqlServerLinkedServerSchemas");
export const listSqlServerLinkedServerTables = forward("listSqlServerLinkedServerTables");
export const saveSchemaCache = forward("saveSchemaCache");
export const loadSchemaCache = forward("loadSchemaCache");
export const deleteSchemaCachePrefix = forward("deleteSchemaCachePrefix");
export const listSchemas = forward("listSchemas");
export const listSchemaInfos = forward("listSchemaInfos");
export const listTables = forward("listTables");
export const getTableComment = forward("getTableComment");
export const listObjects = forward("listObjects");
export const listObjectStatistics = forward("listObjectStatistics");
export const listCompletionObjects = forward("listCompletionObjects");
export const completionAssistantSearch = forward("completionAssistantSearch");
export const getObjectSource = forward("getObjectSource");
export const getColumns = forward("getColumns");
export const listDataTypes = forward("listDataTypes");
export const listIndexes = forward("listIndexes");
export const listForeignKeys = forward("listForeignKeys");
export const listTriggers = forward("listTriggers");
export const getTableDdl = forward("getTableDdl");
export const listFunctions = forward("listFunctions");
export const listSequences = forward("listSequences");
export const listRules = forward("listRules");
export const listOwners = forward("listOwners");
export const prepareSchemaDiff = forward("prepareSchemaDiff");
export const generateSchemaSyncSql = forward("generateSchemaSyncSql");
// Query
export const executeQuery = forward("executeQuery");
export const executeMulti = forward("executeMulti");
export const executeBatch = forward("executeBatch");
export const executeScript = forward("executeScript");
export const executeInTransaction = forward("executeInTransaction");
export const beginManualTransaction = forward("beginManualTransaction");
export const executeInManualTransaction = forward("executeInManualTransaction");
export const commitManualTransaction = forward("commitManualTransaction");
export const rollbackManualTransaction = forward("rollbackManualTransaction");
export const cancelQuery = forward("cancelQuery");
export const closeQuerySession = forward("closeQuerySession");
export const closeClientConnectionSession = forward("closeClientConnectionSession");
export const analyzeSqlReferences = forward("analyzeSqlReferences");
export const findStatementAtCursor = forward("findStatementAtCursor");
export const prepareQueryPaginationExecutionPlan = forward("prepareQueryPaginationExecutionPlan");
export const buildSortedQuerySql = forward("buildSortedQuerySql");
export const buildExplainSql = forward("buildExplainSql");
export const getExplainInfo = forward("getExplainInfo");
export const buildCreateUserSql = forward("buildCreateUserSql");
export const buildDroppedFilePreviewSql = forward("buildDroppedFilePreviewSql");
export const buildTableSelectSql = forward("buildTableSelectSql");
export const buildDatabaseSearchSql = forward("buildDatabaseSearchSql");
export const buildSearchResultWhere = forward("buildSearchResultWhere");
export const buildRenameObjectSql = forward("buildRenameObjectSql");
export const buildCreateDatabaseSql = forward("buildCreateDatabaseSql");
export const buildDuckDbAttachDatabaseSql = forward("buildDuckDbAttachDatabaseSql");
export const buildDropObjectSql = forward("buildDropObjectSql");
export const buildDropTableSql = forward("buildDropTableSql");
export const buildDropTableChildObjectSql = forward("buildDropTableChildObjectSql");
export const buildEmptyTableSql = forward("buildEmptyTableSql");
export const buildTruncateTableSql = forward("buildTruncateTableSql");
export const buildDropDatabaseSql = forward("buildDropDatabaseSql");
export const buildCreateSchemaSql = forward("buildCreateSchemaSql");
export const buildDropSchemaSql = forward("buildDropSchemaSql");
export const buildDuplicateTableStructureSql = forward("buildDuplicateTableStructureSql");
export const buildCopyTableDataSql = forward("buildCopyTableDataSql");
export const buildExecutableObjectSourceStatements = forward("buildExecutableObjectSourceStatements");
export const buildExecutableObjectSourceSql = forward("buildExecutableObjectSourceSql");
export const buildEditableObjectSource = forward("buildEditableObjectSource");
export const buildRoutineRenameObjectSourceStatements = forward("buildRoutineRenameObjectSourceStatements");
export const buildViewDdlSql = forward("buildViewDdlSql");
export const buildTableStructureChangeSql = forward("buildTableStructureChangeSql");
export const buildCreateTableSql = forward("buildCreateTableSql");
export const buildSingleColumnAlterSql = forward("buildSingleColumnAlterSql");
export const analyzeEditableQueryEditability = forward("analyzeEditableQueryEditability");
export const prepareDataGridSave = forward("prepareDataGridSave");
export const buildDataGridCopyUpdateStatements = forward("buildDataGridCopyUpdateStatements");
export const buildDataGridCopyInsertStatement = forward("buildDataGridCopyInsertStatement");
export const buildDataGridContextFilterCondition = forward("buildDataGridContextFilterCondition");
export const buildDataGridColumnValueFilterCondition = forward("buildDataGridColumnValueFilterCondition");
export const buildDataGridColumnValuesFilterCondition = forward("buildDataGridColumnValuesFilterCondition");
export const buildDataGridColumnDistinctValuesSql = forward("buildDataGridColumnDistinctValuesSql");
export const buildDataGridCountSql = forward("buildDataGridCountSql");
export const buildHiveTablePropertiesSql = forward("buildHiveTablePropertiesSql");
export const buildExportInsertStatements = forward("buildExportInsertStatements");
export const buildExportSqlInsert = forward("buildExportSqlInsert");
export const buildDatabaseSqlExport = forward("buildDatabaseSqlExport");
export const prepareDataCompare = forward("prepareDataCompare");
export const prepareDataCompareFromTables = forward("prepareDataCompareFromTables");
export const prepareDataCompareMissingTarget = forward("prepareDataCompareMissingTarget");
export const buildDataCompareSyncPlan = forward("buildDataCompareSyncPlan");
// AI
export const aiComplete = forward("aiComplete");
export const aiStream = forward("aiStream");
export const aiAgentStream = forward("aiAgentStream");
export const aiCancelStream = forward("aiCancelStream");
export const aiTestConnection = forward("aiTestConnection");
export const aiListModels = forward("aiListModels");
export const saveAiConfig = forward("saveAiConfig");
export const loadAiConfig = forward("loadAiConfig");
export const saveAiProviderConfig = forward("saveAiProviderConfig");
export const loadAiProviderConfigs = forward("loadAiProviderConfigs");
export const loadDesktopSettings = forward("loadDesktopSettings");
export const saveDesktopSettings = forward("saveDesktopSettings");
export const completeAppClose = forward("completeAppClose");
export const requestAppClose = forward("requestAppClose");
export const setDriverStoreDir = forward("setDriverStoreDir");
export const setPluginStoreDir = forward("setPluginStoreDir");
export const setAgentStoreDir = forward("setAgentStoreDir");
export const getDriverStorePath = forward("getDriverStorePath");
export const loadPinnedTreeNodeIds = forward("loadPinnedTreeNodeIds");
export const savePinnedTreeNodeIds = forward("savePinnedTreeNodeIds");
export const webdavSyncTest = forward("webdavSyncTest");
export const webdavPasswordStatus = forward("webdavPasswordStatus");
export const saveWebdavSavedPassword = forward("saveWebdavSavedPassword");
export const forgetWebdavSavedPassword = forward("forgetWebdavSavedPassword");
export const webdavSyncUpload = forward("webdavSyncUpload");
export const webdavSyncDownload = forward("webdavSyncDownload");
export const saveAiConversation = forward("saveAiConversation");
export const loadAiConversations = forward("loadAiConversations");
export const deleteAiConversation = forward("deleteAiConversation");
// System
export const listSystemFonts = forward("listSystemFonts");
// SQL File Execution
export const previewSqlFile = forward("previewSqlFile");
export const executeSqlFile = forward("executeSqlFile");
export const cancelSqlFileExecution = forward("cancelSqlFileExecution");
export const listenSqlFileProgress = forward("listenSqlFileProgress");
export const pendingOpenSqlFiles = forward("pendingOpenSqlFiles");
export const pendingOpenDbFiles = forward("pendingOpenDbFiles");
export const pendingOpenConnectionLinks = forward("pendingOpenConnectionLinks");
export const readExternalSqlFile = forward("readExternalSqlFile");
export const writeExternalSqlFile = forward("writeExternalSqlFile");
// Nacos
export const nacosTestConnection = forward("nacosTestConnection");
export const nacosListNamespaces = forward("nacosListNamespaces");
export const nacosCreateNamespace = forward("nacosCreateNamespace");
export const nacosUpdateNamespace = forward("nacosUpdateNamespace");
export const nacosListConfigs = forward("nacosListConfigs");
export const nacosGetConfig = forward("nacosGetConfig");
export const nacosPublishConfig = forward("nacosPublishConfig");
export const nacosDeleteConfig = forward("nacosDeleteConfig");
export const nacosListConfigHistory = forward("nacosListConfigHistory");
export const nacosGetConfigHistory = forward("nacosGetConfigHistory");
export const nacosRollbackConfig = forward("nacosRollbackConfig");
export const nacosListServices = forward("nacosListServices");
export const nacosListInstances = forward("nacosListInstances");
export const nacosUpdateInstance = forward("nacosUpdateInstance");
export const nacosRawRequest = forward("nacosRawRequest");
// Data Transfer
export const startTransfer = forward("startTransfer");
export const cancelTransfer = forward("cancelTransfer");
export const sortTablesByFkDependency = forward("sortTablesByFkDependency");
// Table File Import
export const previewTableImportFile = forward("previewTableImportFile");
export const importTableFile = forward("importTableFile");
export const cancelTableImport = forward("cancelTableImport");
// Database Export
export const exportDatabaseSql = forward("exportDatabaseSql");
export const cancelDatabaseExport = forward("cancelDatabaseExport");
export const exportQueryResultCsv = forward("exportQueryResultCsv");
export const exportTableDataCsv = forward("exportTableDataCsv");
export const exportQueryResultXlsx = forward("exportQueryResultXlsx");
export const exportQueryResultsXlsx = forward("exportQueryResultsXlsx");
export const exportQueryResultJson = forward("exportQueryResultJson");
export const exportQueryResultMarkdown = forward("exportQueryResultMarkdown");
export const startTableExport = forward("startTableExport");
export const cancelTableExport = forward("cancelTableExport");
export const startQueryResultExport = forward("startQueryResultExport");
export const cancelQueryResultExport = forward("cancelQueryResultExport");
// Redis
export const redisListDatabases = forward("redisListDatabases");
export const redisScanKeys = forward("redisScanKeys");
export const redisScanKeysBatch = forward("redisScanKeysBatch");
export const redisScanValues = forward("redisScanValues");
export const redisGetValue = forward("redisGetValue");
export const redisSetString = forward("redisSetString");
export const redisDeleteKey = forward("redisDeleteKey");
export const redisHashSet = forward("redisHashSet");
export const redisHashDel = forward("redisHashDel");
export const redisListPush = forward("redisListPush");
export const redisListSet = forward("redisListSet");
export const redisListRemove = forward("redisListRemove");
export const redisSetAdd = forward("redisSetAdd");
export const redisSetRemove = forward("redisSetRemove");
export const redisZadd = forward("redisZadd");
export const redisZrem = forward("redisZrem");
export const redisStreamAdd = forward("redisStreamAdd");
export const redisJsonSet = forward("redisJsonSet");
export const redisCheckJsonModule = forward("redisCheckJsonModule");
export const redisSetTtl = forward("redisSetTtl");
export const redisDeleteKeys = forward("redisDeleteKeys");
export const redisFlushDb = forward("redisFlushDb");
export const redisExecuteCommand = forward("redisExecuteCommand");
export const redisLoadMore = forward("redisLoadMore");
export const redisPubSubPublish = forward("redisPubSubPublish");
export const redisPubSubConnect = forward("redisPubSubConnect");
export const redisSlowlogGet = forward("redisSlowlogGet");
export const redisClusterMasterNodes = forward("redisClusterMasterNodes");
// etcd
export const etcdListPrefix = forward("etcdListPrefix");
export const etcdGet = forward("etcdGet");
export const etcdPut = forward("etcdPut");
export const etcdDelete = forward("etcdDelete");
// ZooKeeper
export const zookeeperListPrefix = forward("zookeeperListPrefix");
export const zookeeperGet = forward("zookeeperGet");
export const zookeeperPut = forward("zookeeperPut");
export const zookeeperDelete = forward("zookeeperDelete");
// Message Queue
export const mqTestConnection = forward("mqTestConnection");
export const mqListTenants = forward("mqListTenants");
export const mqGetTenant = forward("mqGetTenant");
export const mqCreateTenant = forward("mqCreateTenant");
export const mqUpdateTenant = forward("mqUpdateTenant");
export const mqDeleteTenant = forward("mqDeleteTenant");
export const mqListNamespaces = forward("mqListNamespaces");
export const mqCreateNamespace = forward("mqCreateNamespace");
export const mqDeleteNamespace = forward("mqDeleteNamespace");
export const mqGetNamespacePolicies = forward("mqGetNamespacePolicies");
export const mqListTopics = forward("mqListTopics");
export const mqCreateTopic = forward("mqCreateTopic");
export const mqDeleteTopic = forward("mqDeleteTopic");
export const mqUpdatePartitions = forward("mqUpdatePartitions");
export const mqGetTopicStats = forward("mqGetTopicStats");
export const mqGetTopicInternalStats = forward("mqGetTopicInternalStats");
export const mqListSubscriptions = forward("mqListSubscriptions");
export const mqCreateSubscription = forward("mqCreateSubscription");
export const mqDeleteSubscription = forward("mqDeleteSubscription");
export const mqSkipMessages = forward("mqSkipMessages");
export const mqResetCursor = forward("mqResetCursor");
export const mqClearBacklog = forward("mqClearBacklog");
export const mqPeekMessages = forward("mqPeekMessages");
export const mqExpireMessages = forward("mqExpireMessages");
export const mqListProducers = forward("mqListProducers");
export const mqListConsumers = forward("mqListConsumers");
export const mqUnloadTopic = forward("mqUnloadTopic");
export const mqSetPublishRate = forward("mqSetPublishRate");
export const mqSetDispatchRate = forward("mqSetDispatchRate");
export const mqSetSubscribeRate = forward("mqSetSubscribeRate");
export const mqSetBacklogQuota = forward("mqSetBacklogQuota");
export const mqSetRetention = forward("mqSetRetention");
export const mqGetEffectivePolicies = forward("mqGetEffectivePolicies");
export const mqGrantPermission = forward("mqGrantPermission");
export const mqRevokePermission = forward("mqRevokePermission");
export const mqListPermissions = forward("mqListPermissions");
export const mqIssueToken = forward("mqIssueToken");
export const mqListTokenRecords = forward("mqListTokenRecords");
export const mqGetBacklog = forward("mqGetBacklog");
export const mqGetClusterInfo = forward("mqGetClusterInfo");
export const mqRawRequest = forward("mqRawRequest");
export const mqSendMessage = forward("mqSendMessage");
// MongoDB
export const documentListDatabases = forward("documentListDatabases");
export const mongoListDatabases = forward("mongoListDatabases");
export const documentListCollections = forward("documentListCollections");
export const mongoListCollections = forward("mongoListCollections");
export const documentListGridFsBuckets = forward("documentListGridFsBuckets");
export const documentCreateGridFsBucket = forward("documentCreateGridFsBucket");
export const documentDeleteGridFsBucket = forward("documentDeleteGridFsBucket");
export const documentListGridFsFiles = forward("documentListGridFsFiles");
export const documentDownloadGridFsFile = forward("documentDownloadGridFsFile");
export const documentUploadGridFsFile = forward("documentUploadGridFsFile");
export const documentDeleteGridFsFile = forward("documentDeleteGridFsFile");
export const vectorGetCollectionDetail = forward("vectorGetCollectionDetail");
export const mongoCreateDatabase = forward("mongoCreateDatabase");
export const mongoDropDatabase = forward("mongoDropDatabase");
export const mongoDropCollection = forward("mongoDropCollection");
export const documentFindDocuments = forward("documentFindDocuments");
export const mongoFindDocuments = forward("mongoFindDocuments");
export const mongoServerVersion = forward("mongoServerVersion");
export const mongoAggregateDocuments = forward("mongoAggregateDocuments");
export const mongoCollectionStats = forward("mongoCollectionStats");
export const mongoCreateIndex = forward("mongoCreateIndex");
export const mongoDropIndexes = forward("mongoDropIndexes");
export const documentInsertDocument = forward("documentInsertDocument");
export const mongoInsertDocument = forward("mongoInsertDocument");
export const mongoInsertDocuments = forward("mongoInsertDocuments");
export const documentUpdateDocument = forward("documentUpdateDocument");
export const mongoUpdateDocument = forward("mongoUpdateDocument");
export const mongoUpdateDocuments = forward("mongoUpdateDocuments");
export const documentDeleteDocument = forward("documentDeleteDocument");
export const mongoDeleteDocument = forward("mongoDeleteDocument");
export const mongoDeleteDocuments = forward("mongoDeleteDocuments");
// Elasticsearch
export const elasticsearchListIndices = forward("elasticsearchListIndices");
export const vectorListCollections = forward("vectorListCollections");
// History
export const saveHistory = forward("saveHistory");
export const loadHistory = forward("loadHistory");
export const loadRedisHistory = forward("loadRedisHistory");
export const clearHistory = forward("clearHistory");
export const clearRedisHistory = forward("clearRedisHistory");
export const deleteHistoryEntry = forward("deleteHistoryEntry");
// Updates
export const checkMcpServerStatus = forward("checkMcpServerStatus");
export const installMcpServer = forward("installMcpServer");
export const checkForUpdates = forward("checkForUpdates");
export const getSystemProxyUrl = forward("getSystemProxyUrl");
export const downloadAndInstallUpdate = forward("downloadAndInstallUpdate");
export const getAppVersion = forward("getAppVersion");
// Layout
export const saveSidebarLayout = forward("saveSidebarLayout");
export const loadSidebarLayout = forward("loadSidebarLayout");
// ---------------------------------------------------------------------------
// Re-export all types from tauri.ts (shared between both backends)
// ---------------------------------------------------------------------------
export type {
AiMessage,
AiCompletionRequest,
AiTaskContract,
AiStreamChunk,
AiModelInfo,
AiChatMessage,
AiConversation,
AgentDriverInfo,
DriverStoreUsage,
DriverStoreUsageItem,
DriverRuntimeHealth,
DriverRuntimeStatus,
DriverRuntimeInfo,
DriverRuntimeSummary,
JavaRuntimeMode,
JavaRuntimeConfig,
DriverInstallProgress,
DriverStoreMigrationResult,
DriverStorePathInfo,
WebDavConfig,
WebDavPasswordStatus,
WebDavSyncSummary,
WebDavDownloadResult,
McpServerStatus,
UpdateInfo,
RedisDatabaseInfo,
RedisKeyInfo,
RedisValue,
RedisScanResult,
RedisCommandSafety,
RedisCommandResult,
RedisSlowlogEntry,
RedisNodeEndpoint,
KvValueEncoding,
KvValue,
KvKeyMetadata,
KvKeySummary,
KvListPrefixResponse,
KvListPrefixOptions,
KvGetResponse,
KvWriteMode,
KvCreateMode,
KvPutOptions,
KvPutResponse,
KvDeleteResponse,
MongoDocumentResult,
HistoryEntry,
SqlFileStatus,
SqlFileRequest,
SqlFilePreview,
SqlFileProgress,
TransferRequest,
TransferProgress,
TransferMode,
TransferTableNameCase,
TableImportMode,
TableImportStatus,
TableImportColumnMapping,
TableImportPreview,
TableImportRequest,
TableImportSummary,
TableImportProgress,
DatabaseExportRequest,
ExportProgress,
TableExportProgress,
TableExportStatus,
TableExportRequest,
QueryResultExportRequest,
AgentEvent,
} from "@/lib/backend/tauri";
@@ -0,0 +1,102 @@
export interface EncryptedPayload {
format: "dbx-encrypted";
version: 1;
salt: string;
iv: string;
data: string;
}
export interface PlainConfigPayload {
format: "dbx-config";
version: 1;
connections: unknown[];
}
const PBKDF2_ITERATIONS = 100_000;
export const CONFIG_CRYPTO_UNAVAILABLE = "crypto_unavailable";
function getCrypto(): Crypto {
const runtimeCrypto = globalThis.crypto;
if (!runtimeCrypto?.getRandomValues || !runtimeCrypto.subtle) {
throw new Error(CONFIG_CRYPTO_UNAVAILABLE);
}
return runtimeCrypto;
}
function getSubtleCrypto(): SubtleCrypto {
const subtle = globalThis.crypto?.subtle;
if (!subtle) throw new Error(CONFIG_CRYPTO_UNAVAILABLE);
return subtle;
}
async function deriveKey(passphrase: string, salt: Uint8Array<ArrayBuffer>): Promise<CryptoKey> {
const encoder = new TextEncoder();
const subtle = getSubtleCrypto();
const baseKey = await subtle.importKey("raw", encoder.encode(passphrase), "PBKDF2", false, ["deriveKey"]);
return subtle.deriveKey({ name: "PBKDF2", salt, iterations: PBKDF2_ITERATIONS, hash: "SHA-256" }, baseKey, { name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);
}
function toBase64(data: ArrayBuffer | Uint8Array<ArrayBuffer>): string {
const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
let binary = "";
for (let i = 0; i < bytes.length; i++) {
binary += String.fromCharCode(bytes[i]);
}
return btoa(binary);
}
function fromBase64(base64: string): Uint8Array<ArrayBuffer> {
const binary = atob(base64);
const bytes = new Uint8Array(binary.length);
for (let i = 0; i < binary.length; i++) {
bytes[i] = binary.charCodeAt(i);
}
return bytes;
}
export async function encryptConfig(json: string, passphrase: string): Promise<EncryptedPayload> {
const runtimeCrypto = getCrypto();
const salt = runtimeCrypto.getRandomValues(new Uint8Array(16));
const iv = runtimeCrypto.getRandomValues(new Uint8Array(12));
const key = await deriveKey(passphrase, salt);
const encoded = new TextEncoder().encode(json);
const ciphertext = await runtimeCrypto.subtle.encrypt({ name: "AES-GCM", iv }, key, encoded);
return {
format: "dbx-encrypted",
version: 1,
salt: toBase64(salt),
iv: toBase64(iv),
data: toBase64(ciphertext),
};
}
export async function decryptConfig(payload: EncryptedPayload, passphrase: string): Promise<string> {
const salt = fromBase64(payload.salt);
const iv = fromBase64(payload.iv);
const ciphertext = fromBase64(payload.data);
let key: CryptoKey;
try {
key = await deriveKey(passphrase, salt);
} catch (error) {
if (error instanceof Error && error.message === CONFIG_CRYPTO_UNAVAILABLE) {
const { isTauriRuntime } = await import("@/lib/backend/tauriRuntime");
if (!isTauriRuntime(globalThis)) {
const { decryptConfig: decryptConfigOnBackend } = await import("@/lib/backend/api");
return decryptConfigOnBackend(payload, passphrase);
}
}
throw error;
}
try {
const plaintext = await getSubtleCrypto().decrypt({ name: "AES-GCM", iv }, key, ciphertext);
return new TextDecoder().decode(plaintext);
} catch {
throw new Error("wrong_passphrase");
}
}
export function isEncryptedConfig(data: unknown): data is EncryptedPayload {
if (typeof data !== "object" || data === null) return false;
const obj = data as Record<string, unknown>;
return obj.format === "dbx-encrypted" && obj.version === 1 && typeof obj.salt === "string" && typeof obj.iv === "string" && typeof obj.data === "string";
}
@@ -0,0 +1,5 @@
import type { ConnectionConfig } from "@/types/database";
export function hasEnabledTransportLayers(connection?: Pick<ConnectionConfig, "transport_layers"> | null): boolean {
return !!connection?.transport_layers?.some((layer) => layer.enabled !== false);
}
+259
View File
@@ -0,0 +1,259 @@
const DEBUG_LOG_ENABLED_KEY = "dbx-debug-logging-enabled";
const DEBUG_LOG_ENTRIES_KEY = "dbx-debug-log-entries";
const MAX_DEBUG_LOG_ENTRIES = 1500;
const MAX_TEXT_LENGTH = 4000;
const MAX_LABEL_LENGTH = 120;
type DebugLogLevel = "debug" | "info" | "log" | "warn" | "error";
interface DebugLogEntry {
timestamp: string;
level: DebugLogLevel;
message: string;
}
let installed = false;
let originalConsole: Partial<Record<DebugLogLevel, (...args: unknown[]) => void>> = {};
function safeLocalStorageGet(key: string): string | null {
try {
return localStorage.getItem(key);
} catch {
return null;
}
}
function safeLocalStorageSet(key: string, value: string) {
try {
localStorage.setItem(key, value);
} catch {
// Ignore quota or unavailable storage errors. The app should keep running.
}
}
function safeLocalStorageRemove(key: string) {
try {
localStorage.removeItem(key);
} catch {}
}
export function isDebugLoggingEnabled(): boolean {
return safeLocalStorageGet(DEBUG_LOG_ENABLED_KEY) === "1";
}
function readEntries(): DebugLogEntry[] {
const raw = safeLocalStorageGet(DEBUG_LOG_ENTRIES_KEY);
if (!raw) return [];
try {
const parsed = JSON.parse(raw);
return Array.isArray(parsed) ? parsed.slice(-MAX_DEBUG_LOG_ENTRIES) : [];
} catch {
return [];
}
}
function redactSensitiveText(value: string): string {
return value.replace(/("(?:password|passphrase|apiKey|api_key|token|secret|connectionString|connection_string)"\s*:\s*")([^"]*)(")/gi, "$1[redacted]$3").replace(/\b(password|passphrase|apiKey|api_key|token|secret)=([^&\s]+)/gi, "$1=[redacted]");
}
function formatValue(value: unknown, seen = new WeakSet<object>()): string {
if (value instanceof Error) {
return redactSensitiveText([value.name, value.message, value.stack].filter(Boolean).join(": "));
}
if (typeof value === "string") return redactSensitiveText(value);
if (typeof value !== "object" || value === null) return String(value);
if (seen.has(value)) return "[Circular]";
seen.add(value);
try {
return redactSensitiveText(
JSON.stringify(value, (_key, item) => {
if (typeof item === "function") return `[Function ${item.name || "anonymous"}]`;
return item;
}),
);
} catch {
return redactSensitiveText(String(value));
}
}
function formatArgs(args: unknown[]): string {
const message = args.map((arg) => formatValue(arg)).join(" ");
return message.length > MAX_TEXT_LENGTH ? `${message.slice(0, MAX_TEXT_LENGTH)}...` : message;
}
export function appendDebugLog(level: DebugLogLevel, ...args: unknown[]) {
if (!isDebugLoggingEnabled()) return;
const entries = readEntries();
entries.push({
timestamp: new Date().toISOString(),
level,
message: formatArgs(args),
});
safeLocalStorageSet(DEBUG_LOG_ENTRIES_KEY, JSON.stringify(entries.slice(-MAX_DEBUG_LOG_ENTRIES)));
}
export function setDebugLoggingEnabled(enabled: boolean) {
safeLocalStorageSet(DEBUG_LOG_ENABLED_KEY, enabled ? "1" : "0");
if (enabled) {
appendDebugLog("info", "[DBX][debug-log] enabled", {
url: location.href,
viewport: `${window.innerWidth}x${window.innerHeight}`,
devicePixelRatio: window.devicePixelRatio,
language: navigator.language,
online: navigator.onLine,
});
}
}
export function clearDebugLogs() {
safeLocalStorageRemove(DEBUG_LOG_ENTRIES_KEY);
}
export function getDebugLogText(): string {
const entries = readEntries();
const header = [`DBX debug log`, `Exported: ${new Date().toISOString()}`, `User agent: ${navigator.userAgent}`, `Platform: ${navigator.platform}`, `Timezone: ${Intl.DateTimeFormat().resolvedOptions().timeZone || "unknown"}`, ""];
const body = entries.map((entry) => `[${entry.timestamp}] [${entry.level.toUpperCase()}] ${entry.message}`);
return [...header, ...body].join("\n");
}
export async function downloadDebugLogs() {
const text = await getDebugLogBundleText();
const filename = `dbx-debug-log-${new Date().toISOString().replace(/[:.]/g, "-")}.txt`;
if (typeof window !== "undefined" && isTauriRuntimeLike()) {
const [{ save }, { writeTextFile }] = await Promise.all([import("@tauri-apps/plugin-dialog"), import("@tauri-apps/plugin-fs")]);
const path = await save({
defaultPath: filename,
filters: [{ name: "Text", extensions: ["txt", "log"] }],
});
if (!path) return false;
await writeTextFile(path, text);
return true;
}
const blob = new Blob([text], { type: "text/plain;charset=utf-8" });
const url = URL.createObjectURL(blob);
const link = document.createElement("a");
link.href = url;
link.download = filename;
link.click();
URL.revokeObjectURL(url);
return true;
}
export async function getDebugLogBundleText(): Promise<string> {
const sections = [getDebugLogText()];
const nativeLogs = await loadNativeDebugLogs().catch((error) => `Failed to load native logs: ${formatValue(error)}`);
if (nativeLogs) {
sections.push(["", "===== Native / Tauri logs =====", nativeLogs].join("\n"));
}
return sections.join("\n");
}
async function loadNativeDebugLogs(): Promise<string> {
if (!isTauriRuntimeLike()) return "";
const { invoke } = await import("@tauri-apps/api/core");
return invoke<string>("load_native_debug_logs");
}
function isTauriRuntimeLike(): boolean {
return "__TAURI_INTERNALS__" in globalThis || "__TAURI__" in globalThis;
}
export function installDebugLogCapture() {
if (installed) return;
installed = true;
originalConsole = {
debug: console.debug.bind(console),
info: console.info.bind(console),
log: console.log.bind(console),
warn: console.warn.bind(console),
error: console.error.bind(console),
};
(Object.keys(originalConsole) as DebugLogLevel[]).forEach((level) => {
console[level] = (...args: unknown[]) => {
appendDebugLog(level, ...args);
originalConsole[level]?.(...args);
};
});
window.addEventListener("error", (event) => {
const target = event.target;
if (target instanceof HTMLElement) {
appendDebugLog("error", "[window:resource-error]", describeElement(target));
return;
}
appendDebugLog("error", "[window:error]", event.error ?? event.message);
});
window.addEventListener("unhandledrejection", (event) => {
appendDebugLog("error", "[window:unhandledrejection]", event.reason);
});
window.addEventListener("online", () => appendDebugLog("info", "[window:online]"));
window.addEventListener("offline", () => appendDebugLog("warn", "[window:offline]"));
window.addEventListener("hashchange", () => appendDebugLog("info", "[window:hashchange]", location.hash));
document.addEventListener("visibilitychange", () => {
appendDebugLog("info", "[document:visibilitychange]", document.visibilityState);
});
document.addEventListener(
"click",
(event) => {
const target = event.target instanceof HTMLElement ? interactiveElement(event.target) : null;
if (!target) return;
appendDebugLog("debug", "[ui:click]", describeElement(target));
},
true,
);
document.addEventListener(
"change",
(event) => {
const target = event.target instanceof HTMLElement ? event.target : null;
if (!target || !isFormControl(target)) return;
appendDebugLog("debug", "[ui:change]", describeElement(target));
},
true,
);
installPerformanceCapture();
}
function installPerformanceCapture() {
if (typeof PerformanceObserver === "undefined") return;
try {
const observer = new PerformanceObserver((list) => {
for (const entry of list.getEntries()) {
if (entry.duration >= 250) {
appendDebugLog("warn", "[performance:long-task]", {
name: entry.name,
durationMs: Math.round(entry.duration),
startTimeMs: Math.round(entry.startTime),
});
}
}
});
observer.observe({ entryTypes: ["longtask"] });
} catch {
// Long task entries are not available in every WebView.
}
}
function interactiveElement(target: HTMLElement): HTMLElement | null {
return target.closest(["button", "a[href]", "input", "select", "textarea", "[role='button']", "[role='menuitem']", "[role='tab']", "[data-debug-id]"].join(","));
}
function isFormControl(target: HTMLElement): boolean {
return target instanceof HTMLInputElement || target instanceof HTMLSelectElement || target instanceof HTMLTextAreaElement || target.getAttribute("role") === "switch";
}
function describeElement(element: HTMLElement): Record<string, string> {
const label = element.getAttribute("data-debug-id") || element.getAttribute("aria-label") || element.getAttribute("title") || element.textContent || "";
const attrs: Record<string, string> = {
tag: element.tagName.toLowerCase(),
};
if (element.id) attrs.id = element.id;
const role = element.getAttribute("role");
if (role) attrs.role = role;
const type = element.getAttribute("type");
if (type) attrs.type = type;
const safeLabel = redactSensitiveText(label.trim().replace(/\s+/g, " "));
if (safeLabel) attrs.label = safeLabel.slice(0, MAX_LABEL_LENGTH);
const testId = element.getAttribute("data-testid");
if (testId) attrs.testId = testId;
return attrs;
}
@@ -0,0 +1,63 @@
/**
* Utility functions for consistent error handling across the application.
*/
/**
* Formats an unknown error value into a human-readable string.
* Handles Error objects, strings, null/undefined, and other types.
*
* @param e - The error value to format (from a catch block)
* @returns A human-readable error message string
*
* @example
* try {
* await someOperation();
* } catch (e: unknown) {
* errorMessage.value = formatError(e);
* }
*/
export function formatError(e: unknown): string {
if (e instanceof Error) {
return e.message;
}
if (typeof e === "string") {
return e;
}
if (e === null || e === undefined) {
return "Unknown error occurred";
}
// Try to extract message property from object-like values
if (typeof e === "object" && "message" in e) {
const message = (e as { message: unknown }).message;
if (typeof message === "string") {
return message;
}
}
// Fallback: attempt to stringify
try {
return String(e);
} catch {
return "Unknown error occurred";
}
}
/**
* Formats an error with a context prefix for better debugging.
*
* @param e - The error value to format
* @param context - The operation context (e.g., "loading topics", "creating tenant")
* @returns A formatted error message with context
*
* @example
* catch (e: unknown) {
* errorMessage.value = formatErrorWithContext(e, 'loading topics');
* }
*/
export function formatErrorWithContext(e: unknown, context: string): string {
const message = formatError(e);
return `Failed to ${context}: ${message}`;
}
File diff suppressed because it is too large. Load diff
+219
View File
@@ -0,0 +1,219 @@
// HTTP fetch API for message queue admin (web mode)
import { apiUrl } from "@/lib/common/webPath";
import type {
MqClusterInfo,
ClusterInfo,
TenantInfo,
TenantConfig,
NamespaceRef,
NamespaceInfo,
NamespaceConfig,
TopicRef,
TopicInfo,
ListTopicsOpts,
TopicStats,
SubscriptionInfo,
ResetPosition,
SkipCount,
ConsumerInfo,
ProducerInfo,
PolicyScope,
PublishRate,
DispatchRate,
SubscribeRate,
BacklogQuota,
RetentionPolicy,
AuthAction,
PermissionMap,
MqTokenIssueRequest,
MqTokenRecord,
MqIssuedToken,
BacklogStats,
PeekedMessage,
PeekMessagesOptions,
MqRawRequest,
MqRawResponse,
SendMessageRequest,
SendMessageResponse,
} from "@/types/mq";
async function post<T>(path: string, body: unknown): Promise<T> {
const resp = await fetch(apiUrl(path), {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify(body),
});
if (!resp.ok) {
const detail = (await resp.text().catch(() => "")).trim();
throw new Error(detail ? `${path} returned ${resp.status}: ${detail}` : `${path} returned ${resp.status}`);
}
return resp.json();
}
export async function mqTestConnection(connectionId: string): Promise<MqClusterInfo> {
return post("/api/mq/test-connection", { connectionId });
}
export async function mqListTenants(connectionId: string): Promise<TenantInfo[]> {
return post("/api/mq/tenants/list", { connectionId });
}
export async function mqGetTenant(connectionId: string, name: string): Promise<TenantInfo> {
return post("/api/mq/tenants/get", { connectionId, name });
}
export async function mqCreateTenant(connectionId: string, name: string, config: TenantConfig): Promise<void> {
return post("/api/mq/tenants/create", { connectionId, name, config });
}
export async function mqUpdateTenant(connectionId: string, name: string, config: TenantConfig): Promise<void> {
return post("/api/mq/tenants/update", { connectionId, name, config });
}
export async function mqDeleteTenant(connectionId: string, name: string, force: boolean): Promise<void> {
return post("/api/mq/tenants/delete", { connectionId, name, force });
}
export async function mqListNamespaces(connectionId: string, tenant: string): Promise<NamespaceInfo[]> {
return post("/api/mq/namespaces/list", { connectionId, tenant });
}
export async function mqCreateNamespace(connectionId: string, ns: NamespaceRef, config: NamespaceConfig): Promise<void> {
return post("/api/mq/namespaces/create", { connectionId, ns, config });
}
export async function mqDeleteNamespace(connectionId: string, ns: NamespaceRef, force: boolean): Promise<void> {
return post("/api/mq/namespaces/delete", { connectionId, ns, force });
}
export async function mqGetNamespacePolicies(connectionId: string, ns: NamespaceRef): Promise<unknown> {
return post("/api/mq/namespaces/policies", { connectionId, ns });
}
export async function mqListTopics(connectionId: string, ns: NamespaceRef, opts: ListTopicsOpts): Promise<TopicInfo[]> {
return post("/api/mq/topics/list", { connectionId, ns, opts });
}
export async function mqCreateTopic(connectionId: string, topic: TopicRef, partitions?: number): Promise<void> {
return post("/api/mq/topics/create", { connectionId, topic, partitions });
}
export async function mqDeleteTopic(connectionId: string, topic: TopicRef, force: boolean): Promise<void> {
return post("/api/mq/topics/delete", { connectionId, topic, force });
}
export async function mqUpdatePartitions(connectionId: string, topic: TopicRef, partitions: number): Promise<void> {
return post("/api/mq/topics/update-partitions", { connectionId, topic, partitions });
}
export async function mqGetTopicStats(connectionId: string, topic: TopicRef): Promise<TopicStats> {
return post("/api/mq/topics/stats", { connectionId, topic });
}
export async function mqGetTopicInternalStats(connectionId: string, topic: TopicRef): Promise<unknown> {
return post("/api/mq/topics/internal-stats", { connectionId, topic });
}
export async function mqListSubscriptions(connectionId: string, topic: TopicRef): Promise<SubscriptionInfo[]> {
return post("/api/mq/subscriptions/list", { connectionId, topic });
}
export async function mqCreateSubscription(connectionId: string, topic: TopicRef, sub: string, pos: ResetPosition): Promise<void> {
return post("/api/mq/subscriptions/create", { connectionId, topic, sub, pos });
}
export async function mqDeleteSubscription(connectionId: string, topic: TopicRef, sub: string, force: boolean): Promise<void> {
return post("/api/mq/subscriptions/delete", { connectionId, topic, sub, force });
}
export async function mqSkipMessages(connectionId: string, topic: TopicRef, sub: string, count: SkipCount): Promise<void> {
return post("/api/mq/subscriptions/skip-messages", { connectionId, topic, sub, count });
}
export async function mqResetCursor(connectionId: string, topic: TopicRef, sub: string, pos: ResetPosition): Promise<void> {
return post("/api/mq/subscriptions/reset-cursor", { connectionId, topic, sub, pos });
}
export async function mqClearBacklog(connectionId: string, topic: TopicRef, sub: string): Promise<void> {
return post("/api/mq/subscriptions/clear-backlog", { connectionId, topic, sub });
}
export async function mqPeekMessages(connectionId: string, topic: TopicRef, sub: string, count: number, options?: PeekMessagesOptions): Promise<PeekedMessage[]> {
return post("/api/mq/subscriptions/peek-messages", { connectionId, topic, sub, count, options });
}
export async function mqExpireMessages(connectionId: string, topic: TopicRef, sub: string, expireSeconds: number): Promise<void> {
return post("/api/mq/subscriptions/expire-messages", { connectionId, topic, sub, expireSeconds });
}
export async function mqListProducers(connectionId: string, topic: TopicRef): Promise<ProducerInfo[]> {
return post("/api/mq/producers/list", { connectionId, topic });
}
export async function mqListConsumers(connectionId: string, topic: TopicRef, sub: string): Promise<ConsumerInfo[]> {
return post("/api/mq/consumers/list", { connectionId, topic, sub });
}
export async function mqUnloadTopic(connectionId: string, topic: TopicRef): Promise<void> {
return post("/api/mq/topics/unload", { connectionId, topic });
}
export async function mqSetPublishRate(connectionId: string, scope: PolicyScope, rate: PublishRate): Promise<void> {
return post("/api/mq/policies/publish-rate", { connectionId, scope, rate });
}
export async function mqSetDispatchRate(connectionId: string, scope: PolicyScope, rate: DispatchRate): Promise<void> {
return post("/api/mq/policies/dispatch-rate", { connectionId, scope, rate });
}
export async function mqSetSubscribeRate(connectionId: string, scope: PolicyScope, rate: SubscribeRate): Promise<void> {
return post("/api/mq/policies/subscribe-rate", { connectionId, scope, rate });
}
export async function mqSetBacklogQuota(connectionId: string, scope: PolicyScope, quota: BacklogQuota): Promise<void> {
return post("/api/mq/policies/backlog-quota", { connectionId, scope, quota });
}
export async function mqSetRetention(connectionId: string, scope: PolicyScope, retention: RetentionPolicy): Promise<void> {
return post("/api/mq/policies/retention", { connectionId, scope, retention });
}
export async function mqGetEffectivePolicies(connectionId: string, scope: PolicyScope): Promise<unknown> {
return post("/api/mq/policies/effective", { connectionId, scope });
}
export async function mqGrantPermission(connectionId: string, scope: PolicyScope, role: string, actions: AuthAction[]): Promise<void> {
return post("/api/mq/permissions/grant", { connectionId, scope, role, actions });
}
export async function mqRevokePermission(connectionId: string, scope: PolicyScope, role: string): Promise<void> {
return post("/api/mq/permissions/revoke", { connectionId, scope, role });
}
export async function mqListPermissions(connectionId: string, scope: PolicyScope): Promise<PermissionMap> {
return post("/api/mq/permissions/list", { connectionId, scope });
}
export async function mqIssueToken(connectionId: string, req: MqTokenIssueRequest): Promise<MqIssuedToken> {
return post("/api/mq/tokens/issue", { connectionId, req });
}
export async function mqListTokenRecords(connectionId: string, subject?: string): Promise<MqTokenRecord[]> {
return post("/api/mq/tokens/list", { connectionId, subject });
}
export async function mqGetBacklog(connectionId: string, topic: TopicRef, sub?: string): Promise<BacklogStats> {
return post("/api/mq/monitoring/backlog", { connectionId, topic, sub });
}
export async function mqGetClusterInfo(connectionId: string): Promise<ClusterInfo> {
return post("/api/mq/monitoring/cluster-info", { connectionId });
}
export async function mqRawRequest(connectionId: string, req: MqRawRequest): Promise<MqRawResponse> {
return post("/api/mq/raw", { connectionId, req });
}
export async function mqSendMessage(connectionId: string, req: SendMessageRequest): Promise<SendMessageResponse> {
return post("/api/mq/send-message", { connectionId, req });
}
+216
View File
@@ -0,0 +1,216 @@
// Message queue admin API functions - Tauri invoke layer
import { invoke } from "@tauri-apps/api/core";
import type {
MqClusterInfo,
ClusterInfo,
TenantInfo,
TenantConfig,
NamespaceRef,
NamespaceInfo,
NamespaceConfig,
TopicRef,
TopicInfo,
ListTopicsOpts,
TopicStats,
SubscriptionInfo,
ResetPosition,
SkipCount,
ConsumerInfo,
ProducerInfo,
PolicyScope,
PublishRate,
DispatchRate,
SubscribeRate,
BacklogQuota,
RetentionPolicy,
AuthAction,
PermissionMap,
MqTokenIssueRequest,
MqTokenRecord,
MqIssuedToken,
BacklogStats,
PeekedMessage,
PeekMessagesOptions,
MqRawRequest,
MqRawResponse,
SendMessageRequest,
SendMessageResponse,
} from "@/types/mq";
// Connectivity
export async function mqTestConnection(connectionId: string): Promise<MqClusterInfo> {
return invoke("mq_test_connection", { connectionId });
}
// Tenants
export async function mqListTenants(connectionId: string): Promise<TenantInfo[]> {
return invoke("mq_list_tenants", { connectionId });
}
export async function mqGetTenant(connectionId: string, name: string): Promise<TenantInfo> {
return invoke("mq_get_tenant", { connectionId, name });
}
export async function mqCreateTenant(connectionId: string, name: string, config: TenantConfig): Promise<void> {
return invoke("mq_create_tenant", { connectionId, name, config });
}
export async function mqUpdateTenant(connectionId: string, name: string, config: TenantConfig): Promise<void> {
return invoke("mq_update_tenant", { connectionId, name, config });
}
export async function mqDeleteTenant(connectionId: string, name: string, force: boolean): Promise<void> {
return invoke("mq_delete_tenant", { connectionId, name, force });
}
// Namespaces
export async function mqListNamespaces(connectionId: string, tenant: string): Promise<NamespaceInfo[]> {
return invoke("mq_list_namespaces", { connectionId, tenant });
}
export async function mqCreateNamespace(connectionId: string, ns: NamespaceRef, config: NamespaceConfig): Promise<void> {
return invoke("mq_create_namespace", { connectionId, ns, config });
}
export async function mqDeleteNamespace(connectionId: string, ns: NamespaceRef, force: boolean): Promise<void> {
return invoke("mq_delete_namespace", { connectionId, ns, force });
}
export async function mqGetNamespacePolicies(connectionId: string, ns: NamespaceRef): Promise<unknown> {
return invoke("mq_get_namespace_policies", { connectionId, ns });
}
// Topics
export async function mqListTopics(connectionId: string, ns: NamespaceRef, opts: ListTopicsOpts): Promise<TopicInfo[]> {
return invoke("mq_list_topics", { connectionId, ns, opts });
}
export async function mqCreateTopic(connectionId: string, topic: TopicRef, partitions?: number): Promise<void> {
return invoke("mq_create_topic", { connectionId, topic, partitions });
}
export async function mqDeleteTopic(connectionId: string, topic: TopicRef, force: boolean): Promise<void> {
return invoke("mq_delete_topic", { connectionId, topic, force });
}
export async function mqUpdatePartitions(connectionId: string, topic: TopicRef, partitions: number): Promise<void> {
return invoke("mq_update_partitions", { connectionId, topic, partitions });
}
export async function mqGetTopicStats(connectionId: string, topic: TopicRef): Promise<TopicStats> {
return invoke("mq_get_topic_stats", { connectionId, topic });
}
export async function mqGetTopicInternalStats(connectionId: string, topic: TopicRef): Promise<unknown> {
return invoke("mq_get_topic_internal_stats", { connectionId, topic });
}
// Subscriptions
export async function mqListSubscriptions(connectionId: string, topic: TopicRef): Promise<SubscriptionInfo[]> {
return invoke("mq_list_subscriptions", { connectionId, topic });
}
export async function mqCreateSubscription(connectionId: string, topic: TopicRef, sub: string, pos: ResetPosition): Promise<void> {
return invoke("mq_create_subscription", { connectionId, topic, sub, pos });
}
export async function mqDeleteSubscription(connectionId: string, topic: TopicRef, sub: string, force: boolean): Promise<void> {
return invoke("mq_delete_subscription", { connectionId, topic, sub, force });
}
export async function mqSkipMessages(connectionId: string, topic: TopicRef, sub: string, count: SkipCount): Promise<void> {
return invoke("mq_skip_messages", { connectionId, topic, sub, count });
}
export async function mqResetCursor(connectionId: string, topic: TopicRef, sub: string, pos: ResetPosition): Promise<void> {
return invoke("mq_reset_cursor", { connectionId, topic, sub, pos });
}
export async function mqClearBacklog(connectionId: string, topic: TopicRef, sub: string): Promise<void> {
return invoke("mq_clear_backlog", { connectionId, topic, sub });
}
export async function mqPeekMessages(connectionId: string, topic: TopicRef, sub: string, count: number, options?: PeekMessagesOptions): Promise<PeekedMessage[]> {
return invoke("mq_peek_messages", { connectionId, topic, sub, count, options });
}
export async function mqExpireMessages(connectionId: string, topic: TopicRef, sub: string, expireSeconds: number): Promise<void> {
return invoke("mq_expire_messages", { connectionId, topic, sub, expireSeconds });
}
// Producers / Consumers
export async function mqListProducers(connectionId: string, topic: TopicRef): Promise<ProducerInfo[]> {
return invoke("mq_list_producers", { connectionId, topic });
}
export async function mqListConsumers(connectionId: string, topic: TopicRef, sub: string): Promise<ConsumerInfo[]> {
return invoke("mq_list_consumers", { connectionId, topic, sub });
}
export async function mqUnloadTopic(connectionId: string, topic: TopicRef): Promise<void> {
return invoke("mq_unload_topic", { connectionId, topic });
}
// Policies
export async function mqSetPublishRate(connectionId: string, scope: PolicyScope, rate: PublishRate): Promise<void> {
return invoke("mq_set_publish_rate", { connectionId, scope, rate });
}
export async function mqSetDispatchRate(connectionId: string, scope: PolicyScope, rate: DispatchRate): Promise<void> {
return invoke("mq_set_dispatch_rate", { connectionId, scope, rate });
}
export async function mqSetSubscribeRate(connectionId: string, scope: PolicyScope, rate: SubscribeRate): Promise<void> {
return invoke("mq_set_subscribe_rate", { connectionId, scope, rate });
}
export async function mqSetBacklogQuota(connectionId: string, scope: PolicyScope, quota: BacklogQuota): Promise<void> {
return invoke("mq_set_backlog_quota", { connectionId, scope, quota });
}
export async function mqSetRetention(connectionId: string, scope: PolicyScope, retention: RetentionPolicy): Promise<void> {
return invoke("mq_set_retention", { connectionId, scope, retention });
}
export async function mqGetEffectivePolicies(connectionId: string, scope: PolicyScope): Promise<unknown> {
return invoke("mq_get_effective_policies", { connectionId, scope });
}
// Permissions
export async function mqGrantPermission(connectionId: string, scope: PolicyScope, role: string, actions: AuthAction[]): Promise<void> {
return invoke("mq_grant_permission", { connectionId, scope, role, actions });
}
export async function mqRevokePermission(connectionId: string, scope: PolicyScope, role: string): Promise<void> {
return invoke("mq_revoke_permission", { connectionId, scope, role });
}
export async function mqListPermissions(connectionId: string, scope: PolicyScope): Promise<PermissionMap> {
return invoke("mq_list_permissions", { connectionId, scope });
}
export async function mqIssueToken(connectionId: string, req: MqTokenIssueRequest): Promise<MqIssuedToken> {
return invoke("mq_issue_token", { connectionId, req });
}
export async function mqListTokenRecords(connectionId: string, subject?: string): Promise<MqTokenRecord[]> {
return invoke("mq_list_token_records", { connectionId, subject });
}
// Monitoring
export async function mqGetBacklog(connectionId: string, topic: TopicRef, sub?: string): Promise<BacklogStats> {
return invoke("mq_get_backlog", { connectionId, topic, sub });
}
export async function mqGetClusterInfo(connectionId: string): Promise<ClusterInfo> {
return invoke("mq_get_cluster_info", { connectionId });
}
// Raw request
export async function mqRawRequest(connectionId: string, req: MqRawRequest): Promise<MqRawResponse> {
return invoke("mq_raw_request", { connectionId, req });
}
export async function mqSendMessage(connectionId: string, req: SendMessageRequest): Promise<SendMessageResponse> {
return invoke("mq_send_message", { connectionId, req });
}
@@ -0,0 +1,83 @@
import { invoke } from "@tauri-apps/api/core";
import type {
NacosConfigHistoryKey,
NacosConfigHistoryList,
NacosConfigHistoryQuery,
NacosConfigItem,
NacosConfigKey,
NacosConfigList,
NacosConfigQuery,
NacosConfigRollbackRequest,
NacosConfigUpsert,
NacosConnectionInfo,
NacosInstanceInfo,
NacosInstanceQuery,
NacosInstanceUpdate,
NacosNamespaceCreate,
NacosNamespaceInfo,
NacosNamespaceUpdate,
NacosRawRequest,
NacosRawResponse,
NacosServiceList,
NacosServiceQuery,
} from "@/types/nacos";
export async function nacosTestConnection(connectionId: string): Promise<NacosConnectionInfo> {
return invoke("nacos_test_connection", { connectionId });
}
export async function nacosListNamespaces(connectionId: string): Promise<NacosNamespaceInfo[]> {
return invoke("nacos_list_namespaces", { 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 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 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 nacosListServices(connectionId: string, query: NacosServiceQuery): Promise<NacosServiceList> {
return invoke("nacos_list_services", { 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: NacosInstanceUpdate): Promise<void> {
return invoke("nacos_update_instance", { connectionId, req });
}
export async function nacosRawRequest(connectionId: string, req: NacosRawRequest): Promise<NacosRawResponse> {
return invoke("nacos_raw_request", { connectionId, req });
}
+17
View File
@@ -0,0 +1,17 @@
export type Platform = "macos" | "windows" | "linux" | "unknown";
export function getPlatform(): Platform {
const ua = navigator.userAgent.toLowerCase();
if (ua.includes("mac")) return "macos";
if (ua.includes("win")) return "windows";
if (ua.includes("linux")) return "linux";
return "unknown";
}
export function isMacOS(): boolean {
return getPlatform() === "macos";
}
export function isWindows(): boolean {
return getPlatform() === "windows";
}
@@ -0,0 +1,28 @@
function storageWarn(action: string, key: string, error: unknown) {
console.warn(`[DBX][storage:${action}] ${key}`, error);
}
export function safeLocalStorageGet(key: string): string | null {
try {
return globalThis.localStorage?.getItem(key) ?? null;
} catch (error) {
storageWarn("get", key, error);
return null;
}
}
export function safeLocalStorageSet(key: string, value: string) {
try {
globalThis.localStorage?.setItem(key, value);
} catch (error) {
storageWarn("set", key, error);
}
}
export function safeLocalStorageRemove(key: string) {
try {
globalThis.localStorage?.removeItem(key);
} catch (error) {
storageWarn("remove", key, error);
}
}
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,3 @@
export function isTauriRuntime(globalObject: Record<string, unknown> = globalThis as Record<string, unknown>): boolean {
return Boolean(globalObject.__TAURI_INTERNALS__ || globalObject.__TAURI__);
}