From b040600e47e302b82d9b574145617532b3538999 Mon Sep 17 00:00:00 2001 From: t8y2 <1156263951@qq.com> Date: Sun, 20 Sep 2026 11:38:09 +0800 Subject: [PATCH] fix(sidebar): preserve virtual table group ordering during refresh Closes #9665 --- apps/desktop/src/lib/app/pinnedItems.ts | 32 +++--- .../lib/table/__tests__/tableVGroup.spec.ts | 107 ++++++++++++++++++ .../connectionStore.tableVGroups.spec.ts | 83 ++++++++++++++ 3 files changed, 205 insertions(+), 17 deletions(-) create mode 100644 apps/desktop/src/stores/__tests__/connectionStore.tableVGroups.spec.ts 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, 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, pinnedOrder: readonly string[], isFixedPriority: FixedTreeNodePriority, clones: WeakMap): TreeNode[] { - rememberNaturalTreeNodeOrder(nodes); - return orderPinnedTreeNodes( - nodes.map((node) => clonePinnedTreeNode(node, pinnedIds, pinnedOrder, isFixedPriority, clones)), - pinnedOrder, - isFixedPriority, - ); +function applyPinnedTreeNodeStateInternal(nodes: TreeNode[], pinnedIds: Set, pinnedOrder: readonly string[], isFixedPriority: FixedTreeNodePriority, clones: WeakMap, 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, pinnedOrder: readonly string[] = [...pinnedIds], isFixedPriority: FixedTreeNodePriority = () => false): TreeNode[] { return applyPinnedTreeNodeStateInternal(nodes, pinnedIds, pinnedOrder, isFixedPriority, new WeakMap()); } -function syncPinnedTreeNodeStateInPlaceInternal(nodes: TreeNode[], pinnedIds: Set, pinnedOrder: readonly string[], isFixedPriority: FixedTreeNodePriority, visited: WeakSet): void { +function syncPinnedTreeNodeStateInPlaceInternal(nodes: TreeNode[], pinnedIds: Set, pinnedOrder: readonly string[], isFixedPriority: FixedTreeNodePriority, visited: WeakSet, 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, 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(); + 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); + }); +});