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。

fix(sidebar): preserve virtual table group ordering during refresh

t8y2b040600e47e3
diff --git a/apps/desktop/src/lib/app/pinnedItems.ts b/apps/desktop/src/lib/app/pinnedItems.ts
index 5627c40bcb..3533068479 100644
--- a/apps/desktop/src/lib/app/pinnedItems.ts
+++ b/apps/desktop/src/lib/app/pinnedItems.ts
@@ -258,13 +258,15 @@ function rememberNaturalTreeNodeOrder(nodes: readonly TreeNode[]): void {
export function orderPinnedTreeNodes(nodes: TreeNode[], pinnedOrder: readonly string[] = [], isFixedPriority: FixedTreeNodePriority = () => false): TreeNode[] {
rememberNaturalTreeNodeOrder(nodes);
+ const virtualGroups: TreeNode[] = [];
const fixed: TreeNode[] = [];
const pinned: TreeNode[] = [];
const unpinned: TreeNode[] = [];
const orderByKey = new Map(normalizePinnedTreeNodeOrder(pinnedOrder).map((key, index) => [key, index] as const));
for (const node of nodes) {
- if (isFixedPriority(node)) fixed.push(node);
+ if (node.type === "table-vgroup") virtualGroups.push(node);
+ else if (isFixedPriority(node)) fixed.push(node);
else if (node.pinned) pinned.push(node);
else unpinned.push(node);
}
@@ -280,7 +282,7 @@ export function orderPinnedTreeNodes(nodes: TreeNode[], pinnedOrder: readonly st
return naturalOrder(left, right);
});
unpinned.sort(naturalOrder);
- return [...fixed, ...pinned, ...unpinned];
+ return [...virtualGroups, ...fixed, ...pinned, ...unpinned];
}
function findTreeNodeLocation(nodes: TreeNode[], target: TreeNode, parent: TreeNode | null = null): { node: TreeNode; parent: TreeNode | null } | null {
@@ -300,6 +302,7 @@ export function updatePinnedTreeNodeInPlace(nodes: TreeNode[], target: TreeNode,
if (!location) return "missing";
location.node.pinned = pinned;
+ if (location.parent?.type === "table-vgroup") return "siblings";
const siblings = location.parent?.children ?? nodes;
const ordered = orderPinnedTreeNodes(siblings);
@@ -321,39 +324,34 @@ function clonePinnedTreeNode(node: TreeNode, pinnedIds: Set<string>, pinnedOrder
};
clones.set(node, clone);
inheritNaturalTreeNodeOrder(node, clone);
- if (node.children) clone.children = applyPinnedTreeNodeStateInternal(node.children, pinnedIds, pinnedOrder, isFixedPriority, clones);
- if (node.hiddenChildren) clone.hiddenChildren = applyPinnedTreeNodeStateInternal(node.hiddenChildren, pinnedIds, pinnedOrder, isFixedPriority, clones);
+ if (node.children) clone.children = applyPinnedTreeNodeStateInternal(node.children, pinnedIds, pinnedOrder, isFixedPriority, clones, node.type === "table-vgroup");
+ if (node.hiddenChildren) clone.hiddenChildren = applyPinnedTreeNodeStateInternal(node.hiddenChildren, pinnedIds, pinnedOrder, isFixedPriority, clones, node.type === "table-vgroup");
return clone;
}
-function applyPinnedTreeNodeStateInternal(nodes: TreeNode[], pinnedIds: Set<string>, pinnedOrder: readonly string[], isFixedPriority: FixedTreeNodePriority, clones: WeakMap<TreeNode, TreeNode>): TreeNode[] {
- rememberNaturalTreeNodeOrder(nodes);
- return orderPinnedTreeNodes(
- nodes.map((node) => clonePinnedTreeNode(node, pinnedIds, pinnedOrder, isFixedPriority, clones)),
- pinnedOrder,
- isFixedPriority,
- );
+function applyPinnedTreeNodeStateInternal(nodes: TreeNode[], pinnedIds: Set<string>, pinnedOrder: readonly string[], isFixedPriority: FixedTreeNodePriority, clones: WeakMap<TreeNode, TreeNode>, preserveLayoutOrder = false): TreeNode[] {
+ if (!preserveLayoutOrder) rememberNaturalTreeNodeOrder(nodes);
+ const clonedNodes = nodes.map((node) => clonePinnedTreeNode(node, pinnedIds, pinnedOrder, isFixedPriority, clones));
+ return preserveLayoutOrder ? clonedNodes : orderPinnedTreeNodes(clonedNodes, pinnedOrder, isFixedPriority);
}
export function applyPinnedTreeNodeState(nodes: TreeNode[], pinnedIds: Set<string>, pinnedOrder: readonly string[] = [...pinnedIds], isFixedPriority: FixedTreeNodePriority = () => false): TreeNode[] {
return applyPinnedTreeNodeStateInternal(nodes, pinnedIds, pinnedOrder, isFixedPriority, new WeakMap());
}
-function syncPinnedTreeNodeStateInPlaceInternal(nodes: TreeNode[], pinnedIds: Set<string>, pinnedOrder: readonly string[], isFixedPriority: FixedTreeNodePriority, visited: WeakSet<TreeNode>): void {
+function syncPinnedTreeNodeStateInPlaceInternal(nodes: TreeNode[], pinnedIds: Set<string>, pinnedOrder: readonly string[], isFixedPriority: FixedTreeNodePriority, visited: WeakSet<TreeNode>, preserveLayoutOrder = false): void {
for (const node of nodes) {
if (visited.has(node)) continue;
visited.add(node);
node.pinned = pinnedIds.has(treeNodePinKey(node)) || pinnedIds.has(node.id);
if (node.children) {
- syncPinnedTreeNodeStateInPlaceInternal(node.children, pinnedIds, pinnedOrder, isFixedPriority, visited);
- node.children = orderPinnedTreeNodes(node.children, pinnedOrder, isFixedPriority);
+ syncPinnedTreeNodeStateInPlaceInternal(node.children, pinnedIds, pinnedOrder, isFixedPriority, visited, node.type === "table-vgroup");
}
if (node.hiddenChildren) {
- syncPinnedTreeNodeStateInPlaceInternal(node.hiddenChildren, pinnedIds, pinnedOrder, isFixedPriority, visited);
- node.hiddenChildren = orderPinnedTreeNodes(node.hiddenChildren, pinnedOrder, isFixedPriority);
+ syncPinnedTreeNodeStateInPlaceInternal(node.hiddenChildren, pinnedIds, pinnedOrder, isFixedPriority, visited, node.type === "table-vgroup");
}
}
- nodes.splice(0, nodes.length, ...orderPinnedTreeNodes(nodes, pinnedOrder, isFixedPriority));
+ if (!preserveLayoutOrder) nodes.splice(0, nodes.length, ...orderPinnedTreeNodes(nodes, pinnedOrder, isFixedPriority));
}
export function syncPinnedTreeNodeStateInPlace(nodes: TreeNode[], pinnedIds: Set<string>, pinnedOrder: readonly string[] = [...pinnedIds], isFixedPriority: FixedTreeNodePriority = () => false): void {
diff --git a/apps/desktop/src/lib/table/__tests__/tableVGroup.spec.ts b/apps/desktop/src/lib/table/__tests__/tableVGroup.spec.ts
index 48c2f4b778..c194c3e1a2 100644
--- a/apps/desktop/src/lib/table/__tests__/tableVGroup.spec.ts
+++ b/apps/desktop/src/lib/table/__tests__/tableVGroup.spec.ts
@@ -1,4 +1,6 @@
import { describe, expect, it } from "vitest";
+import { reactive } from "vue";
+import { applyPinnedTreeNodeState, syncPinnedTreeNodeStateInPlace, treeNodePinKey, updatePinnedTreeNodeInPlace } from "@/lib/app/pinnedItems";
import type { TreeNode } from "@/types/database";
import {
applyTableVGroupsToChildren,
@@ -18,6 +20,7 @@ import {
tableVGroupPathForTable,
tableVGroupScopeKey,
toggleTableVGroupCollapsed,
+ type TableVGroupLayout,
} from "@/lib/table/tableVGroup";
const SCOPE = { connectionId: "conn-1", database: "db1" };
@@ -175,6 +178,110 @@ describe("applyTableVGroupsToChildren", () => {
});
});
+describe("table virtual groups with pinned tree ordering", () => {
+ function groupedTree() {
+ const tables = ["t_a", "t_b", "t_c", "t_d", "t_e", "t_f"].map(tableNode);
+ const loadMore = otherNode("load-more");
+ const container: TreeNode = { id: "database", label: "db1", type: "database", ...SCOPE, children: [...tables, loadMore] };
+ const tree = [container];
+ const pinOrder = [treeNodePinKey(tables[5]!), treeNodePinKey(tables[0]!)];
+ const pinnedIds = new Set(pinOrder);
+ const layout: TableVGroupLayout = {
+ version: 1,
+ groups: [
+ { id: "business", name: "Business", collapsed: false },
+ { id: "nested", name: "Nested", collapsed: true },
+ { id: "audit", name: "Audit", collapsed: false },
+ ],
+ order: [
+ {
+ type: "group",
+ id: "business",
+ children: [
+ { type: "table", name: "t_d" },
+ { type: "group", id: "nested", children: [{ type: "table", name: "t_b" }] },
+ { type: "table", name: "t_a" },
+ ],
+ },
+ { type: "group", id: "audit", children: [{ type: "table", name: "t_c" }] },
+ ],
+ };
+ syncPinnedTreeNodeStateInPlace(tree, pinnedIds, pinOrder);
+ container.children = applyTableVGroupsToChildren(container.children!, layout, SCOPE);
+ return { tree, container, tables, loadMore, layout, pinnedIds, pinOrder };
+ }
+
+ it.each(["in-place", "reactive", "clone"])("preserves root and nested layout order during repeated %s pin synchronization", (mode) => {
+ const fixture = groupedTree();
+ let tree = mode === "reactive" ? reactive(fixture.tree) : fixture.tree;
+ const snapshot = () => JSON.stringify(tree, ["id", "children", "isExpanded"]);
+ const expected = snapshot();
+ const savedLayout = JSON.stringify(fixture.layout);
+
+ for (let iteration = 0; iteration < 3; iteration++) {
+ if (mode === "clone") tree = applyPinnedTreeNodeState(tree, fixture.pinnedIds, fixture.pinOrder);
+ else syncPinnedTreeNodeStateInPlace(tree, fixture.pinnedIds, fixture.pinOrder);
+ expect(snapshot()).toBe(expected);
+ }
+
+ expect(tree[0]!.children?.map((node) => node.label)).toEqual(["Business", "Audit", "t_f", "t_e", "load-more"]);
+ expect(tree[0]!.children?.[0]?.children?.map((node) => node.label)).toEqual(["t_d", "Nested", "t_a"]);
+ expect(tree[0]!.children?.[0]?.children?.[2]?.pinned).toBe(true);
+ expect(JSON.stringify(fixture.layout)).toBe(savedLayout);
+ if (mode === "in-place") {
+ expect(tree[0]!.children?.[0]?.children?.[0]).toBe(fixture.tables[3]);
+ expect(tree[0]!.children?.at(-1)).toBe(fixture.loadMore);
+ }
+ });
+
+ it("keeps explicit group member order when a member is pinned or unpinned directly", () => {
+ const { tree, container, tables } = groupedTree();
+ const members = container.children![0]!.children!;
+ const expected = members.map((node) => node.id);
+
+ expect(updatePinnedTreeNodeInPlace(tree, tables[0]!, false)).toBe("siblings");
+ expect(container.children![0]!.children!.map((node) => node.id)).toEqual(expected);
+ expect(updatePinnedTreeNodeInPlace(tree, tables[0]!, true)).toBe("siblings");
+ expect(container.children![0]!.children!.map((node) => node.id)).toEqual(expected);
+ });
+
+ it("uses the latest group layout after drag reordering", () => {
+ const { tree, container, layout, pinnedIds, pinOrder } = groupedTree();
+ const reordered = reorderTableVGroupEntry(layout, "audit", "business", "before");
+ container.children = applyTableVGroupsToChildren(container.children!, reordered, SCOPE);
+
+ syncPinnedTreeNodeStateInPlace(tree, pinnedIds, pinOrder);
+
+ expect(groupIds(container.children!)).toEqual(["table-vgroup:audit", "table-vgroup:business"]);
+ });
+
+ it("restores ordinary pinned and natural ordering when groups are disabled", () => {
+ const { tree, container, tables, layout, pinnedIds, pinOrder } = groupedTree();
+ syncPinnedTreeNodeStateInPlace(tree, pinnedIds, pinOrder);
+ container.children = applyTableVGroupsToChildren(stripTableVGroupsFromChildren(container.children!), { ...layout, enabled: false }, SCOPE);
+
+ syncPinnedTreeNodeStateInPlace(tree, pinnedIds, pinOrder);
+ expect(container.children?.map((node) => node.label)).toEqual(["t_f", "t_a", "t_b", "t_c", "t_d", "t_e", "load-more"]);
+
+ syncPinnedTreeNodeStateInPlace(tree, new Set());
+ expect(container.children).toEqual([...tables, container.children!.at(-1)]);
+ });
+
+ it("still orders metadata below grouped tables by pin state", () => {
+ const { tree, tables, pinnedIds, pinOrder } = groupedTree();
+ const firstColumn: TreeNode = { id: "column-a", label: "a", type: "column", ...SCOPE };
+ const lastColumn: TreeNode = { id: "column-z", label: "z", type: "column", ...SCOPE };
+ tables[3]!.children = [firstColumn, lastColumn];
+ const columnKey = treeNodePinKey(lastColumn);
+
+ syncPinnedTreeNodeStateInPlace(tree, new Set([...pinnedIds, columnKey]), [...pinOrder, columnKey]);
+ expect(tables[3]!.children).toEqual([lastColumn, firstColumn]);
+
+ syncPinnedTreeNodeStateInPlace(tree, pinnedIds, pinOrder);
+ expect(tables[3]!.children).toEqual([firstColumn, lastColumn]);
+ });
+});
+
describe("resolveTableVGroupScopeFromNode", () => {
const databaseNode: TreeNode = { id: "conn-1:main", label: "main", type: "database", connectionId: "conn-1", database: "main" };
const tablesGroup: TreeNode = { id: "conn-1:main:__tables", label: "Tables", type: "group-tables", connectionId: "conn-1", database: "main", schema: "main", children: [] };
diff --git a/apps/desktop/src/stores/__tests__/connectionStore.tableVGroups.spec.ts b/apps/desktop/src/stores/__tests__/connectionStore.tableVGroups.spec.ts
new file mode 100644
index 0000000000..07d7eb0800
--- /dev/null
+++ b/apps/desktop/src/stores/__tests__/connectionStore.tableVGroups.spec.ts
@@ -0,0 +1,83 @@
+import { createPinia, setActivePinia } from "pinia";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { ConnectionConfig, TreeNode } from "@/types/database";
+
+describe("connectionStore table virtual groups during disk reload", () => {
+ beforeEach(() => {
+ vi.resetModules();
+ const storage = new Map<string, string>();
+ vi.stubGlobal("localStorage", {
+ getItem: vi.fn((key: string) => storage.get(key) ?? null),
+ setItem: vi.fn((key: string, value: string) => storage.set(key, value)),
+ removeItem: vi.fn((key: string) => storage.delete(key)),
+ });
+ vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+ vi.doMock("@/lib/backend/api", () => ({
+ loadConnections: vi.fn().mockResolvedValue([]),
+ loadEditorSettings: vi.fn().mockResolvedValue(null),
+ loadPinnedTreeNodeIds: vi.fn().mockResolvedValue([]),
+ loadSidebarLayout: vi.fn().mockResolvedValue(null),
+ loadTableVGroups: vi.fn().mockResolvedValue({}),
+ loadTunnelProfiles: vi.fn().mockResolvedValue([]),
+ saveConnections: vi.fn().mockResolvedValue(undefined),
+ saveEditorSettings: vi.fn().mockResolvedValue(undefined),
+ savePinnedTreeNodeIds: vi.fn().mockResolvedValue(undefined),
+ }));
+ setActivePinia(createPinia());
+ });
+
+ afterEach(() => {
+ vi.unstubAllGlobals();
+ vi.restoreAllMocks();
+ });
+
+ it.each(["simple", "grouped"])("preserves group layout through repeated disk reloads in %s display", async (display) => {
+ const api = await import("@/lib/backend/api");
+ const { applyTableVGroupsToChildren, tableVGroupScopeKey } = await import("@/lib/table/tableVGroup");
+ const { syncPinnedTreeNodeStateInPlace } = await import("@/lib/app/pinnedItems");
+ const { useConnectionStore } = await import("@/stores/connectionStore");
+ const config: ConnectionConfig = { id: "mysql-9665", name: "MySQL", db_type: "mysql", host: "127.0.0.1", port: 3306, username: "root", password: "", database: "app" };
+ const scope = { connectionId: config.id, database: "app" };
+ const layout = {
+ version: 1,
+ enabled: true,
+ groups: [{ id: "business", name: "Business", collapsed: false }],
+ order: [
+ {
+ type: "group" as const,
+ id: "business",
+ children: [
+ { type: "table" as const, name: "t_c" },
+ { type: "table" as const, name: "t_a" },
+ ],
+ },
+ ],
+ };
+ vi.mocked(api.loadConnections).mockResolvedValue([config]);
+ vi.mocked(api.loadTableVGroups).mockResolvedValue({ [tableVGroupScopeKey(scope)!]: layout });
+ const store = useConnectionStore();
+ await store.initFromDisk();
+
+ const tables: TreeNode[] = ["t_a", "t_b", "t_c"].map((name) => ({ id: `${config.id}:app:table:${name}`, label: name, type: "table", ...scope }));
+ const database: TreeNode = { id: `${config.id}:app`, label: "app", type: "database", ...scope, isExpanded: true, children: tables };
+ const container: TreeNode = display === "simple" ? database : { id: `${database.id}:__tables`, label: "Tables", type: "group-tables", ...scope, isExpanded: true, children: tables };
+ if (display === "grouped") database.children = [container];
+ store.treeNodes[0]!.isExpanded = true;
+ store.treeNodes[0]!.children!.push(database);
+ syncPinnedTreeNodeStateInPlace(store.treeNodes, new Set());
+ container.children = applyTableVGroupsToChildren(container.children!, layout, scope);
+
+ for (let reload = 0; reload < 3; reload++) {
+ await store.initFromDisk();
+
+ const currentDatabase = store.treeNodes[0]!.children!.find((node) => node.id === database.id)!;
+ const currentContainer = display === "simple" ? currentDatabase : currentDatabase.children![0]!;
+ expect(currentContainer.children?.map((node) => node.label)).toEqual(["Business", "t_b"]);
+ expect(currentContainer.children?.[0]?.children?.map((node) => node.label)).toEqual(["t_c", "t_a"]);
+ expect(currentContainer.children?.[0]?.isExpanded).toBe(true);
+ }
+
+ expect(api.loadConnections).toHaveBeenCalledTimes(4);
+ expect(store.tableVGroupLayoutFor(container)).toEqual(layout);
+ });
+});