feat(sidebar): expose visible object filters in the connection tree

* feat(sidebar): expose visible object filter

* fix(sidebar): refine visible filter status

* refactor(sidebar): move visible filter status to details

* fix(sidebar): clarify visible filter action
This commit is contained in:
Guoyu Su authored and GitHub committed 2026-08-07 03:24:25 +08:00
1 parent cc5a4068d2
commit dfb9971849
26 files changed
+793 -9

No files matched your search

+66 -4
View File
@@ -123,6 +123,8 @@ import i18n from "@/i18n";
import type { MqAdminConfig } from "@/types/mq";
import { RABBITMQ_MQ_TENANT, resolveMqSystemKindFromConnection } from "@/lib/mq/mqConsoleDefaults";
import { applySidebarDatabaseStorage, applySidebarTableStorage, sidebarDatabaseNames, supportsSidebarDatabaseStorage, supportsSidebarTableStorage, type SidebarTableStorageScope } from "@/lib/sidebar/sidebarDatabaseStorage";
import { connectionHasConfiguredSidebarVisibleFilter, sidebarVisibleFilterSummary } from "@/lib/sidebar/sidebarVisibleFilterSummary";
import { connectionCanConfigureSidebarVisibleDatabases } from "@/lib/sidebar/sidebarVisibleFilterMenu";
const PINNED_TREE_NODES_STORAGE_KEY = "dbx-pinned-tree-nodes";
const ACTIVE_CONNECTION_STORAGE_KEY = "dbx-active-connection";
@@ -344,6 +346,7 @@ export const useConnectionStore = defineStore("connection", () => {
const completionColumnsCache = ref<Record<string, ColumnInfo[]>>({});
const completionForeignKeysCache = ref<Record<string, ForeignKeyInfo[]>>({});
const completionDatabasesCache = ref<Record<string, string[]>>({});
const primaryVisibleObjectNames = ref<Record<string, string[]>>({});
const sqlServerCompletionContextCache = ref<Record<string, SqlServerCompletionContext>>({});
const elasticsearchCompletionIndicesCache = ref<Record<string, string[]>>({});
const redisCompletionKeysCache = ref<Record<string, string[]>>({});
@@ -444,6 +447,7 @@ export const useConnectionStore = defineStore("connection", () => {
const connectionStateRevisions = new Map<string, number>();
const connectionErrorRevisions = new Map<string, number>();
const treeNodeLoads = new TreeNodeLoadRegistry();
const primaryVisibleObjectRefreshInFlight = new Set<string>();
let nextLocalConnectionAttempt = 0;
let beforeConnectHandler: BeforeConnectHandler | null = null;
let initFromDiskPromise: Promise<void> | null = null;
@@ -902,6 +906,7 @@ export const useConnectionStore = defineStore("connection", () => {
function markConnectionLost(connectionId: string, error: unknown) {
connectedIds.value.delete(connectionId);
clearPrimaryVisibleObjectNames(connectionId);
clearConnectionIdentifierQuote(connectionId);
clearConnectionNodeLoading(connectionId);
clearConnectionHealthCheck(connectionId);
@@ -2377,6 +2382,7 @@ export const useConnectionStore = defineStore("connection", () => {
clearConnectionError(id);
connectionErrorRevisions.delete(id);
connectedIds.value.delete(id);
clearPrimaryVisibleObjectNames(id);
clearConnectionIdentifierQuote(id);
clearConnectionHealthCheck(id);
sidebarLayout.value = removeConnectionFromSidebarLayout(sidebarLayout.value, id);
@@ -2412,6 +2418,7 @@ export const useConnectionStore = defineStore("connection", () => {
connections.value = nextConnections;
rebuildTreeNodes();
if (!runtimeConfigChanged) return;
clearPrimaryVisibleObjectNames(config.id);
connectedIds.value.delete(config.id);
clearConnectionIdentifierQuote(config.id);
clearConnectionHealthCheck(config.id);
@@ -2557,6 +2564,34 @@ export const useConnectionStore = defineStore("connection", () => {
await reloadConnectionDatabaseChildren(connectionId);
}
function recordPrimaryVisibleObjectNames(connectionId: string, objectNames: readonly string[]) {
const names = [...objectNames];
const existing = primaryVisibleObjectNames.value[connectionId];
if (existing?.length === names.length && existing.every((name, index) => name === names[index])) return;
primaryVisibleObjectNames.value = { ...primaryVisibleObjectNames.value, [connectionId]: names };
}
function clearPrimaryVisibleObjectNames(connectionId: string) {
if (!(connectionId in primaryVisibleObjectNames.value)) return;
const next = { ...primaryVisibleObjectNames.value };
delete next[connectionId];
primaryVisibleObjectNames.value = next;
}
function getSidebarVisibleFilterSummary(connectionId: string) {
const config = getConfig(connectionId);
return config ? sidebarVisibleFilterSummary(config, primaryVisibleObjectNames.value[connectionId]) : null;
}
function scheduleMissingPrimaryVisibleObjectNamesRefresh(connectionId: string, config: ConnectionConfig | undefined, options?: LoadTreeOptions) {
if (options?.force || !config || primaryVisibleObjectNames.value[connectionId] || primaryVisibleObjectRefreshInFlight.has(connectionId)) return;
if (!connectionCanConfigureSidebarVisibleDatabases(config.db_type) || !connectionHasConfiguredSidebarVisibleFilter(config)) return;
primaryVisibleObjectRefreshInFlight.add(connectionId);
void loadDatabases(connectionId, { force: true, connectedOnly: true })
.catch(() => undefined)
.finally(() => primaryVisibleObjectRefreshInFlight.delete(connectionId));
}
async function clearVisibleDatabases(connectionId: string) {
const config = getConfig(connectionId);
if (!config || !Array.isArray(config.visible_databases)) return;
@@ -2738,6 +2773,7 @@ export const useConnectionStore = defineStore("connection", () => {
if (!cancelled) return false;
clearConnectionError(connectionId);
connectedIds.value.delete(connectionId);
clearPrimaryVisibleObjectNames(connectionId);
clearConnectionIdentifierQuote(connectionId);
clearConnectionHealthCheck(connectionId);
if (activeConnectionId.value === connectionId) activeConnectionId.value = null;
@@ -2753,6 +2789,7 @@ export const useConnectionStore = defineStore("connection", () => {
const shouldRemoveOneTimeConnection = getConfig(connectionId)?.one_time === true;
connectedIds.value.delete(connectionId);
clearPrimaryVisibleObjectNames(connectionId);
clearConnectionIdentifierQuote(connectionId);
forgetSuccessfulLocalConnectionAttempt(connectionId);
clearConnectionHealthCheck(connectionId);
@@ -2829,6 +2866,7 @@ export const useConnectionStore = defineStore("connection", () => {
} catch {
// Backend pool is dead — remove from connectedIds and reconnect
connectedIds.value.delete(connectionId);
clearPrimaryVisibleObjectNames(connectionId);
clearConnectionHealthCheck(connectionId);
if (activeConnectionId.value === connectionId) activeConnectionId.value = null;
}
@@ -3028,23 +3066,33 @@ export const useConnectionStore = defineStore("connection", () => {
await ensureConnected(connectionId);
load = reclaimTreeNodeLoad(load, node);
}
if (useCachedChildren(node, options, load)) return;
const config = getConfig(connectionId);
if (useCachedChildren(node, options, load)) {
scheduleMissingPrimaryVisibleObjectNamesRefresh(connectionId, config, options);
return;
}
if (config?.db_type === "duckdb") {
const cacheKey = schemaCacheKey(connectionId, "duckdb-root");
if (!options?.force) {
const cached = await loadPersistedTreeChildren(node, cacheKey, load);
if (cached.hit) {
if (cached.isStale) refreshStaleTreeNode(node);
else scheduleMissingPrimaryVisibleObjectNamesRefresh(connectionId, config, options);
return;
}
}
const [databases, schemas] = await Promise.all([withMetadataLoadTimeout(connectionId, api.listDatabases(connectionId), "databases"), withMetadataLoadTimeout(connectionId, api.listSchemas(connectionId, "main"), "schemas")]);
const children = withSavedSqlRoot(connectionId, buildDuckDbConnectionTreeNodes(connectionId, databases, schemas), node);
const databaseNames = databases.map((database) => database.name);
const visibleNames = filterDatabaseNamesForConnection(databaseNames, config);
const visibleNameSet = new Set(visibleNames);
const visibleDatabases = databases.filter((database) => visibleNameSet.has(database.name));
const visibleSchemas = visibleNameSet.has("main") ? schemas : [];
const children = withSavedSqlRoot(connectionId, buildDuckDbConnectionTreeNodes(connectionId, visibleDatabases, visibleSchemas), node);
if (isSidebarSearchQueryChanged(options)) return;
const targetNode = treeNodeLoadTarget(load);
if (!targetNode) return;
recordPrimaryVisibleObjectNames(connectionId, databaseNames);
setChildren(targetNode, children);
await savePersistedConnectionTreeChildren(cacheKey, targetNode.children || children);
} else if (config && connectionUsesVisibleSchemaFilter(config)) {
@@ -3056,10 +3104,11 @@ export const useConnectionStore = defineStore("connection", () => {
const cached = await loadPersistedTreeChildren(node, cacheKey, load);
if (cached.hit) {
if (cached.isStale) refreshStaleTreeNode(node);
else scheduleMissingPrimaryVisibleObjectNamesRefresh(connectionId, config, options);
return;
}
}
const schemas = await withMetadataLoadTimeout(connectionId, api.listSchemas(connectionId, effectiveDb, true), "schemas");
const schemas = await withMetadataLoadTimeout(connectionId, api.listSchemas(connectionId, effectiveDb), "schemas");
const visibleSchemas = filterSchemaNamesForConnection(schemas, schemaFilterConfig, effectiveDb || "", { showSystemSchemas });
const schemaNodes: TreeNode[] = sortSidebarNames(visibleSchemas).map((s) => ({
id: `${connectionId}:${s}:${s}`,
@@ -3074,6 +3123,7 @@ export const useConnectionStore = defineStore("connection", () => {
if (isSidebarSearchQueryChanged(options)) return;
const targetNode = treeNodeLoadTarget(load);
if (!targetNode) return;
recordPrimaryVisibleObjectNames(connectionId, schemas);
setChildren(targetNode, withSavedSqlRoot(connectionId, schemaNodes, targetNode));
await savePersistedConnectionTreeChildren(cacheKey, targetNode.children || schemaNodes);
} else {
@@ -3120,6 +3170,7 @@ export const useConnectionStore = defineStore("connection", () => {
const cached = await loadPersistedTreeChildren(node, cacheKey, load);
if (cached.hit) {
if (cached.isStale) refreshStaleTreeNode(node);
else scheduleMissingPrimaryVisibleObjectNamesRefresh(connectionId, config, options);
return;
}
}
@@ -3157,6 +3208,10 @@ export const useConnectionStore = defineStore("connection", () => {
if (isSidebarSearchQueryChanged(options)) return;
const targetNode = treeNodeLoadTarget(load);
if (!targetNode) return;
recordPrimaryVisibleObjectNames(
connectionId,
databases.map((database) => database.name),
);
setChildren(targetNode, children);
await savePersistedConnectionTreeChildren(cacheKey, targetNode.children || children);
}
@@ -3212,6 +3267,10 @@ export const useConnectionStore = defineStore("connection", () => {
const visibleNameSet = new Set(visibleNames);
const targetNode = treeNodeLoadTarget(load);
if (!targetNode) return;
recordPrimaryVisibleObjectNames(
connectionId,
dbs.map((db) => String(db.db)),
);
setChildren(
targetNode,
withSavedSqlRoot(
@@ -3516,6 +3575,7 @@ export const useConnectionStore = defineStore("connection", () => {
const visibleDbs = filterDatabaseNamesForConnection(dbs, config);
const targetNode = treeNodeLoadTarget(load);
if (!targetNode) return;
recordPrimaryVisibleObjectNames(connectionId, dbs);
setChildren(
targetNode,
withSavedSqlRoot(
@@ -6903,6 +6963,8 @@ export const useConnectionStore = defineStore("connection", () => {
ensureVisibleDatabase,
setVisibleSchemas,
clearVisibleSchemas,
recordPrimaryVisibleObjectNames,
getSidebarVisibleFilterSummary,
removeConnection,
removeConnections,
editingConnectionId,