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。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
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.tsindex 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 streturn 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.tsindex 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.tsnew file mode 100644index 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);+ });+});